From c1ba6fe4238c0bb9cac333ca959e25b3ac216cd8 Mon Sep 17 00:00:00 2001 From: Waggle Date: Sat, 3 Aug 2024 05:36:01 +0000 Subject: [PATCH] Huge changes Huge changes - Add Wii controllers for use with RVLoader, which are just extra GCN controllers that work as a Wii Remote - Add new spam bot RegEx - Add new aliases for some inputs - Add reference list for controllers - Add reference list for run IDs - Add feature to make overlay beep every 15 minutes like an old digital watch - Fix bug where channel name and channel ID was being incorrectly logged as ``{{channel_id}}`` in mode change logging and vote logging because of incorrect string replacement - Update global.json to reflect changes for the Kingdom Hearts Re-Revisit run (Run ID 10) - And probably other stuff that I'm forgetting to mention --- backend/backend.js | 124 +- backend/chat_config.json | 2 +- backend/controllers_reference_list.txt | 8 + backend/gcn_rvl_sideways.json | 954 + backend/gcn_rvl_sideways_controller.json | 25937 +++++++++++++++++++++ backend/global.json | 131 +- backend/overlay_576p.html | 2 +- backend/overlay_576p.js | 41 + backend/ps2.json | 4 +- backend/ps2_controller.json | 7 + backend/ps2_controller_digital.json | 7 + backend/ps2_digital.json | 4 +- backend/run_ids_reference_list.txt | 11 + backend/watch_beep_1.mp3 | Bin 0 -> 17280 bytes backend/watch_beep_1_long.mp3 | Bin 0 -> 42240 bytes backend/watch_beep_1_short.mp3 | Bin 0 -> 16320 bytes backend/watch_beep_2.mp3 | Bin 0 -> 19200 bytes backend/watch_beep_2_long.mp3 | Bin 0 -> 43200 bytes backend/watch_beep_2_short.mp3 | Bin 0 -> 17280 bytes 19 files changed, 27095 insertions(+), 137 deletions(-) create mode 100644 backend/controllers_reference_list.txt create mode 100644 backend/gcn_rvl_sideways.json create mode 100644 backend/gcn_rvl_sideways_controller.json create mode 100644 backend/run_ids_reference_list.txt create mode 100644 backend/watch_beep_1.mp3 create mode 100644 backend/watch_beep_1_long.mp3 create mode 100644 backend/watch_beep_1_short.mp3 create mode 100644 backend/watch_beep_2.mp3 create mode 100644 backend/watch_beep_2_long.mp3 create mode 100644 backend/watch_beep_2_short.mp3 diff --git a/backend/backend.js b/backend/backend.js index 8e833cb3..5a0a748d 100644 --- a/backend/backend.js +++ b/backend/backend.js @@ -3541,6 +3541,7 @@ function getTwitchUserFollowingChannelStatus(broadcasterId, userId, username, ch let userFollowTimeDelta = currentTime - userFollowedAtMillis; let userFollowTimeYears = (parseInt(userFollowTimeDelta / 31557600000)).toString(); // 31557600000 is 365.25 days in milliseconds let userFollowTimeDays = (parseInt(userFollowTimeDelta / 86400000) % 365.25).toString(); // One year has about 365.25 days + userFollowTimeDays = parseInt(userFollowTimeDays); let userFollowTimeHours = (parseInt(userFollowTimeDelta / 3600000) % 24).toString().padStart(2, "0"); let userFollowTimeMinutes = (parseInt(userFollowTimeDelta / 60000) % 60).toString().padStart(2, "0"); let userFollowTimeSeconds = (parseInt(userFollowTimeDelta / 1000) % 60).toString().padStart(2, "0"); @@ -4532,7 +4533,7 @@ async function onMessageHandler(target, tags, message, self) { /(d+o+)+\s+(y+o+\w*)+\s+(w+a+n+\w+)+\s*(t*o*)*\s*(b*e*c*o*m*e*)*\s+(p+o+p+u+l+a+r+\w*[^\s]*|f+a+m+o+u+s+\W*[^\s]*)+\s+((b+u+y+)+|(b+e+s+t+)+|(g+e+t+)+)+\s+((f+[o0]+l+[o0]+w+\w*)|((s*u*b*\s*\-*\s*)*p+r+i+m+e+\w*(\s*\-*\s*s*u*b*)*\w*(\s*\-*\s*s*u*b*)*)|(v+i+e+w+\w*))+\s+(a+n+d+)+\s+((f+[o0]+l+[o0]+w+\w*)|((s*u*b*\s*\-*\s*)*p+r+i+m+e+\w*(\s*\-*\s*s*u*b*)*\w*(\s*\-*\s*s*u*b*)*)|(v+i+e+w+\w*))+\s+(\w+)/ig.test(replaceCyrillicsWithLatin.normalize("NFD").replace(/[\u007E-\uFFFF]+/ig, "")), /(a+f+i+l+i+a+t+e+)+\s+(f+o+\w*)+\s+(f+r+e+)+/ig.test(replaceCyrillicsWithLatin.normalize("NFD").replace(/[\u007E-\uFFFF]+/ig, "")), /(s+u+\w+e+r+\w*)+\s+((f+[o0]+l+[o0]+w+\w*)|((s*u*b*\s*\-*\s*)*p+r+i+m+e+\w*(\s*\-*\s*s*u*b*)*\w*(\s*\-*\s*s*u*b*)*)|(v+i+e+w+\w*))+\s+(s+u+b+\w*)+\s*([^\s]*)/ig.test(replaceCyrillicsWithLatin.normalize("NFD").replace(/[\u007E-\uFFFF]+/ig, "")), - /(h+e+l+o+[^\s]*)+\s+(i+f+)+\s+(y+o+\w*)+\s+(n+e+d+)+\s+(r+e+a+l+)\s+(f+r+e+)+\s+(a+n+d+)+\s+(h+i+g+h+)+\s+(q+u+a+l+i+t+y+)+\s+(s+e+r+v+i+c+e+s*)+\s+(t+\w*)+\s+(i+n+c+r+e+a+s+e+)+\s+(y+o+\w*)+\s+((f+[o0]+l+[o0]+w+\w*)|((s*u*b*\s*\-*\s*)*p+r+i+m+e+\w*(\s*\-*\s*s*u*b*)*\w*(\s*\-*\s*s*u*b*)*)|(v+i+e+w+\w*))+/ig.test(replaceCyrillicsWithLatin.normalize("NFD").replace(/[\u007E-\uFFFF]+/ig, "")), + /(h+e+l+o+[^\s]*)+\s+(i+f+)+\s+(y+o+\w*)+\s+(n+e+d+)+\s+(r+e+a+l+)\s+(f+r+e+)+\s+(a+n+d+)+\s+(h+i+[gq]+h+)+\s+(q+u+a+l+i+t+y+)+\s+(s+e+r+v+i+c+e+s*)+\s+(t+\w*)+\s+(i+n+c+r+e+a+s+e+)+\s+(y+o+\w*)+\s+((f+[o0]+l+[o0]+w+\w*)|((s*u*b*\s*\-*\s*)*p+r+i+m+e+\w*(\s*\-*\s*s*u*b*)*\w*(\s*\-*\s*s*u*b*)*)|(v+i+e+w+\w*))+/ig.test(replaceCyrillicsWithLatin.normalize("NFD").replace(/[\u007E-\uFFFF]+/ig, "")), /((c+u+t+)+|(b+i+t+)+|(u+)+|(s+h+o*r+t+u*r+l+)+)+\s*(\.+|d+o+t+)*\s*((l+y+)+|(t+v+)+|(c+o+m*)+|(p+l+u+s*)+|(t+o+)+|(a+t+)+)+/ig.test(replaceCyrillicsWithLatin.normalize("NFD").replace(/[\u007E-\uFFFF]+/ig, "")), /(b+i+g+)+\s*(\.+|d+o+t+)*\s*((f+[o0]+l+[o0]+w+\w*)|((s*u*b*\s*\-*\s*)*p+r+i+m+e+\w*(\s*\-*\s*s*u*b*)*\w*(\s*\-*\s*s*u*b*)*)|(v+i+e+w+\w*))+/ig.test(replaceCyrillicsWithLatin.normalize("NFD").replace(/[\u007E-\uFFFF]+/ig, "")), /(c+h+i+l+p+|b+i+g+\s*((f+[o0]+l+[o0]+w+\w*)|((s*u*b*\s*\-*\s*)*p+r+i+m+e+\w*(\s*\-*\s*s*u*b*)*\w*(\s*\-*\s*s*u*b*)*)|(v+i+e+w+\w*))+)+\s*(\.+|d+o+t+)*\s*(c+o+m*|i+t+)+/ig.test(replaceCyrillicsWithLatin.normalize("NFD").replace(/[\u007E-\uFFFF]+/ig, "")), @@ -4603,6 +4604,7 @@ async function onMessageHandler(target, tags, message, self) { /((\.+|d+o+t+)+\s*(s+t+o+r+e+)+)+/ig.test(replaceCyrillicsWithLatin.normalize("NFD").replace(/[\u007E-\uFFFF]+/ig, "")), /((((v+i+e+w+\w*)+|(f+[o0]+l+[o0]+w+\w*)+|(s+u+b+\w*)+)+((a+n+d+)*|(\,+)*)*\s*((v+i+e+w+\w*)+|(f+[o0]+l+[o0]+w+\w*)+|(s+u+b+\w*)+)+\s*((a+n+d+)*|(\,+)*)*\s*((v+i+e+w+\w*)+|(f+[o0]+l+[o0]+w+\w*)+|(s+u+b+\w*)+)+)+)+/ig.test(replaceCyrillicsWithLatin.normalize("NFD").replace(/[\u007E-\uFFFF]+/ig, "")), // the combination of the words "view(ers)", "follow(ers)" and "view(ers)" in any order (but slightly different) /((t+)+\s*(\.+|d+o+t+)+\s*(c+o+m*)+)+/ig.test(replaceCyrillicsWithLatin.normalize("NFD").replace(/[\u007E-\uFFFF]+/ig, "")), // t.co links? bruh if you post that of course you are getting banned, you can never tell what a t.co link is + /((v+a+l+[\s\-\_]*k+[\s\-\_]*[\w\,]*[\s\-\_]*b+e+a+c+[ht]+)+\s*(\.+|d+o+t+)*\s*(c+o+m*)*)+/ig.test(replaceCyrillicsWithLatin.normalize("NFD").replace(/[\u007E-\uFFFF]+/ig, "")), // valkonbeact.com code: 9cp03 (idk what this link is, it's probably another csgo scam or something) /((a+l+)+\s*(f+o+\w*)+\s*(y+\w*)\s*((s+t+r+m+)+|(s+t+r+e+a+m+)+|(s+t+r+a+e+m+)+|(s+t+r+e+m+)+|(s+t+r+a+m+)+)+)+/ig.test(replaceCyrillicsWithLatin.normalize("NFD").replace(/[\u007E-\uFFFF]+/ig, "")), /(((u+p+(\s*g*r*a*d*e*)*)+|(u+p+(\s*d*a*t*e*)*)+)+\s*(y+\w*)\s*((s+t+r+m+)+|(s+t+r+e+a+m+)+|(s+t+r+a+e+m+)+|(s+t+r+e+m+)+|(s+t+r+a+m+)+|(c+h+a+n+e+l+)+)+)+/ig.test(replaceCyrillicsWithLatin.normalize("NFD").replace(/[\u007E-\uFFFF]+/ig, "")), /(p+r+o+m+o+((t*i*n*g*)*|(t*e*)*)*)\s+(t+w+[li1\!\|]+t+c+h+s*)+\s+(c+h+a+n+e+l+s*)+/ig.test(replaceCyrillicsWithLatin.normalize("NFD").replace(/[\u007E-\uFFFF]+/ig, "")), // <3 The best service in promoting Twitch channels - STREAMSKILL. pro\en ! Get a Free test of 20 viewers for 1 hour only with us! <3 (PART 1) @@ -4614,7 +4616,10 @@ async function onMessageHandler(target, tags, message, self) { /(\d*)*\s*(h+o+u+r)+((\s+(o+n+l+y+)+)*\s+(w+i+t+h*)+\s+(u+s+)+)+/ig.test(replaceCyrillicsWithLatin.normalize("NFD").replace(/[\u007E-\uFFFF]+/ig, "")), // <3 The best service in promoting Twitch channels - STREAMSKILL. pro\en ! Get a Free test of 20 viewers for 1 hour only with us! <3 (PART 5) /(h+i+)*\s*(((I+)+\s+(a+m+)+)+|((I+'+m+)+)+)+\s+(a)+\s+(s+m+[aeiouy]+l+)+\s+(s+t+r+e*a*m+i*n*g*e*r*)+(\s+(b+y+)+\s+(t+h+e+)+)*\s+(n+a+m+e*d*)+\s+([\w\-\_]+)+\s+(g+i+v+e+)+(\s+(m+e+)+)*\s+(a+)+\s+(f+o+l+o+w+)+/ig.test(replaceCyrillicsWithLatin.normalize("NFD").replace(/[\u007E-\uFFFF]+/ig, "")), // Hi I am a small streamer by the name XsaveXgoodX give me a follow I'm live rn I'm 19 and playing black ops 3 it would be much appreciated (Is this even a spam bot? I'm not sure) /(((c+h*e+[ck]+)+)+(\s+((m+y+)+)+)*\s+((l+i+v+e+)+)+\s+((g+i+v+e+\s*a*w+a+y+)+)+\s+((t+w+[li1\!\|]+t+c+h+s*)+)+\s*((f+o+l+o+w+\w*)+)+)+/ig.test(replaceCyrillicsWithLatin.normalize("NFD").replace(/[\u007E-\uFFFF]+/ig, "")), // Ceck my live giveaway twitch followers - /((b+e+s+t+)+|(b+u+y+)+)+\s+(v+i+e+w+\w*)+\s+(\w+)+\s+(f+o+l+o+w+\w*)+/ig.test(replaceCyrillicsWithLatin.normalize("NFD").replace(/[\u007E-\uFFFF]+/ig, "")) // Best Viewers and Followers on StreamBoo .com ( u.to/yp_QIA ) + /((b+e+s+t+)+|(b+u+y+)+|(c+h+e+a+p)+)+\s+((v+i+e+w+\w*)+|(f+o+l+o+w+\w*)+)+\s*([\w\,]*)*\s*((v+i+e+w+\w*)+|(f+o+l+o+w+\w*)+)+/ig.test(replaceCyrillicsWithLatin.normalize("NFD").replace(/[\u007E-\uFFFF]+/ig, "")), // Best Viewers and Followers on StreamBoo .com ( u.to/yp_QIA ) + /((b+e+s+t+)+|(b+u+y+)+|(c+h+e+a+p)+)+\s+((v+i+e+w+\w*)+|(f+o+l+o+w+\w*)+)+\s*([\w\,]*)*/ig.test(replaceCyrillicsWithLatin.normalize("NFD").replace(/[\u007E-\uFFFF]+/ig, "")), // [Wed 2024-05-29T15:16:56Z] Best viewers on cutt.ly/Pey3i71C + /((h+i+[gq]+h+)+\s+(q+u+a+l+i+t+y+)\s*([\w\,]*)*\s*)*((b+e+s+t+)+|(b+u+y+)+|(c+h+e+a+p)+)+\s+((v+i+e+w+\w*)+|(f+o+l+o+w+\w*)+)+\s*([\w\,]*)*\s*((v+i+e+w+\w*)+|(f+o+l+o+w+\w*)+)+/ig.test(replaceCyrillicsWithLatin.normalize("NFD").replace(/[\u007E-\uFFFF]+/ig, "")), // [Mon 2024-06-10T19:14:03Z] Hiqh quality and Cheap Viewers on u.to/vRi7IA + /((h+i+[gq]+h+)+\s+(q+u+a+l+i+t+y+)\s*([\w\,]*)*\s*)*((b+e+s+t+)+|(b+u+y+)+|(c+h+e+a+p)+)+\s+((v+i+e+w+\w*)+|(f+o+l+o+w+\w*)+)+\s*([\w\,]*)*/ig.test(replaceCyrillicsWithLatin.normalize("NFD").replace(/[\u007E-\uFFFF]+/ig, "")) // [Mon 2024-06-10T19:14:03Z] Hiqh quality and Cheap Viewers on u.to/vRi7IA ]; let multiMessageSpamBotTypeA = [/((i+t+)+\s*(i+s+)|(i+t+\W*s+))+\s+(n+i+c+e+)+\s+(t+o+)+\s+(m+e+t+)+\s+(y+\w*)+\s+(\w+\W*v+e+)+\s+(w+a+t+c+h+e+d+)+\s+(y+\w*)+\s+([^\s]*)+\s+(t+w+\w*t+c+h+)\s+(c+h+a+n+e+l+\w*\W*)+/ig.test(replaceCyrillicsWithLatin.normalize("NFD").replace(/[\u007E-\uFFFF]+/ig, "")), /(y+\w*)+\s+(s+i+r+\W*)+\s+(h+a+v+e+)+\s+(f+l+o+w+\W*)+\s+(i+t+\W*s+)+\s+(a+w+e+s+\w+m+e\W*)+\s+(\w+)+\s+(l+i+k+e+)+\s+(y+\w*)+\s+(s+t+r+e+a+m+\w*\W*\w*)+/ig.test(replaceCyrillicsWithLatin.normalize("NFD").replace(/[\u007E-\uFFFF]+/ig, "")), @@ -4823,7 +4828,7 @@ async function onMessageHandler(target, tags, message, self) { if (globalConfig.send_introductory_messages_to_new_users_using_twitch_tags == true) { if (isFirstTwitchMessage == true) { if (isSingleMessageSpamBot == true) { - console.log("BAN THAT MOTHERFUCKER"); + console.log("BAN THAT MOTHERFUCKER A"); //updateTwitchUserRandomChatColor(twitchCredentials, twitchJsonEncodedBotAppAccessToken); banTwitchUser(roomId, userId, null, "You were banned because you got detected as spam bot.", twitchCredentials, twitchJsonEncodedBotAppAccessToken); if (globalConfig.send_messages_to_moderated_user == true) { @@ -4930,7 +4935,7 @@ async function onMessageHandler(target, tags, message, self) { if (isFirstTwitchMessage == false) { if (isSingleMessageSpamBot == true) { /* - console.log("BAN THAT MOTHERFUCKER"); + console.log("BAN THAT MOTHERFUCKER B"); //updateTwitchUserRandomChatColor(twitchCredentials, twitchJsonEncodedBotAppAccessToken); banTwitchUser(roomId, userId, null, "You were banned because you got detected as spam bot.", twitchCredentials, twitchJsonEncodedBotAppAccessToken); if (globalConfig.send_messages_to_moderated_user == true) { @@ -5040,7 +5045,7 @@ async function onMessageHandler(target, tags, message, self) { if (isReturningChatter == true) { if (isSingleMessageSpamBot == true) { /* - console.log("BAN THAT MOTHERFUCKER"); + console.log("BAN THAT MOTHERFUCKER C"); //updateTwitchUserRandomChatColor(twitchCredentials, twitchJsonEncodedBotAppAccessToken); banTwitchUser(roomId, userId, null, "You were banned because you got detected as spam bot.", twitchCredentials, twitchJsonEncodedBotAppAccessToken); if (globalConfig.send_messages_to_moderated_user == true) { @@ -5148,7 +5153,7 @@ async function onMessageHandler(target, tags, message, self) { if (isReturningChatter == false) { if (isSingleMessageSpamBot == true) { /* - console.log("BAN THAT MOTHERFUCKER"); + console.log("BAN THAT MOTHERFUCKER D"); //updateTwitchUserRandomChatColor(twitchCredentials, twitchJsonEncodedBotAppAccessToken); banTwitchUser(roomId, userId, null, "You were banned because you got detected as spam bot.", twitchCredentials, twitchJsonEncodedBotAppAccessToken); if (globalConfig.send_messages_to_moderated_user == true) { @@ -6040,7 +6045,7 @@ async function onMessageHandler(target, tags, message, self) { if (databaseToReadFromResult.is_account_blacklisted == true) { if (databaseToReadFromResult.is_banned == false) { if (globalConfig.enable_silent_timeout == true) { - //console.log("Silently timeout or delete message"); + console.log("Silently timeout or delete message A"); deleteTwitchMessage(roomId, databaseToReadFromResult.last_message_sent_id, twitchCredentials, twitchJsonEncodedBotAppAccessToken); logModbotActionToDatabase(databaseToReadFromResult, roomId, originalMessage, "message_deleted", null, null, null, new Date().toISOString() + " [MODBOT] user_id=" + databaseToReadFromResult.user_id + ", last_username_to_ping=" + databaseToReadFromResult.last_username_to_ping + ", last_message_sent_id=" + databaseToReadFromResult.last_message_sent_id + ", last_message_sent=" + databaseToReadFromResult.last_message_sent + ", last_message_sent_at=" + databaseToReadFromResult.last_message_sent_at_iso_timestamp + ", last_message_length=" + databaseToReadFromResult.last_message_length + ", is_first_twitch_message=" + databaseToReadFromResult.is_first_twitch_message + ", is_returning_chatter=" + databaseToReadFromResult.is_returning_chatter + ", is_account_blacklisted=" + databaseToReadFromResult.is_account_blacklisted + ", is_banned=" + databaseToReadFromResult.is_banned + ", is_first_message_spam_bot=" + databaseToReadFromResult.is_first_message_spam_bot + ", is_spam_bot=" + databaseToReadFromResult.is_spam_bot + ", roomId=" + roomId + ", target=" + target + " Message deleted silently.", new Date().getTime()); logModbotActionToTextFile(databaseToReadFromResult, roomId, originalMessage, "message_deleted", null, null, null, new Date().toISOString() + " [MODBOT] user_id=" + databaseToReadFromResult.user_id + ", last_username_to_ping=" + databaseToReadFromResult.last_username_to_ping + ", last_message_sent_id=" + databaseToReadFromResult.last_message_sent_id + ", last_message_sent=" + databaseToReadFromResult.last_message_sent + ", last_message_sent_at=" + databaseToReadFromResult.last_message_sent_at_iso_timestamp + ", last_message_length=" + databaseToReadFromResult.last_message_length + ", is_first_twitch_message=" + databaseToReadFromResult.is_first_twitch_message + ", is_returning_chatter=" + databaseToReadFromResult.is_returning_chatter + ", is_account_blacklisted=" + databaseToReadFromResult.is_account_blacklisted + ", is_banned=" + databaseToReadFromResult.is_banned + ", is_first_message_spam_bot=" + databaseToReadFromResult.is_first_message_spam_bot + ", is_spam_bot=" + databaseToReadFromResult.is_spam_bot + ", roomId=" + roomId + ", target=" + target + " Message deleted silently.", new Date().getTime()); @@ -6108,7 +6113,7 @@ async function onMessageHandler(target, tags, message, self) { } } if (databaseToReadFromResult.is_spam_bot == true) { - console.log("BAN THAT MOTHERFUCKER"); + console.log("BAN THAT MOTHERFUCKER E"); //updateTwitchUserRandomChatColor(twitchCredentials, twitchJsonEncodedBotAppAccessToken); banTwitchUser(roomId, databaseToReadFromResult.user_id, null, "You were banned because you got detected as spam bot.", twitchCredentials, twitchJsonEncodedBotAppAccessToken); logModbotActionToDatabase(databaseToReadFromResult, roomId, originalMessage, "ban", null, "You were banned because you got detected as spam bot.", "You sent: " + originalMessage, new Date().toISOString() + " [MODBOT] user_id=" + databaseToReadFromResult.user_id + ", last_username_to_ping=" + databaseToReadFromResult.last_username_to_ping + ", last_message_sent_id=" + databaseToReadFromResult.last_message_sent_id + ", last_message_sent=" + databaseToReadFromResult.last_message_sent + ", last_message_sent_at=" + databaseToReadFromResult.last_message_sent_at_iso_timestamp + ", last_message_length=" + databaseToReadFromResult.last_message_length + ", is_first_twitch_message=" + databaseToReadFromResult.is_first_twitch_message + ", is_returning_chatter=" + databaseToReadFromResult.is_returning_chatter + ", is_account_blacklisted=" + databaseToReadFromResult.is_account_blacklisted + ", is_banned=" + databaseToReadFromResult.is_banned + ", is_first_message_spam_bot=" + databaseToReadFromResult.is_first_message_spam_bot + ", is_spam_bot=" + databaseToReadFromResult.is_spam_bot + ", roomId=" + roomId + ", target=" + target + " Banned, detected as spam bot.", new Date().getTime()); @@ -6938,7 +6943,7 @@ async function onMessageHandler(target, tags, message, self) { if (databaseToReadFromResult.is_account_blacklisted == true) { if (databaseToReadFromResult.is_banned == false) { if (globalConfig.enable_silent_timeout == true) { - //console.log("Silently timeout or delete message"); + console.log("Silently timeout or delete message B"); deleteTwitchMessage(roomId, databaseToReadFromResult.last_message_sent_id, twitchCredentials, twitchJsonEncodedBotAppAccessToken); logModbotActionToDatabase(databaseToReadFromResult, roomId, originalMessage, "message_deleted", null, null, null, new Date().toISOString() + " [MODBOT] user_id=" + databaseToReadFromResult.user_id + ", last_username_to_ping=" + databaseToReadFromResult.last_username_to_ping + ", last_message_sent_id=" + databaseToReadFromResult.last_message_sent_id + ", last_message_sent=" + databaseToReadFromResult.last_message_sent + ", last_message_sent_at=" + databaseToReadFromResult.last_message_sent_at_iso_timestamp + ", last_message_length=" + databaseToReadFromResult.last_message_length + ", is_first_twitch_message=" + databaseToReadFromResult.is_first_twitch_message + ", is_returning_chatter=" + databaseToReadFromResult.is_returning_chatter + ", is_account_blacklisted=" + databaseToReadFromResult.is_account_blacklisted + ", is_banned=" + databaseToReadFromResult.is_banned + ", is_first_message_spam_bot=" + databaseToReadFromResult.is_first_message_spam_bot + ", is_spam_bot=" + databaseToReadFromResult.is_spam_bot + ", roomId=" + roomId + ", target=" + target + " Message deleted silently.", new Date().getTime()); logModbotActionToTextFile(databaseToReadFromResult, roomId, originalMessage, "message_deleted", null, null, null, new Date().toISOString() + " [MODBOT] user_id=" + databaseToReadFromResult.user_id + ", last_username_to_ping=" + databaseToReadFromResult.last_username_to_ping + ", last_message_sent_id=" + databaseToReadFromResult.last_message_sent_id + ", last_message_sent=" + databaseToReadFromResult.last_message_sent + ", last_message_sent_at=" + databaseToReadFromResult.last_message_sent_at_iso_timestamp + ", last_message_length=" + databaseToReadFromResult.last_message_length + ", is_first_twitch_message=" + databaseToReadFromResult.is_first_twitch_message + ", is_returning_chatter=" + databaseToReadFromResult.is_returning_chatter + ", is_account_blacklisted=" + databaseToReadFromResult.is_account_blacklisted + ", is_banned=" + databaseToReadFromResult.is_banned + ", is_first_message_spam_bot=" + databaseToReadFromResult.is_first_message_spam_bot + ", is_spam_bot=" + databaseToReadFromResult.is_spam_bot + ", roomId=" + roomId + ", target=" + target + " Message deleted silently.", new Date().getTime()); @@ -7055,21 +7060,23 @@ async function onMessageHandler(target, tags, message, self) { } } if (databaseToReadFromResult.is_spam_bot == true) { - // this should never happen tho lol - console.log("BAN THAT MOTHERFUCKER AGAIN"); - //updateTwitchUserRandomChatColor(twitchCredentials, twitchJsonEncodedBotAppAccessToken); - banTwitchUser(roomId, databaseToReadFromResult.user_id, null, "You were banned because you got detected as spam bot.", twitchCredentials, twitchJsonEncodedBotAppAccessToken); - logModbotActionToDatabase(databaseToReadFromResult, roomId, originalMessage, "ban", null, "You were banned because you got detected as spam bot.", "You sent: " + originalMessage, new Date().toISOString() + " [MODBOT] user_id=" + databaseToReadFromResult.user_id + ", last_username_to_ping=" + databaseToReadFromResult.last_username_to_ping + ", last_message_sent_id=" + databaseToReadFromResult.last_message_sent_id + ", last_message_sent=" + databaseToReadFromResult.last_message_sent + ", last_message_sent_at=" + databaseToReadFromResult.last_message_sent_at_iso_timestamp + ", last_message_length=" + databaseToReadFromResult.last_message_length + ", is_first_twitch_message=" + databaseToReadFromResult.is_first_twitch_message + ", is_returning_chatter=" + databaseToReadFromResult.is_returning_chatter + ", is_account_blacklisted=" + databaseToReadFromResult.is_account_blacklisted + ", is_banned=" + databaseToReadFromResult.is_banned + ", is_first_message_spam_bot=" + databaseToReadFromResult.is_first_message_spam_bot + ", is_spam_bot=" + databaseToReadFromResult.is_spam_bot + ", roomId=" + roomId + ", target=" + target + " Banned, detected as spam bot.", new Date().getTime()); - logModbotActionToTextFile(databaseToReadFromResult, roomId, originalMessage, "ban", null, "You were banned because you got detected as spam bot.", "You sent: " + originalMessage, new Date().toISOString() + " [MODBOT] user_id=" + databaseToReadFromResult.user_id + ", last_username_to_ping=" + databaseToReadFromResult.last_username_to_ping + ", last_message_sent_id=" + databaseToReadFromResult.last_message_sent_id + ", last_message_sent=" + databaseToReadFromResult.last_message_sent + ", last_message_sent_at=" + databaseToReadFromResult.last_message_sent_at_iso_timestamp + ", last_message_length=" + databaseToReadFromResult.last_message_length + ", is_first_twitch_message=" + databaseToReadFromResult.is_first_twitch_message + ", is_returning_chatter=" + databaseToReadFromResult.is_returning_chatter + ", is_account_blacklisted=" + databaseToReadFromResult.is_account_blacklisted + ", is_banned=" + databaseToReadFromResult.is_banned + ", is_first_message_spam_bot=" + databaseToReadFromResult.is_first_message_spam_bot + ", is_spam_bot=" + databaseToReadFromResult.is_spam_bot + ", roomId=" + roomId + ", target=" + target + " Banned, detected as spam bot.", new Date().getTime()); - if (globalConfig.send_messages_to_moderated_user == true) { - client.reply(target, "@" + databaseToReadFromResult.last_username_to_ping + " You were banned because you got detected as spam bot.", databaseToReadFromResult.last_message_sent_id); - } - if (globalConfig.send_whispers_to_moderated_user == true) { - sendTwitchWhisper(databaseToReadFromResult.user_id, "You were banned because you got detected as spam bot. This whisper was sent from the channel " + target.replace(/\#+/ig, "") + ". It is possible your account may have been compromised and is being used to send malicious links to multiple streams.", twitchCredentials, twitchJsonEncodedBotAppAccessToken); - sendTwitchWhisper(databaseToReadFromResult.user_id, "You sent: " + originalMessage, twitchCredentials, twitchJsonEncodedBotAppAccessToken); - } - if (chatConfig.send_debug_channel_messages == true) { - client.action(chatConfig.debug_channel, new Date().toISOString() + " [MODBOT] user_id=" + databaseToReadFromResult.user_id + ", last_username_to_ping=" + databaseToReadFromResult.last_username_to_ping + ", last_message_sent_id=" + databaseToReadFromResult.last_message_sent_id + ", last_message_sent=" + databaseToReadFromResult.last_message_sent + ", last_message_sent_at=" + databaseToReadFromResult.last_message_sent_at_iso_timestamp + ", last_message_length=" + databaseToReadFromResult.last_message_length + ", is_first_twitch_message=" + databaseToReadFromResult.is_first_twitch_message + ", is_returning_chatter=" + databaseToReadFromResult.is_returning_chatter + ", is_account_blacklisted=" + databaseToReadFromResult.is_account_blacklisted + ", is_banned=" + databaseToReadFromResult.is_banned + ", is_first_message_spam_bot=" + databaseToReadFromResult.is_first_message_spam_bot + ", is_spam_bot=" + databaseToReadFromResult.is_spam_bot + ", roomId=" + roomId + ", target=" + target + " Banned, detected as spam bot."); + if (globalConfig.ban_user_again_if_user_is_still_marked_as_spambot == true) { + // this should never happen tho lol + console.log("BAN THAT MOTHERFUCKER AGAIN"); + //updateTwitchUserRandomChatColor(twitchCredentials, twitchJsonEncodedBotAppAccessToken); + banTwitchUser(roomId, databaseToReadFromResult.user_id, null, "You were banned because you got detected as spam bot.", twitchCredentials, twitchJsonEncodedBotAppAccessToken); + logModbotActionToDatabase(databaseToReadFromResult, roomId, originalMessage, "ban", null, "You were banned because you got detected as spam bot.", "You sent: " + originalMessage, new Date().toISOString() + " [MODBOT] user_id=" + databaseToReadFromResult.user_id + ", last_username_to_ping=" + databaseToReadFromResult.last_username_to_ping + ", last_message_sent_id=" + databaseToReadFromResult.last_message_sent_id + ", last_message_sent=" + databaseToReadFromResult.last_message_sent + ", last_message_sent_at=" + databaseToReadFromResult.last_message_sent_at_iso_timestamp + ", last_message_length=" + databaseToReadFromResult.last_message_length + ", is_first_twitch_message=" + databaseToReadFromResult.is_first_twitch_message + ", is_returning_chatter=" + databaseToReadFromResult.is_returning_chatter + ", is_account_blacklisted=" + databaseToReadFromResult.is_account_blacklisted + ", is_banned=" + databaseToReadFromResult.is_banned + ", is_first_message_spam_bot=" + databaseToReadFromResult.is_first_message_spam_bot + ", is_spam_bot=" + databaseToReadFromResult.is_spam_bot + ", roomId=" + roomId + ", target=" + target + " Banned, detected as spam bot.", new Date().getTime()); + logModbotActionToTextFile(databaseToReadFromResult, roomId, originalMessage, "ban", null, "You were banned because you got detected as spam bot.", "You sent: " + originalMessage, new Date().toISOString() + " [MODBOT] user_id=" + databaseToReadFromResult.user_id + ", last_username_to_ping=" + databaseToReadFromResult.last_username_to_ping + ", last_message_sent_id=" + databaseToReadFromResult.last_message_sent_id + ", last_message_sent=" + databaseToReadFromResult.last_message_sent + ", last_message_sent_at=" + databaseToReadFromResult.last_message_sent_at_iso_timestamp + ", last_message_length=" + databaseToReadFromResult.last_message_length + ", is_first_twitch_message=" + databaseToReadFromResult.is_first_twitch_message + ", is_returning_chatter=" + databaseToReadFromResult.is_returning_chatter + ", is_account_blacklisted=" + databaseToReadFromResult.is_account_blacklisted + ", is_banned=" + databaseToReadFromResult.is_banned + ", is_first_message_spam_bot=" + databaseToReadFromResult.is_first_message_spam_bot + ", is_spam_bot=" + databaseToReadFromResult.is_spam_bot + ", roomId=" + roomId + ", target=" + target + " Banned, detected as spam bot.", new Date().getTime()); + if (globalConfig.send_messages_to_moderated_user == true) { + client.reply(target, "@" + databaseToReadFromResult.last_username_to_ping + " You were banned because you got detected as spam bot.", databaseToReadFromResult.last_message_sent_id); + } + if (globalConfig.send_whispers_to_moderated_user == true) { + sendTwitchWhisper(databaseToReadFromResult.user_id, "You were banned because you got detected as spam bot. This whisper was sent from the channel " + target.replace(/\#+/ig, "") + ". It is possible your account may have been compromised and is being used to send malicious links to multiple streams.", twitchCredentials, twitchJsonEncodedBotAppAccessToken); + sendTwitchWhisper(databaseToReadFromResult.user_id, "You sent: " + originalMessage, twitchCredentials, twitchJsonEncodedBotAppAccessToken); + } + if (chatConfig.send_debug_channel_messages == true) { + client.action(chatConfig.debug_channel, new Date().toISOString() + " [MODBOT] user_id=" + databaseToReadFromResult.user_id + ", last_username_to_ping=" + databaseToReadFromResult.last_username_to_ping + ", last_message_sent_id=" + databaseToReadFromResult.last_message_sent_id + ", last_message_sent=" + databaseToReadFromResult.last_message_sent + ", last_message_sent_at=" + databaseToReadFromResult.last_message_sent_at_iso_timestamp + ", last_message_length=" + databaseToReadFromResult.last_message_length + ", is_first_twitch_message=" + databaseToReadFromResult.is_first_twitch_message + ", is_returning_chatter=" + databaseToReadFromResult.is_returning_chatter + ", is_account_blacklisted=" + databaseToReadFromResult.is_account_blacklisted + ", is_banned=" + databaseToReadFromResult.is_banned + ", is_first_message_spam_bot=" + databaseToReadFromResult.is_first_message_spam_bot + ", is_spam_bot=" + databaseToReadFromResult.is_spam_bot + ", roomId=" + roomId + ", target=" + target + " Banned, detected as spam bot."); + } } } if (databaseToReadFromResult.is_first_message_spam_bot == true) { @@ -20232,28 +20239,34 @@ async function stopAllInputs() { async function stopAllInputsAndQuit() { console.log(new Date().toISOString() + " TWITCH PLAYS BACKEND STARTING TO EXIT PROCESS"); + /* if (client.readyState() === "OPEN") { if (chatConfig.send_debug_channel_messages == true) { updateTwitchUserRandomChatColor(twitchCredentials, twitchJsonEncodedBotAppAccessToken); client.action(chatConfig.debug_channel, new Date().toISOString() + " TWITCH PLAYS BACKEND STARTING TO EXIT PROCESS"); } } + */ await stopAllInputs(); console.log(new Date().toISOString() + " TWITCH PLAYS BACKEND SLEEPING"); + /* if (client.readyState() === "OPEN") { if (chatConfig.send_debug_channel_messages == true) { updateTwitchUserRandomChatColor(twitchCredentials, twitchJsonEncodedBotAppAccessToken); client.action(chatConfig.debug_channel, new Date().toISOString() + " TWITCH PLAYS BACKEND SLEEPING"); } } + */ await sleep(500); // Sleeping to make sure all async processes actually have enough time to end (serial port related stuff as well as twitch chat are async) console.log(new Date().toISOString() + " TWITCH PLAYS BACKEND DONE SLEEPING, EXITING PROCESS"); + /* if (client.readyState() === "OPEN") { if (chatConfig.send_debug_channel_messages == true) { updateTwitchUserRandomChatColor(twitchCredentials, twitchJsonEncodedBotAppAccessToken); client.action(chatConfig.debug_channel, new Date().toISOString() + " TWITCH PLAYS BACKEND DONE SLEEPING, EXITING PROCESS"); } } + */ process.exit(0); // 0 will let Node.js know to terminate the process when no async operations are performing. Without mentioning, it will take the default value of 0. } @@ -21680,6 +21693,17 @@ function logModeVotesToDatabase(modeVoteDataObject, modeVotesObjectArray, newMod if (globalConfig.log_mode_votes_to_database == false) { return; } + for (let modeVotesObjectArrayIndex = 0; modeVotesObjectArrayIndex < modeVotesObjectArray.length; modeVotesObjectArrayIndex++) { + //console.log(new Date(millisTimestamp).toISOString() + " [MODE VOTE DATABASE] HERE'S modeVotesObjectArray AT INDEX " + modeVotesObjectArrayIndex); + //console.log(modeVotesObjectArray[modeVotesObjectArrayIndex]); + modeVotesObjectArray[modeVotesObjectArrayIndex].run_name = modeVotesObjectArray[modeVotesObjectArrayIndex].run_name.replace(/({{channel_id}})+/ig, roomId); + //console.log(modeVotesObjectArray[modeVotesObjectArrayIndex]); + } + //console.log(newModeVoteObject.run_name); + newModeVoteObject.run_name = newModeVoteObject.run_name.replace(/({{channel_id}})+/ig, roomId); + //console.log(newModeVoteObject.run_name); + //console.log(new Date(millisTimestamp).toISOString() + " [MODE VOTE DATABASE] Here's the data"); + //console.log(newModeVoteObject); let playTimeTotal = millisTimestamp - runStartTime; let playTimeDays = (parseInt(playTimeTotal / 86400000)).toString().padStart(2, "0"); let playTimeHours = (parseInt(playTimeTotal / 3600000) % 24).toString().padStart(2, "0"); @@ -21709,7 +21733,19 @@ function logModeVotesToDatabase(modeVoteDataObject, modeVotesObjectArray, newMod play_time_total_millis: playTimeTotal, play_time_total_string: playTimeString }; - + /* + for (let modeVotesObjectArrayIndex = 0; modeVotesObjectArrayIndex < dataToAddToDatabase.mode_votes_object_array.length; modeVotesObjectArrayIndex++) { + //console.log(new Date(millisTimestamp).toISOString() + " [MODE VOTE DATABASE] HERE'S dataToAddToDatabase.mode_votes_object_array AT INDEX " + modeVotesObjectArrayIndex); + //console.log(dataToAddToDatabase.mode_votes_object_array[modeVotesObjectArrayIndex]); + dataToAddToDatabase.mode_votes_object_array[modeVotesObjectArrayIndex].run_name = dataToAddToDatabase.mode_votes_object_array[modeVotesObjectArrayIndex].run_name.replace(/({{channel_id}})+/ig, roomId); + //console.log(dataToAddToDatabase.mode_votes_object_array[modeVotesObjectArrayIndex]); + } + */ + //console.log(dataToAddToDatabase.new_mode_vote_object.run_name); + //dataToAddToDatabase.new_mode_vote_object.run_name = dataToAddToDatabase.new_mode_vote_object.run_name.replace(/({{channel_id}})+/ig, roomId); + //console.log(dataToAddToDatabase.new_mode_vote_object.run_name); + //console.log(new Date(millisTimestamp).toISOString() + " [MODE VOTE DATABASE] Here's the data"); + //console.log(dataToAddToDatabase); mongoClient.connect(mongoUrl, { useUnifiedTopology: true }, function(err, db) { @@ -21732,6 +21768,12 @@ function logModeChangesToDatabase(modeVoteDataObject, modeVotesObjectArray, mode if (globalConfig.log_input_mode_changes_to_database == false) { return; } + for (let modeVotesObjectArrayIndex = 0; modeVotesObjectArrayIndex < modeVotesObjectArray.length; modeVotesObjectArrayIndex++) { + //console.log(new Date(millisTimestamp).toISOString() + " [MODE CHANGE DATABASE] HERE'S modeVotesObjectArray AT INDEX " + modeVotesObjectArrayIndex); + //console.log(modeVotesObjectArray[modeVotesObjectArrayIndex]); + modeVotesObjectArray[modeVotesObjectArrayIndex].run_name = modeVotesObjectArray[modeVotesObjectArrayIndex].run_name.replace(/({{channel_id}})+/ig, roomId); + //console.log(modeVotesObjectArray[modeVotesObjectArrayIndex]); + } let playTimeTotal = millisTimestamp - runStartTime; let playTimeDays = (parseInt(playTimeTotal / 86400000)).toString().padStart(2, "0"); let playTimeHours = (parseInt(playTimeTotal / 3600000) % 24).toString().padStart(2, "0"); @@ -21754,7 +21796,16 @@ function logModeChangesToDatabase(modeVoteDataObject, modeVotesObjectArray, mode play_time_total_millis: playTimeTotal, play_time_total_string: playTimeString }; - + /* + for (let modeVotesObjectArrayIndex = 0; modeVotesObjectArrayIndex < dataToAddToDatabase.mode_votes_object_array.length; modeVotesObjectArrayIndex++) { + //console.log(new Date(millisTimestamp).toISOString() + " [MODE CHANGE DATABASE] HERE'S dataToAddToDatabase.mode_votes_object_array AT INDEX " + modeVotesObjectArrayIndex); + //console.log(dataToAddToDatabase.mode_votes_object_array[modeVotesObjectArrayIndex]); + dataToAddToDatabase.mode_votes_object_array[modeVotesObjectArrayIndex].run_name = dataToAddToDatabase.mode_votes_object_array[modeVotesObjectArrayIndex].run_name.replace(/({{channel_id}})+/ig, roomId); + //console.log(dataToAddToDatabase.mode_votes_object_array[modeVotesObjectArrayIndex]); + } + */ + //console.log(new Date(millisTimestamp).toISOString() + " [MODE CHANGE DATABASE] Here's the data"); + //console.log(dataToAddToDatabase); mongoClient.connect(mongoUrl, { useUnifiedTopology: true }, function(err, db) { @@ -21851,6 +21902,17 @@ function logModeVotesToTextFile(modeVoteDataObject, modeVotesObjectArray, newMod if (globalConfig.log_mode_votes_to_text_file == false) { return; } + for (let modeVotesObjectArrayIndex = 0; modeVotesObjectArrayIndex < modeVotesObjectArray.length; modeVotesObjectArrayIndex++) { + //console.log(new Date(millisTimestamp).toISOString() + " [MODE VOTE DATABASE] HERE'S modeVotesObjectArray AT INDEX " + modeVotesObjectArrayIndex); + //console.log(modeVotesObjectArray[modeVotesObjectArrayIndex]); + modeVotesObjectArray[modeVotesObjectArrayIndex].run_name = modeVotesObjectArray[modeVotesObjectArrayIndex].run_name.replace(/({{channel_id}})+/ig, roomId); + //console.log(modeVotesObjectArray[modeVotesObjectArrayIndex]); + } + //console.log(newModeVoteObject.run_name); + newModeVoteObject.run_name = newModeVoteObject.run_name.replace(/({{channel_id}})+/ig, roomId); + //console.log(newModeVoteObject.run_name); + //console.log(new Date(millisTimestamp).toISOString() + " [MODE VOTE DATABASE] Here's the data"); + //console.log(newModeVoteObject); // modeVoteType can be one of the 3 options // 1) added: A sender has never voted before and now added their fresh vote to the array // 2) updated: A sender has updated or changed their vote to either switch modes or to keep that vote fresh @@ -21884,6 +21946,8 @@ function logModeVotesToTextFile(modeVoteDataObject, modeVotesObjectArray, newMod play_time_total_millis: playTimeTotal, play_time_total_string: playTimeString }; + //console.log(new Date(millisTimestamp).toISOString() + " SOMEONE VOTED"); + //console.log(dataToAddToDatabase); writeToTextFile("mode_votes", "mode_vote_logs", JSON.stringify(dataToAddToDatabase), roomId, millisTimestamp); } @@ -21891,6 +21955,12 @@ function logModeChangesToTextFile(modeVoteDataObject, modeVotesObjectArray, mode if (globalConfig.log_input_mode_changes_to_text_file == false) { return; } + for (let modeVotesObjectArrayIndex = 0; modeVotesObjectArrayIndex < modeVotesObjectArray.length; modeVotesObjectArrayIndex++) { + //console.log(new Date(millisTimestamp).toISOString() + " [MODE CHANGE DATABASE] HERE'S modeVotesObjectArray AT INDEX " + modeVotesObjectArrayIndex); + //console.log(modeVotesObjectArray[modeVotesObjectArrayIndex]); + modeVotesObjectArray[modeVotesObjectArrayIndex].run_name = modeVotesObjectArray[modeVotesObjectArrayIndex].run_name.replace(/({{channel_id}})+/ig, roomId); + //console.log(modeVotesObjectArray[modeVotesObjectArrayIndex]); + } let playTimeTotal = millisTimestamp - runStartTime; let playTimeDays = (parseInt(playTimeTotal / 86400000)).toString().padStart(2, "0"); let playTimeHours = (parseInt(playTimeTotal / 3600000) % 24).toString().padStart(2, "0"); @@ -21913,6 +21983,8 @@ function logModeChangesToTextFile(modeVoteDataObject, modeVotesObjectArray, mode play_time_total_millis: playTimeTotal, play_time_total_string: playTimeString }; + //console.log(new Date(millisTimestamp).toISOString() + " THE MODE HAS CHANGED"); + //console.log(dataToAddToDatabase); writeToTextFile("input_mode_changes", "input_mode_change_logs", JSON.stringify(dataToAddToDatabase), roomId, millisTimestamp); } diff --git a/backend/chat_config.json b/backend/chat_config.json index 59be3209..b8f96425 100644 --- a/backend/chat_config.json +++ b/backend/chat_config.json @@ -38,4 +38,4 @@ "trusted_user_userid" ], "discord_bot_token": "discord_bot_token" -} +} \ No newline at end of file diff --git a/backend/controllers_reference_list.txt b/backend/controllers_reference_list.txt new file mode 100644 index 00000000..c8db8e0f --- /dev/null +++ b/backend/controllers_reference_list.txt @@ -0,0 +1,8 @@ +gcn.json contains gcn_controller.json (Normal GCN controller to be used with Gamecube games and Wii games that have native Gamecube controller support) +gcn_rvl_sideways.json contains gcn_rvl_sideways_controller.json (This is an RVLoader controller (GCN to Wii)) +gcn_vc_nes.json contains gcn_vc_nes_controller.json (GCN controller to be used with NES Wii Virtual Console games) +gcn_vc_snes.json contains gcn_vc_snes_controller.json (GCN controller to be used with Super NES Wii Virtual Console games) +n64.json contains n64_controller.json (Normal N64 controller to be used with an actual N64 console) +ps2.json contains ps2_controller.json (PS2 controller with full analog support (Uses analog sticks)) +ps2_digital.json contains ps2_controller_digital.json (PS2 controller but only digital (Does not use analog sticks)) +snes_controller.json does not have any associations (Because I never had any need to do stuff on actual snes because my snes is kinda unreliable) \ No newline at end of file diff --git a/backend/gcn_rvl_sideways.json b/backend/gcn_rvl_sideways.json new file mode 100644 index 00000000..2d231ec0 --- /dev/null +++ b/backend/gcn_rvl_sideways.json @@ -0,0 +1,954 @@ +{ + "com_port": "COM5", + "com_port_parameters": { + "autoOpen": true, + "baudRate": 500000 + }, + "time_unit": "milliseconds", + "time_unit_alternate": "seconds", + "time_unit_short": "ms", + "millis_to_seconds_conversion_threshold": 10, + "display_framerate": false, + "normal_delay": 266, + "max_delay": 65535, + "held_delay": 0, + "stick_minimum": 0, + "stick_maximum": 255, + "stick_center": 127, + "stick_limit": 0, + "initial_macro_preamble": 4, + "final_macro_preamble": 68, + "initial_macro_inner_loop": 69, + "final_macro_inner_loop": 133, + "advanced_input_macros_allowed": 64, + "advanced_input_macro_inner_loops_allowed": 64, + "max_duration_per_precision_input_millis": 65535, + "default_duration_per_precision_input_millis": 266, + "held_duration_per_precision_input_millis": 533, + "max_times_to_repeat_macro": 255, + "controller_object": "gcn_rvl_sideways_controller.json", + "simultaneous_different_basic_buttons_allowed": 5, + "use_vibration_and_led_data": false, + "vibration_negative_range_pixels": -5, + "vibration_positive_range_pixels": 5, + "vibration_options": [ + { + "display_motor": false, + "enable_visual_vibration": false, + "motor_label_name": "Rumble", + "motor_label_state_on": "Rumble On", + "motor_label_state_off": "Rumble Off", + "motor_label_scale": 2, + "motor_label_position": [2, 525], + "motor_icon_on": ["assets\\color\\single_inverted_normal_0.png", "assets\\color\\single_inverted_normal_1.png", "assets\\color\\single_inverted_normal_2.png", "assets\\color\\single_inverted_rotated_0.png", "assets\\color\\single_inverted_rotated_1.png", "assets\\color\\single_inverted_rotated_2.png", "assets\\color\\single_normal_0.png", "assets\\color\\single_normal_1.png", "assets\\color\\single_normal_2.png", "assets\\color\\single_rotated_0.png", "assets\\color\\single_rotated_1.png", "assets\\color\\single_rotated_2.png"], + "motor_icon_off": "assets\\bw\\single_normal_bw_0.png", + "motor_icon_scale": 1, + "motor_icon_position": [2, 485], + "divisor_to_use_for_motor_icon": 1, + "motor_color_state_on": "#00FF00FF", + "motor_color_state_off": "#FF0000FF", + "motor_behavior": "vibrate_icon", + "send_status_change_message": false, + "notes": "motor_behavior is used to tell how the vibration should be displayed, if it should use its own icon or if it should vibrate something else in the overlay, like the text that displays what input is currently being executed, as an example, it is only recommended to use integers for the scales motor_label_scale and motor_icon_scale, it is recommended that icon is scaled to 10x using nearest neighbor, then the program does the rest, downside is that it makes the files larger and they also use up more RAM when the page is loaded, also takes slightly longer to load, but I think loading speeds are pretty much inperceptible", + "valid_behaviors": "vibrate_label, vibrate_icon, vibrate_icon_and_label, vibrate_current_input, vibrate_current_input_with_color_change, all(?)" + }, + { + "display_motor": false, + "enable_visual_vibration": false, + "motor_label_name": "Motor 2", + "motor_label_state_on": "Motor 2 On", + "motor_label_state_off": "Motor 2 Off", + "motor_label_scale": 2, + "motor_label_position": [200, 220], + "motor_icon_on": ["placeholder.png"], + "motor_icon_off": "placeholder.png", + "motor_icon_scale": 2, + "motor_icon_position": [200, 220], + "divisor_to_use_for_motor_icon": 1, + "motor_color_state_on": "#00FF00FF", + "motor_color_state_off": "#FF0000FF", + "motor_behavior": "vibrate_icon", + "send_status_change_message": false, + "notes": "motor_behavior is used to tell how the vibration should be displayed, if it should use its own icon or if it should vibrate something else in the overlay, like the text that displays what input is currently being executed, as an example, it is only recommended to use integers for the scales motor_label_scale and motor_icon_scale, it is recommended that icon is scaled to 10x using nearest neighbor, then the program does the rest, downside is that it makes the files larger and they also use up more RAM when the page is loaded, also takes slightly longer to load, but I think loading speeds are pretty much inperceptible", + "valid_behaviors": "vibrate_label, vibrate_icon, vibrate_icon_and_label, vibrate_current_input, vibrate_current_input_with_color_change, all(?)" + }, + { + "display_motor": false, + "enable_visual_vibration": false, + "motor_label_name": "Motor 3", + "motor_label_state_on": "Motor 3 On", + "motor_label_state_off": "Motor 3 Off", + "motor_label_scale": 2, + "motor_label_position": [200, 230], + "motor_icon_on": ["placeholder.png"], + "motor_icon_off": "placeholder.png", + "motor_icon_scale": 2, + "motor_icon_position": [200, 230], + "divisor_to_use_for_motor_icon": 1, + "motor_color_state_on": "#00FF00FF", + "motor_color_state_off": "#FF0000FF", + "motor_behavior": "vibrate_icon", + "send_status_change_message": false, + "notes": "motor_behavior is used to tell how the vibration should be displayed, if it should use its own icon or if it should vibrate something else in the overlay, like the text that displays what input is currently being executed, as an example, it is only recommended to use integers for the scales motor_label_scale and motor_icon_scale, it is recommended that icon is scaled to 10x using nearest neighbor, then the program does the rest, downside is that it makes the files larger and they also use up more RAM when the page is loaded, also takes slightly longer to load, but I think loading speeds are pretty much inperceptible", + "valid_behaviors": "vibrate_label, vibrate_icon, vibrate_icon_and_label, vibrate_current_input, vibrate_current_input_with_color_change, all(?)" + }, + { + "display_motor": false, + "enable_visual_vibration": false, + "motor_label_name": "Motor 4", + "motor_label_state_on": "Motor 4 On", + "motor_label_state_off": "Motor 4 Off", + "motor_label_scale": 2, + "motor_label_position": [200, 240], + "motor_icon_on": ["placeholder.png"], + "motor_icon_off": "placeholder.png", + "motor_icon_scale": 2, + "motor_icon_position": [200, 240], + "divisor_to_use_for_motor_icon": 1, + "motor_color_state_on": "#00FF00FF", + "motor_color_state_off": "#FF0000FF", + "motor_behavior": "vibrate_icon", + "send_status_change_message": false, + "notes": "motor_behavior is used to tell how the vibration should be displayed, if it should use its own icon or if it should vibrate something else in the overlay, like the text that displays what input is currently being executed, as an example, it is only recommended to use integers for the scales motor_label_scale and motor_icon_scale, it is recommended that icon is scaled to 10x using nearest neighbor, then the program does the rest, downside is that it makes the files larger and they also use up more RAM when the page is loaded, also takes slightly longer to load, but I think loading speeds are pretty much inperceptible", + "valid_behaviors": "vibrate_label, vibrate_icon, vibrate_icon_and_label, vibrate_current_input, vibrate_current_input_with_color_change, all(?)" + } + ], + "led_options": [ + { + "display_led": false, + "led_label_name": "Turbo", + "led_label_state_on": "Turbo On", + "led_label_state_off": "Turbo Off", + "led_label_scale": 2, + "led_label_position": [200, 250], + "led_icon_on": "placeholder.png", + "led_icon_off": "placeholder.png", + "led_icon_scale": 2, + "led_icon_position": [200, 250], + "divisor_to_use_for_led_icon": 1, + "led_color_state_on": "#00FF00FF", + "led_color_state_off": "#FF0000FF", + "led_behavior": "use_icon", + "send_status_change_message": false, + "notes": "led_behavior is used to tell how the LED should be displayed, if it should use its own icon or if it should light up something else in the overlay, like the text that displays what input is currently being executed(?), as an example, it is only recommended to use integers for the scales led_label_scale and led_icon_scale, it is recommended that icon is scaled to 10x using nearest neighbor, then the program does the rest, downside is that it makes the files larger and they also use up more RAM when the page is loaded, also takes slightly longer to load, but I think loading speeds are pretty much inperceptible", + "valid_behaviors": "use_label, use_icon, use_icon_and_label, use_current_input(?), use_current_input_with_color_change(?), all(?)" + }, + { + "display_led": false, + "led_label_name": "Macro", + "led_label_state_on": "Macro On", + "led_label_state_off": "Macro Off", + "led_label_scale": 2, + "led_label_position": [200, 260], + "led_icon_on": "placeholder.png", + "led_icon_off": "placeholder.png", + "led_icon_scale": 2, + "led_icon_position": [200, 260], + "divisor_to_use_for_led_icon": 1, + "led_color_state_on": "#00FF00FF", + "led_color_state_off": "#FF0000FF", + "led_behavior": "use_icon", + "send_status_change_message": false, + "notes": "led_behavior is used to tell how the LED should be displayed, if it should use its own icon or if it should light up something else in the overlay, like the text that displays what input is currently being executed(?), as an example, it is only recommended to use integers for the scales led_label_scale and led_icon_scale, it is recommended that icon is scaled to 10x using nearest neighbor, then the program does the rest, downside is that it makes the files larger and they also use up more RAM when the page is loaded, also takes slightly longer to load, but I think loading speeds are pretty much inperceptible", + "valid_behaviors": "use_label, use_icon, use_icon_and_label, use_current_input(?), use_current_input_with_color_change(?), all(?)" + }, + { + "display_led": false, + "led_label_name": "LED 3", + "led_label_state_on": "LED 3 On", + "led_label_state_off": "LED 3 Off", + "led_label_scale": 2, + "led_label_position": [200, 270], + "led_icon_on": "placeholder.png", + "led_icon_off": "placeholder.png", + "led_icon_scale": 2, + "led_icon_position": [200, 270], + "divisor_to_use_for_led_icon": 1, + "led_color_state_on": "#00FF00FF", + "led_color_state_off": "#FF0000FF", + "led_behavior": "use_icon", + "send_status_change_message": false, + "notes": "led_behavior is used to tell how the LED should be displayed, if it should use its own icon or if it should light up something else in the overlay, like the text that displays what input is currently being executed(?), as an example, it is only recommended to use integers for the scales led_label_scale and led_icon_scale, it is recommended that icon is scaled to 10x using nearest neighbor, then the program does the rest, downside is that it makes the files larger and they also use up more RAM when the page is loaded, also takes slightly longer to load, but I think loading speeds are pretty much inperceptible", + "valid_behaviors": "use_label, use_icon, use_icon_and_label, use_current_input(?), use_current_input_with_color_change(?), all(?)" + }, + { + "display_led": false, + "led_label_name": "LED 4", + "led_label_state_on": "LED 4 On", + "led_label_state_off": "LED 4 Off", + "led_label_scale": 2, + "led_label_position": [200, 280], + "led_icon_on": "placeholder.png", + "led_icon_off": "placeholder.png", + "led_icon_scale": 2, + "led_icon_position": [200, 280], + "divisor_to_use_for_led_icon": 1, + "led_color_state_on": "#00FF00FF", + "led_color_state_off": "#FF0000FF", + "led_behavior": "use_icon", + "send_status_change_message": false, + "notes": "led_behavior is used to tell how the LED should be displayed, if it should use its own icon or if it should light up something else in the overlay, like the text that displays what input is currently being executed(?), as an example, it is only recommended to use integers for the scales led_label_scale and led_icon_scale, it is recommended that icon is scaled to 10x using nearest neighbor, then the program does the rest, downside is that it makes the files larger and they also use up more RAM when the page is loaded, also takes slightly longer to load, but I think loading speeds are pretty much inperceptible", + "valid_behaviors": "use_label, use_icon, use_icon_and_label, use_current_input(?), use_current_input_with_color_change(?), all(?)" + } + ], + "controller_graphics": "gcn_controller_graphics.png", + "use_controller_graphics": false, + "help_message_basic": [ + "Valid inputs are A, B, One, Two, Plus (or Start), Minus (or Select) (Buttons), Up, Down, Left, Right (D Pad), PUp, PDown, PLeft, PRight (Short for PointerUp, PointerDown, PointerLeft, PointerRight, moves the pointer around the screen), and Shake (Shakes the controller). It's exactly what you'd see if you looked at a Wii Remote controller! Typos work too!", + "Typing 1, 2, + or - DOES NOT WORK, you have to type One, Two, Plus or Minus to press said buttons, unfortunately. It's an issue that I never thought I would come across, because numbers and + - are already reserved for other functionalities, so I had to map those buttons as the words One, Two, Plus and Minus. I apologize for the inconvenience.", + "Up to {{simultaneous_different_basic_buttons_allowed}} different inputs can be executed at the same time by using + to combine inputs. Example: B+Up+PRight will press the B Button, press Up on the D Pad and move the pointer to the right. It is not needed to start your message with ! mark.", + "Normal duration of inputs is {{normal_delay}} {{time_unit}}, but you can end your input with - to execute the inputs indefinitely until the next input comes. Alternatively, you can type Wait or Stop to stop the execution of a held input. Maximum duration for an input is {{max_delay}} {{time_unit}}.", + "Example: A+Shake+Right- will hold the Button A, shake the controller, and will press Right on the D Pad. Commands are NOT case sensitive: left and lEft will both press Left on the D Pad.", + "You can type Basic or Advanced to vote to change input modes. The majority of votes needs at least 75% of votes to have the input mode changed to their side, votes are removed from the pool after 5 minutes. After that, you'll have to vote again to have your vote readded to the pool.", + "Alternatively, you can spam votes to make sure your vote always stays in the pool. You can switch sides whenever you want. Basic mode executes inputs are they are received from chat, it is limited for some tasks, while advanced can be used to do a sequence of very precise inputs. Current mode is Basic mode. You can also find this help message in the stream description." + ], + "simultaneous_different_advanced_buttons_allowed": 5, + "help_message_advanced": [ + "Valid inputs are A, B, One, Two, Plus (or Start), Minus (or Select) (Buttons), Up, Down, Left, Right (D Pad), PUp, PDown, PLeft, PRight (Short for PointerUp, PointerDown, PointerLeft, PointerRight, moves the pointer around the screen), and Shake (Shakes the controller). It's exactly what you'd see if you looked at a Wii Remote controller! Typos work too!", + "Typing 1, 2, + or - DOES NOT WORK, you have to type One, Two, Plus or Minus to press said buttons, unfortunately. It's an issue that I never thought I would come across, because numbers and + - are already reserved for other functionalities, so I had to map those buttons as the words One, Two, Plus and Minus. I apologize for the inconvenience.", + "Up to {{simultaneous_different_advanced_buttons_allowed}} different inputs can be executed at the same time by using + to combine inputs. Example: B+Up+PRight will press the B Button, press Up on the D Pad and move the pointer to the right. It is not needed to start your message with ! mark. Commands are NOT case sensitive: left and lEft will both press Left on the D Pad.", + "Normal duration of inputs is {{default_duration_per_precision_input_millis}} {{time_unit}}. You can separate multiple inputs by using spaces or commas to execute multiple inputs in rapid succession.", + "Example: Up+Right+B;2000 A+Shake+Down;1000 *5 Will press Up and Right on the D Pad and press the B Button for 2000 {{time_unit}} (2 {{time_unit_alternate}}), then press the A button, shake the controller, and press Down on the D Pad for 1000 {{time_unit}} (1 {{time_unit_alternate}}), and *5 means the input will be executed once, then it will be repeated 5 times. There is no delay between inputs.", + "You can use square brackets to make smaller loops. Example: [A+B;1000 One+Two;500*4] Plus [Up+Right Up+Left*2] 2 will press A+B then One+Two 4 times, then will press Plus, then will press Up+Right then Up+Left 2 times, and everything will be repeated 2 times.", + "There is no delay between inputs, but sometimes you'll need a delay between inputs, you can use Wait or Stop to add a delay between inputs. Example: A Wait *{{max_times_to_repeat_macro}} will press the A Button for {{default_duration_per_precision_input_millis}} {{time_unit}} then wait for another {{default_duration_per_precision_input_millis}} {{time_unit}}, and will repeat that macro {{max_times_to_repeat_macro}} times, basically mashing the A Button {{max_times_to_repeat_macro}}+1 times. Macros can be repeated up to {{max_times_to_repeat_macro}} times. Up to {{advanced_input_macros_allowed}} inputs can be chained in a macro.", + "You can execute commands backwards if you start your message with Invert. Example: Invert A B One Two will execute commands as Two One B A. You can invert directions if you start you message with Opposite. Example: Opposite Up Down Left Right will execute commands as Down Up Right Left.", + "You can use both Invert and Opposite at the same time. Example: Opposite Invert A+Up B+Down One+Left Two+Right Plus Up Down will execute commands as Up Down Plus Two+Left One+Right B+Up A+Down.", + "Maximum duration for an input is {{max_duration_per_precision_input_millis}} {{time_unit}}. You can type Basic or Advanced to vote to change input modes. The majority of votes needs at least 75% of votes to have the input mode changed to their side, votes are removed from the pool after 5 minutes. After that, you'll have to vote again to have your vote readded to the pool.", + "Alternatively, you can spam votes to make sure your vote always stays in the pool. You can switch sides whenever you want. Basic mode executes inputs are they are received from chat, it is limited for some tasks, while advanced can be used to do a sequence of very precise inputs. Current mode is Advanced mode.", + "You can learn how to save and execute saved macros (and more!) by using the command !macrohelp. You can also find this help message in the stream description." + ], + "blacklisted_combos": [ + { + "blacklisted_combo_input_string": "One+Two+Home", + "blacklisted_combo_input_size": 3, + "blacklisted_combo_input_value": "0x38007F7F7F7F0000L", + "blacklisted_combo_input_description": "Reset controller 1", + "blacklisted_combo_input_components": [ + { + "component_input_alias": "One", + "component_input_value": "0x20007F7F7F7F0000L" + }, + { + "component_input_alias": "Two", + "component_input_value": "0x10007F7F7F7F0000L" + }, + { + "component_input_alias": "Home", + "component_input_value": "0x08007F7F7F7F0000L" + } + ] + }, + { + "blacklisted_combo_input_string": "Minus+Plus+Home", + "blacklisted_combo_input_size": 3, + "blacklisted_combo_input_value": "0x0B037F7F7F7F0000L", + "blacklisted_combo_input_description": "Reset controller 2", + "blacklisted_combo_input_components": [ + { + "component_input_alias": "Minus", + "component_input_value": "0x01017F7F7F7F0000L" + }, + { + "component_input_alias": "Plus", + "component_input_value": "0x02027F7F7F7F0000L" + }, + { + "component_input_alias": "Home", + "component_input_value": "0x08007F7F7F7F0000L" + } + ] + }, + { + "blacklisted_combo_input_string": "Plus+Shake+Home", + "blacklisted_combo_input_size": 3, + "blacklisted_combo_input_value": "0x0E027F7F7F7F0000L", + "blacklisted_combo_input_description": "Reset system", + "blacklisted_combo_input_components": [ + { + "component_input_alias": "Plus", + "component_input_value": "0x02027F7F7F7F0000L" + }, + { + "component_input_alias": "Shake", + "component_input_value": "0x04007F7F7F7F0000L" + }, + { + "component_input_alias": "Home", + "component_input_value": "0x08007F7F7F7F0000L" + } + ] + }, + { + "blacklisted_combo_input_string": "Minus+Plus+Shake", + "blacklisted_combo_input_size": 3, + "blacklisted_combo_input_value": "0x07037F7F7F7F0000L", + "blacklisted_combo_input_description": "RVLoader Safe Menu", + "blacklisted_combo_input_components": [ + { + "component_input_alias": "Minus", + "component_input_value": "0x01017F7F7F7F0000L" + }, + { + "component_input_alias": "Plus", + "component_input_value": "0x02027F7F7F7F0000L" + }, + { + "component_input_alias": "Shake", + "component_input_value": "0x04007F7F7F7F0000L" + } + ] + }, + { + "blacklisted_combo_input_string": "Shake+Two+Up", + "blacklisted_combo_input_size": 3, + "blacklisted_combo_input_value": "0x14107F7F7F7F0000L", + "blacklisted_combo_input_description": "RVLoader Volume +", + "blacklisted_combo_input_components": [ + { + "component_input_alias": "Shake", + "component_input_value": "0x04007F7F7F7F0000L" + }, + { + "component_input_alias": "Two", + "component_input_value": "0x10007F7F7F7F0000L" + }, + { + "component_input_alias": "Up", + "component_input_value": "0x00107F7F7F7F0000L" + } + ] + }, + { + "blacklisted_combo_input_string": "Shake+Two+Down", + "blacklisted_combo_input_size": 3, + "blacklisted_combo_input_value": "0x14207F7F7F7F0000L", + "blacklisted_combo_input_description": "RVLoader Volume -", + "blacklisted_combo_input_components": [ + { + "component_input_alias": "Shake", + "component_input_value": "0x04007F7F7F7F0000L" + }, + { + "component_input_alias": "Two", + "component_input_value": "0x10007F7F7F7F0000L" + }, + { + "component_input_alias": "Down", + "component_input_value": "0x00207F7F7F7F0000L" + } + ] + }, + { + "blacklisted_combo_input_string": "Shake+One+Up", + "blacklisted_combo_input_size": 3, + "blacklisted_combo_input_value": "0x24107F7F7F7F0000L", + "blacklisted_combo_input_description": "RVLoader Brightness +", + "blacklisted_combo_input_components": [ + { + "component_input_alias": "Shake", + "component_input_value": "0x04007F7F7F7F0000L" + }, + { + "component_input_alias": "One", + "component_input_value": "0x20007F7F7F7F0000L" + }, + { + "component_input_alias": "Up", + "component_input_value": "0x00107F7F7F7F0000L" + } + ] + }, + { + "blacklisted_combo_input_string": "Shake+One+Down", + "blacklisted_combo_input_size": 3, + "blacklisted_combo_input_value": "0x24207F7F7F7F0000L", + "blacklisted_combo_input_description": "RVLoader Brightness -", + "blacklisted_combo_input_components": [ + { + "component_input_alias": "Shake", + "component_input_value": "0x04007F7F7F7F0000L" + }, + { + "component_input_alias": "One", + "component_input_value": "0x20007F7F7F7F0000L" + }, + { + "component_input_alias": "Down", + "component_input_value": "0x00207F7F7F7F0000L" + } + ] + }, + { + "blacklisted_combo_input_string": "Minus+Plus+Shake+Home", + "blacklisted_combo_input_size": 4, + "blacklisted_combo_input_value": "0x0F037F7F7F7F0000L", + "blacklisted_combo_input_description": "Reset system 2", + "blacklisted_combo_input_components": [ + { + "component_input_alias": "Minus", + "component_input_value": "0x01017F7F7F7F0000L" + }, + { + "component_input_alias": "Plus", + "component_input_value": "0x02027F7F7F7F0000L" + }, + { + "component_input_alias": "Shake", + "component_input_value": "0x04007F7F7F7F0000L" + }, + { + "component_input_alias": "Home", + "component_input_value": "0x08007F7F7F7F0000L" + } + ] + }, + { + "blacklisted_combo_input_string": "Minus+Plus+Shake+B", + "blacklisted_combo_input_size": 4, + "blacklisted_combo_input_value": "0x47037F7F7F7F0000L", + "blacklisted_combo_input_description": "RVLoader VGA Mode", + "blacklisted_combo_input_components": [ + { + "component_input_alias": "Minus", + "component_input_value": "0x01017F7F7F7F0000L" + }, + { + "component_input_alias": "Plus", + "component_input_value": "0x02027F7F7F7F0000L" + }, + { + "component_input_alias": "Shake", + "component_input_value": "0x04007F7F7F7F0000L" + }, + { + "component_input_alias": "B", + "component_input_value": "0x40007F7F7F7F0000L" + } + ] + }, + { + "blacklisted_combo_input_string": "Plus+Shake+B+Up", + "blacklisted_combo_input_size": 4, + "blacklisted_combo_input_value": "0x46127F7F7F7F0000L", + "blacklisted_combo_input_description": "Turn system off 1", + "blacklisted_combo_input_components": [ + { + "component_input_alias": "Plus", + "component_input_value": "0x02027F7F7F7F0000L" + }, + { + "component_input_alias": "Shake", + "component_input_value": "0x04007F7F7F7F0000L" + }, + { + "component_input_alias": "B", + "component_input_value": "0x40007F7F7F7F0000L" + }, + { + "component_input_alias": "Up", + "component_input_value": "0x00107F7F7F7F0000L" + } + ] + }, + { + "blacklisted_combo_input_string": "Plus+Shake+B+Down", + "blacklisted_combo_input_size": 4, + "blacklisted_combo_input_value": "0x46227F7F7F7F0000L", + "blacklisted_combo_input_description": "Turn system off 2", + "blacklisted_combo_input_components": [ + { + "component_input_alias": "Plus", + "component_input_value": "0x02027F7F7F7F0000L" + }, + { + "component_input_alias": "Shake", + "component_input_value": "0x04007F7F7F7F0000L" + }, + { + "component_input_alias": "B", + "component_input_value": "0x40007F7F7F7F0000L" + }, + { + "component_input_alias": "Down", + "component_input_value": "0x00207F7F7F7F0000L" + } + ] + }, + { + "blacklisted_combo_input_string": "Plus+Shake+B+Right", + "blacklisted_combo_input_size": 4, + "blacklisted_combo_input_value": "0x46427F7F7F7F0000L", + "blacklisted_combo_input_description": "Turn system off 3", + "blacklisted_combo_input_components": [ + { + "component_input_alias": "Plus", + "component_input_value": "0x02027F7F7F7F0000L" + }, + { + "component_input_alias": "Shake", + "component_input_value": "0x04007F7F7F7F0000L" + }, + { + "component_input_alias": "B", + "component_input_value": "0x40007F7F7F7F0000L" + }, + { + "component_input_alias": "Right", + "component_input_value": "0x00407F7F7F7F0000L" + } + ] + }, + { + "blacklisted_combo_input_string": "Plus+Shake+B+Left", + "blacklisted_combo_input_size": 4, + "blacklisted_combo_input_value": "0x46827F7F7F7F0000L", + "blacklisted_combo_input_description": "Turn system off 4", + "blacklisted_combo_input_components": [ + { + "component_input_alias": "Plus", + "component_input_value": "0x02027F7F7F7F0000L" + }, + { + "component_input_alias": "Shake", + "component_input_value": "0x04007F7F7F7F0000L" + }, + { + "component_input_alias": "B", + "component_input_value": "0x40007F7F7F7F0000L" + }, + { + "component_input_alias": "Left", + "component_input_value": "0x00807F7F7F7F0000L" + } + ] + }, + { + "blacklisted_combo_input_string": "Plus+Shake+B+Up+Right", + "blacklisted_combo_input_size": 5, + "blacklisted_combo_input_value": "0x46527F7F7F7F0000L", + "blacklisted_combo_input_description": "Turn system off 5", + "blacklisted_combo_input_components": [ + { + "component_input_alias": "Plus", + "component_input_value": "0x02027F7F7F7F0000L" + }, + { + "component_input_alias": "Shake", + "component_input_value": "0x04007F7F7F7F0000L" + }, + { + "component_input_alias": "B", + "component_input_value": "0x40007F7F7F7F0000L" + }, + { + "component_input_alias": "Up", + "component_input_value": "0x00107F7F7F7F0000L" + }, + { + "component_input_alias": "Right", + "component_input_value": "0x00407F7F7F7F0000L" + } + ] + }, + { + "blacklisted_combo_input_string": "Plus+Shake+B+Down+Right", + "blacklisted_combo_input_size": 5, + "blacklisted_combo_input_value": "0x46627F7F7F7F0000L", + "blacklisted_combo_input_description": "Turn system off 6", + "blacklisted_combo_input_components": [ + { + "component_input_alias": "Plus", + "component_input_value": "0x02027F7F7F7F0000L" + }, + { + "component_input_alias": "Shake", + "component_input_value": "0x04007F7F7F7F0000L" + }, + { + "component_input_alias": "B", + "component_input_value": "0x40007F7F7F7F0000L" + }, + { + "component_input_alias": "Down", + "component_input_value": "0x00207F7F7F7F0000L" + }, + { + "component_input_alias": "Right", + "component_input_value": "0x00407F7F7F7F0000L" + } + ] + }, + { + "blacklisted_combo_input_string": "Plus+Shake+B+Up+Left", + "blacklisted_combo_input_size": 5, + "blacklisted_combo_input_value": "0x46927F7F7F7F0000L", + "blacklisted_combo_input_description": "Turn system off 7", + "blacklisted_combo_input_components": [ + { + "component_input_alias": "Plus", + "component_input_value": "0x02027F7F7F7F0000L" + }, + { + "component_input_alias": "Shake", + "component_input_value": "0x04007F7F7F7F0000L" + }, + { + "component_input_alias": "B", + "component_input_value": "0x40007F7F7F7F0000L" + }, + { + "component_input_alias": "Up", + "component_input_value": "0x00107F7F7F7F0000L" + }, + { + "component_input_alias": "Left", + "component_input_value": "0x00807F7F7F7F0000L" + } + ] + }, + { + "blacklisted_combo_input_string": "Plus+Shake+B+Down+Left", + "blacklisted_combo_input_size": 5, + "blacklisted_combo_input_value": "0x46A27F7F7F7F0000L", + "blacklisted_combo_input_description": "Turn system off 8", + "blacklisted_combo_input_components": [ + { + "component_input_alias": "Plus", + "component_input_value": "0x02027F7F7F7F0000L" + }, + { + "component_input_alias": "Shake", + "component_input_value": "0x04007F7F7F7F0000L" + }, + { + "component_input_alias": "B", + "component_input_value": "0x40007F7F7F7F0000L" + }, + { + "component_input_alias": "Down", + "component_input_value": "0x00207F7F7F7F0000L" + }, + { + "component_input_alias": "Left", + "component_input_value": "0x00807F7F7F7F0000L" + } + ] + }, + { + "blacklisted_combo_input_string": "Plus+Shake+B+Up+Down+Right+Left", + "blacklisted_combo_input_size": 7, + "blacklisted_combo_input_value": "0x46F27F7F7F7F0000L", + "blacklisted_combo_input_description": "Turn system off 9", + "blacklisted_combo_input_components": [ + { + "component_input_alias": "Plus", + "component_input_value": "0x02027F7F7F7F0000L" + }, + { + "component_input_alias": "Shake", + "component_input_value": "0x04007F7F7F7F0000L" + }, + { + "component_input_alias": "B", + "component_input_value": "0x40007F7F7F7F0000L" + }, + { + "component_input_alias": "Up", + "component_input_value": "0x00107F7F7F7F0000L" + }, + { + "component_input_alias": "Down", + "component_input_value": "0x00207F7F7F7F0000L" + }, + { + "component_input_alias": "Right", + "component_input_value": "0x00407F7F7F7F0000L" + }, + { + "component_input_alias": "Left", + "component_input_value": "0x00807F7F7F7F0000L" + } + ] + }, + { + "blacklisted_combo_input_string": "Minus+Plus+Shake+Home+Two+One+B+A", + "blacklisted_combo_input_size": 8, + "blacklisted_combo_input_value": "0xFF037F7F7F7F0000L", + "blacklisted_combo_input_description": "Turn system off 10", + "blacklisted_combo_input_components": [ + { + "component_input_alias": "Minus", + "component_input_value": "0x01017F7F7F7F0000L" + }, + { + "component_input_alias": "Plus", + "component_input_value": "0x02027F7F7F7F0000L" + }, + { + "component_input_alias": "Shake", + "component_input_value": "0x04007F7F7F7F0000L" + }, + { + "component_input_alias": "Home", + "component_input_value": "0x08007F7F7F7F0000L" + }, + { + "component_input_alias": "Two", + "component_input_value": "0x10007F7F7F7F0000L" + }, + { + "component_input_alias": "One", + "component_input_value": "0x20007F7F7F7F0000L" + }, + { + "component_input_alias": "B", + "component_input_value": "0x40007F7F7F7F0000L" + }, + { + "component_input_alias": "A", + "component_input_value": "0x80007F7F7F7F0000L" + } + ] + }, + { + "blacklisted_combo_input_string": "Minus+Plus+Shake+Home+PUp", + "blacklisted_combo_input_size": 5, + "blacklisted_combo_input_value": "0x0F037F7F7F000000L", + "blacklisted_combo_input_description": "Reset game 1", + "blacklisted_combo_input_components": [ + { + "component_input_alias": "Minus", + "component_input_value": "0x01017F7F7F7F0000L" + }, + { + "component_input_alias": "Plus", + "component_input_value": "0x02027F7F7F7F0000L" + }, + { + "component_input_alias": "Shake", + "component_input_value": "0x04007F7F7F7F0000L" + }, + { + "component_input_alias": "Home", + "component_input_value": "0x08007F7F7F7F0000L" + }, + { + "component_input_alias": "PUp", + "component_input_value": "0x00007F7F7F000000L" + } + ] + }, + { + "blacklisted_combo_input_string": "Minus+Plus+Shake+Home+PDown", + "blacklisted_combo_input_size": 5, + "blacklisted_combo_input_value": "0x0F037F7F7FFF0000L", + "blacklisted_combo_input_description": "Reset game 2", + "blacklisted_combo_input_components": [ + { + "component_input_alias": "Minus", + "component_input_value": "0x01017F7F7F7F0000L" + }, + { + "component_input_alias": "Plus", + "component_input_value": "0x02027F7F7F7F0000L" + }, + { + "component_input_alias": "Shake", + "component_input_value": "0x04007F7F7F7F0000L" + }, + { + "component_input_alias": "Home", + "component_input_value": "0x08007F7F7F7F0000L" + }, + { + "component_input_alias": "PDown", + "component_input_value": "0x00007F7F7FFF0000L" + } + ] + }, + { + "blacklisted_combo_input_string": "Minus+Plus+Shake+Home+PLeft", + "blacklisted_combo_input_size": 5, + "blacklisted_combo_input_value": "0x0F037F7F007F0000L", + "blacklisted_combo_input_description": "Reset game 3", + "blacklisted_combo_input_components": [ + { + "component_input_alias": "Minus", + "component_input_value": "0x01017F7F7F7F0000L" + }, + { + "component_input_alias": "Plus", + "component_input_value": "0x02027F7F7F7F0000L" + }, + { + "component_input_alias": "Shake", + "component_input_value": "0x04007F7F7F7F0000L" + }, + { + "component_input_alias": "Home", + "component_input_value": "0x08007F7F7F7F0000L" + }, + { + "component_input_alias": "PLeft", + "component_input_value": "0x00007F7F007F0000L" + } + ] + }, + { + "blacklisted_combo_input_string": "Minus+Plus+Shake+Home+PRight", + "blacklisted_combo_input_size": 5, + "blacklisted_combo_input_value": "0x0F037F7FFF7F0000L", + "blacklisted_combo_input_description": "Reset game 4", + "blacklisted_combo_input_components": [ + { + "component_input_alias": "Minus", + "component_input_value": "0x01017F7F7F7F0000L" + }, + { + "component_input_alias": "Plus", + "component_input_value": "0x02027F7F7F7F0000L" + }, + { + "component_input_alias": "Shake", + "component_input_value": "0x04007F7F7F7F0000L" + }, + { + "component_input_alias": "Home", + "component_input_value": "0x08007F7F7F7F0000L" + }, + { + "component_input_alias": "PRight", + "component_input_value": "0x00007F7FFF7F0000L" + } + ] + }, + { + "blacklisted_combo_input_string": "Minus+Plus+Shake+Home+PUp+PLeft", + "blacklisted_combo_input_size": 6, + "blacklisted_combo_input_value": "0x0F037F7F00000000L", + "blacklisted_combo_input_description": "Reset game 5", + "blacklisted_combo_input_components": [ + { + "component_input_alias": "Minus", + "component_input_value": "0x01017F7F7F7F0000L" + }, + { + "component_input_alias": "Plus", + "component_input_value": "0x02027F7F7F7F0000L" + }, + { + "component_input_alias": "Shake", + "component_input_value": "0x04007F7F7F7F0000L" + }, + { + "component_input_alias": "Home", + "component_input_value": "0x08007F7F7F7F0000L" + }, + { + "component_input_alias": "PUp", + "component_input_value": "0x00007F7F7F000000L" + }, + { + "component_input_alias": "PLeft", + "component_input_value": "0x00007F7F007F0000L" + } + ] + }, + { + "blacklisted_combo_input_string": "Minus+Plus+Shake+Home+PDown+PLeft", + "blacklisted_combo_input_size": 6, + "blacklisted_combo_input_value": "0x0F037F7F00FF0000L", + "blacklisted_combo_input_description": "Reset game 6", + "blacklisted_combo_input_components": [ + { + "component_input_alias": "Minus", + "component_input_value": "0x01017F7F7F7F0000L" + }, + { + "component_input_alias": "Plus", + "component_input_value": "0x02027F7F7F7F0000L" + }, + { + "component_input_alias": "Shake", + "component_input_value": "0x04007F7F7F7F0000L" + }, + { + "component_input_alias": "Home", + "component_input_value": "0x08007F7F7F7F0000L" + }, + { + "component_input_alias": "PDown", + "component_input_value": "0x00007F7F7FFF0000L" + }, + { + "component_input_alias": "PLeft", + "component_input_value": "0x00007F7F007F0000L" + } + ] + }, + { + "blacklisted_combo_input_string": "Minus+Plus+Shake+Home+PUp+PRight", + "blacklisted_combo_input_size": 6, + "blacklisted_combo_input_value": "0x0F037F7FFF000000L", + "blacklisted_combo_input_description": "Reset game 7", + "blacklisted_combo_input_components": [ + { + "component_input_alias": "Minus", + "component_input_value": "0x01017F7F7F7F0000L" + }, + { + "component_input_alias": "Plus", + "component_input_value": "0x02027F7F7F7F0000L" + }, + { + "component_input_alias": "Shake", + "component_input_value": "0x04007F7F7F7F0000L" + }, + { + "component_input_alias": "Home", + "component_input_value": "0x08007F7F7F7F0000L" + }, + { + "component_input_alias": "PUp", + "component_input_value": "0x00007F7F7F000000L" + }, + { + "component_input_alias": "PRight", + "component_input_value": "0x00007F7FFF7F0000L" + } + ] + }, + { + "blacklisted_combo_input_string": "Minus+Plus+Shake+Home+PDown+PRight", + "blacklisted_combo_input_size": 6, + "blacklisted_combo_input_value": "0x0F037F7FFFFF0000L", + "blacklisted_combo_input_description": "Reset game 8", + "blacklisted_combo_input_components": [ + { + "component_input_alias": "Minus", + "component_input_value": "0x01017F7F7F7F0000L" + }, + { + "component_input_alias": "Plus", + "component_input_value": "0x02027F7F7F7F0000L" + }, + { + "component_input_alias": "Shake", + "component_input_value": "0x04007F7F7F7F0000L" + }, + { + "component_input_alias": "Home", + "component_input_value": "0x08007F7F7F7F0000L" + }, + { + "component_input_alias": "PDown", + "component_input_value": "0x00007F7F7FFF0000L" + }, + { + "component_input_alias": "PRight", + "component_input_value": "0x00007F7FFF7F0000L" + } + ] + } + ] +} \ No newline at end of file diff --git a/backend/gcn_rvl_sideways_controller.json b/backend/gcn_rvl_sideways_controller.json new file mode 100644 index 00000000..fd07d671 --- /dev/null +++ b/backend/gcn_rvl_sideways_controller.json @@ -0,0 +1,25937 @@ +[ + { + "input_value": "0x00007F7F7F7F0000L", + "input_name": "Neutral", + "input_alias": [ + "Neutral" + ], + "color_value": "#000000", + "is_blacklisted": true, + "opposite_input_value": "0x00007F7F7F7F0000L", + "opposite_input_name": "Neutral", + "has_opposite": false, + "input_type": 0, + "keyboard_value": null, + "keyboard_key_name": null + }, + { + "input_value": "0x01017F7F7F7F0000L", + "input_name": "Minus", + "input_alias": [ + "Minyus", + "Minuys", + "Minsu", + "Minsuy", + "Minsyu", + "Minuss", + "Minyuss", + "Minuyss", + "Sekect", + "SKT", + "Sek", + "Sekecy", + "Sekec", + "Sekecc", + "Seket", + "Sk", + "Select", + "SLT", + "Sel", + "Minus", + "-", + "Selecy", + "Selec", + "Selecc", + "SE", + "Selet", + "SL", + "Selct", + "Selkect", + "Selkct", + "Sekect", + "Sekct" + ], + "color_value": "#EEEEEE", + "is_blacklisted": false, + "opposite_input_value": "0x01017F7F7F7F0000L", + "opposite_input_name": "Minus", + "has_opposite": false, + "input_type": 1, + "keyboard_value": 81, + "keyboard_key_name": "Q" + }, + { + "input_value": "0x02027F7F7F7F0000L", + "input_name": "Plus", + "input_alias": [ + "Plyus", + "Pluys", + "Plsu", + "Plsuy", + "Plsyu", + "Pluss", + "Plyuss", + "Pluyss", + "Starst", + "Stasrt", + "Stast", + "Map", + "Astqrt", + "Stqrt", + "Stqrtt", + "ASatarrt", + "Satrrat", + "Satarrt", + "Satarry", + "Satarrtt", + "Satearrt", + "Satearr", + "Sataerrt", + "Sataerr", + "AAtarrt", + "Atrrat", + "Atarrt", + "Atarry", + "Atarrtt", + "Atearrt", + "Atearr", + "Ataerrt", + "Ataerr", + "Inventorry", + "Enterr", + "Stsrrt", + "Astarrt", + "Strrat", + "Sarrt", + "Starrt", + "Starry", + "Starrtt", + "Stearrt", + "Stearr", + "Staerrt", + "Staerr", + "Syarrt", + "Syarry", + "ASatart", + "Satrat", + "Sat", + "Satar", + "Satarr", + "Satart", + "Satary", + "Satat", + "Satatt", + "Sataty", + "Satartt", + "Sateart", + "Satear", + "Sataert", + "Sataer", + "AAtart", + "Atrat", + "Atar", + "Atarr", + "Atart", + "Atary", + "Atat", + "Atatt", + "Ataty", + "Atartt", + "Ateart", + "Atear", + "Ataert", + "Ataer", + "Continue", + "Contnue", + "Items", + "Itens", + "Inventory", + "Enter", + "Save", + "Savestate", + "Pasue", + "Stsrt", + "Option", + "Options", + "Puase", + "Unpuase", + "Unpause", + "Play", + "Astart", + "Strat", + "+", + "Pause", + "Plus", + "Sart", + "ST", + "Star", + "Starr", + "Tart", + "Start", + "Stary", + "Stat", + "Statt", + "Staty", + "Startt", + "Steart", + "Stear", + "Staert", + "Staer", + "Syart", + "Syary", + "Syaty", + "Menu", + "MainMenu", + "Dysty" + ], + "color_value": "#EEEEEE", + "is_blacklisted": false, + "opposite_input_value": "0x02027F7F7F7F0000L", + "opposite_input_name": "Plus", + "has_opposite": false, + "input_type": 1, + "keyboard_value": 87, + "keyboard_key_name": "W" + }, + { + "input_value": "0x04007F7F7F7F0000L", + "input_name": "Shake", + "input_alias": [ + "Shae", + "Shaek", + "Shkae", + "Sheka", + "Shake" + ], + "color_value": "#5600AE", + "is_blacklisted": false, + "opposite_input_value": "0x04007F7F7F7F0000L", + "opposite_input_name": "Shake", + "has_opposite": false, + "input_type": 1, + "keyboard_value": 69, + "keyboard_key_name": "E" + }, + { + "input_value": "0x08007F7F7F7F0000L", + "input_name": "Home", + "input_alias": [ + "Home" + ], + "color_value": "#FF3232", + "is_blacklisted": true, + "opposite_input_value": "0x08007F7F7F7F0000L", + "opposite_input_name": "Home", + "has_opposite": false, + "input_type": 1, + "keyboard_value": 10, + "keyboard_key_name": "Enter" + }, + { + "input_value": "0x10007F7F7F7F0000L", + "input_name": "Two", + "input_alias": [ + "Two" + ], + "color_value": "#FF3232", + "is_blacklisted": false, + "opposite_input_value": "0x10007F7F7F7F0000L", + "opposite_input_name": "Two", + "has_opposite": false, + "input_type": 1, + "keyboard_value": 10, + "keyboard_key_name": "Enter" + }, + { + "input_value": "0x20007F7F7F7F0000L", + "input_name": "One", + "input_alias": [ + "One" + ], + "color_value": "#FF3232", + "is_blacklisted": false, + "opposite_input_value": "0x20007F7F7F7F0000L", + "opposite_input_name": "One", + "has_opposite": false, + "input_type": 1, + "keyboard_value": 10, + "keyboard_key_name": "Enter" + }, + { + "input_value": "0x40007F7F7F7F0000L", + "input_name": "B", + "input_alias": [ + "B", + "Hammer", + "Kick", + "Slide", + "Punch", + "Dive", + "Dicve", + "Divce", + "Dice", + "Talk", + "Attack" + ], + "color_value": "#FF3232", + "is_blacklisted": false, + "opposite_input_value": "0x40007F7F7F7F0000L", + "opposite_input_name": "B", + "has_opposite": false, + "input_type": 1, + "keyboard_value": 90, + "keyboard_key_name": "Z" + }, + { + "input_value": "0x80007F7F7F7F0000L", + "input_name": "A", + "input_alias": [ + "JuningJp", + "Jun0ingJp", + "Jun[ingJp", + "JunpingJp", + "JunoingJp", + "JunJp", + "Jun0Jp", + "Jun[Jp", + "JunpJp", + "JunoJp", + "RumingJp", + "Rum0ingJp", + "Rum[ingJp", + "RumpingJp", + "RumoingJp", + "RumJp", + "Rum0Jp", + "Rum[Jp", + "RumpJp", + "RumoJp", + "JmuingJp", + "JmJpingU0", + "JmJpingU[", + "Jmu0ingJp", + "Jmu[ingJp", + "JmJping", + "JmJpingJp", + "LongJmJping", + "JmJpbing", + "JmuoingJp", + "JmuJp", + "JmJpU0", + "JmJpU[", + "Jmu0Jp", + "Jmu[Jp", + "JmJp", + "JmJpJp", + "LongJmJp", + "JmJpb", + "JmuoJp", + "JmingJp", + "Jm0ingJp", + "Jm[ingJp", + "JmpingJp", + "JmoingJp", + "Jm0Jp", + "Jm[Jp", + "JmpJp", + "JmoJp", + "JumingJp", + "Jum0ingJp", + "Jum[ingJp", + "JumpingJp", + "JumoingJp", + "JumJp", + "Jum0Jp", + "Jum[Jp", + "JumpJp", + "JumoJp", + "JuningU0", + "JuningU[", + "Juning", + "Juningup", + "LongJuning", + "Junbing", + "Jun0ingU0", + "Jun[ingU0", + "JunpingU0", + "JunoingU0", + "Jun0ingU[", + "Jun[ingU[", + "JunpingU[", + "JunoingU[", + "Jun0ing", + "Jun0ingup", + "LongJun0ing", + "Jun0ping", + "Jun0bing", + "Jun0oing", + "Jun[ing", + "Jun[ingup", + "LongJun[ing", + "Jun[ping", + "Jun[bing", + "Jun[oing", + "Junping", + "Junpingup", + "LongJunping", + "Junmping", + "Junpbing", + "Junoing", + "Junoingup", + "LongJunoing", + "Junmoing", + "Junobing", + "JunU0", + "JunU[", + "Jun", + "Junup", + "LongJun", + "Junb", + "Jun0U0", + "Jun[U0", + "JunpU0", + "JunoU0", + "Jun0U[", + "Jun[U[", + "JunpU[", + "JunoU[", + "Jun0", + "Jun0up", + "LongJun0", + "Jun0p", + "Jun0b", + "Jun0o", + "Jun[", + "Jun[up", + "LongJun[", + "Jun[p", + "Jun[b", + "Jun[o", + "Junp", + "Junpup", + "LongJunp", + "Junmp", + "Junpb", + "Juno", + "Junoup", + "LongJuno", + "Junmo", + "Junob", + "RumingU0", + "RumingU[", + "Ruming", + "Rumingup", + "LongRuming", + "Rumbing", + "Rum0ingU0", + "Rum[ingU0", + "RumpingU0", + "RumoingU0", + "Rum0ingU[", + "Rum[ingU[", + "RumpingU[", + "RumoingU[", + "Rum0ing", + "Rum0ingup", + "LongRum0ing", + "Rum0ping", + "Rum0bing", + "Rum0oing", + "Rum[ing", + "Rum[ingup", + "LongRum[ing", + "Rum[ping", + "Rum[bing", + "Rum[oing", + "Rumping", + "Rumpingup", + "LongRumping", + "Rummping", + "Rumpbing", + "Rumoing", + "Rumoingup", + "LongRumoing", + "Rummoing", + "Rumobing", + "RumU0", + "RumU[", + "Rum", + "Rumup", + "LongRum", + "Rumb", + "Rum0U0", + "Rum[U0", + "RumpU0", + "RumoU0", + "Rum0U[", + "Rum[U[", + "RumpU[", + "RumoU[", + "Rum0", + "Rum0up", + "LongRum0", + "Rum0p", + "Rum0b", + "Rum0o", + "Rum[", + "Rum[up", + "LongRum[", + "Rum[p", + "Rum[b", + "Rum[o", + "Rump", + "Rumpup", + "LongRump", + "Rummp", + "Rumpb", + "Rumo", + "Rumoup", + "LongRumo", + "Rummo", + "Rumob", + "JmuingU0", + "JmuingU[", + "Jmuing", + "Jmuingup", + "LongJmuing", + "Jmubing", + "Jmu0ingU0", + "Jmu[ingU0", + "JmupingU0", + "JmuoingU0", + "Jmu0ingU[", + "Jmu[ingU[", + "JmupingU[", + "JmuoingU[", + "Jmu0ing", + "Jmu0ingup", + "LongJmu0ing", + "Jmu0ping", + "Jmu0bing", + "Jmu0oing", + "Jmu[ing", + "Jmu[ingup", + "LongJmu[ing", + "Jmu[ping", + "Jmu[bing", + "Jmu[oing", + "Jmuping", + "Jmupingup", + "LongJmuping", + "Jmumping", + "Jmupbing", + "Jmuoing", + "Jmuoingup", + "LongJmuoing", + "Jmumoing", + "Jmuobing", + "JmuU0", + "JmuU[", + "Jmu", + "Jmuup", + "LongJmu", + "Jmub", + "Jmu0U0", + "Jmu[U0", + "JmupU0", + "JmuoU0", + "Jmu0U[", + "Jmu[U[", + "JmupU[", + "JmuoU[", + "Jmu0", + "Jmu0up", + "LongJmu0", + "Jmu0p", + "Jmu0b", + "Jmu0o", + "Jmu[", + "Jmu[up", + "LongJmu[", + "Jmu[p", + "Jmu[b", + "Jmu[o", + "Jmup", + "Jmupup", + "LongJmup", + "Jmump", + "Jmupb", + "Jmuo", + "Jmuoup", + "LongJmuo", + "Jmumo", + "Jmuob", + "JmingU0", + "JmingU[", + "Jming", + "Jmingup", + "LongJming", + "Jmbing", + "Jm0ingU0", + "Jm[ingU0", + "JmpingU0", + "JmoingU0", + "Jm0ingU[", + "Jm[ingU[", + "JmpingU[", + "JmoingU[", + "Jm0ing", + "Jm0ingup", + "LongJm0ing", + "Jm0ping", + "Jm0bing", + "Jm0oing", + "Jm[ing", + "Jm[ingup", + "LongJm[ing", + "Jm[ping", + "Jm[bing", + "Jm[oing", + "Jmping", + "Jmpingup", + "LongJmping", + "Jmmping", + "Jmpbing", + "Jmoing", + "Jmoingup", + "LongJmoing", + "Jmmoing", + "Jmobing", + "Jm", + "LongJm", + "Jmb", + "Jm0U0", + "Jm[U0", + "JmpU0", + "JmoU0", + "Jm0U[", + "Jm[U[", + "JmpU[", + "JmoU[", + "Jm0", + "Jm0up", + "LongJm0", + "Jm0p", + "Jm0b", + "Jm0o", + "Jm[", + "Jm[up", + "LongJm[", + "Jm[p", + "Jm[b", + "Jm[o", + "Jmp", + "Jmpup", + "LongJmp", + "Jmmp", + "Jmpb", + "Jmo", + "Jmoup", + "LongJmo", + "Jmmo", + "Jmob", + "Fly", + "A", + "Click", + "JumingU0", + "JumingU[", + "Juming", + "Jumingup", + "LongJuming", + "Jumbing", + "Jum0ingU0", + "Jum[ingU0", + "JumpingU0", + "JumoingU0", + "Jum0ingU[", + "Jum[ingU[", + "JumpingU[", + "JumoingU[", + "Jum0ing", + "Jum0ingup", + "LongJum0ing", + "Jum0ping", + "Jum0bing", + "Jum0oing", + "Jum[ing", + "Jum[ingup", + "LongJum[ing", + "Jum[ping", + "Jum[bing", + "Jum[oing", + "Jumping", + "Jumpingup", + "Longjumping", + "Jummping", + "Jumpbing", + "Jumoing", + "Jumoingup", + "Longjumoing", + "Jummoing", + "Jumobing", + "JumU0", + "JumU[", + "Jum", + "Jumup", + "LongJum", + "Jumb", + "Jum0U0", + "Jum[U0", + "JumpU0", + "JumoU0", + "Jum0U[", + "Jum[U[", + "JumpU[", + "JumoU[", + "Jum0", + "Jum0up", + "LongJum0", + "Jum0p", + "Jum0b", + "Jum0o", + "Jum[", + "Jum[up", + "LongJum[", + "Jum[p", + "Jum[b", + "Jum[o", + "Jump", + "Jumpup", + "Longjump", + "BLJ", + "LBLJ", + "SBLJ", + "LSBLJ", + "Jummp", + "Jumpb", + "Jumo", + "Jumoup", + "Longjumo", + "Jummo", + "Jumob", + "Swim" + ], + "color_value": "#0000FF", + "is_blacklisted": false, + "opposite_input_value": "0x80007F7F7F7F0000L", + "opposite_input_name": "A", + "has_opposite": false, + "input_type": 1, + "keyboard_value": 88, + "keyboard_key_name": "x" + }, + { + "input_value": "0x00047F7F7F7F0000L", + "input_name": "Macro", + "input_alias": [ + "Macro" + ], + "color_value": "#0000FF", + "is_blacklisted": true, + "opposite_input_value": "0x00047F7F7F7F0000L", + "opposite_input_name": "Macro", + "has_opposite": false, + "input_type": 1, + "keyboard_value": 88, + "keyboard_key_name": "x" + }, + { + "input_value": "0x00087F7F7F7F0000L", + "input_name": "Turbo", + "input_alias": [ + "Turbo" + ], + "color_value": "#0000FF", + "is_blacklisted": true, + "opposite_input_value": "0x00087F7F7F7F0000L", + "opposite_input_name": "Turbo", + "has_opposite": false, + "input_type": 1, + "keyboard_value": 88, + "keyboard_key_name": "x" + }, + { + "input_value": "0x00107F7F7F7F0000L", + "input_name": "^", + "input_alias": [ + "DFprwrddJp", + "DpadFprwrddJp", + "DFprwrdfJp", + "DpadFprwrdfJp", + "DFprwrdJp", + "DFprwrdsJp", + "DpadFprwrdJp", + "DpadFprwrdsJp", + "DFprwrJp", + "DFprwrsJp", + "DpadFprwrJp", + "DpadFprwrsJp", + "DFprwrssJp", + "DpadFprwrssJp", + "DFprwarddJp", + "DpadFprwarddJp", + "DFprwardfJp", + "DpadFprwardfJp", + "DFprwardJp", + "DFprwardsJp", + "DpadFprwardJp", + "DpadFprwardsJp", + "DFprwarJp", + "DFprwarsJp", + "DpadFprwarJp", + "DpadFprwarsJp", + "DFprwarssJp", + "DpadFprwarssJp", + "DFprwordJp", + "DFprwordsJp", + "DpadFprwordJp", + "DpadFprwordsJp", + "DFprworJp", + "DFprworsJp", + "DpadFprworJp", + "DpadFprworsJp", + "DFprworssJp", + "DpadFprworssJp", + "DFprwrddU0", + "DpadFprwrddU0", + "DFprwrdfU0", + "DpadFprwrdfU0", + "DFprwrdU0", + "DFprwrdsU0", + "DpadFprwrdU0", + "DpadFprwrdsU0", + "DFprwrU0", + "DFprwrsU0", + "DpadFprwrU0", + "DpadFprwrsU0", + "DFprwrssU0", + "DpadFprwrssU0", + "DFprwrddU[", + "DpadFprwrddU[", + "DFprwrdfU[", + "DpadFprwrdfU[", + "DFprwrdU[", + "DFprwrdsU[", + "DpadFprwrdU[", + "DpadFprwrdsU[", + "DFprwrU[", + "DFprwrsU[", + "DpadFprwrU[", + "DpadFprwrsU[", + "DFprwrssU[", + "DpadFprwrssU[", + "DFprwrddup", + "DpadFprwrddup", + "DFprwrdfup", + "DpadFprwrdfup", + "DFprwrdup", + "DFprwrdsup", + "DpadFprwrdup", + "DpadFprwrdsup", + "DFprwrup", + "DFprwrsup", + "DpadFprwrup", + "DpadFprwrsup", + "DFprwrssup", + "DpadFprwrssup", + "DFFprwrdd", + "DpadFFprwrdd", + "DFFprwrdf", + "DpadFFprwrdf", + "DFFprwrd", + "DFFprwrds", + "DpadFFprwrd", + "DpadFFprwrds", + "DFFprwr", + "DFFprwrs", + "DpadFFprwr", + "DpadFFprwrs", + "DFFprwrss", + "DpadFFprwrss", + "DFprwrdd", + "DpadFprwrdd", + "DFprwrdf", + "DpadFprwrdf", + "DFprwrd", + "DFprwrds", + "DpadFprwrd", + "DpadFprwrds", + "DFprwr", + "DFprwrs", + "DpadFprwr", + "DpadFprwrs", + "DFprwrss", + "DpadFprwrss", + "DFpwrd", + "DFpwrds", + "DpadFpwrd", + "DpadFpwrds", + "DFpwr", + "DFpwrs", + "DpadFpwr", + "DpadFpwrs", + "DFpwrss", + "DpadFpwrss", + "DFprwarddU0", + "DpadFprwarddU0", + "DFprwardfU0", + "DpadFprwardfU0", + "DFprwardU0", + "DFprwardsU0", + "DpadFprwardU0", + "DpadFprwardsU0", + "DFprwarU0", + "DFprwarsU0", + "DpadFprwarU0", + "DpadFprwarsU0", + "DFprwarssU0", + "DpadFprwarssU0", + "DFprwordU0", + "DFprwordsU0", + "DpadFprwordU0", + "DpadFprwordsU0", + "DFprworU0", + "DFprworsU0", + "DpadFprworU0", + "DpadFprworsU0", + "DFprworssU0", + "DpadFprworssU0", + "DFprwarddU[", + "DpadFprwarddU[", + "DFprwardfU[", + "DpadFprwardfU[", + "DFprwardU[", + "DFprwardsU[", + "DpadFprwardU[", + "DpadFprwardsU[", + "DFprwarU[", + "DFprwarsU[", + "DpadFprwarU[", + "DpadFprwarsU[", + "DFprwarssU[", + "DpadFprwarssU[", + "DFprwordU[", + "DFprwordsU[", + "DpadFprwordU[", + "DpadFprwordsU[", + "DFprworU[", + "DFprworsU[", + "DpadFprworU[", + "DpadFprworsU[", + "DFprworssU[", + "DpadFprworssU[", + "DFprwarddup", + "DpadFprwarddup", + "DFprwardfup", + "DpadFprwardfup", + "DFprwardup", + "DFprwardsup", + "DpadFprwardup", + "DpadFprwardsup", + "DFprwarup", + "DFprwarsup", + "DpadFprwarup", + "DpadFprwarsup", + "DFprwarssup", + "DpadFprwarssup", + "DFprwordup", + "DFprwordsup", + "DpadFprwordup", + "DpadFprwordsup", + "DFprworup", + "DFprworsup", + "DpadFprworup", + "DpadFprworsup", + "DFprworssup", + "DpadFprworssup", + "DFFprwardd", + "DpadFFprwardd", + "DFFprwardf", + "DpadFFprwardf", + "DFFprward", + "DFFprwards", + "DpadFFprward", + "DpadFFprwards", + "DFFprwar", + "DFFprwars", + "DpadFFprwar", + "DpadFFprwars", + "DFFprwarss", + "DpadFFprwarss", + "DFFprword", + "DFFprwords", + "DpadFFprword", + "DpadFFprwords", + "DFFprwor", + "DFFprwors", + "DpadFFprwor", + "DpadFFprwors", + "DFFprworss", + "DpadFFprworss", + "DFprwardd", + "DpadFprwardd", + "DFprwardf", + "DpadFprwardf", + "DFprward", + "DFprwards", + "DpadFprward", + "DpadFprwards", + "DFprwar", + "DFprwars", + "DpadFprwar", + "DpadFprwars", + "DFprwarss", + "DpadFprwarss", + "DFprword", + "DFprwords", + "DpadFprword", + "DpadFprwords", + "DFprwor", + "DFprwors", + "DpadFprwor", + "DpadFprwors", + "DFprworss", + "DpadFprworss", + "DFpword", + "DFpwords", + "DpadFpword", + "DpadFpwords", + "DFpwor", + "DFpwors", + "DpadFpwor", + "DpadFpwors", + "DFpworss", + "DpadFpworss", + "DFpward", + "DFpwards", + "DpadFpward", + "DpadFpwards", + "DFpwar", + "DFpwars", + "DpadFpwar", + "DpadFpwars", + "DFpwarss", + "DpadFpwarss", + "UpD", + "UpDpad", + "DForwrddJp", + "DpadForwrddJp", + "DForwrdfJp", + "DpadForwrdfJp", + "DForwrdJp", + "DForwrdsJp", + "DpadForwrdJp", + "DpadForwrdsJp", + "DForwrJp", + "DForwrsJp", + "DpadForwrJp", + "DpadForwrsJp", + "DForwrssJp", + "DpadForwrssJp", + "DForwarddJp", + "DpadForwarddJp", + "DForwardfJp", + "DpadForwardfJp", + "DForwardJp", + "DForwardsJp", + "DpadForwardJp", + "DpadForwardsJp", + "DForwarJp", + "DForwarsJp", + "DpadForwarJp", + "DpadForwarsJp", + "DForwarssJp", + "DpadForwarssJp", + "DForwordJp", + "DForwordsJp", + "DpadForwordJp", + "DpadForwordsJp", + "DForworJp", + "DForworsJp", + "DpadForworJp", + "DpadForworsJp", + "DForworssJp", + "DpadForworssJp", + "DJp", + "DJpo", + "DJpp", + "DJppo", + "DpadJp", + "DpadJpo", + "DpadJpp", + "DpadJppo", + "DNort", + "DpadNort", + "DForwrddU0", + "DpadForwrddU0", + "DForwrdfU0", + "DpadForwrdfU0", + "DForwrdU0", + "DForwrdsU0", + "DpadForwrdU0", + "DpadForwrdsU0", + "DForwrU0", + "DForwrsU0", + "DpadForwrU0", + "DpadForwrsU0", + "DForwrssU0", + "DpadForwrssU0", + "DForwrddU[", + "DpadForwrddU[", + "DForwrdfU[", + "DpadForwrdfU[", + "DForwrdU[", + "DForwrdsU[", + "DpadForwrdU[", + "DpadForwrdsU[", + "DForwrU[", + "DForwrsU[", + "DpadForwrU[", + "DpadForwrsU[", + "DForwrssU[", + "DpadForwrssU[", + "DForwrddup", + "DpadForwrddup", + "DForwrdfup", + "DpadForwrdfup", + "DForwrdup", + "DForwrdsup", + "DpadForwrdup", + "DpadForwrdsup", + "DForwrup", + "DForwrsup", + "DpadForwrup", + "DpadForwrsup", + "DForwrssup", + "DpadForwrssup", + "DFforwrdd", + "DpadFforwrdd", + "DFforwrdf", + "DpadFforwrdf", + "DFforwrd", + "DFforwrds", + "DpadFforwrd", + "DpadFforwrds", + "DFforwr", + "DFforwrs", + "DpadFforwr", + "DpadFforwrs", + "DFforwrss", + "DpadFforwrss", + "DFirwrdd", + "DpadFirwrdd", + "DFirwrdf", + "DpadFirwrdf", + "DFirwrd", + "DFirwrds", + "DpadFirwrd", + "DpadFirwrds", + "DFirwr", + "DFirwrs", + "DpadFirwr", + "DpadFirwrs", + "DFirwrss", + "DpadFirwrss", + "DFrwrdd", + "DpadFrwrdd", + "DFrwrdf", + "DpadFrwrdf", + "DFrwrd", + "DFrwrds", + "DpadFrwrd", + "DpadFrwrds", + "DFrwr", + "DFrwrs", + "DpadFrwr", + "DpadFrwrs", + "DFrwrss", + "DpadFrwrss", + "DForwrdd", + "DpadForwrdd", + "DForwrdf", + "DpadForwrdf", + "DForwrd", + "DForwrds", + "DpadForwrd", + "DpadForwrds", + "DForwr", + "DForwrs", + "DpadForwr", + "DpadForwrs", + "DForwrss", + "DpadForwrss", + "DFowrd", + "DFowrds", + "DpadFowrd", + "DpadFowrds", + "DFowr", + "DFowrs", + "DpadFowr", + "DpadFowrs", + "DFowrss", + "DpadFowrss", + "DNorht", + "DpadNorht", + "DForwarddU0", + "DpadForwarddU0", + "DForwardfU0", + "DpadForwardfU0", + "DForwardU0", + "DForwardsU0", + "DpadForwardU0", + "DpadForwardsU0", + "DForwarU0", + "DForwarsU0", + "DpadForwarU0", + "DpadForwarsU0", + "DForwarssU0", + "DpadForwarssU0", + "DForwordU0", + "DForwordsU0", + "DpadForwordU0", + "DpadForwordsU0", + "DForworU0", + "DForworsU0", + "DpadForworU0", + "DpadForworsU0", + "DForworssU0", + "DpadForworssU0", + "DU0", + "DU0o", + "DU0p", + "DU0po", + "DpadU0", + "DpadU0o", + "DpadU0p", + "DpadU0po", + "DForwarddU[", + "DpadForwarddU[", + "DForwardfU[", + "DpadForwardfU[", + "DForwardU[", + "DForwardsU[", + "DpadForwardU[", + "DpadForwardsU[", + "DForwarU[", + "DForwarsU[", + "DpadForwarU[", + "DpadForwarsU[", + "DForwarssU[", + "DpadForwarssU[", + "DForwordU[", + "DForwordsU[", + "DpadForwordU[", + "DpadForwordsU[", + "DForworU[", + "DForworsU[", + "DpadForworU[", + "DpadForworsU[", + "DForworssU[", + "DpadForworssU[", + "DU[", + "DU[o", + "DU[p", + "DU[po", + "DpadU[", + "DpadU[o", + "DpadU[p", + "DpadU[po", + "DForwarddup", + "DpadForwarddup", + "DForwardfup", + "DpadForwardfup", + "DForwardup", + "DForwardsup", + "DpadForwardup", + "DpadForwardsup", + "DForwarup", + "DForwarsup", + "DpadForwarup", + "DpadForwarsup", + "DForwarssup", + "DpadForwarssup", + "DForwordup", + "DForwordsup", + "DpadForwordup", + "DpadForwordsup", + "DForworup", + "DForworsup", + "DpadForworup", + "DpadForworsup", + "DForworssup", + "DpadForworssup", + "DFforwardd", + "DpadFforwardd", + "DFforwardf", + "DpadFforwardf", + "DFforward", + "DFforwards", + "DpadFforward", + "DpadFforwards", + "DFforwar", + "DFforwars", + "DpadFforwar", + "DpadFforwars", + "DFforwarss", + "DpadFforwarss", + "DFforword", + "DFforwords", + "DpadFforword", + "DpadFforwords", + "DFforwor", + "DFforwors", + "DpadFforwor", + "DpadFforwors", + "DFforworss", + "DpadFforworss", + "DFirwardd", + "DpadFirwardd", + "DFirwardf", + "DpadFirwardf", + "DFirward", + "DFirwards", + "DpadFirward", + "DpadFirwards", + "DFirwar", + "DFirwars", + "DpadFirwar", + "DpadFirwars", + "DFirwarss", + "DpadFirwarss", + "DFirword", + "DFirwords", + "DpadFirword", + "DpadFirwords", + "DFirwor", + "DFirwors", + "DpadFirwor", + "DpadFirwors", + "DFirworss", + "DpadFirworss", + "DFrwardd", + "DpadFrwardd", + "DFrwardf", + "DpadFrwardf", + "DFrward", + "DFrwards", + "DpadFrward", + "DpadFrwards", + "DFrwar", + "DFrwars", + "DpadFrwar", + "DpadFrwars", + "DFrwarss", + "DpadFrwarss", + "DFrword", + "DFrwords", + "DpadFrword", + "DpadFrwords", + "DFrwor", + "DFrwors", + "DpadFrwor", + "DpadFrwors", + "DFrworss", + "DpadFrworss", + "DForwardd", + "DpadForwardd", + "DForwardf", + "DpadForwardf", + "Dup", + "DU", + "D^", + "D↑", + "D▲", + "DNorth", + "DN", + "DUo", + "DUpo", + "DUop", + "DUopo", + "DYp", + "DY", + "DYo", + "DYpo", + "DYop", + "DYopo", + "DIp", + "DI", + "DIpo", + "Dupp", + "DUppo", + "DUopp", + "DUoppo", + "DYpp", + "DYppo", + "DYopp", + "DYoppo", + "DIpp", + "DIppo", + "DNoth", + "Dpadup", + "DpadU", + "Dpad^", + "Dpad↑", + "Dpad▲", + "DpadNorth", + "DpadN", + "DpadUo", + "DpadUpo", + "DpadUop", + "DpadUopo", + "DpadYp", + "DpadY", + "DpadYo", + "DpadYpo", + "DpadYop", + "DpadYopo", + "DpadIp", + "DpadI", + "DpadIpo", + "Dpadupp", + "DpadUppo", + "DpadUopp", + "DpadUoppo", + "DpadYpp", + "DpadYppo", + "DpadYopp", + "DpadYoppo", + "DpadIpp", + "DpadIppo", + "DpadNoth", + "DForward", + "DForwards", + "DFront", + "DpadForward", + "DpadForwards", + "DpadFront", + "DForwar", + "DForwars", + "DpadForwar", + "DpadForwars", + "DForwarss", + "DpadForwarss", + "DForword", + "DForwords", + "DpadForword", + "DpadForwords", + "DForwor", + "DForwors", + "DpadForwor", + "DpadForwors", + "DForworss", + "DpadForworss", + "DFoword", + "DFowords", + "DpadFoword", + "DpadFowords", + "DFowor", + "DFowors", + "DpadFowor", + "DpadFowors", + "DFoworss", + "DpadFoworss", + "DFoward", + "DFowards", + "DpadFoward", + "DpadFowards", + "DFowar", + "DFowars", + "DpadFowar", + "DpadFowars", + "DFowarss", + "DpadFowarss", + "LeftStickUp", + "LeftStickU", + "LStickUp", + "LStickU", + "StickUp", + "StickU", + "FprwrddJp", + "AFprwrddJp", + "WalkFprwrddJp", + "MoveFprwrddJp", + "MvoeFprwrddJp", + "FprwrdfJp", + "AFprwrdfJp", + "WalkFprwrdfJp", + "MoveFprwrdfJp", + "MvoeFprwrdfJp", + "FprwrdJp", + "FprwrdsJp", + "AFprwrdJp", + "AFprwrdsJp", + "FprwrJp", + "FprwrsJp", + "AFprwrJp", + "AFprwrsJp", + "FprwrssJp", + "AFprwrssJp", + "WalkFprwrJp", + "MoveFprwrJp", + "MvoeFprwrJp", + "WalkFprwrsJp", + "MoveFprwrsJp", + "MvoeFprwrsJp", + "WalkFprwrdJp", + "MoveFprwrdJp", + "MvoeFprwrdJp", + "WalkFprwrdsJp", + "MoveFprwrdsJp", + "MvoeFprwrdsJp", + "WalkFprwrssJp", + "MoveFprwrssJp", + "MvoeFprwrssJp", + "FprwarddJp", + "AFprwarddJp", + "WalkFprwarddJp", + "MoveFprwarddJp", + "MvoeFprwarddJp", + "FprwardfJp", + "AFprwardfJp", + "WalkFprwardfJp", + "MoveFprwardfJp", + "MvoeFprwardfJp", + "FprwardJp", + "FprwardsJp", + "AFprwardJp", + "AFprwardsJp", + "FprwarJp", + "FprwarsJp", + "AFprwarJp", + "AFprwarsJp", + "FprwarssJp", + "AFprwarssJp", + "WalkFprwarJp", + "MoveFprwarJp", + "MvoeFprwarJp", + "WalkFprwarsJp", + "MoveFprwarsJp", + "MvoeFprwarsJp", + "WalkFprwardJp", + "MoveFprwardJp", + "MvoeFprwardJp", + "WalkFprwardsJp", + "MoveFprwardsJp", + "MvoeFprwardsJp", + "WalkFprwarssJp", + "MoveFprwarssJp", + "MvoeFprwarssJp", + "FprwordJp", + "FprwordsJp", + "AFprwordJp", + "AFprwordsJp", + "FprworJp", + "FprworsJp", + "AFprworJp", + "AFprworsJp", + "FprworssJp", + "AFprworssJp", + "WalkFprworJp", + "MoveFprworJp", + "MvoeFprworJp", + "WalkFprworsJp", + "MoveFprworsJp", + "MvoeFprworsJp", + "WalkFprwordJp", + "MoveFprwordJp", + "MvoeFprwordJp", + "WalkFprwordsJp", + "MoveFprwordsJp", + "MvoeFprwordsJp", + "WalkFprworssJp", + "MoveFprworssJp", + "MvoeFprworssJp", + "Fprwarf", + "FprwrddU0", + "AFprwrddU0", + "WalkFprwrddU0", + "MoveFprwrddU0", + "MvoeFprwrddU0", + "FprwrdfU0", + "AFprwrdfU0", + "WalkFprwrdfU0", + "MoveFprwrdfU0", + "MvoeFprwrdfU0", + "FprwrdU0", + "FprwrdsU0", + "AFprwrdU0", + "AFprwrdsU0", + "FprwrU0", + "FprwrsU0", + "AFprwrU0", + "AFprwrsU0", + "FprwrssU0", + "AFprwrssU0", + "WalkFprwrU0", + "MoveFprwrU0", + "MvoeFprwrU0", + "WalkFprwrsU0", + "MoveFprwrsU0", + "MvoeFprwrsU0", + "WalkFprwrdU0", + "MoveFprwrdU0", + "MvoeFprwrdU0", + "WalkFprwrdsU0", + "MoveFprwrdsU0", + "MvoeFprwrdsU0", + "WalkFprwrssU0", + "MoveFprwrssU0", + "MvoeFprwrssU0", + "FprwrddU[", + "AFprwrddU[", + "WalkFprwrddU[", + "MoveFprwrddU[", + "MvoeFprwrddU[", + "FprwrdfU[", + "AFprwrdfU[", + "WalkFprwrdfU[", + "MoveFprwrdfU[", + "MvoeFprwrdfU[", + "FprwrdU[", + "FprwrdsU[", + "AFprwrdU[", + "AFprwrdsU[", + "FprwrU[", + "FprwrsU[", + "AFprwrU[", + "AFprwrsU[", + "FprwrssU[", + "AFprwrssU[", + "WalkFprwrU[", + "MoveFprwrU[", + "MvoeFprwrU[", + "WalkFprwrsU[", + "MoveFprwrsU[", + "MvoeFprwrsU[", + "WalkFprwrdU[", + "MoveFprwrdU[", + "MvoeFprwrdU[", + "WalkFprwrdsU[", + "MoveFprwrdsU[", + "MvoeFprwrdsU[", + "WalkFprwrssU[", + "MoveFprwrssU[", + "MvoeFprwrssU[", + "Fprwrddup", + "AFprwrddup", + "WalkFprwrddup", + "MoveFprwrddup", + "MvoeFprwrddup", + "Fprwrdfup", + "AFprwrdfup", + "WalkFprwrdfup", + "MoveFprwrdfup", + "MvoeFprwrdfup", + "Fprwrdup", + "Fprwrdsup", + "AFprwrdup", + "AFprwrdsup", + "Fprwrup", + "Fprwrsup", + "AFprwrup", + "AFprwrsup", + "Fprwrssup", + "AFprwrssup", + "WalkFprwrup", + "MoveFprwrup", + "MvoeFprwrup", + "WalkFprwrsup", + "MoveFprwrsup", + "MvoeFprwrsup", + "WalkFprwrdup", + "MoveFprwrdup", + "MvoeFprwrdup", + "WalkFprwrdsup", + "MoveFprwrdsup", + "MvoeFprwrdsup", + "WalkFprwrssup", + "MoveFprwrssup", + "MvoeFprwrssup", + "FFprwrdd", + "AFFprwrdd", + "WalkFFprwrdd", + "MoveFFprwrdd", + "MvoeFFprwrdd", + "FFprwrdf", + "AFFprwrdf", + "WalkFFprwrdf", + "MoveFFprwrdf", + "MvoeFFprwrdf", + "FFprwrd", + "FFprwrds", + "AFFprwrd", + "AFFprwrds", + "FFprwr", + "FFprwrs", + "AFFprwr", + "AFFprwrs", + "FFprwrss", + "AFFprwrss", + "WalkFFprwr", + "MoveFFprwr", + "MvoeFFprwr", + "WalkFFprwrs", + "MoveFFprwrs", + "MvoeFFprwrs", + "WalkFFprwrd", + "MoveFFprwrd", + "MvoeFFprwrd", + "WalkFFprwrds", + "MoveFFprwrds", + "MvoeFFprwrds", + "WalkFFprwrss", + "MoveFFprwrss", + "MvoeFFprwrss", + "Fprwrdd", + "AFprwrdd", + "WalkFprwrdd", + "MoveFprwrdd", + "MvoeFprwrdd", + "Fprwrdf", + "AFprwrdf", + "WalkFprwrdf", + "MoveFprwrdf", + "MvoeFprwrdf", + "Fprwrd", + "Fprwrds", + "AFprwrd", + "AFprwrds", + "Fprwr", + "Fprwrs", + "AFprwr", + "AFprwrs", + "Fprwrss", + "AFprwrss", + "WalkFprwr", + "MoveFprwr", + "MvoeFprwr", + "WalkFprwrs", + "MoveFprwrs", + "MvoeFprwrs", + "WalkFprwrd", + "MoveFprwrd", + "MvoeFprwrd", + "WalkFprwrds", + "MoveFprwrds", + "MvoeFprwrds", + "WalkFprwrss", + "MoveFprwrss", + "MvoeFprwrss", + "Fpwrd", + "Fpwrds", + "AFpwrd", + "AFpwrds", + "Fpwr", + "Fpwrs", + "AFpwr", + "AFpwrs", + "Fpwrss", + "AFpwrss", + "WalkFpwr", + "MoveFpwr", + "MvoeFpwr", + "WalkFpwrs", + "MoveFpwrs", + "MvoeFpwrs", + "WalkFpwrd", + "MoveFpwrd", + "MvoeFpwrd", + "WalkFpwrds", + "MoveFpwrds", + "MvoeFpwrds", + "WalkFpwrss", + "MoveFpwrss", + "MvoeFpwrss", + "FprwarddU0", + "AFprwarddU0", + "WalkFprwarddU0", + "MoveFprwarddU0", + "MvoeFprwarddU0", + "FprwardfU0", + "AFprwardfU0", + "WalkFprwardfU0", + "MoveFprwardfU0", + "MvoeFprwardfU0", + "FprwardU0", + "FprwardsU0", + "AFprwardU0", + "AFprwardsU0", + "FprwarU0", + "FprwarsU0", + "AFprwarU0", + "AFprwarsU0", + "FprwarssU0", + "AFprwarssU0", + "WalkFprwarU0", + "MoveFprwarU0", + "MvoeFprwarU0", + "WalkFprwarsU0", + "MoveFprwarsU0", + "MvoeFprwarsU0", + "WalkFprwardU0", + "MoveFprwardU0", + "MvoeFprwardU0", + "WalkFprwardsU0", + "MoveFprwardsU0", + "MvoeFprwardsU0", + "WalkFprwarssU0", + "MoveFprwarssU0", + "MvoeFprwarssU0", + "FprwordU0", + "FprwordsU0", + "AFprwordU0", + "AFprwordsU0", + "FprworU0", + "FprworsU0", + "AFprworU0", + "AFprworsU0", + "FprworssU0", + "AFprworssU0", + "WalkFprworU0", + "MoveFprworU0", + "MvoeFprworU0", + "WalkFprworsU0", + "MoveFprworsU0", + "MvoeFprworsU0", + "WalkFprwordU0", + "MoveFprwordU0", + "MvoeFprwordU0", + "WalkFprwordsU0", + "MoveFprwordsU0", + "MvoeFprwordsU0", + "WalkFprworssU0", + "MoveFprworssU0", + "MvoeFprworssU0", + "FprwarddU[", + "AFprwarddU[", + "WalkFprwarddU[", + "MoveFprwarddU[", + "MvoeFprwarddU[", + "FprwardfU[", + "AFprwardfU[", + "WalkFprwardfU[", + "MoveFprwardfU[", + "MvoeFprwardfU[", + "FprwardU[", + "FprwardsU[", + "AFprwardU[", + "AFprwardsU[", + "FprwarU[", + "FprwarsU[", + "AFprwarU[", + "AFprwarsU[", + "FprwarssU[", + "AFprwarssU[", + "WalkFprwarU[", + "MoveFprwarU[", + "MvoeFprwarU[", + "WalkFprwarsU[", + "MoveFprwarsU[", + "MvoeFprwarsU[", + "WalkFprwardU[", + "MoveFprwardU[", + "MvoeFprwardU[", + "WalkFprwardsU[", + "MoveFprwardsU[", + "MvoeFprwardsU[", + "WalkFprwarssU[", + "MoveFprwarssU[", + "MvoeFprwarssU[", + "FprwordU[", + "FprwordsU[", + "AFprwordU[", + "AFprwordsU[", + "FprworU[", + "FprworsU[", + "AFprworU[", + "AFprworsU[", + "FprworssU[", + "AFprworssU[", + "WalkFprworU[", + "MoveFprworU[", + "MvoeFprworU[", + "WalkFprworsU[", + "MoveFprworsU[", + "MvoeFprworsU[", + "WalkFprwordU[", + "MoveFprwordU[", + "MvoeFprwordU[", + "WalkFprwordsU[", + "MoveFprwordsU[", + "MvoeFprwordsU[", + "WalkFprworssU[", + "MoveFprworssU[", + "MvoeFprworssU[", + "Fprwarddup", + "AFprwarddup", + "WalkFprwarddup", + "MoveFprwarddup", + "MvoeFprwarddup", + "Fprwardfup", + "AFprwardfup", + "WalkFprwardfup", + "MoveFprwardfup", + "MvoeFprwardfup", + "Fprwardup", + "Fprwardsup", + "AFprwardup", + "AFprwardsup", + "Fprwarup", + "Fprwarsup", + "AFprwarup", + "AFprwarsup", + "Fprwarssup", + "AFprwarssup", + "WalkFprwarup", + "MoveFprwarup", + "MvoeFprwarup", + "WalkFprwarsup", + "MoveFprwarsup", + "MvoeFprwarsup", + "WalkFprwardup", + "MoveFprwardup", + "MvoeFprwardup", + "WalkFprwardsup", + "MoveFprwardsup", + "MvoeFprwardsup", + "WalkFprwarssup", + "MoveFprwarssup", + "MvoeFprwarssup", + "Fprwordup", + "Fprwordsup", + "AFprwordup", + "AFprwordsup", + "Fprworup", + "Fprworsup", + "AFprworup", + "AFprworsup", + "Fprworssup", + "AFprworssup", + "WalkFprworup", + "MoveFprworup", + "MvoeFprworup", + "WalkFprworsup", + "MoveFprworsup", + "MvoeFprworsup", + "WalkFprwordup", + "MoveFprwordup", + "MvoeFprwordup", + "WalkFprwordsup", + "MoveFprwordsup", + "MvoeFprwordsup", + "WalkFprworssup", + "MoveFprworssup", + "MvoeFprworssup", + "FFprwardd", + "AFFprwardd", + "WalkFFprwardd", + "MoveFFprwardd", + "MvoeFFprwardd", + "FFprwardf", + "AFFprwardf", + "WalkFFprwardf", + "MoveFFprwardf", + "MvoeFFprwardf", + "FFprward", + "FFprwards", + "AFFprward", + "AFFprwards", + "FFprwar", + "FFprwars", + "AFFprwar", + "AFFprwars", + "FFprwarss", + "AFFprwarss", + "WalkFFprwar", + "MoveFFprwar", + "MvoeFFprwar", + "WalkFFprwars", + "MoveFFprwars", + "MvoeFFprwars", + "WalkFFprward", + "MoveFFprward", + "MvoeFFprward", + "WalkFFprwards", + "MoveFFprwards", + "MvoeFFprwards", + "WalkFFprwarss", + "MoveFFprwarss", + "MvoeFFprwarss", + "FFprword", + "FFprwords", + "AFFprword", + "AFFprwords", + "FFprwor", + "FFprwors", + "AFFprwor", + "AFFprwors", + "FFprworss", + "AFFprworss", + "WalkFFprwor", + "MoveFFprwor", + "MvoeFFprwor", + "WalkFFprwors", + "MoveFFprwors", + "MvoeFFprwors", + "WalkFFprword", + "MoveFFprword", + "MvoeFFprword", + "WalkFFprwords", + "MoveFFprwords", + "MvoeFFprwords", + "WalkFFprworss", + "MoveFFprworss", + "MvoeFFprworss", + "Fprwardd", + "AFprwardd", + "WalkFprwardd", + "MoveFprwardd", + "MvoeFprwardd", + "Fprwardf", + "AFprwardf", + "WalkFprwardf", + "MoveFprwardf", + "MvoeFprwardf", + "Fprward", + "Fprwards", + "AFprward", + "AFprwards", + "Fprwar", + "Fprwars", + "AFprwar", + "AFprwars", + "Fprwarss", + "AFprwarss", + "WalkFprwar", + "MoveFprwar", + "MvoeFprwar", + "WalkFprwars", + "MoveFprwars", + "MvoeFprwars", + "WalkFprward", + "MoveFprward", + "MvoeFprward", + "WalkFprwards", + "MoveFprwards", + "MvoeFprwards", + "WalkFprwarss", + "MoveFprwarss", + "MvoeFprwarss", + "Fprword", + "Fprwords", + "AFprword", + "AFprwords", + "Fprwor", + "Fprwors", + "AFprwor", + "AFprwors", + "Fprworss", + "AFprworss", + "WalkFprwor", + "MoveFprwor", + "MvoeFprwor", + "WalkFprwors", + "MoveFprwors", + "MvoeFprwors", + "WalkFprword", + "MoveFprword", + "MvoeFprword", + "WalkFprwords", + "MoveFprwords", + "MvoeFprwords", + "WalkFprworss", + "MoveFprworss", + "MvoeFprworss", + "Fpword", + "Fpwords", + "AFpword", + "AFpwords", + "Fpwor", + "Fpwors", + "AFpwor", + "AFpwors", + "Fpworss", + "AFpworss", + "WalkFpwor", + "MoveFpwor", + "MvoeFpwor", + "WalkFpwors", + "MoveFpwors", + "MvoeFpwors", + "WalkFpword", + "MoveFpword", + "MvoeFpword", + "WalkFpwords", + "MoveFpwords", + "MvoeFpwords", + "WalkFpworss", + "MoveFpworss", + "MvoeFpworss", + "Fpward", + "Fpwards", + "AFpward", + "AFpwards", + "Fpwar", + "Fpwars", + "AFpwar", + "AFpwars", + "Fpwarss", + "AFpwarss", + "WalkFpwar", + "MoveFpwar", + "MvoeFpwar", + "WalkFpwars", + "MoveFpwars", + "MvoeFpwars", + "WalkFpward", + "MoveFpward", + "MvoeFpward", + "WalkFpwards", + "MoveFpwards", + "MvoeFpwards", + "WalkFpwarss", + "MoveFpwarss", + "MvoeFpwarss", + "UpA", + "UpAnalog", + "ForwrddJp", + "AForwrddJp", + "WalkForwrddJp", + "MoveForwrddJp", + "MvoeForwrddJp", + "ForwrdfJp", + "AForwrdfJp", + "WalkForwrdfJp", + "MoveForwrdfJp", + "MvoeForwrdfJp", + "ForwrdJp", + "ForwrdsJp", + "AForwrdJp", + "AForwrdsJp", + "ForwrJp", + "ForwrsJp", + "AForwrJp", + "AForwrsJp", + "ForwrssJp", + "AForwrssJp", + "WalkForwrJp", + "MoveForwrJp", + "MvoeForwrJp", + "WalkForwrsJp", + "MoveForwrsJp", + "MvoeForwrsJp", + "WalkForwrdJp", + "MoveForwrdJp", + "MvoeForwrdJp", + "WalkForwrdsJp", + "MoveForwrdsJp", + "MvoeForwrdsJp", + "WalkForwrssJp", + "MoveForwrssJp", + "MvoeForwrssJp", + "ForwarddJp", + "AForwarddJp", + "WalkForwarddJp", + "MoveForwarddJp", + "MvoeForwarddJp", + "ForwardfJp", + "AForwardfJp", + "WalkForwardfJp", + "MoveForwardfJp", + "MvoeForwardfJp", + "ForwardJp", + "ForwardsJp", + "AForwardJp", + "AForwardsJp", + "ForwarJp", + "ForwarsJp", + "AForwarJp", + "AForwarsJp", + "ForwarssJp", + "AForwarssJp", + "WalkForwarJp", + "MoveForwarJp", + "MvoeForwarJp", + "WalkForwarsJp", + "MoveForwarsJp", + "MvoeForwarsJp", + "WalkForwardJp", + "MoveForwardJp", + "MvoeForwardJp", + "WalkForwardsJp", + "MoveForwardsJp", + "MvoeForwardsJp", + "WalkForwarssJp", + "MoveForwarssJp", + "MvoeForwarssJp", + "ForwordJp", + "ForwordsJp", + "AForwordJp", + "AForwordsJp", + "ForworJp", + "ForworsJp", + "AForworJp", + "AForworsJp", + "ForworssJp", + "AForworssJp", + "WalkForworJp", + "MoveForworJp", + "MvoeForworJp", + "WalkForworsJp", + "MoveForworsJp", + "MvoeForworsJp", + "WalkForwordJp", + "MoveForwordJp", + "MvoeForwordJp", + "WalkForwordsJp", + "MoveForwordsJp", + "MvoeForwordsJp", + "WalkForworssJp", + "MoveForworssJp", + "MvoeForworssJp", + "AnalogJp", + "AJp", + "Jp", + "AJpo", + "Jpo", + "AJpp", + "Jpp", + "AJppo", + "Jppo", + "WalkJp", + "MoveJp", + "MvoeJp", + "Forwarf", + "Forearf", + "ANort", + "Nort", + "ForwrddU0", + "AForwrddU0", + "WalkForwrddU0", + "MoveForwrddU0", + "MvoeForwrddU0", + "ForwrdfU0", + "AForwrdfU0", + "WalkForwrdfU0", + "MoveForwrdfU0", + "MvoeForwrdfU0", + "ForwrdU0", + "ForwrdsU0", + "AForwrdU0", + "AForwrdsU0", + "ForwrU0", + "ForwrsU0", + "AForwrU0", + "AForwrsU0", + "ForwrssU0", + "AForwrssU0", + "WalkForwrU0", + "MoveForwrU0", + "MvoeForwrU0", + "WalkForwrsU0", + "MoveForwrsU0", + "MvoeForwrsU0", + "WalkForwrdU0", + "MoveForwrdU0", + "MvoeForwrdU0", + "WalkForwrdsU0", + "MoveForwrdsU0", + "MvoeForwrdsU0", + "WalkForwrssU0", + "MoveForwrssU0", + "MvoeForwrssU0", + "ForwrddU[", + "AForwrddU[", + "WalkForwrddU[", + "MoveForwrddU[", + "MvoeForwrddU[", + "ForwrdfU[", + "AForwrdfU[", + "WalkForwrdfU[", + "MoveForwrdfU[", + "MvoeForwrdfU[", + "ForwrdU[", + "ForwrdsU[", + "AForwrdU[", + "AForwrdsU[", + "ForwrU[", + "ForwrsU[", + "AForwrU[", + "AForwrsU[", + "ForwrssU[", + "AForwrssU[", + "WalkForwrU[", + "MoveForwrU[", + "MvoeForwrU[", + "WalkForwrsU[", + "MoveForwrsU[", + "MvoeForwrsU[", + "WalkForwrdU[", + "MoveForwrdU[", + "MvoeForwrdU[", + "WalkForwrdsU[", + "MoveForwrdsU[", + "MvoeForwrdsU[", + "WalkForwrssU[", + "MoveForwrssU[", + "MvoeForwrssU[", + "Forwrddup", + "AForwrddup", + "WalkForwrddup", + "MoveForwrddup", + "MvoeForwrddup", + "Forwrdfup", + "AForwrdfup", + "WalkForwrdfup", + "MoveForwrdfup", + "MvoeForwrdfup", + "Forwrdup", + "Forwrdsup", + "AForwrdup", + "AForwrdsup", + "Forwrup", + "Forwrsup", + "AForwrup", + "AForwrsup", + "Forwrssup", + "AForwrssup", + "WalkForwrup", + "MoveForwrup", + "MvoeForwrup", + "WalkForwrsup", + "MoveForwrsup", + "MvoeForwrsup", + "WalkForwrdup", + "MoveForwrdup", + "MvoeForwrdup", + "WalkForwrdsup", + "MoveForwrdsup", + "MvoeForwrdsup", + "WalkForwrssup", + "MoveForwrssup", + "MvoeForwrssup", + "Fforwrdd", + "AFforwrdd", + "WalkFforwrdd", + "MoveFforwrdd", + "MvoeFforwrdd", + "Fforwrdf", + "AFforwrdf", + "WalkFforwrdf", + "MoveFforwrdf", + "MvoeFforwrdf", + "Fforwrd", + "Fforwrds", + "AFforwrd", + "AFforwrds", + "Fforwr", + "Fforwrs", + "AFforwr", + "AFforwrs", + "Fforwrss", + "AFforwrss", + "WalkFforwr", + "MoveFforwr", + "MvoeFforwr", + "WalkFforwrs", + "MoveFforwrs", + "MvoeFforwrs", + "WalkFforwrd", + "MoveFforwrd", + "MvoeFforwrd", + "WalkFforwrds", + "MoveFforwrds", + "MvoeFforwrds", + "WalkFforwrss", + "MoveFforwrss", + "MvoeFforwrss", + "Firwrdd", + "AFirwrdd", + "WalkFirwrdd", + "MoveFirwrdd", + "MvoeFirwrdd", + "Firwrdf", + "AFirwrdf", + "WalkFirwrdf", + "MoveFirwrdf", + "MvoeFirwrdf", + "Firwrd", + "Firwrds", + "AFirwrd", + "AFirwrds", + "Firwr", + "Firwrs", + "AFirwr", + "AFirwrs", + "Firwrss", + "AFirwrss", + "WalkFirwr", + "MoveFirwr", + "MvoeFirwr", + "WalkFirwrs", + "MoveFirwrs", + "MvoeFirwrs", + "WalkFirwrd", + "MoveFirwrd", + "MvoeFirwrd", + "WalkFirwrds", + "MoveFirwrds", + "MvoeFirwrds", + "WalkFirwrss", + "MoveFirwrss", + "MvoeFirwrss", + "Frwrdd", + "AFrwrdd", + "WalkFrwrdd", + "MoveFrwrdd", + "MvoeFrwrdd", + "Frwrdf", + "AFrwrdf", + "WalkFrwrdf", + "MoveFrwrdf", + "MvoeFrwrdf", + "Frwrd", + "Frwrds", + "AFrwrd", + "AFrwrds", + "Frwr", + "Frwrs", + "AFrwr", + "AFrwrs", + "Frwrss", + "AFrwrss", + "WalkFrwr", + "MoveFrwr", + "MvoeFrwr", + "WalkFrwrs", + "MoveFrwrs", + "MvoeFrwrs", + "WalkFrwrd", + "MoveFrwrd", + "MvoeFrwrd", + "WalkFrwrds", + "MoveFrwrds", + "MvoeFrwrds", + "WalkFrwrss", + "MoveFrwrss", + "MvoeFrwrss", + "Forwrdd", + "AForwrdd", + "WalkForwrdd", + "MoveForwrdd", + "MvoeForwrdd", + "Forwrdf", + "AForwrdf", + "WalkForwrdf", + "MoveForwrdf", + "MvoeForwrdf", + "Forwrd", + "Forwrds", + "AForwrd", + "AForwrds", + "Forwr", + "Forwrs", + "AForwr", + "AForwrs", + "Forwrss", + "AForwrss", + "WalkForwr", + "MoveForwr", + "MvoeForwr", + "WalkForwrs", + "MoveForwrs", + "MvoeForwrs", + "WalkForwrd", + "MoveForwrd", + "MvoeForwrd", + "WalkForwrds", + "MoveForwrds", + "MvoeForwrds", + "WalkForwrss", + "MoveForwrss", + "MvoeForwrss", + "Fowrd", + "Fowrds", + "AFowrd", + "AFowrds", + "Fowr", + "Fowrs", + "AFowr", + "AFowrs", + "Fowrss", + "AFowrss", + "WalkFowr", + "MoveFowr", + "MvoeFowr", + "WalkFowrs", + "MoveFowrs", + "MvoeFowrs", + "WalkFowrd", + "MoveFowrd", + "MvoeFowrd", + "WalkFowrds", + "MoveFowrds", + "MvoeFowrds", + "WalkFowrss", + "MoveFowrss", + "MvoeFowrss", + "ANorht", + "Norht", + "Straight", + "ForwarddU0", + "AForwarddU0", + "WalkForwarddU0", + "MoveForwarddU0", + "MvoeForwarddU0", + "ForwardfU0", + "AForwardfU0", + "WalkForwardfU0", + "MoveForwardfU0", + "MvoeForwardfU0", + "ForwardU0", + "ForwardsU0", + "AForwardU0", + "AForwardsU0", + "ForwarU0", + "ForwarsU0", + "AForwarU0", + "AForwarsU0", + "ForwarssU0", + "AForwarssU0", + "WalkForwarU0", + "MoveForwarU0", + "MvoeForwarU0", + "WalkForwarsU0", + "MoveForwarsU0", + "MvoeForwarsU0", + "WalkForwardU0", + "MoveForwardU0", + "MvoeForwardU0", + "WalkForwardsU0", + "MoveForwardsU0", + "MvoeForwardsU0", + "WalkForwarssU0", + "MoveForwarssU0", + "MvoeForwarssU0", + "ForwordU0", + "ForwordsU0", + "AForwordU0", + "AForwordsU0", + "ForworU0", + "ForworsU0", + "AForworU0", + "AForworsU0", + "ForworssU0", + "AForworssU0", + "WalkForworU0", + "MoveForworU0", + "MvoeForworU0", + "WalkForworsU0", + "MoveForworsU0", + "MvoeForworsU0", + "WalkForwordU0", + "MoveForwordU0", + "MvoeForwordU0", + "WalkForwordsU0", + "MoveForwordsU0", + "MvoeForwordsU0", + "WalkForworssU0", + "MoveForworssU0", + "MvoeForworssU0", + "AnalogU0", + "AU0", + "U0", + "AU0o", + "U0o", + "AU0p", + "U0p", + "AU0po", + "U0po", + "WalkU0", + "MoveU0", + "MvoeU0", + "ForwarddU[", + "AForwarddU[", + "WalkForwarddU[", + "MoveForwarddU[", + "MvoeForwarddU[", + "ForwardfU[", + "AForwardfU[", + "WalkForwardfU[", + "MoveForwardfU[", + "MvoeForwardfU[", + "ForwardU[", + "ForwardsU[", + "AForwardU[", + "AForwardsU[", + "ForwarU[", + "ForwarsU[", + "AForwarU[", + "AForwarsU[", + "ForwarssU[", + "AForwarssU[", + "WalkForwarU[", + "MoveForwarU[", + "MvoeForwarU[", + "WalkForwarsU[", + "MoveForwarsU[", + "MvoeForwarsU[", + "WalkForwardU[", + "MoveForwardU[", + "MvoeForwardU[", + "WalkForwardsU[", + "MoveForwardsU[", + "MvoeForwardsU[", + "WalkForwarssU[", + "MoveForwarssU[", + "MvoeForwarssU[", + "ForwordU[", + "ForwordsU[", + "AForwordU[", + "AForwordsU[", + "ForworU[", + "ForworsU[", + "AForworU[", + "AForworsU[", + "ForworssU[", + "AForworssU[", + "WalkForworU[", + "MoveForworU[", + "MvoeForworU[", + "WalkForworsU[", + "MoveForworsU[", + "MvoeForworsU[", + "WalkForwordU[", + "MoveForwordU[", + "MvoeForwordU[", + "WalkForwordsU[", + "MoveForwordsU[", + "MvoeForwordsU[", + "WalkForworssU[", + "MoveForworssU[", + "MvoeForworssU[", + "AnalogU[", + "AU[", + "U[", + "AU[o", + "U[o", + "AU[p", + "U[p", + "AU[po", + "U[po", + "WalkU[", + "MoveU[", + "MvoeU[", + "Forwarddup", + "AForwarddup", + "WalkForwarddup", + "MoveForwarddup", + "MvoeForwarddup", + "Forwardfup", + "AForwardfup", + "WalkForwardfup", + "MoveForwardfup", + "MvoeForwardfup", + "Forwardup", + "Forwardsup", + "AForwardup", + "AForwardsup", + "Forwarup", + "Forwarsup", + "AForwarup", + "AForwarsup", + "Forwarssup", + "AForwarssup", + "WalkForwarup", + "MoveForwarup", + "MvoeForwarup", + "WalkForwarsup", + "MoveForwarsup", + "MvoeForwarsup", + "WalkForwardup", + "MoveForwardup", + "MvoeForwardup", + "WalkForwardsup", + "MoveForwardsup", + "MvoeForwardsup", + "WalkForwarssup", + "MoveForwarssup", + "MvoeForwarssup", + "Forwordup", + "Forwordsup", + "AForwordup", + "AForwordsup", + "Forworup", + "Forworsup", + "AForworup", + "AForworsup", + "Forworssup", + "AForworssup", + "WalkForworup", + "MoveForworup", + "MvoeForworup", + "WalkForworsup", + "MoveForworsup", + "MvoeForworsup", + "WalkForwordup", + "MoveForwordup", + "MvoeForwordup", + "WalkForwordsup", + "MoveForwordsup", + "MvoeForwordsup", + "WalkForworssup", + "MoveForworssup", + "MvoeForworssup", + "Fforwardd", + "AFforwardd", + "WalkFforwardd", + "MoveFforwardd", + "MvoeFforwardd", + "Fforwardf", + "AFforwardf", + "WalkFforwardf", + "MoveFforwardf", + "MvoeFforwardf", + "Fforward", + "Fforwards", + "AFforward", + "AFforwards", + "Fforwar", + "Fforwars", + "AFforwar", + "AFforwars", + "Fforwarss", + "AFforwarss", + "WalkFforwar", + "MoveFforwar", + "MvoeFforwar", + "WalkFforwars", + "MoveFforwars", + "MvoeFforwars", + "WalkFforward", + "MoveFforward", + "MvoeFforward", + "WalkFforwards", + "MoveFforwards", + "MvoeFforwards", + "WalkFforwarss", + "MoveFforwarss", + "MvoeFforwarss", + "Fforword", + "Fforwords", + "AFforword", + "AFforwords", + "Fforwor", + "Fforwors", + "AFforwor", + "AFforwors", + "Fforworss", + "AFforworss", + "WalkFforwor", + "MoveFforwor", + "MvoeFforwor", + "WalkFforwors", + "MoveFforwors", + "MvoeFforwors", + "WalkFforword", + "MoveFforword", + "MvoeFforword", + "WalkFforwords", + "MoveFforwords", + "MvoeFforwords", + "WalkFforworss", + "MoveFforworss", + "MvoeFforworss", + "Firwardd", + "AFirwardd", + "WalkFirwardd", + "MoveFirwardd", + "MvoeFirwardd", + "Firwardf", + "AFirwardf", + "WalkFirwardf", + "MoveFirwardf", + "MvoeFirwardf", + "Firward", + "Firwards", + "AFirward", + "AFirwards", + "Firwar", + "Firwars", + "AFirwar", + "AFirwars", + "Firwarss", + "AFirwarss", + "WalkFirwar", + "MoveFirwar", + "MvoeFirwar", + "WalkFirwars", + "MoveFirwars", + "MvoeFirwars", + "WalkFirward", + "MoveFirward", + "MvoeFirward", + "WalkFirwards", + "MoveFirwards", + "MvoeFirwards", + "WalkFirwarss", + "MoveFirwarss", + "MvoeFirwarss", + "Firword", + "Firwords", + "AFirword", + "AFirwords", + "Firwor", + "Firwors", + "AFirwor", + "AFirwors", + "Firworss", + "AFirworss", + "WalkFirwor", + "MoveFirwor", + "MvoeFirwor", + "WalkFirwors", + "MoveFirwors", + "MvoeFirwors", + "WalkFirword", + "MoveFirword", + "MvoeFirword", + "WalkFirwords", + "MoveFirwords", + "MvoeFirwords", + "WalkFirworss", + "MoveFirworss", + "MvoeFirworss", + "Frwardd", + "AFrwardd", + "WalkFrwardd", + "MoveFrwardd", + "MvoeFrwardd", + "Frwardf", + "AFrwardf", + "WalkFrwardf", + "MoveFrwardf", + "MvoeFrwardf", + "Frward", + "Frwards", + "AFrward", + "AFrwards", + "Frwar", + "Frwars", + "AFrwar", + "AFrwars", + "Frwarss", + "AFrwarss", + "WalkFrwar", + "MoveFrwar", + "MvoeFrwar", + "WalkFrwars", + "MoveFrwars", + "MvoeFrwars", + "WalkFrward", + "MoveFrward", + "MvoeFrward", + "WalkFrwards", + "MoveFrwards", + "MvoeFrwards", + "WalkFrwarss", + "MoveFrwarss", + "MvoeFrwarss", + "Frword", + "Frwords", + "AFrword", + "AFrwords", + "Frwor", + "Frwors", + "AFrwor", + "AFrwors", + "Frworss", + "AFrworss", + "WalkFrwor", + "MoveFrwor", + "MvoeFrwor", + "WalkFrwors", + "MoveFrwors", + "MvoeFrwors", + "WalkFrword", + "MoveFrword", + "MvoeFrword", + "WalkFrwords", + "MoveFrwords", + "MvoeFrwords", + "WalkFrworss", + "MoveFrworss", + "MvoeFrworss", + "Forwardd", + "AForwardd", + "WalkForwardd", + "MoveForwardd", + "MvoeForwardd", + "Forwardf", + "AForwardf", + "WalkForwardf", + "MoveForwardf", + "MvoeForwardf", + "Analogup", + "↑", + "Aup", + "U", + "AU", + "Up", + "^", + "A^", + "A↑", + "A▲", + "▲", + "ANorth", + "North", + "N", + "AN", + "AUo", + "Uo", + "AUpo", + "Upo", + "AUop", + "Uop", + "AUopo", + "Uopo", + "AYp", + "AY", + "Yp", + "AYpo", + "Ypo", + "AYop", + "Yop", + "AYopo", + "Yopo", + "AIp", + "Ip", + "AIo", + "Io", + "AIpo", + "Ipo", + "AIop", + "Iop", + "AIopo", + "Iopo", + "Aupp", + "Upp", + "AUppo", + "Uppo", + "AUopp", + "Uopp", + "AUoppo", + "Uoppo", + "AYpp", + "Ypp", + "AYppo", + "Yppo", + "AYopp", + "Yopp", + "AYoppo", + "Yoppo", + "AIpp", + "Ipp", + "AIppo", + "Ippo", + "AIopp", + "Iopp", + "AIoppo", + "Ioppo", + "ANoth", + "Noth", + "Forward", + "Forwards", + "Front", + "AForward", + "AForwards", + "AFront", + "Forwar", + "Forwars", + "AForwar", + "AForwars", + "Forwarss", + "AForwarss", + "Walk", + "Walkup", + "Move", + "Moveup", + "Mvoe", + "Mvoeup", + "WalkFront", + "MoveFront", + "MvoeFront", + "WalkForwar", + "MoveForwar", + "MvoeForwar", + "WalkForwars", + "MoveForwars", + "MvoeForwars", + "WalkForward", + "MoveForward", + "MvoeForward", + "WalkForwards", + "MoveForwards", + "MvoeForwards", + "WalkForwarss", + "MoveForwarss", + "MvoeForwarss", + "Forword", + "Forwords", + "AForword", + "AForwords", + "Forwor", + "Forwors", + "AForwor", + "AForwors", + "Forworss", + "AForworss", + "WalkForwor", + "MoveForwor", + "MvoeForwor", + "WalkForwors", + "MoveForwors", + "MvoeForwors", + "WalkForword", + "MoveForword", + "MvoeForword", + "WalkForwords", + "MoveForwords", + "MvoeForwords", + "WalkForworss", + "MoveForworss", + "MvoeForworss", + "Foword", + "Fowords", + "AFoword", + "AFowords", + "Fowor", + "Fowors", + "AFowor", + "AFowors", + "Foworss", + "AFoworss", + "WalkFowor", + "MoveFowor", + "MvoeFowor", + "WalkFowors", + "MoveFowors", + "MvoeFowors", + "WalkFoword", + "MoveFoword", + "MvoeFoword", + "WalkFowords", + "MoveFowords", + "MvoeFowords", + "WalkFoworss", + "MoveFoworss", + "MvoeFoworss", + "Foward", + "Fowards", + "AFoward", + "AFowards", + "Fowar", + "Fowars", + "AFowar", + "AFowars", + "Fowarss", + "AFowarss", + "WalkFowar", + "MoveFowar", + "MvoeFowar", + "WalkFowars", + "MoveFowars", + "MvoeFowars", + "WalkFoward", + "MoveFoward", + "MvoeFoward", + "WalkFowards", + "MoveFowards", + "MvoeFowards", + "WalkFowarss", + "MoveFowarss", + "MvoeFowarss", + "RightStickUp", + "RightStickU", + "RStickUp", + "RStickU", + "CameraStickUp", + "CameraStickU", + "CamStickUp", + "CamStickU", + "CStickUp", + "CStickU", + "CamFprwrddJp", + "CamFprwrdfJp", + "CamFprwrdJp", + "CamFprwrdsJp", + "CamFprwrJp", + "CamFprwrsJp", + "CamFprwrssJp", + "CamFprwarddJp", + "CamFprwardfJp", + "CamFprwardJp", + "CamFprwardsJp", + "CamFprwarJp", + "CamFprwarsJp", + "CamFprwarssJp", + "CamFprwordJp", + "CamFprwordsJp", + "CamFprworJp", + "CamFprworsJp", + "CamFprworssJp", + "CamFprwrddU0", + "CamFprwrdfU0", + "CamFprwrdU0", + "CamFprwrdsU0", + "CamFprwrU0", + "CamFprwrsU0", + "CamFprwrssU0", + "CamFprwrddU[", + "CamFprwrdfU[", + "CamFprwrdU[", + "CamFprwrdsU[", + "CamFprwrU[", + "CamFprwrsU[", + "CamFprwrssU[", + "CamFprwrddup", + "CamFprwrdfup", + "CamFprwrdup", + "CamFprwrdsup", + "CamFprwrup", + "CamFprwrsup", + "CamFprwrssup", + "CamFFprwrdd", + "CamFFprwrdf", + "CamFFprwrd", + "CamFFprwrds", + "CamFFprwr", + "CamFFprwrs", + "CamFFprwrss", + "CamFprwrdd", + "CamFprwrdf", + "CamFprwrd", + "CamFprwrds", + "CamFprwr", + "CamFprwrs", + "CamFprwrss", + "CamFpwrd", + "CamFpwrds", + "CamFpwr", + "CamFpwrs", + "CamFpwrss", + "CamFprwarddU0", + "CamFprwardfU0", + "CamFprwardU0", + "CamFprwardsU0", + "CamFprwarU0", + "CamFprwarsU0", + "CamFprwarssU0", + "CamFprwordU0", + "CamFprwordsU0", + "CamFprworU0", + "CamFprworsU0", + "CamFprworssU0", + "CamFprwarddU[", + "CamFprwardfU[", + "CamFprwardU[", + "CamFprwardsU[", + "CamFprwarU[", + "CamFprwarsU[", + "CamFprwarssU[", + "CamFprwordU[", + "CamFprwordsU[", + "CamFprworU[", + "CamFprworsU[", + "CamFprworssU[", + "CamFprwarddup", + "CamFprwardfup", + "CamFprwardup", + "CamFprwardsup", + "CamFprwarup", + "CamFprwarsup", + "CamFprwarssup", + "CamFprwordup", + "CamFprwordsup", + "CamFprworup", + "CamFprworsup", + "CamFprworssup", + "CamFFprwardd", + "CamFFprwardf", + "CamFFprward", + "CamFFprwards", + "CamFFprwar", + "CamFFprwars", + "CamFFprwarss", + "CamFFprword", + "CamFFprwords", + "CamFFprwor", + "CamFFprwors", + "CamFFprworss", + "CamFprwardd", + "CamFprwardf", + "CamFprward", + "CamFprwards", + "CamFprwar", + "CamFprwars", + "CamFprwarss", + "CamFprword", + "CamFprwords", + "CamFprwor", + "CamFprwors", + "CamFprworss", + "CamFpword", + "CamFpwords", + "CamFpwor", + "CamFpwors", + "CamFpworss", + "CamFpward", + "CamFpwards", + "CamFpwar", + "CamFpwars", + "CamFpwarss", + "UpCam", + "CamForwrddJp", + "CamForwrdfJp", + "CamForwrdJp", + "CamForwrdsJp", + "CamForwrJp", + "CamForwrsJp", + "CamForwrssJp", + "CamForwarddJp", + "CamForwardfJp", + "CamForwardJp", + "CamForwardsJp", + "CamForwarJp", + "CamForwarsJp", + "CamForwarssJp", + "CamForwordJp", + "CamForwordsJp", + "CamForworJp", + "CamForworsJp", + "CamForworssJp", + "Cam-Jp", + "CamJp", + "CamJpo", + "CamJpp", + "CamJppo", + "CamNort", + "CamForwrddU0", + "CamForwrdfU0", + "CamForwrdU0", + "CamForwrdsU0", + "CamForwrU0", + "CamForwrsU0", + "CamForwrssU0", + "CamForwrddU[", + "CamForwrdfU[", + "CamForwrdU[", + "CamForwrdsU[", + "CamForwrU[", + "CamForwrsU[", + "CamForwrssU[", + "CamForwrddup", + "CamForwrdfup", + "CamForwrdup", + "CamForwrdsup", + "CamForwrup", + "CamForwrsup", + "CamForwrssup", + "CamFforwrdd", + "CamFforwrdf", + "CamFforwrd", + "CamFforwrds", + "CamFforwr", + "CamFforwrs", + "CamFforwrss", + "CamFirwrdd", + "CamFirwrdf", + "CamFirwrd", + "CamFirwrds", + "CamFirwr", + "CamFirwrs", + "CamFirwrss", + "CamFrwrdd", + "CamFrwrdf", + "CamFrwrd", + "CamFrwrds", + "CamFrwr", + "CamFrwrs", + "CamFrwrss", + "CamForwrdd", + "CamForwrdf", + "CamForwrd", + "CamForwrds", + "CamForwr", + "CamForwrs", + "CamForwrss", + "CamFowrd", + "CamFowrds", + "CamFowr", + "CamFowrs", + "CamFowrss", + "CamNorht", + "CamForwarddU0", + "CamForwardfU0", + "CamForwardU0", + "CamForwardsU0", + "CamForwarU0", + "CamForwarsU0", + "CamForwarssU0", + "CamForwordU0", + "CamForwordsU0", + "CamForworU0", + "CamForworsU0", + "CamForworssU0", + "Cam-U0", + "CamU0", + "CamU0o", + "CamU0p", + "CamU0po", + "CamForwarddU[", + "CamForwardfU[", + "CamForwardU[", + "CamForwardsU[", + "CamForwarU[", + "CamForwarsU[", + "CamForwarssU[", + "CamForwordU[", + "CamForwordsU[", + "CamForworU[", + "CamForworsU[", + "CamForworssU[", + "Cam-U[", + "CamU[", + "CamU[o", + "CamU[p", + "CamU[po", + "CamForwarddup", + "CamForwardfup", + "CamForwardup", + "CamForwardsup", + "CamForwarup", + "CamForwarsup", + "CamForwarssup", + "CamForwordup", + "CamForwordsup", + "CamForworup", + "CamForworsup", + "CamForworssup", + "CamFforwardd", + "CamFforwardf", + "CamFforward", + "CamFforwards", + "CamFforwar", + "CamFforwars", + "CamFforwarss", + "CamFforword", + "CamFforwords", + "CamFforwor", + "CamFforwors", + "CamFforworss", + "CamFirwardd", + "CamFirwardf", + "CamFirward", + "CamFirwards", + "CamFirwar", + "CamFirwars", + "CamFirwarss", + "CamFirword", + "CamFirwords", + "CamFirwor", + "CamFirwors", + "CamFirworss", + "CamFrwardd", + "CamFrwardf", + "CamFrward", + "CamFrwards", + "CamFrwar", + "CamFrwars", + "CamFrwarss", + "CamFrword", + "CamFrwords", + "CamFrwor", + "CamFrwors", + "CamFrworss", + "CamForwardd", + "CamForwardf", + "Cam-up", + "Camup", + "CamU", + "Cam^", + "Cam↑", + "Cam▲", + "CamNorth", + "CamN", + "CamUo", + "CamUpo", + "CamUop", + "CamUopo", + "CamYp", + "CamY", + "CamYo", + "CamYpo", + "CamYop", + "CamYopo", + "CamIp", + "CamI", + "CamIo", + "CamIpo", + "CamIop", + "CamIopo", + "Camupp", + "CamUppo", + "CamUopp", + "CamUoppo", + "CamYpp", + "CamYppo", + "CamYopp", + "CamYoppo", + "CamIpp", + "CamIppo", + "CamIopp", + "CamIoppo", + "CamNoth", + "CamForward", + "CamForwards", + "CamFront", + "CamForwar", + "CamForwars", + "CamForwarss", + "CamForword", + "CamForwords", + "CamForwor", + "CamForwors", + "CamForworss", + "CamFoword", + "CamFowords", + "CamFowor", + "CamFowors", + "CamFoworss", + "CamFoward", + "CamFowards", + "CamFowar", + "CamFowars", + "CamFowarss", + "CFprwrddJp", + "CameraFprwrddJp", + "CFprwrdfJp", + "CameraFprwrdfJp", + "CFprwrdJp", + "CFprwrdsJp", + "CameraFprwrdJp", + "CameraFprwrdsJp", + "CFprwrJp", + "CFprwrsJp", + "CameraFprwrJp", + "CameraFprwrsJp", + "CFprwrssJp", + "CameraFprwrssJp", + "CFprwarddJp", + "CameraFprwarddJp", + "CFprwardfJp", + "CameraFprwardfJp", + "CFprwardJp", + "CFprwardsJp", + "CameraFprwardJp", + "CameraFprwardsJp", + "CFprwarJp", + "CFprwarsJp", + "CameraFprwarJp", + "CameraFprwarsJp", + "CFprwarssJp", + "CameraFprwarssJp", + "CFprwordJp", + "CFprwordsJp", + "CameraFprwordJp", + "CameraFprwordsJp", + "CFprworJp", + "CFprworsJp", + "CameraFprworJp", + "CameraFprworsJp", + "CFprworssJp", + "CameraFprworssJp", + "CFprwrddU0", + "CameraFprwrddU0", + "CFprwrdfU0", + "CameraFprwrdfU0", + "CFprwrdU0", + "CFprwrdsU0", + "CameraFprwrdU0", + "CameraFprwrdsU0", + "CFprwrU0", + "CFprwrsU0", + "CameraFprwrU0", + "CameraFprwrsU0", + "CFprwrssU0", + "CameraFprwrssU0", + "CFprwrddU[", + "CameraFprwrddU[", + "CFprwrdfU[", + "CameraFprwrdfU[", + "CFprwrdU[", + "CFprwrdsU[", + "CameraFprwrdU[", + "CameraFprwrdsU[", + "CFprwrU[", + "CFprwrsU[", + "CameraFprwrU[", + "CameraFprwrsU[", + "CFprwrssU[", + "CameraFprwrssU[", + "CFprwrddup", + "CameraFprwrddup", + "CFprwrdfup", + "CameraFprwrdfup", + "CFprwrdup", + "CFprwrdsup", + "CameraFprwrdup", + "CameraFprwrdsup", + "CFprwrup", + "CFprwrsup", + "CameraFprwrup", + "CameraFprwrsup", + "CFprwrssup", + "CameraFprwrssup", + "CFFprwrdd", + "CameraFFprwrdd", + "CFFprwrdf", + "CameraFFprwrdf", + "CFFprwrd", + "CFFprwrds", + "CameraFFprwrd", + "CameraFFprwrds", + "CFFprwr", + "CFFprwrs", + "CameraFFprwr", + "CameraFFprwrs", + "CFFprwrss", + "CameraFFprwrss", + "CFprwrdd", + "CameraFprwrdd", + "CFprwrdf", + "CameraFprwrdf", + "CFprwrd", + "CFprwrds", + "CameraFprwrd", + "CameraFprwrds", + "CFprwr", + "CFprwrs", + "CameraFprwr", + "CameraFprwrs", + "CFprwrss", + "CameraFprwrss", + "CFpwrd", + "CFpwrds", + "CameraFpwrd", + "CameraFpwrds", + "CFpwr", + "CFpwrs", + "CameraFpwr", + "CameraFpwrs", + "CFpwrss", + "CameraFpwrss", + "CFprwarddU0", + "CameraFprwarddU0", + "CFprwardfU0", + "CameraFprwardfU0", + "CFprwardU0", + "CFprwardsU0", + "CameraFprwardU0", + "CameraFprwardsU0", + "CFprwarU0", + "CFprwarsU0", + "CameraFprwarU0", + "CameraFprwarsU0", + "CFprwarssU0", + "CameraFprwarssU0", + "CFprwordU0", + "CFprwordsU0", + "CameraFprwordU0", + "CameraFprwordsU0", + "CFprworU0", + "CFprworsU0", + "CameraFprworU0", + "CameraFprworsU0", + "CFprworssU0", + "CameraFprworssU0", + "CFprwarddU[", + "CameraFprwarddU[", + "CFprwardfU[", + "CameraFprwardfU[", + "CFprwardU[", + "CFprwardsU[", + "CameraFprwardU[", + "CameraFprwardsU[", + "CFprwarU[", + "CFprwarsU[", + "CameraFprwarU[", + "CameraFprwarsU[", + "CFprwarssU[", + "CameraFprwarssU[", + "CFprwordU[", + "CFprwordsU[", + "CameraFprwordU[", + "CameraFprwordsU[", + "CFprworU[", + "CFprworsU[", + "CameraFprworU[", + "CameraFprworsU[", + "CFprworssU[", + "CameraFprworssU[", + "CFprwarddup", + "CameraFprwarddup", + "CFprwardfup", + "CameraFprwardfup", + "CFprwardup", + "CFprwardsup", + "CameraFprwardup", + "CameraFprwardsup", + "CFprwarup", + "CFprwarsup", + "CameraFprwarup", + "CameraFprwarsup", + "CFprwarssup", + "CameraFprwarssup", + "CFprwordup", + "CFprwordsup", + "CameraFprwordup", + "CameraFprwordsup", + "CFprworup", + "CFprworsup", + "CameraFprworup", + "CameraFprworsup", + "CFprworssup", + "CameraFprworssup", + "CFFprwardd", + "CameraFFprwardd", + "CFFprwardf", + "CameraFFprwardf", + "CFFprward", + "CFFprwards", + "CameraFFprward", + "CameraFFprwards", + "CFFprwar", + "CFFprwars", + "CameraFFprwar", + "CameraFFprwars", + "CFFprwarss", + "CameraFFprwarss", + "CFFprword", + "CFFprwords", + "CameraFFprword", + "CameraFFprwords", + "CFFprwor", + "CFFprwors", + "CameraFFprwor", + "CameraFFprwors", + "CFFprworss", + "CameraFFprworss", + "CFprwardd", + "CameraFprwardd", + "CFprwardf", + "CameraFprwardf", + "CFprward", + "CFprwards", + "CameraFprward", + "CameraFprwards", + "CFprwar", + "CFprwars", + "CameraFprwar", + "CameraFprwars", + "CFprwarss", + "CameraFprwarss", + "CFprword", + "CFprwords", + "CameraFprword", + "CameraFprwords", + "CFprwor", + "CFprwors", + "CameraFprwor", + "CameraFprwors", + "CFprworss", + "CameraFprworss", + "CFpword", + "CFpwords", + "CameraFpword", + "CameraFpwords", + "CFpwor", + "CFpwors", + "CameraFpwor", + "CameraFpwors", + "CFpworss", + "CameraFpworss", + "CFpward", + "CFpwards", + "CameraFpward", + "CameraFpwards", + "CFpwar", + "CFpwars", + "CameraFpwar", + "CameraFpwars", + "CFpwarss", + "CameraFpwarss", + "UpC", + "UpCamera", + "CForwrddJp", + "CameraForwrddJp", + "CForwrdfJp", + "CameraForwrdfJp", + "CForwrdJp", + "CForwrdsJp", + "CameraForwrdJp", + "CameraForwrdsJp", + "CForwrJp", + "CForwrsJp", + "CameraForwrJp", + "CameraForwrsJp", + "CForwrssJp", + "CameraForwrssJp", + "CForwarddJp", + "CameraForwarddJp", + "CForwardfJp", + "CameraForwardfJp", + "CForwardJp", + "CForwardsJp", + "CameraForwardJp", + "CameraForwardsJp", + "CForwarJp", + "CForwarsJp", + "CameraForwarJp", + "CameraForwarsJp", + "CForwarssJp", + "CameraForwarssJp", + "CForwordJp", + "CForwordsJp", + "CameraForwordJp", + "CameraForwordsJp", + "CForworJp", + "CForworsJp", + "CameraForworJp", + "CameraForworsJp", + "CForworssJp", + "CameraForworssJp", + "C-Jp", + "Camera-Jp", + "CJp", + "CJpo", + "CJpp", + "CJppo", + "CameraJp", + "CameraJpo", + "CameraJpp", + "CameraJppo", + "CNort", + "CameraNort", + "CForwrddU0", + "CameraForwrddU0", + "CForwrdfU0", + "CameraForwrdfU0", + "CForwrdU0", + "CForwrdsU0", + "CameraForwrdU0", + "CameraForwrdsU0", + "CForwrU0", + "CForwrsU0", + "CameraForwrU0", + "CameraForwrsU0", + "CForwrssU0", + "CameraForwrssU0", + "CForwrddU[", + "CameraForwrddU[", + "CForwrdfU[", + "CameraForwrdfU[", + "CForwrdU[", + "CForwrdsU[", + "CameraForwrdU[", + "CameraForwrdsU[", + "CForwrU[", + "CForwrsU[", + "CameraForwrU[", + "CameraForwrsU[", + "CForwrssU[", + "CameraForwrssU[", + "CForwrddup", + "CameraForwrddup", + "CForwrdfup", + "CameraForwrdfup", + "CForwrdup", + "CForwrdsup", + "CameraForwrdup", + "CameraForwrdsup", + "CForwrup", + "CForwrsup", + "CameraForwrup", + "CameraForwrsup", + "CForwrssup", + "CameraForwrssup", + "CFforwrdd", + "CameraFforwrdd", + "CFforwrdf", + "CameraFforwrdf", + "CFforwrd", + "CFforwrds", + "CameraFforwrd", + "CameraFforwrds", + "CFforwr", + "CFforwrs", + "CameraFforwr", + "CameraFforwrs", + "CFforwrss", + "CameraFforwrss", + "CFirwrdd", + "CameraFirwrdd", + "CFirwrdf", + "CameraFirwrdf", + "CFirwrd", + "CFirwrds", + "CameraFirwrd", + "CameraFirwrds", + "CFirwr", + "CFirwrs", + "CameraFirwr", + "CameraFirwrs", + "CFirwrss", + "CameraFirwrss", + "CFrwrdd", + "CameraFrwrdd", + "CFrwrdf", + "CameraFrwrdf", + "CFrwrd", + "CFrwrds", + "CameraFrwrd", + "CameraFrwrds", + "CFrwr", + "CFrwrs", + "CameraFrwr", + "CameraFrwrs", + "CFrwrss", + "CameraFrwrss", + "CForwrdd", + "CameraForwrdd", + "CForwrdf", + "CameraForwrdf", + "CForwrd", + "CForwrds", + "CameraForwrd", + "CameraForwrds", + "CForwr", + "CForwrs", + "CameraForwr", + "CameraForwrs", + "CForwrss", + "CameraForwrss", + "CFowrd", + "CFowrds", + "CameraFowrd", + "CameraFowrds", + "CFowr", + "CFowrs", + "CameraFowr", + "CameraFowrs", + "CFowrss", + "CameraFowrss", + "CNorht", + "CameraNorht", + "CForwarddU0", + "CameraForwarddU0", + "CForwardfU0", + "CameraForwardfU0", + "CForwardU0", + "CForwardsU0", + "CameraForwardU0", + "CameraForwardsU0", + "CForwarU0", + "CForwarsU0", + "CameraForwarU0", + "CameraForwarsU0", + "CForwarssU0", + "CameraForwarssU0", + "CForwordU0", + "CForwordsU0", + "CameraForwordU0", + "CameraForwordsU0", + "CForworU0", + "CForworsU0", + "CameraForworU0", + "CameraForworsU0", + "CForworssU0", + "CameraForworssU0", + "C-U0", + "Camera-U0", + "CU0", + "CU0o", + "CU0p", + "CU0po", + "CameraU0", + "CameraU0o", + "CameraU0p", + "CameraU0po", + "CForwarddU[", + "CameraForwarddU[", + "CForwardfU[", + "CameraForwardfU[", + "CForwardU[", + "CForwardsU[", + "CameraForwardU[", + "CameraForwardsU[", + "CForwarU[", + "CForwarsU[", + "CameraForwarU[", + "CameraForwarsU[", + "CForwarssU[", + "CameraForwarssU[", + "CForwordU[", + "CForwordsU[", + "CameraForwordU[", + "CameraForwordsU[", + "CForworU[", + "CForworsU[", + "CameraForworU[", + "CameraForworsU[", + "CForworssU[", + "CameraForworssU[", + "C-U[", + "Camera-U[", + "CU[", + "CU[o", + "CU[p", + "CU[po", + "CameraU[", + "CameraU[o", + "CameraU[p", + "CameraU[po", + "CForwarddup", + "CameraForwarddup", + "CForwardfup", + "CameraForwardfup", + "CForwardup", + "CForwardsup", + "CameraForwardup", + "CameraForwardsup", + "CForwarup", + "CForwarsup", + "CameraForwarup", + "CameraForwarsup", + "CForwarssup", + "CameraForwarssup", + "CForwordup", + "CForwordsup", + "CameraForwordup", + "CameraForwordsup", + "CForworup", + "CForworsup", + "CameraForworup", + "CameraForworsup", + "CForworssup", + "CameraForworssup", + "CFforwardd", + "CameraFforwardd", + "CFforwardf", + "CameraFforwardf", + "CFforward", + "CFforwards", + "CameraFforward", + "CameraFforwards", + "CFforwar", + "CFforwars", + "CameraFforwar", + "CameraFforwars", + "CFforwarss", + "CameraFforwarss", + "CFforword", + "CFforwords", + "CameraFforword", + "CameraFforwords", + "CFforwor", + "CFforwors", + "CameraFforwor", + "CameraFforwors", + "CFforworss", + "CameraFforworss", + "CFirwardd", + "CameraFirwardd", + "CFirwardf", + "CameraFirwardf", + "CFirward", + "CFirwards", + "CameraFirward", + "CameraFirwards", + "CFirwar", + "CFirwars", + "CameraFirwar", + "CameraFirwars", + "CFirwarss", + "CameraFirwarss", + "CFirword", + "CFirwords", + "CameraFirword", + "CameraFirwords", + "CFirwor", + "CFirwors", + "CameraFirwor", + "CameraFirwors", + "CFirworss", + "CameraFirworss", + "CFrwardd", + "CameraFrwardd", + "CFrwardf", + "CameraFrwardf", + "CFrward", + "CFrwards", + "CameraFrward", + "CameraFrwards", + "CFrwar", + "CFrwars", + "CameraFrwar", + "CameraFrwars", + "CFrwarss", + "CameraFrwarss", + "CFrword", + "CFrwords", + "CameraFrword", + "CameraFrwords", + "CFrwor", + "CFrwors", + "CameraFrwor", + "CameraFrwors", + "CFrworss", + "CameraFrworss", + "CForwardd", + "CameraForwardd", + "CForwardf", + "CameraForwardf", + "C-up", + "Camera-up", + "Cup", + "CU", + "C^", + "C↑", + "C▲", + "CNorth", + "CN", + "CUo", + "CUpo", + "CUop", + "CUopo", + "CYp", + "CY", + "CYo", + "CYpo", + "CYop", + "CYopo", + "CIp", + "CI", + "CIo", + "CIpo", + "CIop", + "CIopo", + "Cupp", + "CUppo", + "CUopp", + "CUoppo", + "CYpp", + "CYppo", + "CYopp", + "CYoppo", + "CIpp", + "CIppo", + "CIopp", + "CIoppo", + "CNoth", + "Cameraup", + "CameraU", + "Camera^", + "Camera↑", + "Camera▲", + "CameraNorth", + "CameraN", + "CameraUo", + "CameraUpo", + "CameraUop", + "CameraUopo", + "CameraYp", + "CameraY", + "CameraYo", + "CameraYpo", + "CameraYop", + "CameraYopo", + "CameraIp", + "CameraI", + "CameraIo", + "CameraIpo", + "CameraIop", + "CameraIopo", + "Cameraupp", + "CameraUppo", + "CameraUopp", + "CameraUoppo", + "CameraYpp", + "CameraYppo", + "CameraYopp", + "CameraYoppo", + "CameraIpp", + "CameraIppo", + "CameraIopp", + "CameraIoppo", + "CameraNoth", + "CForward", + "CForwards", + "CFront", + "CameraForward", + "CameraForwards", + "CameraFront", + "CForwar", + "CForwars", + "CameraForwar", + "CameraForwars", + "CForwarss", + "CameraForwarss", + "CForword", + "CForwords", + "CameraForword", + "CameraForwords", + "CForwor", + "CForwors", + "CameraForwor", + "CameraForwors", + "CForworss", + "CameraForworss", + "CFoword", + "CFowords", + "CameraFoword", + "CameraFowords", + "CFowor", + "CFowors", + "CameraFowor", + "CameraFowors", + "CFoworss", + "CameraFoworss", + "CFoward", + "CFowards", + "CameraFoward", + "CameraFowards", + "CFowar", + "CFowars", + "CameraFowar", + "CameraFowars", + "CFowarss", + "CameraFowarss" + ], + "color_value": "#C7C7C7", + "is_blacklisted": false, + "opposite_input_value": "0x00207F7F7F7F0000L", + "opposite_input_name": "v", + "has_opposite": true, + "input_type": 1, + "keyboard_value": 36, + "keyboard_key_name": "Home" + }, + { + "input_value": "0x00207F7F7F7F0000L", + "input_name": "v", + "input_alias": [ + "DownnD", + "DownnDpad", + "DDownn", + "DpadDownn", + "DFpwn", + "DFpwb", + "DFpw", + "DpadFpwn", + "DpadFpwb", + "DpadFpw", + "DFpwm", + "DpadFpwm", + "DownD", + "DownDpad", + "DAckwrd", + "DAckwrds", + "DpadAckwrd", + "DpadAckwrds", + "DAckwrs", + "DAckwrss", + "DpadAckwrs", + "DpadAckwrss", + "DAckwr", + "DpadAckwr", + "DAckward", + "DAckwards", + "DAck", + "DpadAckward", + "DpadAckwards", + "DpadAck", + "DAckwars", + "DAckwarss", + "DpadAckwars", + "DpadAckwarss", + "DAckwar", + "DpadAckwar", + "DAckword", + "DAckwords", + "DpadAckword", + "DpadAckwords", + "DAckwors", + "DAckworss", + "DpadAckwors", + "DpadAckworss", + "DAckwor", + "DpadAckwor", + "DBabkwrd", + "DBabkwrds", + "DpadBabkwrd", + "DpadBabkwrds", + "DBabkwrs", + "DBabkwrss", + "DpadBabkwrs", + "DpadBabkwrss", + "DBabkwr", + "DpadBabkwr", + "DBabkward", + "DBabkwards", + "DBabk", + "DpadBabkward", + "DpadBabkwards", + "DpadBabk", + "DBabkwars", + "DBabkwarss", + "DpadBabkwars", + "DpadBabkwarss", + "DBabkwar", + "DpadBabkwar", + "DBabkword", + "DBabkwords", + "DpadBabkword", + "DpadBabkwords", + "DBabkwors", + "DBabkworss", + "DpadBabkwors", + "DpadBabkworss", + "DBabkwor", + "DpadBabkwor", + "DXown", + "DpadXown", + "DDoown", + "DpadDoown", + "Ddowwn", + "Ddonww", + "Dpaddowwn", + "Dpaddonww", + "DSputh", + "FSputh", + "DpadSputh", + "DSout", + "FSout", + "DpadSout", + "DSput", + "FSput", + "DpadSput", + "DBackwrd", + "DBackwrds", + "DpadBackwrd", + "DpadBackwrds", + "DBackwrs", + "DBackwrss", + "DpadBackwrs", + "DpadBackwrss", + "DBackwr", + "DpadBackwr", + "DBacxkwrd", + "DBacxkwrds", + "DpadBacxkwrd", + "DpadBacxkwrds", + "DBaxckwrd", + "DBaxckwrds", + "DpadBaxckwrd", + "DpadBaxckwrds", + "DBaxkwrd", + "DBaxkwrds", + "DpadBaxkwrd", + "DpadBaxkwrds", + "DBacxkwr", + "DBacxkwrs", + "DpadBacxkwr", + "DpadBacxkwrs", + "DBaxckwr", + "DBaxckwrs", + "DpadBaxckwr", + "DpadBaxckwrs", + "DBaxkwr", + "DBaxkwrs", + "DpadBaxkwr", + "DpadBaxkwrs", + "DBacxkwrss", + "DpadBacxkwrss", + "DBaxckwrss", + "DpadBaxckwrss", + "DBaxkwrss", + "DpadBaxkwrss", + "DBavckwrd", + "DBavckwrds", + "DpadBavckwrd", + "DpadBavckwrds", + "DBavckwrs", + "DBavckwrss", + "DpadBavckwrs", + "DpadBavckwrss", + "DBavckwr", + "DpadBavckwr", + "DBakcwrd", + "DBakcwrds", + "DpadBakcwrd", + "DpadBakcwrds", + "DBakcwrs", + "DBakcwrss", + "DpadBakcwrs", + "DpadBakcwrss", + "DBakcwr", + "DpadBakcwr", + "DBaccwrd", + "DBaccwrds", + "DpadBaccwrd", + "DpadBaccwrds", + "DBaccwrs", + "DBaccwrss", + "DpadBaccwrs", + "DpadBaccwrss", + "DBaccwr", + "DpadBaccwr", + "DBavkwrd", + "DBavkwrds", + "DpadBavkwrd", + "DpadBavkwrds", + "DBavkwrs", + "DBavkwrss", + "DpadBavkwrs", + "DpadBavkwrss", + "DBavkwr", + "DpadBavkwr", + "DBacvkwrd", + "DBacvkwrds", + "DpadBacvkwrd", + "DpadBacvkwrds", + "DBacvkwrs", + "DBacvkwrss", + "DpadBacvkwrs", + "DpadBacvkwrss", + "DBacvkwr", + "DpadBacvkwr", + "DDoqn", + "DpadDoqn", + "DReverse", + "DpadReverse", + "Ddown", + "Ddwon", + "Ddonw", + "Ddnow", + "Ddnwo", + "DD", + "Dv", + "D↓", + "DSouth", + "DS", + "D▼", + "Ddiwn", + "Ddwin", + "Ddinw", + "Ddniw", + "Ddnwi", + "Ddpwn", + "Ddwpn", + "Ddpnw", + "Ddnpw", + "Ddnwp", + "Ddon", + "Ddin", + "Ddpn", + "Ddoiwn", + "Ddpiwn", + "Ddipwn", + "Ddpown", + "Ddopwn", + "Ddoinw", + "Ddpinw", + "Ddipnw", + "Ddponw", + "Ddopnw", + "Ddowb", + "Ddwob", + "Ddobw", + "Ddbow", + "Ddbwo", + "Ddiwb", + "Ddwib", + "Ddibw", + "Ddbiw", + "Ddbwi", + "Ddpwb", + "Ddwpb", + "Ddpbw", + "Ddbpw", + "Ddbwp", + "Ddob", + "Ddib", + "Ddpb", + "Ddoiwb", + "Ddpiwb", + "Ddipwb", + "Ddpowb", + "Ddopwb", + "Ddoibw", + "Ddpibw", + "Ddipbw", + "Ddpobw", + "Ddopbw", + "Dsown", + "Dswon", + "Dsonw", + "Dsnow", + "Dsnwo", + "Dsiwn", + "Dsinw", + "Dsniw", + "Dsnwi", + "Dspwn", + "Dswpn", + "Dspnw", + "Dsnpw", + "Dsnwp", + "Dspn", + "Dsoiwn", + "Dspiwn", + "Dsiown", + "Dsipwn", + "Dspown", + "Dsopwn", + "Dsoinw", + "Dsionw", + "Dsipnw", + "Dsponw", + "Dsopnw", + "Dsowb", + "Dswob", + "Dsobw", + "Dsbow", + "Dsbwo", + "Dsiwb", + "Dswib", + "Dsibw", + "Dsbiw", + "Dsbwi", + "Dspwb", + "Dswpb", + "Dspbw", + "Dsbpw", + "Dsbwp", + "Dsob", + "Dsib", + "Dspb", + "Dsoiwb", + "Dspiwb", + "Dsiowb", + "Dsipwb", + "Dspowb", + "Dsopwb", + "Dsoibw", + "Dspibw", + "Dsiobw", + "Dsipbw", + "Dspobw", + "Dsopbw", + "Ddow", + "Ddwo", + "Ddno", + "Ddnw", + "Ddiw", + "Ddwi", + "Ddni", + "Ddpw", + "Ddwp", + "Ddnp", + "Ddoiw", + "Ddpiw", + "Ddipw", + "Ddpow", + "Ddopw", + "Ddoin", + "Ddpin", + "Ddipn", + "Ddpon", + "Ddopn", + "Ddbo", + "Ddbw", + "Ddbi", + "Ddbp", + "Ddoib", + "Ddpib", + "Ddipb", + "Ddpob", + "Ddopb", + "Dsow", + "Dswo", + "Dsno", + "Dsnw", + "Dsiw", + "Dswi", + "Dsni", + "Dspw", + "Dswp", + "Dsnp", + "Dsoiw", + "Dspiw", + "Dsiow", + "Dsipw", + "Dspow", + "Dsopw", + "Dsoin", + "Dsion", + "Dsipn", + "Dspon", + "Dsopn", + "Dsbo", + "Dsbw", + "Dsbi", + "Dsbp", + "Dsoib", + "Dspib", + "Dsiob", + "Dsipb", + "Dspob", + "Dsopb", + "Dd0wn", + "Ddw0n", + "Dd0nw", + "Ddn0w", + "Ddnw0", + "DS0uth", + "Dd0n", + "Dd0iwn", + "Ddi0wn", + "Ddp0wn", + "Dd0pwn", + "Dd0inw", + "Ddi0nw", + "Ddp0nw", + "Dd0pnw", + "Dd0wb", + "Ddw0b", + "Dd0bw", + "Ddb0w", + "Ddbw0", + "Dd0b", + "Dd0iwb", + "Ddi0wb", + "Ddp0wb", + "Dd0pwb", + "Dd0ibw", + "Ddi0bw", + "Ddp0bw", + "Dd0pbw", + "Ds0wn", + "Dsw0n", + "Ds0nw", + "Dsn0w", + "Dsnw0", + "Ds0n", + "Ds0iwn", + "Dsi0wn", + "Dsp0wn", + "Ds0pwn", + "Ds0inw", + "Dsi0nw", + "Dsp0nw", + "Ds0pnw", + "Ds0wb", + "Dsw0b", + "Ds0bw", + "Dsb0w", + "Dsbw0", + "Ds0b", + "Ds0iwb", + "Dsi0wb", + "Dsp0wb", + "Ds0pwb", + "Ds0ibw", + "Dsi0bw", + "Dsp0bw", + "Ds0pbw", + "Dd0w", + "Ddw0", + "Ddn0", + "Dd0iw", + "Ddi0w", + "Ddp0w", + "Dd0pw", + "Dd0in", + "Ddi0n", + "Ddp0n", + "Dd0pn", + "Ddb0", + "Dd0ib", + "Ddi0b", + "Ddp0b", + "Dd0pb", + "Ds0w", + "Dsw0", + "Dsn0", + "Ds0iw", + "Dsi0w", + "Dsp0w", + "Ds0pw", + "Ds0in", + "Dsi0n", + "Dsp0n", + "Ds0pn", + "Dsb0", + "Ds0ib", + "Dsi0b", + "Dsp0b", + "Ds0pb", + "Dd9wn", + "Ddw9n", + "Dd9nw", + "Ddn9w", + "Ddnw9", + "DS9uth", + "Dd9n", + "Dd9iwn", + "Ddi9wn", + "Ddp9wn", + "Dd9pwn", + "Dd9inw", + "Ddi9nw", + "Ddp9nw", + "Dd9pnw", + "Dd9wb", + "Ddw9b", + "Dd9bw", + "Ddb9w", + "Ddbw9", + "Dd9b", + "Dd9iwb", + "Ddi9wb", + "Ddp9wb", + "Dd9pwb", + "Dd9ibw", + "Ddi9bw", + "Ddp9bw", + "Dd9pbw", + "Ds9wn", + "Dsw9n", + "Ds9nw", + "Dsn9w", + "Dsnw9", + "Ds9n", + "Ds9iwn", + "Dsi9wn", + "Dsp9wn", + "Ds9pwn", + "Ds9inw", + "Dsi9nw", + "Dsp9nw", + "Ds9pnw", + "Ds9wb", + "Dsw9b", + "Ds9bw", + "Dsb9w", + "Dsbw9", + "Ds9b", + "Ds9iwb", + "Dsi9wb", + "Dsp9wb", + "Ds9pwb", + "Ds9ibw", + "Dsi9bw", + "Dsp9bw", + "Ds9pbw", + "Dd9w", + "Ddw9", + "Ddn9", + "Dd9iw", + "Ddi9w", + "Ddp9w", + "Dd9pw", + "Dd9in", + "Ddi9n", + "Ddp9n", + "Dd9pn", + "Ddb9", + "Dd9ib", + "Ddi9b", + "Ddp9b", + "Dd9pb", + "Ds9w", + "Dsw9", + "Dsn9", + "Ds9iw", + "Dsi9w", + "Dsp9w", + "Ds9pw", + "Ds9in", + "Dsi9n", + "Dsp9n", + "Ds9pn", + "Dsb9", + "Ds9ib", + "Dsi9b", + "Dsp9b", + "Ds9pb", + "Dfown", + "Dfwon", + "Dfonw", + "Dfnow", + "Dfnwo", + "Df", + "Dfiwn", + "Dfwin", + "Dfinw", + "Dfniw", + "Dfnwi", + "Dfwpn", + "Dfpnw", + "Dfnpw", + "Dfnwp", + "Dfon", + "Dfin", + "Dfpn", + "Dfoiwn", + "Dfpiwn", + "Dfiown", + "Dfipwn", + "Dfpown", + "Dfopwn", + "Dfoinw", + "Dfpinw", + "Dfionw", + "Dfipnw", + "Dfponw", + "Dfopnw", + "Dfowb", + "Dfwob", + "Dfobw", + "Dfbow", + "Dfbwo", + "Dfiwb", + "Dfwib", + "Dfibw", + "Dfbiw", + "Dfbwi", + "Dfwpb", + "Dfpbw", + "Dfbpw", + "Dfbwp", + "Dfob", + "Dfib", + "Dfpb", + "Dfoiwb", + "Dfpiwb", + "Dfiowb", + "Dfipwb", + "Dfpowb", + "Dfopwb", + "Dfoibw", + "Dfpibw", + "Dfiobw", + "Dfipbw", + "Dfpobw", + "Dfopbw", + "Dfow", + "Dfwo", + "Dfno", + "Dfnw", + "Dfiw", + "Dfwi", + "Dfni", + "Dfwp", + "Dfnp", + "Dfoiw", + "Dfpiw", + "Dfiow", + "Dfipw", + "Dfpow", + "Dfopw", + "Dfoin", + "Dfpin", + "Dfion", + "Dfipn", + "Dfpon", + "Dfopn", + "Dfbo", + "Dfbw", + "Dfbi", + "Dfbp", + "Dfoib", + "Dfpib", + "Dfiob", + "Dfipb", + "Dfpob", + "Dfopb", + "Df0wn", + "Dfw0n", + "Df0nw", + "Dfn0w", + "Dfnw0", + "Df0n", + "Df0iwn", + "Dfi0wn", + "Dfp0wn", + "Df0pwn", + "Df0inw", + "Dfi0nw", + "Dfp0nw", + "Df0pnw", + "Df0wb", + "Dfw0b", + "Df0bw", + "Dfb0w", + "Dfbw0", + "Df0b", + "Df0iwb", + "Dfi0wb", + "Dfp0wb", + "Df0pwb", + "Df0ibw", + "Dfi0bw", + "Dfp0bw", + "Df0pbw", + "Df0w", + "Dfw0", + "Dfn0", + "Df0iw", + "Dfi0w", + "Dfp0w", + "Df0pw", + "Df0in", + "Dfi0n", + "Dfp0n", + "Df0pn", + "Dfb0", + "Df0ib", + "Dfi0b", + "Dfp0b", + "Df0pb", + "Df9wn", + "Dfw9n", + "Df9nw", + "Dfn9w", + "Dfnw9", + "Df9n", + "Df9iwn", + "Dfi9wn", + "Dfp9wn", + "Df9pwn", + "Df9inw", + "Dfi9nw", + "Dfp9nw", + "Df9pnw", + "Df9wb", + "Dfw9b", + "Df9bw", + "Dfb9w", + "Dfbw9", + "Df9b", + "Df9iwb", + "Dfi9wb", + "Dfp9wb", + "Df9pwb", + "Df9ibw", + "Dfi9bw", + "Dfp9bw", + "Df9pbw", + "Df9w", + "Dfw9", + "Dfn9", + "Df9iw", + "Dfi9w", + "Dfp9w", + "Df9pw", + "Df9in", + "Dfi9n", + "Dfp9n", + "Df9pn", + "Dfb9", + "Df9ib", + "Dfi9b", + "Dfp9b", + "Df9pb", + "Fv", + "F↓", + "FSouth", + "FS", + "F▼", + "Fsown", + "Fswon", + "Fsonw", + "Fsnow", + "Fsnwo", + "Fsiwn", + "Fsinw", + "Fsniw", + "Fsnwi", + "Fspwn", + "Fswpn", + "Fspnw", + "Fsnpw", + "Fsnwp", + "Fspn", + "Fsoiwn", + "Fspiwn", + "Fsiown", + "Fsipwn", + "Fspown", + "Fsopwn", + "Fsoinw", + "Fsionw", + "Fsipnw", + "Fsponw", + "Fsopnw", + "Fsowb", + "Fswob", + "Fsobw", + "Fsbow", + "Fsbwo", + "Fsiwb", + "Fswib", + "Fsibw", + "Fsbiw", + "Fsbwi", + "Fspwb", + "Fswpb", + "Fspbw", + "Fsbpw", + "Fsbwp", + "Fsob", + "Fsib", + "Fspb", + "Fsoiwb", + "Fspiwb", + "Fsiowb", + "Fsipwb", + "Fspowb", + "Fsopwb", + "Fsoibw", + "Fspibw", + "Fsiobw", + "Fsipbw", + "Fspobw", + "Fsopbw", + "Fsow", + "Fswo", + "Fsno", + "Fsnw", + "Fsiw", + "Fswi", + "Fsni", + "Fspw", + "Fswp", + "Fsnp", + "Fsoiw", + "Fspiw", + "Fsiow", + "Fsipw", + "Fspow", + "Fsopw", + "Fsoin", + "Fsion", + "Fsipn", + "Fspon", + "Fsopn", + "Fsbo", + "Fsbw", + "Fsbi", + "Fsbp", + "Fsoib", + "Fspib", + "Fsiob", + "Fsipb", + "Fspob", + "Fsopb", + "FS0uth", + "Fs0wn", + "Fsw0n", + "Fs0nw", + "Fsn0w", + "Fsnw0", + "Fs0n", + "Fs0iwn", + "Fsi0wn", + "Fsp0wn", + "Fs0pwn", + "Fs0inw", + "Fsi0nw", + "Fsp0nw", + "Fs0pnw", + "Fs0wb", + "Fsw0b", + "Fs0bw", + "Fsb0w", + "Fsbw0", + "Fs0b", + "Fs0iwb", + "Fsi0wb", + "Fsp0wb", + "Fs0pwb", + "Fs0ibw", + "Fsi0bw", + "Fsp0bw", + "Fs0pbw", + "Fs0w", + "Fsw0", + "Fsn0", + "Fs0iw", + "Fsi0w", + "Fsp0w", + "Fs0pw", + "Fs0in", + "Fsi0n", + "Fsp0n", + "Fs0pn", + "Fsb0", + "Fs0ib", + "Fsi0b", + "Fsp0b", + "Fs0pb", + "FS9uth", + "Fs9wn", + "Fsw9n", + "Fs9nw", + "Fsn9w", + "Fsnw9", + "Fs9n", + "Fs9iwn", + "Fsi9wn", + "Fsp9wn", + "Fs9pwn", + "Fs9inw", + "Fsi9nw", + "Fsp9nw", + "Fs9pnw", + "Fs9wb", + "Fsw9b", + "Fs9bw", + "Fsb9w", + "Fsbw9", + "Fs9b", + "Fs9iwb", + "Fsi9wb", + "Fsp9wb", + "Fs9pwb", + "Fs9ibw", + "Fsi9bw", + "Fsp9bw", + "Fs9pbw", + "Fs9w", + "Fsw9", + "Fsn9", + "Fs9iw", + "Fsi9w", + "Fsp9w", + "Fs9pw", + "Fs9in", + "Fsi9n", + "Fsp9n", + "Fs9pn", + "Fsb9", + "Fs9ib", + "Fsi9b", + "Fsp9b", + "Fs9pb", + "Dpaddown", + "Dpaddwon", + "Dpaddonw", + "Dpaddnow", + "Dpaddnwo", + "DpadD", + "Dpadv", + "Dpad↓", + "DpadSouth", + "DpadS", + "Dpad▼", + "Dpaddiwn", + "Dpaddwin", + "Dpaddinw", + "Dpaddniw", + "Dpaddnwi", + "Dpaddpwn", + "Dpaddwpn", + "Dpaddpnw", + "Dpaddnpw", + "Dpaddnwp", + "Dpaddon", + "Dpaddin", + "Dpaddpn", + "Dpaddoiwn", + "Dpaddpiwn", + "Dpaddipwn", + "Dpaddpown", + "Dpaddopwn", + "Dpaddoinw", + "Dpaddpinw", + "Dpaddipnw", + "Dpaddponw", + "Dpaddopnw", + "Dpaddowb", + "Dpaddwob", + "Dpaddobw", + "Dpaddbow", + "Dpaddbwo", + "Dpaddiwb", + "Dpaddwib", + "Dpaddibw", + "Dpaddbiw", + "Dpaddbwi", + "Dpaddpwb", + "Dpaddwpb", + "Dpaddpbw", + "Dpaddbpw", + "Dpaddbwp", + "Dpaddob", + "Dpaddib", + "Dpaddpb", + "Dpaddoiwb", + "Dpaddpiwb", + "Dpaddipwb", + "Dpaddpowb", + "Dpaddopwb", + "Dpaddoibw", + "Dpaddpibw", + "Dpaddipbw", + "Dpaddpobw", + "Dpaddopbw", + "Dpadsown", + "Dpadswon", + "Dpadsonw", + "Dpadsnow", + "Dpadsnwo", + "Dpadsiwn", + "Dpadsinw", + "Dpadsniw", + "Dpadsnwi", + "Dpadspwn", + "Dpadswpn", + "Dpadspnw", + "Dpadsnpw", + "Dpadsnwp", + "Dpadspn", + "Dpadsoiwn", + "Dpadspiwn", + "Dpadsiown", + "Dpadsipwn", + "Dpadspown", + "Dpadsopwn", + "Dpadsoinw", + "Dpadsionw", + "Dpadsipnw", + "Dpadsponw", + "Dpadsopnw", + "Dpadsowb", + "Dpadswob", + "Dpadsobw", + "Dpadsbow", + "Dpadsbwo", + "Dpadsiwb", + "Dpadswib", + "Dpadsibw", + "Dpadsbiw", + "Dpadsbwi", + "Dpadspwb", + "Dpadswpb", + "Dpadspbw", + "Dpadsbpw", + "Dpadsbwp", + "Dpadsob", + "Dpadsib", + "Dpadspb", + "Dpadsoiwb", + "Dpadspiwb", + "Dpadsiowb", + "Dpadsipwb", + "Dpadspowb", + "Dpadsopwb", + "Dpadsoibw", + "Dpadspibw", + "Dpadsiobw", + "Dpadsipbw", + "Dpadspobw", + "Dpadsopbw", + "Dpaddow", + "Dpaddwo", + "Dpaddno", + "Dpaddnw", + "Dpaddiw", + "Dpaddwi", + "Dpaddni", + "Dpaddpw", + "Dpaddwp", + "Dpaddnp", + "Dpaddoiw", + "Dpaddpiw", + "Dpaddipw", + "Dpaddpow", + "Dpaddopw", + "Dpaddoin", + "Dpaddpin", + "Dpaddipn", + "Dpaddpon", + "Dpaddopn", + "Dpaddbo", + "Dpaddbw", + "Dpaddbi", + "Dpaddbp", + "Dpaddoib", + "Dpaddpib", + "Dpaddipb", + "Dpaddpob", + "Dpaddopb", + "Dpadsow", + "Dpadswo", + "Dpadsno", + "Dpadsnw", + "Dpadsiw", + "Dpadswi", + "Dpadsni", + "Dpadspw", + "Dpadswp", + "Dpadsnp", + "Dpadsoiw", + "Dpadspiw", + "Dpadsiow", + "Dpadsipw", + "Dpadspow", + "Dpadsopw", + "Dpadsoin", + "Dpadsion", + "Dpadsipn", + "Dpadspon", + "Dpadsopn", + "Dpadsbo", + "Dpadsbw", + "Dpadsbi", + "Dpadsbp", + "Dpadsoib", + "Dpadspib", + "Dpadsiob", + "Dpadsipb", + "Dpadspob", + "Dpadsopb", + "Dpadd0wn", + "Dpaddw0n", + "Dpadd0nw", + "Dpaddn0w", + "Dpaddnw0", + "DpadS0uth", + "Dpadd0n", + "Dpadd0iwn", + "Dpaddi0wn", + "Dpaddp0wn", + "Dpadd0pwn", + "Dpadd0inw", + "Dpaddi0nw", + "Dpaddp0nw", + "Dpadd0pnw", + "Dpadd0wb", + "Dpaddw0b", + "Dpadd0bw", + "Dpaddb0w", + "Dpaddbw0", + "Dpadd0b", + "Dpadd0iwb", + "Dpaddi0wb", + "Dpaddp0wb", + "Dpadd0pwb", + "Dpadd0ibw", + "Dpaddi0bw", + "Dpaddp0bw", + "Dpadd0pbw", + "Dpads0wn", + "Dpadsw0n", + "Dpads0nw", + "Dpadsn0w", + "Dpadsnw0", + "Dpads0n", + "Dpads0iwn", + "Dpadsi0wn", + "Dpadsp0wn", + "Dpads0pwn", + "Dpads0inw", + "Dpadsi0nw", + "Dpadsp0nw", + "Dpads0pnw", + "Dpads0wb", + "Dpadsw0b", + "Dpads0bw", + "Dpadsb0w", + "Dpadsbw0", + "Dpads0b", + "Dpads0iwb", + "Dpadsi0wb", + "Dpadsp0wb", + "Dpads0pwb", + "Dpads0ibw", + "Dpadsi0bw", + "Dpadsp0bw", + "Dpads0pbw", + "Dpadd0w", + "Dpaddw0", + "Dpaddn0", + "Dpadd0iw", + "Dpaddi0w", + "Dpaddp0w", + "Dpadd0pw", + "Dpadd0in", + "Dpaddi0n", + "Dpaddp0n", + "Dpadd0pn", + "Dpaddb0", + "Dpadd0ib", + "Dpaddi0b", + "Dpaddp0b", + "Dpadd0pb", + "Dpads0w", + "Dpadsw0", + "Dpadsn0", + "Dpads0iw", + "Dpadsi0w", + "Dpadsp0w", + "Dpads0pw", + "Dpads0in", + "Dpadsi0n", + "Dpadsp0n", + "Dpads0pn", + "Dpadsb0", + "Dpads0ib", + "Dpadsi0b", + "Dpadsp0b", + "Dpads0pb", + "Dpadd9wn", + "Dpaddw9n", + "Dpadd9nw", + "Dpaddn9w", + "Dpaddnw9", + "DpadS9uth", + "Dpadd9n", + "Dpadd9iwn", + "Dpaddi9wn", + "Dpaddp9wn", + "Dpadd9pwn", + "Dpadd9inw", + "Dpaddi9nw", + "Dpaddp9nw", + "Dpadd9pnw", + "Dpadd9wb", + "Dpaddw9b", + "Dpadd9bw", + "Dpaddb9w", + "Dpaddbw9", + "Dpadd9b", + "Dpadd9iwb", + "Dpaddi9wb", + "Dpaddp9wb", + "Dpadd9pwb", + "Dpadd9ibw", + "Dpaddi9bw", + "Dpaddp9bw", + "Dpadd9pbw", + "Dpads9wn", + "Dpadsw9n", + "Dpads9nw", + "Dpadsn9w", + "Dpadsnw9", + "Dpads9n", + "Dpads9iwn", + "Dpadsi9wn", + "Dpadsp9wn", + "Dpads9pwn", + "Dpads9inw", + "Dpadsi9nw", + "Dpadsp9nw", + "Dpads9pnw", + "Dpads9wb", + "Dpadsw9b", + "Dpads9bw", + "Dpadsb9w", + "Dpadsbw9", + "Dpads9b", + "Dpads9iwb", + "Dpadsi9wb", + "Dpadsp9wb", + "Dpads9pwb", + "Dpads9ibw", + "Dpadsi9bw", + "Dpadsp9bw", + "Dpads9pbw", + "Dpadd9w", + "Dpaddw9", + "Dpaddn9", + "Dpadd9iw", + "Dpaddi9w", + "Dpaddp9w", + "Dpadd9pw", + "Dpadd9in", + "Dpaddi9n", + "Dpaddp9n", + "Dpadd9pn", + "Dpaddb9", + "Dpadd9ib", + "Dpaddi9b", + "Dpaddp9b", + "Dpadd9pb", + "Dpads9w", + "Dpadsw9", + "Dpadsn9", + "Dpads9iw", + "Dpadsi9w", + "Dpadsp9w", + "Dpads9pw", + "Dpads9in", + "Dpadsi9n", + "Dpadsp9n", + "Dpads9pn", + "Dpadsb9", + "Dpads9ib", + "Dpadsi9b", + "Dpadsp9b", + "Dpads9pb", + "Dpadfown", + "Dpadfwon", + "Dpadfonw", + "Dpadfnow", + "Dpadfnwo", + "Dpadf", + "Dpadfiwn", + "Dpadfwin", + "Dpadfinw", + "Dpadfniw", + "Dpadfnwi", + "Dpadfwpn", + "Dpadfpnw", + "Dpadfnpw", + "Dpadfnwp", + "Dpadfon", + "Dpadfin", + "Dpadfpn", + "Dpadfoiwn", + "Dpadfpiwn", + "Dpadfiown", + "Dpadfipwn", + "Dpadfpown", + "Dpadfopwn", + "Dpadfoinw", + "Dpadfpinw", + "Dpadfionw", + "Dpadfipnw", + "Dpadfponw", + "Dpadfopnw", + "Dpadfowb", + "Dpadfwob", + "Dpadfobw", + "Dpadfbow", + "Dpadfbwo", + "Dpadfiwb", + "Dpadfwib", + "Dpadfibw", + "Dpadfbiw", + "Dpadfbwi", + "Dpadfwpb", + "Dpadfpbw", + "Dpadfbpw", + "Dpadfbwp", + "Dpadfob", + "Dpadfib", + "Dpadfpb", + "Dpadfoiwb", + "Dpadfpiwb", + "Dpadfiowb", + "Dpadfipwb", + "Dpadfpowb", + "Dpadfopwb", + "Dpadfoibw", + "Dpadfpibw", + "Dpadfiobw", + "Dpadfipbw", + "Dpadfpobw", + "Dpadfopbw", + "Dpadfow", + "Dpadfwo", + "Dpadfno", + "Dpadfnw", + "Dpadfiw", + "Dpadfwi", + "Dpadfni", + "Dpadfwp", + "Dpadfnp", + "Dpadfoiw", + "Dpadfpiw", + "Dpadfiow", + "Dpadfipw", + "Dpadfpow", + "Dpadfopw", + "Dpadfoin", + "Dpadfpin", + "Dpadfion", + "Dpadfipn", + "Dpadfpon", + "Dpadfopn", + "Dpadfbo", + "Dpadfbw", + "Dpadfbi", + "Dpadfbp", + "Dpadfoib", + "Dpadfpib", + "Dpadfiob", + "Dpadfipb", + "Dpadfpob", + "Dpadfopb", + "Dpadf0wn", + "Dpadfw0n", + "Dpadf0nw", + "Dpadfn0w", + "Dpadfnw0", + "Dpadf0n", + "Dpadf0iwn", + "Dpadfi0wn", + "Dpadfp0wn", + "Dpadf0pwn", + "Dpadf0inw", + "Dpadfi0nw", + "Dpadfp0nw", + "Dpadf0pnw", + "Dpadf0wb", + "Dpadfw0b", + "Dpadf0bw", + "Dpadfb0w", + "Dpadfbw0", + "Dpadf0b", + "Dpadf0iwb", + "Dpadfi0wb", + "Dpadfp0wb", + "Dpadf0pwb", + "Dpadf0ibw", + "Dpadfi0bw", + "Dpadfp0bw", + "Dpadf0pbw", + "Dpadf0w", + "Dpadfw0", + "Dpadfn0", + "Dpadf0iw", + "Dpadfi0w", + "Dpadfp0w", + "Dpadf0pw", + "Dpadf0in", + "Dpadfi0n", + "Dpadfp0n", + "Dpadf0pn", + "Dpadfb0", + "Dpadf0ib", + "Dpadfi0b", + "Dpadfp0b", + "Dpadf0pb", + "Dpadf9wn", + "Dpadfw9n", + "Dpadf9nw", + "Dpadfn9w", + "Dpadfnw9", + "Dpadf9n", + "Dpadf9iwn", + "Dpadfi9wn", + "Dpadfp9wn", + "Dpadf9pwn", + "Dpadf9inw", + "Dpadfi9nw", + "Dpadfp9nw", + "Dpadf9pnw", + "Dpadf9wb", + "Dpadfw9b", + "Dpadf9bw", + "Dpadfb9w", + "Dpadfbw9", + "Dpadf9b", + "Dpadf9iwb", + "Dpadfi9wb", + "Dpadfp9wb", + "Dpadf9pwb", + "Dpadf9ibw", + "Dpadfi9bw", + "Dpadfp9bw", + "Dpadf9pbw", + "Dpadf9w", + "Dpadfw9", + "Dpadfn9", + "Dpadf9iw", + "Dpadfi9w", + "Dpadfp9w", + "Dpadf9pw", + "Dpadf9in", + "Dpadfi9n", + "Dpadfp9n", + "Dpadf9pn", + "Dpadfb9", + "Dpadf9ib", + "Dpadfi9b", + "Dpadfp9b", + "Dpadf9pb", + "Dsp9mw", + "Ds9pmw", + "Ddm9", + "Dd9im", + "Ddi9m", + "Ddp9m", + "Dd9pm", + "Dsm9", + "Ds9im", + "Dsi9m", + "Dsp9m", + "Ds9pm", + "Dfowm", + "Dfwom", + "Dfomw", + "Dfmow", + "Dfmwo", + "Dfiwm", + "Dfwim", + "Dfimw", + "Dfmiw", + "Dfmwi", + "Dfwpm", + "Dfpmw", + "Dfmpw", + "Dfmwp", + "Dfom", + "Dfim", + "Dfpm", + "Dfoiwm", + "Dfpiwm", + "Dfiowm", + "Dfipwm", + "Dfpowm", + "Dfopwm", + "Dfoimw", + "Dfpimw", + "Dfiomw", + "Dfipmw", + "Dfpomw", + "Dfopmw", + "Dfmo", + "Dfmw", + "Dfmi", + "Dfmp", + "Dfoim", + "Dfpim", + "Dfiom", + "Dfipm", + "Dfpom", + "Dfopm", + "Df0wm", + "Dfw0m", + "Df0mw", + "Dfm0w", + "Dfmw0", + "Df0m", + "Df0iwm", + "Dfi0wm", + "Dfp0wm", + "Df0pwm", + "Df0imw", + "Dfi0mw", + "Dfp0mw", + "Df0pmw", + "Dfm0", + "Df0im", + "Dfi0m", + "Dfp0m", + "Df0pm", + "Df9wm", + "Dfw9m", + "Df9mw", + "Dfm9w", + "Dfmw9", + "Df9m", + "Df9iwm", + "Dfi9wm", + "Dfp9wm", + "Df9pwm", + "Df9imw", + "Dfi9mw", + "Dfp9mw", + "Df9pmw", + "Dfm9", + "Df9im", + "Dfi9m", + "Dfp9m", + "Df9pm", + "Fsowm", + "Fswom", + "Fsomw", + "Fsmow", + "Fsmwo", + "Fsiwm", + "Fsimw", + "Fsmiw", + "Fsmwi", + "Fspwm", + "Fswpm", + "Fspmw", + "Fsmpw", + "Fsmwp", + "Fsom", + "Fsim", + "Fspm", + "Fsoiwm", + "Fspiwm", + "Fsiowm", + "Fsipwm", + "Fspowm", + "Fsopwm", + "Fsoimw", + "Fsiomw", + "Fsipmw", + "Fspomw", + "Fsopmw", + "Fsmo", + "Fsmw", + "Fsmi", + "Fsmp", + "Fsoim", + "Fsiom", + "Fsipm", + "Fspom", + "Fsopm", + "Fs0wm", + "Fsw0m", + "Fs0mw", + "Fsm0w", + "Fsmw0", + "Fs0m", + "Fs0iwm", + "Fsi0wm", + "Fsp0wm", + "Fs0pwm", + "Fs0imw", + "Fsi0mw", + "Fsp0mw", + "Fs0pmw", + "Fsm0", + "Fs0im", + "Fsi0m", + "Fsp0m", + "Fs0pm", + "Fs9wm", + "Fsw9m", + "Fs9mw", + "Fsm9w", + "Fsmw9", + "Fs9m", + "Fs9iwm", + "Fsi9wm", + "Fsp9wm", + "Fs9pwm", + "Fs9imw", + "Fsi9mw", + "Fsp9mw", + "Fs9pmw", + "Fsm9", + "Fs9im", + "Fsi9m", + "Fsp9m", + "Fs9pm", + "Dpaddowm", + "Dpaddwom", + "Dpaddomw", + "Dpaddmow", + "Dpaddmwo", + "Dpaddiwm", + "Dpaddwim", + "Dpaddimw", + "Dpaddmiw", + "Dpaddmwi", + "Dpaddpwm", + "Dpaddwpm", + "Dpaddpmw", + "Dpaddmpw", + "Dpaddmwp", + "Dpaddom", + "Dpaddim", + "Dpaddpm", + "Dpaddoiwm", + "Dpaddpiwm", + "Dpaddipwm", + "Dpaddpowm", + "Dpaddopwm", + "Dpaddoimw", + "Dpaddpimw", + "Dpaddipmw", + "Dpaddpomw", + "Dpaddopmw", + "Dpadsowm", + "Dpadswom", + "Dpadsomw", + "Dpadsmow", + "Dpadsmwo", + "Dpadsiwm", + "Dpadsimw", + "Dpadsmiw", + "Dpadsmwi", + "Dpadspwm", + "Dpadswpm", + "Dpadspmw", + "Dpadsmpw", + "Dpadsmwp", + "Dpadsom", + "Dpadsim", + "Dpadspm", + "Dpadsoiwm", + "Dpadspiwm", + "Dpadsiowm", + "Dpadsipwm", + "Dpadspowm", + "Dpadsopwm", + "Dpadsoimw", + "Dpadsiomw", + "Dpadsipmw", + "Dpadspomw", + "Dpadsopmw", + "Dpaddmo", + "Dpaddmw", + "Dpaddmi", + "Dpaddmp", + "Dpaddoim", + "Dpaddpim", + "Dpaddipm", + "Dpaddpom", + "Dpaddopm", + "Dpadsmo", + "Dpadsmw", + "Dpadsmi", + "Dpadsmp", + "Dpadsoim", + "Dpadsiom", + "Dpadsipm", + "Dpadspom", + "Dpadsopm", + "Dpadd0wm", + "Dpaddw0m", + "Dpadd0mw", + "Dpaddm0w", + "Dpaddmw0", + "Dpadd0m", + "Dpadd0iwm", + "Dpaddi0wm", + "Dpaddp0wm", + "Dpadd0pwm", + "Dpadd0imw", + "Dpaddi0mw", + "Dpaddp0mw", + "Dpadd0pmw", + "Dpads0wm", + "Dpadsw0m", + "Dpads0mw", + "Dpadsm0w", + "Dpadsmw0", + "Dpads0m", + "Dpads0iwm", + "Dpadsi0wm", + "Dpadsp0wm", + "Dpads0pwm", + "Dpads0imw", + "Dpadsi0mw", + "Dpadsp0mw", + "Dpads0pmw", + "Dpaddm0", + "Dpadd0im", + "Dpaddi0m", + "Dpaddp0m", + "Dpadd0pm", + "Dpadsm0", + "Dpads0im", + "Dpadsi0m", + "Dpadsp0m", + "Dpads0pm", + "Dpadd9wm", + "Dpaddw9m", + "Dpadd9mw", + "Dpaddm9w", + "Dpaddmw9", + "Dpadd9m", + "Dpadd9iwm", + "Dpaddi9wm", + "Dpaddp9wm", + "Dpadd9pwm", + "Dpadd9imw", + "Dpaddi9mw", + "Dpaddp9mw", + "Dpadd9pmw", + "Dpads9wm", + "Dpadsw9m", + "Dpads9mw", + "Dpadsm9w", + "Dpadsmw9", + "Dpads9m", + "Dpads9iwm", + "Dpadsi9wm", + "Dpadsp9wm", + "Dpads9pwm", + "Dpads9imw", + "Dpadsi9mw", + "Dpadsp9mw", + "Dpads9pmw", + "Dpaddm9", + "Dpadd9im", + "Dpaddi9m", + "Dpaddp9m", + "Dpadd9pm", + "Dpadsm9", + "Dpads9im", + "Dpadsi9m", + "Dpadsp9m", + "Dpads9pm", + "Dpadfowm", + "Dpadfwom", + "Dpadfomw", + "Dpadfmow", + "Dpadfmwo", + "Dpadfiwm", + "Dpadfwim", + "Dpadfimw", + "Dpadfmiw", + "Dpadfmwi", + "Dpadfwpm", + "Dpadfpmw", + "Dpadfmpw", + "Dpadfmwp", + "Dpadfom", + "Dpadfim", + "Dpadfpm", + "Dpadfoiwm", + "Dpadfpiwm", + "Dpadfiowm", + "Dpadfipwm", + "Dpadfpowm", + "Dpadfopwm", + "Dpadfoimw", + "Dpadfpimw", + "Dpadfiomw", + "Dpadfipmw", + "Dpadfpomw", + "Dpadfopmw", + "Dpadfmo", + "Dpadfmw", + "Dpadfmi", + "Dpadfmp", + "Dpadfoim", + "Dpadfpim", + "Dpadfiom", + "Dpadfipm", + "Dpadfpom", + "Dpadfopm", + "Dpadf0wm", + "Dpadfw0m", + "Dpadf0mw", + "Dpadfm0w", + "Dpadfmw0", + "Dpadf0m", + "Dpadf0iwm", + "Dpadfi0wm", + "Dpadfp0wm", + "Dpadf0pwm", + "Dpadf0imw", + "Dpadfi0mw", + "Dpadfp0mw", + "Dpadf0pmw", + "Dpadfm0", + "Dpadf0im", + "Dpadfi0m", + "Dpadfp0m", + "Dpadf0pm", + "Dpadf9wm", + "Dpadfw9m", + "Dpadf9mw", + "Dpadfm9w", + "Dpadfmw9", + "Dpadf9m", + "Dpadf9iwm", + "Dpadfi9wm", + "Dpadfp9wm", + "Dpadf9pwm", + "Dpadf9imw", + "Dpadfi9mw", + "Dpadfp9mw", + "Dpadf9pmw", + "Dpadfm9", + "Dpadf9im", + "Dpadfi9m", + "Dpadfp9m", + "Dpadf9pm", + "Ddoen", + "Ddeon", + "Ddone", + "Ddnoe", + "Ddneo", + "Ddein", + "Ddine", + "Ddnie", + "Ddnei", + "Ddpen", + "Ddepn", + "Ddpne", + "Ddnpe", + "Ddnep", + "Ddoien", + "Ddpien", + "Ddipen", + "Ddpoen", + "Ddoine", + "Ddpine", + "Ddipne", + "Ddpone", + "Ddopne", + "Ddoeb", + "Ddeob", + "Ddobe", + "Ddboe", + "Ddbeo", + "Ddeib", + "Ddibe", + "Ddbie", + "Ddbei", + "Ddpeb", + "Ddepb", + "Ddpbe", + "Ddbpe", + "Ddbep", + "Ddoieb", + "Ddpieb", + "Ddipeb", + "Ddpoeb", + "Ddoibe", + "Ddpibe", + "Ddipbe", + "Ddpobe", + "Ddopbe", + "Dsoen", + "Dseon", + "Dsone", + "Dsnoe", + "Dsneo", + "Dsien", + "Dsein", + "Dsine", + "Dsnie", + "Dsnei", + "Dspen", + "Dsepn", + "Dspne", + "Dsnpe", + "Dsnep", + "Dsoien", + "Dspien", + "Dsioen", + "Dsipen", + "Dspoen", + "Dsopen", + "Dsoine", + "Dsione", + "Dsipne", + "Dspone", + "Dsopne", + "Dsoeb", + "Dseob", + "Dsobe", + "Dsboe", + "Dsbeo", + "Dsieb", + "Dseib", + "Dsibe", + "Dsbie", + "Dsbei", + "Dspeb", + "Dsepb", + "Dspbe", + "Dsbpe", + "Dsbep", + "Dsoieb", + "Dspieb", + "Dsioeb", + "Dsipeb", + "Dspoeb", + "Dsopeb", + "Dsoibe", + "Dspibe", + "Dsiobe", + "Dsipbe", + "Dspobe", + "Dsopbe", + "Ddoe", + "Ddeo", + "Ddne", + "Ddei", + "Ddpe", + "Ddep", + "Ddoie", + "Ddpie", + "Ddipe", + "Ddpoe", + "Ddbe", + "Dsoe", + "Dseo", + "Dsne", + "Dsie", + "Dsei", + "Dspe", + "Dsep", + "Dsoie", + "Dspie", + "Dsioe", + "Dsipe", + "Dspoe", + "Dsope", + "Dsbe", + "Dd0en", + "Dde0n", + "Dd0ne", + "Ddn0e", + "Ddne0", + "Dd0ien", + "Ddi0en", + "Ddp0en", + "Dd0pen", + "Dd0ine", + "Ddi0ne", + "Ddp0ne", + "Dd0pne", + "Dd0eb", + "Dde0b", + "Dd0be", + "Ddb0e", + "Ddbe0", + "Dd0ieb", + "Ddi0eb", + "Ddp0eb", + "Dd0peb", + "Dd0ibe", + "Ddi0be", + "Ddp0be", + "Dd0pbe", + "Ds0en", + "Dse0n", + "Ds0ne", + "Dsn0e", + "Dsne0", + "Ds0ien", + "Dsi0en", + "Dsp0en", + "Ds0pen", + "Ds0ine", + "Dsi0ne", + "Dsp0ne", + "Ds0pne", + "Ds0eb", + "Dse0b", + "Ds0be", + "Dsb0e", + "Dsbe0", + "Ds0ieb", + "Dsi0eb", + "Dsp0eb", + "Ds0peb", + "Ds0ibe", + "Dsi0be", + "Dsp0be", + "Ds0pbe", + "Dd0e", + "Dde0", + "Dd0ie", + "Ddi0e", + "Ddp0e", + "Dd0pe", + "Ds0e", + "Dse0", + "Ds0ie", + "Dsi0e", + "Dsp0e", + "Ds0pe", + "Dd9en", + "Dde9n", + "Dd9ne", + "Ddn9e", + "Ddne9", + "Dd9ien", + "Ddi9en", + "Ddp9en", + "Dd9pen", + "Dd9ine", + "Ddi9ne", + "Ddp9ne", + "Dd9pne", + "Dd9eb", + "Dde9b", + "Dd9be", + "Ddb9e", + "Ddbe9", + "Dd9ieb", + "Ddi9eb", + "Ddp9eb", + "Dd9peb", + "Dd9ibe", + "Ddi9be", + "Ddp9be", + "Dd9pbe", + "Ds9en", + "Dse9n", + "Ds9ne", + "Dsn9e", + "Dsne9", + "Ds9ien", + "Dsi9en", + "Dsp9en", + "Ds9pen", + "Ds9ine", + "Dsi9ne", + "Dsp9ne", + "Ds9pne", + "Ds9eb", + "Dse9b", + "Ds9be", + "Dsb9e", + "Dsbe9", + "Ds9ieb", + "Dsi9eb", + "Dsp9eb", + "Ds9peb", + "Ds9ibe", + "Dsi9be", + "Dsp9be", + "Ds9pbe", + "Dd9e", + "Dde9", + "Dd9ie", + "Ddi9e", + "Ddp9e", + "Dd9pe", + "Ds9e", + "Dse9", + "Ds9ie", + "Dsi9e", + "Dsp9e", + "Ds9pe", + "Dfoen", + "Dfeon", + "Dfone", + "Dfnoe", + "Dfneo", + "Dfien", + "Dfein", + "Dfnie", + "Dfnei", + "Dfpen", + "Dfepn", + "Dfpne", + "Dfnpe", + "Dfnep", + "Dfoien", + "Dfpien", + "Dfioen", + "Dfipen", + "Dfpoen", + "Dfopen", + "Dfoine", + "Dfpine", + "Dfione", + "Dfipne", + "Dfpone", + "Dfopne", + "Dfoeb", + "Dfeob", + "Dfobe", + "Dfboe", + "Dfbeo", + "Dfieb", + "Dfeib", + "Dfibe", + "Dfbie", + "Dfbei", + "Dfpeb", + "Dfepb", + "Dfpbe", + "Dfbpe", + "Dfbep", + "Dfoieb", + "Dfpieb", + "Dfioeb", + "Dfipeb", + "Dfpoeb", + "Dfopeb", + "Dfoibe", + "Dfpibe", + "Dfiobe", + "Dfipbe", + "Dfpobe", + "Dfopbe", + "Dfoe", + "Dfeo", + "Dfne", + "Dfie", + "Dfei", + "Dfpe", + "Dfep", + "Dfoie", + "Dfpie", + "Dfioe", + "Dfipe", + "Dfpoe", + "Dfope", + "Dfbe", + "Df0en", + "Dfe0n", + "Df0ne", + "Dfn0e", + "Dfne0", + "Df0ien", + "Dfi0en", + "Dfp0en", + "Df0pen", + "Df0ine", + "Dfi0ne", + "Dfp0ne", + "Df0pne", + "Df0eb", + "Dfe0b", + "Df0be", + "Dfb0e", + "Dfbe0", + "Df0ieb", + "Dfi0eb", + "Dfp0eb", + "Df0peb", + "Df0ibe", + "Dfi0be", + "Dfp0be", + "Df0pbe", + "Df0e", + "Dfe0", + "Df0ie", + "Dfi0e", + "Dfp0e", + "Df0pe", + "Df9en", + "Dfe9n", + "Df9ne", + "Dfn9e", + "Dfne9", + "Df9ien", + "Dfi9en", + "Dfp9en", + "Df9pen", + "Df9ine", + "Dfi9ne", + "Dfp9ne", + "Df9pne", + "Df9eb", + "Dfe9b", + "Df9be", + "Dfb9e", + "Dfbe9", + "Df9ieb", + "Dfi9eb", + "Dfp9eb", + "Df9peb", + "Df9ibe", + "Dfi9be", + "Dfp9be", + "Df9pbe", + "Df9e", + "Dfe9", + "Df9ie", + "Dfi9e", + "Dfp9e", + "Df9pe", + "Fsoen", + "Fseon", + "Fsone", + "Fsnoe", + "Fsneo", + "Fsien", + "Fsein", + "Fsine", + "Fsnie", + "Fsnei", + "Fspen", + "Fsepn", + "Fspne", + "Fsnpe", + "Fsnep", + "Fsoien", + "Fspien", + "Fsioen", + "Fsipen", + "Fspoen", + "Fsopen", + "Fsoine", + "Fsione", + "Fsipne", + "Fspone", + "Fsopne", + "Fsoeb", + "Fseob", + "Fsobe", + "Fsboe", + "Fsbeo", + "Fsieb", + "Fseib", + "Fsibe", + "Fsbie", + "Fsbei", + "Fspeb", + "Fsepb", + "Fspbe", + "Fsbpe", + "Fsbep", + "Fsoieb", + "Fspieb", + "Fsioeb", + "Fsipeb", + "Fspoeb", + "Fsopeb", + "Fsoibe", + "Fspibe", + "Fsiobe", + "Fsipbe", + "Fspobe", + "Fsopbe", + "Fsoe", + "Fseo", + "Fsne", + "Fsie", + "Fsei", + "Fspe", + "Fsep", + "Fsoie", + "Fspie", + "Fsioe", + "Fsipe", + "Fspoe", + "Fsope", + "Fsbe", + "Fs0en", + "Fse0n", + "Fs0ne", + "Fsn0e", + "Fsne0", + "Fs0ien", + "Fsi0en", + "Fsp0en", + "Fs0pen", + "Fs0ine", + "Fsi0ne", + "Fsp0ne", + "Fs0pne", + "Fs0eb", + "Fse0b", + "Fs0be", + "Fsb0e", + "Fsbe0", + "Fs0ieb", + "Fsi0eb", + "Fsp0eb", + "Fs0peb", + "Fs0ibe", + "Fsi0be", + "Fsp0be", + "Fs0pbe", + "Fs0e", + "Fse0", + "Fs0ie", + "Fsi0e", + "Fsp0e", + "Fs0pe", + "Fs9en", + "Fse9n", + "Fs9ne", + "Fsn9e", + "Fsne9", + "Fs9ien", + "Fsi9en", + "Fsp9en", + "Fs9pen", + "Fs9ine", + "Fsi9ne", + "Fsp9ne", + "Fs9pne", + "Fs9eb", + "Fse9b", + "Fs9be", + "Fsb9e", + "Fsbe9", + "Fs9ieb", + "Fsi9eb", + "Fsp9eb", + "Fs9peb", + "Fs9ibe", + "Fsi9be", + "Fsp9be", + "Fs9pbe", + "Fs9e", + "Fse9", + "Fs9ie", + "Fsi9e", + "Fsp9e", + "Fs9pe", + "Dpaddoen", + "Dpaddeon", + "Dpaddone", + "Dpaddnoe", + "Dpaddneo", + "Dpaddein", + "Dpaddine", + "Dpaddnie", + "Dpaddnei", + "Dpaddpen", + "Dpaddepn", + "Dpaddpne", + "Dpaddnpe", + "Dpaddnep", + "Dpaddoien", + "Dpaddpien", + "Dpaddipen", + "Dpaddpoen", + "Dpaddoine", + "Dpaddpine", + "Dpaddipne", + "Dpaddpone", + "Dpaddopne", + "Dpaddoeb", + "Dpaddeob", + "Dpaddobe", + "Dpaddboe", + "Dpaddbeo", + "Dpaddeib", + "Dpaddibe", + "Dpaddbie", + "Dpaddbei", + "Dpaddpeb", + "Dpaddepb", + "Dpaddpbe", + "Dpaddbpe", + "Dpaddbep", + "Dpaddoieb", + "Dpaddpieb", + "Dpaddipeb", + "Dpaddpoeb", + "Dpaddoibe", + "Dpaddpibe", + "Dpaddipbe", + "Dpaddpobe", + "Dpaddopbe", + "Dpadsoen", + "Dpadseon", + "Dpadsone", + "Dpadsnoe", + "Dpadsneo", + "Dpadsien", + "Dpadsein", + "Dpadsine", + "Dpadsnie", + "Dpadsnei", + "Dpadspen", + "Dpadsepn", + "Dpadspne", + "Dpadsnpe", + "Dpadsnep", + "Dpadsoien", + "Dpadspien", + "Dpadsioen", + "Dpadsipen", + "Dpadspoen", + "Dpadsopen", + "Dpadsoine", + "Dpadsione", + "Dpadsipne", + "Dpadspone", + "Dpadsopne", + "Dpadsoeb", + "Dpadseob", + "Dpadsobe", + "Dpadsboe", + "Dpadsbeo", + "Dpadsieb", + "Dpadseib", + "Dpadsibe", + "Dpadsbie", + "Dpadsbei", + "Dpadspeb", + "Dpadsepb", + "Dpadspbe", + "Dpadsbpe", + "Dpadsbep", + "Dpadsoieb", + "Dpadspieb", + "Dpadsioeb", + "Dpadsipeb", + "Dpadspoeb", + "Dpadsopeb", + "Dpadsoibe", + "Dpadspibe", + "Dpadsiobe", + "Dpadsipbe", + "Dpadspobe", + "Dpadsopbe", + "Dpaddoe", + "Dpaddeo", + "Dpaddne", + "Dpaddei", + "Dpaddpe", + "Dpaddep", + "Dpaddoie", + "Dpaddpie", + "Dpaddipe", + "Dpaddpoe", + "Dpaddbe", + "Dpadsoe", + "Dpadseo", + "Dpadsne", + "Dpadsie", + "Dpadsei", + "Dpadspe", + "Dpadsep", + "Dpadsoie", + "Dpadspie", + "Dpadsioe", + "Dpadsipe", + "Dpadspoe", + "Dpadsope", + "Dpadsbe", + "Dpadd0en", + "Dpadde0n", + "Dpadd0ne", + "Dpaddn0e", + "Dpaddne0", + "Dpadd0ien", + "Dpaddi0en", + "Dpaddp0en", + "Dpadd0pen", + "Dpadd0ine", + "Dpaddi0ne", + "Dpaddp0ne", + "Dpadd0pne", + "Dpadd0eb", + "Dpadde0b", + "Dpadd0be", + "Dpaddb0e", + "Dpaddbe0", + "Dpadd0ieb", + "Dpaddi0eb", + "Dpaddp0eb", + "Dpadd0peb", + "Dpadd0ibe", + "Dpaddi0be", + "Dpaddp0be", + "Dpadd0pbe", + "Dpads0en", + "Dpadse0n", + "Dpads0ne", + "Dpadsn0e", + "Dpadsne0", + "Dpads0ien", + "Dpadsi0en", + "Dpadsp0en", + "Dpads0pen", + "Dpads0ine", + "Dpadsi0ne", + "Dpadsp0ne", + "Dpads0pne", + "Dpads0eb", + "Dpadse0b", + "Dpads0be", + "Dpadsb0e", + "Dpadsbe0", + "Dpads0ieb", + "Dpadsi0eb", + "Dpadsp0eb", + "Dpads0peb", + "Dpads0ibe", + "Dpadsi0be", + "Dpadsp0be", + "Dpads0pbe", + "Dpadd0e", + "Dpadde0", + "Dpadd0ie", + "Dpaddi0e", + "Dpaddp0e", + "Dpadd0pe", + "Dpads0e", + "Dpadse0", + "Dpads0ie", + "Dpadsi0e", + "Dpadsp0e", + "Dpads0pe", + "Dpadd9en", + "Dpadde9n", + "Dpadd9ne", + "Dpaddn9e", + "Dpaddne9", + "Dpadd9ien", + "Dpaddi9en", + "Dpaddp9en", + "Dpadd9pen", + "Dpadd9ine", + "Dpaddi9ne", + "Dpaddp9ne", + "Dpadd9pne", + "Dpadd9eb", + "Dpadde9b", + "Dpadd9be", + "Dpaddb9e", + "Dpaddbe9", + "Dpadd9ieb", + "Dpaddi9eb", + "Dpaddp9eb", + "Dpadd9peb", + "Dpadd9ibe", + "Dpaddi9be", + "Dpaddp9be", + "Dpadd9pbe", + "Dpads9en", + "Dpadse9n", + "Dpads9ne", + "Dpadsn9e", + "Dpadsne9", + "Dpads9ien", + "Dpadsi9en", + "Dpadsp9en", + "Dpads9pen", + "Dpads9ine", + "Dpadsi9ne", + "Dpadsp9ne", + "Dpads9pne", + "Dpads9eb", + "Dpadse9b", + "Dpads9be", + "Dpadsb9e", + "Dpadsbe9", + "Dpads9ieb", + "Dpadsi9eb", + "Dpadsp9eb", + "Dpads9peb", + "Dpads9ibe", + "Dpadsi9be", + "Dpadsp9be", + "Dpads9pbe", + "Dpadd9e", + "Dpadde9", + "Dpadd9ie", + "Dpaddi9e", + "Dpaddp9e", + "Dpadd9pe", + "Dpads9e", + "Dpadse9", + "Dpads9ie", + "Dpadsi9e", + "Dpadsp9e", + "Dpads9pe", + "Dpadfoen", + "Dpadfeon", + "Dpadfone", + "Dpadfnoe", + "Dpadfneo", + "Dpadfien", + "Dpadfein", + "Dpadfnie", + "Dpadfnei", + "Dpadfpen", + "Dpadfepn", + "Dpadfpne", + "Dpadfnpe", + "Dpadfnep", + "Dpadfoien", + "Dpadfpien", + "Dpadfioen", + "Dpadfipen", + "Dpadfpoen", + "Dpadfopen", + "Dpadfoine", + "Dpadfpine", + "Dpadfione", + "Dpadfipne", + "Dpadfpone", + "Dpadfopne", + "Dpadfoeb", + "Dpadfeob", + "Dpadfobe", + "Dpadfboe", + "Dpadfbeo", + "Dpadfieb", + "Dpadfeib", + "Dpadfibe", + "Dpadfbie", + "Dpadfbei", + "Dpadfpeb", + "Dpadfepb", + "Dpadfpbe", + "Dpadfbpe", + "Dpadfbep", + "Dpadfoieb", + "Dpadfpieb", + "Dpadfioeb", + "Dpadfipeb", + "Dpadfpoeb", + "Dpadfopeb", + "Dpadfoibe", + "Dpadfpibe", + "Dpadfiobe", + "Dpadfipbe", + "Dpadfpobe", + "Dpadfopbe", + "Dpadfoe", + "Dpadfeo", + "Dpadfne", + "Dpadfie", + "Dpadfei", + "Dpadfpe", + "Dpadfep", + "Dpadfoie", + "Dpadfpie", + "Dpadfioe", + "Dpadfipe", + "Dpadfpoe", + "Dpadfope", + "Dpadfbe", + "Dpadf0en", + "Dpadfe0n", + "Dpadf0ne", + "Dpadfn0e", + "Dpadfne0", + "Dpadf0ien", + "Dpadfi0en", + "Dpadfp0en", + "Dpadf0pen", + "Dpadf0ine", + "Dpadfi0ne", + "Dpadfp0ne", + "Dpadf0pne", + "Dpadf0eb", + "Dpadfe0b", + "Dpadf0be", + "Dpadfb0e", + "Dpadfbe0", + "Dpadf0ieb", + "Dpadfi0eb", + "Dpadfp0eb", + "Dpadf0peb", + "Dpadf0ibe", + "Dpadfi0be", + "Dpadfp0be", + "Dpadf0pbe", + "Dpadf0e", + "Dpadfe0", + "Dpadf0ie", + "Dpadfi0e", + "Dpadfp0e", + "Dpadf0pe", + "Dpadf9en", + "Dpadfe9n", + "Dpadf9ne", + "Dpadfn9e", + "Dpadfne9", + "Dpadf9ien", + "Dpadfi9en", + "Dpadfp9en", + "Dpadf9pen", + "Dpadf9ine", + "Dpadfi9ne", + "Dpadfp9ne", + "Dpadf9pne", + "Dpadf9eb", + "Dpadfe9b", + "Dpadf9be", + "Dpadfb9e", + "Dpadfbe9", + "Dpadf9ieb", + "Dpadfi9eb", + "Dpadfp9eb", + "Dpadf9peb", + "Dpadf9ibe", + "Dpadfi9be", + "Dpadfp9be", + "Dpadf9pbe", + "Dpadf9e", + "Dpadfe9", + "Dpadf9ie", + "Dpadfi9e", + "Dpadfp9e", + "Dpadf9pe", + "Ddoem", + "Ddeom", + "Ddome", + "Ddmoe", + "Ddmeo", + "Ddeim", + "Ddime", + "Ddmie", + "Ddmei", + "Ddpem", + "Ddepm", + "Ddpme", + "Ddmpe", + "Ddmep", + "Ddoiem", + "Ddpiem", + "Ddipem", + "Ddpoem", + "Ddoime", + "Ddpime", + "Ddipme", + "Ddpome", + "Ddopme", + "Dsoem", + "Dseom", + "Dsmoe", + "Dsmeo", + "Dsiem", + "Dseim", + "Dsime", + "Dsmie", + "Dsmei", + "Dspem", + "Dsepm", + "Dspme", + "Dsmpe", + "Dsmep", + "Dsoiem", + "Dspiem", + "Dsioem", + "Dsipem", + "Dspoem", + "Dsopem", + "Dsoime", + "Dsiome", + "Dsipme", + "Dspome", + "Dsopme", + "Ddme", + "Dsme", + "Dd0em", + "Dde0m", + "Dd0me", + "Ddm0e", + "Ddme0", + "Dd0iem", + "Ddi0em", + "Ddp0em", + "Dd0pem", + "Dd0ime", + "Ddi0me", + "Ddp0me", + "Dd0pme", + "Ds0em", + "Dse0m", + "Ds0me", + "Dsm0e", + "Dsme0", + "Ds0iem", + "Dsi0em", + "Dsp0em", + "Ds0pem", + "Ds0ime", + "Dsi0me", + "Dsp0me", + "Ds0pme", + "Dd9em", + "Dde9m", + "Dd9me", + "Ddm9e", + "Ddme9", + "Dd9iem", + "Ddi9em", + "Ddp9em", + "Dd9pem", + "Dd9ime", + "Ddi9me", + "Ddp9me", + "Dd9pme", + "Ds9em", + "Dse9m", + "Ds9me", + "Dsm9e", + "Dsme9", + "Ds9iem", + "Dsi9em", + "Dsp9em", + "Ds9pem", + "Ds9ime", + "Dsi9me", + "Dsp9me", + "Ds9pme", + "Dfoem", + "Dfeom", + "Dfome", + "Dfmoe", + "Dfmeo", + "Dfiem", + "Dfeim", + "Dfime", + "Dfmie", + "Dfmei", + "Dfpem", + "Dfepm", + "Dfpme", + "Dfmpe", + "Dfmep", + "Dfoiem", + "Dfpiem", + "Dfioem", + "Dfipem", + "Dfpoem", + "Dfopem", + "Dfoime", + "Dfpime", + "Dfiome", + "Dfipme", + "Dfpome", + "Dfopme", + "Dfme", + "Df0em", + "Dfe0m", + "Df0me", + "Dfm0e", + "Dfme0", + "Df0iem", + "Dfi0em", + "Dfp0em", + "Df0pem", + "Df0ime", + "Dfi0me", + "Dfp0me", + "Df0pme", + "Df9em", + "Dfe9m", + "Df9me", + "Dfm9e", + "Dfme9", + "Df9iem", + "Dfi9em", + "Dfp9em", + "Df9pem", + "Df9ime", + "Dfi9me", + "Dfp9me", + "Df9pme", + "Fsoem", + "Fseom", + "Fsmoe", + "Fsmeo", + "Fsiem", + "Fseim", + "Fsime", + "Fsmie", + "Fsmei", + "Fspem", + "Fsepm", + "Fspme", + "Fsmpe", + "Fsmep", + "Fsoiem", + "Fspiem", + "Fsioem", + "Fsipem", + "Fspoem", + "Fsopem", + "Fsoime", + "Fsiome", + "Fsipme", + "Fspome", + "Fsopme", + "Fsme", + "Fs0em", + "Fse0m", + "Fs0me", + "Fsm0e", + "Fsme0", + "Fs0iem", + "Fsi0em", + "Fsp0em", + "Fs0pem", + "Fs0ime", + "Fsi0me", + "Fsp0me", + "Fs0pme", + "Fs9em", + "Fse9m", + "Fs9me", + "Fsm9e", + "Fsme9", + "Fs9iem", + "Fsi9em", + "Fsp9em", + "Fs9pem", + "Fs9ime", + "Fsi9me", + "Fsp9me", + "Fs9pme", + "Dpaddoem", + "Dpaddeom", + "Dpaddome", + "Dpaddmoe", + "Dpaddmeo", + "Dpaddeim", + "Dpaddime", + "Dpaddmie", + "Dpaddmei", + "Dpaddpem", + "Dpaddepm", + "Dpaddpme", + "Dpaddmpe", + "Dpaddmep", + "Dpaddoiem", + "Dpaddpiem", + "Dpaddipem", + "Dpaddpoem", + "Dpaddoime", + "Dpaddpime", + "Dpaddipme", + "Dpaddpome", + "Dpaddopme", + "Dpadsoem", + "Dpadseom", + "Dpadsmoe", + "Dpadsmeo", + "Dpadsiem", + "Dpadseim", + "Dpadsime", + "Dpadsmie", + "Dpadsmei", + "Dpadspem", + "Dpadsepm", + "Dpadspme", + "Dpadsmpe", + "Dpadsmep", + "Dpadsoiem", + "Dpadspiem", + "Dpadsioem", + "Dpadsipem", + "Dpadspoem", + "Dpadsopem", + "Dpadsoime", + "Dpadsiome", + "Dpadsipme", + "Dpadspome", + "Dpadsopme", + "Dpaddme", + "Dpadsme", + "Dpadd0em", + "Dpadde0m", + "Dpadd0me", + "Dpaddm0e", + "Dpaddme0", + "Dpadd0iem", + "Dpaddi0em", + "Dpaddp0em", + "Dpadd0pem", + "Dpadd0ime", + "Dpaddi0me", + "Dpaddp0me", + "Dpadd0pme", + "Dpads0em", + "Dpadse0m", + "Dpads0me", + "Dpadsm0e", + "Dpadsme0", + "Dpads0iem", + "Dpadsi0em", + "Dpadsp0em", + "Dpads0pem", + "Dpads0ime", + "Dpadsi0me", + "Dpadsp0me", + "Dpads0pme", + "Dpadd9em", + "Dpadde9m", + "Dpadd9me", + "Dpaddm9e", + "Dpaddme9", + "Dpadd9iem", + "Dpaddi9em", + "Dpaddp9em", + "Dpadd9pem", + "Dpadd9ime", + "Dpaddi9me", + "Dpaddp9me", + "Dpadd9pme", + "Dpads9em", + "Dpadse9m", + "Dpads9me", + "Dpadsm9e", + "Dpadsme9", + "Dpads9iem", + "Dpadsi9em", + "Dpadsp9em", + "Dpads9pem", + "Dpads9ime", + "Dpadsi9me", + "Dpadsp9me", + "Dpads9pme", + "Dpadfoem", + "Dpadfeom", + "Dpadfome", + "Dpadfmoe", + "Dpadfmeo", + "Dpadfiem", + "Dpadfeim", + "Dpadfime", + "Dpadfmie", + "Dpadfmei", + "Dpadfpem", + "Dpadfepm", + "Dpadfpme", + "Dpadfmpe", + "Dpadfmep", + "Dpadfoiem", + "Dpadfpiem", + "Dpadfioem", + "Dpadfipem", + "Dpadfpoem", + "Dpadfopem", + "Dpadfoime", + "Dpadfpime", + "Dpadfiome", + "Dpadfipme", + "Dpadfpome", + "Dpadfopme", + "Dpadfme", + "Dpadf0em", + "Dpadfe0m", + "Dpadf0me", + "Dpadfm0e", + "Dpadfme0", + "Dpadf0iem", + "Dpadfi0em", + "Dpadfp0em", + "Dpadf0pem", + "Dpadf0ime", + "Dpadfi0me", + "Dpadfp0me", + "Dpadf0pme", + "Dpadf9em", + "Dpadfe9m", + "Dpadf9me", + "Dpadfm9e", + "Dpadfme9", + "Dpadf9iem", + "Dpadfi9em", + "Dpadfp9em", + "Dpadf9pem", + "Dpadf9ime", + "Dpadfi9me", + "Dpadfp9me", + "Dpadf9pme", + "DBackward", + "DBackwards", + "DBack", + "DpadBackward", + "DpadBackwards", + "DpadBack", + "DBackwars", + "DBackwarss", + "DpadBackwars", + "DpadBackwarss", + "DBackwar", + "DpadBackwar", + "DBacxkward", + "DBacxkwards", + "DBacxk", + "DpadBacxkward", + "DpadBacxkwards", + "DpadBacxk", + "DBaxckward", + "DBaxckwards", + "DBaxck", + "DpadBaxckward", + "DpadBaxckwards", + "DpadBaxck", + "DBaxkward", + "DBaxkwards", + "DBaxk", + "DpadBaxkward", + "DpadBaxkwards", + "DpadBaxk", + "DBacxkwar", + "DBacxkwars", + "DpadBacxkwar", + "DpadBacxkwars", + "DBaxckwar", + "DBaxckwars", + "DpadBaxckwar", + "DpadBaxckwars", + "DBaxkwar", + "DBaxkwars", + "DpadBaxkwar", + "DpadBaxkwars", + "DBacxkwarss", + "DpadBacxkwarss", + "DBaxckwarss", + "DpadBaxckwarss", + "DBaxkwarss", + "DpadBaxkwarss", + "DBavckward", + "DBavckwards", + "DBavck", + "DpadBavckward", + "DpadBavckwards", + "DpadBavck", + "DBavckwars", + "DBavckwarss", + "DpadBavckwars", + "DpadBavckwarss", + "DBavckwar", + "DpadBavckwar", + "DBakcward", + "DBakcwards", + "DBakc", + "DpadBakcward", + "DpadBakcwards", + "DpadBakc", + "DBakcwars", + "DBakcwarss", + "DpadBakcwars", + "DpadBakcwarss", + "DBakcwar", + "DpadBakcwar", + "DBaccward", + "DBaccwards", + "DBacc", + "DpadBaccward", + "DpadBaccwards", + "DpadBacc", + "DBaccwars", + "DBaccwarss", + "DpadBaccwars", + "DpadBaccwarss", + "DBaccwar", + "DpadBaccwar", + "DBavkward", + "DBavkwards", + "DBavk", + "DpadBavkward", + "DpadBavkwards", + "DpadBavk", + "DBavkwars", + "DBavkwarss", + "DpadBavkwars", + "DpadBavkwarss", + "DBavkwar", + "DpadBavkwar", + "DBacvkward", + "DBacvkwards", + "DBacvk", + "DpadBacvkward", + "DpadBacvkwards", + "DpadBacvk", + "DBacvkwars", + "DBacvkwarss", + "DpadBacvkwars", + "DpadBacvkwarss", + "DBacvkwar", + "DpadBacvkwar", + "DBackword", + "DBackwords", + "DpadBackword", + "DpadBackwords", + "DBackwors", + "DBackworss", + "DpadBackwors", + "DpadBackworss", + "DBackwor", + "DpadBackwor", + "DBacxkword", + "DBacxkwords", + "DpadBacxkword", + "DpadBacxkwords", + "DBaxckword", + "DBaxckwords", + "DpadBaxckword", + "DpadBaxckwords", + "DBaxkword", + "DBaxkwords", + "DpadBaxkword", + "DpadBaxkwords", + "DBacxkwor", + "DBacxkwors", + "DpadBacxkwor", + "DpadBacxkwors", + "DBaxckwor", + "DBaxckwors", + "DpadBaxckwor", + "DpadBaxckwors", + "DBaxkwor", + "DBaxkwors", + "DpadBaxkwor", + "DpadBaxkwors", + "DBacxkworss", + "DpadBacxkworss", + "DBaxckworss", + "DpadBaxckworss", + "DBaxkworss", + "DpadBaxkworss", + "DBavckword", + "DBavckwords", + "DpadBavckword", + "DpadBavckwords", + "DBavckwors", + "DBavckworss", + "DpadBavckwors", + "DpadBavckworss", + "DBavckwor", + "DpadBavckwor", + "DBakcword", + "DBakcwords", + "DpadBakcword", + "DpadBakcwords", + "DBakcwors", + "DBakcworss", + "DpadBakcwors", + "DpadBakcworss", + "DBakcwor", + "DpadBakcwor", + "DBaccword", + "DBaccwords", + "DpadBaccword", + "DpadBaccwords", + "DBaccwors", + "DBaccworss", + "DpadBaccwors", + "DpadBaccworss", + "DBaccwor", + "DpadBaccwor", + "DBavkword", + "DBavkwords", + "DpadBavkword", + "DpadBavkwords", + "DBavkwors", + "DBavkworss", + "DpadBavkwors", + "DpadBavkworss", + "DBavkwor", + "DpadBavkwor", + "DBacvkword", + "DBacvkwords", + "DpadBacvkword", + "DpadBacvkwords", + "DBacvkwors", + "DBacvkworss", + "DpadBacvkwors", + "DpadBacvkworss", + "DBacvkwor", + "DpadBacvkwor", + "DpadBacvkwors", + "LeftStickDown", + "LeftStickD", + "LStickDown", + "LStickD", + "StickDown", + "StickD", + "DownnA", + "DownnAnalog", + "AnalogDownn", + "ADownn", + "Downn", + "WalkDownn", + "MoveDownn", + "MvoeDownn", + "AFpwn", + "Fpwn", + "AFpwb", + "Fpwb", + "AFpw", + "Fpw", + "AFpwm", + "Fpwm", + "DownA", + "DownAnalog", + "Ackwrd", + "Ackwrds", + "AAckwrd", + "AAckwrds", + "Ackwrs", + "Ackwrss", + "AAckwrs", + "AAckwrss", + "Ackwr", + "AAckwr", + "WalkAckwr", + "WalkAckwrs", + "WalkAckwrd", + "WalkAckwrds", + "WalkAckwrss", + "MoveAckwr", + "MoveAckwrs", + "MoveAckwrd", + "MoveAckwrds", + "MoveAckwrss", + "MvoeAckwr", + "MvoeAckwrs", + "MvoeAckwrd", + "MvoeAckwrds", + "MvoeAckwrss", + "Ackward", + "Ackwards", + "Ack", + "AAckward", + "AAckwards", + "AAck", + "Ackwars", + "Ackwarss", + "AAckwars", + "AAckwarss", + "Ackwar", + "AAckwar", + "WalkAck", + "MoveAck", + "MvoeAck", + "WalkAckwar", + "WalkAckwars", + "WalkAckward", + "WalkAckwards", + "WalkAckwarss", + "MoveAckwar", + "MoveAckwars", + "MoveAckward", + "MoveAckwards", + "MoveAckwarss", + "MvoeAckwar", + "MvoeAckwars", + "MvoeAckward", + "MvoeAckwards", + "MvoeAckwarss", + "Ackword", + "Ackwords", + "AAckword", + "AAckwords", + "Ackwors", + "Ackworss", + "AAckwors", + "AAckworss", + "Ackwor", + "AAckwor", + "WalkAckwor", + "WalkAckwors", + "WalkAckword", + "WalkAckwords", + "WalkAckworss", + "MoveAckwor", + "MoveAckwors", + "MoveAckword", + "MoveAckwords", + "MoveAckworss", + "MvoeAckwor", + "MvoeAckwors", + "MvoeAckword", + "MvoeAckwords", + "MvoeAckworss", + "Babkwrd", + "Babkwrds", + "ABabkwrd", + "ABabkwrds", + "Babkwrs", + "Babkwrss", + "ABabkwrs", + "ABabkwrss", + "Babkwr", + "ABabkwr", + "WalkBabkwr", + "WalkBabkwrs", + "WalkBabkwrd", + "WalkBabkwrds", + "WalkBabkwrss", + "MoveBabkwr", + "MoveBabkwrs", + "MoveBabkwrd", + "MoveBabkwrds", + "MoveBabkwrss", + "MvoeBabkwr", + "MvoeBabkwrs", + "MvoeBabkwrd", + "MvoeBabkwrds", + "MvoeBabkwrss", + "Babkward", + "Babkwards", + "Babk", + "ABabkward", + "ABabkwards", + "ABabk", + "Babkwars", + "Babkwarss", + "ABabkwars", + "ABabkwarss", + "Babkwar", + "ABabkwar", + "WalkBabk", + "MoveBabk", + "MvoeBabk", + "WalkBabkwar", + "WalkBabkwars", + "WalkBabkward", + "WalkBabkwards", + "WalkBabkwarss", + "MoveBabkwar", + "MoveBabkwars", + "MoveBabkward", + "MoveBabkwards", + "MoveBabkwarss", + "MvoeBabkwar", + "MvoeBabkwars", + "MvoeBabkward", + "MvoeBabkwards", + "MvoeBabkwarss", + "Babkword", + "Babkwords", + "ABabkword", + "ABabkwords", + "Babkwors", + "Babkworss", + "ABabkwors", + "ABabkworss", + "Babkwor", + "ABabkwor", + "WalkBabkwor", + "WalkBabkwors", + "WalkBabkword", + "WalkBabkwords", + "WalkBabkworss", + "MoveBabkwor", + "MoveBabkwors", + "MoveBabkword", + "MoveBabkwords", + "MoveBabkworss", + "MvoeBabkwor", + "MvoeBabkwors", + "MvoeBabkword", + "MvoeBabkwords", + "MvoeBabkworss", + "AnalogXown", + "AXown", + "Xown", + "WalkXown", + "MoveXown", + "MvoeXown", + "AnalogDoown", + "ADoown", + "Doown", + "WalkDoown", + "MoveDoown", + "MvoeDoown", + "Analogdowwn", + "Adowwn", + "Adonww", + "Dowwn", + "Donww", + "Walkdowwn", + "Movedowwn", + "Mvoedowwn", + "ASputh", + "Sputh", + "ASout", + "Sout", + "ASput", + "Sput", + "Backwrd", + "Backwrds", + "ABackwrd", + "ABackwrds", + "Backwrs", + "Backwrss", + "ABackwrs", + "ABackwrss", + "Backwr", + "ABackwr", + "Bacxkwrd", + "Bacxkwrds", + "ABacxkwrd", + "ABacxkwrds", + "Baxckwrd", + "Baxckwrds", + "ABaxckwrd", + "ABaxckwrds", + "Baxkwrd", + "Baxkwrds", + "ABaxkwrd", + "ABaxkwrds", + "Bacxkwr", + "Bacxkwrs", + "ABacxkwr", + "ABacxkwrs", + "Baxckwr", + "Baxckwrs", + "ABaxckwr", + "ABaxckwrs", + "Baxkwr", + "Baxkwrs", + "ABaxkwr", + "ABaxkwrs", + "Bacxkwrss", + "ABacxkwrss", + "Baxckwrss", + "ABaxckwrss", + "Baxkwrss", + "ABaxkwrss", + "Bavckwrd", + "Bavckwrds", + "ABavckwrd", + "ABavckwrds", + "Bavckwrs", + "Bavckwrss", + "ABavckwrs", + "ABavckwrss", + "Bavckwr", + "ABavckwr", + "Bakcwrd", + "Bakcwrds", + "ABakcwrd", + "ABakcwrds", + "Bakcwrs", + "Bakcwrss", + "ABakcwrs", + "ABakcwrss", + "Bakcwr", + "ABakcwr", + "Baccwrd", + "Baccwrds", + "ABaccwrd", + "ABaccwrds", + "Baccwrs", + "Baccwrss", + "ABaccwrs", + "ABaccwrss", + "Baccwr", + "ABaccwr", + "Bavkwrd", + "Bavkwrds", + "ABavkwrd", + "ABavkwrds", + "Bavkwrs", + "Bavkwrss", + "ABavkwrs", + "ABavkwrss", + "Bavkwr", + "ABavkwr", + "Bacvkwrd", + "Bacvkwrds", + "ABacvkwrd", + "ABacvkwrds", + "Bacvkwrs", + "Bacvkwrss", + "ABacvkwrs", + "ABacvkwrss", + "Bacvkwr", + "ABacvkwr", + "WalkBackwr", + "WalkBaccwr", + "WalkBakcwr", + "WalkBavckwr", + "WalkBavkwr", + "WalkBacvkwr", + "WalkBacxkwr", + "WalkBaxckwr", + "WalkBaxkwr", + "WalkBackwrs", + "WalkBaccwrs", + "WalkBakcwrs", + "WalkBavckwrs", + "WalkBavkwrs", + "WalkBacvkwrs", + "WalkBacxkwrs", + "WalkBaxckwrs", + "WalkBaxkwrs", + "WalkBackwrd", + "WalkBaccwrd", + "WalkBakcwrd", + "WalkBavckwrd", + "WalkBavkwrd", + "WalkBacvkwrd", + "WalkBacxkwrd", + "WalkBaxckwrd", + "WalkBaxkwrd", + "WalkBackwrds", + "WalkBaccwrds", + "WalkBakcwrds", + "WalkBavckwrds", + "WalkBavkwrds", + "WalkBacvkwrds", + "WalkBacxkwrds", + "WalkBaxckwrds", + "WalkBaxkwrds", + "WalkBackwrss", + "WalkBaccwrss", + "WalkBakcwrss", + "WalkBavckwrss", + "WalkBavkwrss", + "WalkBacvkwrss", + "WalkBacxkwrss", + "WalkBaxckwrss", + "WalkBaxkwrss", + "MoveBackwr", + "MoveBaccwr", + "MoveBakcwr", + "MoveBavckwr", + "MoveBavkwr", + "MoveBacvkwr", + "MoveBacxkwr", + "MoveBaxckwr", + "MoveBaxkwr", + "MoveBackwrs", + "MoveBaccwrs", + "MoveBakcwrs", + "MoveBavckwrs", + "MoveBavkwrs", + "MoveBacvkwrs", + "MoveBacxkwrs", + "MoveBaxckwrs", + "MoveBaxkwrs", + "MoveBackwrd", + "MoveBaccwrd", + "MoveBakcwrd", + "MoveBavckwrd", + "MoveBavkwrd", + "MoveBacvkwrd", + "MoveBacxkwrd", + "MoveBaxckwrd", + "MoveBaxkwrd", + "MoveBackwrds", + "MoveBaccwrds", + "MoveBakcwrds", + "MoveBavckwrds", + "MoveBavkwrds", + "MoveBacvkwrds", + "MoveBacxkwrds", + "MoveBaxckwrds", + "MoveBaxkwrds", + "MoveBackwrss", + "MoveBaccwrss", + "MoveBakcwrss", + "MoveBavckwrss", + "MoveBavkwrss", + "MoveBacvkwrss", + "MoveBacxkwrss", + "MoveBaxckwrss", + "MoveBaxkwrss", + "MvoeBackwr", + "MvoeBaccwr", + "MvoeBakcwr", + "MvoeBavckwr", + "MvoeBavkwr", + "MvoeBacvkwr", + "MvoeBacxkwr", + "MvoeBaxckwr", + "MvoeBaxkwr", + "MvoeBackwrs", + "MvoeBaccwrs", + "MvoeBakcwrs", + "MvoeBavckwrs", + "MvoeBavkwrs", + "MvoeBacvkwrs", + "MvoeBacxkwrs", + "MvoeBaxckwrs", + "MvoeBaxkwrs", + "MvoeBackwrd", + "MvoeBaccwrd", + "MvoeBakcwrd", + "MvoeBavckwrd", + "MvoeBavkwrd", + "MvoeBacvkwrd", + "MvoeBacxkwrd", + "MvoeBaxckwrd", + "MvoeBaxkwrd", + "MvoeBackwrds", + "MvoeBaccwrds", + "MvoeBakcwrds", + "MvoeBavckwrds", + "MvoeBavkwrds", + "MvoeBacvkwrds", + "MvoeBacxkwrds", + "MvoeBaxckwrds", + "MvoeBaxkwrds", + "MvoeBackwrss", + "MvoeBaccwrss", + "MvoeBakcwrss", + "MvoeBavckwrss", + "MvoeBavkwrss", + "MvoeBacvkwrss", + "MvoeBacxkwrss", + "MvoeBaxckwrss", + "MvoeBaxkwrss", + "AnalogDoqn", + "ADoqn", + "Doqn", + "WalkDoqn", + "MoveDoqn", + "MvoeDoqn", + "Analogdown", + "↓", + "Reverse", + "AReverse", + "Adown", + "Adwon", + "Adonw", + "Adnow", + "Adnwo", + "Down", + "Dwon", + "Donw", + "Dnow", + "Dnwo", + "D", + "AD", + "v", + "Av", + "A↓", + "ASouth", + "South", + "S", + "AS", + "A▼", + "▼", + "Adiwn", + "Adwin", + "Adinw", + "Adniw", + "Adnwi", + "Diwn", + "Dwin", + "Dinw", + "Dniw", + "Dnwi", + "Adpwn", + "Adwpn", + "Adpnw", + "Adnpw", + "Adnwp", + "Dpwn", + "Dwpn", + "Dpnw", + "Dnpw", + "Dnwp", + "Adon", + "Don", + "Adin", + "Din", + "Adpn", + "Dpn", + "Adoiwn", + "Doiwn", + "Adpiwn", + "Dpiwn", + "Adipwn", + "Dipwn", + "Adpown", + "Dpown", + "Adopwn", + "Dopwn", + "Adoinw", + "Doinw", + "Adpinw", + "Dpinw", + "Adipnw", + "Dipnw", + "Adponw", + "Dponw", + "Adopnw", + "Dopnw", + "Adowb", + "Adwob", + "Adobw", + "Adbow", + "Adbwo", + "Dowb", + "Dwob", + "Dobw", + "Dbow", + "Dbwo", + "Adiwb", + "Adwib", + "Adibw", + "Adbiw", + "Adbwi", + "Diwb", + "Dwib", + "Dibw", + "Dbiw", + "Dbwi", + "Adpwb", + "Adwpb", + "Adpbw", + "Adbpw", + "Adbwp", + "Dpwb", + "Dwpb", + "Dpbw", + "Dbpw", + "Dbwp", + "Adob", + "Dob", + "Adib", + "Dib", + "Adpb", + "Dpb", + "Adoiwb", + "Doiwb", + "Adpiwb", + "Dpiwb", + "Adipwb", + "Dipwb", + "Adpowb", + "Dpowb", + "Adopwb", + "Dopwb", + "Adoibw", + "Doibw", + "Adpibw", + "Dpibw", + "Adipbw", + "Dipbw", + "Adpobw", + "Dpobw", + "Adopbw", + "Dopbw", + "ASown", + "ASwon", + "ASonw", + "ASnow", + "ASnwo", + "Sown", + "Swon", + "Sonw", + "Snow", + "Snwo", + "ASiwn", + "ASinw", + "ASniw", + "ASnwi", + "Siwn", + "Sinw", + "Sniw", + "Snwi", + "ASpwn", + "ASwpn", + "ASpnw", + "ASnpw", + "ASnwp", + "Spwn", + "Swpn", + "Spnw", + "Snpw", + "Snwp", + "ASpn", + "Spn", + "ASoiwn", + "Soiwn", + "ASpiwn", + "Spiwn", + "ASiown", + "Siown", + "ASipwn", + "Sipwn", + "ASpown", + "Spown", + "ASopwn", + "Sopwn", + "ASoinw", + "Soinw", + "ASionw", + "Sionw", + "ASipnw", + "Sipnw", + "ASponw", + "Sponw", + "ASopnw", + "Sopnw", + "ASowb", + "ASwob", + "ASobw", + "ASbow", + "ASbwo", + "Sowb", + "Swob", + "Sobw", + "Sbow", + "Sbwo", + "ASiwb", + "ASwib", + "ASibw", + "ASbiw", + "ASbwi", + "Siwb", + "Swib", + "Sibw", + "Sbiw", + "Sbwi", + "ASpwb", + "ASwpb", + "ASpbw", + "ASbpw", + "ASbwp", + "Spwb", + "Swpb", + "Spbw", + "Sbpw", + "Sbwp", + "ASob", + "Sob", + "ASib", + "Sib", + "ASpb", + "Spb", + "ASoiwb", + "Soiwb", + "ASpiwb", + "Spiwb", + "ASiowb", + "Siowb", + "ASipwb", + "Sipwb", + "ASpowb", + "Spowb", + "ASopwb", + "Sopwb", + "ASoibw", + "Soibw", + "ASpibw", + "Spibw", + "ASiobw", + "Siobw", + "ASipbw", + "Sipbw", + "ASpobw", + "Spobw", + "ASopbw", + "Sopbw", + "Adow", + "Adwo", + "Adno", + "Adnw", + "Dow", + "Dwo", + "Dno", + "Dnw", + "Adiw", + "Adwi", + "Adni", + "Diw", + "Dwi", + "Dni", + "Adpw", + "Adwp", + "Adnp", + "Dpw", + "Dwp", + "Dnp", + "Adoiw", + "Doiw", + "Adpiw", + "Dpiw", + "Adipw", + "Dipw", + "Adpow", + "Dpow", + "Adopw", + "Dopw", + "Adoin", + "Doin", + "Adpin", + "Dpin", + "Adipn", + "Dipn", + "Adpon", + "Dpon", + "Adopn", + "Dopn", + "Adbo", + "Adbw", + "Dbo", + "Dbw", + "Adbi", + "Dbi", + "Adbp", + "Dbp", + "Adoib", + "Doib", + "Adpib", + "Dpib", + "Adipb", + "Dipb", + "Adpob", + "Dpob", + "Adopb", + "Dopb", + "ASow", + "ASwo", + "ASno", + "ASnw", + "Sow", + "Swo", + "Sno", + "Snw", + "ASiw", + "ASwi", + "ASni", + "Siw", + "Swi", + "Sni", + "ASpw", + "ASwp", + "ASnp", + "Spw", + "Swp", + "Snp", + "ASoiw", + "Soiw", + "ASpiw", + "Spiw", + "ASiow", + "Siow", + "ASipw", + "Sipw", + "ASpow", + "Spow", + "ASopw", + "Sopw", + "ASoin", + "Soin", + "ASion", + "Sion", + "ASipn", + "Sipn", + "ASpon", + "Spon", + "ASopn", + "Sopn", + "ASbo", + "ASbw", + "Sbo", + "Sbw", + "ASbi", + "Sbi", + "ASbp", + "Sbp", + "ASoib", + "Soib", + "ASpib", + "Spib", + "ASiob", + "Siob", + "ASipb", + "Sipb", + "ASpob", + "Spob", + "ASopb", + "Sopb", + "Ad0wn", + "Adw0n", + "Ad0nw", + "Adn0w", + "Adnw0", + "D0wn", + "Dw0n", + "D0nw", + "Dn0w", + "Dnw0", + "AS0uth", + "S0uth", + "Ad0n", + "D0n", + "Ad0iwn", + "D0iwn", + "Adi0wn", + "Di0wn", + "Adp0wn", + "Dp0wn", + "Ad0pwn", + "D0pwn", + "Ad0inw", + "D0inw", + "Adi0nw", + "Di0nw", + "Adp0nw", + "Dp0nw", + "Ad0pnw", + "D0pnw", + "Ad0wb", + "Adw0b", + "Ad0bw", + "Adb0w", + "Adbw0", + "D0wb", + "Dw0b", + "D0bw", + "Db0w", + "Dbw0", + "Ad0b", + "D0b", + "Ad0iwb", + "D0iwb", + "Adi0wb", + "Di0wb", + "Adp0wb", + "Dp0wb", + "Ad0pwb", + "D0pwb", + "Ad0ibw", + "D0ibw", + "Adi0bw", + "Di0bw", + "Adp0bw", + "Dp0bw", + "Ad0pbw", + "D0pbw", + "AS0wn", + "ASw0n", + "AS0nw", + "ASn0w", + "ASnw0", + "S0wn", + "Sw0n", + "S0nw", + "Sn0w", + "Snw0", + "AS0n", + "S0n", + "AS0iwn", + "S0iwn", + "ASi0wn", + "Si0wn", + "ASp0wn", + "Sp0wn", + "AS0pwn", + "S0pwn", + "AS0inw", + "S0inw", + "ASi0nw", + "Si0nw", + "ASp0nw", + "Sp0nw", + "AS0pnw", + "S0pnw", + "AS0wb", + "ASw0b", + "AS0bw", + "ASb0w", + "ASbw0", + "S0wb", + "Sw0b", + "S0bw", + "Sb0w", + "Sbw0", + "AS0b", + "S0b", + "AS0iwb", + "S0iwb", + "ASi0wb", + "Si0wb", + "ASp0wb", + "Sp0wb", + "AS0pwb", + "S0pwb", + "AS0ibw", + "S0ibw", + "ASi0bw", + "Si0bw", + "ASp0bw", + "Sp0bw", + "AS0pbw", + "S0pbw", + "Ad0w", + "Adw0", + "Adn0", + "D0w", + "Dw0", + "Dn0", + "Ad0iw", + "D0iw", + "Adi0w", + "Di0w", + "Adp0w", + "Dp0w", + "Ad0pw", + "D0pw", + "Ad0in", + "D0in", + "Adi0n", + "Di0n", + "Adp0n", + "Dp0n", + "Ad0pn", + "D0pn", + "Adb0", + "Db0", + "Ad0ib", + "D0ib", + "Adi0b", + "Di0b", + "Adp0b", + "Dp0b", + "Ad0pb", + "D0pb", + "AS0w", + "ASw0", + "ASn0", + "S0w", + "Sw0", + "Sn0", + "AS0iw", + "S0iw", + "ASi0w", + "Si0w", + "ASp0w", + "Sp0w", + "AS0pw", + "S0pw", + "AS0in", + "S0in", + "ASi0n", + "Si0n", + "ASp0n", + "Sp0n", + "AS0pn", + "S0pn", + "ASb0", + "Sb0", + "AS0ib", + "S0ib", + "ASi0b", + "Si0b", + "ASp0b", + "Sp0b", + "AS0pb", + "S0pb", + "Ad9wn", + "Adw9n", + "Ad9nw", + "Adn9w", + "Adnw9", + "D9wn", + "Dw9n", + "D9nw", + "Dn9w", + "Dnw9", + "AS9uth", + "S9uth", + "Ad9n", + "D9n", + "Ad9iwn", + "D9iwn", + "Adi9wn", + "Di9wn", + "Adp9wn", + "Dp9wn", + "Ad9pwn", + "D9pwn", + "Ad9inw", + "D9inw", + "Adi9nw", + "Di9nw", + "Adp9nw", + "Dp9nw", + "Ad9pnw", + "D9pnw", + "Ad9wb", + "Adw9b", + "Ad9bw", + "Adb9w", + "Adbw9", + "D9wb", + "Dw9b", + "D9bw", + "Db9w", + "Dbw9", + "Ad9b", + "D9b", + "Ad9iwb", + "D9iwb", + "Adi9wb", + "Di9wb", + "Adp9wb", + "Dp9wb", + "Ad9pwb", + "D9pwb", + "Ad9ibw", + "D9ibw", + "Adi9bw", + "Di9bw", + "Adp9bw", + "Dp9bw", + "Ad9pbw", + "D9pbw", + "AS9wn", + "ASw9n", + "AS9nw", + "ASn9w", + "ASnw9", + "S9wn", + "Sw9n", + "S9nw", + "Sn9w", + "Snw9", + "AS9n", + "S9n", + "AS9iwn", + "S9iwn", + "ASi9wn", + "Si9wn", + "ASp9wn", + "Sp9wn", + "AS9pwn", + "S9pwn", + "AS9inw", + "S9inw", + "ASi9nw", + "Si9nw", + "ASp9nw", + "Sp9nw", + "AS9pnw", + "S9pnw", + "AS9wb", + "ASw9b", + "AS9bw", + "ASb9w", + "ASbw9", + "S9wb", + "Sw9b", + "S9bw", + "Sb9w", + "Sbw9", + "AS9b", + "S9b", + "AS9iwb", + "S9iwb", + "ASi9wb", + "Si9wb", + "ASp9wb", + "Sp9wb", + "AS9pwb", + "S9pwb", + "AS9ibw", + "S9ibw", + "ASi9bw", + "Si9bw", + "ASp9bw", + "Sp9bw", + "AS9pbw", + "S9pbw", + "Ad9w", + "Adw9", + "Adn9", + "D9w", + "Dw9", + "Dn9", + "Ad9iw", + "D9iw", + "Adi9w", + "Di9w", + "Adp9w", + "Dp9w", + "Ad9pw", + "D9pw", + "Ad9in", + "D9in", + "Adi9n", + "Di9n", + "Adp9n", + "Dp9n", + "Ad9pn", + "D9pn", + "Adb9", + "Db9", + "Ad9ib", + "D9ib", + "Adi9b", + "Di9b", + "Adp9b", + "Dp9b", + "Ad9pb", + "D9pb", + "AS9w", + "ASw9", + "ASn9", + "S9w", + "Sw9", + "Sn9", + "AS9iw", + "S9iw", + "ASi9w", + "Si9w", + "ASp9w", + "Sp9w", + "AS9pw", + "S9pw", + "AS9in", + "S9in", + "ASi9n", + "Si9n", + "ASp9n", + "Sp9n", + "AS9pn", + "S9pn", + "ASb9", + "Sb9", + "AS9ib", + "S9ib", + "ASi9b", + "Si9b", + "ASp9b", + "Sp9b", + "AS9pb", + "S9pb", + "AFown", + "AFwon", + "AFonw", + "AFnow", + "AFnwo", + "Fown", + "Fwon", + "Fonw", + "Fnow", + "Fnwo", + "AF", + "AFiwn", + "AFwin", + "AFinw", + "AFniw", + "AFnwi", + "Fiwn", + "Fwin", + "Finw", + "Fniw", + "Fnwi", + "AFwpn", + "AFpnw", + "AFnpw", + "AFnwp", + "Fwpn", + "Fpnw", + "Fnpw", + "Fnwp", + "AFon", + "Fon", + "AFin", + "Fin", + "AFpn", + "Fpn", + "AFoiwn", + "Foiwn", + "AFpiwn", + "Fpiwn", + "AFiown", + "Fiown", + "AFipwn", + "Fipwn", + "AFpown", + "Fpown", + "AFopwn", + "Fopwn", + "AFoinw", + "Foinw", + "AFpinw", + "Fpinw", + "AFionw", + "Fionw", + "AFipnw", + "Fipnw", + "AFponw", + "Fponw", + "AFopnw", + "Fopnw", + "AFowb", + "AFwob", + "AFobw", + "AFbow", + "AFbwo", + "Fowb", + "Fwob", + "Fobw", + "Fbow", + "Fbwo", + "AFiwb", + "AFwib", + "AFibw", + "AFbiw", + "AFbwi", + "Fiwb", + "Fwib", + "Fibw", + "Fbiw", + "Fbwi", + "AFwpb", + "AFpbw", + "AFbpw", + "AFbwp", + "Fwpb", + "Fpbw", + "Fbpw", + "Fbwp", + "AFob", + "Fob", + "AFib", + "Fib", + "AFpb", + "Fpb", + "AFoiwb", + "Foiwb", + "AFpiwb", + "Fpiwb", + "AFiowb", + "Fiowb", + "AFipwb", + "Fipwb", + "AFpowb", + "Fpowb", + "AFopwb", + "Fopwb", + "AFoibw", + "Foibw", + "AFpibw", + "Fpibw", + "AFiobw", + "Fiobw", + "AFipbw", + "Fipbw", + "AFpobw", + "Fpobw", + "AFopbw", + "Fopbw", + "AFow", + "AFwo", + "AFno", + "AFnw", + "Fow", + "Fwo", + "Fno", + "Fnw", + "AFiw", + "AFwi", + "AFni", + "Fiw", + "Fwi", + "Fni", + "AFwp", + "AFnp", + "Fwp", + "Fnp", + "AFoiw", + "Foiw", + "AFpiw", + "Fpiw", + "AFiow", + "Fiow", + "AFipw", + "Fipw", + "AFpow", + "Fpow", + "AFopw", + "Fopw", + "AFoin", + "Foin", + "AFpin", + "Fpin", + "AFion", + "Fion", + "AFipn", + "Fipn", + "AFpon", + "Fpon", + "AFopn", + "Fopn", + "AFbo", + "AFbw", + "Fbo", + "Fbw", + "AFbi", + "Fbi", + "AFbp", + "Fbp", + "AFoib", + "Foib", + "AFpib", + "Fpib", + "AFiob", + "Fiob", + "AFipb", + "Fipb", + "AFpob", + "Fpob", + "AFopb", + "Fopb", + "AF0wn", + "AFw0n", + "AF0nw", + "AFn0w", + "AFnw0", + "F0wn", + "Fw0n", + "F0nw", + "Fn0w", + "Fnw0", + "AF0n", + "F0n", + "AF0iwn", + "F0iwn", + "AFi0wn", + "Fi0wn", + "AFp0wn", + "Fp0wn", + "AF0pwn", + "F0pwn", + "AF0inw", + "F0inw", + "AFi0nw", + "Fi0nw", + "AFp0nw", + "Fp0nw", + "AF0pnw", + "F0pnw", + "AF0wb", + "AFw0b", + "AF0bw", + "AFb0w", + "AFbw0", + "F0wb", + "Fw0b", + "F0bw", + "Fb0w", + "Fbw0", + "AF0b", + "F0b", + "AF0iwb", + "F0iwb", + "AFi0wb", + "Fi0wb", + "AFp0wb", + "Fp0wb", + "AF0pwb", + "F0pwb", + "AF0ibw", + "F0ibw", + "AFi0bw", + "Fi0bw", + "AFp0bw", + "Fp0bw", + "AF0pbw", + "F0pbw", + "AF0w", + "AFw0", + "AFn0", + "F0w", + "Fw0", + "Fn0", + "AF0iw", + "F0iw", + "AFi0w", + "Fi0w", + "AFp0w", + "Fp0w", + "AF0pw", + "F0pw", + "AF0in", + "F0in", + "AFi0n", + "Fi0n", + "AFp0n", + "Fp0n", + "AF0pn", + "F0pn", + "AFb0", + "Fb0", + "AF0ib", + "F0ib", + "AFi0b", + "Fi0b", + "AFp0b", + "Fp0b", + "AF0pb", + "F0pb", + "AF9wn", + "AFw9n", + "AF9nw", + "AFn9w", + "AFnw9", + "F9wn", + "Fw9n", + "F9nw", + "Fn9w", + "Fnw9", + "AF9n", + "F9n", + "AF9iwn", + "F9iwn", + "AFi9wn", + "Fi9wn", + "AFp9wn", + "Fp9wn", + "AF9pwn", + "F9pwn", + "AF9inw", + "F9inw", + "AFi9nw", + "Fi9nw", + "AFp9nw", + "Fp9nw", + "AF9pnw", + "F9pnw", + "AF9wb", + "AFw9b", + "AF9bw", + "AFb9w", + "AFbw9", + "F9wb", + "Fw9b", + "F9bw", + "Fb9w", + "Fbw9", + "AF9b", + "F9b", + "AF9iwb", + "F9iwb", + "AFi9wb", + "Fi9wb", + "AFp9wb", + "Fp9wb", + "AF9pwb", + "F9pwb", + "AF9ibw", + "F9ibw", + "AFi9bw", + "Fi9bw", + "AFp9bw", + "Fp9bw", + "AF9pbw", + "F9pbw", + "AF9w", + "AFw9", + "AFn9", + "F9w", + "Fw9", + "Fn9", + "AF9iw", + "F9iw", + "AFi9w", + "Fi9w", + "AFp9w", + "Fp9w", + "AF9pw", + "F9pw", + "AF9in", + "F9in", + "AFi9n", + "Fi9n", + "AFp9n", + "Fp9n", + "AF9pn", + "F9pn", + "AFb9", + "Fb9", + "AF9ib", + "F9ib", + "AFi9b", + "Fi9b", + "AFp9b", + "Fp9b", + "AF9pb", + "F9pb", + "Adowm", + "Adwom", + "Adomw", + "Admow", + "Admwo", + "Dowm", + "Dwom", + "Domw", + "Dmow", + "Dmwo", + "Adiwm", + "Adwim", + "Adimw", + "Admiw", + "Admwi", + "Diwm", + "Dwim", + "Dimw", + "Dmiw", + "Dmwi", + "Adpwm", + "Adwpm", + "Adpmw", + "Admpw", + "Admwp", + "Dpwm", + "Dwpm", + "Dpmw", + "Dmpw", + "Dmwp", + "Adom", + "Dom", + "Adim", + "Dim", + "Adpm", + "Dpm", + "Adoiwm", + "Doiwm", + "Adpiwm", + "Dpiwm", + "Adipwm", + "Dipwm", + "Adpowm", + "Dpowm", + "Adopwm", + "Dopwm", + "Adoimw", + "Doimw", + "Adpimw", + "Dpimw", + "Adipmw", + "Dipmw", + "Adpomw", + "Dpomw", + "Adopmw", + "Dopmw", + "ASowm", + "ASwom", + "ASomw", + "ASmow", + "ASmwo", + "Sowm", + "Swom", + "Somw", + "Smow", + "Smwo", + "ASiwm", + "ASimw", + "ASmiw", + "ASmwi", + "Siwm", + "Simw", + "Smiw", + "Smwi", + "ASpwm", + "ASwpm", + "ASpmw", + "ASmpw", + "ASmwp", + "Spwm", + "Swpm", + "Spmw", + "Smpw", + "Smwp", + "ASom", + "Som", + "ASim", + "Sim", + "ASpm", + "Spm", + "ASoiwm", + "Soiwm", + "ASpiwm", + "Spiwm", + "ASiowm", + "Siowm", + "ASipwm", + "Sipwm", + "ASpowm", + "Spowm", + "ASopwm", + "Sopwm", + "ASoimw", + "Soimw", + "ASiomw", + "Siomw", + "ASipmw", + "Sipmw", + "ASpomw", + "Spomw", + "ASopmw", + "Sopmw", + "Admo", + "Admw", + "Dmo", + "Dmw", + "Admi", + "Dmi", + "Admp", + "Dmp", + "Adoim", + "Doim", + "Adpim", + "Dpim", + "Adipm", + "Dipm", + "Adpom", + "Dpom", + "Adopm", + "Dopm", + "ASmo", + "ASmw", + "Smo", + "Smw", + "ASmi", + "Smi", + "ASmp", + "Smp", + "ASoim", + "Soim", + "ASiom", + "Siom", + "ASipm", + "Sipm", + "ASpom", + "Spom", + "ASopm", + "Sopm", + "Ad0wm", + "Adw0m", + "Ad0mw", + "Adm0w", + "Admw0", + "D0wm", + "Dw0m", + "D0mw", + "Dm0w", + "Dmw0", + "Ad0m", + "D0m", + "Ad0iwm", + "D0iwm", + "Adi0wm", + "Di0wm", + "Adp0wm", + "Dp0wm", + "Ad0pwm", + "D0pwm", + "Ad0imw", + "D0imw", + "Adi0mw", + "Di0mw", + "Adp0mw", + "Dp0mw", + "Ad0pmw", + "D0pmw", + "AS0wm", + "ASw0m", + "AS0mw", + "ASm0w", + "ASmw0", + "S0wm", + "Sw0m", + "S0mw", + "Sm0w", + "Smw0", + "AS0m", + "S0m", + "AS0iwm", + "S0iwm", + "ASi0wm", + "Si0wm", + "ASp0wm", + "Sp0wm", + "AS0pwm", + "S0pwm", + "AS0imw", + "S0imw", + "ASi0mw", + "Si0mw", + "ASp0mw", + "Sp0mw", + "AS0pmw", + "S0pmw", + "Adm0", + "Dm0", + "Ad0im", + "D0im", + "Adi0m", + "Di0m", + "Adp0m", + "Dp0m", + "Ad0pm", + "D0pm", + "ASm0", + "Sm0", + "AS0im", + "S0im", + "ASi0m", + "Si0m", + "ASp0m", + "Sp0m", + "AS0pm", + "S0pm", + "Ad9wm", + "Adw9m", + "Ad9mw", + "Adm9w", + "Admw9", + "D9wm", + "Dw9m", + "D9mw", + "Dm9w", + "Dmw9", + "Ad9m", + "D9m", + "Ad9iwm", + "D9iwm", + "Adi9wm", + "Di9wm", + "Adp9wm", + "Dp9wm", + "Ad9pwm", + "D9pwm", + "Ad9imw", + "D9imw", + "Adi9mw", + "Di9mw", + "Adp9mw", + "Dp9mw", + "Ad9pmw", + "D9pmw", + "AS9wm", + "ASw9m", + "AS9mw", + "ASm9w", + "ASmw9", + "S9wm", + "Sw9m", + "S9mw", + "Sm9w", + "Smw9", + "AS9m", + "S9m", + "AS9iwm", + "S9iwm", + "ASi9wm", + "Si9wm", + "ASp9wm", + "Sp9wm", + "AS9pwm", + "S9pwm", + "AS9imw", + "S9imw", + "ASi9mw", + "Si9mw", + "ASp9mw", + "Sp9mw", + "AS9pmw", + "S9pmw", + "Adm9", + "Dm9", + "Ad9im", + "D9im", + "Adi9m", + "Di9m", + "Adp9m", + "Dp9m", + "Ad9pm", + "D9pm", + "ASm9", + "Sm9", + "AS9im", + "S9im", + "ASi9m", + "Si9m", + "ASp9m", + "Sp9m", + "AS9pm", + "S9pm", + "AFowm", + "AFwom", + "AFomw", + "AFmow", + "AFmwo", + "Fowm", + "Fwom", + "Fomw", + "Fmow", + "Fmwo", + "AFiwm", + "AFwim", + "AFimw", + "AFmiw", + "AFmwi", + "Fiwm", + "Fwim", + "Fimw", + "Fmiw", + "Fmwi", + "AFwpm", + "AFpmw", + "AFmpw", + "AFmwp", + "Fwpm", + "Fpmw", + "Fmpw", + "Fmwp", + "AFom", + "Fom", + "AFim", + "Fim", + "AFpm", + "Fpm", + "AFoiwm", + "Foiwm", + "AFpiwm", + "Fpiwm", + "AFiowm", + "Fiowm", + "AFipwm", + "Fipwm", + "AFpowm", + "Fpowm", + "AFopwm", + "Fopwm", + "AFoimw", + "Foimw", + "AFpimw", + "Fpimw", + "AFiomw", + "Fiomw", + "AFipmw", + "Fipmw", + "AFpomw", + "Fpomw", + "AFopmw", + "Fopmw", + "AFmo", + "AFmw", + "Fmo", + "Fmw", + "AFmi", + "Fmi", + "AFmp", + "Fmp", + "AFoim", + "Foim", + "AFpim", + "Fpim", + "AFiom", + "Fiom", + "AFipm", + "Fipm", + "AFpom", + "Fpom", + "AFopm", + "Fopm", + "AF0wm", + "AFw0m", + "AF0mw", + "AFm0w", + "AFmw0", + "F0wm", + "Fw0m", + "F0mw", + "Fm0w", + "Fmw0", + "AF0m", + "F0m", + "AF0iwm", + "F0iwm", + "AFi0wm", + "Fi0wm", + "AFp0wm", + "Fp0wm", + "AF0pwm", + "F0pwm", + "AF0imw", + "F0imw", + "AFi0mw", + "Fi0mw", + "AFp0mw", + "Fp0mw", + "AF0pmw", + "F0pmw", + "AFm0", + "Fm0", + "AF0im", + "F0im", + "AFi0m", + "Fi0m", + "AFp0m", + "Fp0m", + "AF0pm", + "F0pm", + "AF9wm", + "AFw9m", + "AF9mw", + "AFm9w", + "AFmw9", + "F9wm", + "Fw9m", + "F9mw", + "Fm9w", + "Fmw9", + "AF9m", + "F9m", + "AF9iwm", + "F9iwm", + "AFi9wm", + "Fi9wm", + "AFp9wm", + "Fp9wm", + "AF9pwm", + "F9pwm", + "AF9imw", + "F9imw", + "AFi9mw", + "Fi9mw", + "AFp9mw", + "Fp9mw", + "AF9pmw", + "F9pmw", + "AFm9", + "Fm9", + "AF9im", + "F9im", + "AFi9m", + "Fi9m", + "AFp9m", + "Fp9m", + "AF9pm", + "F9pm", + "Adoen", + "Adeon", + "Adone", + "Adnoe", + "Adneo", + "Doen", + "Deon", + "Done", + "Dnoe", + "Dneo", + "Adein", + "Adine", + "Adnie", + "Adnei", + "Dein", + "Dine", + "Dnie", + "Dnei", + "Adpen", + "Adepn", + "Adpne", + "Adnpe", + "Adnep", + "Dpen", + "Depn", + "Dpne", + "Dnpe", + "Dnep", + "Adoien", + "Doien", + "Adpien", + "Dpien", + "Adipen", + "Dipen", + "Adpoen", + "Dpoen", + "Adoine", + "Doine", + "Adpine", + "Dpine", + "Adipne", + "Dipne", + "Adpone", + "Dpone", + "Adopne", + "Dopne", + "Adoeb", + "Adeob", + "Adobe", + "Adboe", + "Adbeo", + "Doeb", + "Deob", + "Dobe", + "Dboe", + "Dbeo", + "Adeib", + "Adibe", + "Adbie", + "Adbei", + "Deib", + "Dibe", + "Dbie", + "Dbei", + "Adpeb", + "Adepb", + "Adpbe", + "Adbpe", + "Adbep", + "Dpeb", + "Depb", + "Dpbe", + "Dbpe", + "Dbep", + "Adoieb", + "Doieb", + "Adpieb", + "Dpieb", + "Adipeb", + "Dipeb", + "Adpoeb", + "Dpoeb", + "Adoibe", + "Doibe", + "Adpibe", + "Dpibe", + "Adipbe", + "Dipbe", + "Adpobe", + "Dpobe", + "Adopbe", + "Dopbe", + "ASoen", + "ASeon", + "ASone", + "ASnoe", + "ASneo", + "Soen", + "Seon", + "Sone", + "Snoe", + "Sneo", + "ASien", + "ASein", + "ASine", + "ASnie", + "ASnei", + "Sien", + "Sein", + "Sine", + "Snie", + "Snei", + "ASpen", + "ASepn", + "ASpne", + "ASnpe", + "ASnep", + "Spen", + "Sepn", + "Spne", + "Snpe", + "Snep", + "ASoien", + "Soien", + "ASpien", + "Spien", + "ASioen", + "Sioen", + "ASipen", + "Sipen", + "ASpoen", + "Spoen", + "ASopen", + "Sopen", + "ASoine", + "Soine", + "ASione", + "Sione", + "ASipne", + "Sipne", + "ASpone", + "Spone", + "ASopne", + "Sopne", + "ASoeb", + "ASeob", + "ASobe", + "ASboe", + "ASbeo", + "Soeb", + "Seob", + "Sobe", + "Sboe", + "Sbeo", + "ASieb", + "ASeib", + "ASibe", + "ASbie", + "ASbei", + "Sieb", + "Seib", + "Sibe", + "Sbie", + "Sbei", + "ASpeb", + "ASepb", + "ASpbe", + "ASbpe", + "ASbep", + "Speb", + "Sepb", + "Spbe", + "Sbpe", + "Sbep", + "ASoieb", + "Soieb", + "ASpieb", + "Spieb", + "ASioeb", + "Sioeb", + "ASipeb", + "Sipeb", + "ASpoeb", + "Spoeb", + "ASopeb", + "Sopeb", + "ASoibe", + "Soibe", + "ASpibe", + "Spibe", + "ASiobe", + "Siobe", + "ASipbe", + "Sipbe", + "ASpobe", + "Spobe", + "ASopbe", + "Sopbe", + "Adoe", + "Adeo", + "Adne", + "Doe", + "Deo", + "Dne", + "Adei", + "Dei", + "Adpe", + "Adep", + "Dpe", + "Dep", + "Adoie", + "Doie", + "Adpie", + "Dpie", + "Adipe", + "Dipe", + "Adpoe", + "Dpoe", + "Adbe", + "Dbe", + "ASoe", + "ASeo", + "ASne", + "Soe", + "Seo", + "Sne", + "ASie", + "ASei", + "Sie", + "Sei", + "ASpe", + "ASep", + "Spe", + "Sep", + "ASoie", + "Soie", + "ASpie", + "Spie", + "ASioe", + "Sioe", + "ASipe", + "Sipe", + "ASpoe", + "Spoe", + "ASope", + "Sope", + "ASbe", + "Sbe", + "Ad0en", + "Ade0n", + "Ad0ne", + "Adn0e", + "Adne0", + "D0en", + "De0n", + "D0ne", + "Dn0e", + "Dne0", + "Ad0ien", + "D0ien", + "Adi0en", + "Di0en", + "Adp0en", + "Dp0en", + "Ad0pen", + "D0pen", + "Ad0ine", + "D0ine", + "Adi0ne", + "Di0ne", + "Adp0ne", + "Dp0ne", + "Ad0pne", + "D0pne", + "Ad0eb", + "Ade0b", + "Ad0be", + "Adb0e", + "Adbe0", + "D0eb", + "De0b", + "D0be", + "Db0e", + "Dbe0", + "Ad0ieb", + "D0ieb", + "Adi0eb", + "Di0eb", + "Adp0eb", + "Dp0eb", + "Ad0peb", + "D0peb", + "Ad0ibe", + "D0ibe", + "Adi0be", + "Di0be", + "Adp0be", + "Dp0be", + "Ad0pbe", + "D0pbe", + "AS0en", + "ASe0n", + "AS0ne", + "ASn0e", + "ASne0", + "S0en", + "Se0n", + "S0ne", + "Sn0e", + "Sne0", + "AS0ien", + "S0ien", + "ASi0en", + "Si0en", + "ASp0en", + "Sp0en", + "AS0pen", + "S0pen", + "AS0ine", + "S0ine", + "ASi0ne", + "Si0ne", + "ASp0ne", + "Sp0ne", + "AS0pne", + "S0pne", + "AS0eb", + "ASe0b", + "AS0be", + "ASb0e", + "ASbe0", + "S0eb", + "Se0b", + "S0be", + "Sb0e", + "Sbe0", + "AS0ieb", + "S0ieb", + "ASi0eb", + "Si0eb", + "ASp0eb", + "Sp0eb", + "AS0peb", + "S0peb", + "AS0ibe", + "S0ibe", + "ASi0be", + "Si0be", + "ASp0be", + "Sp0be", + "AS0pbe", + "S0pbe", + "Ad0e", + "Ade0", + "D0e", + "De0", + "Ad0ie", + "D0ie", + "Adi0e", + "Di0e", + "Adp0e", + "Dp0e", + "Ad0pe", + "D0pe", + "AS0e", + "ASe0", + "S0e", + "Se0", + "AS0ie", + "S0ie", + "ASi0e", + "Si0e", + "ASp0e", + "Sp0e", + "AS0pe", + "S0pe", + "Ad9en", + "Ade9n", + "Ad9ne", + "Adn9e", + "Adne9", + "D9en", + "De9n", + "D9ne", + "Dn9e", + "Dne9", + "Ad9ien", + "D9ien", + "Adi9en", + "Di9en", + "Adp9en", + "Dp9en", + "Ad9pen", + "D9pen", + "Ad9ine", + "D9ine", + "Adi9ne", + "Di9ne", + "Adp9ne", + "Dp9ne", + "Ad9pne", + "D9pne", + "Ad9eb", + "Ade9b", + "Ad9be", + "Adb9e", + "Adbe9", + "D9eb", + "De9b", + "D9be", + "Db9e", + "Dbe9", + "Ad9ieb", + "D9ieb", + "Adi9eb", + "Di9eb", + "Adp9eb", + "Dp9eb", + "Ad9peb", + "D9peb", + "Ad9ibe", + "D9ibe", + "Adi9be", + "Di9be", + "Adp9be", + "Dp9be", + "Ad9pbe", + "D9pbe", + "AS9en", + "ASe9n", + "AS9ne", + "ASn9e", + "ASne9", + "S9en", + "Se9n", + "S9ne", + "Sn9e", + "Sne9", + "AS9ien", + "S9ien", + "ASi9en", + "Si9en", + "ASp9en", + "Sp9en", + "AS9pen", + "S9pen", + "AS9ine", + "S9ine", + "ASi9ne", + "Si9ne", + "ASp9ne", + "Sp9ne", + "AS9pne", + "S9pne", + "AS9eb", + "ASe9b", + "AS9be", + "ASb9e", + "ASbe9", + "S9eb", + "Se9b", + "S9be", + "Sb9e", + "Sbe9", + "AS9ieb", + "S9ieb", + "ASi9eb", + "Si9eb", + "ASp9eb", + "Sp9eb", + "AS9peb", + "S9peb", + "AS9ibe", + "S9ibe", + "ASi9be", + "Si9be", + "ASp9be", + "Sp9be", + "AS9pbe", + "S9pbe", + "Ad9e", + "Ade9", + "D9e", + "De9", + "Ad9ie", + "D9ie", + "Adi9e", + "Di9e", + "Adp9e", + "Dp9e", + "Ad9pe", + "D9pe", + "AS9e", + "ASe9", + "S9e", + "Se9", + "AS9ie", + "S9ie", + "ASi9e", + "Si9e", + "ASp9e", + "Sp9e", + "AS9pe", + "S9pe", + "AFoen", + "AFeon", + "AFone", + "AFnoe", + "AFneo", + "Foen", + "Feon", + "Fone", + "Fnoe", + "Fneo", + "AFien", + "AFein", + "AFnie", + "AFnei", + "Fien", + "Fein", + "Fnie", + "Fnei", + "AFpen", + "AFepn", + "AFpne", + "AFnpe", + "AFnep", + "Fpen", + "Fepn", + "Fpne", + "Fnpe", + "Fnep", + "AFoien", + "Foien", + "AFpien", + "Fpien", + "AFioen", + "Fioen", + "AFipen", + "Fipen", + "AFpoen", + "Fpoen", + "AFopen", + "Fopen", + "AFoine", + "Foine", + "AFpine", + "Fpine", + "AFione", + "Fione", + "AFipne", + "Fipne", + "AFpone", + "Fpone", + "AFopne", + "Fopne", + "AFoeb", + "AFeob", + "AFobe", + "AFboe", + "AFbeo", + "Foeb", + "Feob", + "Fobe", + "Fboe", + "Fbeo", + "AFieb", + "AFeib", + "AFibe", + "AFbie", + "AFbei", + "Fieb", + "Feib", + "Fibe", + "Fbie", + "Fbei", + "AFpeb", + "AFepb", + "AFpbe", + "AFbpe", + "AFbep", + "Fpeb", + "Fepb", + "Fpbe", + "Fbpe", + "Fbep", + "AFoieb", + "Foieb", + "AFpieb", + "Fpieb", + "AFioeb", + "Fioeb", + "AFipeb", + "Fipeb", + "AFpoeb", + "Fpoeb", + "AFopeb", + "Fopeb", + "AFoibe", + "Foibe", + "AFpibe", + "Fpibe", + "AFiobe", + "Fiobe", + "AFipbe", + "Fipbe", + "AFpobe", + "Fpobe", + "AFopbe", + "Fopbe", + "AFoe", + "AFeo", + "AFne", + "Foe", + "Feo", + "Fne", + "AFie", + "AFei", + "Fie", + "Fei", + "AFpe", + "AFep", + "Fpe", + "Fep", + "AFoie", + "Foie", + "AFpie", + "Fpie", + "AFioe", + "Fioe", + "AFipe", + "Fipe", + "AFpoe", + "Fpoe", + "AFope", + "Fope", + "AFbe", + "Fbe", + "AF0en", + "AFe0n", + "AF0ne", + "AFn0e", + "AFne0", + "F0en", + "Fe0n", + "F0ne", + "Fn0e", + "Fne0", + "AF0ien", + "F0ien", + "AFi0en", + "Fi0en", + "AFp0en", + "Fp0en", + "AF0pen", + "F0pen", + "AF0ine", + "F0ine", + "AFi0ne", + "Fi0ne", + "AFp0ne", + "Fp0ne", + "AF0pne", + "F0pne", + "AF0eb", + "AFe0b", + "AF0be", + "AFb0e", + "AFbe0", + "F0eb", + "Fe0b", + "F0be", + "Fb0e", + "Fbe0", + "AF0ieb", + "F0ieb", + "AFi0eb", + "Fi0eb", + "AFp0eb", + "Fp0eb", + "AF0peb", + "F0peb", + "AF0ibe", + "F0ibe", + "AFi0be", + "Fi0be", + "AFp0be", + "Fp0be", + "AF0pbe", + "F0pbe", + "AF0e", + "AFe0", + "F0e", + "Fe0", + "AF0ie", + "F0ie", + "AFi0e", + "Fi0e", + "AFp0e", + "Fp0e", + "AF0pe", + "F0pe", + "AF9en", + "AFe9n", + "AF9ne", + "AFn9e", + "AFne9", + "F9en", + "Fe9n", + "F9ne", + "Fn9e", + "Fne9", + "AF9ien", + "F9ien", + "AFi9en", + "Fi9en", + "AFp9en", + "Fp9en", + "AF9pen", + "F9pen", + "AF9ine", + "F9ine", + "AFi9ne", + "Fi9ne", + "AFp9ne", + "Fp9ne", + "AF9pne", + "F9pne", + "AF9eb", + "AFe9b", + "AF9be", + "AFb9e", + "AFbe9", + "F9eb", + "Fe9b", + "F9be", + "Fb9e", + "Fbe9", + "AF9ieb", + "F9ieb", + "AFi9eb", + "Fi9eb", + "AFp9eb", + "Fp9eb", + "AF9peb", + "F9peb", + "AF9ibe", + "F9ibe", + "AFi9be", + "Fi9be", + "AFp9be", + "Fp9be", + "AF9pbe", + "F9pbe", + "AF9e", + "AFe9", + "F9e", + "Fe9", + "AF9ie", + "F9ie", + "AFi9e", + "Fi9e", + "AFp9e", + "Fp9e", + "AF9pe", + "F9pe", + "Adoem", + "Adeom", + "Adome", + "Admoe", + "Admeo", + "Doem", + "Deom", + "Dome", + "Dmoe", + "Dmeo", + "Adeim", + "Adime", + "Admie", + "Admei", + "Deim", + "Dime", + "Dmie", + "Dmei", + "Adpem", + "Adepm", + "Adpme", + "Admpe", + "Admep", + "Dpem", + "Depm", + "Dpme", + "Dmpe", + "Dmep", + "Adoiem", + "Doiem", + "Adpiem", + "Dpiem", + "Adipem", + "Dipem", + "Adpoem", + "Dpoem", + "Adoime", + "Doime", + "Adpime", + "Dpime", + "Adipme", + "Dipme", + "Adpome", + "Dpome", + "Adopme", + "Dopme", + "ASoem", + "ASeom", + "ASmoe", + "ASmeo", + "Soem", + "Seom", + "Smoe", + "Smeo", + "ASiem", + "ASeim", + "ASime", + "ASmie", + "ASmei", + "Siem", + "Seim", + "Sime", + "Smie", + "Smei", + "ASpem", + "ASepm", + "ASpme", + "ASmpe", + "ASmep", + "Spem", + "Sepm", + "Spme", + "Smpe", + "Smep", + "ASoiem", + "Soiem", + "ASpiem", + "Spiem", + "ASioem", + "Sioem", + "ASipem", + "Sipem", + "ASpoem", + "Spoem", + "ASopem", + "Sopem", + "ASoime", + "Soime", + "ASiome", + "Siome", + "ASipme", + "Sipme", + "ASpome", + "Spome", + "ASopme", + "Sopme", + "Adme", + "Dme", + "ASme", + "Sme", + "Ad0em", + "Ade0m", + "Ad0me", + "Adm0e", + "Adme0", + "D0em", + "De0m", + "D0me", + "Dm0e", + "Dme0", + "Ad0iem", + "D0iem", + "Adi0em", + "Di0em", + "Adp0em", + "Dp0em", + "Ad0pem", + "D0pem", + "Ad0ime", + "D0ime", + "Adi0me", + "Di0me", + "Adp0me", + "Dp0me", + "Ad0pme", + "D0pme", + "AS0em", + "ASe0m", + "AS0me", + "ASm0e", + "ASme0", + "S0em", + "Se0m", + "S0me", + "Sm0e", + "Sme0", + "AS0iem", + "S0iem", + "ASi0em", + "Si0em", + "ASp0em", + "Sp0em", + "AS0pem", + "S0pem", + "AS0ime", + "S0ime", + "ASi0me", + "Si0me", + "ASp0me", + "Sp0me", + "AS0pme", + "S0pme", + "Ad9em", + "Ade9m", + "Ad9me", + "Adm9e", + "Adme9", + "D9em", + "De9m", + "D9me", + "Dm9e", + "Dme9", + "Ad9iem", + "D9iem", + "Adi9em", + "Di9em", + "Adp9em", + "Dp9em", + "Ad9pem", + "D9pem", + "Ad9ime", + "D9ime", + "Adi9me", + "Di9me", + "Adp9me", + "Dp9me", + "Ad9pme", + "D9pme", + "AS9em", + "ASe9m", + "AS9me", + "ASm9e", + "ASme9", + "S9em", + "Se9m", + "S9me", + "Sm9e", + "Sme9", + "AS9iem", + "S9iem", + "ASi9em", + "Si9em", + "ASp9em", + "Sp9em", + "AS9pem", + "S9pem", + "AS9ime", + "S9ime", + "ASi9me", + "Si9me", + "ASp9me", + "Sp9me", + "AS9pme", + "S9pme", + "AFoem", + "AFeom", + "AFome", + "AFmoe", + "AFmeo", + "Foem", + "Feom", + "Fome", + "Fmoe", + "Fmeo", + "AFiem", + "AFeim", + "AFime", + "AFmie", + "AFmei", + "Fiem", + "Feim", + "Fime", + "Fmie", + "Fmei", + "AFpem", + "AFepm", + "AFpme", + "AFmpe", + "AFmep", + "Fpem", + "Fepm", + "Fpme", + "Fmpe", + "Fmep", + "AFoiem", + "Foiem", + "AFpiem", + "Fpiem", + "AFioem", + "Fioem", + "AFipem", + "Fipem", + "AFpoem", + "Fpoem", + "AFopem", + "Fopem", + "AFoime", + "Foime", + "AFpime", + "Fpime", + "AFiome", + "Fiome", + "AFipme", + "Fipme", + "AFpome", + "Fpome", + "AFopme", + "Fopme", + "AFme", + "Fme", + "AF0em", + "AFe0m", + "AF0me", + "AFm0e", + "AFme0", + "F0em", + "Fe0m", + "F0me", + "Fm0e", + "Fme0", + "AF0iem", + "F0iem", + "AFi0em", + "Fi0em", + "AFp0em", + "Fp0em", + "AF0pem", + "F0pem", + "AF0ime", + "F0ime", + "AFi0me", + "Fi0me", + "AFp0me", + "Fp0me", + "AF0pme", + "F0pme", + "AF9em", + "AFe9m", + "AF9me", + "AFm9e", + "AFme9", + "F9em", + "Fe9m", + "F9me", + "Fm9e", + "Fme9", + "AF9iem", + "F9iem", + "AFi9em", + "Fi9em", + "AFp9em", + "Fp9em", + "AF9pem", + "F9pem", + "AF9ime", + "F9ime", + "AFi9me", + "Fi9me", + "AFp9me", + "Fp9me", + "AF9pme", + "F9pme", + "Backward", + "Backwards", + "Back", + "ABackward", + "ABackwards", + "ABack", + "Backwars", + "Backwarss", + "ABackwars", + "ABackwarss", + "Backwar", + "ABackwar", + "Bacxkward", + "Bacxkwards", + "Bacxk", + "ABacxkward", + "ABacxkwards", + "ABacxk", + "Baxckward", + "Baxckwards", + "Baxck", + "ABaxckward", + "ABaxckwards", + "ABaxck", + "Baxkward", + "Baxkwards", + "Baxk", + "ABaxkward", + "ABaxkwards", + "ABaxk", + "Bacxkwar", + "Bacxkwars", + "ABacxkwar", + "ABacxkwars", + "Baxckwar", + "Baxckwars", + "ABaxckwar", + "ABaxckwars", + "Baxkwar", + "Baxkwars", + "ABaxkwar", + "ABaxkwars", + "Bacxkwarss", + "ABacxkwarss", + "Baxckwarss", + "ABaxckwarss", + "Baxkwarss", + "ABaxkwarss", + "Bavckward", + "Bavckwards", + "Bavck", + "ABavckward", + "ABavckwards", + "ABavck", + "Bavckwars", + "Bavckwarss", + "ABavckwars", + "ABavckwarss", + "Bavckwar", + "ABavckwar", + "Bakcward", + "Bakcwards", + "Bakc", + "ABakcward", + "ABakcwards", + "ABakc", + "Bakcwars", + "Bakcwarss", + "ABakcwars", + "ABakcwarss", + "Bakcwar", + "ABakcwar", + "Baccward", + "Baccwards", + "Bacc", + "ABaccward", + "ABaccwards", + "ABacc", + "Baccwars", + "Baccwarss", + "ABaccwars", + "ABaccwarss", + "Baccwar", + "ABaccwar", + "Bavkward", + "Bavkwards", + "Bavk", + "ABavkward", + "ABavkwards", + "ABavk", + "Bavkwars", + "Bavkwarss", + "ABavkwars", + "ABavkwarss", + "Bavkwar", + "ABavkwar", + "Bacvkward", + "Bacvkwards", + "Bacvk", + "ABacvkward", + "ABacvkwards", + "ABacvk", + "Bacvkwars", + "Bacvkwarss", + "ABacvkwars", + "ABacvkwarss", + "Bacvkwar", + "ABacvkwar", + "Walkdown", + "Movedown", + "Mvoedown", + "WalkBack", + "WalkBacc", + "WalkBakc", + "WalkBavck", + "WalkBavk", + "WalkBacvk", + "WalkBacxk", + "WalkBaxck", + "WalkBaxk", + "MoveBack", + "MoveBacc", + "MoveBakc", + "MoveBavck", + "MoveBavk", + "MoveBacvk", + "MoveBacxk", + "MoveBaxck", + "MoveBaxk", + "MvoeBack", + "MvoeBacc", + "MvoeBakc", + "MvoeBavck", + "MvoeBavk", + "MvoeBacvk", + "MvoeBacxk", + "MvoeBaxck", + "MvoeBaxk", + "WalkBackwar", + "WalkBaccwar", + "WalkBakcwar", + "WalkBavckwar", + "WalkBavkwar", + "WalkBacvkwar", + "WalkBacxkwar", + "WalkBaxckwar", + "WalkBaxkwar", + "WalkBackwars", + "WalkBaccwars", + "WalkBakcwars", + "WalkBavckwars", + "WalkBavkwars", + "WalkBacvkwars", + "WalkBacxkwars", + "WalkBaxckwars", + "WalkBaxkwars", + "WalkBackward", + "WalkBaccward", + "WalkBakcward", + "WalkBavckward", + "WalkBavkward", + "WalkBacvkward", + "WalkBacxkward", + "WalkBaxckward", + "WalkBaxkward", + "WalkBackwards", + "WalkBaccwards", + "WalkBakcwards", + "WalkBavckwards", + "WalkBavkwards", + "WalkBacvkwards", + "WalkBacxkwards", + "WalkBaxckwards", + "WalkBaxkwards", + "WalkBackwarss", + "WalkBaccwarss", + "WalkBakcwarss", + "WalkBavckwarss", + "WalkBavkwarss", + "WalkBacvkwarss", + "WalkBacxkwarss", + "WalkBaxckwarss", + "WalkBaxkwarss", + "MoveBackwar", + "MoveBaccwar", + "MoveBakcwar", + "MoveBavckwar", + "MoveBavkwar", + "MoveBacvkwar", + "MoveBacxkwar", + "MoveBaxckwar", + "MoveBaxkwar", + "MoveBackwars", + "MoveBaccwars", + "MoveBakcwars", + "MoveBavckwars", + "MoveBavkwars", + "MoveBacvkwars", + "MoveBacxkwars", + "MoveBaxckwars", + "MoveBaxkwars", + "MoveBackward", + "MoveBaccward", + "MoveBakcward", + "MoveBavckward", + "MoveBavkward", + "MoveBacvkward", + "MoveBacxkward", + "MoveBaxckward", + "MoveBaxkward", + "MoveBackwards", + "MoveBaccwards", + "MoveBakcwards", + "MoveBavckwards", + "MoveBavkwards", + "MoveBacvkwards", + "MoveBacxkwards", + "MoveBaxckwards", + "MoveBaxkwards", + "MoveBackwarss", + "MoveBaccwarss", + "MoveBakcwarss", + "MoveBavckwarss", + "MoveBavkwarss", + "MoveBacvkwarss", + "MoveBacxkwarss", + "MoveBaxckwarss", + "MoveBaxkwarss", + "MvoeBackwar", + "MvoeBaccwar", + "MvoeBakcwar", + "MvoeBavckwar", + "MvoeBavkwar", + "MvoeBacvkwar", + "MvoeBacxkwar", + "MvoeBaxckwar", + "MvoeBaxkwar", + "MvoeBackwars", + "MvoeBaccwars", + "MvoeBakcwars", + "MvoeBavckwars", + "MvoeBavkwars", + "MvoeBacvkwars", + "MvoeBacxkwars", + "MvoeBaxckwars", + "MvoeBaxkwars", + "MvoeBackward", + "MvoeBaccward", + "MvoeBakcward", + "MvoeBavckward", + "MvoeBavkward", + "MvoeBacvkward", + "MvoeBacxkward", + "MvoeBaxckward", + "MvoeBaxkward", + "MvoeBackwards", + "MvoeBaccwards", + "MvoeBakcwards", + "MvoeBavckwards", + "MvoeBavkwards", + "MvoeBacvkwards", + "MvoeBacxkwards", + "MvoeBaxckwards", + "MvoeBaxkwards", + "MvoeBackwarss", + "MvoeBaccwarss", + "MvoeBakcwarss", + "MvoeBavckwarss", + "MvoeBavkwarss", + "MvoeBacvkwarss", + "MvoeBacxkwarss", + "MvoeBaxckwarss", + "MvoeBaxkwarss", + "Backword", + "Backwords", + "ABackword", + "ABackwords", + "Backwors", + "Backworss", + "ABackwors", + "ABackworss", + "Backwor", + "ABackwor", + "Bacxkword", + "Bacxkwords", + "ABacxkword", + "ABacxkwords", + "Baxckword", + "Baxckwords", + "ABaxckword", + "ABaxckwords", + "Baxkword", + "Baxkwords", + "ABaxkword", + "ABaxkwords", + "Bacxkwor", + "Bacxkwors", + "ABacxkwor", + "ABacxkwors", + "Baxckwor", + "Baxckwors", + "ABaxckwor", + "ABaxckwors", + "Baxkwor", + "Baxkwors", + "ABaxkwor", + "ABaxkwors", + "Bacxkworss", + "ABacxkworss", + "Baxckworss", + "ABaxckworss", + "Baxkworss", + "ABaxkworss", + "Bavckword", + "Bavckwords", + "ABavckword", + "ABavckwords", + "Bavckwors", + "Bavckworss", + "ABavckwors", + "ABavckworss", + "Bavckwor", + "ABavckwor", + "Bakcword", + "Bakcwords", + "ABakcword", + "ABakcwords", + "Bakcwors", + "Bakcworss", + "ABakcwors", + "ABakcworss", + "Bakcwor", + "ABakcwor", + "Baccword", + "Baccwords", + "ABaccword", + "ABaccwords", + "Baccwors", + "Baccworss", + "ABaccwors", + "ABaccworss", + "Baccwor", + "ABaccwor", + "Bavkword", + "Bavkwords", + "ABavkword", + "ABavkwords", + "Bavkwors", + "Bavkworss", + "ABavkwors", + "ABavkworss", + "Bavkwor", + "ABavkwor", + "Bacvkword", + "Bacvkwords", + "ABacvkword", + "ABacvkwords", + "Bacvkwors", + "Bacvkworss", + "ABacvkwors", + "ABacvkworss", + "Bacvkwor", + "ABacvkwor", + "WalkBackwor", + "WalkBaccwor", + "WalkBakcwor", + "WalkBavckwor", + "WalkBavkwor", + "WalkBacvkwor", + "WalkBacxkwor", + "WalkBaxckwor", + "WalkBaxkwor", + "WalkBackwors", + "WalkBaccwors", + "WalkBakcwors", + "WalkBavckwors", + "WalkBavkwors", + "WalkBacvkwors", + "WalkBacxkwors", + "WalkBaxckwors", + "WalkBaxkwors", + "WalkBackword", + "WalkBaccword", + "WalkBakcword", + "WalkBavckword", + "WalkBavkword", + "WalkBacvkword", + "WalkBacxkword", + "WalkBaxckword", + "WalkBaxkword", + "WalkBackwords", + "WalkBaccwords", + "WalkBakcwords", + "WalkBavckwords", + "WalkBavkwords", + "WalkBacvkwords", + "WalkBacxkwords", + "WalkBaxckwords", + "WalkBaxkwords", + "WalkBackworss", + "WalkBaccworss", + "WalkBakcworss", + "WalkBavckworss", + "WalkBavkworss", + "WalkBacvkworss", + "WalkBacxkworss", + "WalkBaxckworss", + "WalkBaxkworss", + "MoveBackwor", + "MoveBaccwor", + "MoveBakcwor", + "MoveBavckwor", + "MoveBavkwor", + "MoveBacvkwor", + "MoveBacxkwor", + "MoveBaxckwor", + "MoveBaxkwor", + "MoveBackwors", + "MoveBaccwors", + "MoveBakcwors", + "MoveBavckwors", + "MoveBavkwors", + "MoveBacvkwors", + "MoveBacxkwors", + "MoveBaxckwors", + "MoveBaxkwors", + "MoveBackword", + "MoveBaccword", + "MoveBakcword", + "MoveBavckword", + "MoveBavkword", + "MoveBacvkword", + "MoveBacxkword", + "MoveBaxckword", + "MoveBaxkword", + "MoveBackwords", + "MoveBaccwords", + "MoveBakcwords", + "MoveBavckwords", + "MoveBavkwords", + "MoveBacvkwords", + "MoveBacxkwords", + "MoveBaxckwords", + "MoveBaxkwords", + "MoveBackworss", + "MoveBaccworss", + "MoveBakcworss", + "MoveBavckworss", + "MoveBavkworss", + "MoveBacvkworss", + "MoveBacxkworss", + "MoveBaxckworss", + "MoveBaxkworss", + "MvoeBackwor", + "MvoeBaccwor", + "MvoeBakcwor", + "MvoeBavckwor", + "MvoeBavkwor", + "MvoeBacvkwor", + "MvoeBacxkwor", + "MvoeBaxckwor", + "MvoeBaxkwor", + "MvoeBackwors", + "MvoeBaccwors", + "MvoeBakcwors", + "MvoeBavckwors", + "MvoeBavkwors", + "MvoeBacvkwors", + "MvoeBacxkwors", + "MvoeBaxckwors", + "MvoeBaxkwors", + "MvoeBackword", + "MvoeBaccword", + "MvoeBakcword", + "MvoeBavckword", + "MvoeBavkword", + "MvoeBacvkword", + "MvoeBacxkword", + "MvoeBaxckword", + "MvoeBaxkword", + "MvoeBackwords", + "MvoeBaccwords", + "MvoeBakcwords", + "MvoeBavckwords", + "MvoeBavkwords", + "MvoeBacvkwords", + "MvoeBacxkwords", + "MvoeBaxckwords", + "MvoeBaxkwords", + "MvoeBackworss", + "MvoeBaccworss", + "MvoeBakcworss", + "MvoeBavckworss", + "MvoeBavkworss", + "MvoeBacvkworss", + "MvoeBacxkworss", + "MvoeBaxckworss", + "MvoeBaxkworss", + "RightStickDown", + "RightStickD", + "RStickDown", + "RStickD", + "CameraStickDown", + "CameraStickD", + "CamStickDown", + "CamStickD", + "CStickDown", + "CStickD", + "DownnCam", + "Cam-Downn", + "CamDownn", + "CamFpwn", + "CamFpwb", + "CamFpw", + "CamFpwm", + "DownCam", + "CamAckwrd", + "CamAckwrds", + "CamAckwrs", + "CamAckwrss", + "CamAckwr", + "CamAckward", + "CamAckwards", + "CamAck", + "CamAckwars", + "CamAckwarss", + "CamAckwar", + "CamAckword", + "CamAckwords", + "CamAckwors", + "CamAckworss", + "CamAckwor", + "CamBabkwrd", + "CamBabkwrds", + "CamBabkwrs", + "CamBabkwrss", + "CamBabkwr", + "CamBabkward", + "CamBabkwards", + "CamBabk", + "CamBabkwars", + "CamBabkwarss", + "CamBabkwar", + "CamBabkword", + "CamBabkwords", + "CamBabkwors", + "CamBabkworss", + "CamBabkwor", + "Cam-Xown", + "CamXown", + "Cam-Doown", + "CamDoown", + "Cam-dowwn", + "Camdowwn", + "Camdonww", + "CamSputh", + "CamSout", + "CamSput", + "CamBackwrd", + "CamBackwrds", + "CamBackwrs", + "CamBackwrss", + "CamBackwr", + "CamBacxkwrd", + "CamBacxkwrds", + "CamBaxckwrd", + "CamBaxckwrds", + "CamBaxkwrd", + "CamBaxkwrds", + "CamBacxkwr", + "CamBacxkwrs", + "CamBaxckwr", + "CamBaxckwrs", + "CamBaxkwr", + "CamBaxkwrs", + "CamBacxkwrss", + "CamBaxckwrss", + "CamBaxkwrss", + "CamBavckwrd", + "CamBavckwrds", + "CamBavckwrs", + "CamBavckwrss", + "CamBavckwr", + "CamBakcwrd", + "CamBakcwrds", + "CamBakcwrs", + "CamBakcwrss", + "CamBakcwr", + "CamBaccwrd", + "CamBaccwrds", + "CamBaccwrs", + "CamBaccwrss", + "CamBaccwr", + "CamBavkwrd", + "CamBavkwrds", + "CamBavkwrs", + "CamBavkwrss", + "CamBavkwr", + "CamBacvkwrd", + "CamBacvkwrds", + "CamBacvkwrs", + "CamBacvkwrss", + "CamBacvkwr", + "Cam-Doqn", + "CamDoqn", + "Cam-down", + "CamReverse", + "Camdown", + "Camdwon", + "Camdonw", + "Camdnow", + "Camdnwo", + "CamD", + "Camv", + "Cam↓", + "CamSouth", + "CamS", + "Cam▼", + "Camdiwn", + "Camdwin", + "Camdinw", + "Camdniw", + "Camdnwi", + "Camdpwn", + "Camdwpn", + "Camdpnw", + "Camdnpw", + "Camdnwp", + "Camdon", + "Camdin", + "Camdpn", + "Camdoiwn", + "Camdpiwn", + "Camdipwn", + "Camdpown", + "Camdopwn", + "Camdoinw", + "Camdpinw", + "Camdipnw", + "Camdponw", + "Camdopnw", + "Camdowb", + "Camdwob", + "Camdobw", + "Camdbow", + "Camdbwo", + "Camdiwb", + "Camdwib", + "Camdibw", + "Camdbiw", + "Camdbwi", + "Camdpwb", + "Camdwpb", + "Camdpbw", + "Camdbpw", + "Camdbwp", + "Camdob", + "Camdib", + "Camdpb", + "Camdoiwb", + "Camdpiwb", + "Camdipwb", + "Camdpowb", + "Camdopwb", + "Camdoibw", + "Camdpibw", + "Camdipbw", + "Camdpobw", + "Camdopbw", + "CamSown", + "CamSwon", + "CamSonw", + "CamSnow", + "CamSnwo", + "CamSiwn", + "CamSinw", + "CamSniw", + "CamSnwi", + "CamSpwn", + "CamSwpn", + "CamSpnw", + "CamSnpw", + "CamSnwp", + "CamSpn", + "CamSoiwn", + "CamSpiwn", + "CamSiown", + "CamSipwn", + "CamSpown", + "CamSopwn", + "CamSoinw", + "CamSionw", + "CamSipnw", + "CamSponw", + "CamSopnw", + "CamSowb", + "CamSwob", + "CamSobw", + "CamSbow", + "CamSbwo", + "CamSiwb", + "CamSwib", + "CamSibw", + "CamSbiw", + "CamSbwi", + "CamSpwb", + "CamSwpb", + "CamSpbw", + "CamSbpw", + "CamSbwp", + "CamSob", + "CamSib", + "CamSpb", + "CamSoiwb", + "CamSpiwb", + "CamSiowb", + "CamSipwb", + "CamSpowb", + "CamSopwb", + "CamSoibw", + "CamSpibw", + "CamSiobw", + "CamSipbw", + "CamSpobw", + "CamSopbw", + "Camdow", + "Camdwo", + "Camdno", + "Camdnw", + "Camdiw", + "Camdwi", + "Camdni", + "Camdpw", + "Camdwp", + "Camdnp", + "Camdoiw", + "Camdpiw", + "Camdipw", + "Camdpow", + "Camdopw", + "Camdoin", + "Camdpin", + "Camdipn", + "Camdpon", + "Camdopn", + "Camdbo", + "Camdbw", + "Camdbi", + "Camdbp", + "Camdoib", + "Camdpib", + "Camdipb", + "Camdpob", + "Camdopb", + "CamSow", + "CamSwo", + "CamSno", + "CamSnw", + "CamSiw", + "CamSwi", + "CamSni", + "CamSpw", + "CamSwp", + "CamSnp", + "CamSoiw", + "CamSpiw", + "CamSiow", + "CamSipw", + "CamSpow", + "CamSopw", + "CamSoin", + "CamSion", + "CamSipn", + "CamSpon", + "CamSopn", + "CamSbo", + "CamSbw", + "CamSbi", + "CamSbp", + "CamSoib", + "CamSpib", + "CamSiob", + "CamSipb", + "CamSpob", + "CamSopb", + "Camd0wn", + "Camdw0n", + "Camd0nw", + "Camdn0w", + "Camdnw0", + "CamS0uth", + "Camd0n", + "Camd0iwn", + "Camdi0wn", + "Camdp0wn", + "Camd0pwn", + "Camd0inw", + "Camdi0nw", + "Camdp0nw", + "Camd0pnw", + "Camd0wb", + "Camdw0b", + "Camd0bw", + "Camdb0w", + "Camdbw0", + "Camd0b", + "Camd0iwb", + "Camdi0wb", + "Camdp0wb", + "Camd0pwb", + "Camd0ibw", + "Camdi0bw", + "Camdp0bw", + "Camd0pbw", + "CamS0wn", + "CamSw0n", + "CamS0nw", + "CamSn0w", + "CamSnw0", + "CamS0n", + "CamS0iwn", + "CamSi0wn", + "CamSp0wn", + "CamS0pwn", + "CamS0inw", + "CamSi0nw", + "CamSp0nw", + "CamS0pnw", + "CamS0wb", + "CamSw0b", + "CamS0bw", + "CamSb0w", + "CamSbw0", + "CamS0b", + "CamS0iwb", + "CamSi0wb", + "CamSp0wb", + "CamS0pwb", + "CamS0ibw", + "CamSi0bw", + "CamSp0bw", + "CamS0pbw", + "Camd0w", + "Camdw0", + "Camdn0", + "Camd0iw", + "Camdi0w", + "Camdp0w", + "Camd0pw", + "Camd0in", + "Camdi0n", + "Camdp0n", + "Camd0pn", + "Camdb0", + "Camd0ib", + "Camdi0b", + "Camdp0b", + "Camd0pb", + "CamS0w", + "CamSw0", + "CamSn0", + "CamS0iw", + "CamSi0w", + "CamSp0w", + "CamS0pw", + "CamS0in", + "CamSi0n", + "CamSp0n", + "CamS0pn", + "CamSb0", + "CamS0ib", + "CamSi0b", + "CamSp0b", + "CamS0pb", + "Camd9wn", + "Camdw9n", + "Camd9nw", + "Camdn9w", + "Camdnw9", + "CamS9uth", + "Camd9n", + "Camd9iwn", + "Camdi9wn", + "Camdp9wn", + "Camd9pwn", + "Camd9inw", + "Camdi9nw", + "Camdp9nw", + "Camd9pnw", + "Camd9wb", + "Camdw9b", + "Camd9bw", + "Camdb9w", + "Camdbw9", + "Camd9b", + "Camd9iwb", + "Camdi9wb", + "Camdp9wb", + "Camd9pwb", + "Camd9ibw", + "Camdi9bw", + "Camdp9bw", + "Camd9pbw", + "CamS9wn", + "CamSw9n", + "CamS9nw", + "CamSn9w", + "CamSnw9", + "CamS9n", + "CamS9iwn", + "CamSi9wn", + "CamSp9wn", + "CamS9pwn", + "CamS9inw", + "CamSi9nw", + "CamSp9nw", + "CamS9pnw", + "CamS9wb", + "CamSw9b", + "CamS9bw", + "CamSb9w", + "CamSbw9", + "CamS9b", + "CamS9iwb", + "CamSi9wb", + "CamSp9wb", + "CamS9pwb", + "CamS9ibw", + "CamSi9bw", + "CamSp9bw", + "CamS9pbw", + "Camd9w", + "Camdw9", + "Camdn9", + "Camd9iw", + "Camdi9w", + "Camdp9w", + "Camd9pw", + "Camd9in", + "Camdi9n", + "Camdp9n", + "Camd9pn", + "Camdb9", + "Camd9ib", + "Camdi9b", + "Camdp9b", + "Camd9pb", + "CamS9w", + "CamSw9", + "CamSn9", + "CamS9iw", + "CamSi9w", + "CamSp9w", + "CamS9pw", + "CamS9in", + "CamSi9n", + "CamSp9n", + "CamS9pn", + "CamSb9", + "CamS9ib", + "CamSi9b", + "CamSp9b", + "CamS9pb", + "CamFown", + "CamFwon", + "CamFonw", + "CamFnow", + "CamFnwo", + "CamF", + "CamFiwn", + "CamFwin", + "CamFinw", + "CamFniw", + "CamFnwi", + "CamFwpn", + "CamFpnw", + "CamFnpw", + "CamFnwp", + "CamFon", + "CamFin", + "CamFpn", + "CamFoiwn", + "CamFpiwn", + "CamFiown", + "CamFipwn", + "CamFpown", + "CamFopwn", + "CamFoinw", + "CamFpinw", + "CamFionw", + "CamFipnw", + "CamFponw", + "CamFopnw", + "CamFowb", + "CamFwob", + "CamFobw", + "CamFbow", + "CamFbwo", + "CamFiwb", + "CamFwib", + "CamFibw", + "CamFbiw", + "CamFbwi", + "CamFwpb", + "CamFpbw", + "CamFbpw", + "CamFbwp", + "CamFob", + "CamFib", + "CamFpb", + "CamFoiwb", + "CamFpiwb", + "CamFiowb", + "CamFipwb", + "CamFpowb", + "CamFopwb", + "CamFoibw", + "CamFpibw", + "CamFiobw", + "CamFipbw", + "CamFpobw", + "CamFopbw", + "CamFow", + "CamFwo", + "CamFno", + "CamFnw", + "CamFiw", + "CamFwi", + "CamFni", + "CamFwp", + "CamFnp", + "CamFoiw", + "CamFpiw", + "CamFiow", + "CamFipw", + "CamFpow", + "CamFopw", + "CamFoin", + "CamFpin", + "CamFion", + "CamFipn", + "CamFpon", + "CamFopn", + "CamFbo", + "CamFbw", + "CamFbi", + "CamFbp", + "CamFoib", + "CamFpib", + "CamFiob", + "CamFipb", + "CamFpob", + "CamFopb", + "CamF0wn", + "CamFw0n", + "CamF0nw", + "CamFn0w", + "CamFnw0", + "CamF0n", + "CamF0iwn", + "CamFi0wn", + "CamFp0wn", + "CamF0pwn", + "CamF0inw", + "CamFi0nw", + "CamFp0nw", + "CamF0pnw", + "CamF0wb", + "CamFw0b", + "CamF0bw", + "CamFb0w", + "CamFbw0", + "CamF0b", + "CamF0iwb", + "CamFi0wb", + "CamFp0wb", + "CamF0pwb", + "CamF0ibw", + "CamFi0bw", + "CamFp0bw", + "CamF0pbw", + "CamF0w", + "CamFw0", + "CamFn0", + "CamF0iw", + "CamFi0w", + "CamFp0w", + "CamF0pw", + "CamF0in", + "CamFi0n", + "CamFp0n", + "CamF0pn", + "CamFb0", + "CamF0ib", + "CamFi0b", + "CamFp0b", + "CamF0pb", + "CamF9wn", + "CamFw9n", + "CamF9nw", + "CamFn9w", + "CamFnw9", + "CamF9n", + "CamF9iwn", + "CamFi9wn", + "CamFp9wn", + "CamF9pwn", + "CamF9inw", + "CamFi9nw", + "CamFp9nw", + "CamF9pnw", + "CamF9wb", + "CamFw9b", + "CamF9bw", + "CamFb9w", + "CamFbw9", + "CamF9b", + "CamF9iwb", + "CamFi9wb", + "CamFp9wb", + "CamF9pwb", + "CamF9ibw", + "CamFi9bw", + "CamFp9bw", + "CamF9pbw", + "CamF9w", + "CamFw9", + "CamFn9", + "CamF9iw", + "CamFi9w", + "CamFp9w", + "CamF9pw", + "CamF9in", + "CamFi9n", + "CamFp9n", + "CamF9pn", + "CamFb9", + "CamF9ib", + "CamFi9b", + "CamFp9b", + "CamF9pb", + "Camdowm", + "Camdwom", + "Camdomw", + "Camdmow", + "Camdmwo", + "Camdiwm", + "Camdwim", + "Camdimw", + "Camdmiw", + "Camdmwi", + "Camdpwm", + "Camdwpm", + "Camdpmw", + "Camdmpw", + "Camdmwp", + "Camdom", + "Camdim", + "Camdpm", + "Camdoiwm", + "Camdpiwm", + "Camdipwm", + "Camdpowm", + "Camdopwm", + "Camdoimw", + "Camdpimw", + "Camdipmw", + "Camdpomw", + "Camdopmw", + "CamSowm", + "CamSwom", + "CamSomw", + "CamSmow", + "CamSmwo", + "CamSiwm", + "CamSimw", + "CamSmiw", + "CamSmwi", + "CamSpwm", + "CamSwpm", + "CamSpmw", + "CamSmpw", + "CamSmwp", + "CamSom", + "CamSim", + "CamSpm", + "CamSoiwm", + "CamSpiwm", + "CamSiowm", + "CamSipwm", + "CamSpowm", + "CamSopwm", + "CamSoimw", + "CamSiomw", + "CamSipmw", + "CamSpomw", + "CamSopmw", + "Camdmo", + "Camdmw", + "Camdmi", + "Camdmp", + "Camdoim", + "Camdpim", + "Camdipm", + "Camdpom", + "Camdopm", + "CamSmo", + "CamSmw", + "CamSmi", + "CamSmp", + "CamSoim", + "CamSiom", + "CamSipm", + "CamSpom", + "CamSopm", + "Camd0wm", + "Camdw0m", + "Camd0mw", + "Camdm0w", + "Camdmw0", + "Camd0m", + "Camd0iwm", + "Camdi0wm", + "Camdp0wm", + "Camd0pwm", + "Camd0imw", + "Camdi0mw", + "Camdp0mw", + "Camd0pmw", + "CamS0wm", + "CamSw0m", + "CamS0mw", + "CamSm0w", + "CamSmw0", + "CamS0m", + "CamS0iwm", + "CamSi0wm", + "CamSp0wm", + "CamS0pwm", + "CamS0imw", + "CamSi0mw", + "CamSp0mw", + "CamS0pmw", + "Camdm0", + "Camd0im", + "Camdi0m", + "Camdp0m", + "Camd0pm", + "CamSm0", + "CamS0im", + "CamSi0m", + "CamSp0m", + "CamS0pm", + "Camd9wm", + "Camdw9m", + "Camd9mw", + "Camdm9w", + "Camdmw9", + "Camd9m", + "Camd9iwm", + "Camdi9wm", + "Camdp9wm", + "Camd9pwm", + "Camd9imw", + "Camdi9mw", + "Camdp9mw", + "Camd9pmw", + "CamS9wm", + "CamSw9m", + "CamS9mw", + "CamSm9w", + "CamSmw9", + "CamS9m", + "CamS9iwm", + "CamSi9wm", + "CamSp9wm", + "CamS9pwm", + "CamS9imw", + "CamSi9mw", + "CamSp9mw", + "CamS9pmw", + "Camdm9", + "Camd9im", + "Camdi9m", + "Camdp9m", + "Camd9pm", + "CamSm9", + "CamS9im", + "CamSi9m", + "CamSp9m", + "CamS9pm", + "CamFowm", + "CamFwom", + "CamFomw", + "CamFmow", + "CamFmwo", + "CamFiwm", + "CamFwim", + "CamFimw", + "CamFmiw", + "CamFmwi", + "CamFwpm", + "CamFpmw", + "CamFmpw", + "CamFmwp", + "CamFom", + "CamFim", + "CamFpm", + "CamFoiwm", + "CamFpiwm", + "CamFiowm", + "CamFipwm", + "CamFpowm", + "CamFopwm", + "CamFoimw", + "CamFpimw", + "CamFiomw", + "CamFipmw", + "CamFpomw", + "CamFopmw", + "CamFmo", + "CamFmw", + "CamFmi", + "CamFmp", + "CamFoim", + "CamFpim", + "CamFiom", + "CamFipm", + "CamFpom", + "CamFopm", + "CamF0wm", + "CamFw0m", + "CamF0mw", + "CamFm0w", + "CamFmw0", + "CamF0m", + "CamF0iwm", + "CamFi0wm", + "CamFp0wm", + "CamF0pwm", + "CamF0imw", + "CamFi0mw", + "CamFp0mw", + "CamF0pmw", + "CamFm0", + "CamF0im", + "CamFi0m", + "CamFp0m", + "CamF0pm", + "CamF9wm", + "CamFw9m", + "CamF9mw", + "CamFm9w", + "CamFmw9", + "CamF9m", + "CamF9iwm", + "CamFi9wm", + "CamFp9wm", + "CamF9pwm", + "CamF9imw", + "CamFi9mw", + "CamFp9mw", + "CamF9pmw", + "CamFm9", + "CamF9im", + "CamFi9m", + "CamFp9m", + "CamF9pm", + "Camdoen", + "Camdeon", + "Camdone", + "Camdnoe", + "Camdneo", + "Camdein", + "Camdine", + "Camdnie", + "Camdnei", + "Camdpen", + "Camdepn", + "Camdpne", + "Camdnpe", + "Camdnep", + "Camdoien", + "Camdpien", + "Camdipen", + "Camdpoen", + "Camdoine", + "Camdpine", + "Camdipne", + "Camdpone", + "Camdopne", + "Camdoeb", + "Camdeob", + "Camdobe", + "Camdboe", + "Camdbeo", + "Camdeib", + "Camdibe", + "Camdbie", + "Camdbei", + "Camdpeb", + "Camdepb", + "Camdpbe", + "Camdbpe", + "Camdbep", + "Camdoieb", + "Camdpieb", + "Camdipeb", + "Camdpoeb", + "Camdoibe", + "Camdpibe", + "Camdipbe", + "Camdpobe", + "Camdopbe", + "CamSoen", + "CamSeon", + "CamSone", + "CamSnoe", + "CamSneo", + "CamSien", + "CamSein", + "CamSine", + "CamSnie", + "CamSnei", + "CamSpen", + "CamSepn", + "CamSpne", + "CamSnpe", + "CamSnep", + "CamSoien", + "CamSpien", + "CamSioen", + "CamSipen", + "CamSpoen", + "CamSopen", + "CamSoine", + "CamSione", + "CamSipne", + "CamSpone", + "CamSopne", + "CamSoeb", + "CamSeob", + "CamSobe", + "CamSboe", + "CamSbeo", + "CamSieb", + "CamSeib", + "CamSibe", + "CamSbie", + "CamSbei", + "CamSpeb", + "CamSepb", + "CamSpbe", + "CamSbpe", + "CamSbep", + "CamSoieb", + "CamSpieb", + "CamSioeb", + "CamSipeb", + "CamSpoeb", + "CamSopeb", + "CamSoibe", + "CamSpibe", + "CamSiobe", + "CamSipbe", + "CamSpobe", + "CamSopbe", + "Camdoe", + "Camdeo", + "Camdne", + "Camdei", + "Camdpe", + "Camdep", + "Camdoie", + "Camdpie", + "Camdipe", + "Camdpoe", + "Camdbe", + "CamSoe", + "CamSeo", + "CamSne", + "CamSie", + "CamSei", + "CamSpe", + "CamSep", + "CamSoie", + "CamSpie", + "CamSioe", + "CamSipe", + "CamSpoe", + "CamSope", + "CamSbe", + "Camd0en", + "Camde0n", + "Camd0ne", + "Camdn0e", + "Camdne0", + "Camd0ien", + "Camdi0en", + "Camdp0en", + "Camd0pen", + "Camd0ine", + "Camdi0ne", + "Camdp0ne", + "Camd0pne", + "Camd0eb", + "Camde0b", + "Camd0be", + "Camdb0e", + "Camdbe0", + "Camd0ieb", + "Camdi0eb", + "Camdp0eb", + "Camd0peb", + "Camd0ibe", + "Camdi0be", + "Camdp0be", + "Camd0pbe", + "CamS0en", + "CamSe0n", + "CamS0ne", + "CamSn0e", + "CamSne0", + "CamS0ien", + "CamSi0en", + "CamSp0en", + "CamS0pen", + "CamS0ine", + "CamSi0ne", + "CamSp0ne", + "CamS0pne", + "CamS0eb", + "CamSe0b", + "CamS0be", + "CamSb0e", + "CamSbe0", + "CamS0ieb", + "CamSi0eb", + "CamSp0eb", + "CamS0peb", + "CamS0ibe", + "CamSi0be", + "CamSp0be", + "CamS0pbe", + "Camd0e", + "Camde0", + "Camd0ie", + "Camdi0e", + "Camdp0e", + "Camd0pe", + "CamS0e", + "CamSe0", + "CamS0ie", + "CamSi0e", + "CamSp0e", + "CamS0pe", + "Camd9en", + "Camde9n", + "Camd9ne", + "Camdn9e", + "Camdne9", + "Camd9ien", + "Camdi9en", + "Camdp9en", + "Camd9pen", + "Camd9ine", + "Camdi9ne", + "Camdp9ne", + "Camd9pne", + "Camd9eb", + "Camde9b", + "Camd9be", + "Camdb9e", + "Camdbe9", + "Camd9ieb", + "Camdi9eb", + "Camdp9eb", + "Camd9peb", + "Camd9ibe", + "Camdi9be", + "Camdp9be", + "Camd9pbe", + "CamS9en", + "CamSe9n", + "CamS9ne", + "CamSn9e", + "CamSne9", + "CamS9ien", + "CamSi9en", + "CamSp9en", + "CamS9pen", + "CamS9ine", + "CamSi9ne", + "CamSp9ne", + "CamS9pne", + "CamS9eb", + "CamSe9b", + "CamS9be", + "CamSb9e", + "CamSbe9", + "CamS9ieb", + "CamSi9eb", + "CamSp9eb", + "CamS9peb", + "CamS9ibe", + "CamSi9be", + "CamSp9be", + "CamS9pbe", + "Camd9e", + "Camde9", + "Camd9ie", + "Camdi9e", + "Camdp9e", + "Camd9pe", + "CamS9e", + "CamSe9", + "CamS9ie", + "CamSi9e", + "CamSp9e", + "CamS9pe", + "CamFoen", + "CamFeon", + "CamFone", + "CamFnoe", + "CamFneo", + "CamFien", + "CamFein", + "CamFnie", + "CamFnei", + "CamFpen", + "CamFepn", + "CamFpne", + "CamFnpe", + "CamFnep", + "CamFoien", + "CamFpien", + "CamFioen", + "CamFipen", + "CamFpoen", + "CamFopen", + "CamFoine", + "CamFpine", + "CamFione", + "CamFipne", + "CamFpone", + "CamFopne", + "CamFoeb", + "CamFeob", + "CamFobe", + "CamFboe", + "CamFbeo", + "CamFieb", + "CamFeib", + "CamFibe", + "CamFbie", + "CamFbei", + "CamFpeb", + "CamFepb", + "CamFpbe", + "CamFbpe", + "CamFbep", + "CamFoieb", + "CamFpieb", + "CamFioeb", + "CamFipeb", + "CamFpoeb", + "CamFopeb", + "CamFoibe", + "CamFpibe", + "CamFiobe", + "CamFipbe", + "CamFpobe", + "CamFopbe", + "CamFoe", + "CamFeo", + "CamFne", + "CamFie", + "CamFei", + "CamFpe", + "CamFep", + "CamFoie", + "CamFpie", + "CamFioe", + "CamFipe", + "CamFpoe", + "CamFope", + "CamFbe", + "CamF0en", + "CamFe0n", + "CamF0ne", + "CamFn0e", + "CamFne0", + "CamF0ien", + "CamFi0en", + "CamFp0en", + "CamF0pen", + "CamF0ine", + "CamFi0ne", + "CamFp0ne", + "CamF0pne", + "CamF0eb", + "CamFe0b", + "CamF0be", + "CamFb0e", + "CamFbe0", + "CamF0ieb", + "CamFi0eb", + "CamFp0eb", + "CamF0peb", + "CamF0ibe", + "CamFi0be", + "CamFp0be", + "CamF0pbe", + "CamF0e", + "CamFe0", + "CamF0ie", + "CamFi0e", + "CamFp0e", + "CamF0pe", + "CamF9en", + "CamFe9n", + "CamF9ne", + "CamFn9e", + "CamFne9", + "CamF9ien", + "CamFi9en", + "CamFp9en", + "CamF9pen", + "CamF9ine", + "CamFi9ne", + "CamFp9ne", + "CamF9pne", + "CamF9eb", + "CamFe9b", + "CamF9be", + "CamFb9e", + "CamFbe9", + "CamF9ieb", + "CamFi9eb", + "CamFp9eb", + "CamF9peb", + "CamF9ibe", + "CamFi9be", + "CamFp9be", + "CamF9pbe", + "CamF9e", + "CamFe9", + "CamF9ie", + "CamFi9e", + "CamFp9e", + "CamF9pe", + "Camdoem", + "Camdeom", + "Camdome", + "Camdmoe", + "Camdmeo", + "Camdeim", + "Camdime", + "Camdmie", + "Camdmei", + "Camdpem", + "Camdepm", + "Camdpme", + "Camdmpe", + "Camdmep", + "Camdoiem", + "Camdpiem", + "Camdipem", + "Camdpoem", + "Camdoime", + "Camdpime", + "Camdipme", + "Camdpome", + "Camdopme", + "CamSoem", + "CamSeom", + "CamSmoe", + "CamSmeo", + "CamSiem", + "CamSeim", + "CamSime", + "CamSmie", + "CamSmei", + "CamSpem", + "CamSepm", + "CamSpme", + "CamSmpe", + "CamSmep", + "CamSoiem", + "CamSpiem", + "CamSioem", + "CamSipem", + "CamSpoem", + "CamSopem", + "CamSoime", + "CamSiome", + "CamSipme", + "CamSpome", + "CamSopme", + "Camdme", + "CamSme", + "Camd0em", + "Camde0m", + "Camd0me", + "Camdm0e", + "Camdme0", + "Camd0iem", + "Camdi0em", + "Camdp0em", + "Camd0pem", + "Camd0ime", + "Camdi0me", + "Camdp0me", + "Camd0pme", + "CamS0em", + "CamSe0m", + "CamS0me", + "CamSm0e", + "CamSme0", + "CamS0iem", + "CamSi0em", + "CamSp0em", + "CamS0pem", + "CamS0ime", + "CamSi0me", + "CamSp0me", + "CamS0pme", + "Camd9em", + "Camde9m", + "Camd9me", + "Camdm9e", + "Camdme9", + "Camd9iem", + "Camdi9em", + "Camdp9em", + "Camd9pem", + "Camd9ime", + "Camdi9me", + "Camdp9me", + "Camd9pme", + "CamS9em", + "CamSe9m", + "CamS9me", + "CamSm9e", + "CamSme9", + "CamS9iem", + "CamSi9em", + "CamSp9em", + "CamS9pem", + "CamS9ime", + "CamSi9me", + "CamSp9me", + "CamS9pme", + "CamFoem", + "CamFeom", + "CamFome", + "CamFmoe", + "CamFmeo", + "CamFiem", + "CamFeim", + "CamFime", + "CamFmie", + "CamFmei", + "CamFpem", + "CamFepm", + "CamFpme", + "CamFmpe", + "CamFmep", + "CamFoiem", + "CamFpiem", + "CamFioem", + "CamFipem", + "CamFpoem", + "CamFopem", + "CamFoime", + "CamFpime", + "CamFiome", + "CamFipme", + "CamFpome", + "CamFopme", + "CamFme", + "CamF0em", + "CamFe0m", + "CamF0me", + "CamFm0e", + "CamFme0", + "CamF0iem", + "CamFi0em", + "CamFp0em", + "CamF0pem", + "CamF0ime", + "CamFi0me", + "CamFp0me", + "CamF0pme", + "CamF9em", + "CamFe9m", + "CamF9me", + "CamFm9e", + "CamFme9", + "CamF9iem", + "CamFi9em", + "CamFp9em", + "CamF9pem", + "CamF9ime", + "CamFi9me", + "CamFp9me", + "CamF9pme", + "CamBackward", + "CamBackwards", + "CamBack", + "CamBackwars", + "CamBackwarss", + "CamBackwar", + "CamBacxkward", + "CamBacxkwards", + "CamBacxk", + "CamBaxckward", + "CamBaxckwards", + "CamBaxck", + "CamBaxkward", + "CamBaxkwards", + "CamBaxk", + "CamBacxkwar", + "CamBacxkwars", + "CamBaxckwar", + "CamBaxckwars", + "CamBaxkwar", + "CamBaxkwars", + "CamBacxkwarss", + "CamBaxckwarss", + "CamBaxkwarss", + "CamBavckward", + "CamBavckwards", + "CamBavck", + "CamBavckwars", + "CamBavckwarss", + "CamBavckwar", + "CamBakcward", + "CamBakcwards", + "CamBakc", + "CamBakcwars", + "CamBakcwarss", + "CamBakcwar", + "CamBaccward", + "CamBaccwards", + "CamBacc", + "CamBaccwars", + "CamBaccwarss", + "CamBaccwar", + "CamBavkward", + "CamBavkwards", + "CamBavk", + "CamBavkwars", + "CamBavkwarss", + "CamBavkwar", + "CamBacvkward", + "CamBacvkwards", + "CamBacvk", + "CamBacvkwars", + "CamBacvkwarss", + "CamBacvkwar", + "CamBackword", + "CamBackwords", + "CamBackwors", + "CamBackworss", + "CamBackwor", + "CamBacxkword", + "CamBacxkwords", + "CamBaxckword", + "CamBaxckwords", + "CamBaxkword", + "CamBaxkwords", + "CamBacxkwor", + "CamBacxkwors", + "CamBaxckwor", + "CamBaxckwors", + "CamBaxkwor", + "CamBaxkwors", + "CamBacxkworss", + "CamBaxckworss", + "CamBaxkworss", + "CamBavckword", + "CamBavckwords", + "CamBavckwors", + "CamBavckworss", + "CamBavckwor", + "CamBakcword", + "CamBakcwords", + "CamBakcwors", + "CamBakcworss", + "CamBakcwor", + "CamBaccword", + "CamBaccwords", + "CamBaccwors", + "CamBaccworss", + "CamBaccwor", + "CamBavkword", + "CamBavkwords", + "CamBavkwors", + "CamBavkworss", + "CamBavkwor", + "CamBacvkword", + "CamBacvkwords", + "CamBacvkwors", + "CamBacvkworss", + "CamBacvkwor", + "CamBacvkwors", + "DownnC", + "DownnCamera", + "C-Downn", + "Camera-Downn", + "CDownn", + "CameraDownn", + "CFpwn", + "CFpwb", + "CFpw", + "CameraFpwn", + "CameraFpwb", + "CameraFpw", + "CFpwm", + "CameraFpwm", + "DownC", + "DownCamera", + "CAckwrd", + "CAckwrds", + "CameraAckwrd", + "CameraAckwrds", + "CAckwrs", + "CAckwrss", + "CameraAckwrs", + "CameraAckwrss", + "CAckwr", + "CameraAckwr", + "CAckward", + "CAckwards", + "CAck", + "CameraAckward", + "CameraAckwards", + "CameraAck", + "CAckwars", + "CAckwarss", + "CameraAckwars", + "CameraAckwarss", + "CAckwar", + "CameraAckwar", + "CAckword", + "CAckwords", + "CameraAckword", + "CameraAckwords", + "CAckwors", + "CAckworss", + "CameraAckwors", + "CameraAckworss", + "CAckwor", + "CameraAckwor", + "CBabkwrd", + "CBabkwrds", + "CameraBabkwrd", + "CameraBabkwrds", + "CBabkwrs", + "CBabkwrss", + "CameraBabkwrs", + "CameraBabkwrss", + "CBabkwr", + "CameraBabkwr", + "CBabkward", + "CBabkwards", + "CBabk", + "CameraBabkward", + "CameraBabkwards", + "CameraBabk", + "CBabkwars", + "CBabkwarss", + "CameraBabkwars", + "CameraBabkwarss", + "CBabkwar", + "CameraBabkwar", + "CBabkword", + "CBabkwords", + "CameraBabkword", + "CameraBabkwords", + "CBabkwors", + "CBabkworss", + "CameraBabkwors", + "CameraBabkworss", + "CBabkwor", + "CameraBabkwor", + "C-Xown", + "Camera-Xown", + "CXown", + "CameraXown", + "C-Doown", + "Camera-Doown", + "CDoown", + "CameraDoown", + "C-dowwn", + "Camera-dowwn", + "Cdowwn", + "Cdonww", + "Cameradowwn", + "Cameradonww", + "CSputh", + "CameraSputh", + "CSout", + "CameraSout", + "CSput", + "CameraSput", + "CBackwrd", + "CBackwrds", + "CameraBackwrd", + "CameraBackwrds", + "CBackwrs", + "CBackwrss", + "CameraBackwrs", + "CameraBackwrss", + "CBackwr", + "CameraBackwr", + "CBacxkwrd", + "CBacxkwrds", + "CameraBacxkwrd", + "CameraBacxkwrds", + "CBaxckwrd", + "CBaxckwrds", + "CameraBaxckwrd", + "CameraBaxckwrds", + "CBaxkwrd", + "CBaxkwrds", + "CameraBaxkwrd", + "CameraBaxkwrds", + "CBacxkwr", + "CBacxkwrs", + "CameraBacxkwr", + "CameraBacxkwrs", + "CBaxckwr", + "CBaxckwrs", + "CameraBaxckwr", + "CameraBaxckwrs", + "CBaxkwr", + "CBaxkwrs", + "CameraBaxkwr", + "CameraBaxkwrs", + "CBacxkwrss", + "CameraBacxkwrss", + "CBaxckwrss", + "CameraBaxckwrss", + "CBaxkwrss", + "CameraBaxkwrss", + "CBavckwrd", + "CBavckwrds", + "CameraBavckwrd", + "CameraBavckwrds", + "CBavckwrs", + "CBavckwrss", + "CameraBavckwrs", + "CameraBavckwrss", + "CBavckwr", + "CameraBavckwr", + "CBakcwrd", + "CBakcwrds", + "CameraBakcwrd", + "CameraBakcwrds", + "CBakcwrs", + "CBakcwrss", + "CameraBakcwrs", + "CameraBakcwrss", + "CBakcwr", + "CameraBakcwr", + "CBaccwrd", + "CBaccwrds", + "CameraBaccwrd", + "CameraBaccwrds", + "CBaccwrs", + "CBaccwrss", + "CameraBaccwrs", + "CameraBaccwrss", + "CBaccwr", + "CameraBaccwr", + "CBavkwrd", + "CBavkwrds", + "CameraBavkwrd", + "CameraBavkwrds", + "CBavkwrs", + "CBavkwrss", + "CameraBavkwrs", + "CameraBavkwrss", + "CBavkwr", + "CameraBavkwr", + "CBacvkwrd", + "CBacvkwrds", + "CameraBacvkwrd", + "CameraBacvkwrds", + "CBacvkwrs", + "CBacvkwrss", + "CameraBacvkwrs", + "CameraBacvkwrss", + "CBacvkwr", + "CameraBacvkwr", + "C-Doqn", + "Camera-Doqn", + "CDoqn", + "CameraDoqn", + "C-down", + "Camera-down", + "CReverse", + "CameraReverse", + "Cdown", + "Cdwon", + "Cdonw", + "Cdnow", + "Cdnwo", + "CD", + "Cv", + "C↓", + "CSouth", + "CS", + "C▼", + "Cdiwn", + "Cdwin", + "Cdinw", + "Cdniw", + "Cdnwi", + "Cdpwn", + "Cdwpn", + "Cdpnw", + "Cdnpw", + "Cdnwp", + "Cdon", + "Cdin", + "Cdpn", + "Cdoiwn", + "Cdpiwn", + "Cdipwn", + "Cdpown", + "Cdopwn", + "Cdoinw", + "Cdpinw", + "Cdipnw", + "Cdponw", + "Cdopnw", + "Cdowb", + "Cdwob", + "Cdobw", + "Cdbow", + "Cdbwo", + "Cdiwb", + "Cdwib", + "Cdibw", + "Cdbiw", + "Cdbwi", + "Cdpwb", + "Cdwpb", + "Cdpbw", + "Cdbpw", + "Cdbwp", + "Cdob", + "Cdib", + "Cdpb", + "Cdoiwb", + "Cdpiwb", + "Cdipwb", + "Cdpowb", + "Cdopwb", + "Cdoibw", + "Cdpibw", + "Cdipbw", + "Cdpobw", + "Cdopbw", + "CSown", + "CSwon", + "CSonw", + "CSnow", + "CSnwo", + "CSiwn", + "CSinw", + "CSniw", + "CSnwi", + "CSpwn", + "CSwpn", + "CSpnw", + "CSnpw", + "CSnwp", + "CSpn", + "CSoiwn", + "CSpiwn", + "CSiown", + "CSipwn", + "CSpown", + "CSopwn", + "CSoinw", + "CSionw", + "CSipnw", + "CSponw", + "CSopnw", + "CSowb", + "CSwob", + "CSobw", + "CSbow", + "CSbwo", + "CSiwb", + "CSwib", + "CSibw", + "CSbiw", + "CSbwi", + "CSpwb", + "CSwpb", + "CSpbw", + "CSbpw", + "CSbwp", + "CSob", + "CSib", + "CSpb", + "CSoiwb", + "CSpiwb", + "CSiowb", + "CSipwb", + "CSpowb", + "CSopwb", + "CSoibw", + "CSpibw", + "CSiobw", + "CSipbw", + "CSpobw", + "CSopbw", + "Cdow", + "Cdwo", + "Cdno", + "Cdnw", + "Cdiw", + "Cdwi", + "Cdni", + "Cdpw", + "Cdwp", + "Cdnp", + "Cdoiw", + "Cdpiw", + "Cdipw", + "Cdpow", + "Cdopw", + "Cdoin", + "Cdpin", + "Cdipn", + "Cdpon", + "Cdopn", + "Cdbo", + "Cdbw", + "Cdbi", + "Cdbp", + "Cdoib", + "Cdpib", + "Cdipb", + "Cdpob", + "Cdopb", + "CSow", + "CSwo", + "CSno", + "CSnw", + "CSiw", + "CSwi", + "CSni", + "CSpw", + "CSwp", + "CSnp", + "CSoiw", + "CSpiw", + "CSiow", + "CSipw", + "CSpow", + "CSopw", + "CSoin", + "CSion", + "CSipn", + "CSpon", + "CSopn", + "CSbo", + "CSbw", + "CSbi", + "CSbp", + "CSoib", + "CSpib", + "CSiob", + "CSipb", + "CSpob", + "CSopb", + "Cd0wn", + "Cdw0n", + "Cd0nw", + "Cdn0w", + "Cdnw0", + "CS0uth", + "Cd0n", + "Cd0iwn", + "Cdi0wn", + "Cdp0wn", + "Cd0pwn", + "Cd0inw", + "Cdi0nw", + "Cdp0nw", + "Cd0pnw", + "Cd0wb", + "Cdw0b", + "Cd0bw", + "Cdb0w", + "Cdbw0", + "Cd0b", + "Cd0iwb", + "Cdi0wb", + "Cdp0wb", + "Cd0pwb", + "Cd0ibw", + "Cdi0bw", + "Cdp0bw", + "Cd0pbw", + "CS0wn", + "CSw0n", + "CS0nw", + "CSn0w", + "CSnw0", + "CS0n", + "CS0iwn", + "CSi0wn", + "CSp0wn", + "CS0pwn", + "CS0inw", + "CSi0nw", + "CSp0nw", + "CS0pnw", + "CS0wb", + "CSw0b", + "CS0bw", + "CSb0w", + "CSbw0", + "CS0b", + "CS0iwb", + "CSi0wb", + "CSp0wb", + "CS0pwb", + "CS0ibw", + "CSi0bw", + "CSp0bw", + "CS0pbw", + "Cd0w", + "Cdw0", + "Cdn0", + "Cd0iw", + "Cdi0w", + "Cdp0w", + "Cd0pw", + "Cd0in", + "Cdi0n", + "Cdp0n", + "Cd0pn", + "Cdb0", + "Cd0ib", + "Cdi0b", + "Cdp0b", + "Cd0pb", + "CS0w", + "CSw0", + "CSn0", + "CS0iw", + "CSi0w", + "CSp0w", + "CS0pw", + "CS0in", + "CSi0n", + "CSp0n", + "CS0pn", + "CSb0", + "CS0ib", + "CSi0b", + "CSp0b", + "CS0pb", + "Cd9wn", + "Cdw9n", + "Cd9nw", + "Cdn9w", + "Cdnw9", + "CS9uth", + "Cd9n", + "Cd9iwn", + "Cdi9wn", + "Cdp9wn", + "Cd9pwn", + "Cd9inw", + "Cdi9nw", + "Cdp9nw", + "Cd9pnw", + "Cd9wb", + "Cdw9b", + "Cd9bw", + "Cdb9w", + "Cdbw9", + "Cd9b", + "Cd9iwb", + "Cdi9wb", + "Cdp9wb", + "Cd9pwb", + "Cd9ibw", + "Cdi9bw", + "Cdp9bw", + "Cd9pbw", + "CS9wn", + "CSw9n", + "CS9nw", + "CSn9w", + "CSnw9", + "CS9n", + "CS9iwn", + "CSi9wn", + "CSp9wn", + "CS9pwn", + "CS9inw", + "CSi9nw", + "CSp9nw", + "CS9pnw", + "CS9wb", + "CSw9b", + "CS9bw", + "CSb9w", + "CSbw9", + "CS9b", + "CS9iwb", + "CSi9wb", + "CSp9wb", + "CS9pwb", + "CS9ibw", + "CSi9bw", + "CSp9bw", + "CS9pbw", + "Cd9w", + "Cdw9", + "Cdn9", + "Cd9iw", + "Cdi9w", + "Cdp9w", + "Cd9pw", + "Cd9in", + "Cdi9n", + "Cdp9n", + "Cd9pn", + "Cdb9", + "Cd9ib", + "Cdi9b", + "Cdp9b", + "Cd9pb", + "CS9w", + "CSw9", + "CSn9", + "CS9iw", + "CSi9w", + "CSp9w", + "CS9pw", + "CS9in", + "CSi9n", + "CSp9n", + "CS9pn", + "CSb9", + "CS9ib", + "CSi9b", + "CSp9b", + "CS9pb", + "CFown", + "CFwon", + "CFonw", + "CFnow", + "CFnwo", + "CF", + "CFiwn", + "CFwin", + "CFinw", + "CFniw", + "CFnwi", + "CFwpn", + "CFpnw", + "CFnpw", + "CFnwp", + "CFon", + "CFin", + "CFpn", + "CFoiwn", + "CFpiwn", + "CFiown", + "CFipwn", + "CFpown", + "CFopwn", + "CFoinw", + "CFpinw", + "CFionw", + "CFipnw", + "CFponw", + "CFopnw", + "CFowb", + "CFwob", + "CFobw", + "CFbow", + "CFbwo", + "CFiwb", + "CFwib", + "CFibw", + "CFbiw", + "CFbwi", + "CFwpb", + "CFpbw", + "CFbpw", + "CFbwp", + "CFob", + "CFib", + "CFpb", + "CFoiwb", + "CFpiwb", + "CFiowb", + "CFipwb", + "CFpowb", + "CFopwb", + "CFoibw", + "CFpibw", + "CFiobw", + "CFipbw", + "CFpobw", + "CFopbw", + "CFow", + "CFwo", + "CFno", + "CFnw", + "CFiw", + "CFwi", + "CFni", + "CFwp", + "CFnp", + "CFoiw", + "CFpiw", + "CFiow", + "CFipw", + "CFpow", + "CFopw", + "CFoin", + "CFpin", + "CFion", + "CFipn", + "CFpon", + "CFopn", + "CFbo", + "CFbw", + "CFbi", + "CFbp", + "CFoib", + "CFpib", + "CFiob", + "CFipb", + "CFpob", + "CFopb", + "CF0wn", + "CFw0n", + "CF0nw", + "CFn0w", + "CFnw0", + "CF0n", + "CF0iwn", + "CFi0wn", + "CFp0wn", + "CF0pwn", + "CF0inw", + "CFi0nw", + "CFp0nw", + "CF0pnw", + "CF0wb", + "CFw0b", + "CF0bw", + "CFb0w", + "CFbw0", + "CF0b", + "CF0iwb", + "CFi0wb", + "CFp0wb", + "CF0pwb", + "CF0ibw", + "CFi0bw", + "CFp0bw", + "CF0pbw", + "CF0w", + "CFw0", + "CFn0", + "CF0iw", + "CFi0w", + "CFp0w", + "CF0pw", + "CF0in", + "CFi0n", + "CFp0n", + "CF0pn", + "CFb0", + "CF0ib", + "CFi0b", + "CFp0b", + "CF0pb", + "CF9wn", + "CFw9n", + "CF9nw", + "CFn9w", + "CFnw9", + "CF9n", + "CF9iwn", + "CFi9wn", + "CFp9wn", + "CF9pwn", + "CF9inw", + "CFi9nw", + "CFp9nw", + "CF9pnw", + "CF9wb", + "CFw9b", + "CF9bw", + "CFb9w", + "CFbw9", + "CF9b", + "CF9iwb", + "CFi9wb", + "CFp9wb", + "CF9pwb", + "CF9ibw", + "CFi9bw", + "CFp9bw", + "CF9pbw", + "CF9w", + "CFw9", + "CFn9", + "CF9iw", + "CFi9w", + "CFp9w", + "CF9pw", + "CF9in", + "CFi9n", + "CFp9n", + "CF9pn", + "CFb9", + "CF9ib", + "CFi9b", + "CFp9b", + "CF9pb", + "Cameradown", + "Cameradwon", + "Cameradonw", + "Cameradnow", + "Cameradnwo", + "CameraD", + "Camerav", + "Camera↓", + "CameraSouth", + "CameraS", + "Camera▼", + "Cameradiwn", + "Cameradwin", + "Cameradinw", + "Cameradniw", + "Cameradnwi", + "Cameradpwn", + "Cameradwpn", + "Cameradpnw", + "Cameradnpw", + "Cameradnwp", + "Cameradon", + "Cameradin", + "Cameradpn", + "Cameradoiwn", + "Cameradpiwn", + "Cameradipwn", + "Cameradpown", + "Cameradopwn", + "Cameradoinw", + "Cameradpinw", + "Cameradipnw", + "Cameradponw", + "Cameradopnw", + "Cameradowb", + "Cameradwob", + "Cameradobw", + "Cameradbow", + "Cameradbwo", + "Cameradiwb", + "Cameradwib", + "Cameradibw", + "Cameradbiw", + "Cameradbwi", + "Cameradpwb", + "Cameradwpb", + "Cameradpbw", + "Cameradbpw", + "Cameradbwp", + "Cameradob", + "Cameradib", + "Cameradpb", + "Cameradoiwb", + "Cameradpiwb", + "Cameradipwb", + "Cameradpowb", + "Cameradopwb", + "Cameradoibw", + "Cameradpibw", + "Cameradipbw", + "Cameradpobw", + "Cameradopbw", + "CameraSown", + "CameraSwon", + "CameraSonw", + "CameraSnow", + "CameraSnwo", + "CameraSiwn", + "CameraSinw", + "CameraSniw", + "CameraSnwi", + "CameraSpwn", + "CameraSwpn", + "CameraSpnw", + "CameraSnpw", + "CameraSnwp", + "CameraSpn", + "CameraSoiwn", + "CameraSpiwn", + "CameraSiown", + "CameraSipwn", + "CameraSpown", + "CameraSopwn", + "CameraSoinw", + "CameraSionw", + "CameraSipnw", + "CameraSponw", + "CameraSopnw", + "CameraSowb", + "CameraSwob", + "CameraSobw", + "CameraSbow", + "CameraSbwo", + "CameraSiwb", + "CameraSwib", + "CameraSibw", + "CameraSbiw", + "CameraSbwi", + "CameraSpwb", + "CameraSwpb", + "CameraSpbw", + "CameraSbpw", + "CameraSbwp", + "CameraSob", + "CameraSib", + "CameraSpb", + "CameraSoiwb", + "CameraSpiwb", + "CameraSiowb", + "CameraSipwb", + "CameraSpowb", + "CameraSopwb", + "CameraSoibw", + "CameraSpibw", + "CameraSiobw", + "CameraSipbw", + "CameraSpobw", + "CameraSopbw", + "Cameradow", + "Cameradwo", + "Cameradno", + "Cameradnw", + "Cameradiw", + "Cameradwi", + "Cameradni", + "Cameradpw", + "Cameradwp", + "Cameradnp", + "Cameradoiw", + "Cameradpiw", + "Cameradipw", + "Cameradpow", + "Cameradopw", + "Cameradoin", + "Cameradpin", + "Cameradipn", + "Cameradpon", + "Cameradopn", + "Cameradbo", + "Cameradbw", + "Cameradbi", + "Cameradbp", + "Cameradoib", + "Cameradpib", + "Cameradipb", + "Cameradpob", + "Cameradopb", + "CameraSow", + "CameraSwo", + "CameraSno", + "CameraSnw", + "CameraSiw", + "CameraSwi", + "CameraSni", + "CameraSpw", + "CameraSwp", + "CameraSnp", + "CameraSoiw", + "CameraSpiw", + "CameraSiow", + "CameraSipw", + "CameraSpow", + "CameraSopw", + "CameraSoin", + "CameraSion", + "CameraSipn", + "CameraSpon", + "CameraSopn", + "CameraSbo", + "CameraSbw", + "CameraSbi", + "CameraSbp", + "CameraSoib", + "CameraSpib", + "CameraSiob", + "CameraSipb", + "CameraSpob", + "CameraSopb", + "Camerad0wn", + "Cameradw0n", + "Camerad0nw", + "Cameradn0w", + "Cameradnw0", + "CameraS0uth", + "Camerad0n", + "Camerad0iwn", + "Cameradi0wn", + "Cameradp0wn", + "Camerad0pwn", + "Camerad0inw", + "Cameradi0nw", + "Cameradp0nw", + "Camerad0pnw", + "Camerad0wb", + "Cameradw0b", + "Camerad0bw", + "Cameradb0w", + "Cameradbw0", + "Camerad0b", + "Camerad0iwb", + "Cameradi0wb", + "Cameradp0wb", + "Camerad0pwb", + "Camerad0ibw", + "Cameradi0bw", + "Cameradp0bw", + "Camerad0pbw", + "CameraS0wn", + "CameraSw0n", + "CameraS0nw", + "CameraSn0w", + "CameraSnw0", + "CameraS0n", + "CameraS0iwn", + "CameraSi0wn", + "CameraSp0wn", + "CameraS0pwn", + "CameraS0inw", + "CameraSi0nw", + "CameraSp0nw", + "CameraS0pnw", + "CameraS0wb", + "CameraSw0b", + "CameraS0bw", + "CameraSb0w", + "CameraSbw0", + "CameraS0b", + "CameraS0iwb", + "CameraSi0wb", + "CameraSp0wb", + "CameraS0pwb", + "CameraS0ibw", + "CameraSi0bw", + "CameraSp0bw", + "CameraS0pbw", + "Camerad0w", + "Cameradw0", + "Cameradn0", + "Camerad0iw", + "Cameradi0w", + "Cameradp0w", + "Camerad0pw", + "Camerad0in", + "Cameradi0n", + "Cameradp0n", + "Camerad0pn", + "Cameradb0", + "Camerad0ib", + "Cameradi0b", + "Cameradp0b", + "Camerad0pb", + "CameraS0w", + "CameraSw0", + "CameraSn0", + "CameraS0iw", + "CameraSi0w", + "CameraSp0w", + "CameraS0pw", + "CameraS0in", + "CameraSi0n", + "CameraSp0n", + "CameraS0pn", + "CameraSb0", + "CameraS0ib", + "CameraSi0b", + "CameraSp0b", + "CameraS0pb", + "Camerad9wn", + "Cameradw9n", + "Camerad9nw", + "Cameradn9w", + "Cameradnw9", + "CameraS9uth", + "Camerad9n", + "Camerad9iwn", + "Cameradi9wn", + "Cameradp9wn", + "Camerad9pwn", + "Camerad9inw", + "Cameradi9nw", + "Cameradp9nw", + "Camerad9pnw", + "Camerad9wb", + "Cameradw9b", + "Camerad9bw", + "Cameradb9w", + "Cameradbw9", + "Camerad9b", + "Camerad9iwb", + "Cameradi9wb", + "Cameradp9wb", + "Camerad9pwb", + "Camerad9ibw", + "Cameradi9bw", + "Cameradp9bw", + "Camerad9pbw", + "CameraS9wn", + "CameraSw9n", + "CameraS9nw", + "CameraSn9w", + "CameraSnw9", + "CameraS9n", + "CameraS9iwn", + "CameraSi9wn", + "CameraSp9wn", + "CameraS9pwn", + "CameraS9inw", + "CameraSi9nw", + "CameraSp9nw", + "CameraS9pnw", + "CameraS9wb", + "CameraSw9b", + "CameraS9bw", + "CameraSb9w", + "CameraSbw9", + "CameraS9b", + "CameraS9iwb", + "CameraSi9wb", + "CameraSp9wb", + "CameraS9pwb", + "CameraS9ibw", + "CameraSi9bw", + "CameraSp9bw", + "CameraS9pbw", + "Camerad9w", + "Cameradw9", + "Cameradn9", + "Camerad9iw", + "Cameradi9w", + "Cameradp9w", + "Camerad9pw", + "Camerad9in", + "Cameradi9n", + "Cameradp9n", + "Camerad9pn", + "Cameradb9", + "Camerad9ib", + "Cameradi9b", + "Cameradp9b", + "Camerad9pb", + "CameraS9w", + "CameraSw9", + "CameraSn9", + "CameraS9iw", + "CameraSi9w", + "CameraSp9w", + "CameraS9pw", + "CameraS9in", + "CameraSi9n", + "CameraSp9n", + "CameraS9pn", + "CameraSb9", + "CameraS9ib", + "CameraSi9b", + "CameraSp9b", + "CameraS9pb", + "CameraFown", + "CameraFwon", + "CameraFonw", + "CameraFnow", + "CameraFnwo", + "CameraF", + "CameraFiwn", + "CameraFwin", + "CameraFinw", + "CameraFniw", + "CameraFnwi", + "CameraFwpn", + "CameraFpnw", + "CameraFnpw", + "CameraFnwp", + "CameraFon", + "CameraFin", + "CameraFpn", + "CameraFoiwn", + "CameraFpiwn", + "CameraFiown", + "CameraFipwn", + "CameraFpown", + "CameraFopwn", + "CameraFoinw", + "CameraFpinw", + "CameraFionw", + "CameraFipnw", + "CameraFponw", + "CameraFopnw", + "CameraFowb", + "CameraFwob", + "CameraFobw", + "CameraFbow", + "CameraFbwo", + "CameraFiwb", + "CameraFwib", + "CameraFibw", + "CameraFbiw", + "CameraFbwi", + "CameraFwpb", + "CameraFpbw", + "CameraFbpw", + "CameraFbwp", + "CameraFob", + "CameraFib", + "CameraFpb", + "CameraFoiwb", + "CameraFpiwb", + "CameraFiowb", + "CameraFipwb", + "CameraFpowb", + "CameraFopwb", + "CameraFoibw", + "CameraFpibw", + "CameraFiobw", + "CameraFipbw", + "CameraFpobw", + "CameraFopbw", + "CameraFow", + "CameraFwo", + "CameraFno", + "CameraFnw", + "CameraFiw", + "CameraFwi", + "CameraFni", + "CameraFwp", + "CameraFnp", + "CameraFoiw", + "CameraFpiw", + "CameraFiow", + "CameraFipw", + "CameraFpow", + "CameraFopw", + "CameraFoin", + "CameraFpin", + "CameraFion", + "CameraFipn", + "CameraFpon", + "CameraFopn", + "CameraFbo", + "CameraFbw", + "CameraFbi", + "CameraFbp", + "CameraFoib", + "CameraFpib", + "CameraFiob", + "CameraFipb", + "CameraFpob", + "CameraFopb", + "CameraF0wn", + "CameraFw0n", + "CameraF0nw", + "CameraFn0w", + "CameraFnw0", + "CameraF0n", + "CameraF0iwn", + "CameraFi0wn", + "CameraFp0wn", + "CameraF0pwn", + "CameraF0inw", + "CameraFi0nw", + "CameraFp0nw", + "CameraF0pnw", + "CameraF0wb", + "CameraFw0b", + "CameraF0bw", + "CameraFb0w", + "CameraFbw0", + "CameraF0b", + "CameraF0iwb", + "CameraFi0wb", + "CameraFp0wb", + "CameraF0pwb", + "CameraF0ibw", + "CameraFi0bw", + "CameraFp0bw", + "CameraF0pbw", + "CameraF0w", + "CameraFw0", + "CameraFn0", + "CameraF0iw", + "CameraFi0w", + "CameraFp0w", + "CameraF0pw", + "CameraF0in", + "CameraFi0n", + "CameraFp0n", + "CameraF0pn", + "CameraFb0", + "CameraF0ib", + "CameraFi0b", + "CameraFp0b", + "CameraF0pb", + "CameraF9wn", + "CameraFw9n", + "CameraF9nw", + "CameraFn9w", + "CameraFnw9", + "CameraF9n", + "CameraF9iwn", + "CameraFi9wn", + "CameraFp9wn", + "CameraF9pwn", + "CameraF9inw", + "CameraFi9nw", + "CameraFp9nw", + "CameraF9pnw", + "CameraF9wb", + "CameraFw9b", + "CameraF9bw", + "CameraFb9w", + "CameraFbw9", + "CameraF9b", + "CameraF9iwb", + "CameraFi9wb", + "CameraFp9wb", + "CameraF9pwb", + "CameraF9ibw", + "CameraFi9bw", + "CameraFp9bw", + "CameraF9pbw", + "CameraF9w", + "CameraFw9", + "CameraFn9", + "CameraF9iw", + "CameraFi9w", + "CameraFp9w", + "CameraF9pw", + "CameraF9in", + "CameraFi9n", + "CameraFp9n", + "CameraF9pn", + "CameraFb9", + "CameraF9ib", + "CameraFi9b", + "CameraFp9b", + "CameraF9pb", + "Cdowm", + "Cdwom", + "Cdomw", + "Cdmow", + "Cdmwo", + "Cdiwm", + "Cdwim", + "Cdimw", + "Cdmiw", + "Cdmwi", + "Cdpwm", + "Cdwpm", + "Cdpmw", + "Cdmpw", + "Cdmwp", + "Cdom", + "Cdim", + "Cdpm", + "Cdoiwm", + "Cdpiwm", + "Cdipwm", + "Cdpowm", + "Cdopwm", + "Cdoimw", + "Cdpimw", + "Cdipmw", + "Cdpomw", + "Cdopmw", + "CSowm", + "CSwom", + "CSomw", + "CSmow", + "CSmwo", + "CSiwm", + "CSimw", + "CSmiw", + "CSmwi", + "CSpwm", + "CSwpm", + "CSpmw", + "CSmpw", + "CSmwp", + "CSom", + "CSim", + "CSpm", + "CSoiwm", + "CSpiwm", + "CSiowm", + "CSipwm", + "CSpowm", + "CSopwm", + "CSoimw", + "CSiomw", + "CSipmw", + "CSpomw", + "CSopmw", + "Cdmo", + "Cdmw", + "Cdmi", + "Cdmp", + "Cdoim", + "Cdpim", + "Cdipm", + "Cdpom", + "Cdopm", + "CSmo", + "CSmw", + "CSmi", + "CSmp", + "CSoim", + "CSiom", + "CSipm", + "CSpom", + "CSopm", + "Cd0wm", + "Cdw0m", + "Cd0mw", + "Cdm0w", + "Cdmw0", + "Cd0m", + "Cd0iwm", + "Cdi0wm", + "Cdp0wm", + "Cd0pwm", + "Cd0imw", + "Cdi0mw", + "Cdp0mw", + "Cd0pmw", + "CS0wm", + "CSw0m", + "CS0mw", + "CSm0w", + "CSmw0", + "CS0m", + "CS0iwm", + "CSi0wm", + "CSp0wm", + "CS0pwm", + "CS0imw", + "CSi0mw", + "CSp0mw", + "CS0pmw", + "Cdm0", + "Cd0im", + "Cdi0m", + "Cdp0m", + "Cd0pm", + "CSm0", + "CS0im", + "CSi0m", + "CSp0m", + "CS0pm", + "Cd9wm", + "Cdw9m", + "Cd9mw", + "Cdm9w", + "Cdmw9", + "Cd9m", + "Cd9iwm", + "Cdi9wm", + "Cdp9wm", + "Cd9pwm", + "Cd9imw", + "Cdi9mw", + "Cdp9mw", + "Cd9pmw", + "CS9wm", + "CSw9m", + "CS9mw", + "CSm9w", + "CSmw9", + "CS9m", + "CS9iwm", + "CSi9wm", + "CSp9wm", + "CS9pwm", + "CS9imw", + "CSi9mw", + "CSp9mw", + "CS9pmw", + "Cdm9", + "Cd9im", + "Cdi9m", + "Cdp9m", + "Cd9pm", + "CSm9", + "CS9im", + "CSi9m", + "CSp9m", + "CS9pm", + "CFowm", + "CFwom", + "CFomw", + "CFmow", + "CFmwo", + "CFiwm", + "CFwim", + "CFimw", + "CFmiw", + "CFmwi", + "CFwpm", + "CFpmw", + "CFmpw", + "CFmwp", + "CFom", + "CFim", + "CFpm", + "CFoiwm", + "CFpiwm", + "CFiowm", + "CFipwm", + "CFpowm", + "CFopwm", + "CFoimw", + "CFpimw", + "CFiomw", + "CFipmw", + "CFpomw", + "CFopmw", + "CFmo", + "CFmw", + "CFmi", + "CFmp", + "CFoim", + "CFpim", + "CFiom", + "CFipm", + "CFpom", + "CFopm", + "CF0wm", + "CFw0m", + "CF0mw", + "CFm0w", + "CFmw0", + "CF0m", + "CF0iwm", + "CFi0wm", + "CFp0wm", + "CF0pwm", + "CF0imw", + "CFi0mw", + "CFp0mw", + "CF0pmw", + "CFm0", + "CF0im", + "CFi0m", + "CFp0m", + "CF0pm", + "CF9wm", + "CFw9m", + "CF9mw", + "CFm9w", + "CFmw9", + "CF9m", + "CF9iwm", + "CFi9wm", + "CFp9wm", + "CF9pwm", + "CF9imw", + "CFi9mw", + "CFp9mw", + "CF9pmw", + "CFm9", + "CF9im", + "CFi9m", + "CFp9m", + "CF9pm", + "Cameradowm", + "Cameradwom", + "Cameradomw", + "Cameradmow", + "Cameradmwo", + "Cameradiwm", + "Cameradwim", + "Cameradimw", + "Cameradmiw", + "Cameradmwi", + "Cameradpwm", + "Cameradwpm", + "Cameradpmw", + "Cameradmpw", + "Cameradmwp", + "Cameradom", + "Cameradim", + "Cameradpm", + "Cameradoiwm", + "Cameradpiwm", + "Cameradipwm", + "Cameradpowm", + "Cameradopwm", + "Cameradoimw", + "Cameradpimw", + "Cameradipmw", + "Cameradpomw", + "Cameradopmw", + "CameraSowm", + "CameraSwom", + "CameraSomw", + "CameraSmow", + "CameraSmwo", + "CameraSiwm", + "CameraSimw", + "CameraSmiw", + "CameraSmwi", + "CameraSpwm", + "CameraSwpm", + "CameraSpmw", + "CameraSmpw", + "CameraSmwp", + "CameraSom", + "CameraSim", + "CameraSpm", + "CameraSoiwm", + "CameraSpiwm", + "CameraSiowm", + "CameraSipwm", + "CameraSpowm", + "CameraSopwm", + "CameraSoimw", + "CameraSiomw", + "CameraSipmw", + "CameraSpomw", + "CameraSopmw", + "Cameradmo", + "Cameradmw", + "Cameradmi", + "Cameradmp", + "Cameradoim", + "Cameradpim", + "Cameradipm", + "Cameradpom", + "Cameradopm", + "CameraSmo", + "CameraSmw", + "CameraSmi", + "CameraSmp", + "CameraSoim", + "CameraSiom", + "CameraSipm", + "CameraSpom", + "CameraSopm", + "Camerad0wm", + "Cameradw0m", + "Camerad0mw", + "Cameradm0w", + "Cameradmw0", + "Camerad0m", + "Camerad0iwm", + "Cameradi0wm", + "Cameradp0wm", + "Camerad0pwm", + "Camerad0imw", + "Cameradi0mw", + "Cameradp0mw", + "Camerad0pmw", + "CameraS0wm", + "CameraSw0m", + "CameraS0mw", + "CameraSm0w", + "CameraSmw0", + "CameraS0m", + "CameraS0iwm", + "CameraSi0wm", + "CameraSp0wm", + "CameraS0pwm", + "CameraS0imw", + "CameraSi0mw", + "CameraSp0mw", + "CameraS0pmw", + "Cameradm0", + "Camerad0im", + "Cameradi0m", + "Cameradp0m", + "Camerad0pm", + "CameraSm0", + "CameraS0im", + "CameraSi0m", + "CameraSp0m", + "CameraS0pm", + "Camerad9wm", + "Cameradw9m", + "Camerad9mw", + "Cameradm9w", + "Cameradmw9", + "Camerad9m", + "Camerad9iwm", + "Cameradi9wm", + "Cameradp9wm", + "Camerad9pwm", + "Camerad9imw", + "Cameradi9mw", + "Cameradp9mw", + "Camerad9pmw", + "CameraS9wm", + "CameraSw9m", + "CameraS9mw", + "CameraSm9w", + "CameraSmw9", + "CameraS9m", + "CameraS9iwm", + "CameraSi9wm", + "CameraSp9wm", + "CameraS9pwm", + "CameraS9imw", + "CameraSi9mw", + "CameraSp9mw", + "CameraS9pmw", + "Cameradm9", + "Camerad9im", + "Cameradi9m", + "Cameradp9m", + "Camerad9pm", + "CameraSm9", + "CameraS9im", + "CameraSi9m", + "CameraSp9m", + "CameraS9pm", + "CameraFowm", + "CameraFwom", + "CameraFomw", + "CameraFmow", + "CameraFmwo", + "CameraFiwm", + "CameraFwim", + "CameraFimw", + "CameraFmiw", + "CameraFmwi", + "CameraFwpm", + "CameraFpmw", + "CameraFmpw", + "CameraFmwp", + "CameraFom", + "CameraFim", + "CameraFpm", + "CameraFoiwm", + "CameraFpiwm", + "CameraFiowm", + "CameraFipwm", + "CameraFpowm", + "CameraFopwm", + "CameraFoimw", + "CameraFpimw", + "CameraFiomw", + "CameraFipmw", + "CameraFpomw", + "CameraFopmw", + "CameraFmo", + "CameraFmw", + "CameraFmi", + "CameraFmp", + "CameraFoim", + "CameraFpim", + "CameraFiom", + "CameraFipm", + "CameraFpom", + "CameraFopm", + "CameraF0wm", + "CameraFw0m", + "CameraF0mw", + "CameraFm0w", + "CameraFmw0", + "CameraF0m", + "CameraF0iwm", + "CameraFi0wm", + "CameraFp0wm", + "CameraF0pwm", + "CameraF0imw", + "CameraFi0mw", + "CameraFp0mw", + "CameraF0pmw", + "CameraFm0", + "CameraF0im", + "CameraFi0m", + "CameraFp0m", + "CameraF0pm", + "CameraF9wm", + "CameraFw9m", + "CameraF9mw", + "CameraFm9w", + "CameraFmw9", + "CameraF9m", + "CameraF9iwm", + "CameraFi9wm", + "CameraFp9wm", + "CameraF9pwm", + "CameraF9imw", + "CameraFi9mw", + "CameraFp9mw", + "CameraF9pmw", + "CameraFm9", + "CameraF9im", + "CameraFi9m", + "CameraFp9m", + "CameraF9pm", + "Cdoen", + "Cdeon", + "Cdone", + "Cdnoe", + "Cdneo", + "Cdein", + "Cdine", + "Cdnie", + "Cdnei", + "Cdpen", + "Cdepn", + "Cdpne", + "Cdnpe", + "Cdnep", + "Cdoien", + "Cdpien", + "Cdipen", + "Cdpoen", + "Cdoine", + "Cdpine", + "Cdipne", + "Cdpone", + "Cdopne", + "Cdoeb", + "Cdeob", + "Cdobe", + "Cdboe", + "Cdbeo", + "Cdeib", + "Cdibe", + "Cdbie", + "Cdbei", + "Cdpeb", + "Cdepb", + "Cdpbe", + "Cdbpe", + "Cdbep", + "Cdoieb", + "Cdpieb", + "Cdipeb", + "Cdpoeb", + "Cdoibe", + "Cdpibe", + "Cdipbe", + "Cdpobe", + "Cdopbe", + "CSoen", + "CSeon", + "CSone", + "CSnoe", + "CSneo", + "CSien", + "CSein", + "CSine", + "CSnie", + "CSnei", + "CSpen", + "CSepn", + "CSpne", + "CSnpe", + "CSnep", + "CSoien", + "CSpien", + "CSioen", + "CSipen", + "CSpoen", + "CSopen", + "CSoine", + "CSione", + "CSipne", + "CSpone", + "CSopne", + "CSoeb", + "CSeob", + "CSobe", + "CSboe", + "CSbeo", + "CSieb", + "CSeib", + "CSibe", + "CSbie", + "CSbei", + "CSpeb", + "CSepb", + "CSpbe", + "CSbpe", + "CSbep", + "CSoieb", + "CSpieb", + "CSioeb", + "CSipeb", + "CSpoeb", + "CSopeb", + "CSoibe", + "CSpibe", + "CSiobe", + "CSipbe", + "CSpobe", + "CSopbe", + "Cdoe", + "Cdeo", + "Cdne", + "Cdei", + "Cdpe", + "Cdep", + "Cdoie", + "Cdpie", + "Cdipe", + "Cdpoe", + "Cdbe", + "CSoe", + "CSeo", + "CSne", + "CSie", + "CSei", + "CSpe", + "CSep", + "CSoie", + "CSpie", + "CSioe", + "CSipe", + "CSpoe", + "CSope", + "CSbe", + "Cd0en", + "Cde0n", + "Cd0ne", + "Cdn0e", + "Cdne0", + "Cd0ien", + "Cdi0en", + "Cdp0en", + "Cd0pen", + "Cd0ine", + "Cdi0ne", + "Cdp0ne", + "Cd0pne", + "Cd0eb", + "Cde0b", + "Cd0be", + "Cdb0e", + "Cdbe0", + "Cd0ieb", + "Cdi0eb", + "Cdp0eb", + "Cd0peb", + "Cd0ibe", + "Cdi0be", + "Cdp0be", + "Cd0pbe", + "CS0en", + "CSe0n", + "CS0ne", + "CSn0e", + "CSne0", + "CS0ien", + "CSi0en", + "CSp0en", + "CS0pen", + "CS0ine", + "CSi0ne", + "CSp0ne", + "CS0pne", + "CS0eb", + "CSe0b", + "CS0be", + "CSb0e", + "CSbe0", + "CS0ieb", + "CSi0eb", + "CSp0eb", + "CS0peb", + "CS0ibe", + "CSi0be", + "CSp0be", + "CS0pbe", + "Cd0e", + "Cde0", + "Cd0ie", + "Cdi0e", + "Cdp0e", + "Cd0pe", + "CS0e", + "CSe0", + "CS0ie", + "CSi0e", + "CSp0e", + "CS0pe", + "Cd9en", + "Cde9n", + "Cd9ne", + "Cdn9e", + "Cdne9", + "Cd9ien", + "Cdi9en", + "Cdp9en", + "Cd9pen", + "Cd9ine", + "Cdi9ne", + "Cdp9ne", + "Cd9pne", + "Cd9eb", + "Cde9b", + "Cd9be", + "Cdb9e", + "Cdbe9", + "Cd9ieb", + "Cdi9eb", + "Cdp9eb", + "Cd9peb", + "Cd9ibe", + "Cdi9be", + "Cdp9be", + "Cd9pbe", + "CS9en", + "CSe9n", + "CS9ne", + "CSn9e", + "CSne9", + "CS9ien", + "CSi9en", + "CSp9en", + "CS9pen", + "CS9ine", + "CSi9ne", + "CSp9ne", + "CS9pne", + "CS9eb", + "CSe9b", + "CS9be", + "CSb9e", + "CSbe9", + "CS9ieb", + "CSi9eb", + "CSp9eb", + "CS9peb", + "CS9ibe", + "CSi9be", + "CSp9be", + "CS9pbe", + "Cd9e", + "Cde9", + "Cd9ie", + "Cdi9e", + "Cdp9e", + "Cd9pe", + "CS9e", + "CSe9", + "CS9ie", + "CSi9e", + "CSp9e", + "CS9pe", + "CFoen", + "CFeon", + "CFone", + "CFnoe", + "CFneo", + "CFien", + "CFein", + "CFnie", + "CFnei", + "CFpen", + "CFepn", + "CFpne", + "CFnpe", + "CFnep", + "CFoien", + "CFpien", + "CFioen", + "CFipen", + "CFpoen", + "CFopen", + "CFoine", + "CFpine", + "CFione", + "CFipne", + "CFpone", + "CFopne", + "CFoeb", + "CFeob", + "CFobe", + "CFboe", + "CFbeo", + "CFieb", + "CFeib", + "CFibe", + "CFbie", + "CFbei", + "CFpeb", + "CFepb", + "CFpbe", + "CFbpe", + "CFbep", + "CFoieb", + "CFpieb", + "CFioeb", + "CFipeb", + "CFpoeb", + "CFopeb", + "CFoibe", + "CFpibe", + "CFiobe", + "CFipbe", + "CFpobe", + "CFopbe", + "CFoe", + "CFeo", + "CFne", + "CFie", + "CFei", + "CFpe", + "CFep", + "CFoie", + "CFpie", + "CFioe", + "CFipe", + "CFpoe", + "CFope", + "CFbe", + "CF0en", + "CFe0n", + "CF0ne", + "CFn0e", + "CFne0", + "CF0ien", + "CFi0en", + "CFp0en", + "CF0pen", + "CF0ine", + "CFi0ne", + "CFp0ne", + "CF0pne", + "CF0eb", + "CFe0b", + "CF0be", + "CFb0e", + "CFbe0", + "CF0ieb", + "CFi0eb", + "CFp0eb", + "CF0peb", + "CF0ibe", + "CFi0be", + "CFp0be", + "CF0pbe", + "CF0e", + "CFe0", + "CF0ie", + "CFi0e", + "CFp0e", + "CF0pe", + "CF9en", + "CFe9n", + "CF9ne", + "CFn9e", + "CFne9", + "CF9ien", + "CFi9en", + "CFp9en", + "CF9pen", + "CF9ine", + "CFi9ne", + "CFp9ne", + "CF9pne", + "CF9eb", + "CFe9b", + "CF9be", + "CFb9e", + "CFbe9", + "CF9ieb", + "CFi9eb", + "CFp9eb", + "CF9peb", + "CF9ibe", + "CFi9be", + "CFp9be", + "CF9pbe", + "CF9e", + "CFe9", + "CF9ie", + "CFi9e", + "CFp9e", + "CF9pe", + "Cameradoen", + "Cameradeon", + "Cameradone", + "Cameradnoe", + "Cameradneo", + "Cameradein", + "Cameradine", + "Cameradnie", + "Cameradnei", + "Cameradpen", + "Cameradepn", + "Cameradpne", + "Cameradnpe", + "Cameradnep", + "Cameradoien", + "Cameradpien", + "Cameradipen", + "Cameradpoen", + "Cameradoine", + "Cameradpine", + "Cameradipne", + "Cameradpone", + "Cameradopne", + "Cameradoeb", + "Cameradeob", + "Cameradobe", + "Cameradboe", + "Cameradbeo", + "Cameradeib", + "Cameradibe", + "Cameradbie", + "Cameradbei", + "Cameradpeb", + "Cameradepb", + "Cameradpbe", + "Cameradbpe", + "Cameradbep", + "Cameradoieb", + "Cameradpieb", + "Cameradipeb", + "Cameradpoeb", + "Cameradoibe", + "Cameradpibe", + "Cameradipbe", + "Cameradpobe", + "Cameradopbe", + "CameraSoen", + "CameraSeon", + "CameraSone", + "CameraSnoe", + "CameraSneo", + "CameraSien", + "CameraSein", + "CameraSine", + "CameraSnie", + "CameraSnei", + "CameraSpen", + "CameraSepn", + "CameraSpne", + "CameraSnpe", + "CameraSnep", + "CameraSoien", + "CameraSpien", + "CameraSioen", + "CameraSipen", + "CameraSpoen", + "CameraSopen", + "CameraSoine", + "CameraSione", + "CameraSipne", + "CameraSpone", + "CameraSopne", + "CameraSoeb", + "CameraSeob", + "CameraSobe", + "CameraSboe", + "CameraSbeo", + "CameraSieb", + "CameraSeib", + "CameraSibe", + "CameraSbie", + "CameraSbei", + "CameraSpeb", + "CameraSepb", + "CameraSpbe", + "CameraSbpe", + "CameraSbep", + "CameraSoieb", + "CameraSpieb", + "CameraSioeb", + "CameraSipeb", + "CameraSpoeb", + "CameraSopeb", + "CameraSoibe", + "CameraSpibe", + "CameraSiobe", + "CameraSipbe", + "CameraSpobe", + "CameraSopbe", + "Cameradoe", + "Cameradeo", + "Cameradne", + "Cameradei", + "Cameradpe", + "Cameradep", + "Cameradoie", + "Cameradpie", + "Cameradipe", + "Cameradpoe", + "Cameradbe", + "CameraSoe", + "CameraSeo", + "CameraSne", + "CameraSie", + "CameraSei", + "CameraSpe", + "CameraSep", + "CameraSoie", + "CameraSpie", + "CameraSioe", + "CameraSipe", + "CameraSpoe", + "CameraSope", + "CameraSbe", + "Camerad0en", + "Camerade0n", + "Camerad0ne", + "Cameradn0e", + "Cameradne0", + "Camerad0ien", + "Cameradi0en", + "Cameradp0en", + "Camerad0pen", + "Camerad0ine", + "Cameradi0ne", + "Cameradp0ne", + "Camerad0pne", + "Camerad0eb", + "Camerade0b", + "Camerad0be", + "Cameradb0e", + "Cameradbe0", + "Camerad0ieb", + "Cameradi0eb", + "Cameradp0eb", + "Camerad0peb", + "Camerad0ibe", + "Cameradi0be", + "Cameradp0be", + "Camerad0pbe", + "CameraS0en", + "CameraSe0n", + "CameraS0ne", + "CameraSn0e", + "CameraSne0", + "CameraS0ien", + "CameraSi0en", + "CameraSp0en", + "CameraS0pen", + "CameraS0ine", + "CameraSi0ne", + "CameraSp0ne", + "CameraS0pne", + "CameraS0eb", + "CameraSe0b", + "CameraS0be", + "CameraSb0e", + "CameraSbe0", + "CameraS0ieb", + "CameraSi0eb", + "CameraSp0eb", + "CameraS0peb", + "CameraS0ibe", + "CameraSi0be", + "CameraSp0be", + "CameraS0pbe", + "Camerad0e", + "Camerade0", + "Camerad0ie", + "Cameradi0e", + "Cameradp0e", + "Camerad0pe", + "CameraS0e", + "CameraSe0", + "CameraS0ie", + "CameraSi0e", + "CameraSp0e", + "CameraS0pe", + "Camerad9en", + "Camerade9n", + "Camerad9ne", + "Cameradn9e", + "Cameradne9", + "Camerad9ien", + "Cameradi9en", + "Cameradp9en", + "Camerad9pen", + "Camerad9ine", + "Cameradi9ne", + "Cameradp9ne", + "Camerad9pne", + "Camerad9eb", + "Camerade9b", + "Camerad9be", + "Cameradb9e", + "Cameradbe9", + "Camerad9ieb", + "Cameradi9eb", + "Cameradp9eb", + "Camerad9peb", + "Camerad9ibe", + "Cameradi9be", + "Cameradp9be", + "Camerad9pbe", + "CameraS9en", + "CameraSe9n", + "CameraS9ne", + "CameraSn9e", + "CameraSne9", + "CameraS9ien", + "CameraSi9en", + "CameraSp9en", + "CameraS9pen", + "CameraS9ine", + "CameraSi9ne", + "CameraSp9ne", + "CameraS9pne", + "CameraS9eb", + "CameraSe9b", + "CameraS9be", + "CameraSb9e", + "CameraSbe9", + "CameraS9ieb", + "CameraSi9eb", + "CameraSp9eb", + "CameraS9peb", + "CameraS9ibe", + "CameraSi9be", + "CameraSp9be", + "CameraS9pbe", + "Camerad9e", + "Camerade9", + "Camerad9ie", + "Cameradi9e", + "Cameradp9e", + "Camerad9pe", + "CameraS9e", + "CameraSe9", + "CameraS9ie", + "CameraSi9e", + "CameraSp9e", + "CameraS9pe", + "CameraFoen", + "CameraFeon", + "CameraFone", + "CameraFnoe", + "CameraFneo", + "CameraFien", + "CameraFein", + "CameraFnie", + "CameraFnei", + "CameraFpen", + "CameraFepn", + "CameraFpne", + "CameraFnpe", + "CameraFnep", + "CameraFoien", + "CameraFpien", + "CameraFioen", + "CameraFipen", + "CameraFpoen", + "CameraFopen", + "CameraFoine", + "CameraFpine", + "CameraFione", + "CameraFipne", + "CameraFpone", + "CameraFopne", + "CameraFoeb", + "CameraFeob", + "CameraFobe", + "CameraFboe", + "CameraFbeo", + "CameraFieb", + "CameraFeib", + "CameraFibe", + "CameraFbie", + "CameraFbei", + "CameraFpeb", + "CameraFepb", + "CameraFpbe", + "CameraFbpe", + "CameraFbep", + "CameraFoieb", + "CameraFpieb", + "CameraFioeb", + "CameraFipeb", + "CameraFpoeb", + "CameraFopeb", + "CameraFoibe", + "CameraFpibe", + "CameraFiobe", + "CameraFipbe", + "CameraFpobe", + "CameraFopbe", + "CameraFoe", + "CameraFeo", + "CameraFne", + "CameraFie", + "CameraFei", + "CameraFpe", + "CameraFep", + "CameraFoie", + "CameraFpie", + "CameraFioe", + "CameraFipe", + "CameraFpoe", + "CameraFope", + "CameraFbe", + "CameraF0en", + "CameraFe0n", + "CameraF0ne", + "CameraFn0e", + "CameraFne0", + "CameraF0ien", + "CameraFi0en", + "CameraFp0en", + "CameraF0pen", + "CameraF0ine", + "CameraFi0ne", + "CameraFp0ne", + "CameraF0pne", + "CameraF0eb", + "CameraFe0b", + "CameraF0be", + "CameraFb0e", + "CameraFbe0", + "CameraF0ieb", + "CameraFi0eb", + "CameraFp0eb", + "CameraF0peb", + "CameraF0ibe", + "CameraFi0be", + "CameraFp0be", + "CameraF0pbe", + "CameraF0e", + "CameraFe0", + "CameraF0ie", + "CameraFi0e", + "CameraFp0e", + "CameraF0pe", + "CameraF9en", + "CameraFe9n", + "CameraF9ne", + "CameraFn9e", + "CameraFne9", + "CameraF9ien", + "CameraFi9en", + "CameraFp9en", + "CameraF9pen", + "CameraF9ine", + "CameraFi9ne", + "CameraFp9ne", + "CameraF9pne", + "CameraF9eb", + "CameraFe9b", + "CameraF9be", + "CameraFb9e", + "CameraFbe9", + "CameraF9ieb", + "CameraFi9eb", + "CameraFp9eb", + "CameraF9peb", + "CameraF9ibe", + "CameraFi9be", + "CameraFp9be", + "CameraF9pbe", + "CameraF9e", + "CameraFe9", + "CameraF9ie", + "CameraFi9e", + "CameraFp9e", + "CameraF9pe", + "Cdoem", + "Cdeom", + "Cdome", + "Cdmoe", + "Cdmeo", + "Cdeim", + "Cdime", + "Cdmie", + "Cdmei", + "Cdpem", + "Cdepm", + "Cdpme", + "Cdmpe", + "Cdmep", + "Cdoiem", + "Cdpiem", + "Cdipem", + "Cdpoem", + "Cdoime", + "Cdpime", + "Cdipme", + "Cdpome", + "Cdopme", + "CSoem", + "CSeom", + "CSmoe", + "CSmeo", + "CSiem", + "CSeim", + "CSime", + "CSmie", + "CSmei", + "CSpem", + "CSepm", + "CSpme", + "CSmpe", + "CSmep", + "CSoiem", + "CSpiem", + "CSioem", + "CSipem", + "CSpoem", + "CSopem", + "CSoime", + "CSiome", + "CSipme", + "CSpome", + "CSopme", + "Cdme", + "CSme", + "Cd0em", + "Cde0m", + "Cd0me", + "Cdm0e", + "Cdme0", + "Cd0iem", + "Cdi0em", + "Cdp0em", + "Cd0pem", + "Cd0ime", + "Cdi0me", + "Cdp0me", + "Cd0pme", + "CS0em", + "CSe0m", + "CS0me", + "CSm0e", + "CSme0", + "CS0iem", + "CSi0em", + "CSp0em", + "CS0pem", + "CS0ime", + "CSi0me", + "CSp0me", + "CS0pme", + "Cd9em", + "Cde9m", + "Cd9me", + "Cdm9e", + "Cdme9", + "Cd9iem", + "Cdi9em", + "Cdp9em", + "Cd9pem", + "Cd9ime", + "Cdi9me", + "Cdp9me", + "Cd9pme", + "CS9em", + "CSe9m", + "CS9me", + "CSm9e", + "CSme9", + "CS9iem", + "CSi9em", + "CSp9em", + "CS9pem", + "CS9ime", + "CSi9me", + "CSp9me", + "CS9pme", + "CFoem", + "CFeom", + "CFome", + "CFmoe", + "CFmeo", + "CFiem", + "CFeim", + "CFime", + "CFmie", + "CFmei", + "CFpem", + "CFepm", + "CFpme", + "CFmpe", + "CFmep", + "CFoiem", + "CFpiem", + "CFioem", + "CFipem", + "CFpoem", + "CFopem", + "CFoime", + "CFpime", + "CFiome", + "CFipme", + "CFpome", + "CFopme", + "CFme", + "CF0em", + "CFe0m", + "CF0me", + "CFm0e", + "CFme0", + "CF0iem", + "CFi0em", + "CFp0em", + "CF0pem", + "CF0ime", + "CFi0me", + "CFp0me", + "CF0pme", + "CF9em", + "CFe9m", + "CF9me", + "CFm9e", + "CFme9", + "CF9iem", + "CFi9em", + "CFp9em", + "CF9pem", + "CF9ime", + "CFi9me", + "CFp9me", + "CF9pme", + "Cameradoem", + "Cameradeom", + "Cameradome", + "Cameradmoe", + "Cameradmeo", + "Cameradeim", + "Cameradime", + "Cameradmie", + "Cameradmei", + "Cameradpem", + "Cameradepm", + "Cameradpme", + "Cameradmpe", + "Cameradmep", + "Cameradoiem", + "Cameradpiem", + "Cameradipem", + "Cameradpoem", + "Cameradoime", + "Cameradpime", + "Cameradipme", + "Cameradpome", + "Cameradopme", + "CameraSoem", + "CameraSeom", + "CameraSmoe", + "CameraSmeo", + "CameraSiem", + "CameraSeim", + "CameraSime", + "CameraSmie", + "CameraSmei", + "CameraSpem", + "CameraSepm", + "CameraSpme", + "CameraSmpe", + "CameraSmep", + "CameraSoiem", + "CameraSpiem", + "CameraSioem", + "CameraSipem", + "CameraSpoem", + "CameraSopem", + "CameraSoime", + "CameraSiome", + "CameraSipme", + "CameraSpome", + "CameraSopme", + "Cameradme", + "CameraSme", + "Camerad0em", + "Camerade0m", + "Camerad0me", + "Cameradm0e", + "Cameradme0", + "Camerad0iem", + "Cameradi0em", + "Cameradp0em", + "Camerad0pem", + "Camerad0ime", + "Cameradi0me", + "Cameradp0me", + "Camerad0pme", + "CameraS0em", + "CameraSe0m", + "CameraS0me", + "CameraSm0e", + "CameraSme0", + "CameraS0iem", + "CameraSi0em", + "CameraSp0em", + "CameraS0pem", + "CameraS0ime", + "CameraSi0me", + "CameraSp0me", + "CameraS0pme", + "Camerad9em", + "Camerade9m", + "Camerad9me", + "Cameradm9e", + "Cameradme9", + "Camerad9iem", + "Cameradi9em", + "Cameradp9em", + "Camerad9pem", + "Camerad9ime", + "Cameradi9me", + "Cameradp9me", + "Camerad9pme", + "CameraS9em", + "CameraSe9m", + "CameraS9me", + "CameraSm9e", + "CameraSme9", + "CameraS9iem", + "CameraSi9em", + "CameraSp9em", + "CameraS9pem", + "CameraS9ime", + "CameraSi9me", + "CameraSp9me", + "CameraS9pme", + "CameraFoem", + "CameraFeom", + "CameraFome", + "CameraFmoe", + "CameraFmeo", + "CameraFiem", + "CameraFeim", + "CameraFime", + "CameraFmie", + "CameraFmei", + "CameraFpem", + "CameraFepm", + "CameraFpme", + "CameraFmpe", + "CameraFmep", + "CameraFoiem", + "CameraFpiem", + "CameraFioem", + "CameraFipem", + "CameraFpoem", + "CameraFopem", + "CameraFoime", + "CameraFpime", + "CameraFiome", + "CameraFipme", + "CameraFpome", + "CameraFopme", + "CameraFme", + "CameraF0em", + "CameraFe0m", + "CameraF0me", + "CameraFm0e", + "CameraFme0", + "CameraF0iem", + "CameraFi0em", + "CameraFp0em", + "CameraF0pem", + "CameraF0ime", + "CameraFi0me", + "CameraFp0me", + "CameraF0pme", + "CameraF9em", + "CameraFe9m", + "CameraF9me", + "CameraFm9e", + "CameraFme9", + "CameraF9iem", + "CameraFi9em", + "CameraFp9em", + "CameraF9pem", + "CameraF9ime", + "CameraFi9me", + "CameraFp9me", + "CameraF9pme", + "CBackward", + "CBackwards", + "CBack", + "CameraBackward", + "CameraBackwards", + "CameraBack", + "CBackwars", + "CBackwarss", + "CameraBackwars", + "CameraBackwarss", + "CBackwar", + "CameraBackwar", + "CBacxkward", + "CBacxkwards", + "CBacxk", + "CameraBacxkward", + "CameraBacxkwards", + "CameraBacxk", + "CBaxckward", + "CBaxckwards", + "CBaxck", + "CameraBaxckward", + "CameraBaxckwards", + "CameraBaxck", + "CBaxkward", + "CBaxkwards", + "CBaxk", + "CameraBaxkward", + "CameraBaxkwards", + "CameraBaxk", + "CBacxkwar", + "CBacxkwars", + "CameraBacxkwar", + "CameraBacxkwars", + "CBaxckwar", + "CBaxckwars", + "CameraBaxckwar", + "CameraBaxckwars", + "CBaxkwar", + "CBaxkwars", + "CameraBaxkwar", + "CameraBaxkwars", + "CBacxkwarss", + "CameraBacxkwarss", + "CBaxckwarss", + "CameraBaxckwarss", + "CBaxkwarss", + "CameraBaxkwarss", + "CBavckward", + "CBavckwards", + "CBavck", + "CameraBavckward", + "CameraBavckwards", + "CameraBavck", + "CBavckwars", + "CBavckwarss", + "CameraBavckwars", + "CameraBavckwarss", + "CBavckwar", + "CameraBavckwar", + "CBakcward", + "CBakcwards", + "CBakc", + "CameraBakcward", + "CameraBakcwards", + "CameraBakc", + "CBakcwars", + "CBakcwarss", + "CameraBakcwars", + "CameraBakcwarss", + "CBakcwar", + "CameraBakcwar", + "CBaccward", + "CBaccwards", + "CBacc", + "CameraBaccward", + "CameraBaccwards", + "CameraBacc", + "CBaccwars", + "CBaccwarss", + "CameraBaccwars", + "CameraBaccwarss", + "CBaccwar", + "CameraBaccwar", + "CBavkward", + "CBavkwards", + "CBavk", + "CameraBavkward", + "CameraBavkwards", + "CameraBavk", + "CBavkwars", + "CBavkwarss", + "CameraBavkwars", + "CameraBavkwarss", + "CBavkwar", + "CameraBavkwar", + "CBacvkward", + "CBacvkwards", + "CBacvk", + "CameraBacvkward", + "CameraBacvkwards", + "CameraBacvk", + "CBacvkwars", + "CBacvkwarss", + "CameraBacvkwars", + "CameraBacvkwarss", + "CBacvkwar", + "CameraBacvkwar", + "CBackword", + "CBackwords", + "CameraBackword", + "CameraBackwords", + "CBackwors", + "CBackworss", + "CameraBackwors", + "CameraBackworss", + "CBackwor", + "CameraBackwor", + "CBacxkword", + "CBacxkwords", + "CameraBacxkword", + "CameraBacxkwords", + "CBaxckword", + "CBaxckwords", + "CameraBaxckword", + "CameraBaxckwords", + "CBaxkword", + "CBaxkwords", + "CameraBaxkword", + "CameraBaxkwords", + "CBacxkwor", + "CBacxkwors", + "CameraBacxkwor", + "CameraBacxkwors", + "CBaxckwor", + "CBaxckwors", + "CameraBaxckwor", + "CameraBaxckwors", + "CBaxkwor", + "CBaxkwors", + "CameraBaxkwor", + "CameraBaxkwors", + "CBacxkworss", + "CameraBacxkworss", + "CBaxckworss", + "CameraBaxckworss", + "CBaxkworss", + "CameraBaxkworss", + "CBavckword", + "CBavckwords", + "CameraBavckword", + "CameraBavckwords", + "CBavckwors", + "CBavckworss", + "CameraBavckwors", + "CameraBavckworss", + "CBavckwor", + "CameraBavckwor", + "CBakcword", + "CBakcwords", + "CameraBakcword", + "CameraBakcwords", + "CBakcwors", + "CBakcworss", + "CameraBakcwors", + "CameraBakcworss", + "CBakcwor", + "CameraBakcwor", + "CBaccword", + "CBaccwords", + "CameraBaccword", + "CameraBaccwords", + "CBaccwors", + "CBaccworss", + "CameraBaccwors", + "CameraBaccworss", + "CBaccwor", + "CameraBaccwor", + "CBavkword", + "CBavkwords", + "CameraBavkword", + "CameraBavkwords", + "CBavkwors", + "CBavkworss", + "CameraBavkwors", + "CameraBavkworss", + "CBavkwor", + "CameraBavkwor", + "CBacvkword", + "CBacvkwords", + "CameraBacvkword", + "CameraBacvkwords", + "CBacvkwors", + "CBacvkworss", + "CameraBacvkwors", + "CameraBacvkworss", + "CBacvkwor", + "CameraBacvkwor", + "CameraBacvkwors" + ], + "color_value": "#C7C7C7", + "is_blacklisted": false, + "opposite_input_value": "0x00107F7F7F7F0000L", + "opposite_input_name": "^", + "has_opposite": true, + "input_type": 1, + "keyboard_value": 35, + "keyboard_key_name": "End" + }, + { + "input_value": "0x00407F7F7F7F0000L", + "input_name": ">", + "input_alias": [ + "D=≥", + "Dpad=≥", + "D≥", + "D-≥", + "Dpad≥", + "Dpad-≥", + "RigfhtD", + "RigfhtDpad", + "DRigfht", + "DpadRigfht", + "DRigfhty", + "DpadRigfhty", + "RifghtD", + "RifghtDpad", + "DRifght", + "DpadRifght", + "DRifghty", + "DpadRifghty", + "RigfthD", + "RigfthDpad", + "DRigfth", + "DpadRigfth", + "DRigfthy", + "DpadRigfthy", + "RifgthD", + "RifgthDpad", + "DRifgth", + "DpadRifgth", + "DRifgthy", + "DpadRifgthy", + "DRugh", + "DpadRugh", + "DRughy", + "DpadRughy", + "RightD", + "RightDpad", + "DRught", + "DpadRught", + "DRughty", + "DpadRughty", + "DRifgt", + "DpadRifgt", + "DRifgty", + "DpadRifgty", + "DRighg", + "DpadRighg", + "DRighgy", + "DpadRighgy", + "DRighr", + "DpadRighr", + "DRighry", + "DpadRighry", + "DRig", + "DpadRig", + "Drigt", + "Dpadrigt", + "DRigty", + "DpadRigty", + "DRigy", + "DpadRigy", + "DFifht", + "DpadFifht", + "DFifhty", + "DpadFifhty", + "DTifht", + "DpadTifht", + "DEifht", + "DpadEifht", + "Drifht", + "Dpadrifht", + "DRofht", + "DpadRofht", + "DRfht", + "DpadRfht", + "DRifhty", + "DpadRifhty", + "DIefht", + "DpadIefht", + "DRuifht", + "DpadRuifht", + "DRiufht", + "DpadRiufht", + "DIrfht", + "DpadIrfht", + "DRogjt", + "DpadRogjt", + "DRogjty", + "DpadRogjty", + "DRihgy", + "DpadRihgy", + "DRihgyy", + "DpadRihgyy", + "DRivht", + "DpadRivht", + "DRivhty", + "DpadRivhty", + "DRigtt", + "DpadRigtt", + "DRigtty", + "DpadRigtty", + "DRi", + "DRihgt", + "DpadRihgt", + "DRihgty", + "DpadRihgty", + "DRigth", + "DpadRigth", + "DRigthy", + "DpadRigthy", + "DEash", + "DpadEash", + "DFigh", + "DpadFigh", + "DFight", + "DpadFight", + "DFighty", + "DpadFighty", + "DFighy", + "DpadFighy", + "DRigh", + "DpadRigh", + "D=>", + "Dpad=>", + "DTight", + "DpadTight", + "DEight", + "DpadEight", + "Dright", + "DR", + "D>", + "D->", + "D→", + "DEast", + "DE", + "D►", + "Dpadright", + "DpadR", + "Dpad>", + "Dpad->", + "Dpad→", + "DpadEast", + "DpadE", + "Dpad►", + "DRigjt", + "DpadRigjt", + "DRoght", + "DpadRoght", + "DRght", + "DpadRght", + "DRighty", + "DpadRighty", + "DRighy", + "DpadRighy", + "DIeght", + "DpadIeght", + "DRuight", + "DpadRuight", + "DRiught", + "DpadRiught", + "DIrght", + "DpadIrght", + "LeftStickRight", + "LeftStickR", + "LStickRight", + "LStickR", + "StickRight", + "StickR", + "=≥", + "A=≥", + "≥", + "A≥", + "-≥", + "A-≥", + "RigfhtA", + "RigfhtAnalog", + "AnalogRigfht", + "ARigfht", + "Rigfht", + "WalkRigfht", + "MoveRigfht", + "MvoeRigfht", + "ARigfhty", + "Rigfhty", + "WalkRigfhty", + "MoveRigfhty", + "MvoeRigfhty", + "RifghtA", + "RifghtAnalog", + "AnalogRifght", + "ARifght", + "Rifght", + "WalkRifght", + "MoveRifght", + "MvoeRifght", + "ARifghty", + "Rifghty", + "WalkRifghty", + "MoveRifghty", + "MvoeRifghty", + "RigfthA", + "RigfthAnalog", + "AnalogRigfth", + "ARigfth", + "Rigfth", + "WalkRigfth", + "MoveRigfth", + "MvoeRigfth", + "ARigfthy", + "Rigfthy", + "WalkRigfthy", + "MoveRigfthy", + "MvoeRigfthy", + "RifgthA", + "RifgthAnalog", + "AnalogRifgth", + "ARifgth", + "Rifgth", + "WalkRifgth", + "MoveRifgth", + "MvoeRifgth", + "ARifgthy", + "Rifgthy", + "WalkRifgthy", + "MoveRifgthy", + "MvoeRifgthy", + "AnalogRugh", + "ARugh", + "Rugh", + "WalkRugh", + "MoveRugh", + "MvoeRugh", + "ARughy", + "Rughy", + "WalkRughy", + "MoveRughy", + "MvoeRughy", + "RightA", + "RightAnalog", + "AnalogRught", + "ARught", + "Rught", + "WalkRught", + "MoveRught", + "MvoeRught", + "ARughty", + "Rughty", + "WalkRughty", + "MoveRughty", + "MvoeRughty", + "AnalogRifgt", + "ARifgt", + "Rifgt", + "WalkRifgt", + "MoveRifgt", + "MvoeRifgt", + "ARifgty", + "Rifgty", + "WalkRifgty", + "MoveRifgty", + "MvoeRifgty", + "AnalogRighg", + "ARighg", + "Righg", + "WalkRighg", + "MoveRighg", + "MvoeRighg", + "ARighgy", + "Righgy", + "WalkRighgy", + "MoveRighgy", + "MvoeRighgy", + "AnalogRighr", + "ARighr", + "Righr", + "WalkRighr", + "MoveRighr", + "MvoeRighr", + "ARighry", + "Righry", + "WalkRighry", + "MoveRighry", + "MvoeRighry", + "AnalogRig", + "ARig", + "Rig", + "WalkRig", + "MoveRig", + "MvoeRig", + "Analogrigt", + "Arigt", + "Rigt", + "Walkrigt", + "Moverigt", + "Mvoerigt", + "ARigty", + "Rigty", + "WalkRigty", + "MoveRigty", + "MvoeRigty", + "ARigy", + "Rigy", + "WalkRigy", + "MoveRigy", + "MvoeRigy", + "AnalogFifht", + "AFifht", + "Fifht", + "WalkFifht", + "MoveFifht", + "MvoeFifht", + "AFifhty", + "Fifhty", + "WalkFifhty", + "MoveFifhty", + "MvoeFifhty", + "Analogrifht", + "ATifht", + "Tifht", + "WalkTifht", + "MoveTifht", + "MvoeTifht", + "AEifht", + "Eifht", + "Arifht", + "Rifht", + "Walkrifht", + "Moverifht", + "Mvoerifht", + "ARofht", + "Rofht", + "WalkRofht", + "MoveRofht", + "MvoeRofht", + "ARfht", + "Rfht", + "WalkRfht", + "MoveRfht", + "MvoeRfht", + "ARifhty", + "Rifhty", + "WalkRifhty", + "MoveRifhty", + "MvoeRifhty", + "AIefht", + "Iefht", + "WalkIefht", + "MoveIefht", + "MvoeIefht", + "ARuifht", + "Ruifht", + "WalkRuifht", + "MoveRuifht", + "MvoeRuifht", + "ARiufht", + "Riufht", + "WalkRiufht", + "MoveRiufht", + "MvoeRiufht", + "AIrfht", + "Irfht", + "WalkIrfht", + "MoveIrfht", + "MvoeIrfht", + "AnalogRogjt", + "ARogjt", + "Rogjt", + "WalkRogjt", + "MoveRogjt", + "MvoeRogjt", + "ARogjty", + "Rogjty", + "WalkRogjty", + "MoveRogjty", + "MvoeRogjty", + "AnalogRihgy", + "ARihgy", + "Rihgy", + "WalkRihgy", + "MoveRihgy", + "MvoeRihgy", + "ARihgyy", + "Rihgyy", + "WalkRihgyy", + "MoveRihgyy", + "MvoeRihgyy", + "AnalogRivht", + "ARivht", + "Rivht", + "WalkRivht", + "MoveRivht", + "MvoeRivht", + "ARivhty", + "Rivhty", + "WalkRivhty", + "MoveRivhty", + "MvoeRivhty", + "AnalogRigtt", + "ARigtt", + "Rigtt", + "WalkRigtt", + "MoveRigtt", + "MvoeRigtt", + "ARigtty", + "Rigtty", + "WalkRigtty", + "MoveRigtty", + "MvoeRigtty", + "Ri", + "ARi", + "AnalogRi", + "AnalogRihgt", + "ARihgt", + "Rihgt", + "WalkRihgt", + "MoveRihgt", + "MvoeRihgt", + "ARihgty", + "Rihgty", + "WalkRihgty", + "MoveRihgty", + "MvoeRihgty", + "AnalogRigth", + "ARigth", + "Rigth", + "WalkRigth", + "MoveRigth", + "MvoeRigth", + "ARigthy", + "Rigthy", + "WalkRigthy", + "MoveRigthy", + "MvoeRigthy", + "AEash", + "Eash", + "AnalogFigh", + "AFigh", + "Figh", + "WalkFigh", + "MoveFigh", + "MvoeFigh", + "AnalogFight", + "AFight", + "Fight", + "WalkFight", + "MoveFight", + "MvoeFight", + "AFighty", + "Fighty", + "WalkFighty", + "MoveFighty", + "MvoeFighty", + "AFighy", + "Fighy", + "WalkFighy", + "MoveFighy", + "MvoeFighy", + "AnalogRigh", + "ARigh", + "Righ", + "WalkRigh", + "MoveRigh", + "MvoeRigh", + "Analogright", + "→", + "=>", + "A=>", + "ATight", + "Tight", + "WalkTight", + "MoveTight", + "MvoeTight", + "AEight", + "Eight", + "Aright", + "AR", + "Right", + ">", + "A>", + "->", + "A->", + "A→", + "AEast", + "East", + "E", + "AE", + "►", + "A►", + "Walkright", + "Moveright", + "Mvoeright", + "ARigjt", + "Rigjt", + "WalkRigjt", + "MoveRigjt", + "MvoeRigjt", + "ARoght", + "Roght", + "WalkRoght", + "MoveRoght", + "MvoeRoght", + "ARght", + "Rght", + "WalkRght", + "MoveRght", + "MvoeRght", + "ARighty", + "Righty", + "WalkRighty", + "MoveRighty", + "MvoeRighty", + "ARighy", + "Righy", + "WalkRighy", + "MoveRighy", + "MvoeRighy", + "AIeght", + "Ieght", + "WalkIeght", + "MoveIeght", + "MvoeIeght", + "ARuight", + "Ruight", + "WalkRuight", + "MoveRuight", + "MvoeRuight", + "ARiught", + "Riught", + "WalkRiught", + "MoveRiught", + "MvoeRiught", + "AIrght", + "Irght", + "WalkIrght", + "MoveIrght", + "MvoeIrght", + "RightStickRight", + "RightStickR", + "RStickRight", + "RStickR", + "CameraStickRight", + "CameraStickR", + "CamStickRight", + "CamStickR", + "CStickRight", + "CStickR", + "Cam=≥", + "Cam≥", + "Cam-≥", + "RigfhtCam", + "Cam-Rigfht", + "CamRigfht", + "CamRigfhty", + "RifghtCam", + "Cam-Rifght", + "CamRifght", + "CamRifghty", + "RigfthCam", + "Cam-Rigfth", + "CamRigfth", + "CamRigfthy", + "RifgthCam", + "Cam-Rifgth", + "CamRifgth", + "CamRifgthy", + "Cam-Rugh", + "CamRugh", + "CamRughy", + "RightCam", + "Cam-Rught", + "CamRught", + "CamRughty", + "Cam-Rifgt", + "CamRifgt", + "CamRifgty", + "Cam-Righg", + "CamRighg", + "CamRighgy", + "Cam-Righr", + "CamRighr", + "CamRighry", + "Cam-Rig", + "CamRig", + "Cam-rigt", + "Camrigt", + "CamRigty", + "CamRigy", + "Cam-Fifht", + "CamFifht", + "CamFifhty", + "Cam-rifht", + "CamTifht", + "CamEifht", + "Camrifht", + "CamRofht", + "CamRfht", + "CamRifhty", + "CamIefht", + "CamRuifht", + "CamRiufht", + "CamIrfht", + "Cam-Rogjt", + "CamRogjt", + "CamRogjty", + "Cam-Rihgy", + "CamRihgy", + "CamRihgyy", + "Cam-Rivht", + "CamRivht", + "CamRivhty", + "Cam-Rigtt", + "CamRigtt", + "CamRigtty", + "CamRi", + "Cam-Ri", + "Cam-Rihgt", + "CamRihgt", + "CamRihgty", + "Cam-Rigth", + "CamRigth", + "CamRigthy", + "CamEash", + "Cam-Figh", + "CamFigh", + "Cam-Fight", + "CamFight", + "CamFighty", + "CamFighy", + "Cam-Righ", + "CamRigh", + "Cam-right", + "Cam=>", + "CamTight", + "CamEight", + "Camright", + "CamR", + "Cam>", + "Cam->", + "Cam→", + "CamEast", + "CamE", + "Cam►", + "CamRigjt", + "CamRoght", + "CamRght", + "CamRighty", + "CamRighy", + "CamIeght", + "CamRuight", + "CamRiught", + "CamIrght", + "C=≥", + "Camera=≥", + "C≥", + "C-≥", + "Camera≥", + "Camera-≥", + "RigfhtC", + "RigfhtCamera", + "C-Rigfht", + "Camera-Rigfht", + "CRigfht", + "CameraRigfht", + "CRigfhty", + "CameraRigfhty", + "RifghtC", + "RifghtCamera", + "C-Rifght", + "Camera-Rifght", + "CRifght", + "CameraRifght", + "CRifghty", + "CameraRifghty", + "RigfthC", + "RigfthCamera", + "C-Rigfth", + "Camera-Rigfth", + "CRigfth", + "CameraRigfth", + "CRigfthy", + "CameraRigfthy", + "RifgthC", + "RifgthCamera", + "C-Rifgth", + "Camera-Rifgth", + "CRifgth", + "CameraRifgth", + "CRifgthy", + "CameraRifgthy", + "C-Rugh", + "Camera-Rugh", + "CRugh", + "CameraRugh", + "CRughy", + "CameraRughy", + "RightC", + "RightCamera", + "C-Rught", + "Camera-Rught", + "CRught", + "CameraRught", + "CRughty", + "CameraRughty", + "C-Rifgt", + "Camera-Rifgt", + "CRifgt", + "CameraRifgt", + "CRifgty", + "CameraRifgty", + "C-Righg", + "Camera-Righg", + "CRighg", + "CameraRighg", + "CRighgy", + "CameraRighgy", + "C-Righr", + "Camera-Righr", + "CRighr", + "CameraRighr", + "CRighry", + "CameraRighry", + "C-Rig", + "Camera-Rig", + "CRig", + "CameraRig", + "C-rigt", + "Camera-rigt", + "Crigt", + "Camerarigt", + "CRigty", + "CameraRigty", + "CRigy", + "CameraRigy", + "C-Fifht", + "Camera-Fifht", + "CFifht", + "CameraFifht", + "CFifhty", + "CameraFifhty", + "C-rifht", + "Camera-rifht", + "CTifht", + "CameraTifht", + "CEifht", + "CameraEifht", + "Crifht", + "Camerarifht", + "CRofht", + "CameraRofht", + "CRfht", + "CameraRfht", + "CRifhty", + "CameraRifhty", + "CIefht", + "CameraIefht", + "CRuifht", + "CameraRuifht", + "CRiufht", + "CameraRiufht", + "CIrfht", + "CameraIrfht", + "C-Rogjt", + "Camera-Rogjt", + "CRogjt", + "CameraRogjt", + "CRogjty", + "CameraRogjty", + "C-Rihgy", + "Camera-Rihgy", + "CRihgy", + "CameraRihgy", + "CRihgyy", + "CameraRihgyy", + "C-Rivht", + "Camera-Rivht", + "CRivht", + "CameraRivht", + "CRivhty", + "CameraRivhty", + "C-Rigtt", + "Camera-Rigtt", + "CRigtt", + "CameraRigtt", + "CRigtty", + "CameraRigtty", + "CRi", + "CameraRi", + "C-Ri", + "Camera-Ri", + "C-Rihgt", + "Camera-Rihgt", + "CRihgt", + "CameraRihgt", + "CRihgty", + "CameraRihgty", + "C-Rigth", + "Camera-Rigth", + "CRigth", + "CameraRigth", + "CRigthy", + "CameraRigthy", + "CEash", + "CameraEash", + "C-Figh", + "Camera-Figh", + "CFigh", + "CameraFigh", + "C-Fight", + "Camera-Fight", + "CFight", + "CameraFight", + "CFighty", + "CameraFighty", + "CFighy", + "CameraFighy", + "C-Righ", + "Camera-Righ", + "CRigh", + "CameraRigh", + "C-right", + "Camera-right", + "C=>", + "Camera=>", + "CTight", + "CameraTight", + "CEight", + "CameraEight", + "Cright", + "CR", + "C>", + "C->", + "C→", + "CEast", + "CE", + "C►", + "Cameraright", + "CameraR", + "Camera>", + "Camera->", + "Camera→", + "CameraEast", + "CameraE", + "Camera►", + "CRigjt", + "CameraRigjt", + "CRoght", + "CameraRoght", + "CRght", + "CameraRght", + "CRighty", + "CameraRighty", + "CRighy", + "CameraRighy", + "CIeght", + "CameraIeght", + "CRuight", + "CameraRuight", + "CRiught", + "CameraRiught", + "CIrght", + "CameraIrght" + ], + "color_value": "#C7C7C7", + "is_blacklisted": false, + "opposite_input_value": "0x00807F7F7F7F0000L", + "opposite_input_name": "<", + "has_opposite": true, + "input_type": 1, + "keyboard_value": 34, + "keyboard_key_name": "PageDown" + }, + { + "input_value": "0x00807F7F7F7F0000L", + "input_name": "<", + "input_alias": [ + "PeftD", + "PeftDpad", + "DPeftt", + "DpadPeftt", + "DPeft", + "DpadPeft", + "D≤=", + "Dpad≤=", + "D≤", + "D≤-", + "Dpad≤", + "Dpad≤-", + "LestD", + "LestDpad", + "DLestt", + "DpadLestt", + "DLest", + "DpadLest", + "LectD", + "LectDpad", + "DLectt", + "DpadLectt", + "DLect", + "DpadLect", + "LwctD", + "LwctDpad", + "DLwctt", + "DpadLwctt", + "DLwct", + "DpadLwct", + "LecyD", + "LecyDpad", + "DLecyt", + "DpadLecyt", + "DLecy", + "DpadLecy", + "LwcyD", + "LwcyDpad", + "DLwcyt", + "DpadLwcyt", + "DLwcy", + "DpadLwcy", + "LeftD", + "LeftDpad", + "DLwftt", + "DpadLwftt", + "DLwft", + "DpadLwft", + "DLweftt", + "DpadLweftt", + "DLweft", + "DpadLweft", + "DLewftt", + "DpadLewftt", + "DLewft", + "DpadLewft", + "DEftt", + "DpadEftt", + "DEft", + "DpadEft", + "Dlettt", + "Dpadlettt", + "Dlett", + "Dpadlett", + "DMeftt", + "DpadMeftt", + "DMeft", + "DpadMeft", + "DLftt", + "DpadLftt", + "DLft", + "DpadLft", + "DEldtt", + "DpadEldtt", + "DElftt", + "DElgtt", + "DpadElftt", + "DpadElgtt", + "DEldt", + "DpadEldt", + "DElgft", + "DpadElgft", + "DElft", + "DEltf", + "DElgy", + "DElgt", + "DEltg", + "DElyg", + "DElfy", + "DElyf", + "DElg", + "DElfg", + "DElgf", + "DElgg", + "DElf", + "DElff", + "DElfr", + "DElaft", + "DElafy", + "DElafg", + "DElaf", + "DElaff", + "DElafr", + "DpadElft", + "DpadEltf", + "DpadElgy", + "DpadElgt", + "DpadEltg", + "DpadElyg", + "DpadElfy", + "DpadElyf", + "DpadElg", + "DpadElfg", + "DpadElgf", + "DpadElgg", + "DpadElf", + "DpadElff", + "DpadElfr", + "DpadElaft", + "DpadElafy", + "DpadElafg", + "DpadElaf", + "DpadElaff", + "DpadElafr", + "DLedtt", + "DpadLedtt", + "Dleftt", + "Dlegtt", + "Dpadleftt", + "Dpadlegtt", + "DLedt", + "DpadLedt", + "DLegft", + "DpadLegft", + "D<=", + "Dpad<=", + "Dleft", + "DL", + "D<", + "D<-", + "D←", + "D◄", + "DWest", + "DW", + "Dlfet", + "Dletf", + "Dlegy", + "Dlegt", + "Dletg", + "Dleyg", + "Dlefy", + "Dleyf", + "Dleg", + "Dlget", + "Dlgey", + "Dlfey", + "DLrft", + "DLfrt", + "DLrtf", + "DLrgy", + "DLrgt", + "DLrtg", + "DLryg", + "DLrfy", + "DLryf", + "DLrt", + "DLrg", + "DLgrt", + "DLgry", + "DLfry", + "DKeft", + "DK", + "DKfet", + "DKetf", + "DKegy", + "DKegt", + "DKetg", + "DKeyg", + "DKefy", + "DKeyf", + "DKet", + "DKeg", + "DKget", + "DKgey", + "DKfey", + "DKrft", + "DKfrt", + "DKrtf", + "DKrgy", + "DKrgt", + "DKrtg", + "DKryg", + "DKrfy", + "DKryf", + "DKrt", + "DKrg", + "DKgrt", + "DKgry", + "DKfry", + "DLef", + "DLeff", + "DLefr", + "Dleaft", + "Dleafy", + "DKeaft", + "DKeafy", + "Dleafg", + "DKeafg", + "DLeaf", + "DLeaff", + "DLeafr", + "Dpadleft", + "DpadL", + "Dpad<", + "Dpad<-", + "Dpad←", + "Dpad◄", + "DpadWest", + "DpadW", + "Dpadlfet", + "Dpadletf", + "Dpadlegy", + "Dpadlegt", + "Dpadletg", + "Dpadleyg", + "Dpadlefy", + "Dpadleyf", + "Dpadleg", + "Dpadlget", + "Dpadlgey", + "Dpadlfey", + "DpadLrft", + "DpadLfrt", + "DpadLrtf", + "DpadLrgy", + "DpadLrgt", + "DpadLrtg", + "DpadLryg", + "DpadLrfy", + "DpadLryf", + "DpadLrt", + "DpadLrg", + "DpadLgrt", + "DpadLgry", + "DpadLfry", + "DpadKeft", + "DpadK", + "DpadKfet", + "DpadKetf", + "DpadKegy", + "DpadKegt", + "DpadKetg", + "DpadKeyg", + "DpadKefy", + "DpadKeyf", + "DpadKet", + "DpadKeg", + "DpadKget", + "DpadKgey", + "DpadKfey", + "DpadKrft", + "DpadKfrt", + "DpadKrtf", + "DpadKrgy", + "DpadKrgt", + "DpadKrtg", + "DpadKryg", + "DpadKrfy", + "DpadKryf", + "DpadKrt", + "DpadKrg", + "DpadKgrt", + "DpadKgry", + "DpadKfry", + "Dpadlefg", + "DpadWesg", + "Dpadlfeg", + "Dpadlegf", + "Dpadlegg", + "Dpadlgeg", + "DpadLrfg", + "DpadLfrg", + "DpadLrgf", + "DpadLrgg", + "DpadLgrg", + "DpadKefg", + "DpadKfeg", + "DpadKegf", + "DpadKegg", + "DpadKgeg", + "DpadKrfg", + "DpadKfrg", + "DpadKrgf", + "DpadKrgg", + "DpadKgrg", + "DpadLef", + "DpadLeff", + "DpadLefr", + "Dpadleaft", + "Dpadleafy", + "DpadKeaft", + "DpadKeafy", + "Dpadleafg", + "DpadKeafg", + "DpadLeaf", + "DpadLeaff", + "DpadLeafr", + "LeftStickLeft", + "LeftStickL", + "LStickLeft", + "LStickL", + "StickLeft", + "StickL", + "PeftA", + "PeftAnalog", + "AnalogPeftt", + "APeftt", + "Peftt", + "WalkPeftt", + "MovePeftt", + "MvoePeftt", + "AnalogPeft", + "APeft", + "Peft", + "WalkPeft", + "MovePeft", + "MvoePeft", + "≤=", + "A≤=", + "≤", + "A≤", + "≤-", + "A≤-", + "LestA", + "LestAnalog", + "AnalogLestt", + "ALestt", + "Lestt", + "WalkLestt", + "MoveLestt", + "MvoeLestt", + "AnalogLest", + "ALest", + "Lest", + "WalkLest", + "MoveLest", + "MvoeLest", + "LectA", + "LectAnalog", + "AnalogLectt", + "ALectt", + "Lectt", + "WalkLectt", + "MoveLectt", + "MvoeLectt", + "AnalogLect", + "ALect", + "Lect", + "WalkLect", + "MoveLect", + "MvoeLect", + "LwctA", + "LwctAnalog", + "AnalogLwctt", + "ALwctt", + "Lwctt", + "WalkLwctt", + "MoveLwctt", + "MvoeLwctt", + "AnalogLwct", + "ALwct", + "Lwct", + "WalkLwct", + "MoveLwct", + "MvoeLwct", + "LecyA", + "LecyAnalog", + "AnalogLecyt", + "ALecyt", + "Lecyt", + "WalkLecyt", + "MoveLecyt", + "MvoeLecyt", + "AnalogLecy", + "ALecy", + "Lecy", + "WalkLecy", + "MoveLecy", + "MvoeLecy", + "LwcyA", + "LwcyAnalog", + "AnalogLwcyt", + "ALwcyt", + "Lwcyt", + "WalkLwcyt", + "MoveLwcyt", + "MvoeLwcyt", + "AnalogLwcy", + "ALwcy", + "Lwcy", + "WalkLwcy", + "MoveLwcy", + "MvoeLwcy", + "LeftA", + "LeftAnalog", + "AnalogLwftt", + "ALwftt", + "Lwftt", + "WalkLwftt", + "MoveLwftt", + "MvoeLwftt", + "AnalogLwft", + "ALwft", + "Lwft", + "WalkLwft", + "MoveLwft", + "MvoeLwft", + "AnalogLweftt", + "ALweftt", + "Lweftt", + "WalkLweftt", + "MoveLweftt", + "MvoeLweftt", + "AnalogLweft", + "ALweft", + "Lweft", + "WalkLweft", + "MoveLweft", + "MvoeLweft", + "AnalogLewftt", + "ALewftt", + "Lewftt", + "WalkLewftt", + "MoveLewftt", + "MvoeLewftt", + "AnalogLewft", + "ALewft", + "Lewft", + "WalkLewft", + "MoveLewft", + "MvoeLewft", + "AnalogEftt", + "AEftt", + "Eftt", + "WalkEftt", + "MoveEftt", + "MvoeEftt", + "AnalogEft", + "AEft", + "Eft", + "WalkEft", + "MoveEft", + "MvoeEft", + "Analoglettt", + "Alettt", + "Lettt", + "Walklettt", + "Movelettt", + "Mvoelettt", + "Analoglett", + "Alett", + "Lett", + "Walklett", + "Movelett", + "Mvoelett", + "AnalogMeftt", + "AMeftt", + "Meftt", + "WalkMeftt", + "MoveMeftt", + "MvoeMeftt", + "AnalogMeft", + "AMeft", + "Meft", + "WalkMeft", + "MoveMeft", + "MvoeMeft", + "AnalogLftt", + "ALftt", + "Lftt", + "WalkLftt", + "MoveLftt", + "MvoeLftt", + "AnalogLft", + "ALft", + "Lft", + "WalkLft", + "MoveLft", + "MvoeLft", + "AKeft", + "Keft", + "AnalogEldtt", + "AEldtt", + "Eldtt", + "WalkEldtt", + "MoveEldtt", + "MvoeEldtt", + "AnalogElftt", + "AElftt", + "Elftt", + "AElgtt", + "Elgtt", + "WalkElftt", + "MoveElftt", + "MvoeElftt", + "AnalogEldt", + "AEldt", + "Eldt", + "WalkEldt", + "MoveEldt", + "MvoeEldt", + "AnalogElgft", + "AElgft", + "Elgft", + "WalkElgft", + "MoveElgft", + "MvoeElgft", + "AnalogElft", + "AElft", + "Elft", + "Eltf", + "AEltf", + "AElgy", + "Elgy", + "AElgt", + "Elgt", + "AEltg", + "Eltg", + "AElyg", + "Elyg", + "AElfy", + "Elfy", + "AElyf", + "Elyf", + "AElg", + "Elg", + "AElfg", + "Elfg", + "Elgf", + "AElgf", + "AElgg", + "Elgg", + "AElf", + "Elf", + "AElff", + "Elff", + "AElfr", + "Elfr", + "AElaft", + "Elaft", + "AElafy", + "Elafy", + "AElafg", + "Elafg", + "AElaf", + "Elaf", + "AElaff", + "Elaff", + "AElafr", + "Elafr", + "WalkElft", + "MoveElft", + "MvoeElft", + "AnalogLedtt", + "ALedtt", + "Ledtt", + "WalkLedtt", + "MoveLedtt", + "MvoeLedtt", + "Analogleftt", + "Aleftt", + "Leftt", + "Alegtt", + "Legtt", + "Walkleftt", + "Moveleftt", + "Mvoeleftt", + "AnalogLedt", + "ALedt", + "Ledt", + "WalkLedt", + "MoveLedt", + "MvoeLedt", + "AnalogLegft", + "ALegft", + "Legft", + "WalkLegft", + "MoveLegft", + "MvoeLegft", + "Analogleft", + "←", + "<=", + "A<=", + "Aleft", + "Left", + "AL", + "<", + "A<", + "<-", + "A<-", + "A←", + "A◄", + "◄", + "AWest", + "West", + "AW", + "W", + "Lfet", + "Letf", + "Alfet", + "Aletf", + "Alegy", + "Legy", + "Alegt", + "Legt", + "Aletg", + "Letg", + "Aleyg", + "Leyg", + "Alefy", + "Lefy", + "Aleyf", + "Leyf", + "Aleg", + "Leg", + "Alget", + "Lget", + "Algey", + "Lgey", + "Alfey", + "Lfey", + "ALrft", + "Lrft", + "Lfrt", + "Lrtf", + "ALfrt", + "ALrtf", + "ALrgy", + "Lrgy", + "ALrgt", + "Lrgt", + "ALrtg", + "Lrtg", + "ALryg", + "Lryg", + "ALrfy", + "Lrfy", + "ALryf", + "Lryf", + "ALrt", + "Lrt", + "ALrg", + "Lrg", + "ALgrt", + "Lgrt", + "ALgry", + "Lgry", + "ALfry", + "Lfry", + "ALeaf", + "Leaf", + "ALeaff", + "Leaff", + "ALeafr", + "Leafr", + "Walkleft", + "Moveleft", + "Mvoeleft", + "RightStickLeft", + "RightStickL", + "RStickLeft", + "RStickL", + "CameraStickLeft", + "CameraStickL", + "CamStickLeft", + "CamStickL", + "CStickLeft", + "CStickL", + "PeftCam", + "Cam-Peftt", + "CamPeftt", + "Cam-Peft", + "CamPeft", + "Cam≤=", + "Cam≤", + "Cam≤-", + "LestCam", + "Cam-Lestt", + "CamLestt", + "Cam-Lest", + "CamLest", + "LectCam", + "Cam-Lectt", + "CamLectt", + "Cam-Lect", + "CamLect", + "LwctCam", + "Cam-Lwctt", + "CamLwctt", + "Cam-Lwct", + "CamLwct", + "LecyCam", + "Cam-Lecyt", + "CamLecyt", + "Cam-Lecy", + "CamLecy", + "LwcyCam", + "Cam-Lwcyt", + "CamLwcyt", + "Cam-Lwcy", + "CamLwcy", + "LeftCam", + "Cam-Lwftt", + "CamLwftt", + "Cam-Lwft", + "CamLwft", + "Cam-Lweftt", + "CamLweftt", + "Cam-Lweft", + "CamLweft", + "Cam-Lewftt", + "CamLewftt", + "Cam-Lewft", + "CamLewft", + "Cam-Eftt", + "CamEftt", + "Cam-Eft", + "CamEft", + "Cam-lettt", + "Camlettt", + "Cam-lett", + "Camlett", + "Cam-Meftt", + "CamMeftt", + "Cam-Meft", + "CamMeft", + "Cam-Eldtt", + "CamEldtt", + "Cam-Elftt", + "CamElftt", + "CamElgtt", + "Cam-Eldt", + "CamEldt", + "Cam-Elgft", + "CamElgft", + "Cam-Elft", + "CamElft", + "CamEltf", + "CamElgy", + "CamElgt", + "CamEltg", + "CamElyg", + "CamElfy", + "CamElyf", + "CamElg", + "CamElfg", + "CamElgf", + "CamElgg", + "CamElf", + "CamElff", + "CamElfr", + "CamElaft", + "CamElafy", + "CamElafg", + "CamElaf", + "CamElaff", + "CamElafr", + "Cam-Ledtt", + "CamLedtt", + "Cam-leftt", + "Camleftt", + "Camlegtt", + "Cam-Ledt", + "CamLedt", + "Cam-Legft", + "CamLegft", + "Cam-left", + "Cam<=", + "Camleft", + "CamL", + "Cam<", + "Cam<-", + "Cam←", + "Cam◄", + "CamWest", + "CamW", + "Camlfet", + "Camletf", + "Camlegy", + "Camlegt", + "Camletg", + "Camleyg", + "Camlefy", + "Camleyf", + "Camleg", + "Camlget", + "Camlgey", + "Camlfey", + "CamLrft", + "CamLfrt", + "CamLrtf", + "CamLrgy", + "CamLrgt", + "CamLrtg", + "CamLryg", + "CamLrfy", + "CamLryf", + "CamLrt", + "CamLrg", + "CamLgrt", + "CamLgry", + "CamLfry", + "CamKeft", + "CamK", + "CamKfet", + "CamKetf", + "CamKegy", + "CamKegt", + "CamKetg", + "CamKeyg", + "CamKefy", + "CamKeyf", + "CamKet", + "CamKeg", + "CamKget", + "CamKgey", + "CamKfey", + "CamKrft", + "CamKfrt", + "CamKrtf", + "CamKrgy", + "CamKrgt", + "CamKrtg", + "CamKryg", + "CamKrfy", + "CamKryf", + "CamKrt", + "CamKrg", + "CamKgrt", + "CamKgry", + "CamKfry", + "Camlefg", + "CamWesg", + "Camlfeg", + "Camlegf", + "Camlegg", + "Camlgeg", + "CamLrfg", + "CamLfrg", + "CamLrgf", + "CamLrgg", + "CamLgrg", + "CamKefg", + "CamKfeg", + "CamKegf", + "CamKegg", + "CamKgeg", + "CamKrfg", + "CamKfrg", + "CamKrgf", + "CamKrgg", + "CamKgrg", + "CamLef", + "CamLeff", + "CamLefr", + "Camleaft", + "Camleafy", + "CamKeaft", + "CamKeafy", + "Camleafg", + "CamKeafg", + "CamLeaf", + "CamLeaff", + "CamLeafr", + "PeftC", + "PeftCamera", + "C-Peftt", + "Camera-Peftt", + "CPeftt", + "CameraPeftt", + "C-Peft", + "Camera-Peft", + "CPeft", + "CameraPeft", + "C≤=", + "Camera≤=", + "C≤", + "C≤-", + "Camera≤", + "Camera≤-", + "LestC", + "LestCamera", + "C-Lestt", + "Camera-Lestt", + "CLestt", + "CameraLestt", + "C-Lest", + "Camera-Lest", + "CLest", + "CameraLest", + "LectC", + "LectCamera", + "C-Lectt", + "Camera-Lectt", + "CLectt", + "CameraLectt", + "C-Lect", + "Camera-Lect", + "CLect", + "CameraLect", + "LwctC", + "LwctCamera", + "C-Lwctt", + "Camera-Lwctt", + "CLwctt", + "CameraLwctt", + "C-Lwct", + "Camera-Lwct", + "CLwct", + "CameraLwct", + "LecyC", + "LecyCamera", + "C-Lecyt", + "Camera-Lecyt", + "CLecyt", + "CameraLecyt", + "C-Lecy", + "Camera-Lecy", + "CLecy", + "CameraLecy", + "LwcyC", + "LwcyCamera", + "C-Lwcyt", + "Camera-Lwcyt", + "CLwcyt", + "CameraLwcyt", + "C-Lwcy", + "Camera-Lwcy", + "CLwcy", + "CameraLwcy", + "LeftC", + "LeftCamera", + "C-Lwftt", + "Camera-Lwftt", + "CLwftt", + "CameraLwftt", + "C-Lwft", + "Camera-Lwft", + "CLwft", + "CameraLwft", + "C-Lweftt", + "Camera-Lweftt", + "CLweftt", + "CameraLweftt", + "C-Lweft", + "Camera-Lweft", + "CLweft", + "CameraLweft", + "C-Lewftt", + "Camera-Lewftt", + "CLewftt", + "CameraLewftt", + "C-Lewft", + "Camera-Lewft", + "CLewft", + "CameraLewft", + "C-Eftt", + "Camera-Eftt", + "CEftt", + "CameraEftt", + "C-Eft", + "Camera-Eft", + "CEft", + "CameraEft", + "C-lettt", + "Camera-lettt", + "Clettt", + "Cameralettt", + "C-lett", + "Camera-lett", + "Clett", + "Cameralett", + "C-Meftt", + "Camera-Meftt", + "CMeftt", + "CameraMeftt", + "C-Meft", + "Camera-Meft", + "CMeft", + "CameraMeft", + "C-Eldtt", + "Camera-Eldtt", + "CEldtt", + "CameraEldtt", + "C-Elftt", + "Camera-Elftt", + "CElftt", + "CElgtt", + "CameraElftt", + "CameraElgtt", + "C-Eldt", + "Camera-Eldt", + "CEldt", + "CameraEldt", + "C-Elgft", + "Camera-Elgft", + "CElgft", + "CameraElgft", + "C-Elft", + "Camera-Elft", + "CElft", + "CEltf", + "CElgy", + "CElgt", + "CEltg", + "CElyg", + "CElfy", + "CElyf", + "CElg", + "CElfg", + "CElgf", + "CElgg", + "CElf", + "CElff", + "CElfr", + "CElaft", + "CElafy", + "CElafg", + "CElaf", + "CElaff", + "CElafr", + "CameraElft", + "CameraEltf", + "CameraElgy", + "CameraElgt", + "CameraEltg", + "CameraElyg", + "CameraElfy", + "CameraElyf", + "CameraElg", + "CameraElfg", + "CameraElgf", + "CameraElgg", + "CameraElf", + "CameraElff", + "CameraElfr", + "CameraElaft", + "CameraElafy", + "CameraElafg", + "CameraElaf", + "CameraElaff", + "CameraElafr", + "C-Ledtt", + "Camera-Ledtt", + "CLedtt", + "CameraLedtt", + "C-leftt", + "Camera-leftt", + "Cleftt", + "Clegtt", + "Cameraleftt", + "Cameralegtt", + "C-Ledt", + "Camera-Ledt", + "CLedt", + "CameraLedt", + "C-Legft", + "Camera-Legft", + "CLegft", + "CameraLegft", + "C-left", + "Camera-left", + "C<=", + "Camera<=", + "Cleft", + "CL", + "C<", + "C<-", + "C←", + "C◄", + "CWest", + "CW", + "Clfet", + "Cletf", + "Clegy", + "Clegt", + "Cletg", + "Cleyg", + "Clefy", + "Cleyf", + "Cleg", + "Clget", + "Clgey", + "Clfey", + "CLrft", + "CLfrt", + "CLrtf", + "CLrgy", + "CLrgt", + "CLrtg", + "CLryg", + "CLrfy", + "CLryf", + "CLrt", + "CLrg", + "CLgrt", + "CLgry", + "CLfry", + "CKeft", + "CK", + "CKfet", + "CKetf", + "CKegy", + "CKegt", + "CKetg", + "CKeyg", + "CKefy", + "CKeyf", + "CKet", + "CKeg", + "CKget", + "CKgey", + "CKfey", + "CKrft", + "CKfrt", + "CKrtf", + "CKrgy", + "CKrgt", + "CKrtg", + "CKryg", + "CKrfy", + "CKryf", + "CKrt", + "CKrg", + "CKgrt", + "CKgry", + "CKfry", + "CLef", + "CLeff", + "CLefr", + "Cleaft", + "Cleafy", + "CKeaft", + "CKeafy", + "Cleafg", + "CKeafg", + "CLeaf", + "CLeaff", + "CLeafr", + "Cameraleft", + "CameraL", + "Camera<", + "Camera<-", + "Camera←", + "Camera◄", + "CameraWest", + "CameraW", + "Cameralfet", + "Cameraletf", + "Cameralegy", + "Cameralegt", + "Cameraletg", + "Cameraleyg", + "Cameralefy", + "Cameraleyf", + "Cameraleg", + "Cameralget", + "Cameralgey", + "Cameralfey", + "CameraLrft", + "CameraLfrt", + "CameraLrtf", + "CameraLrgy", + "CameraLrgt", + "CameraLrtg", + "CameraLryg", + "CameraLrfy", + "CameraLryf", + "CameraLrt", + "CameraLrg", + "CameraLgrt", + "CameraLgry", + "CameraLfry", + "CameraKeft", + "CameraK", + "CameraKfet", + "CameraKetf", + "CameraKegy", + "CameraKegt", + "CameraKetg", + "CameraKeyg", + "CameraKefy", + "CameraKeyf", + "CameraKet", + "CameraKeg", + "CameraKget", + "CameraKgey", + "CameraKfey", + "CameraKrft", + "CameraKfrt", + "CameraKrtf", + "CameraKrgy", + "CameraKrgt", + "CameraKrtg", + "CameraKryg", + "CameraKrfy", + "CameraKryf", + "CameraKrt", + "CameraKrg", + "CameraKgrt", + "CameraKgry", + "CameraKfry", + "Cameralefg", + "CameraWesg", + "Cameralfeg", + "Cameralegf", + "Cameralegg", + "Cameralgeg", + "CameraLrfg", + "CameraLfrg", + "CameraLrgf", + "CameraLrgg", + "CameraLgrg", + "CameraKefg", + "CameraKfeg", + "CameraKegf", + "CameraKegg", + "CameraKgeg", + "CameraKrfg", + "CameraKfrg", + "CameraKrgf", + "CameraKrgg", + "CameraKgrg", + "CameraLef", + "CameraLeff", + "CameraLefr", + "Cameraleaft", + "Cameraleafy", + "CameraKeaft", + "CameraKeafy", + "Cameraleafg", + "CameraKeafg", + "CameraLeaf", + "CameraLeaff", + "CameraLeafr" + ], + "color_value": "#C7C7C7", + "is_blacklisted": false, + "opposite_input_value": "0x00407F7F7F7F0000L", + "opposite_input_name": ">", + "has_opposite": true, + "input_type": 1, + "keyboard_value": 127, + "keyboard_key_name": "Delete" + }, + { + "input_value": "0x00007F7F007F0000L", + "input_name": "P<", + "input_alias": [ + "PointerStickLeft", + "PointerStickL", + "PointStickLeft", + "PointStickL", + "PeftPoint", + "Point-Peftt", + "PointPeftt", + "Point-Peft", + "PointPeft", + "Point≤=", + "Point≤", + "Point≤-", + "LestPoint", + "Point-Lestt", + "PointLestt", + "Point-Lest", + "PointLest", + "LectPoint", + "Point-Lectt", + "PointLectt", + "Point-Lect", + "PointLect", + "LwctPoint", + "Point-Lwctt", + "PointLwctt", + "Point-Lwct", + "PointLwct", + "LecyPoint", + "Point-Lecyt", + "PointLecyt", + "Point-Lecy", + "PointLecy", + "LwcyPoint", + "Point-Lwcyt", + "PointLwcyt", + "Point-Lwcy", + "PointLwcy", + "LeftPoint", + "Point-Lwftt", + "PointLwftt", + "Point-Lwft", + "PointLwft", + "Point-Lweftt", + "PointLweftt", + "Point-Lweft", + "PointLweft", + "Point-Lewftt", + "PointLewftt", + "Point-Lewft", + "PointLewft", + "Point-Eftt", + "PointEftt", + "Point-Eft", + "PointEft", + "Point-lettt", + "Pointlettt", + "Point-lett", + "Pointlett", + "Point-Meftt", + "PointMeftt", + "Point-Meft", + "PointMeft", + "Point-Eldtt", + "PointEldtt", + "Point-Elftt", + "PointElftt", + "PointElgtt", + "Point-Eldt", + "PointEldt", + "Point-Elgft", + "PointElgft", + "Point-Elft", + "PointElft", + "PointEltf", + "PointElgy", + "PointElgt", + "PointEltg", + "PointElyg", + "PointElfy", + "PointElyf", + "PointElg", + "PointElfg", + "PointElgf", + "PointElgg", + "PointElf", + "PointElff", + "PointElfr", + "PointElaft", + "PointElafy", + "PointElafg", + "PointElaf", + "PointElaff", + "PointElafr", + "Point-Ledtt", + "PointLedtt", + "Point-leftt", + "Pointleftt", + "Pointlegtt", + "Point-Ledt", + "PointLedt", + "Point-Legft", + "PointLegft", + "Point-left", + "Point<=", + "Pointleft", + "PointL", + "Point<", + "Point<-", + "Point←", + "Point◄", + "PointWest", + "PointW", + "Pointlfet", + "Pointletf", + "Pointlegy", + "Pointlegt", + "Pointletg", + "Pointleyg", + "Pointlefy", + "Pointleyf", + "Pointleg", + "Pointlget", + "Pointlgey", + "Pointlfey", + "PointLrft", + "PointLfrt", + "PointLrtf", + "PointLrgy", + "PointLrgt", + "PointLrtg", + "PointLryg", + "PointLrfy", + "PointLryf", + "PointLrt", + "PointLrg", + "PointLgrt", + "PointLgry", + "PointLfry", + "PointKeft", + "PointK", + "PointKfet", + "PointKetf", + "PointKegy", + "PointKegt", + "PointKetg", + "PointKeyg", + "PointKefy", + "PointKeyf", + "PointKet", + "PointKeg", + "PointKget", + "PointKgey", + "PointKfey", + "PointKrft", + "PointKfrt", + "PointKrtf", + "PointKrgy", + "PointKrgt", + "PointKrtg", + "PointKryg", + "PointKrfy", + "PointKryf", + "PointKrt", + "PointKrg", + "PointKgrt", + "PointKgry", + "PointKfry", + "Pointlefg", + "PointWesg", + "Pointlfeg", + "Pointlegf", + "Pointlegg", + "Pointlgeg", + "PointLrfg", + "PointLfrg", + "PointLrgf", + "PointLrgg", + "PointLgrg", + "PointKefg", + "PointKfeg", + "PointKegf", + "PointKegg", + "PointKgeg", + "PointKrfg", + "PointKfrg", + "PointKrgf", + "PointKrgg", + "PointKgrg", + "PointLef", + "PointLeff", + "PointLefr", + "Pointleaft", + "Pointleafy", + "PointKeaft", + "PointKeafy", + "Pointleafg", + "PointKeafg", + "PointLeaf", + "PointLeaff", + "PointLeafr", + "PeftPointer", + "Pointer-Peftt", + "PointerPeftt", + "Pointer-Peft", + "PointerPeft", + "Pointer≤=", + "Pointer≤", + "Pointer≤-", + "LestPointer", + "Pointer-Lestt", + "PointerLestt", + "Pointer-Lest", + "PointerLest", + "LectPointer", + "Pointer-Lectt", + "PointerLectt", + "Pointer-Lect", + "PointerLect", + "LwctPointer", + "Pointer-Lwctt", + "PointerLwctt", + "Pointer-Lwct", + "PointerLwct", + "LecyPointer", + "Pointer-Lecyt", + "PointerLecyt", + "Pointer-Lecy", + "PointerLecy", + "LwcyPointer", + "Pointer-Lwcyt", + "PointerLwcyt", + "Pointer-Lwcy", + "PointerLwcy", + "LeftPointer", + "Pointer-Lwftt", + "PointerLwftt", + "Pointer-Lwft", + "PointerLwft", + "Pointer-Lweftt", + "PointerLweftt", + "Pointer-Lweft", + "PointerLweft", + "Pointer-Lewftt", + "PointerLewftt", + "Pointer-Lewft", + "PointerLewft", + "Pointer-Eftt", + "PointerEftt", + "Pointer-Eft", + "PointerEft", + "Pointer-lettt", + "Pointerlettt", + "Pointer-lett", + "Pointerlett", + "Pointer-Meftt", + "PointerMeftt", + "Pointer-Meft", + "PointerMeft", + "Pointer-Eldtt", + "PointerEldtt", + "Pointer-Elftt", + "PointerElftt", + "PointerElgtt", + "Pointer-Eldt", + "PointerEldt", + "Pointer-Elgft", + "PointerElgft", + "Pointer-Elft", + "PointerElft", + "PointerEltf", + "PointerElgy", + "PointerElgt", + "PointerEltg", + "PointerElyg", + "PointerElfy", + "PointerElyf", + "PointerElg", + "PointerElfg", + "PointerElgf", + "PointerElgg", + "PointerElf", + "PointerElff", + "PointerElfr", + "PointerElaft", + "PointerElafy", + "PointerElafg", + "PointerElaf", + "PointerElaff", + "PointerElafr", + "Pointer-Ledtt", + "PointerLedtt", + "Pointer-leftt", + "Pointerleftt", + "Pointerlegtt", + "Pointer-Ledt", + "PointerLedt", + "Pointer-Legft", + "PointerLegft", + "Pointer-left", + "Pointer<=", + "Pointerleft", + "PointerL", + "Pointer<", + "Pointer<-", + "Pointer←", + "Pointer◄", + "PointerWest", + "PointerW", + "Pointerlfet", + "Pointerletf", + "Pointerlegy", + "Pointerlegt", + "Pointerletg", + "Pointerleyg", + "Pointerlefy", + "Pointerleyf", + "Pointerleg", + "Pointerlget", + "Pointerlgey", + "Pointerlfey", + "PointerLrft", + "PointerLfrt", + "PointerLrtf", + "PointerLrgy", + "PointerLrgt", + "PointerLrtg", + "PointerLryg", + "PointerLrfy", + "PointerLryf", + "PointerLrt", + "PointerLrg", + "PointerLgrt", + "PointerLgry", + "PointerLfry", + "PointerKeft", + "PointerK", + "PointerKfet", + "PointerKetf", + "PointerKegy", + "PointerKegt", + "PointerKetg", + "PointerKeyg", + "PointerKefy", + "PointerKeyf", + "PointerKet", + "PointerKeg", + "PointerKget", + "PointerKgey", + "PointerKfey", + "PointerKrft", + "PointerKfrt", + "PointerKrtf", + "PointerKrgy", + "PointerKrgt", + "PointerKrtg", + "PointerKryg", + "PointerKrfy", + "PointerKryf", + "PointerKrt", + "PointerKrg", + "PointerKgrt", + "PointerKgry", + "PointerKfry", + "Pointerlefg", + "PointerWesg", + "Pointerlfeg", + "Pointerlegf", + "Pointerlegg", + "Pointerlgeg", + "PointerLrfg", + "PointerLfrg", + "PointerLrgf", + "PointerLrgg", + "PointerLgrg", + "PointerKefg", + "PointerKfeg", + "PointerKegf", + "PointerKegg", + "PointerKgeg", + "PointerKrfg", + "PointerKfrg", + "PointerKrgf", + "PointerKrgg", + "PointerKgrg", + "PointerLef", + "PointerLeff", + "PointerLefr", + "Pointerleaft", + "Pointerleafy", + "PointerKeaft", + "PointerKeafy", + "Pointerleafg", + "PointerKeafg", + "PointerLeaf", + "PointerLeaff", + "PointerLeafr", + "PStickLeft", + "PStickL", + "PeftC", + "P-Peftt", + "PPeftt", + "P-Peft", + "PPeft", + "P≤=", + "P≤", + "P≤-", + "P-Lestt", + "PLestt", + "P-Lest", + "PLest", + "P-Lectt", + "PLectt", + "P-Lect", + "PLect", + "P-Lwctt", + "PLwctt", + "P-Lwct", + "PLwct", + "P-Lecyt", + "PLecyt", + "P-Lecy", + "PLecy", + "P-Lwcyt", + "PLwcyt", + "P-Lwcy", + "PLwcy", + "P-Lwftt", + "PLwftt", + "P-Lwft", + "PLwft", + "P-Lweftt", + "PLweftt", + "P-Lweft", + "PLweft", + "P-Lewftt", + "PLewftt", + "P-Lewft", + "PLewft", + "P-Eftt", + "PEftt", + "P-Eft", + "PEft", + "P-lettt", + "Plettt", + "P-lett", + "Plett", + "P-Meftt", + "PMeftt", + "P-Meft", + "PMeft", + "P-Eldtt", + "PEldtt", + "P-Elftt", + "PElftt", + "PElgtt", + "P-Eldt", + "PEldt", + "P-Elgft", + "PElgft", + "P-Elft", + "PElft", + "PEltf", + "PElgy", + "PElgt", + "PEltg", + "PElyg", + "PElfy", + "PElyf", + "PElg", + "PElfg", + "PElgf", + "PElgg", + "PElf", + "PElff", + "PElfr", + "PElaft", + "PElafy", + "PElafg", + "PElaf", + "PElaff", + "PElafr", + "P-Ledtt", + "PLedtt", + "P-leftt", + "Pleftt", + "Plegtt", + "P-Ledt", + "PLedt", + "P-Legft", + "PLegft", + "P-left", + "P<=", + "Pleft", + "PL", + "P<", + "P<-", + "P←", + "P◄", + "PWest", + "PW", + "Plfet", + "Pletf", + "Plegy", + "Plegt", + "Pletg", + "Pleyg", + "Plefy", + "Pleyf", + "Pleg", + "Plget", + "Plgey", + "Plfey", + "PLrft", + "PLfrt", + "PLrtf", + "PLrgy", + "PLrgt", + "PLrtg", + "PLryg", + "PLrfy", + "PLryf", + "PLrt", + "PLrg", + "PLgrt", + "PLgry", + "PLfry", + "PKeft", + "PK", + "PKfet", + "PKetf", + "PKegy", + "PKegt", + "PKetg", + "PKeyg", + "PKefy", + "PKeyf", + "PKet", + "PKeg", + "PKget", + "PKgey", + "PKfey", + "PKrft", + "PKfrt", + "PKrtf", + "PKrgy", + "PKrgt", + "PKrtg", + "PKryg", + "PKrfy", + "PKryf", + "PKrt", + "PKrg", + "PKgrt", + "PKgry", + "PKfry", + "PLef", + "PLeff", + "PLefr", + "Pleaft", + "Pleafy", + "PKeaft", + "PKeafy", + "Pleafg", + "PKeafg", + "PLeaf", + "PLeaff", + "PLeafr", + "LestC", + "LectC", + "LwctC", + "LecyC", + "LwcyC", + "LeftC" + ], + "color_value": "#FFE400", + "is_blacklisted": false, + "opposite_input_value": "0x00007F7FFF7F0000L", + "opposite_input_name": "P>", + "has_opposite": true, + "input_type": 2, + "keyboard_value": 37, + "keyboard_key_name": "ArrowLeft" + }, + { + "input_value": "0x00007F7FFF7F0000L", + "input_name": "P>", + "input_alias": [ + "PointerStickRight", + "PointerStickR", + "PointStickRight", + "PointStickR", + "PStickRight", + "PStickR", + "Point=≥", + "Point≥", + "Point-≥", + "RigfhtPoint", + "Point-Rigfht", + "PointRigfht", + "PointRigfhty", + "RifghtPoint", + "Point-Rifght", + "PointRifght", + "PointRifghty", + "RigfthPoint", + "Point-Rigfth", + "PointRigfth", + "PointRigfthy", + "RifgthPoint", + "Point-Rifgth", + "PointRifgth", + "PointRifgthy", + "Point-Rugh", + "PointRugh", + "PointRughy", + "RightPoint", + "Point-Rught", + "PointRught", + "PointRughty", + "Point-Rifgt", + "PointRifgt", + "PointRifgty", + "Point-Righg", + "PointRighg", + "PointRighgy", + "Point-Righr", + "PointRighr", + "PointRighry", + "Point-Rig", + "PointRig", + "Point-rigt", + "Pointrigt", + "PointRigty", + "PointRigy", + "Point-Fifht", + "PointFifht", + "PointFifhty", + "Point-rifht", + "PointTifht", + "PointEifht", + "Pointrifht", + "PointRofht", + "PointRfht", + "PointRifhty", + "PointIefht", + "PointRuifht", + "PointRiufht", + "PointIrfht", + "Point-Rogjt", + "PointRogjt", + "PointRogjty", + "Point-Rihgy", + "PointRihgy", + "PointRihgyy", + "Point-Rivht", + "PointRivht", + "PointRivhty", + "Point-Rigtt", + "PointRigtt", + "PointRigtty", + "PointRi", + "Point-Ri", + "Point-Rihgt", + "PointRihgt", + "PointRihgty", + "Point-Rigth", + "PointRigth", + "PointRigthy", + "PointEash", + "Point-Figh", + "PointFigh", + "Point-Fight", + "PointFight", + "PointFighty", + "PointFighy", + "Point-Righ", + "PointRigh", + "Point-right", + "Point=>", + "PointTight", + "PointEight", + "Pointright", + "PointR", + "Point>", + "Point->", + "Point→", + "PointEast", + "PointE", + "Point►", + "PointRigjt", + "PointRoght", + "PointRght", + "PointRighty", + "PointRighy", + "PointIeght", + "PointRuight", + "PointRiught", + "PointIrght", + "P=≥", + "Pointer=≥", + "P≥", + "P-≥", + "Pointer≥", + "Pointer-≥", + "RigfhtP", + "RigfhtPointer", + "P-Rigfht", + "Pointer-Rigfht", + "PRigfht", + "PointerRigfht", + "PRigfhty", + "PointerRigfhty", + "RifghtP", + "RifghtPointer", + "P-Rifght", + "Pointer-Rifght", + "PRifght", + "PointerRifght", + "PRifghty", + "PointerRifghty", + "RigfthP", + "RigfthPointer", + "P-Rigfth", + "Pointer-Rigfth", + "PRigfth", + "PointerRigfth", + "PRigfthy", + "PointerRigfthy", + "RifgthP", + "RifgthPointer", + "P-Rifgth", + "Pointer-Rifgth", + "PRifgth", + "PointerRifgth", + "PRifgthy", + "PointerRifgthy", + "P-Rugh", + "Pointer-Rugh", + "PRugh", + "PointerRugh", + "PRughy", + "PointerRughy", + "RightP", + "RightPointer", + "P-Rught", + "Pointer-Rught", + "PRught", + "PointerRught", + "PRughty", + "PointerRughty", + "P-Rifgt", + "Pointer-Rifgt", + "PRifgt", + "PointerRifgt", + "PRifgty", + "PointerRifgty", + "P-Righg", + "Pointer-Righg", + "PRighg", + "PointerRighg", + "PRighgy", + "PointerRighgy", + "P-Righr", + "Pointer-Righr", + "PRighr", + "PointerRighr", + "PRighry", + "PointerRighry", + "P-Rig", + "Pointer-Rig", + "PRig", + "PointerRig", + "P-rigt", + "Pointer-rigt", + "Prigt", + "Pointerrigt", + "PRigty", + "PointerRigty", + "PRigy", + "PointerRigy", + "P-Fifht", + "Pointer-Fifht", + "PFifht", + "PointerFifht", + "PFifhty", + "PointerFifhty", + "P-rifht", + "Pointer-rifht", + "PTifht", + "PointerTifht", + "PEifht", + "PointerEifht", + "Prifht", + "Pointerrifht", + "PRofht", + "PointerRofht", + "PRfht", + "PointerRfht", + "PRifhty", + "PointerRifhty", + "PIefht", + "PointerIefht", + "PRuifht", + "PointerRuifht", + "PRiufht", + "PointerRiufht", + "PIrfht", + "PointerIrfht", + "P-Rogjt", + "Pointer-Rogjt", + "PRogjt", + "PointerRogjt", + "PRogjty", + "PointerRogjty", + "P-Rihgy", + "Pointer-Rihgy", + "PRihgy", + "PointerRihgy", + "PRihgyy", + "PointerRihgyy", + "P-Rivht", + "Pointer-Rivht", + "PRivht", + "PointerRivht", + "PRivhty", + "PointerRivhty", + "P-Rigtt", + "Pointer-Rigtt", + "PRigtt", + "PointerRigtt", + "PRigtty", + "PointerRigtty", + "PRi", + "PointerRi", + "P-Ri", + "Pointer-Ri", + "P-Rihgt", + "Pointer-Rihgt", + "PRihgt", + "PointerRihgt", + "PRihgty", + "PointerRihgty", + "P-Rigth", + "Pointer-Rigth", + "PRigth", + "PointerRigth", + "PRigthy", + "PointerRigthy", + "PEash", + "PointerEash", + "P-Figh", + "Pointer-Figh", + "PFigh", + "PointerFigh", + "P-Fight", + "Pointer-Fight", + "PFight", + "PointerFight", + "PFighty", + "PointerFighty", + "PFighy", + "PointerFighy", + "P-Righ", + "Pointer-Righ", + "PRigh", + "PointerRigh", + "P-right", + "Pointer-right", + "P=>", + "Pointer=>", + "PTight", + "PointerTight", + "PEight", + "PointerEight", + "Pright", + "PR", + "P>", + "P->", + "P→", + "PEast", + "PE", + "P►", + "Pointerright", + "PointerR", + "Pointer>", + "Pointer->", + "Pointer→", + "PointerEast", + "PointerE", + "Pointer►", + "PRigjt", + "PointerRigjt", + "PRoght", + "PointerRoght", + "PRght", + "PointerRght", + "PRighty", + "PointerRighty", + "PRighy", + "PointerRighy", + "PIeght", + "PointerIeght", + "PRuight", + "PointerRuight", + "PRiught", + "PointerRiught", + "PIrght", + "PointerIrght" + ], + "color_value": "#FFE400", + "is_blacklisted": false, + "opposite_input_value": "0x00007F7F007F0000L", + "opposite_input_name": "P<", + "has_opposite": true, + "input_type": 2, + "keyboard_value": 39, + "keyboard_key_name": "ArrowRight" + }, + { + "input_value": "0x00007F7F7F000000L", + "input_name": "P^", + "input_alias": [ + "PointerStickUp", + "PointerStickU", + "PointStickUp", + "PointStickU", + "PointFprwrddJp", + "PointFprwrdfJp", + "PointFprwrdJp", + "PointFprwrdsJp", + "PointFprwrJp", + "PointFprwrsJp", + "PointFprwrssJp", + "PointFprwarddJp", + "PointFprwardfJp", + "PointFprwardJp", + "PointFprwardsJp", + "PointFprwarJp", + "PointFprwarsJp", + "PointFprwarssJp", + "PointFprwordJp", + "PointFprwordsJp", + "PointFprworJp", + "PointFprworsJp", + "PointFprworssJp", + "PointFprwrddU0", + "PointFprwrdfU0", + "PointFprwrdU0", + "PointFprwrdsU0", + "PointFprwrU0", + "PointFprwrsU0", + "PointFprwrssU0", + "PointFprwrddU[", + "PointFprwrdfU[", + "PointFprwrdU[", + "PointFprwrdsU[", + "PointFprwrU[", + "PointFprwrsU[", + "PointFprwrssU[", + "PointFprwrddup", + "PointFprwrdfup", + "PointFprwrdup", + "PointFprwrdsup", + "PointFprwrup", + "PointFprwrsup", + "PointFprwrssup", + "PointFFprwrdd", + "PointFFprwrdf", + "PointFFprwrd", + "PointFFprwrds", + "PointFFprwr", + "PointFFprwrs", + "PointFFprwrss", + "PointFprwrdd", + "PointFprwrdf", + "PointFprwrd", + "PointFprwrds", + "PointFprwr", + "PointFprwrs", + "PointFprwrss", + "PointFpwrd", + "PointFpwrds", + "PointFpwr", + "PointFpwrs", + "PointFpwrss", + "PointFprwarddU0", + "PointFprwardfU0", + "PointFprwardU0", + "PointFprwardsU0", + "PointFprwarU0", + "PointFprwarsU0", + "PointFprwarssU0", + "PointFprwordU0", + "PointFprwordsU0", + "PointFprworU0", + "PointFprworsU0", + "PointFprworssU0", + "PointFprwarddU[", + "PointFprwardfU[", + "PointFprwardU[", + "PointFprwardsU[", + "PointFprwarU[", + "PointFprwarsU[", + "PointFprwarssU[", + "PointFprwordU[", + "PointFprwordsU[", + "PointFprworU[", + "PointFprworsU[", + "PointFprworssU[", + "PointFprwarddup", + "PointFprwardfup", + "PointFprwardup", + "PointFprwardsup", + "PointFprwarup", + "PointFprwarsup", + "PointFprwarssup", + "PointFprwordup", + "PointFprwordsup", + "PointFprworup", + "PointFprworsup", + "PointFprworssup", + "PointFFprwardd", + "PointFFprwardf", + "PointFFprward", + "PointFFprwards", + "PointFFprwar", + "PointFFprwars", + "PointFFprwarss", + "PointFFprword", + "PointFFprwords", + "PointFFprwor", + "PointFFprwors", + "PointFFprworss", + "PointFprwardd", + "PointFprwardf", + "PointFprward", + "PointFprwards", + "PointFprwar", + "PointFprwars", + "PointFprwarss", + "PointFprword", + "PointFprwords", + "PointFprwor", + "PointFprwors", + "PointFprworss", + "PointFpword", + "PointFpwords", + "PointFpwor", + "PointFpwors", + "PointFpworss", + "PointFpward", + "PointFpwards", + "PointFpwar", + "PointFpwars", + "PointFpwarss", + "UpPoint", + "PointForwrddJp", + "PointForwrdfJp", + "PointForwrdJp", + "PointForwrdsJp", + "PointForwrJp", + "PointForwrsJp", + "PointForwrssJp", + "PointForwarddJp", + "PointForwardfJp", + "PointForwardJp", + "PointForwardsJp", + "PointForwarJp", + "PointForwarsJp", + "PointForwarssJp", + "PointForwordJp", + "PointForwordsJp", + "PointForworJp", + "PointForworsJp", + "PointForworssJp", + "Point-Jp", + "PointJp", + "PointJpo", + "PointJpp", + "PointJppo", + "PointNort", + "PointForwrddU0", + "PointForwrdfU0", + "PointForwrdU0", + "PointForwrdsU0", + "PointForwrU0", + "PointForwrsU0", + "PointForwrssU0", + "PointForwrddU[", + "PointForwrdfU[", + "PointForwrdU[", + "PointForwrdsU[", + "PointForwrU[", + "PointForwrsU[", + "PointForwrssU[", + "PointForwrddup", + "PointForwrdfup", + "PointForwrdup", + "PointForwrdsup", + "PointForwrup", + "PointForwrsup", + "PointForwrssup", + "PointFforwrdd", + "PointFforwrdf", + "PointFforwrd", + "PointFforwrds", + "PointFforwr", + "PointFforwrs", + "PointFforwrss", + "PointFirwrdd", + "PointFirwrdf", + "PointFirwrd", + "PointFirwrds", + "PointFirwr", + "PointFirwrs", + "PointFirwrss", + "PointFrwrdd", + "PointFrwrdf", + "PointFrwrd", + "PointFrwrds", + "PointFrwr", + "PointFrwrs", + "PointFrwrss", + "PointForwrdd", + "PointForwrdf", + "PointForwrd", + "PointForwrds", + "PointForwr", + "PointForwrs", + "PointForwrss", + "PointFowrd", + "PointFowrds", + "PointFowr", + "PointFowrs", + "PointFowrss", + "PointNorht", + "PointForwarddU0", + "PointForwardfU0", + "PointForwardU0", + "PointForwardsU0", + "PointForwarU0", + "PointForwarsU0", + "PointForwarssU0", + "PointForwordU0", + "PointForwordsU0", + "PointForworU0", + "PointForworsU0", + "PointForworssU0", + "Point-U0", + "PointU0", + "PointU0o", + "PointU0p", + "PointU0po", + "PointForwarddU[", + "PointForwardfU[", + "PointForwardU[", + "PointForwardsU[", + "PointForwarU[", + "PointForwarsU[", + "PointForwarssU[", + "PointForwordU[", + "PointForwordsU[", + "PointForworU[", + "PointForworsU[", + "PointForworssU[", + "Point-U[", + "PointU[", + "PointU[o", + "PointU[p", + "PointU[po", + "PointForwarddup", + "PointForwardfup", + "PointForwardup", + "PointForwardsup", + "PointForwarup", + "PointForwarsup", + "PointForwarssup", + "PointForwordup", + "PointForwordsup", + "PointForworup", + "PointForworsup", + "PointForworssup", + "PointFforwardd", + "PointFforwardf", + "PointFforward", + "PointFforwards", + "PointFforwar", + "PointFforwars", + "PointFforwarss", + "PointFforword", + "PointFforwords", + "PointFforwor", + "PointFforwors", + "PointFforworss", + "PointFirwardd", + "PointFirwardf", + "PointFirward", + "PointFirwards", + "PointFirwar", + "PointFirwars", + "PointFirwarss", + "PointFirword", + "PointFirwords", + "PointFirwor", + "PointFirwors", + "PointFirworss", + "PointFrwardd", + "PointFrwardf", + "PointFrward", + "PointFrwards", + "PointFrwar", + "PointFrwars", + "PointFrwarss", + "PointFrword", + "PointFrwords", + "PointFrwor", + "PointFrwors", + "PointFrworss", + "PointForwardd", + "PointForwardf", + "Point-up", + "Pointup", + "PointU", + "Point^", + "Point↑", + "Point▲", + "PointNorth", + "PointN", + "PointUo", + "PointUpo", + "PointUop", + "PointUopo", + "PointYp", + "PointY", + "PointYo", + "PointYpo", + "PointYop", + "PointYopo", + "PointIp", + "PointI", + "PointIo", + "PointIpo", + "PointIop", + "PointIopo", + "Pointupp", + "PointUppo", + "PointUopp", + "PointUoppo", + "PointYpp", + "PointYppo", + "PointYopp", + "PointYoppo", + "PointIpp", + "PointIppo", + "PointIopp", + "PointIoppo", + "PointNoth", + "PointForward", + "PointForwards", + "PointFront", + "PointForwar", + "PointForwars", + "PointForwarss", + "PointForword", + "PointForwords", + "PointForwor", + "PointForwors", + "PointForworss", + "PointFoword", + "PointFowords", + "PointFowor", + "PointFowors", + "PointFoworss", + "PointFoward", + "PointFowards", + "PointFowar", + "PointFowars", + "PointFowarss", + "PointerFprwrddJp", + "PointerFprwrdfJp", + "PointerFprwrdJp", + "PointerFprwrdsJp", + "PointerFprwrJp", + "PointerFprwrsJp", + "PointerFprwrssJp", + "PointerFprwarddJp", + "PointerFprwardfJp", + "PointerFprwardJp", + "PointerFprwardsJp", + "PointerFprwarJp", + "PointerFprwarsJp", + "PointerFprwarssJp", + "PointerFprwordJp", + "PointerFprwordsJp", + "PointerFprworJp", + "PointerFprworsJp", + "PointerFprworssJp", + "PointerFprwrddU0", + "PointerFprwrdfU0", + "PointerFprwrdU0", + "PointerFprwrdsU0", + "PointerFprwrU0", + "PointerFprwrsU0", + "PointerFprwrssU0", + "PointerFprwrddU[", + "PointerFprwrdfU[", + "PointerFprwrdU[", + "PointerFprwrdsU[", + "PointerFprwrU[", + "PointerFprwrsU[", + "PointerFprwrssU[", + "PointerFprwrddup", + "PointerFprwrdfup", + "PointerFprwrdup", + "PointerFprwrdsup", + "PointerFprwrup", + "PointerFprwrsup", + "PointerFprwrssup", + "PointerFFprwrdd", + "PointerFFprwrdf", + "PointerFFprwrd", + "PointerFFprwrds", + "PointerFFprwr", + "PointerFFprwrs", + "PointerFFprwrss", + "PointerFprwrdd", + "PointerFprwrdf", + "PointerFprwrd", + "PointerFprwrds", + "PointerFprwr", + "PointerFprwrs", + "PointerFprwrss", + "PointerFpwrd", + "PointerFpwrds", + "PointerFpwr", + "PointerFpwrs", + "PointerFpwrss", + "PointerFprwarddU0", + "PointerFprwardfU0", + "PointerFprwardU0", + "PointerFprwardsU0", + "PointerFprwarU0", + "PointerFprwarsU0", + "PointerFprwarssU0", + "PointerFprwordU0", + "PointerFprwordsU0", + "PointerFprworU0", + "PointerFprworsU0", + "PointerFprworssU0", + "PointerFprwarddU[", + "PointerFprwardfU[", + "PointerFprwardU[", + "PointerFprwardsU[", + "PointerFprwarU[", + "PointerFprwarsU[", + "PointerFprwarssU[", + "PointerFprwordU[", + "PointerFprwordsU[", + "PointerFprworU[", + "PointerFprworsU[", + "PointerFprworssU[", + "PointerFprwarddup", + "PointerFprwardfup", + "PointerFprwardup", + "PointerFprwardsup", + "PointerFprwarup", + "PointerFprwarsup", + "PointerFprwarssup", + "PointerFprwordup", + "PointerFprwordsup", + "PointerFprworup", + "PointerFprworsup", + "PointerFprworssup", + "PointerFFprwardd", + "PointerFFprwardf", + "PointerFFprward", + "PointerFFprwards", + "PointerFFprwar", + "PointerFFprwars", + "PointerFFprwarss", + "PointerFFprword", + "PointerFFprwords", + "PointerFFprwor", + "PointerFFprwors", + "PointerFFprworss", + "PointerFprwardd", + "PointerFprwardf", + "PointerFprward", + "PointerFprwards", + "PointerFprwar", + "PointerFprwars", + "PointerFprwarss", + "PointerFprword", + "PointerFprwords", + "PointerFprwor", + "PointerFprwors", + "PointerFprworss", + "PointerFpword", + "PointerFpwords", + "PointerFpwor", + "PointerFpwors", + "PointerFpworss", + "PointerFpward", + "PointerFpwards", + "PointerFpwar", + "PointerFpwars", + "PointerFpwarss", + "UpPointer", + "PointerForwrddJp", + "PointerForwrdfJp", + "PointerForwrdJp", + "PointerForwrdsJp", + "PointerForwrJp", + "PointerForwrsJp", + "PointerForwrssJp", + "PointerForwarddJp", + "PointerForwardfJp", + "PointerForwardJp", + "PointerForwardsJp", + "PointerForwarJp", + "PointerForwarsJp", + "PointerForwarssJp", + "PointerForwordJp", + "PointerForwordsJp", + "PointerForworJp", + "PointerForworsJp", + "PointerForworssJp", + "Pointer-Jp", + "PointerJp", + "PointerJpo", + "PointerJpp", + "PointerJppo", + "PointerNort", + "PointerForwrddU0", + "PointerForwrdfU0", + "PointerForwrdU0", + "PointerForwrdsU0", + "PointerForwrU0", + "PointerForwrsU0", + "PointerForwrssU0", + "PointerForwrddU[", + "PointerForwrdfU[", + "PointerForwrdU[", + "PointerForwrdsU[", + "PointerForwrU[", + "PointerForwrsU[", + "PointerForwrssU[", + "PointerForwrddup", + "PointerForwrdfup", + "PointerForwrdup", + "PointerForwrdsup", + "PointerForwrup", + "PointerForwrsup", + "PointerForwrssup", + "PointerFforwrdd", + "PointerFforwrdf", + "PointerFforwrd", + "PointerFforwrds", + "PointerFforwr", + "PointerFforwrs", + "PointerFforwrss", + "PointerFirwrdd", + "PointerFirwrdf", + "PointerFirwrd", + "PointerFirwrds", + "PointerFirwr", + "PointerFirwrs", + "PointerFirwrss", + "PointerFrwrdd", + "PointerFrwrdf", + "PointerFrwrd", + "PointerFrwrds", + "PointerFrwr", + "PointerFrwrs", + "PointerFrwrss", + "PointerForwrdd", + "PointerForwrdf", + "PointerForwrd", + "PointerForwrds", + "PointerForwr", + "PointerForwrs", + "PointerForwrss", + "PointerFowrd", + "PointerFowrds", + "PointerFowr", + "PointerFowrs", + "PointerFowrss", + "PointerNorht", + "PointerForwarddU0", + "PointerForwardfU0", + "PointerForwardU0", + "PointerForwardsU0", + "PointerForwarU0", + "PointerForwarsU0", + "PointerForwarssU0", + "PointerForwordU0", + "PointerForwordsU0", + "PointerForworU0", + "PointerForworsU0", + "PointerForworssU0", + "Pointer-U0", + "PointerU0", + "PointerU0o", + "PointerU0p", + "PointerU0po", + "PointerForwarddU[", + "PointerForwardfU[", + "PointerForwardU[", + "PointerForwardsU[", + "PointerForwarU[", + "PointerForwarsU[", + "PointerForwarssU[", + "PointerForwordU[", + "PointerForwordsU[", + "PointerForworU[", + "PointerForworsU[", + "PointerForworssU[", + "Pointer-U[", + "PointerU[", + "PointerU[o", + "PointerU[p", + "PointerU[po", + "PointerForwarddup", + "PointerForwardfup", + "PointerForwardup", + "PointerForwardsup", + "PointerForwarup", + "PointerForwarsup", + "PointerForwarssup", + "PointerForwordup", + "PointerForwordsup", + "PointerForworup", + "PointerForworsup", + "PointerForworssup", + "PointerFforwardd", + "PointerFforwardf", + "PointerFforward", + "PointerFforwards", + "PointerFforwar", + "PointerFforwars", + "PointerFforwarss", + "PointerFforword", + "PointerFforwords", + "PointerFforwor", + "PointerFforwors", + "PointerFforworss", + "PointerFirwardd", + "PointerFirwardf", + "PointerFirward", + "PointerFirwards", + "PointerFirwar", + "PointerFirwars", + "PointerFirwarss", + "PointerFirword", + "PointerFirwords", + "PointerFirwor", + "PointerFirwors", + "PointerFirworss", + "PointerFrwardd", + "PointerFrwardf", + "PointerFrward", + "PointerFrwards", + "PointerFrwar", + "PointerFrwars", + "PointerFrwarss", + "PointerFrword", + "PointerFrwords", + "PointerFrwor", + "PointerFrwors", + "PointerFrworss", + "PointerForwardd", + "PointerForwardf", + "Pointer-up", + "Pointerup", + "PointerU", + "Pointer^", + "Pointer↑", + "Pointer▲", + "PointerNorth", + "PointerN", + "PointerUo", + "PointerUpo", + "PointerUop", + "PointerUopo", + "PointerYp", + "PointerY", + "PointerYo", + "PointerYpo", + "PointerYop", + "PointerYopo", + "PointerIp", + "PointerI", + "PointerIo", + "PointerIpo", + "PointerIop", + "PointerIopo", + "Pointerupp", + "PointerUppo", + "PointerUopp", + "PointerUoppo", + "PointerYpp", + "PointerYppo", + "PointerYopp", + "PointerYoppo", + "PointerIpp", + "PointerIppo", + "PointerIopp", + "PointerIoppo", + "PointerNoth", + "PointerForward", + "PointerForwards", + "PointerFront", + "PointerForwar", + "PointerForwars", + "PointerForwarss", + "PointerForword", + "PointerForwords", + "PointerForwor", + "PointerForwors", + "PointerForworss", + "PointerFoword", + "PointerFowords", + "PointerFowor", + "PointerFowors", + "PointerFoworss", + "PointerFoward", + "PointerFowards", + "PointerFowar", + "PointerFowars", + "PointerFowarss", + "PStickUp", + "PStickU", + "PFprwrddJp", + "PFprwrdfJp", + "PFprwrdJp", + "PFprwrdsJp", + "PFprwrJp", + "PFprwrsJp", + "PFprwrssJp", + "PFprwarddJp", + "PFprwardfJp", + "PFprwardJp", + "PFprwardsJp", + "PFprwarJp", + "PFprwarsJp", + "PFprwarssJp", + "PFprwordJp", + "PFprwordsJp", + "PFprworJp", + "PFprworsJp", + "PFprworssJp", + "PFprwrddU0", + "PFprwrdfU0", + "PFprwrdU0", + "PFprwrdsU0", + "PFprwrU0", + "PFprwrsU0", + "PFprwrssU0", + "PFprwrddU[", + "PFprwrdfU[", + "PFprwrdU[", + "PFprwrdsU[", + "PFprwrU[", + "PFprwrsU[", + "PFprwrssU[", + "PFprwrddup", + "PFprwrdfup", + "PFprwrdup", + "PFprwrdsup", + "PFprwrup", + "PFprwrsup", + "PFprwrssup", + "PFFprwrdd", + "PFFprwrdf", + "PFFprwrd", + "PFFprwrds", + "PFFprwr", + "PFFprwrs", + "PFFprwrss", + "PFprwrdd", + "PFprwrdf", + "PFprwrd", + "PFprwrds", + "PFprwr", + "PFprwrs", + "PFprwrss", + "PFpwrd", + "PFpwrds", + "PFpwr", + "PFpwrs", + "PFpwrss", + "PFprwarddU0", + "PFprwardfU0", + "PFprwardU0", + "PFprwardsU0", + "PFprwarU0", + "PFprwarsU0", + "PFprwarssU0", + "PFprwordU0", + "PFprwordsU0", + "PFprworU0", + "PFprworsU0", + "PFprworssU0", + "PFprwarddU[", + "PFprwardfU[", + "PFprwardU[", + "PFprwardsU[", + "PFprwarU[", + "PFprwarsU[", + "PFprwarssU[", + "PFprwordU[", + "PFprwordsU[", + "PFprworU[", + "PFprworsU[", + "PFprworssU[", + "PFprwarddup", + "PFprwardfup", + "PFprwardup", + "PFprwardsup", + "PFprwarup", + "PFprwarsup", + "PFprwarssup", + "PFprwordup", + "PFprwordsup", + "PFprworup", + "PFprworsup", + "PFprworssup", + "PFFprwardd", + "PFFprwardf", + "PFFprward", + "PFFprwards", + "PFFprwar", + "PFFprwars", + "PFFprwarss", + "PFFprword", + "PFFprwords", + "PFFprwor", + "PFFprwors", + "PFFprworss", + "PFprwardd", + "PFprwardf", + "PFprward", + "PFprwards", + "PFprwar", + "PFprwars", + "PFprwarss", + "PFprword", + "PFprwords", + "PFprwor", + "PFprwors", + "PFprworss", + "PFpword", + "PFpwords", + "PFpwor", + "PFpwors", + "PFpworss", + "PFpward", + "PFpwards", + "PFpwar", + "PFpwars", + "PFpwarss", + "PForwrddJp", + "PForwrdfJp", + "PForwrdJp", + "PForwrdsJp", + "PForwrJp", + "PForwrsJp", + "PForwrssJp", + "PForwarddJp", + "PForwardfJp", + "PForwardJp", + "PForwardsJp", + "PForwarJp", + "PForwarsJp", + "PForwarssJp", + "PForwordJp", + "PForwordsJp", + "PForworJp", + "PForworsJp", + "PForworssJp", + "P-Jp", + "PJp", + "PJpo", + "PJpp", + "PJppo", + "PNort", + "PForwrddU0", + "PForwrdfU0", + "PForwrdU0", + "PForwrdsU0", + "PForwrU0", + "PForwrsU0", + "PForwrssU0", + "PForwrddU[", + "PForwrdfU[", + "PForwrdU[", + "PForwrdsU[", + "PForwrU[", + "PForwrsU[", + "PForwrssU[", + "PForwrddup", + "PForwrdfup", + "PForwrdup", + "PForwrdsup", + "PForwrup", + "PForwrsup", + "PForwrssup", + "PFforwrdd", + "PFforwrdf", + "PFforwrd", + "PFforwrds", + "PFforwr", + "PFforwrs", + "PFforwrss", + "PFirwrdd", + "PFirwrdf", + "PFirwrd", + "PFirwrds", + "PFirwr", + "PFirwrs", + "PFirwrss", + "PFrwrdd", + "PFrwrdf", + "PFrwrd", + "PFrwrds", + "PFrwr", + "PFrwrs", + "PFrwrss", + "PForwrdd", + "PForwrdf", + "PForwrd", + "PForwrds", + "PForwr", + "PForwrs", + "PForwrss", + "PFowrd", + "PFowrds", + "PFowr", + "PFowrs", + "PFowrss", + "PNorht", + "PForwarddU0", + "PForwardfU0", + "PForwardU0", + "PForwardsU0", + "PForwarU0", + "PForwarsU0", + "PForwarssU0", + "PForwordU0", + "PForwordsU0", + "PForworU0", + "PForworsU0", + "PForworssU0", + "P-U0", + "PU0", + "PU0o", + "PU0p", + "PU0po", + "PForwarddU[", + "PForwardfU[", + "PForwardU[", + "PForwardsU[", + "PForwarU[", + "PForwarsU[", + "PForwarssU[", + "PForwordU[", + "PForwordsU[", + "PForworU[", + "PForworsU[", + "PForworssU[", + "P-U[", + "PU[", + "PU[o", + "PU[p", + "PU[po", + "PForwarddup", + "PForwardfup", + "PForwardup", + "PForwardsup", + "PForwarup", + "PForwarsup", + "PForwarssup", + "PForwordup", + "PForwordsup", + "PForworup", + "PForworsup", + "PForworssup", + "PFforwardd", + "PFforwardf", + "PFforward", + "PFforwards", + "PFforwar", + "PFforwars", + "PFforwarss", + "PFforword", + "PFforwords", + "PFforwor", + "PFforwors", + "PFforworss", + "PFirwardd", + "PFirwardf", + "PFirward", + "PFirwards", + "PFirwar", + "PFirwars", + "PFirwarss", + "PFirword", + "PFirwords", + "PFirwor", + "PFirwors", + "PFirworss", + "PFrwardd", + "PFrwardf", + "PFrward", + "PFrwards", + "PFrwar", + "PFrwars", + "PFrwarss", + "PFrword", + "PFrwords", + "PFrwor", + "PFrwors", + "PFrworss", + "PForwardd", + "PForwardf", + "P-up", + "Pup", + "PU", + "P^", + "P↑", + "P▲", + "PNorth", + "PN", + "PUo", + "PUpo", + "PUop", + "PUopo", + "PYp", + "PY", + "PYo", + "PYpo", + "PYop", + "PYopo", + "PIp", + "PI", + "PIo", + "PIpo", + "PIop", + "PIopo", + "Pupp", + "PUppo", + "PUopp", + "PUoppo", + "PYpp", + "PYppo", + "PYopp", + "PYoppo", + "PIpp", + "PIppo", + "PIopp", + "PIoppo", + "PNoth", + "PForward", + "PForwards", + "PFront", + "PForwar", + "PForwars", + "PForwarss", + "PForword", + "PForwords", + "PForwor", + "PForwors", + "PForworss", + "PFoword", + "PFowords", + "PFowor", + "PFowors", + "PFoworss", + "PFoward", + "PFowards", + "PFowar", + "PFowars", + "PFowarss", + "UpP" + ], + "color_value": "#FFE400", + "is_blacklisted": false, + "opposite_input_value": "0x00007F7F7FFF0000L", + "opposite_input_name": "Pv", + "has_opposite": true, + "input_type": 2, + "keyboard_value": 38, + "keyboard_key_name": "ArrowUp" + }, + { + "input_value": "0x00007F7F7FFF0000L", + "input_name": "Pv", + "input_alias": [ + "PointerStickDown", + "PointerStickD", + "PointStickDown", + "PointStickD", + "DownnPoint", + "Point-Downn", + "PointDownn", + "PointFpwn", + "PointFpwb", + "PointFpw", + "PointFpwm", + "DownPoint", + "PointAckwrd", + "PointAckwrds", + "PointAckwrs", + "PointAckwrss", + "PointAckwr", + "PointAckward", + "PointAckwards", + "PointAck", + "PointAckwars", + "PointAckwarss", + "PointAckwar", + "PointAckword", + "PointAckwords", + "PointAckwors", + "PointAckworss", + "PointAckwor", + "PointBabkwrd", + "PointBabkwrds", + "PointBabkwrs", + "PointBabkwrss", + "PointBabkwr", + "PointBabkward", + "PointBabkwards", + "PointBabk", + "PointBabkwars", + "PointBabkwarss", + "PointBabkwar", + "PointBabkword", + "PointBabkwords", + "PointBabkwors", + "PointBabkworss", + "PointBabkwor", + "Point-Xown", + "PointXown", + "Point-Doown", + "PointDoown", + "Point-dowwn", + "Pointdowwn", + "Pointdonww", + "PointSputh", + "PointSout", + "PointSput", + "PointBackwrd", + "PointBackwrds", + "PointBackwrs", + "PointBackwrss", + "PointBackwr", + "PointBacxkwrd", + "PointBacxkwrds", + "PointBaxckwrd", + "PointBaxckwrds", + "PointBaxkwrd", + "PointBaxkwrds", + "PointBacxkwr", + "PointBacxkwrs", + "PointBaxckwr", + "PointBaxckwrs", + "PointBaxkwr", + "PointBaxkwrs", + "PointBacxkwrss", + "PointBaxckwrss", + "PointBaxkwrss", + "PointBavckwrd", + "PointBavckwrds", + "PointBavckwrs", + "PointBavckwrss", + "PointBavckwr", + "PointBakcwrd", + "PointBakcwrds", + "PointBakcwrs", + "PointBakcwrss", + "PointBakcwr", + "PointBaccwrd", + "PointBaccwrds", + "PointBaccwrs", + "PointBaccwrss", + "PointBaccwr", + "PointBavkwrd", + "PointBavkwrds", + "PointBavkwrs", + "PointBavkwrss", + "PointBavkwr", + "PointBacvkwrd", + "PointBacvkwrds", + "PointBacvkwrs", + "PointBacvkwrss", + "PointBacvkwr", + "Point-Doqn", + "PointDoqn", + "Point-down", + "PointReverse", + "Pointdown", + "Pointdwon", + "Pointdonw", + "Pointdnow", + "Pointdnwo", + "PointD", + "Pointv", + "Point↓", + "PointSouth", + "PointS", + "Point▼", + "Pointdiwn", + "Pointdwin", + "Pointdinw", + "Pointdniw", + "Pointdnwi", + "Pointdpwn", + "Pointdwpn", + "Pointdpnw", + "Pointdnpw", + "Pointdnwp", + "Pointdon", + "Pointdin", + "Pointdpn", + "Pointdoiwn", + "Pointdpiwn", + "Pointdipwn", + "Pointdpown", + "Pointdopwn", + "Pointdoinw", + "Pointdpinw", + "Pointdipnw", + "Pointdponw", + "Pointdopnw", + "Pointdowb", + "Pointdwob", + "Pointdobw", + "Pointdbow", + "Pointdbwo", + "Pointdiwb", + "Pointdwib", + "Pointdibw", + "Pointdbiw", + "Pointdbwi", + "Pointdpwb", + "Pointdwpb", + "Pointdpbw", + "Pointdbpw", + "Pointdbwp", + "Pointdob", + "Pointdib", + "Pointdpb", + "Pointdoiwb", + "Pointdpiwb", + "Pointdipwb", + "Pointdpowb", + "Pointdopwb", + "Pointdoibw", + "Pointdpibw", + "Pointdipbw", + "Pointdpobw", + "Pointdopbw", + "PointSown", + "PointSwon", + "PointSonw", + "PointSnow", + "PointSnwo", + "PointSiwn", + "PointSinw", + "PointSniw", + "PointSnwi", + "PointSpwn", + "PointSwpn", + "PointSpnw", + "PointSnpw", + "PointSnwp", + "PointSpn", + "PointSoiwn", + "PointSpiwn", + "PointSiown", + "PointSipwn", + "PointSpown", + "PointSopwn", + "PointSoinw", + "PointSionw", + "PointSipnw", + "PointSponw", + "PointSopnw", + "PointSowb", + "PointSwob", + "PointSobw", + "PointSbow", + "PointSbwo", + "PointSiwb", + "PointSwib", + "PointSibw", + "PointSbiw", + "PointSbwi", + "PointSpwb", + "PointSwpb", + "PointSpbw", + "PointSbpw", + "PointSbwp", + "PointSob", + "PointSib", + "PointSpb", + "PointSoiwb", + "PointSpiwb", + "PointSiowb", + "PointSipwb", + "PointSpowb", + "PointSopwb", + "PointSoibw", + "PointSpibw", + "PointSiobw", + "PointSipbw", + "PointSpobw", + "PointSopbw", + "Pointdow", + "Pointdwo", + "Pointdno", + "Pointdnw", + "Pointdiw", + "Pointdwi", + "Pointdni", + "Pointdpw", + "Pointdwp", + "Pointdnp", + "Pointdoiw", + "Pointdpiw", + "Pointdipw", + "Pointdpow", + "Pointdopw", + "Pointdoin", + "Pointdpin", + "Pointdipn", + "Pointdpon", + "Pointdopn", + "Pointdbo", + "Pointdbw", + "Pointdbi", + "Pointdbp", + "Pointdoib", + "Pointdpib", + "Pointdipb", + "Pointdpob", + "Pointdopb", + "PointSow", + "PointSwo", + "PointSno", + "PointSnw", + "PointSiw", + "PointSwi", + "PointSni", + "PointSpw", + "PointSwp", + "PointSnp", + "PointSoiw", + "PointSpiw", + "PointSiow", + "PointSipw", + "PointSpow", + "PointSopw", + "PointSoin", + "PointSion", + "PointSipn", + "PointSpon", + "PointSopn", + "PointSbo", + "PointSbw", + "PointSbi", + "PointSbp", + "PointSoib", + "PointSpib", + "PointSiob", + "PointSipb", + "PointSpob", + "PointSopb", + "Pointd0wn", + "Pointdw0n", + "Pointd0nw", + "Pointdn0w", + "Pointdnw0", + "PointS0uth", + "Pointd0n", + "Pointd0iwn", + "Pointdi0wn", + "Pointdp0wn", + "Pointd0pwn", + "Pointd0inw", + "Pointdi0nw", + "Pointdp0nw", + "Pointd0pnw", + "Pointd0wb", + "Pointdw0b", + "Pointd0bw", + "Pointdb0w", + "Pointdbw0", + "Pointd0b", + "Pointd0iwb", + "Pointdi0wb", + "Pointdp0wb", + "Pointd0pwb", + "Pointd0ibw", + "Pointdi0bw", + "Pointdp0bw", + "Pointd0pbw", + "PointS0wn", + "PointSw0n", + "PointS0nw", + "PointSn0w", + "PointSnw0", + "PointS0n", + "PointS0iwn", + "PointSi0wn", + "PointSp0wn", + "PointS0pwn", + "PointS0inw", + "PointSi0nw", + "PointSp0nw", + "PointS0pnw", + "PointS0wb", + "PointSw0b", + "PointS0bw", + "PointSb0w", + "PointSbw0", + "PointS0b", + "PointS0iwb", + "PointSi0wb", + "PointSp0wb", + "PointS0pwb", + "PointS0ibw", + "PointSi0bw", + "PointSp0bw", + "PointS0pbw", + "Pointd0w", + "Pointdw0", + "Pointdn0", + "Pointd0iw", + "Pointdi0w", + "Pointdp0w", + "Pointd0pw", + "Pointd0in", + "Pointdi0n", + "Pointdp0n", + "Pointd0pn", + "Pointdb0", + "Pointd0ib", + "Pointdi0b", + "Pointdp0b", + "Pointd0pb", + "PointS0w", + "PointSw0", + "PointSn0", + "PointS0iw", + "PointSi0w", + "PointSp0w", + "PointS0pw", + "PointS0in", + "PointSi0n", + "PointSp0n", + "PointS0pn", + "PointSb0", + "PointS0ib", + "PointSi0b", + "PointSp0b", + "PointS0pb", + "Pointd9wn", + "Pointdw9n", + "Pointd9nw", + "Pointdn9w", + "Pointdnw9", + "PointS9uth", + "Pointd9n", + "Pointd9iwn", + "Pointdi9wn", + "Pointdp9wn", + "Pointd9pwn", + "Pointd9inw", + "Pointdi9nw", + "Pointdp9nw", + "Pointd9pnw", + "Pointd9wb", + "Pointdw9b", + "Pointd9bw", + "Pointdb9w", + "Pointdbw9", + "Pointd9b", + "Pointd9iwb", + "Pointdi9wb", + "Pointdp9wb", + "Pointd9pwb", + "Pointd9ibw", + "Pointdi9bw", + "Pointdp9bw", + "Pointd9pbw", + "PointS9wn", + "PointSw9n", + "PointS9nw", + "PointSn9w", + "PointSnw9", + "PointS9n", + "PointS9iwn", + "PointSi9wn", + "PointSp9wn", + "PointS9pwn", + "PointS9inw", + "PointSi9nw", + "PointSp9nw", + "PointS9pnw", + "PointS9wb", + "PointSw9b", + "PointS9bw", + "PointSb9w", + "PointSbw9", + "PointS9b", + "PointS9iwb", + "PointSi9wb", + "PointSp9wb", + "PointS9pwb", + "PointS9ibw", + "PointSi9bw", + "PointSp9bw", + "PointS9pbw", + "Pointd9w", + "Pointdw9", + "Pointdn9", + "Pointd9iw", + "Pointdi9w", + "Pointdp9w", + "Pointd9pw", + "Pointd9in", + "Pointdi9n", + "Pointdp9n", + "Pointd9pn", + "Pointdb9", + "Pointd9ib", + "Pointdi9b", + "Pointdp9b", + "Pointd9pb", + "PointS9w", + "PointSw9", + "PointSn9", + "PointS9iw", + "PointSi9w", + "PointSp9w", + "PointS9pw", + "PointS9in", + "PointSi9n", + "PointSp9n", + "PointS9pn", + "PointSb9", + "PointS9ib", + "PointSi9b", + "PointSp9b", + "PointS9pb", + "PointFown", + "PointFwon", + "PointFonw", + "PointFnow", + "PointFnwo", + "PointF", + "PointFiwn", + "PointFwin", + "PointFinw", + "PointFniw", + "PointFnwi", + "PointFwpn", + "PointFpnw", + "PointFnpw", + "PointFnwp", + "PointFon", + "PointFin", + "PointFpn", + "PointFoiwn", + "PointFpiwn", + "PointFiown", + "PointFipwn", + "PointFpown", + "PointFopwn", + "PointFoinw", + "PointFpinw", + "PointFionw", + "PointFipnw", + "PointFponw", + "PointFopnw", + "PointFowb", + "PointFwob", + "PointFobw", + "PointFbow", + "PointFbwo", + "PointFiwb", + "PointFwib", + "PointFibw", + "PointFbiw", + "PointFbwi", + "PointFwpb", + "PointFpbw", + "PointFbpw", + "PointFbwp", + "PointFob", + "PointFib", + "PointFpb", + "PointFoiwb", + "PointFpiwb", + "PointFiowb", + "PointFipwb", + "PointFpowb", + "PointFopwb", + "PointFoibw", + "PointFpibw", + "PointFiobw", + "PointFipbw", + "PointFpobw", + "PointFopbw", + "PointFow", + "PointFwo", + "PointFno", + "PointFnw", + "PointFiw", + "PointFwi", + "PointFni", + "PointFwp", + "PointFnp", + "PointFoiw", + "PointFpiw", + "PointFiow", + "PointFipw", + "PointFpow", + "PointFopw", + "PointFoin", + "PointFpin", + "PointFion", + "PointFipn", + "PointFpon", + "PointFopn", + "PointFbo", + "PointFbw", + "PointFbi", + "PointFbp", + "PointFoib", + "PointFpib", + "PointFiob", + "PointFipb", + "PointFpob", + "PointFopb", + "PointF0wn", + "PointFw0n", + "PointF0nw", + "PointFn0w", + "PointFnw0", + "PointF0n", + "PointF0iwn", + "PointFi0wn", + "PointFp0wn", + "PointF0pwn", + "PointF0inw", + "PointFi0nw", + "PointFp0nw", + "PointF0pnw", + "PointF0wb", + "PointFw0b", + "PointF0bw", + "PointFb0w", + "PointFbw0", + "PointF0b", + "PointF0iwb", + "PointFi0wb", + "PointFp0wb", + "PointF0pwb", + "PointF0ibw", + "PointFi0bw", + "PointFp0bw", + "PointF0pbw", + "PointF0w", + "PointFw0", + "PointFn0", + "PointF0iw", + "PointFi0w", + "PointFp0w", + "PointF0pw", + "PointF0in", + "PointFi0n", + "PointFp0n", + "PointF0pn", + "PointFb0", + "PointF0ib", + "PointFi0b", + "PointFp0b", + "PointF0pb", + "PointF9wn", + "PointFw9n", + "PointF9nw", + "PointFn9w", + "PointFnw9", + "PointF9n", + "PointF9iwn", + "PointFi9wn", + "PointFp9wn", + "PointF9pwn", + "PointF9inw", + "PointFi9nw", + "PointFp9nw", + "PointF9pnw", + "PointF9wb", + "PointFw9b", + "PointF9bw", + "PointFb9w", + "PointFbw9", + "PointF9b", + "PointF9iwb", + "PointFi9wb", + "PointFp9wb", + "PointF9pwb", + "PointF9ibw", + "PointFi9bw", + "PointFp9bw", + "PointF9pbw", + "PointF9w", + "PointFw9", + "PointFn9", + "PointF9iw", + "PointFi9w", + "PointFp9w", + "PointF9pw", + "PointF9in", + "PointFi9n", + "PointFp9n", + "PointF9pn", + "PointFb9", + "PointF9ib", + "PointFi9b", + "PointFp9b", + "PointF9pb", + "Pointdowm", + "Pointdwom", + "Pointdomw", + "Pointdmow", + "Pointdmwo", + "Pointdiwm", + "Pointdwim", + "Pointdimw", + "Pointdmiw", + "Pointdmwi", + "Pointdpwm", + "Pointdwpm", + "Pointdpmw", + "Pointdmpw", + "Pointdmwp", + "Pointdom", + "Pointdim", + "Pointdpm", + "Pointdoiwm", + "Pointdpiwm", + "Pointdipwm", + "Pointdpowm", + "Pointdopwm", + "Pointdoimw", + "Pointdpimw", + "Pointdipmw", + "Pointdpomw", + "Pointdopmw", + "PointSowm", + "PointSwom", + "PointSomw", + "PointSmow", + "PointSmwo", + "PointSiwm", + "PointSimw", + "PointSmiw", + "PointSmwi", + "PointSpwm", + "PointSwpm", + "PointSpmw", + "PointSmpw", + "PointSmwp", + "PointSom", + "PointSim", + "PointSpm", + "PointSoiwm", + "PointSpiwm", + "PointSiowm", + "PointSipwm", + "PointSpowm", + "PointSopwm", + "PointSoimw", + "PointSiomw", + "PointSipmw", + "PointSpomw", + "PointSopmw", + "Pointdmo", + "Pointdmw", + "Pointdmi", + "Pointdmp", + "Pointdoim", + "Pointdpim", + "Pointdipm", + "Pointdpom", + "Pointdopm", + "PointSmo", + "PointSmw", + "PointSmi", + "PointSmp", + "PointSoim", + "PointSiom", + "PointSipm", + "PointSpom", + "PointSopm", + "Pointd0wm", + "Pointdw0m", + "Pointd0mw", + "Pointdm0w", + "Pointdmw0", + "Pointd0m", + "Pointd0iwm", + "Pointdi0wm", + "Pointdp0wm", + "Pointd0pwm", + "Pointd0imw", + "Pointdi0mw", + "Pointdp0mw", + "Pointd0pmw", + "PointS0wm", + "PointSw0m", + "PointS0mw", + "PointSm0w", + "PointSmw0", + "PointS0m", + "PointS0iwm", + "PointSi0wm", + "PointSp0wm", + "PointS0pwm", + "PointS0imw", + "PointSi0mw", + "PointSp0mw", + "PointS0pmw", + "Pointdm0", + "Pointd0im", + "Pointdi0m", + "Pointdp0m", + "Pointd0pm", + "PointSm0", + "PointS0im", + "PointSi0m", + "PointSp0m", + "PointS0pm", + "Pointd9wm", + "Pointdw9m", + "Pointd9mw", + "Pointdm9w", + "Pointdmw9", + "Pointd9m", + "Pointd9iwm", + "Pointdi9wm", + "Pointdp9wm", + "Pointd9pwm", + "Pointd9imw", + "Pointdi9mw", + "Pointdp9mw", + "Pointd9pmw", + "PointS9wm", + "PointSw9m", + "PointS9mw", + "PointSm9w", + "PointSmw9", + "PointS9m", + "PointS9iwm", + "PointSi9wm", + "PointSp9wm", + "PointS9pwm", + "PointS9imw", + "PointSi9mw", + "PointSp9mw", + "PointS9pmw", + "Pointdm9", + "Pointd9im", + "Pointdi9m", + "Pointdp9m", + "Pointd9pm", + "PointSm9", + "PointS9im", + "PointSi9m", + "PointSp9m", + "PointS9pm", + "PointFowm", + "PointFwom", + "PointFomw", + "PointFmow", + "PointFmwo", + "PointFiwm", + "PointFwim", + "PointFimw", + "PointFmiw", + "PointFmwi", + "PointFwpm", + "PointFpmw", + "PointFmpw", + "PointFmwp", + "PointFom", + "PointFim", + "PointFpm", + "PointFoiwm", + "PointFpiwm", + "PointFiowm", + "PointFipwm", + "PointFpowm", + "PointFopwm", + "PointFoimw", + "PointFpimw", + "PointFiomw", + "PointFipmw", + "PointFpomw", + "PointFopmw", + "PointFmo", + "PointFmw", + "PointFmi", + "PointFmp", + "PointFoim", + "PointFpim", + "PointFiom", + "PointFipm", + "PointFpom", + "PointFopm", + "PointF0wm", + "PointFw0m", + "PointF0mw", + "PointFm0w", + "PointFmw0", + "PointF0m", + "PointF0iwm", + "PointFi0wm", + "PointFp0wm", + "PointF0pwm", + "PointF0imw", + "PointFi0mw", + "PointFp0mw", + "PointF0pmw", + "PointFm0", + "PointF0im", + "PointFi0m", + "PointFp0m", + "PointF0pm", + "PointF9wm", + "PointFw9m", + "PointF9mw", + "PointFm9w", + "PointFmw9", + "PointF9m", + "PointF9iwm", + "PointFi9wm", + "PointFp9wm", + "PointF9pwm", + "PointF9imw", + "PointFi9mw", + "PointFp9mw", + "PointF9pmw", + "PointFm9", + "PointF9im", + "PointFi9m", + "PointFp9m", + "PointF9pm", + "Pointdoen", + "Pointdeon", + "Pointdone", + "Pointdnoe", + "Pointdneo", + "Pointdein", + "Pointdine", + "Pointdnie", + "Pointdnei", + "Pointdpen", + "Pointdepn", + "Pointdpne", + "Pointdnpe", + "Pointdnep", + "Pointdoien", + "Pointdpien", + "Pointdipen", + "Pointdpoen", + "Pointdoine", + "Pointdpine", + "Pointdipne", + "Pointdpone", + "Pointdopne", + "Pointdoeb", + "Pointdeob", + "Pointdobe", + "Pointdboe", + "Pointdbeo", + "Pointdeib", + "Pointdibe", + "Pointdbie", + "Pointdbei", + "Pointdpeb", + "Pointdepb", + "Pointdpbe", + "Pointdbpe", + "Pointdbep", + "Pointdoieb", + "Pointdpieb", + "Pointdipeb", + "Pointdpoeb", + "Pointdoibe", + "Pointdpibe", + "Pointdipbe", + "Pointdpobe", + "Pointdopbe", + "PointSoen", + "PointSeon", + "PointSone", + "PointSnoe", + "PointSneo", + "PointSien", + "PointSein", + "PointSine", + "PointSnie", + "PointSnei", + "PointSpen", + "PointSepn", + "PointSpne", + "PointSnpe", + "PointSnep", + "PointSoien", + "PointSpien", + "PointSioen", + "PointSipen", + "PointSpoen", + "PointSopen", + "PointSoine", + "PointSione", + "PointSipne", + "PointSpone", + "PointSopne", + "PointSoeb", + "PointSeob", + "PointSobe", + "PointSboe", + "PointSbeo", + "PointSieb", + "PointSeib", + "PointSibe", + "PointSbie", + "PointSbei", + "PointSpeb", + "PointSepb", + "PointSpbe", + "PointSbpe", + "PointSbep", + "PointSoieb", + "PointSpieb", + "PointSioeb", + "PointSipeb", + "PointSpoeb", + "PointSopeb", + "PointSoibe", + "PointSpibe", + "PointSiobe", + "PointSipbe", + "PointSpobe", + "PointSopbe", + "Pointdoe", + "Pointdeo", + "Pointdne", + "Pointdei", + "Pointdpe", + "Pointdep", + "Pointdoie", + "Pointdpie", + "Pointdipe", + "Pointdpoe", + "Pointdbe", + "PointSoe", + "PointSeo", + "PointSne", + "PointSie", + "PointSei", + "PointSpe", + "PointSep", + "PointSoie", + "PointSpie", + "PointSioe", + "PointSipe", + "PointSpoe", + "PointSope", + "PointSbe", + "Pointd0en", + "Pointde0n", + "Pointd0ne", + "Pointdn0e", + "Pointdne0", + "Pointd0ien", + "Pointdi0en", + "Pointdp0en", + "Pointd0pen", + "Pointd0ine", + "Pointdi0ne", + "Pointdp0ne", + "Pointd0pne", + "Pointd0eb", + "Pointde0b", + "Pointd0be", + "Pointdb0e", + "Pointdbe0", + "Pointd0ieb", + "Pointdi0eb", + "Pointdp0eb", + "Pointd0peb", + "Pointd0ibe", + "Pointdi0be", + "Pointdp0be", + "Pointd0pbe", + "PointS0en", + "PointSe0n", + "PointS0ne", + "PointSn0e", + "PointSne0", + "PointS0ien", + "PointSi0en", + "PointSp0en", + "PointS0pen", + "PointS0ine", + "PointSi0ne", + "PointSp0ne", + "PointS0pne", + "PointS0eb", + "PointSe0b", + "PointS0be", + "PointSb0e", + "PointSbe0", + "PointS0ieb", + "PointSi0eb", + "PointSp0eb", + "PointS0peb", + "PointS0ibe", + "PointSi0be", + "PointSp0be", + "PointS0pbe", + "Pointd0e", + "Pointde0", + "Pointd0ie", + "Pointdi0e", + "Pointdp0e", + "Pointd0pe", + "PointS0e", + "PointSe0", + "PointS0ie", + "PointSi0e", + "PointSp0e", + "PointS0pe", + "Pointd9en", + "Pointde9n", + "Pointd9ne", + "Pointdn9e", + "Pointdne9", + "Pointd9ien", + "Pointdi9en", + "Pointdp9en", + "Pointd9pen", + "Pointd9ine", + "Pointdi9ne", + "Pointdp9ne", + "Pointd9pne", + "Pointd9eb", + "Pointde9b", + "Pointd9be", + "Pointdb9e", + "Pointdbe9", + "Pointd9ieb", + "Pointdi9eb", + "Pointdp9eb", + "Pointd9peb", + "Pointd9ibe", + "Pointdi9be", + "Pointdp9be", + "Pointd9pbe", + "PointS9en", + "PointSe9n", + "PointS9ne", + "PointSn9e", + "PointSne9", + "PointS9ien", + "PointSi9en", + "PointSp9en", + "PointS9pen", + "PointS9ine", + "PointSi9ne", + "PointSp9ne", + "PointS9pne", + "PointS9eb", + "PointSe9b", + "PointS9be", + "PointSb9e", + "PointSbe9", + "PointS9ieb", + "PointSi9eb", + "PointSp9eb", + "PointS9peb", + "PointS9ibe", + "PointSi9be", + "PointSp9be", + "PointS9pbe", + "Pointd9e", + "Pointde9", + "Pointd9ie", + "Pointdi9e", + "Pointdp9e", + "Pointd9pe", + "PointS9e", + "PointSe9", + "PointS9ie", + "PointSi9e", + "PointSp9e", + "PointS9pe", + "PointFoen", + "PointFeon", + "PointFone", + "PointFnoe", + "PointFneo", + "PointFien", + "PointFein", + "PointFnie", + "PointFnei", + "PointFpen", + "PointFepn", + "PointFpne", + "PointFnpe", + "PointFnep", + "PointFoien", + "PointFpien", + "PointFioen", + "PointFipen", + "PointFpoen", + "PointFopen", + "PointFoine", + "PointFpine", + "PointFione", + "PointFipne", + "PointFpone", + "PointFopne", + "PointFoeb", + "PointFeob", + "PointFobe", + "PointFboe", + "PointFbeo", + "PointFieb", + "PointFeib", + "PointFibe", + "PointFbie", + "PointFbei", + "PointFpeb", + "PointFepb", + "PointFpbe", + "PointFbpe", + "PointFbep", + "PointFoieb", + "PointFpieb", + "PointFioeb", + "PointFipeb", + "PointFpoeb", + "PointFopeb", + "PointFoibe", + "PointFpibe", + "PointFiobe", + "PointFipbe", + "PointFpobe", + "PointFopbe", + "PointFoe", + "PointFeo", + "PointFne", + "PointFie", + "PointFei", + "PointFpe", + "PointFep", + "PointFoie", + "PointFpie", + "PointFioe", + "PointFipe", + "PointFpoe", + "PointFope", + "PointFbe", + "PointF0en", + "PointFe0n", + "PointF0ne", + "PointFn0e", + "PointFne0", + "PointF0ien", + "PointFi0en", + "PointFp0en", + "PointF0pen", + "PointF0ine", + "PointFi0ne", + "PointFp0ne", + "PointF0pne", + "PointF0eb", + "PointFe0b", + "PointF0be", + "PointFb0e", + "PointFbe0", + "PointF0ieb", + "PointFi0eb", + "PointFp0eb", + "PointF0peb", + "PointF0ibe", + "PointFi0be", + "PointFp0be", + "PointF0pbe", + "PointF0e", + "PointFe0", + "PointF0ie", + "PointFi0e", + "PointFp0e", + "PointF0pe", + "PointF9en", + "PointFe9n", + "PointF9ne", + "PointFn9e", + "PointFne9", + "PointF9ien", + "PointFi9en", + "PointFp9en", + "PointF9pen", + "PointF9ine", + "PointFi9ne", + "PointFp9ne", + "PointF9pne", + "PointF9eb", + "PointFe9b", + "PointF9be", + "PointFb9e", + "PointFbe9", + "PointF9ieb", + "PointFi9eb", + "PointFp9eb", + "PointF9peb", + "PointF9ibe", + "PointFi9be", + "PointFp9be", + "PointF9pbe", + "PointF9e", + "PointFe9", + "PointF9ie", + "PointFi9e", + "PointFp9e", + "PointF9pe", + "Pointdoem", + "Pointdeom", + "Pointdome", + "Pointdmoe", + "Pointdmeo", + "Pointdeim", + "Pointdime", + "Pointdmie", + "Pointdmei", + "Pointdpem", + "Pointdepm", + "Pointdpme", + "Pointdmpe", + "Pointdmep", + "Pointdoiem", + "Pointdpiem", + "Pointdipem", + "Pointdpoem", + "Pointdoime", + "Pointdpime", + "Pointdipme", + "Pointdpome", + "Pointdopme", + "PointSoem", + "PointSeom", + "PointSmoe", + "PointSmeo", + "PointSiem", + "PointSeim", + "PointSime", + "PointSmie", + "PointSmei", + "PointSpem", + "PointSepm", + "PointSpme", + "PointSmpe", + "PointSmep", + "PointSoiem", + "PointSpiem", + "PointSioem", + "PointSipem", + "PointSpoem", + "PointSopem", + "PointSoime", + "PointSiome", + "PointSipme", + "PointSpome", + "PointSopme", + "Pointdme", + "PointSme", + "Pointd0em", + "Pointde0m", + "Pointd0me", + "Pointdm0e", + "Pointdme0", + "Pointd0iem", + "Pointdi0em", + "Pointdp0em", + "Pointd0pem", + "Pointd0ime", + "Pointdi0me", + "Pointdp0me", + "Pointd0pme", + "PointS0em", + "PointSe0m", + "PointS0me", + "PointSm0e", + "PointSme0", + "PointS0iem", + "PointSi0em", + "PointSp0em", + "PointS0pem", + "PointS0ime", + "PointSi0me", + "PointSp0me", + "PointS0pme", + "Pointd9em", + "Pointde9m", + "Pointd9me", + "Pointdm9e", + "Pointdme9", + "Pointd9iem", + "Pointdi9em", + "Pointdp9em", + "Pointd9pem", + "Pointd9ime", + "Pointdi9me", + "Pointdp9me", + "Pointd9pme", + "PointS9em", + "PointSe9m", + "PointS9me", + "PointSm9e", + "PointSme9", + "PointS9iem", + "PointSi9em", + "PointSp9em", + "PointS9pem", + "PointS9ime", + "PointSi9me", + "PointSp9me", + "PointS9pme", + "PointFoem", + "PointFeom", + "PointFome", + "PointFmoe", + "PointFmeo", + "PointFiem", + "PointFeim", + "PointFime", + "PointFmie", + "PointFmei", + "PointFpem", + "PointFepm", + "PointFpme", + "PointFmpe", + "PointFmep", + "PointFoiem", + "PointFpiem", + "PointFioem", + "PointFipem", + "PointFpoem", + "PointFopem", + "PointFoime", + "PointFpime", + "PointFiome", + "PointFipme", + "PointFpome", + "PointFopme", + "PointFme", + "PointF0em", + "PointFe0m", + "PointF0me", + "PointFm0e", + "PointFme0", + "PointF0iem", + "PointFi0em", + "PointFp0em", + "PointF0pem", + "PointF0ime", + "PointFi0me", + "PointFp0me", + "PointF0pme", + "PointF9em", + "PointFe9m", + "PointF9me", + "PointFm9e", + "PointFme9", + "PointF9iem", + "PointFi9em", + "PointFp9em", + "PointF9pem", + "PointF9ime", + "PointFi9me", + "PointFp9me", + "PointF9pme", + "PointBackward", + "PointBackwards", + "PointBack", + "PointBackwars", + "PointBackwarss", + "PointBackwar", + "PointBacxkward", + "PointBacxkwards", + "PointBacxk", + "PointBaxckward", + "PointBaxckwards", + "PointBaxck", + "PointBaxkward", + "PointBaxkwards", + "PointBaxk", + "PointBacxkwar", + "PointBacxkwars", + "PointBaxckwar", + "PointBaxckwars", + "PointBaxkwar", + "PointBaxkwars", + "PointBacxkwarss", + "PointBaxckwarss", + "PointBaxkwarss", + "PointBavckward", + "PointBavckwards", + "PointBavck", + "PointBavckwars", + "PointBavckwarss", + "PointBavckwar", + "PointBakcward", + "PointBakcwards", + "PointBakP", + "PointBakcwars", + "PointBakcwarss", + "PointBakcwar", + "PointBaccward", + "PointBaccwards", + "PointBacP", + "PointBaccwars", + "PointBaccwarss", + "PointBaccwar", + "PointBavkward", + "PointBavkwards", + "PointBavk", + "PointBavkwars", + "PointBavkwarss", + "PointBavkwar", + "PointBacvkward", + "PointBacvkwards", + "PointBacvk", + "PointBacvkwars", + "PointBacvkwarss", + "PointBacvkwar", + "PointBackword", + "PointBackwords", + "PointBackwors", + "PointBackworss", + "PointBackwor", + "PointBacxkword", + "PointBacxkwords", + "PointBaxckword", + "PointBaxckwords", + "PointBaxkword", + "PointBaxkwords", + "PointBacxkwor", + "PointBacxkwors", + "PointBaxckwor", + "PointBaxckwors", + "PointBaxkwor", + "PointBaxkwors", + "PointBacxkworss", + "PointBaxckworss", + "PointBaxkworss", + "PointBavckword", + "PointBavckwords", + "PointBavckwors", + "PointBavckworss", + "PointBavckwor", + "PointBakcword", + "PointBakcwords", + "PointBakcwors", + "PointBakcworss", + "PointBakcwor", + "PointBaccword", + "PointBaccwords", + "PointBaccwors", + "PointBaccworss", + "PointBaccwor", + "PointBavkword", + "PointBavkwords", + "PointBavkwors", + "PointBavkworss", + "PointBavkwor", + "PointBacvkword", + "PointBacvkwords", + "PointBacvkwors", + "PointBacvkworss", + "PointBacvkwor", + "PointBacvkwors", + "DownnPointer", + "Pointer-Downn", + "PointerDownn", + "PointerFpwn", + "PointerFpwb", + "PointerFpw", + "PointerFpwm", + "DownPointer", + "PointerAckwrd", + "PointerAckwrds", + "PointerAckwrs", + "PointerAckwrss", + "PointerAckwr", + "PointerAckward", + "PointerAckwards", + "PointerAck", + "PointerAckwars", + "PointerAckwarss", + "PointerAckwar", + "PointerAckword", + "PointerAckwords", + "PointerAckwors", + "PointerAckworss", + "PointerAckwor", + "PointerBabkwrd", + "PointerBabkwrds", + "PointerBabkwrs", + "PointerBabkwrss", + "PointerBabkwr", + "PointerBabkward", + "PointerBabkwards", + "PointerBabk", + "PointerBabkwars", + "PointerBabkwarss", + "PointerBabkwar", + "PointerBabkword", + "PointerBabkwords", + "PointerBabkwors", + "PointerBabkworss", + "PointerBabkwor", + "Pointer-Xown", + "PointerXown", + "Pointer-Doown", + "PointerDoown", + "Pointer-dowwn", + "Pointerdowwn", + "Pointerdonww", + "PointerSputh", + "PointerSout", + "PointerSput", + "PointerBackwrd", + "PointerBackwrds", + "PointerBackwrs", + "PointerBackwrss", + "PointerBackwr", + "PointerBacxkwrd", + "PointerBacxkwrds", + "PointerBaxckwrd", + "PointerBaxckwrds", + "PointerBaxkwrd", + "PointerBaxkwrds", + "PointerBacxkwr", + "PointerBacxkwrs", + "PointerBaxckwr", + "PointerBaxckwrs", + "PointerBaxkwr", + "PointerBaxkwrs", + "PointerBacxkwrss", + "PointerBaxckwrss", + "PointerBaxkwrss", + "PointerBavckwrd", + "PointerBavckwrds", + "PointerBavckwrs", + "PointerBavckwrss", + "PointerBavckwr", + "PointerBakcwrd", + "PointerBakcwrds", + "PointerBakcwrs", + "PointerBakcwrss", + "PointerBakcwr", + "PointerBaccwrd", + "PointerBaccwrds", + "PointerBaccwrs", + "PointerBaccwrss", + "PointerBaccwr", + "PointerBavkwrd", + "PointerBavkwrds", + "PointerBavkwrs", + "PointerBavkwrss", + "PointerBavkwr", + "PointerBacvkwrd", + "PointerBacvkwrds", + "PointerBacvkwrs", + "PointerBacvkwrss", + "PointerBacvkwr", + "Pointer-Doqn", + "PointerDoqn", + "Pointer-down", + "PointerReverse", + "Pointerdown", + "Pointerdwon", + "Pointerdonw", + "Pointerdnow", + "Pointerdnwo", + "PointerD", + "Pointerv", + "Pointer↓", + "PointerSouth", + "PointerS", + "Pointer▼", + "Pointerdiwn", + "Pointerdwin", + "Pointerdinw", + "Pointerdniw", + "Pointerdnwi", + "Pointerdpwn", + "Pointerdwpn", + "Pointerdpnw", + "Pointerdnpw", + "Pointerdnwp", + "Pointerdon", + "Pointerdin", + "Pointerdpn", + "Pointerdoiwn", + "Pointerdpiwn", + "Pointerdipwn", + "Pointerdpown", + "Pointerdopwn", + "Pointerdoinw", + "Pointerdpinw", + "Pointerdipnw", + "Pointerdponw", + "Pointerdopnw", + "Pointerdowb", + "Pointerdwob", + "Pointerdobw", + "Pointerdbow", + "Pointerdbwo", + "Pointerdiwb", + "Pointerdwib", + "Pointerdibw", + "Pointerdbiw", + "Pointerdbwi", + "Pointerdpwb", + "Pointerdwpb", + "Pointerdpbw", + "Pointerdbpw", + "Pointerdbwp", + "Pointerdob", + "Pointerdib", + "Pointerdpb", + "Pointerdoiwb", + "Pointerdpiwb", + "Pointerdipwb", + "Pointerdpowb", + "Pointerdopwb", + "Pointerdoibw", + "Pointerdpibw", + "Pointerdipbw", + "Pointerdpobw", + "Pointerdopbw", + "PointerSown", + "PointerSwon", + "PointerSonw", + "PointerSnow", + "PointerSnwo", + "PointerSiwn", + "PointerSinw", + "PointerSniw", + "PointerSnwi", + "PointerSpwn", + "PointerSwpn", + "PointerSpnw", + "PointerSnpw", + "PointerSnwp", + "PointerSpn", + "PointerSoiwn", + "PointerSpiwn", + "PointerSiown", + "PointerSipwn", + "PointerSpown", + "PointerSopwn", + "PointerSoinw", + "PointerSionw", + "PointerSipnw", + "PointerSponw", + "PointerSopnw", + "PointerSowb", + "PointerSwob", + "PointerSobw", + "PointerSbow", + "PointerSbwo", + "PointerSiwb", + "PointerSwib", + "PointerSibw", + "PointerSbiw", + "PointerSbwi", + "PointerSpwb", + "PointerSwpb", + "PointerSpbw", + "PointerSbpw", + "PointerSbwp", + "PointerSob", + "PointerSib", + "PointerSpb", + "PointerSoiwb", + "PointerSpiwb", + "PointerSiowb", + "PointerSipwb", + "PointerSpowb", + "PointerSopwb", + "PointerSoibw", + "PointerSpibw", + "PointerSiobw", + "PointerSipbw", + "PointerSpobw", + "PointerSopbw", + "Pointerdow", + "Pointerdwo", + "Pointerdno", + "Pointerdnw", + "Pointerdiw", + "Pointerdwi", + "Pointerdni", + "Pointerdpw", + "Pointerdwp", + "Pointerdnp", + "Pointerdoiw", + "Pointerdpiw", + "Pointerdipw", + "Pointerdpow", + "Pointerdopw", + "Pointerdoin", + "Pointerdpin", + "Pointerdipn", + "Pointerdpon", + "Pointerdopn", + "Pointerdbo", + "Pointerdbw", + "Pointerdbi", + "Pointerdbp", + "Pointerdoib", + "Pointerdpib", + "Pointerdipb", + "Pointerdpob", + "Pointerdopb", + "PointerSow", + "PointerSwo", + "PointerSno", + "PointerSnw", + "PointerSiw", + "PointerSwi", + "PointerSni", + "PointerSpw", + "PointerSwp", + "PointerSnp", + "PointerSoiw", + "PointerSpiw", + "PointerSiow", + "PointerSipw", + "PointerSpow", + "PointerSopw", + "PointerSoin", + "PointerSion", + "PointerSipn", + "PointerSpon", + "PointerSopn", + "PointerSbo", + "PointerSbw", + "PointerSbi", + "PointerSbp", + "PointerSoib", + "PointerSpib", + "PointerSiob", + "PointerSipb", + "PointerSpob", + "PointerSopb", + "Pointerd0wn", + "Pointerdw0n", + "Pointerd0nw", + "Pointerdn0w", + "Pointerdnw0", + "PointerS0uth", + "Pointerd0n", + "Pointerd0iwn", + "Pointerdi0wn", + "Pointerdp0wn", + "Pointerd0pwn", + "Pointerd0inw", + "Pointerdi0nw", + "Pointerdp0nw", + "Pointerd0pnw", + "Pointerd0wb", + "Pointerdw0b", + "Pointerd0bw", + "Pointerdb0w", + "Pointerdbw0", + "Pointerd0b", + "Pointerd0iwb", + "Pointerdi0wb", + "Pointerdp0wb", + "Pointerd0pwb", + "Pointerd0ibw", + "Pointerdi0bw", + "Pointerdp0bw", + "Pointerd0pbw", + "PointerS0wn", + "PointerSw0n", + "PointerS0nw", + "PointerSn0w", + "PointerSnw0", + "PointerS0n", + "PointerS0iwn", + "PointerSi0wn", + "PointerSp0wn", + "PointerS0pwn", + "PointerS0inw", + "PointerSi0nw", + "PointerSp0nw", + "PointerS0pnw", + "PointerS0wb", + "PointerSw0b", + "PointerS0bw", + "PointerSb0w", + "PointerSbw0", + "PointerS0b", + "PointerS0iwb", + "PointerSi0wb", + "PointerSp0wb", + "PointerS0pwb", + "PointerS0ibw", + "PointerSi0bw", + "PointerSp0bw", + "PointerS0pbw", + "Pointerd0w", + "Pointerdw0", + "Pointerdn0", + "Pointerd0iw", + "Pointerdi0w", + "Pointerdp0w", + "Pointerd0pw", + "Pointerd0in", + "Pointerdi0n", + "Pointerdp0n", + "Pointerd0pn", + "Pointerdb0", + "Pointerd0ib", + "Pointerdi0b", + "Pointerdp0b", + "Pointerd0pb", + "PointerS0w", + "PointerSw0", + "PointerSn0", + "PointerS0iw", + "PointerSi0w", + "PointerSp0w", + "PointerS0pw", + "PointerS0in", + "PointerSi0n", + "PointerSp0n", + "PointerS0pn", + "PointerSb0", + "PointerS0ib", + "PointerSi0b", + "PointerSp0b", + "PointerS0pb", + "Pointerd9wn", + "Pointerdw9n", + "Pointerd9nw", + "Pointerdn9w", + "Pointerdnw9", + "PointerS9uth", + "Pointerd9n", + "Pointerd9iwn", + "Pointerdi9wn", + "Pointerdp9wn", + "Pointerd9pwn", + "Pointerd9inw", + "Pointerdi9nw", + "Pointerdp9nw", + "Pointerd9pnw", + "Pointerd9wb", + "Pointerdw9b", + "Pointerd9bw", + "Pointerdb9w", + "Pointerdbw9", + "Pointerd9b", + "Pointerd9iwb", + "Pointerdi9wb", + "Pointerdp9wb", + "Pointerd9pwb", + "Pointerd9ibw", + "Pointerdi9bw", + "Pointerdp9bw", + "Pointerd9pbw", + "PointerS9wn", + "PointerSw9n", + "PointerS9nw", + "PointerSn9w", + "PointerSnw9", + "PointerS9n", + "PointerS9iwn", + "PointerSi9wn", + "PointerSp9wn", + "PointerS9pwn", + "PointerS9inw", + "PointerSi9nw", + "PointerSp9nw", + "PointerS9pnw", + "PointerS9wb", + "PointerSw9b", + "PointerS9bw", + "PointerSb9w", + "PointerSbw9", + "PointerS9b", + "PointerS9iwb", + "PointerSi9wb", + "PointerSp9wb", + "PointerS9pwb", + "PointerS9ibw", + "PointerSi9bw", + "PointerSp9bw", + "PointerS9pbw", + "Pointerd9w", + "Pointerdw9", + "Pointerdn9", + "Pointerd9iw", + "Pointerdi9w", + "Pointerdp9w", + "Pointerd9pw", + "Pointerd9in", + "Pointerdi9n", + "Pointerdp9n", + "Pointerd9pn", + "Pointerdb9", + "Pointerd9ib", + "Pointerdi9b", + "Pointerdp9b", + "Pointerd9pb", + "PointerS9w", + "PointerSw9", + "PointerSn9", + "PointerS9iw", + "PointerSi9w", + "PointerSp9w", + "PointerS9pw", + "PointerS9in", + "PointerSi9n", + "PointerSp9n", + "PointerS9pn", + "PointerSb9", + "PointerS9ib", + "PointerSi9b", + "PointerSp9b", + "PointerS9pb", + "PointerFown", + "PointerFwon", + "PointerFonw", + "PointerFnow", + "PointerFnwo", + "PointerF", + "PointerFiwn", + "PointerFwin", + "PointerFinw", + "PointerFniw", + "PointerFnwi", + "PointerFwpn", + "PointerFpnw", + "PointerFnpw", + "PointerFnwp", + "PointerFon", + "PointerFin", + "PointerFpn", + "PointerFoiwn", + "PointerFpiwn", + "PointerFiown", + "PointerFipwn", + "PointerFpown", + "PointerFopwn", + "PointerFoinw", + "PointerFpinw", + "PointerFionw", + "PointerFipnw", + "PointerFponw", + "PointerFopnw", + "PointerFowb", + "PointerFwob", + "PointerFobw", + "PointerFbow", + "PointerFbwo", + "PointerFiwb", + "PointerFwib", + "PointerFibw", + "PointerFbiw", + "PointerFbwi", + "PointerFwpb", + "PointerFpbw", + "PointerFbpw", + "PointerFbwp", + "PointerFob", + "PointerFib", + "PointerFpb", + "PointerFoiwb", + "PointerFpiwb", + "PointerFiowb", + "PointerFipwb", + "PointerFpowb", + "PointerFopwb", + "PointerFoibw", + "PointerFpibw", + "PointerFiobw", + "PointerFipbw", + "PointerFpobw", + "PointerFopbw", + "PointerFow", + "PointerFwo", + "PointerFno", + "PointerFnw", + "PointerFiw", + "PointerFwi", + "PointerFni", + "PointerFwp", + "PointerFnp", + "PointerFoiw", + "PointerFpiw", + "PointerFiow", + "PointerFipw", + "PointerFpow", + "PointerFopw", + "PointerFoin", + "PointerFpin", + "PointerFion", + "PointerFipn", + "PointerFpon", + "PointerFopn", + "PointerFbo", + "PointerFbw", + "PointerFbi", + "PointerFbp", + "PointerFoib", + "PointerFpib", + "PointerFiob", + "PointerFipb", + "PointerFpob", + "PointerFopb", + "PointerF0wn", + "PointerFw0n", + "PointerF0nw", + "PointerFn0w", + "PointerFnw0", + "PointerF0n", + "PointerF0iwn", + "PointerFi0wn", + "PointerFp0wn", + "PointerF0pwn", + "PointerF0inw", + "PointerFi0nw", + "PointerFp0nw", + "PointerF0pnw", + "PointerF0wb", + "PointerFw0b", + "PointerF0bw", + "PointerFb0w", + "PointerFbw0", + "PointerF0b", + "PointerF0iwb", + "PointerFi0wb", + "PointerFp0wb", + "PointerF0pwb", + "PointerF0ibw", + "PointerFi0bw", + "PointerFp0bw", + "PointerF0pbw", + "PointerF0w", + "PointerFw0", + "PointerFn0", + "PointerF0iw", + "PointerFi0w", + "PointerFp0w", + "PointerF0pw", + "PointerF0in", + "PointerFi0n", + "PointerFp0n", + "PointerF0pn", + "PointerFb0", + "PointerF0ib", + "PointerFi0b", + "PointerFp0b", + "PointerF0pb", + "PointerF9wn", + "PointerFw9n", + "PointerF9nw", + "PointerFn9w", + "PointerFnw9", + "PointerF9n", + "PointerF9iwn", + "PointerFi9wn", + "PointerFp9wn", + "PointerF9pwn", + "PointerF9inw", + "PointerFi9nw", + "PointerFp9nw", + "PointerF9pnw", + "PointerF9wb", + "PointerFw9b", + "PointerF9bw", + "PointerFb9w", + "PointerFbw9", + "PointerF9b", + "PointerF9iwb", + "PointerFi9wb", + "PointerFp9wb", + "PointerF9pwb", + "PointerF9ibw", + "PointerFi9bw", + "PointerFp9bw", + "PointerF9pbw", + "PointerF9w", + "PointerFw9", + "PointerFn9", + "PointerF9iw", + "PointerFi9w", + "PointerFp9w", + "PointerF9pw", + "PointerF9in", + "PointerFi9n", + "PointerFp9n", + "PointerF9pn", + "PointerFb9", + "PointerF9ib", + "PointerFi9b", + "PointerFp9b", + "PointerF9pb", + "Pointerdowm", + "Pointerdwom", + "Pointerdomw", + "Pointerdmow", + "Pointerdmwo", + "Pointerdiwm", + "Pointerdwim", + "Pointerdimw", + "Pointerdmiw", + "Pointerdmwi", + "Pointerdpwm", + "Pointerdwpm", + "Pointerdpmw", + "Pointerdmpw", + "Pointerdmwp", + "Pointerdom", + "Pointerdim", + "Pointerdpm", + "Pointerdoiwm", + "Pointerdpiwm", + "Pointerdipwm", + "Pointerdpowm", + "Pointerdopwm", + "Pointerdoimw", + "Pointerdpimw", + "Pointerdipmw", + "Pointerdpomw", + "Pointerdopmw", + "PointerSowm", + "PointerSwom", + "PointerSomw", + "PointerSmow", + "PointerSmwo", + "PointerSiwm", + "PointerSimw", + "PointerSmiw", + "PointerSmwi", + "PointerSpwm", + "PointerSwpm", + "PointerSpmw", + "PointerSmpw", + "PointerSmwp", + "PointerSom", + "PointerSim", + "PointerSpm", + "PointerSoiwm", + "PointerSpiwm", + "PointerSiowm", + "PointerSipwm", + "PointerSpowm", + "PointerSopwm", + "PointerSoimw", + "PointerSiomw", + "PointerSipmw", + "PointerSpomw", + "PointerSopmw", + "Pointerdmo", + "Pointerdmw", + "Pointerdmi", + "Pointerdmp", + "Pointerdoim", + "Pointerdpim", + "Pointerdipm", + "Pointerdpom", + "Pointerdopm", + "PointerSmo", + "PointerSmw", + "PointerSmi", + "PointerSmp", + "PointerSoim", + "PointerSiom", + "PointerSipm", + "PointerSpom", + "PointerSopm", + "Pointerd0wm", + "Pointerdw0m", + "Pointerd0mw", + "Pointerdm0w", + "Pointerdmw0", + "Pointerd0m", + "Pointerd0iwm", + "Pointerdi0wm", + "Pointerdp0wm", + "Pointerd0pwm", + "Pointerd0imw", + "Pointerdi0mw", + "Pointerdp0mw", + "Pointerd0pmw", + "PointerS0wm", + "PointerSw0m", + "PointerS0mw", + "PointerSm0w", + "PointerSmw0", + "PointerS0m", + "PointerS0iwm", + "PointerSi0wm", + "PointerSp0wm", + "PointerS0pwm", + "PointerS0imw", + "PointerSi0mw", + "PointerSp0mw", + "PointerS0pmw", + "Pointerdm0", + "Pointerd0im", + "Pointerdi0m", + "Pointerdp0m", + "Pointerd0pm", + "PointerSm0", + "PointerS0im", + "PointerSi0m", + "PointerSp0m", + "PointerS0pm", + "Pointerd9wm", + "Pointerdw9m", + "Pointerd9mw", + "Pointerdm9w", + "Pointerdmw9", + "Pointerd9m", + "Pointerd9iwm", + "Pointerdi9wm", + "Pointerdp9wm", + "Pointerd9pwm", + "Pointerd9imw", + "Pointerdi9mw", + "Pointerdp9mw", + "Pointerd9pmw", + "PointerS9wm", + "PointerSw9m", + "PointerS9mw", + "PointerSm9w", + "PointerSmw9", + "PointerS9m", + "PointerS9iwm", + "PointerSi9wm", + "PointerSp9wm", + "PointerS9pwm", + "PointerS9imw", + "PointerSi9mw", + "PointerSp9mw", + "PointerS9pmw", + "Pointerdm9", + "Pointerd9im", + "Pointerdi9m", + "Pointerdp9m", + "Pointerd9pm", + "PointerSm9", + "PointerS9im", + "PointerSi9m", + "PointerSp9m", + "PointerS9pm", + "PointerFowm", + "PointerFwom", + "PointerFomw", + "PointerFmow", + "PointerFmwo", + "PointerFiwm", + "PointerFwim", + "PointerFimw", + "PointerFmiw", + "PointerFmwi", + "PointerFwpm", + "PointerFpmw", + "PointerFmpw", + "PointerFmwp", + "PointerFom", + "PointerFim", + "PointerFpm", + "PointerFoiwm", + "PointerFpiwm", + "PointerFiowm", + "PointerFipwm", + "PointerFpowm", + "PointerFopwm", + "PointerFoimw", + "PointerFpimw", + "PointerFiomw", + "PointerFipmw", + "PointerFpomw", + "PointerFopmw", + "PointerFmo", + "PointerFmw", + "PointerFmi", + "PointerFmp", + "PointerFoim", + "PointerFpim", + "PointerFiom", + "PointerFipm", + "PointerFpom", + "PointerFopm", + "PointerF0wm", + "PointerFw0m", + "PointerF0mw", + "PointerFm0w", + "PointerFmw0", + "PointerF0m", + "PointerF0iwm", + "PointerFi0wm", + "PointerFp0wm", + "PointerF0pwm", + "PointerF0imw", + "PointerFi0mw", + "PointerFp0mw", + "PointerF0pmw", + "PointerFm0", + "PointerF0im", + "PointerFi0m", + "PointerFp0m", + "PointerF0pm", + "PointerF9wm", + "PointerFw9m", + "PointerF9mw", + "PointerFm9w", + "PointerFmw9", + "PointerF9m", + "PointerF9iwm", + "PointerFi9wm", + "PointerFp9wm", + "PointerF9pwm", + "PointerF9imw", + "PointerFi9mw", + "PointerFp9mw", + "PointerF9pmw", + "PointerFm9", + "PointerF9im", + "PointerFi9m", + "PointerFp9m", + "PointerF9pm", + "Pointerdoen", + "Pointerdeon", + "Pointerdone", + "Pointerdnoe", + "Pointerdneo", + "Pointerdein", + "Pointerdine", + "Pointerdnie", + "Pointerdnei", + "Pointerdpen", + "Pointerdepn", + "Pointerdpne", + "Pointerdnpe", + "Pointerdnep", + "Pointerdoien", + "Pointerdpien", + "Pointerdipen", + "Pointerdpoen", + "Pointerdoine", + "Pointerdpine", + "Pointerdipne", + "Pointerdpone", + "Pointerdopne", + "Pointerdoeb", + "Pointerdeob", + "Pointerdobe", + "Pointerdboe", + "Pointerdbeo", + "Pointerdeib", + "Pointerdibe", + "Pointerdbie", + "Pointerdbei", + "Pointerdpeb", + "Pointerdepb", + "Pointerdpbe", + "Pointerdbpe", + "Pointerdbep", + "Pointerdoieb", + "Pointerdpieb", + "Pointerdipeb", + "Pointerdpoeb", + "Pointerdoibe", + "Pointerdpibe", + "Pointerdipbe", + "Pointerdpobe", + "Pointerdopbe", + "PointerSoen", + "PointerSeon", + "PointerSone", + "PointerSnoe", + "PointerSneo", + "PointerSien", + "PointerSein", + "PointerSine", + "PointerSnie", + "PointerSnei", + "PointerSpen", + "PointerSepn", + "PointerSpne", + "PointerSnpe", + "PointerSnep", + "PointerSoien", + "PointerSpien", + "PointerSioen", + "PointerSipen", + "PointerSpoen", + "PointerSopen", + "PointerSoine", + "PointerSione", + "PointerSipne", + "PointerSpone", + "PointerSopne", + "PointerSoeb", + "PointerSeob", + "PointerSobe", + "PointerSboe", + "PointerSbeo", + "PointerSieb", + "PointerSeib", + "PointerSibe", + "PointerSbie", + "PointerSbei", + "PointerSpeb", + "PointerSepb", + "PointerSpbe", + "PointerSbpe", + "PointerSbep", + "PointerSoieb", + "PointerSpieb", + "PointerSioeb", + "PointerSipeb", + "PointerSpoeb", + "PointerSopeb", + "PointerSoibe", + "PointerSpibe", + "PointerSiobe", + "PointerSipbe", + "PointerSpobe", + "PointerSopbe", + "Pointerdoe", + "Pointerdeo", + "Pointerdne", + "Pointerdei", + "Pointerdpe", + "Pointerdep", + "Pointerdoie", + "Pointerdpie", + "Pointerdipe", + "Pointerdpoe", + "Pointerdbe", + "PointerSoe", + "PointerSeo", + "PointerSne", + "PointerSie", + "PointerSei", + "PointerSpe", + "PointerSep", + "PointerSoie", + "PointerSpie", + "PointerSioe", + "PointerSipe", + "PointerSpoe", + "PointerSope", + "PointerSbe", + "Pointerd0en", + "Pointerde0n", + "Pointerd0ne", + "Pointerdn0e", + "Pointerdne0", + "Pointerd0ien", + "Pointerdi0en", + "Pointerdp0en", + "Pointerd0pen", + "Pointerd0ine", + "Pointerdi0ne", + "Pointerdp0ne", + "Pointerd0pne", + "Pointerd0eb", + "Pointerde0b", + "Pointerd0be", + "Pointerdb0e", + "Pointerdbe0", + "Pointerd0ieb", + "Pointerdi0eb", + "Pointerdp0eb", + "Pointerd0peb", + "Pointerd0ibe", + "Pointerdi0be", + "Pointerdp0be", + "Pointerd0pbe", + "PointerS0en", + "PointerSe0n", + "PointerS0ne", + "PointerSn0e", + "PointerSne0", + "PointerS0ien", + "PointerSi0en", + "PointerSp0en", + "PointerS0pen", + "PointerS0ine", + "PointerSi0ne", + "PointerSp0ne", + "PointerS0pne", + "PointerS0eb", + "PointerSe0b", + "PointerS0be", + "PointerSb0e", + "PointerSbe0", + "PointerS0ieb", + "PointerSi0eb", + "PointerSp0eb", + "PointerS0peb", + "PointerS0ibe", + "PointerSi0be", + "PointerSp0be", + "PointerS0pbe", + "Pointerd0e", + "Pointerde0", + "Pointerd0ie", + "Pointerdi0e", + "Pointerdp0e", + "Pointerd0pe", + "PointerS0e", + "PointerSe0", + "PointerS0ie", + "PointerSi0e", + "PointerSp0e", + "PointerS0pe", + "Pointerd9en", + "Pointerde9n", + "Pointerd9ne", + "Pointerdn9e", + "Pointerdne9", + "Pointerd9ien", + "Pointerdi9en", + "Pointerdp9en", + "Pointerd9pen", + "Pointerd9ine", + "Pointerdi9ne", + "Pointerdp9ne", + "Pointerd9pne", + "Pointerd9eb", + "Pointerde9b", + "Pointerd9be", + "Pointerdb9e", + "Pointerdbe9", + "Pointerd9ieb", + "Pointerdi9eb", + "Pointerdp9eb", + "Pointerd9peb", + "Pointerd9ibe", + "Pointerdi9be", + "Pointerdp9be", + "Pointerd9pbe", + "PointerS9en", + "PointerSe9n", + "PointerS9ne", + "PointerSn9e", + "PointerSne9", + "PointerS9ien", + "PointerSi9en", + "PointerSp9en", + "PointerS9pen", + "PointerS9ine", + "PointerSi9ne", + "PointerSp9ne", + "PointerS9pne", + "PointerS9eb", + "PointerSe9b", + "PointerS9be", + "PointerSb9e", + "PointerSbe9", + "PointerS9ieb", + "PointerSi9eb", + "PointerSp9eb", + "PointerS9peb", + "PointerS9ibe", + "PointerSi9be", + "PointerSp9be", + "PointerS9pbe", + "Pointerd9e", + "Pointerde9", + "Pointerd9ie", + "Pointerdi9e", + "Pointerdp9e", + "Pointerd9pe", + "PointerS9e", + "PointerSe9", + "PointerS9ie", + "PointerSi9e", + "PointerSp9e", + "PointerS9pe", + "PointerFoen", + "PointerFeon", + "PointerFone", + "PointerFnoe", + "PointerFneo", + "PointerFien", + "PointerFein", + "PointerFnie", + "PointerFnei", + "PointerFpen", + "PointerFepn", + "PointerFpne", + "PointerFnpe", + "PointerFnep", + "PointerFoien", + "PointerFpien", + "PointerFioen", + "PointerFipen", + "PointerFpoen", + "PointerFopen", + "PointerFoine", + "PointerFpine", + "PointerFione", + "PointerFipne", + "PointerFpone", + "PointerFopne", + "PointerFoeb", + "PointerFeob", + "PointerFobe", + "PointerFboe", + "PointerFbeo", + "PointerFieb", + "PointerFeib", + "PointerFibe", + "PointerFbie", + "PointerFbei", + "PointerFpeb", + "PointerFepb", + "PointerFpbe", + "PointerFbpe", + "PointerFbep", + "PointerFoieb", + "PointerFpieb", + "PointerFioeb", + "PointerFipeb", + "PointerFpoeb", + "PointerFopeb", + "PointerFoibe", + "PointerFpibe", + "PointerFiobe", + "PointerFipbe", + "PointerFpobe", + "PointerFopbe", + "PointerFoe", + "PointerFeo", + "PointerFne", + "PointerFie", + "PointerFei", + "PointerFpe", + "PointerFep", + "PointerFoie", + "PointerFpie", + "PointerFioe", + "PointerFipe", + "PointerFpoe", + "PointerFope", + "PointerFbe", + "PointerF0en", + "PointerFe0n", + "PointerF0ne", + "PointerFn0e", + "PointerFne0", + "PointerF0ien", + "PointerFi0en", + "PointerFp0en", + "PointerF0pen", + "PointerF0ine", + "PointerFi0ne", + "PointerFp0ne", + "PointerF0pne", + "PointerF0eb", + "PointerFe0b", + "PointerF0be", + "PointerFb0e", + "PointerFbe0", + "PointerF0ieb", + "PointerFi0eb", + "PointerFp0eb", + "PointerF0peb", + "PointerF0ibe", + "PointerFi0be", + "PointerFp0be", + "PointerF0pbe", + "PointerF0e", + "PointerFe0", + "PointerF0ie", + "PointerFi0e", + "PointerFp0e", + "PointerF0pe", + "PointerF9en", + "PointerFe9n", + "PointerF9ne", + "PointerFn9e", + "PointerFne9", + "PointerF9ien", + "PointerFi9en", + "PointerFp9en", + "PointerF9pen", + "PointerF9ine", + "PointerFi9ne", + "PointerFp9ne", + "PointerF9pne", + "PointerF9eb", + "PointerFe9b", + "PointerF9be", + "PointerFb9e", + "PointerFbe9", + "PointerF9ieb", + "PointerFi9eb", + "PointerFp9eb", + "PointerF9peb", + "PointerF9ibe", + "PointerFi9be", + "PointerFp9be", + "PointerF9pbe", + "PointerF9e", + "PointerFe9", + "PointerF9ie", + "PointerFi9e", + "PointerFp9e", + "PointerF9pe", + "Pointerdoem", + "Pointerdeom", + "Pointerdome", + "Pointerdmoe", + "Pointerdmeo", + "Pointerdeim", + "Pointerdime", + "Pointerdmie", + "Pointerdmei", + "Pointerdpem", + "Pointerdepm", + "Pointerdpme", + "Pointerdmpe", + "Pointerdmep", + "Pointerdoiem", + "Pointerdpiem", + "Pointerdipem", + "Pointerdpoem", + "Pointerdoime", + "Pointerdpime", + "Pointerdipme", + "Pointerdpome", + "Pointerdopme", + "PointerSoem", + "PointerSeom", + "PointerSmoe", + "PointerSmeo", + "PointerSiem", + "PointerSeim", + "PointerSime", + "PointerSmie", + "PointerSmei", + "PointerSpem", + "PointerSepm", + "PointerSpme", + "PointerSmpe", + "PointerSmep", + "PointerSoiem", + "PointerSpiem", + "PointerSioem", + "PointerSipem", + "PointerSpoem", + "PointerSopem", + "PointerSoime", + "PointerSiome", + "PointerSipme", + "PointerSpome", + "PointerSopme", + "Pointerdme", + "PointerSme", + "Pointerd0em", + "Pointerde0m", + "Pointerd0me", + "Pointerdm0e", + "Pointerdme0", + "Pointerd0iem", + "Pointerdi0em", + "Pointerdp0em", + "Pointerd0pem", + "Pointerd0ime", + "Pointerdi0me", + "Pointerdp0me", + "Pointerd0pme", + "PointerS0em", + "PointerSe0m", + "PointerS0me", + "PointerSm0e", + "PointerSme0", + "PointerS0iem", + "PointerSi0em", + "PointerSp0em", + "PointerS0pem", + "PointerS0ime", + "PointerSi0me", + "PointerSp0me", + "PointerS0pme", + "Pointerd9em", + "Pointerde9m", + "Pointerd9me", + "Pointerdm9e", + "Pointerdme9", + "Pointerd9iem", + "Pointerdi9em", + "Pointerdp9em", + "Pointerd9pem", + "Pointerd9ime", + "Pointerdi9me", + "Pointerdp9me", + "Pointerd9pme", + "PointerS9em", + "PointerSe9m", + "PointerS9me", + "PointerSm9e", + "PointerSme9", + "PointerS9iem", + "PointerSi9em", + "PointerSp9em", + "PointerS9pem", + "PointerS9ime", + "PointerSi9me", + "PointerSp9me", + "PointerS9pme", + "PointerFoem", + "PointerFeom", + "PointerFome", + "PointerFmoe", + "PointerFmeo", + "PointerFiem", + "PointerFeim", + "PointerFime", + "PointerFmie", + "PointerFmei", + "PointerFpem", + "PointerFepm", + "PointerFpme", + "PointerFmpe", + "PointerFmep", + "PointerFoiem", + "PointerFpiem", + "PointerFioem", + "PointerFipem", + "PointerFpoem", + "PointerFopem", + "PointerFoime", + "PointerFpime", + "PointerFiome", + "PointerFipme", + "PointerFpome", + "PointerFopme", + "PointerFme", + "PointerF0em", + "PointerFe0m", + "PointerF0me", + "PointerFm0e", + "PointerFme0", + "PointerF0iem", + "PointerFi0em", + "PointerFp0em", + "PointerF0pem", + "PointerF0ime", + "PointerFi0me", + "PointerFp0me", + "PointerF0pme", + "PointerF9em", + "PointerFe9m", + "PointerF9me", + "PointerFm9e", + "PointerFme9", + "PointerF9iem", + "PointerFi9em", + "PointerFp9em", + "PointerF9pem", + "PointerF9ime", + "PointerFi9me", + "PointerFp9me", + "PointerF9pme", + "PointerBackward", + "PointerBackwards", + "PointerBack", + "PointerBackwars", + "PointerBackwarss", + "PointerBackwar", + "PointerBacxkward", + "PointerBacxkwards", + "PointerBacxk", + "PointerBaxckward", + "PointerBaxckwards", + "PointerBaxck", + "PointerBaxkward", + "PointerBaxkwards", + "PointerBaxk", + "PointerBacxkwar", + "PointerBacxkwars", + "PointerBaxckwar", + "PointerBaxckwars", + "PointerBaxkwar", + "PointerBaxkwars", + "PointerBacxkwarss", + "PointerBaxckwarss", + "PointerBaxkwarss", + "PointerBavckward", + "PointerBavckwards", + "PointerBavck", + "PointerBavckwars", + "PointerBavckwarss", + "PointerBavckwar", + "PointerBakcward", + "PointerBakcwards", + "PointerBakP", + "PointerBakcwars", + "PointerBakcwarss", + "PointerBakcwar", + "PointerBaccward", + "PointerBaccwards", + "PointerBacP", + "PointerBaccwars", + "PointerBaccwarss", + "PointerBaccwar", + "PointerBavkward", + "PointerBavkwards", + "PointerBavk", + "PointerBavkwars", + "PointerBavkwarss", + "PointerBavkwar", + "PointerBacvkward", + "PointerBacvkwards", + "PointerBacvk", + "PointerBacvkwars", + "PointerBacvkwarss", + "PointerBacvkwar", + "PointerBackword", + "PointerBackwords", + "PointerBackwors", + "PointerBackworss", + "PointerBackwor", + "PointerBacxkword", + "PointerBacxkwords", + "PointerBaxckword", + "PointerBaxckwords", + "PointerBaxkword", + "PointerBaxkwords", + "PointerBacxkwor", + "PointerBacxkwors", + "PointerBaxckwor", + "PointerBaxckwors", + "PointerBaxkwor", + "PointerBaxkwors", + "PointerBacxkworss", + "PointerBaxckworss", + "PointerBaxkworss", + "PointerBavckword", + "PointerBavckwords", + "PointerBavckwors", + "PointerBavckworss", + "PointerBavckwor", + "PointerBakcword", + "PointerBakcwords", + "PointerBakcwors", + "PointerBakcworss", + "PointerBakcwor", + "PointerBaccword", + "PointerBaccwords", + "PointerBaccwors", + "PointerBaccworss", + "PointerBaccwor", + "PointerBavkword", + "PointerBavkwords", + "PointerBavkwors", + "PointerBavkworss", + "PointerBavkwor", + "PointerBacvkword", + "PointerBacvkwords", + "PointerBacvkwors", + "PointerBacvkworss", + "PointerBacvkwor", + "PointerBacvkwors", + "PStickDown", + "PStickD", + "P-Downn", + "PDownn", + "PFpwn", + "PFpwb", + "PFpw", + "PFpwm", + "PAckwrd", + "PAckwrds", + "PAckwrs", + "PAckwrss", + "PAckwr", + "PAckward", + "PAckwards", + "PAck", + "PAckwars", + "PAckwarss", + "PAckwar", + "PAckword", + "PAckwords", + "PAckwors", + "PAckworss", + "PAckwor", + "PBabkwrd", + "PBabkwrds", + "PBabkwrs", + "PBabkwrss", + "PBabkwr", + "PBabkward", + "PBabkwards", + "PBabk", + "PBabkwars", + "PBabkwarss", + "PBabkwar", + "PBabkword", + "PBabkwords", + "PBabkwors", + "PBabkworss", + "PBabkwor", + "P-Xown", + "PXown", + "P-Doown", + "PDoown", + "P-dowwn", + "Pdowwn", + "Pdonww", + "PSputh", + "PSout", + "PSput", + "PBackwrd", + "PBackwrds", + "PBackwrs", + "PBackwrss", + "PBackwr", + "PBacxkwrd", + "PBacxkwrds", + "PBaxckwrd", + "PBaxckwrds", + "PBaxkwrd", + "PBaxkwrds", + "PBacxkwr", + "PBacxkwrs", + "PBaxckwr", + "PBaxckwrs", + "PBaxkwr", + "PBaxkwrs", + "PBacxkwrss", + "PBaxckwrss", + "PBaxkwrss", + "PBavckwrd", + "PBavckwrds", + "PBavckwrs", + "PBavckwrss", + "PBavckwr", + "PBakcwrd", + "PBakcwrds", + "PBakcwrs", + "PBakcwrss", + "PBakcwr", + "PBaccwrd", + "PBaccwrds", + "PBaccwrs", + "PBaccwrss", + "PBaccwr", + "PBavkwrd", + "PBavkwrds", + "PBavkwrs", + "PBavkwrss", + "PBavkwr", + "PBacvkwrd", + "PBacvkwrds", + "PBacvkwrs", + "PBacvkwrss", + "PBacvkwr", + "P-Doqn", + "PDoqn", + "P-down", + "PReverse", + "Pdown", + "Pdwon", + "Pdonw", + "Pdnow", + "Pdnwo", + "PD", + "Pv", + "P↓", + "PSouth", + "PS", + "P▼", + "Pdiwn", + "Pdwin", + "Pdinw", + "Pdniw", + "Pdnwi", + "Pdpwn", + "Pdwpn", + "Pdpnw", + "Pdnpw", + "Pdnwp", + "Pdon", + "Pdin", + "Pdpn", + "Pdoiwn", + "Pdpiwn", + "Pdipwn", + "Pdpown", + "Pdopwn", + "Pdoinw", + "Pdpinw", + "Pdipnw", + "Pdponw", + "Pdopnw", + "Pdowb", + "Pdwob", + "Pdobw", + "Pdbow", + "Pdbwo", + "Pdiwb", + "Pdwib", + "Pdibw", + "Pdbiw", + "Pdbwi", + "Pdpwb", + "Pdwpb", + "Pdpbw", + "Pdbpw", + "Pdbwp", + "Pdob", + "Pdib", + "Pdpb", + "Pdoiwb", + "Pdpiwb", + "Pdipwb", + "Pdpowb", + "Pdopwb", + "Pdoibw", + "Pdpibw", + "Pdipbw", + "Pdpobw", + "Pdopbw", + "PSown", + "PSwon", + "PSonw", + "PSnow", + "PSnwo", + "PSiwn", + "PSinw", + "PSniw", + "PSnwi", + "PSpwn", + "PSwpn", + "PSpnw", + "PSnpw", + "PSnwp", + "PSpn", + "PSoiwn", + "PSpiwn", + "PSiown", + "PSipwn", + "PSpown", + "PSopwn", + "PSoinw", + "PSionw", + "PSipnw", + "PSponw", + "PSopnw", + "PSowb", + "PSwob", + "PSobw", + "PSbow", + "PSbwo", + "PSiwb", + "PSwib", + "PSibw", + "PSbiw", + "PSbwi", + "PSpwb", + "PSwpb", + "PSpbw", + "PSbpw", + "PSbwp", + "PSob", + "PSib", + "PSpb", + "PSoiwb", + "PSpiwb", + "PSiowb", + "PSipwb", + "PSpowb", + "PSopwb", + "PSoibw", + "PSpibw", + "PSiobw", + "PSipbw", + "PSpobw", + "PSopbw", + "Pdow", + "Pdwo", + "Pdno", + "Pdnw", + "Pdiw", + "Pdwi", + "Pdni", + "Pdpw", + "Pdwp", + "Pdnp", + "Pdoiw", + "Pdpiw", + "Pdipw", + "Pdpow", + "Pdopw", + "Pdoin", + "Pdpin", + "Pdipn", + "Pdpon", + "Pdopn", + "Pdbo", + "Pdbw", + "Pdbi", + "Pdbp", + "Pdoib", + "Pdpib", + "Pdipb", + "Pdpob", + "Pdopb", + "PSow", + "PSwo", + "PSno", + "PSnw", + "PSiw", + "PSwi", + "PSni", + "PSpw", + "PSwp", + "PSnp", + "PSoiw", + "PSpiw", + "PSiow", + "PSipw", + "PSpow", + "PSopw", + "PSoin", + "PSion", + "PSipn", + "PSpon", + "PSopn", + "PSbo", + "PSbw", + "PSbi", + "PSbp", + "PSoib", + "PSpib", + "PSiob", + "PSipb", + "PSpob", + "PSopb", + "Pd0wn", + "Pdw0n", + "Pd0nw", + "Pdn0w", + "Pdnw0", + "PS0uth", + "Pd0n", + "Pd0iwn", + "Pdi0wn", + "Pdp0wn", + "Pd0pwn", + "Pd0inw", + "Pdi0nw", + "Pdp0nw", + "Pd0pnw", + "Pd0wb", + "Pdw0b", + "Pd0bw", + "Pdb0w", + "Pdbw0", + "Pd0b", + "Pd0iwb", + "Pdi0wb", + "Pdp0wb", + "Pd0pwb", + "Pd0ibw", + "Pdi0bw", + "Pdp0bw", + "Pd0pbw", + "PS0wn", + "PSw0n", + "PS0nw", + "PSn0w", + "PSnw0", + "PS0n", + "PS0iwn", + "PSi0wn", + "PSp0wn", + "PS0pwn", + "PS0inw", + "PSi0nw", + "PSp0nw", + "PS0pnw", + "PS0wb", + "PSw0b", + "PS0bw", + "PSb0w", + "PSbw0", + "PS0b", + "PS0iwb", + "PSi0wb", + "PSp0wb", + "PS0pwb", + "PS0ibw", + "PSi0bw", + "PSp0bw", + "PS0pbw", + "Pd0w", + "Pdw0", + "Pdn0", + "Pd0iw", + "Pdi0w", + "Pdp0w", + "Pd0pw", + "Pd0in", + "Pdi0n", + "Pdp0n", + "Pd0pn", + "Pdb0", + "Pd0ib", + "Pdi0b", + "Pdp0b", + "Pd0pb", + "PS0w", + "PSw0", + "PSn0", + "PS0iw", + "PSi0w", + "PSp0w", + "PS0pw", + "PS0in", + "PSi0n", + "PSp0n", + "PS0pn", + "PSb0", + "PS0ib", + "PSi0b", + "PSp0b", + "PS0pb", + "Pd9wn", + "Pdw9n", + "Pd9nw", + "Pdn9w", + "Pdnw9", + "PS9uth", + "Pd9n", + "Pd9iwn", + "Pdi9wn", + "Pdp9wn", + "Pd9pwn", + "Pd9inw", + "Pdi9nw", + "Pdp9nw", + "Pd9pnw", + "Pd9wb", + "Pdw9b", + "Pd9bw", + "Pdb9w", + "Pdbw9", + "Pd9b", + "Pd9iwb", + "Pdi9wb", + "Pdp9wb", + "Pd9pwb", + "Pd9ibw", + "Pdi9bw", + "Pdp9bw", + "Pd9pbw", + "PS9wn", + "PSw9n", + "PS9nw", + "PSn9w", + "PSnw9", + "PS9n", + "PS9iwn", + "PSi9wn", + "PSp9wn", + "PS9pwn", + "PS9inw", + "PSi9nw", + "PSp9nw", + "PS9pnw", + "PS9wb", + "PSw9b", + "PS9bw", + "PSb9w", + "PSbw9", + "PS9b", + "PS9iwb", + "PSi9wb", + "PSp9wb", + "PS9pwb", + "PS9ibw", + "PSi9bw", + "PSp9bw", + "PS9pbw", + "Pd9w", + "Pdw9", + "Pdn9", + "Pd9iw", + "Pdi9w", + "Pdp9w", + "Pd9pw", + "Pd9in", + "Pdi9n", + "Pdp9n", + "Pd9pn", + "Pdb9", + "Pd9ib", + "Pdi9b", + "Pdp9b", + "Pd9pb", + "PS9w", + "PSw9", + "PSn9", + "PS9iw", + "PSi9w", + "PSp9w", + "PS9pw", + "PS9in", + "PSi9n", + "PSp9n", + "PS9pn", + "PSb9", + "PS9ib", + "PSi9b", + "PSp9b", + "PS9pb", + "PFown", + "PFwon", + "PFonw", + "PFnow", + "PFnwo", + "PF", + "PFiwn", + "PFwin", + "PFinw", + "PFniw", + "PFnwi", + "PFwpn", + "PFpnw", + "PFnpw", + "PFnwp", + "PFon", + "PFin", + "PFpn", + "PFoiwn", + "PFpiwn", + "PFiown", + "PFipwn", + "PFpown", + "PFopwn", + "PFoinw", + "PFpinw", + "PFionw", + "PFipnw", + "PFponw", + "PFopnw", + "PFowb", + "PFwob", + "PFobw", + "PFbow", + "PFbwo", + "PFiwb", + "PFwib", + "PFibw", + "PFbiw", + "PFbwi", + "PFwpb", + "PFpbw", + "PFbpw", + "PFbwp", + "PFob", + "PFib", + "PFpb", + "PFoiwb", + "PFpiwb", + "PFiowb", + "PFipwb", + "PFpowb", + "PFopwb", + "PFoibw", + "PFpibw", + "PFiobw", + "PFipbw", + "PFpobw", + "PFopbw", + "PFow", + "PFwo", + "PFno", + "PFnw", + "PFiw", + "PFwi", + "PFni", + "PFwp", + "PFnp", + "PFoiw", + "PFpiw", + "PFiow", + "PFipw", + "PFpow", + "PFopw", + "PFoin", + "PFpin", + "PFion", + "PFipn", + "PFpon", + "PFopn", + "PFbo", + "PFbw", + "PFbi", + "PFbp", + "PFoib", + "PFpib", + "PFiob", + "PFipb", + "PFpob", + "PFopb", + "PF0wn", + "PFw0n", + "PF0nw", + "PFn0w", + "PFnw0", + "PF0n", + "PF0iwn", + "PFi0wn", + "PFp0wn", + "PF0pwn", + "PF0inw", + "PFi0nw", + "PFp0nw", + "PF0pnw", + "PF0wb", + "PFw0b", + "PF0bw", + "PFb0w", + "PFbw0", + "PF0b", + "PF0iwb", + "PFi0wb", + "PFp0wb", + "PF0pwb", + "PF0ibw", + "PFi0bw", + "PFp0bw", + "PF0pbw", + "PF0w", + "PFw0", + "PFn0", + "PF0iw", + "PFi0w", + "PFp0w", + "PF0pw", + "PF0in", + "PFi0n", + "PFp0n", + "PF0pn", + "PFb0", + "PF0ib", + "PFi0b", + "PFp0b", + "PF0pb", + "PF9wn", + "PFw9n", + "PF9nw", + "PFn9w", + "PFnw9", + "PF9n", + "PF9iwn", + "PFi9wn", + "PFp9wn", + "PF9pwn", + "PF9inw", + "PFi9nw", + "PFp9nw", + "PF9pnw", + "PF9wb", + "PFw9b", + "PF9bw", + "PFb9w", + "PFbw9", + "PF9b", + "PF9iwb", + "PFi9wb", + "PFp9wb", + "PF9pwb", + "PF9ibw", + "PFi9bw", + "PFp9bw", + "PF9pbw", + "PF9w", + "PFw9", + "PFn9", + "PF9iw", + "PFi9w", + "PFp9w", + "PF9pw", + "PF9in", + "PFi9n", + "PFp9n", + "PF9pn", + "PFb9", + "PF9ib", + "PFi9b", + "PFp9b", + "PF9pb", + "Pdowm", + "Pdwom", + "Pdomw", + "Pdmow", + "Pdmwo", + "Pdiwm", + "Pdwim", + "Pdimw", + "Pdmiw", + "Pdmwi", + "Pdpwm", + "Pdwpm", + "Pdpmw", + "Pdmpw", + "Pdmwp", + "Pdom", + "Pdim", + "Pdpm", + "Pdoiwm", + "Pdpiwm", + "Pdipwm", + "Pdpowm", + "Pdopwm", + "Pdoimw", + "Pdpimw", + "Pdipmw", + "Pdpomw", + "Pdopmw", + "PSowm", + "PSwom", + "PSomw", + "PSmow", + "PSmwo", + "PSiwm", + "PSimw", + "PSmiw", + "PSmwi", + "PSpwm", + "PSwpm", + "PSpmw", + "PSmpw", + "PSmwp", + "PSom", + "PSim", + "PSpm", + "PSoiwm", + "PSpiwm", + "PSiowm", + "PSipwm", + "PSpowm", + "PSopwm", + "PSoimw", + "PSiomw", + "PSipmw", + "PSpomw", + "PSopmw", + "Pdmo", + "Pdmw", + "Pdmi", + "Pdmp", + "Pdoim", + "Pdpim", + "Pdipm", + "Pdpom", + "Pdopm", + "PSmo", + "PSmw", + "PSmi", + "PSmp", + "PSoim", + "PSiom", + "PSipm", + "PSpom", + "PSopm", + "Pd0wm", + "Pdw0m", + "Pd0mw", + "Pdm0w", + "Pdmw0", + "Pd0m", + "Pd0iwm", + "Pdi0wm", + "Pdp0wm", + "Pd0pwm", + "Pd0imw", + "Pdi0mw", + "Pdp0mw", + "Pd0pmw", + "PS0wm", + "PSw0m", + "PS0mw", + "PSm0w", + "PSmw0", + "PS0m", + "PS0iwm", + "PSi0wm", + "PSp0wm", + "PS0pwm", + "PS0imw", + "PSi0mw", + "PSp0mw", + "PS0pmw", + "Pdm0", + "Pd0im", + "Pdi0m", + "Pdp0m", + "Pd0pm", + "PSm0", + "PS0im", + "PSi0m", + "PSp0m", + "PS0pm", + "Pd9wm", + "Pdw9m", + "Pd9mw", + "Pdm9w", + "Pdmw9", + "Pd9m", + "Pd9iwm", + "Pdi9wm", + "Pdp9wm", + "Pd9pwm", + "Pd9imw", + "Pdi9mw", + "Pdp9mw", + "Pd9pmw", + "PS9wm", + "PSw9m", + "PS9mw", + "PSm9w", + "PSmw9", + "PS9m", + "PS9iwm", + "PSi9wm", + "PSp9wm", + "PS9pwm", + "PS9imw", + "PSi9mw", + "PSp9mw", + "PS9pmw", + "Pdm9", + "Pd9im", + "Pdi9m", + "Pdp9m", + "Pd9pm", + "PSm9", + "PS9im", + "PSi9m", + "PSp9m", + "PS9pm", + "PFowm", + "PFwom", + "PFomw", + "PFmow", + "PFmwo", + "PFiwm", + "PFwim", + "PFimw", + "PFmiw", + "PFmwi", + "PFwpm", + "PFpmw", + "PFmpw", + "PFmwp", + "PFom", + "PFim", + "PFpm", + "PFoiwm", + "PFpiwm", + "PFiowm", + "PFipwm", + "PFpowm", + "PFopwm", + "PFoimw", + "PFpimw", + "PFiomw", + "PFipmw", + "PFpomw", + "PFopmw", + "PFmo", + "PFmw", + "PFmi", + "PFmp", + "PFoim", + "PFpim", + "PFiom", + "PFipm", + "PFpom", + "PFopm", + "PF0wm", + "PFw0m", + "PF0mw", + "PFm0w", + "PFmw0", + "PF0m", + "PF0iwm", + "PFi0wm", + "PFp0wm", + "PF0pwm", + "PF0imw", + "PFi0mw", + "PFp0mw", + "PF0pmw", + "PFm0", + "PF0im", + "PFi0m", + "PFp0m", + "PF0pm", + "PF9wm", + "PFw9m", + "PF9mw", + "PFm9w", + "PFmw9", + "PF9m", + "PF9iwm", + "PFi9wm", + "PFp9wm", + "PF9pwm", + "PF9imw", + "PFi9mw", + "PFp9mw", + "PF9pmw", + "PFm9", + "PF9im", + "PFi9m", + "PFp9m", + "PF9pm", + "Pdoen", + "Pdeon", + "Pdone", + "Pdnoe", + "Pdneo", + "Pdein", + "Pdine", + "Pdnie", + "Pdnei", + "Pdpen", + "Pdepn", + "Pdpne", + "Pdnpe", + "Pdnep", + "Pdoien", + "Pdpien", + "Pdipen", + "Pdpoen", + "Pdoine", + "Pdpine", + "Pdipne", + "Pdpone", + "Pdopne", + "Pdoeb", + "Pdeob", + "Pdobe", + "Pdboe", + "Pdbeo", + "Pdeib", + "Pdibe", + "Pdbie", + "Pdbei", + "Pdpeb", + "Pdepb", + "Pdpbe", + "Pdbpe", + "Pdbep", + "Pdoieb", + "Pdpieb", + "Pdipeb", + "Pdpoeb", + "Pdoibe", + "Pdpibe", + "Pdipbe", + "Pdpobe", + "Pdopbe", + "PSoen", + "PSeon", + "PSone", + "PSnoe", + "PSneo", + "PSien", + "PSein", + "PSine", + "PSnie", + "PSnei", + "PSpen", + "PSepn", + "PSpne", + "PSnpe", + "PSnep", + "PSoien", + "PSpien", + "PSioen", + "PSipen", + "PSpoen", + "PSopen", + "PSoine", + "PSione", + "PSipne", + "PSpone", + "PSopne", + "PSoeb", + "PSeob", + "PSobe", + "PSboe", + "PSbeo", + "PSieb", + "PSeib", + "PSibe", + "PSbie", + "PSbei", + "PSpeb", + "PSepb", + "PSpbe", + "PSbpe", + "PSbep", + "PSoieb", + "PSpieb", + "PSioeb", + "PSipeb", + "PSpoeb", + "PSopeb", + "PSoibe", + "PSpibe", + "PSiobe", + "PSipbe", + "PSpobe", + "PSopbe", + "Pdoe", + "Pdeo", + "Pdne", + "Pdei", + "Pdpe", + "Pdep", + "Pdoie", + "Pdpie", + "Pdipe", + "Pdpoe", + "Pdbe", + "PSoe", + "PSeo", + "PSne", + "PSie", + "PSei", + "PSpe", + "PSep", + "PSoie", + "PSpie", + "PSioe", + "PSipe", + "PSpoe", + "PSope", + "PSbe", + "Pd0en", + "Pde0n", + "Pd0ne", + "Pdn0e", + "Pdne0", + "Pd0ien", + "Pdi0en", + "Pdp0en", + "Pd0pen", + "Pd0ine", + "Pdi0ne", + "Pdp0ne", + "Pd0pne", + "Pd0eb", + "Pde0b", + "Pd0be", + "Pdb0e", + "Pdbe0", + "Pd0ieb", + "Pdi0eb", + "Pdp0eb", + "Pd0peb", + "Pd0ibe", + "Pdi0be", + "Pdp0be", + "Pd0pbe", + "PS0en", + "PSe0n", + "PS0ne", + "PSn0e", + "PSne0", + "PS0ien", + "PSi0en", + "PSp0en", + "PS0pen", + "PS0ine", + "PSi0ne", + "PSp0ne", + "PS0pne", + "PS0eb", + "PSe0b", + "PS0be", + "PSb0e", + "PSbe0", + "PS0ieb", + "PSi0eb", + "PSp0eb", + "PS0peb", + "PS0ibe", + "PSi0be", + "PSp0be", + "PS0pbe", + "Pd0e", + "Pde0", + "Pd0ie", + "Pdi0e", + "Pdp0e", + "Pd0pe", + "PS0e", + "PSe0", + "PS0ie", + "PSi0e", + "PSp0e", + "PS0pe", + "Pd9en", + "Pde9n", + "Pd9ne", + "Pdn9e", + "Pdne9", + "Pd9ien", + "Pdi9en", + "Pdp9en", + "Pd9pen", + "Pd9ine", + "Pdi9ne", + "Pdp9ne", + "Pd9pne", + "Pd9eb", + "Pde9b", + "Pd9be", + "Pdb9e", + "Pdbe9", + "Pd9ieb", + "Pdi9eb", + "Pdp9eb", + "Pd9peb", + "Pd9ibe", + "Pdi9be", + "Pdp9be", + "Pd9pbe", + "PS9en", + "PSe9n", + "PS9ne", + "PSn9e", + "PSne9", + "PS9ien", + "PSi9en", + "PSp9en", + "PS9pen", + "PS9ine", + "PSi9ne", + "PSp9ne", + "PS9pne", + "PS9eb", + "PSe9b", + "PS9be", + "PSb9e", + "PSbe9", + "PS9ieb", + "PSi9eb", + "PSp9eb", + "PS9peb", + "PS9ibe", + "PSi9be", + "PSp9be", + "PS9pbe", + "Pd9e", + "Pde9", + "Pd9ie", + "Pdi9e", + "Pdp9e", + "Pd9pe", + "PS9e", + "PSe9", + "PS9ie", + "PSi9e", + "PSp9e", + "PS9pe", + "PFoen", + "PFeon", + "PFone", + "PFnoe", + "PFneo", + "PFien", + "PFein", + "PFnie", + "PFnei", + "PFpen", + "PFepn", + "PFpne", + "PFnpe", + "PFnep", + "PFoien", + "PFpien", + "PFioen", + "PFipen", + "PFpoen", + "PFopen", + "PFoine", + "PFpine", + "PFione", + "PFipne", + "PFpone", + "PFopne", + "PFoeb", + "PFeob", + "PFobe", + "PFboe", + "PFbeo", + "PFieb", + "PFeib", + "PFibe", + "PFbie", + "PFbei", + "PFpeb", + "PFepb", + "PFpbe", + "PFbpe", + "PFbep", + "PFoieb", + "PFpieb", + "PFioeb", + "PFipeb", + "PFpoeb", + "PFopeb", + "PFoibe", + "PFpibe", + "PFiobe", + "PFipbe", + "PFpobe", + "PFopbe", + "PFoe", + "PFeo", + "PFne", + "PFie", + "PFei", + "PFpe", + "PFep", + "PFoie", + "PFpie", + "PFioe", + "PFipe", + "PFpoe", + "PFope", + "PFbe", + "PF0en", + "PFe0n", + "PF0ne", + "PFn0e", + "PFne0", + "PF0ien", + "PFi0en", + "PFp0en", + "PF0pen", + "PF0ine", + "PFi0ne", + "PFp0ne", + "PF0pne", + "PF0eb", + "PFe0b", + "PF0be", + "PFb0e", + "PFbe0", + "PF0ieb", + "PFi0eb", + "PFp0eb", + "PF0peb", + "PF0ibe", + "PFi0be", + "PFp0be", + "PF0pbe", + "PF0e", + "PFe0", + "PF0ie", + "PFi0e", + "PFp0e", + "PF0pe", + "PF9en", + "PFe9n", + "PF9ne", + "PFn9e", + "PFne9", + "PF9ien", + "PFi9en", + "PFp9en", + "PF9pen", + "PF9ine", + "PFi9ne", + "PFp9ne", + "PF9pne", + "PF9eb", + "PFe9b", + "PF9be", + "PFb9e", + "PFbe9", + "PF9ieb", + "PFi9eb", + "PFp9eb", + "PF9peb", + "PF9ibe", + "PFi9be", + "PFp9be", + "PF9pbe", + "PF9e", + "PFe9", + "PF9ie", + "PFi9e", + "PFp9e", + "PF9pe", + "Pdoem", + "Pdeom", + "Pdome", + "Pdmoe", + "Pdmeo", + "Pdeim", + "Pdime", + "Pdmie", + "Pdmei", + "Pdpem", + "Pdepm", + "Pdpme", + "Pdmpe", + "Pdmep", + "Pdoiem", + "Pdpiem", + "Pdipem", + "Pdpoem", + "Pdoime", + "Pdpime", + "Pdipme", + "Pdpome", + "Pdopme", + "PSoem", + "PSeom", + "PSmoe", + "PSmeo", + "PSiem", + "PSeim", + "PSime", + "PSmie", + "PSmei", + "PSpem", + "PSepm", + "PSpme", + "PSmpe", + "PSmep", + "PSoiem", + "PSpiem", + "PSioem", + "PSipem", + "PSpoem", + "PSopem", + "PSoime", + "PSiome", + "PSipme", + "PSpome", + "PSopme", + "Pdme", + "PSme", + "Pd0em", + "Pde0m", + "Pd0me", + "Pdm0e", + "Pdme0", + "Pd0iem", + "Pdi0em", + "Pdp0em", + "Pd0pem", + "Pd0ime", + "Pdi0me", + "Pdp0me", + "Pd0pme", + "PS0em", + "PSe0m", + "PS0me", + "PSm0e", + "PSme0", + "PS0iem", + "PSi0em", + "PSp0em", + "PS0pem", + "PS0ime", + "PSi0me", + "PSp0me", + "PS0pme", + "Pd9em", + "Pde9m", + "Pd9me", + "Pdm9e", + "Pdme9", + "Pd9iem", + "Pdi9em", + "Pdp9em", + "Pd9pem", + "Pd9ime", + "Pdi9me", + "Pdp9me", + "Pd9pme", + "PS9em", + "PSe9m", + "PS9me", + "PSm9e", + "PSme9", + "PS9iem", + "PSi9em", + "PSp9em", + "PS9pem", + "PS9ime", + "PSi9me", + "PSp9me", + "PS9pme", + "PFoem", + "PFeom", + "PFome", + "PFmoe", + "PFmeo", + "PFiem", + "PFeim", + "PFime", + "PFmie", + "PFmei", + "PFpem", + "PFepm", + "PFpme", + "PFmpe", + "PFmep", + "PFoiem", + "PFpiem", + "PFioem", + "PFipem", + "PFpoem", + "PFopem", + "PFoime", + "PFpime", + "PFiome", + "PFipme", + "PFpome", + "PFopme", + "PFme", + "PF0em", + "PFe0m", + "PF0me", + "PFm0e", + "PFme0", + "PF0iem", + "PFi0em", + "PFp0em", + "PF0pem", + "PF0ime", + "PFi0me", + "PFp0me", + "PF0pme", + "PF9em", + "PFe9m", + "PF9me", + "PFm9e", + "PFme9", + "PF9iem", + "PFi9em", + "PFp9em", + "PF9pem", + "PF9ime", + "PFi9me", + "PFp9me", + "PF9pme", + "PBackward", + "PBackwards", + "PBack", + "PBackwars", + "PBackwarss", + "PBackwar", + "PBacxkward", + "PBacxkwards", + "PBacxk", + "PBaxckward", + "PBaxckwards", + "PBaxck", + "PBaxkward", + "PBaxkwards", + "PBaxk", + "PBacxkwar", + "PBacxkwars", + "PBaxckwar", + "PBaxckwars", + "PBaxkwar", + "PBaxkwars", + "PBacxkwarss", + "PBaxckwarss", + "PBaxkwarss", + "PBavckward", + "PBavckwards", + "PBavck", + "PBavckwars", + "PBavckwarss", + "PBavckwar", + "PBakcward", + "PBakcwards", + "PBakP", + "PBakcwars", + "PBakcwarss", + "PBakcwar", + "PBaccward", + "PBaccwards", + "PBacP", + "PBaccwars", + "PBaccwarss", + "PBaccwar", + "PBavkward", + "PBavkwards", + "PBavk", + "PBavkwars", + "PBavkwarss", + "PBavkwar", + "PBacvkward", + "PBacvkwards", + "PBacvk", + "PBacvkwars", + "PBacvkwarss", + "PBacvkwar", + "PBackword", + "PBackwords", + "PBackwors", + "PBackworss", + "PBackwor", + "PBacxkword", + "PBacxkwords", + "PBaxckword", + "PBaxckwords", + "PBaxkword", + "PBaxkwords", + "PBacxkwor", + "PBacxkwors", + "PBaxckwor", + "PBaxckwors", + "PBaxkwor", + "PBaxkwors", + "PBacxkworss", + "PBaxckworss", + "PBaxkworss", + "PBavckword", + "PBavckwords", + "PBavckwors", + "PBavckworss", + "PBavckwor", + "PBakcword", + "PBakcwords", + "PBakcwors", + "PBakcworss", + "PBakcwor", + "PBaccword", + "PBaccwords", + "PBaccwors", + "PBaccworss", + "PBaccwor", + "PBavkword", + "PBavkwords", + "PBavkwors", + "PBavkworss", + "PBavkwor", + "PBacvkword", + "PBacvkwords", + "PBacvkwors", + "PBacvkworss", + "PBacvkwor", + "DownnP", + "DownP" + ], + "color_value": "#FFE400", + "is_blacklisted": false, + "opposite_input_value": "0x00007F7F7F000000L", + "opposite_input_name": "P^", + "has_opposite": true, + "input_type": 2, + "keyboard_value": 40, + "keyboard_key_name": "ArrowDown" + }, + { + "input_value": "0x00007F7F7F7F0100L", + "input_name": "Mode", + "input_alias": [ + "Mode" + ], + "color_value": "#FFFFFF", + "is_blacklisted": true, + "opposite_input_value": "0x00007F7F7F7F0100L", + "opposite_input_name": "Mode", + "has_opposite": false, + "input_type": 3, + "keyboard_value": null, + "keyboard_key_name": null + }, + { + "input_value": "0x00007F7F7F7F0001L", + "input_name": "Riot", + "input_alias": [ + "Riot" + ], + "color_value": "#FFFFFF", + "is_blacklisted": false, + "opposite_input_value": "0x00007F7F7F7F0001L", + "opposite_input_name": "Riot", + "has_opposite": false, + "input_type": 3, + "keyboard_value": null, + "keyboard_key_name": null + }, + { + "input_value": "0x00007F7F7F7F0002L", + "input_name": "Wait", + "input_alias": [ + "Cancel", + "Cacnel", + "Wati", + "Wita", + "Wiat", + "Wsit", + "Sto0o", + "St0", + "Sth0", + "St[0", + "Sy0", + "Syh0", + "Sy[0", + "Dt0", + "Dth0", + "Dt[0", + "Dy0", + "Dyh0", + "Dy[0", + "Wto0", + "Wtah0", + "Wto[0", + "Wot0", + "Wti0", + "Wti[0", + "Wit0", + "Wtu0", + "Wtu[0", + "Wut0", + "Wyo0", + "Wyah0", + "Wyo[0", + "Woy0", + "Wyi0", + "Wyi[0", + "Wiy0", + "Wyu0", + "Wyu[0", + "Wuy0", + "Sto0", + "Stah0", + "Sto[0", + "Sot0", + "Sti0", + "Sti[0", + "Sit0", + "Stu0", + "Stu[0", + "Sut0", + "Syo0", + "Syah0", + "Syo[0", + "Soy0", + "Syi0", + "Syi[0", + "Siy0", + "Syu0", + "Syu[0", + "Suy0", + "Dto0", + "Dtah0", + "Dto[0", + "Dot0", + "Dti0", + "Dti[0", + "Dit0", + "Dtu0", + "Dtu[0", + "Dut0", + "Dyo0", + "Dyah0", + "Dyo[0", + "Doy0", + "Dyi0", + "Dyi[0", + "Diy0", + "Dyu0", + "Dyu[0", + "Duy0", + "Atopo", + "Atp", + "Athp", + "At[p", + "Ayp", + "Ayhp", + "Ay[p", + "Atop", + "Atahp", + "Ato[p", + "Aotp", + "Atip", + "Ati[p", + "Aitp", + "Atup", + "Atu[p", + "Autp", + "Ayop", + "Ayahp", + "Ayo[p", + "Aoyp", + "Ayip", + "Ayi[p", + "Aiyp", + "Ayup", + "Ayu[p", + "Auyp", + "Ato0o", + "At0", + "Ath0", + "At[0", + "Ay0", + "Ayh0", + "Ay[0", + "Ato0", + "Atah0", + "Ato[0", + "Aot0", + "Ati0", + "Ati[0", + "Ait0", + "Atu0", + "Atu[0", + "Aut0", + "Ayo0", + "Ayah0", + "Ayo[0", + "Aoy0", + "Ayi0", + "Ayi[0", + "Aiy0", + "Ayu0", + "Ayu[0", + "Auy0", + "Stopo", + "Wwait", + "Wtp", + "Wthp", + "Wt[p", + "Wyp", + "Wyhp", + "Wy[p", + "Stp", + "Sthp", + "St[p", + "Syp", + "Syhp", + "Sy[p", + "Dtp", + "Dthp", + "Dt[p", + "Dyp", + "Dyhp", + "Dy[p", + "Waor", + "Aor", + "Wair", + "Waur", + "Waiyr", + "Wir", + "Wiyr", + "Wit", + "Wiyt", + "Wtop", + "Wtahp", + "Wto[p", + "Wotp", + "Wtip", + "Wti[p", + "Witp", + "Wtup", + "Wtu[p", + "Wutp", + "Wyop", + "Wyahp", + "Wyo[p", + "Woyp", + "Wyip", + "Wyi[p", + "Wiyp", + "Wyup", + "Wyu[p", + "Wuyp", + "Waot", + "Aot", + "Wait", + "Qait", + "P", + "Xp", + "Exp", + "Stop", + "Stahp", + "Sto[p", + "Sotp", + "Stip", + "Sti[p", + "Sitp", + "Stup", + "Stu[p", + "Sutp", + "Syop", + "Syahp", + "Syo[p", + "Soyp", + "Syip", + "Syi[p", + "Siyp", + "Syup", + "Syu[p", + "Suyp", + "Dtop", + "Dtahp", + "Dto[p", + "Dotp", + "Dtip", + "Dti[p", + "Ditp", + "Dtup", + "Dtu[p", + "Dutp", + "Dyop", + "Dyahp", + "Dyo[p", + "Doyp", + "Dyip", + "Dyi[p", + "Diyp", + "Dyup", + "Dyu[p", + "Duyp", + "Waut", + "Waiyt", + "Ait" + ], + "color_value": "#FFFFFF", + "is_blacklisted": false, + "opposite_input_value": "0x00007F7F7F7F0002L", + "opposite_input_name": "Wait", + "has_opposite": false, + "input_type": 3, + "keyboard_value": null, + "keyboard_key_name": null + }, + { + "input_value": "0x00007F7F7F7F0004L", + "input_name": "Power", + "input_alias": [ + "ShutOff", + "ShutFpwn", + "ShutFpwb", + "ShutFpw", + "ShutFpwm", + "ShutDoown", + "Shutdowwn", + "Shutdonww", + "Suicide", + "Open", + "Close", + "Surrender", + "Die", + "Esc", + "Escape", + "Exit", + "ShutDoqn", + "Leave", + "AltF4", + "Alt-F4", + "Alt+F4", + "Quit", + "Qiut", + "Sleep", + "Power", + "PowerButton", + "PowerOn", + "PowerOff", + "On", + "Off", + "PWR", + "PWRON", + "PWROFF", + "PWRBTN", + "PowerBTN", + "Shutdown", + "Shutdwon", + "Shutdonw", + "Shutdnow", + "Shutdnwo", + "Shutdiwn", + "Shutdwin", + "Shutdinw", + "Shutdniw", + "Shutdnwi", + "Shutdpwn", + "Shutdwpn", + "Shutdpnw", + "Shutdnpw", + "Shutdnwp", + "Shutdon", + "Shutdin", + "Shutdpn", + "Shutdoiwn", + "Shutdpiwn", + "Shutdipwn", + "Shutdpown", + "Shutdopwn", + "Shutdoinw", + "Shutdpinw", + "Shutdipnw", + "Shutdponw", + "Shutdopnw", + "Shutdowb", + "Shutdwob", + "Shutdobw", + "Shutdbow", + "Shutdbwo", + "Shutdiwb", + "Shutdwib", + "Shutdibw", + "Shutdbiw", + "Shutdbwi", + "Shutdpwb", + "Shutdwpb", + "Shutdpbw", + "Shutdbpw", + "Shutdbwp", + "Shutdob", + "Shutdib", + "Shutdpb", + "Shutdoiwb", + "Shutdpiwb", + "Shutdipwb", + "Shutdpowb", + "Shutdopwb", + "Shutdoibw", + "Shutdpibw", + "Shutdipbw", + "Shutdpobw", + "Shutdopbw", + "Shutsown", + "Shutswon", + "Shutsonw", + "Shutsnow", + "Shutsnwo", + "Shutsiwn", + "Shutsinw", + "Shutsniw", + "Shutsnwi", + "Shutspwn", + "Shutswpn", + "Shutspnw", + "Shutsnpw", + "Shutsnwp", + "Shutspn", + "Shutsoiwn", + "Shutspiwn", + "Shutsiown", + "Shutsipwn", + "Shutspown", + "Shutsopwn", + "Shutsoinw", + "Shutsionw", + "Shutsipnw", + "Shutsponw", + "Shutsopnw", + "Shutsowb", + "Shutswob", + "Shutsobw", + "Shutsbow", + "Shutsbwo", + "Shutsiwb", + "Shutswib", + "Shutsibw", + "Shutsbiw", + "Shutsbwi", + "Shutspwb", + "Shutswpb", + "Shutspbw", + "Shutsbpw", + "Shutsbwp", + "Shutsob", + "Shutsib", + "Shutspb", + "Shutsoiwb", + "Shutspiwb", + "Shutsiowb", + "Shutsipwb", + "Shutspowb", + "Shutsopwb", + "Shutsoibw", + "Shutspibw", + "Shutsiobw", + "Shutsipbw", + "Shutspobw", + "Shutsopbw", + "Shutdow", + "Shutdwo", + "Shutdno", + "Shutdnw", + "Shutdiw", + "Shutdwi", + "Shutdni", + "Shutdpw", + "Shutdwp", + "Shutdnp", + "Shutdoiw", + "Shutdpiw", + "Shutdipw", + "Shutdpow", + "Shutdopw", + "Shutdoin", + "Shutdpin", + "Shutdipn", + "Shutdpon", + "Shutdopn", + "Shutdbo", + "Shutdbw", + "Shutdbi", + "Shutdbp", + "Shutdoib", + "Shutdpib", + "Shutdipb", + "Shutdpob", + "Shutdopb", + "Shutsow", + "Shutswo", + "Shutsno", + "Shutsnw", + "Shutsiw", + "Shutswi", + "Shutsni", + "Shutspw", + "Shutswp", + "Shutsnp", + "Shutsoiw", + "Shutspiw", + "Shutsiow", + "Shutsipw", + "Shutspow", + "Shutsopw", + "Shutsoin", + "Shutsion", + "Shutsipn", + "Shutspon", + "Shutsopn", + "Shutsbo", + "Shutsbw", + "Shutsbi", + "Shutsbp", + "Shutsoib", + "Shutspib", + "Shutsiob", + "Shutsipb", + "Shutspob", + "Shutsopb", + "P0wer", + "P0werButt0n", + "P0wer0n", + "P0wer0ff", + "0n", + "0ff", + "PWR0N", + "PWR0FF", + "P0werBTN", + "Shutd0wn", + "Shutdw0n", + "Shutd0nw", + "Shutdn0w", + "Shutdnw0", + "Shutd0n", + "Shutd0iwn", + "Shutdi0wn", + "Shutdp0wn", + "Shutd0pwn", + "Shutd0inw", + "Shutdi0nw", + "Shutdp0nw", + "Shutd0pnw", + "Shutd0wb", + "Shutdw0b", + "Shutd0bw", + "Shutdb0w", + "Shutdbw0", + "Shutd0b", + "Shutd0iwb", + "Shutdi0wb", + "Shutdp0wb", + "Shutd0pwb", + "Shutd0ibw", + "Shutdi0bw", + "Shutdp0bw", + "Shutd0pbw", + "Shuts0wn", + "Shutsw0n", + "Shuts0nw", + "Shutsn0w", + "Shutsnw0", + "Shuts0n", + "Shuts0iwn", + "Shutsi0wn", + "Shutsp0wn", + "Shuts0pwn", + "Shuts0inw", + "Shutsi0nw", + "Shutsp0nw", + "Shuts0pnw", + "Shuts0wb", + "Shutsw0b", + "Shuts0bw", + "Shutsb0w", + "Shutsbw0", + "Shuts0b", + "Shuts0iwb", + "Shutsi0wb", + "Shutsp0wb", + "Shuts0pwb", + "Shuts0ibw", + "Shutsi0bw", + "Shutsp0bw", + "Shuts0pbw", + "Shutd0w", + "Shutdw0", + "Shutdn0", + "Shutd0iw", + "Shutdi0w", + "Shutdp0w", + "Shutd0pw", + "Shutd0in", + "Shutdi0n", + "Shutdp0n", + "Shutd0pn", + "Shutdb0", + "Shutd0ib", + "Shutdi0b", + "Shutdp0b", + "Shutd0pb", + "Shuts0w", + "Shutsw0", + "Shutsn0", + "Shuts0iw", + "Shutsi0w", + "Shutsp0w", + "Shuts0pw", + "Shuts0in", + "Shutsi0n", + "Shutsp0n", + "Shuts0pn", + "Shutsb0", + "Shuts0ib", + "Shutsi0b", + "Shutsp0b", + "Shuts0pb", + "P9wer", + "P9werButt9n", + "P9wer9n", + "P9wer9ff", + "9n", + "9ff", + "PWR9N", + "PWR9FF", + "P9werBTN", + "Shutd9wn", + "Shutdw9n", + "Shutd9nw", + "Shutdn9w", + "Shutdnw9", + "Shutd9n", + "Shutd9iwn", + "Shutdi9wn", + "Shutdp9wn", + "Shutd9pwn", + "Shutd9inw", + "Shutdi9nw", + "Shutdp9nw", + "Shutd9pnw", + "Shutd9wb", + "Shutdw9b", + "Shutd9bw", + "Shutdb9w", + "Shutdbw9", + "Shutd9b", + "Shutd9iwb", + "Shutdi9wb", + "Shutdp9wb", + "Shutd9pwb", + "Shutd9ibw", + "Shutdi9bw", + "Shutdp9bw", + "Shutd9pbw", + "Shuts9wn", + "Shutsw9n", + "Shuts9nw", + "Shutsn9w", + "Shutsnw9", + "Shuts9n", + "Shuts9iwn", + "Shutsi9wn", + "Shutsp9wn", + "Shuts9pwn", + "Shuts9inw", + "Shutsi9nw", + "Shutsp9nw", + "Shuts9pnw", + "Shuts9wb", + "Shutsw9b", + "Shuts9bw", + "Shutsb9w", + "Shutsbw9", + "Shuts9b", + "Shuts9iwb", + "Shutsi9wb", + "Shutsp9wb", + "Shuts9pwb", + "Shuts9ibw", + "Shutsi9bw", + "Shutsp9bw", + "Shuts9pbw", + "Shutd9w", + "Shutdw9", + "Shutdn9", + "Shutd9iw", + "Shutdi9w", + "Shutdp9w", + "Shutd9pw", + "Shutd9in", + "Shutdi9n", + "Shutdp9n", + "Shutd9pn", + "Shutdb9", + "Shutd9ib", + "Shutdi9b", + "Shutdp9b", + "Shutd9pb", + "Shuts9w", + "Shutsw9", + "Shutsn9", + "Shuts9iw", + "Shutsi9w", + "Shutsp9w", + "Shuts9pw", + "Shuts9in", + "Shutsi9n", + "Shutsp9n", + "Shuts9pn", + "Shutsb9", + "Shuts9ib", + "Shutsi9b", + "Shutsp9b", + "Shuts9pb", + "ShutFown", + "ShutFwon", + "ShutFonw", + "ShutFnow", + "ShutFnwo", + "ShutFiwn", + "ShutFwin", + "ShutFinw", + "ShutFniw", + "ShutFnwi", + "ShutFwpn", + "ShutFpnw", + "ShutFnpw", + "ShutFnwp", + "ShutFon", + "ShutFin", + "ShutFpn", + "ShutFoiwn", + "ShutFpiwn", + "ShutFiown", + "ShutFipwn", + "ShutFpown", + "ShutFopwn", + "ShutFoinw", + "ShutFpinw", + "ShutFionw", + "ShutFipnw", + "ShutFponw", + "ShutFopnw", + "ShutFowb", + "ShutFwob", + "ShutFobw", + "ShutFbow", + "ShutFbwo", + "ShutFiwb", + "ShutFwib", + "ShutFibw", + "ShutFbiw", + "ShutFbwi", + "ShutFwpb", + "ShutFpbw", + "ShutFbpw", + "ShutFbwp", + "ShutFob", + "ShutFib", + "ShutFpb", + "ShutFoiwb", + "ShutFpiwb", + "ShutFiowb", + "ShutFipwb", + "ShutFpowb", + "ShutFopwb", + "ShutFoibw", + "ShutFpibw", + "ShutFiobw", + "ShutFipbw", + "ShutFpobw", + "ShutFopbw", + "ShutFow", + "ShutFwo", + "ShutFno", + "ShutFnw", + "ShutFiw", + "ShutFwi", + "ShutFni", + "ShutFwp", + "ShutFnp", + "ShutFoiw", + "ShutFpiw", + "ShutFiow", + "ShutFipw", + "ShutFpow", + "ShutFopw", + "ShutFoin", + "ShutFpin", + "ShutFion", + "ShutFipn", + "ShutFpon", + "ShutFopn", + "ShutFbo", + "ShutFbw", + "ShutFbi", + "ShutFbp", + "ShutFoib", + "ShutFpib", + "ShutFiob", + "ShutFipb", + "ShutFpob", + "ShutFopb", + "ShutF0wn", + "ShutFw0n", + "ShutF0nw", + "ShutFn0w", + "ShutFnw0", + "ShutF0n", + "ShutF0iwn", + "ShutFi0wn", + "ShutFp0wn", + "ShutF0pwn", + "ShutF0inw", + "ShutFi0nw", + "ShutFp0nw", + "ShutF0pnw", + "ShutF0wb", + "ShutFw0b", + "ShutF0bw", + "ShutFb0w", + "ShutFbw0", + "ShutF0b", + "ShutF0iwb", + "ShutFi0wb", + "ShutFp0wb", + "ShutF0pwb", + "ShutF0ibw", + "ShutFi0bw", + "ShutFp0bw", + "ShutF0pbw", + "ShutF0w", + "ShutFw0", + "ShutFn0", + "ShutF0iw", + "ShutFi0w", + "ShutFp0w", + "ShutF0pw", + "ShutF0in", + "ShutFi0n", + "ShutFp0n", + "ShutF0pn", + "ShutFb0", + "ShutF0ib", + "ShutFi0b", + "ShutFp0b", + "ShutF0pb", + "ShutF9wn", + "ShutFw9n", + "ShutF9nw", + "ShutFn9w", + "ShutFnw9", + "ShutF9n", + "ShutF9iwn", + "ShutFi9wn", + "ShutFp9wn", + "ShutF9pwn", + "ShutF9inw", + "ShutFi9nw", + "ShutFp9nw", + "ShutF9pnw", + "ShutF9wb", + "ShutFw9b", + "ShutF9bw", + "ShutFb9w", + "ShutFbw9", + "ShutF9b", + "ShutF9iwb", + "ShutFi9wb", + "ShutFp9wb", + "ShutF9pwb", + "ShutF9ibw", + "ShutFi9bw", + "ShutFp9bw", + "ShutF9pbw", + "ShutF9w", + "ShutFw9", + "ShutFn9", + "ShutF9iw", + "ShutFi9w", + "ShutFp9w", + "ShutF9pw", + "ShutF9in", + "ShutFi9n", + "ShutFp9n", + "ShutF9pn", + "ShutFb9", + "ShutF9ib", + "ShutFi9b", + "ShutFp9b", + "ShutF9pb", + "PowerButtom", + "PowerOm", + "Om", + "PWROm", + "PWRBTm", + "PowerBTm", + "Shutdowm", + "Shutdwom", + "Shutdomw", + "Shutdmow", + "Shutdmwo", + "Shutdiwm", + "Shutdwim", + "Shutdimw", + "Shutdmiw", + "Shutdmwi", + "Shutdpwm", + "Shutdwpm", + "Shutdpmw", + "Shutdmpw", + "Shutdmwp", + "Shutdom", + "Shutdim", + "Shutdpm", + "Shutdoiwm", + "Shutdpiwm", + "Shutdipwm", + "Shutdpowm", + "Shutdopwm", + "Shutdoimw", + "Shutdpimw", + "Shutdipmw", + "Shutdpomw", + "Shutdopmw", + "Shutsowm", + "Shutswom", + "Shutsomw", + "Shutsmow", + "Shutsmwo", + "Shutsiwm", + "Shutsimw", + "Shutsmiw", + "Shutsmwi", + "Shutspwm", + "Shutswpm", + "Shutspmw", + "Shutsmpw", + "Shutsmwp", + "Shutsom", + "Shutsim", + "Shutspm", + "Shutsoiwm", + "Shutspiwm", + "Shutsiowm", + "Shutsipwm", + "Shutspowm", + "Shutsopwm", + "Shutsoimw", + "Shutsiomw", + "Shutsipmw", + "Shutspomw", + "Shutsopmw", + "Shutdmo", + "Shutdmw", + "Shutdmi", + "Shutdmp", + "Shutdoim", + "Shutdpim", + "Shutdipm", + "Shutdpom", + "Shutdopm", + "Shutsmo", + "Shutsmw", + "Shutsmi", + "Shutsmp", + "Shutsoim", + "Shutsiom", + "Shutsipm", + "Shutspom", + "Shutsopm", + "P0werButt0m", + "P0wer0m", + "0m", + "PWR0m", + "P0werBTm", + "Shutd0wm", + "Shutdw0m", + "Shutd0mw", + "Shutdm0w", + "Shutdmw0", + "Shutd0m", + "Shutd0iwm", + "Shutdi0wm", + "Shutdp0wm", + "Shutd0pwm", + "Shutd0imw", + "Shutdi0mw", + "Shutdp0mw", + "Shutd0pmw", + "Shuts0wm", + "Shutsw0m", + "Shuts0mw", + "Shutsm0w", + "Shutsmw0", + "Shuts0m", + "Shuts0iwm", + "Shutsi0wm", + "Shutsp0wm", + "Shuts0pwm", + "Shuts0imw", + "Shutsi0mw", + "Shutsp0mw", + "Shuts0pmw", + "Shutdm0", + "Shutd0im", + "Shutdi0m", + "Shutdp0m", + "Shutd0pm", + "Shutsm0", + "Shuts0im", + "Shutsi0m", + "Shutsp0m", + "Shuts0pm", + "P9werButt9m", + "P9wer9m", + "9m", + "PWR9m", + "P9werBTm", + "Shutd9wm", + "Shutdw9m", + "Shutd9mw", + "Shutdm9w", + "Shutdmw9", + "Shutd9m", + "Shutd9iwm", + "Shutdi9wm", + "Shutdp9wm", + "Shutd9pwm", + "Shutd9imw", + "Shutdi9mw", + "Shutdp9mw", + "Shutd9pmw", + "Shuts9wm", + "Shutsw9m", + "Shuts9mw", + "Shutsm9w", + "Shutsmw9", + "Shuts9m", + "Shuts9iwm", + "Shutsi9wm", + "Shutsp9wm", + "Shuts9pwm", + "Shuts9imw", + "Shutsi9mw", + "Shutsp9mw", + "Shuts9pmw", + "Shutdm9", + "Shutd9im", + "Shutdi9m", + "Shutdp9m", + "Shutd9pm", + "Shutsm9", + "Shuts9im", + "Shutsi9m", + "Shutsp9m", + "Shuts9pm", + "ShutFowm", + "ShutFwom", + "ShutFomw", + "ShutFmow", + "ShutFmwo", + "ShutFiwm", + "ShutFwim", + "ShutFimw", + "ShutFmiw", + "ShutFmwi", + "ShutFwpm", + "ShutFpmw", + "ShutFmpw", + "ShutFmwp", + "ShutFom", + "ShutFim", + "ShutFpm", + "ShutFoiwm", + "ShutFpiwm", + "ShutFiowm", + "ShutFipwm", + "ShutFpowm", + "ShutFopwm", + "ShutFoimw", + "ShutFpimw", + "ShutFiomw", + "ShutFipmw", + "ShutFpomw", + "ShutFopmw", + "ShutFmo", + "ShutFmw", + "ShutFmi", + "ShutFmp", + "ShutFoim", + "ShutFpim", + "ShutFiom", + "ShutFipm", + "ShutFpom", + "ShutFopm", + "ShutF0wm", + "ShutFw0m", + "ShutF0mw", + "ShutFm0w", + "ShutFmw0", + "ShutF0m", + "ShutF0iwm", + "ShutFi0wm", + "ShutFp0wm", + "ShutF0pwm", + "ShutF0imw", + "ShutFi0mw", + "ShutFp0mw", + "ShutF0pmw", + "ShutFm0", + "ShutF0im", + "ShutFi0m", + "ShutFp0m", + "ShutF0pm", + "ShutF9wm", + "ShutFw9m", + "ShutF9mw", + "ShutFm9w", + "ShutFmw9", + "ShutF9m", + "ShutF9iwm", + "ShutFi9wm", + "ShutFp9wm", + "ShutF9pwm", + "ShutF9imw", + "ShutFi9mw", + "ShutFp9mw", + "ShutF9pmw", + "ShutFm9", + "ShutF9im", + "ShutFi9m", + "ShutFp9m", + "ShutF9pm", + "Poeer", + "PoeerButton", + "PoeerOn", + "PoeerOff", + "PeR", + "PeRON", + "PeROFF", + "PeRBTN", + "PoeerBTN", + "Shutdoen", + "Shutdeon", + "Shutdone", + "Shutdnoe", + "Shutdneo", + "Shutdein", + "Shutdine", + "Shutdnie", + "Shutdnei", + "Shutdpen", + "Shutdepn", + "Shutdpne", + "Shutdnpe", + "Shutdnep", + "Shutdoien", + "Shutdpien", + "Shutdipen", + "Shutdpoen", + "Shutdoine", + "Shutdpine", + "Shutdipne", + "Shutdpone", + "Shutdopne", + "Shutdoeb", + "Shutdeob", + "Shutdobe", + "Shutdboe", + "Shutdbeo", + "Shutdeib", + "Shutdibe", + "Shutdbie", + "Shutdbei", + "Shutdpeb", + "Shutdepb", + "Shutdpbe", + "Shutdbpe", + "Shutdbep", + "Shutdoieb", + "Shutdpieb", + "Shutdipeb", + "Shutdpoeb", + "Shutdoibe", + "Shutdpibe", + "Shutdipbe", + "Shutdpobe", + "Shutdopbe", + "Shutsoen", + "Shutseon", + "Shutsone", + "Shutsnoe", + "Shutsneo", + "Shutsien", + "Shutsein", + "Shutsine", + "Shutsnie", + "Shutsnei", + "Shutspen", + "Shutsepn", + "Shutspne", + "Shutsnpe", + "Shutsnep", + "Shutsoien", + "Shutspien", + "Shutsioen", + "Shutsipen", + "Shutspoen", + "Shutsopen", + "Shutsoine", + "Shutsione", + "Shutsipne", + "Shutspone", + "Shutsopne", + "Shutsoeb", + "Shutseob", + "Shutsobe", + "Shutsboe", + "Shutsbeo", + "Shutsieb", + "Shutseib", + "Shutsibe", + "Shutsbie", + "Shutsbei", + "Shutspeb", + "Shutsepb", + "Shutspbe", + "Shutsbpe", + "Shutsbep", + "Shutsoieb", + "Shutspieb", + "Shutsioeb", + "Shutsipeb", + "Shutspoeb", + "Shutsopeb", + "Shutsoibe", + "Shutspibe", + "Shutsiobe", + "Shutsipbe", + "Shutspobe", + "Shutsopbe", + "Shutdoe", + "Shutdeo", + "Shutdne", + "Shutdei", + "Shutdpe", + "Shutdep", + "Shutdoie", + "Shutdpie", + "Shutdipe", + "Shutdpoe", + "Shutdbe", + "Shutsoe", + "Shutseo", + "Shutsne", + "Shutsie", + "Shutsei", + "Shutspe", + "Shutsep", + "Shutsoie", + "Shutspie", + "Shutsioe", + "Shutsipe", + "Shutspoe", + "Shutsope", + "Shutsbe", + "P0eer", + "P0eerButt0n", + "P0eer0n", + "P0eer0ff", + "PeR0N", + "PeR0FF", + "P0eerBTN", + "Shutd0en", + "Shutde0n", + "Shutd0ne", + "Shutdn0e", + "Shutdne0", + "Shutd0ien", + "Shutdi0en", + "Shutdp0en", + "Shutd0pen", + "Shutd0ine", + "Shutdi0ne", + "Shutdp0ne", + "Shutd0pne", + "Shutd0eb", + "Shutde0b", + "Shutd0be", + "Shutdb0e", + "Shutdbe0", + "Shutd0ieb", + "Shutdi0eb", + "Shutdp0eb", + "Shutd0peb", + "Shutd0ibe", + "Shutdi0be", + "Shutdp0be", + "Shutd0pbe", + "Shuts0en", + "Shutse0n", + "Shuts0ne", + "Shutsn0e", + "Shutsne0", + "Shuts0ien", + "Shutsi0en", + "Shutsp0en", + "Shuts0pen", + "Shuts0ine", + "Shutsi0ne", + "Shutsp0ne", + "Shuts0pne", + "Shuts0eb", + "Shutse0b", + "Shuts0be", + "Shutsb0e", + "Shutsbe0", + "Shuts0ieb", + "Shutsi0eb", + "Shutsp0eb", + "Shuts0peb", + "Shuts0ibe", + "Shutsi0be", + "Shutsp0be", + "Shuts0pbe", + "Shutd0e", + "Shutde0", + "Shutd0ie", + "Shutdi0e", + "Shutdp0e", + "Shutd0pe", + "Shuts0e", + "Shutse0", + "Shuts0ie", + "Shutsi0e", + "Shutsp0e", + "Shuts0pe", + "P9eer", + "P9eerButt9n", + "P9eer9n", + "P9eer9ff", + "PeR9N", + "PeR9FF", + "P9eerBTN", + "Shutd9en", + "Shutde9n", + "Shutd9ne", + "Shutdn9e", + "Shutdne9", + "Shutd9ien", + "Shutdi9en", + "Shutdp9en", + "Shutd9pen", + "Shutd9ine", + "Shutdi9ne", + "Shutdp9ne", + "Shutd9pne", + "Shutd9eb", + "Shutde9b", + "Shutd9be", + "Shutdb9e", + "Shutdbe9", + "Shutd9ieb", + "Shutdi9eb", + "Shutdp9eb", + "Shutd9peb", + "Shutd9ibe", + "Shutdi9be", + "Shutdp9be", + "Shutd9pbe", + "Shuts9en", + "Shutse9n", + "Shuts9ne", + "Shutsn9e", + "Shutsne9", + "Shuts9ien", + "Shutsi9en", + "Shutsp9en", + "Shuts9pen", + "Shuts9ine", + "Shutsi9ne", + "Shutsp9ne", + "Shuts9pne", + "Shuts9eb", + "Shutse9b", + "Shuts9be", + "Shutsb9e", + "Shutsbe9", + "Shuts9ieb", + "Shutsi9eb", + "Shutsp9eb", + "Shuts9peb", + "Shuts9ibe", + "Shutsi9be", + "Shutsp9be", + "Shuts9pbe", + "Shutd9e", + "Shutde9", + "Shutd9ie", + "Shutdi9e", + "Shutdp9e", + "Shutd9pe", + "Shuts9e", + "Shutse9", + "Shuts9ie", + "Shutsi9e", + "Shutsp9e", + "Shuts9pe", + "ShutFoen", + "ShutFeon", + "ShutFone", + "ShutFnoe", + "ShutFneo", + "ShutFien", + "ShutFein", + "ShutFnie", + "ShutFnei", + "ShutFpen", + "ShutFepn", + "ShutFpne", + "ShutFnpe", + "ShutFnep", + "ShutFoien", + "ShutFpien", + "ShutFioen", + "ShutFipen", + "ShutFpoen", + "ShutFopen", + "ShutFoine", + "ShutFpine", + "ShutFione", + "ShutFipne", + "ShutFpone", + "ShutFopne", + "ShutFoeb", + "ShutFeob", + "ShutFobe", + "ShutFboe", + "ShutFbeo", + "ShutFieb", + "ShutFeib", + "ShutFibe", + "ShutFbie", + "ShutFbei", + "ShutFpeb", + "ShutFepb", + "ShutFpbe", + "ShutFbpe", + "ShutFbep", + "ShutFoieb", + "ShutFpieb", + "ShutFioeb", + "ShutFipeb", + "ShutFpoeb", + "ShutFopeb", + "ShutFoibe", + "ShutFpibe", + "ShutFiobe", + "ShutFipbe", + "ShutFpobe", + "ShutFopbe", + "ShutFoe", + "ShutFeo", + "ShutFne", + "ShutFie", + "ShutFei", + "ShutFpe", + "ShutFep", + "ShutFoie", + "ShutFpie", + "ShutFioe", + "ShutFipe", + "ShutFpoe", + "ShutFope", + "ShutFbe", + "ShutF0en", + "ShutFe0n", + "ShutF0ne", + "ShutFn0e", + "ShutFne0", + "ShutF0ien", + "ShutFi0en", + "ShutFp0en", + "ShutF0pen", + "ShutF0ine", + "ShutFi0ne", + "ShutFp0ne", + "ShutF0pne", + "ShutF0eb", + "ShutFe0b", + "ShutF0be", + "ShutFb0e", + "ShutFbe0", + "ShutF0ieb", + "ShutFi0eb", + "ShutFp0eb", + "ShutF0peb", + "ShutF0ibe", + "ShutFi0be", + "ShutFp0be", + "ShutF0pbe", + "ShutF0e", + "ShutFe0", + "ShutF0ie", + "ShutFi0e", + "ShutFp0e", + "ShutF0pe", + "ShutF9en", + "ShutFe9n", + "ShutF9ne", + "ShutFn9e", + "ShutFne9", + "ShutF9ien", + "ShutFi9en", + "ShutFp9en", + "ShutF9pen", + "ShutF9ine", + "ShutFi9ne", + "ShutFp9ne", + "ShutF9pne", + "ShutF9eb", + "ShutFe9b", + "ShutF9be", + "ShutFb9e", + "ShutFbe9", + "ShutF9ieb", + "ShutFi9eb", + "ShutFp9eb", + "ShutF9peb", + "ShutF9ibe", + "ShutFi9be", + "ShutFp9be", + "ShutF9pbe", + "ShutF9e", + "ShutFe9", + "ShutF9ie", + "ShutFi9e", + "ShutFp9e", + "ShutF9pe", + "PoeerButtom", + "PoeerOm", + "PeROm", + "PeRBTm", + "PoeerBTm", + "Shutdoem", + "Shutdeom", + "Shutdome", + "Shutdmoe", + "Shutdmeo", + "Shutdeim", + "Shutdime", + "Shutdmie", + "Shutdmei", + "Shutdpem", + "Shutdepm", + "Shutdpme", + "Shutdmpe", + "Shutdmep", + "Shutdoiem", + "Shutdpiem", + "Shutdipem", + "Shutdpoem", + "Shutdoime", + "Shutdpime", + "Shutdipme", + "Shutdpome", + "Shutdopme", + "Shutsoem", + "Shutseom", + "Shutsmoe", + "Shutsmeo", + "Shutsiem", + "Shutseim", + "Shutsime", + "Shutsmie", + "Shutsmei", + "Shutspem", + "Shutsepm", + "Shutspme", + "Shutsmpe", + "Shutsmep", + "Shutsoiem", + "Shutspiem", + "Shutsioem", + "Shutsipem", + "Shutspoem", + "Shutsopem", + "Shutsoime", + "Shutsiome", + "Shutsipme", + "Shutspome", + "Shutsopme", + "Shutdme", + "Shutsme", + "P0eerButt0m", + "P0eer0m", + "PeR0m", + "P0eerBTm", + "Shutd0em", + "Shutde0m", + "Shutd0me", + "Shutdm0e", + "Shutdme0", + "Shutd0iem", + "Shutdi0em", + "Shutdp0em", + "Shutd0pem", + "Shutd0ime", + "Shutdi0me", + "Shutdp0me", + "Shutd0pme", + "Shuts0em", + "Shutse0m", + "Shuts0me", + "Shutsm0e", + "Shutsme0", + "Shuts0iem", + "Shutsi0em", + "Shutsp0em", + "Shuts0pem", + "Shuts0ime", + "Shutsi0me", + "Shutsp0me", + "Shuts0pme", + "P9eerButt9m", + "P9eer9m", + "PeR9m", + "P9eerBTm", + "Shutd9em", + "Shutde9m", + "Shutd9me", + "Shutdm9e", + "Shutdme9", + "Shutd9iem", + "Shutdi9em", + "Shutdp9em", + "Shutd9pem", + "Shutd9ime", + "Shutdi9me", + "Shutdp9me", + "Shutd9pme", + "Shuts9em", + "Shutse9m", + "Shuts9me", + "Shutsm9e", + "Shutsme9", + "Shuts9iem", + "Shutsi9em", + "Shutsp9em", + "Shuts9pem", + "Shuts9ime", + "Shutsi9me", + "Shutsp9me", + "Shuts9pme", + "ShutFoem", + "ShutFeom", + "ShutFome", + "ShutFmoe", + "ShutFmeo", + "ShutFiem", + "ShutFeim", + "ShutFime", + "ShutFmie", + "ShutFmei", + "ShutFpem", + "ShutFepm", + "ShutFpme", + "ShutFmpe", + "ShutFmep", + "ShutFoiem", + "ShutFpiem", + "ShutFioem", + "ShutFipem", + "ShutFpoem", + "ShutFopem", + "ShutFoime", + "ShutFpime", + "ShutFiome", + "ShutFipme", + "ShutFpome", + "ShutFopme", + "ShutFme", + "ShutF0em", + "ShutFe0m", + "ShutF0me", + "ShutFm0e", + "ShutFme0", + "ShutF0iem", + "ShutFi0em", + "ShutFp0em", + "ShutF0pem", + "ShutF0ime", + "ShutFi0me", + "ShutFp0me", + "ShutF0pme", + "ShutF9em", + "ShutFe9m", + "ShutF9me", + "ShutFm9e", + "ShutFme9", + "ShutF9iem", + "ShutFi9em", + "ShutFp9em", + "ShutF9pem", + "ShutF9ime", + "ShutFi9me", + "ShutFp9me", + "ShutF9pme" + ], + "color_value": "#FFFFFF", + "is_blacklisted": false, + "opposite_input_value": "0x00007F7F7F7F0004L", + "opposite_input_name": "Power", + "has_opposite": false, + "input_type": 3, + "keyboard_value": null, + "keyboard_key_name": null + }, + { + "input_value": "0x00007F7F7F7F0008L", + "input_name": "Reset", + "input_alias": [ + "Restarst", + "Restasrt", + "Restast", + "Rser", + "Rsr", + "Rserbutton", + "Rserbtn", + "Reser", + "Resr", + "Reserbutton", + "Reserbtn", + "RSRBTN", + "Rset", + "Rst", + "Rsetbutton", + "Rsetbtn", + "Rstart", + "Rstar", + "Rsey", + "Reboot", + "Reset", + "Rest", + "Re", + "Resetbutton", + "Resetbtn", + "RSTBTN", + "Erstard", + "Restart", + "Restar", + "Resey", + "Delete", + "Refresh" + ], + "color_value": "#FFFFFF", + "is_blacklisted": false, + "opposite_input_value": "0x00007F7F7F7F0008L", + "opposite_input_name": "Reset", + "has_opposite": false, + "input_type": 3, + "keyboard_value": null, + "keyboard_key_name": null + }, + { + "input_value": "0x00007F7F7F7F0010L", + "input_name": "Eject", + "input_alias": [ + "Eject", + "Ejt" + ], + "color_value": "#FFFFFF", + "is_blacklisted": false, + "opposite_input_value": "0x00007F7F7F7F0010L", + "opposite_input_name": "Eject", + "has_opposite": false, + "input_type": 3, + "keyboard_value": null, + "keyboard_key_name": null + }, + { + "input_value": "0x00007F7F7F7F0020L", + "input_name": "Etc", + "input_alias": [ + "Etc", + "Etcetera" + ], + "color_value": "#FFFFFF", + "is_blacklisted": false, + "opposite_input_value": "0x00007F7F7F7F0020L", + "opposite_input_name": "Etc", + "has_opposite": false, + "input_type": 3, + "keyboard_value": null, + "keyboard_key_name": null + }, + { + "input_value": "0x00007F7F7F7F0040L", + "input_name": "Tilt", + "input_alias": [ + "Tilt", + "Titl", + "Cartridge", + "Titlcartridge", + "Tiltcartridge", + "Cardridge", + "Tiltcardridge", + "Titlcardridge", + "Cartrifge", + "Titlcartrifge", + "Tiltcartrifge", + "Cardrifge", + "Tiltcardrifge", + "Titlcardrifge" + ], + "color_value": "#FFFFFF", + "is_blacklisted": false, + "opposite_input_value": "0x00007F7F7F7F0040L", + "opposite_input_name": "Tilt", + "has_opposite": false, + "input_type": 3, + "keyboard_value": null, + "keyboard_key_name": null + }, + { + "input_value": "0x00007F7F7F7F0080L", + "input_name": "YOUWIN", + "input_alias": [ + "YOUWIN", + "Win", + "Clear" + ], + "color_value": "#FFFFFF", + "is_blacklisted": false, + "opposite_input_value": "0x00007F7F7F7F0080L", + "opposite_input_name": "YOUWIN", + "has_opposite": false, + "input_type": 3, + "keyboard_value": null, + "keyboard_key_name": null + } +] \ No newline at end of file diff --git a/backend/global.json b/backend/global.json index 2a8fd9c4..76c2f1dc 100644 --- a/backend/global.json +++ b/backend/global.json @@ -1,5 +1,5 @@ { - "controller_config": "gcn_vc_snes.json", + "controller_config": "ps2.json", "linux_restart_command": "sudo reboot now", "windows_restart_command": "shutdown \/r", "enable_slur_detection": true, @@ -15,9 +15,10 @@ "warn_if_message_is_long": false, "enable_silent_timeout": true, "ban_spambots": true, + "ban_user_again_if_user_is_still_marked_as_spambot": false, "send_messages_to_moderated_user": true, "send_whispers_to_moderated_user": true, - "enable_your_input_was_interpreted_as_reply_message": false, + "enable_your_input_was_interpreted_as_reply_message": true, "enable_updating_stream_title_automatically": true, "enable_check_uptime": true, "enable_check_moderators": true, @@ -34,9 +35,9 @@ "use_databases": true, "webserver_port": 8080, "chat_config": "chat_config.json", - "run_start_time": 1714867200000, + "run_start_time": 1723939200000, "next_run_start_time": 1723939200000, - "stream_end_time": 1715904000000, + "stream_end_time": 1723939200000, "initial_accept_inputs": false, "initial_accept_tts": false, "initial_accept_inputs_from_anyone": true, @@ -51,12 +52,12 @@ "voting_allowed_period_millis": 300000, "vote_expiration_time_millis": 300000, "help_message_cooldown_millis": 5000, - "game_title": "Final Fantasy 6", - "game_title_short": "Final Fantasy 6", - "game_title_shorter": "Final Fantasy 6", - "game_title_shorter_2": "Final Fantasy 6", - "game_title_shorter_3": "Final Fantasy 6", - "stream_title": "Twitch Plays(Viewers play\/Chat plays){{game_title_shorter_3}} on an actual Wii day {{play_time_days}} hour {{hour_low}} to hour {{hour_high}} type !help to learn how to play", + "game_title": "Kingdom Hearts 2 Re-Revisit", + "game_title_short": "Kingdom Hearts 2", + "game_title_shorter": "Kingdom Hearts 2", + "game_title_shorter_2": "Kingdom Hearts 2", + "game_title_shorter_3": "Kingdom Hearts 2", + "stream_title": "Twitch Plays(Viewers play\/Chat plays){{game_title}} on an actual PS2 day {{play_time_days}} hour {{hour_low}} to hour {{hour_high}} type !help to learn how to play", "stream_going_offline_message": "{{game_title}} day {{play_time_days}} hour {{hour_low}} to hour {{hour_high}}, stream is briefly going offline, don't go anywhere! Reload the stream if the stream doesn't automatically reload.", "send_stream_going_offline_message": true, "next_game_title": "Vote for the next game in the !discord", @@ -76,7 +77,7 @@ "modbot_moderation_collection_name": "modbot_moderation_{{channel_id}}", "main_database_name": "twitch_plays_{{channel_id}}", "chatters_collection_name": "chatters_{{channel_id}}", - "run_name": "Final_Fantasy_6_{{channel_id}}", + "run_name": "Kingdom_Hearts_II_Re_Revisit_{{channel_id}}", "global_database_name": "twitch_plays_global_{{channel_id}}", "inputter_database_name": "twitch_plays_inputters_{{channel_id}}", "macro_database_name": "twitch_plays_macro_{{channel_id}}", @@ -95,13 +96,15 @@ "longest_macro_name_length_allowed": 250, "reason_macro_database_is_disabled": "You can now save macros just fine, everything now works as intended :)", "use_discord_bot": true, - "discord_url": "https://discord.gg/yHETNuZCUK Go to the #polls channel to vote for the next run (Countdown here: https://www.timeanddate.com/countdown/generic?iso=20240818T00&p0=1440&msg=Next+Run,+Vote+In+The+Discord&font=sanserif&csz=1)! The options are: The Legend of Zelda (NES), Zelda 2 The Adventure of Link (NES) and Kingdom Hearts 2 Re-Revisit (So you can finish whatever there is left to do and beat the game), you can vote for more than one option!", + "discord_url": "https://discord.gg/yHETNuZCUK Go to the #polls channel to vote for the next run (Date TBD)! The options are: Final Fantasy Tactics (PS1), Super Paper Mario (Wii) and Tecmo Secret of The Stars (SNES), you can vote for more than one option!", "github_message": "The source code for everything used on this stream can be found here:", "github_repo": "https://github.com/WhatAboutGaming/Twitch-Plays-Stuff", - "run_id": 9, + "run_id": 10, "notes": "To test server: Set game_title as TEST RUN 0, set stream_title as TEST RUN 1, set next_game_title as TEST RUN 2, set main_database_name as test_database_main, set chatters_collection_name as test_database_chatters, set run_name as test_database_run_name, set global_database_name as test_database_global, set inputter_database_name as test_database_inputters, set macro_database_name as test_database_macro, set run_id as -1", - "overlay_header_text": "Twitch Plays (Viewers play\/Chat plays) {{game_title_short}}\non an actual Wii (SNES Wii VC) !help !discord", - "overlay_advanced_mode_help_message_to_display": "!help to learn how to play\nGame beaten! Congrats!\nStream goes offline in\n{{stream_end_time}}\n(The {{play_time:1715904000000}} mark)\nGo to the !discord and go to\n#polls to vote for next game\n(Starts in {{next_run_start_time}})", + "overlay_enable_hourly_beeps": true, + "overlay_enable_secondary_beeps": true, + "overlay_header_text": "Twitch Plays (Viewers play\/Chat plays) {{game_title_short}}\non an actual PS2 !help !discord", + "overlay_advanced_mode_help_message_to_display": "\n\n!help to learn how to play\n\nGo to the !discord and go to\n#polls to vote for next game\n(Date TBD)", "overlay_text_rotation": [ "Type !help or !commands to learn how to play", "Type !macrohelp to learn how to save macros and\nexecute saved macros", @@ -109,105 +112,23 @@ "Type !discord to get a link to the stream Discord server\nand go to #polls to vote for next game", "Please, don't delete any files, and please save regularly", "Attempting to delete or deleting any file will earn you an\nunappealable permanent ban", - "Beat Whelk: {{play_time:1714870962538}} ({{absolute_time:1714870962538}})!", - "Beat Lobo/Marshal:{{play_time:1714873778904}} ({{absolute_time:1714873778904}})!", - "Beat M-TekArmor: {{play_time:1714928272288}} ({{absolute_time:1714928272288}})!", - "Beat Vargas: {{play_time:1715008257855}} ({{absolute_time:1715008257855}})!", - "Beat Ultros: {{play_time:1715150130021}} ({{absolute_time:1715150130021}})!", - "Beat GhostTrain: {{play_time:1715155783762}} ({{absolute_time:1715155783762}})!", - "Beat TunnelArmr: {{play_time:1715196950194}} ({{absolute_time:1715196950194}})!", - "Beat Battle of Narshe:\n{{play_time:1715200483129}} ({{absolute_time:1715200483129}})!", - "Beat Dadaluma: {{play_time:1715205510849}} ({{absolute_time:1715205510849}})!", - "Sung Opera: {{play_time:1715231637592}} ({{absolute_time:1715231637592}})!", - "Saved Opera: {{play_time:1715303524204}} ({{absolute_time:1715303524204}})!", - "Beat 024 and 128: {{play_time:1715307273614}} ({{absolute_time:1715307273614}})!", - "Beat FlameEater: {{play_time:1715359822718}} ({{absolute_time:1715359822718}})!", - "Beat Ultros 3: {{play_time:1715363320346}} ({{absolute_time:1715363320346}})!", - "Beat Ultros 4: {{play_time:1715372833889}} ({{absolute_time:1715372833889}})!", - "Beat Atma: {{play_time:1715390214722}} ({{absolute_time:1715390214722}})!", - "Escape Floating Island:\n{{play_time:1715449900634}} ({{absolute_time:1715449900634}})!", - "Beat Tentacles: {{play_time:1715456999985}} ({{absolute_time:1715456999985}})!", - "Beat Presenter: {{play_time:1715459893790}} ({{absolute_time:1715459893790}})!", - "Beat Dullahan: {{play_time:1715460293819}} ({{absolute_time:1715460293819}})!", - "Beat Phunbaba: {{play_time:1715465400755}} ({{absolute_time:1715465400755}})!", - "Saved Sabin: {{play_time:1715473761369}} ({{absolute_time:1715473761369}})!", - "Beat Tritoch: {{play_time:1715493021779}} ({{absolute_time:1715493021779}})!", - "Beat Umaro: {{play_time:1715494047817}} ({{absolute_time:1715494047817}})!", - "Beat SrBehemoth: {{play_time:1715526233778}} ({{absolute_time:1715526233778}})!", - "Beat Chadarnook: {{play_time:1715527827614}} ({{absolute_time:1715527827614}})!", - "Beat KatanaSoul: {{play_time:1715530828461}} ({{absolute_time:1715530828461}})!", - "Beat Shadow (Coliseum):\n{{play_time:1715554173779}} ({{absolute_time:1715554173779}})!", - "Beat Timed Cave: {{play_time:1715572668891}} ({{absolute_time:1715572668891}})!", - "Beat 3 Dream Stooges:\n{{play_time:1715579470440}} ({{absolute_time:1715579470440}})!", - "Beat Wrexsoul: {{play_time:1715580291601}} ({{absolute_time:1715580291601}})!", - "Beat Magimaster: {{play_time:1715584665600}} ({{absolute_time:1715584665600}})!", - "Beat Inferno: {{play_time:1715626598213}} ({{absolute_time:1715626598213}})!", - "Beat Guardian: {{play_time:1715630630935}} ({{absolute_time:1715630630935}})!", - "Beat Doom: {{play_time:1715633584566}} ({{absolute_time:1715633584566}})!", - "Beat Goddess: {{play_time:1715634676696}} ({{absolute_time:1715634676696}})!", - "Beat Poltrgeist: {{play_time:1715635315304}} ({{absolute_time:1715635315304}})!", - "Beat Kefka: {{play_time:1715639833598}} ({{absolute_time:1715639833598}})!", - "Current goal: Celebrate! Game was beaten! Congrats to\nall who participated! Also beat Kefka again lol", + "Current goal: Finish whatever there is\nleft to do! There isn't much left!", "The time is {{current_time_no_millis}}.\n{{game_title_short}} has been going for {{play_time_total_string_no_millis}}.", - "Stream goes offline in {{stream_end_time}} (The {{play_time:1715904000000}} mark)", - "{{next_game_title}} (starts in\n{{next_run_start_time}})", "If anything breaks, please ping @WhatAboutGamingLive", - "The Endgame Conditions are: In order to beat the game, you\nhave to do the following tasks in the following order:", - "1) Beat all main bosses, order in which bosses are beaten\nDOES NOT MATTER", - "2) Watch the credits. 3) Have fun with post game and\nsidequests! Tasks have to be followed in the order listed.", - "Glitches are allowed as long as they don't break or crash\nthe game, or leave the game in an unplayable state.", - "There will be extra time for post game and sidequests, so\ntake your time!" + "The Endgame Conditions are: See how far you can get!", + "Glitches are allowed as long as they don't break or crash\nthe game, or leave the game in an unplayable state." ], "current_run_endgame_goals": [ - "The Endgame Conditions are: you have to do the following tasks in the following order: 1) Beat all main bosses, order in which bosses are beaten DOES NOT MATTER 2) Watch the credits 3) Have fun with post game and sidequests! The tasks have to be followed in the order listed. Glitches are allowed as long as the glitches don't break or crash the game, or leave the game in an unplayable state. There will be extra time for post game content, so take your time!" + "The Endgame Conditions are: See how far you can get! Glitches are allowed as long as they don't break or crash the game, or leave the game in an unplayable state." ], "periodical_news_messages": [ "Not sure how to play? You can type !help or !commands in chat at any time to have a help message sent straight to chat.", "You can type !macrohelp to learn how to save and execute saved macros.", "All of the code used on this stream is open source and can be found here: https://github.com/WhatAboutGaming/Twitch-Plays-Stuff", - "We have a Discord server and there is currently a poll up for which game to be played after this (In {{next_run_start_time}}), the options are: The Legend of Zelda (NES), Zelda 2 The Adventure of Link (NES) and Kingdom Hearts 2 Re-Revisit (So you can finish whatever there is left to do and beat the game), you can vote for more than one option, Discord server link here: https://discord.gg/yHETNuZCUK Countdown here: https://www.timeanddate.com/countdown/generic?iso=20240818T00&p0=1440&msg=Next+Run,+Vote+In+The+Discord&font=sanserif&csz=1", + "We have a Discord server and there is currently a poll up for which game to be played after this (Date TBD), the options are: Final Fantasy Tactics (PS1), Super Paper Mario (Wii) and Tecmo Secret of The Stars (SNES), you can vote for more than one option, Discord server link here: https://discord.gg/yHETNuZCUK", "The time is {{current_time}}. {{game_title}} has been going for {{play_time_total_string}}.", - "We're currently playing {{game_title}}. Save files for this run can be found here: https://github.com/WhatAboutGaming/Twitch-Plays-Stuff/tree/master/Save%20Files/Final%20Fantasy%206 and the videos for this run can be found on this playlist: https://www.twitch.tv/collections/07MTYQlrtRf4LQ", - "Stream goes offline in {{stream_end_time}} (The {{play_time:1715904000000}} mark). Countdown here: https://www.timeanddate.com/countdown/generic?iso=20240517T00&p0=1440&msg=Stream+Going+Offline&font=sanserif&csz=1", - "Video: Beating Whelk https://www.twitch.tv/videos/2138397949 {{play_time:1714870962538}} ({{absolute_time:1714870962538}})", - "Video: Beating Lobo and Marshal https://www.twitch.tv/videos/2138397950 {{play_time:1714873778904}} ({{absolute_time:1714873778904}})", - "Video: Beating M-TekArmor https://www.twitch.tv/videos/2138439829 {{play_time:1714928272288}} ({{absolute_time:1714928272288}})", - "Video: Beating Vargas https://www.twitch.tv/videos/2139240828 {{play_time:1715008257855}} ({{absolute_time:1715008257855}})", - "Video: Beating Ultros https://www.twitch.tv/videos/2140971715 {{play_time:1715150130021}} ({{absolute_time:1715150130021}})", - "Video: Beating GhostTrain https://www.twitch.tv/videos/2141025133 {{play_time:1715155783762}} ({{absolute_time:1715155783762}})", - "Video: Beating TunnelArmr https://www.twitch.tv/videos/2141085873 {{play_time:1715196950194}} ({{absolute_time:1715196950194}})", - "Video: Beating Battle of Narshe https://www.twitch.tv/videos/2141085876 {{play_time:1715200483129}} ({{absolute_time:1715200483129}})", - "Video: Beating Dadaluma https://www.twitch.tv/videos/2141085874 {{play_time:1715205510849}} ({{absolute_time:1715205510849}})", - "Video: Singing the Opera https://www.twitch.tv/videos/2141912290 {{play_time:1715231637592}} ({{absolute_time:1715231637592}})", - "Video: Saving the Opera https://www.twitch.tv/videos/2141955187 {{play_time:1715303524204}} ({{absolute_time:1715303524204}})", - "Video: Beating Number 024 and Number 128 https://www.twitch.tv/videos/2141955185 {{play_time:1715307273614}} ({{absolute_time:1715307273614}})", - "Video: Beating FlameEater https://www.twitch.tv/videos/2142578733 {{play_time:1715359822718}} ({{absolute_time:1715359822718}})", - "Video: Beating Ultros 3 https://www.twitch.tv/videos/2142578735 {{play_time:1715363320346}} ({{absolute_time:1715363320346}})", - "Video: Beating Ultros 4 https://www.twitch.tv/videos/2142578734 {{play_time:1715372833889}} ({{absolute_time:1715372833889}})", - "Video: Beating Atma https://www.twitch.tv/videos/2142726204 {{play_time:1715390214722}} ({{absolute_time:1715390214722}})", - "Video: Escaping Floating Island https://www.twitch.tv/videos/2143459773 {{play_time:1715449900634}} ({{absolute_time:1715449900634}})", - "Video: Beating Tentacles https://www.twitch.tv/videos/2143459776 {{play_time:1715456999985}} ({{absolute_time:1715456999985}})", - "Video: Beating Presenter https://www.twitch.tv/videos/2143459772 {{play_time:1715459893790}} ({{absolute_time:1715459893790}})", - "Video: Beating Dullahan https://www.twitch.tv/videos/2143459774 {{play_time:1715460293819}} ({{absolute_time:1715460293819}})", - "Video: Beating Phunbaba https://www.twitch.tv/videos/2143480603 {{play_time:1715465400755}} ({{absolute_time:1715465400755}})", - "Video: Saving Sabin https://www.twitch.tv/videos/2143526341 {{play_time:1715473761369}} ({{absolute_time:1715473761369}})", - "Video: Beating Tritoch https://www.twitch.tv/videos/2144239922 {{play_time:1715493021779}} ({{absolute_time:1715493021779}})", - "Video: Beating Umaro https://www.twitch.tv/videos/2144239923 {{play_time:1715494047817}} ({{absolute_time:1715494047817}})", - "Video: Beating SrBehemoth https://www.twitch.tv/videos/2144323118 {{play_time:1715526233778}} ({{absolute_time:1715526233778}})", - "Video: Beating Chadarnook https://www.twitch.tv/videos/2144323115 {{play_time:1715527827614}} ({{absolute_time:1715527827614}})", - "Video: Beating KatanaSoul https://www.twitch.tv/videos/2144323116 {{play_time:1715530828461}} ({{absolute_time:1715530828461}})", - "Video: Beating Shadow (Coliseum) https://www.twitch.tv/videos/2144344239 {{play_time:1715554173779}} ({{absolute_time:1715554173779}})", - "Video: Beating Timed Cave https://www.twitch.tv/videos/2145156128 {{play_time:1715572668891}} ({{absolute_time:1715572668891}})", - "Video: Beating 3 Dream Stooges https://www.twitch.tv/videos/2145156130 {{play_time:1715579470440}} ({{absolute_time:1715579470440}})", - "Video: Beating Wrexsoul https://www.twitch.tv/videos/2145156129 {{play_time:1715580291601}} ({{absolute_time:1715580291601}})", - "Video: Beating Magimaster https://www.twitch.tv/videos/2145156131 {{play_time:1715584665600}} ({{absolute_time:1715584665600}})", - "Video: Beating Inferno https://www.twitch.tv/videos/2145227392 {{play_time:1715626598213}} ({{absolute_time:1715626598213}})", - "Video: Beating Guardian https://www.twitch.tv/videos/2145227395 {{play_time:1715630630935}} ({{absolute_time:1715630630935}})", - "Video: Beating Doom https://www.twitch.tv/videos/2145227394 {{play_time:1715633584566}} ({{absolute_time:1715633584566}})", - "Video: Beating Goddess https://www.twitch.tv/videos/2145227402 {{play_time:1715634676696}} ({{absolute_time:1715634676696}})", - "Video: Beating Poltrgeist https://www.twitch.tv/videos/2145227391 {{play_time:1715635315304}} ({{absolute_time:1715635315304}})", - "Video: Beating Kefka https://www.twitch.tv/videos/2145227400 {{play_time:1715639833598}} ({{absolute_time:1715639833598}})", - "Current goal: Celebrate! Game was beaten! Congrats to all who participated! Also beat Kefka again lol" + "We're currently playing {{game_title}}. Save files for this run can be found here: https://github.com/WhatAboutGaming/Twitch-Plays-Stuff/tree/master/Save%20Files/Kingdom%20Hearts%202%20Re-Revisit and the videos for this run can be found on this playlist: https://www.twitch.tv/collections/PhLInYxg0RdbmA", + "Current goal: Finish whatever there is left to do! There isn't much left!" ], "help_message_saving_macros": [ "You can save or edit a macro by using the command !savemacro . Example: !savemacro WalkInCircles Up Right Down Left will save or edit the macro WalkInCircles with the inputs Up Right Down Left, which can then be used later.", @@ -216,7 +137,7 @@ "You can see the list of inputs of a macro by using the command !listmacro . Example: !listmacro WalkingCircles will list the inputs of the macro WalkingCircles, which is Up Right Down Left. You can see the list of all macros saved by using the command !listallmacros.", "You can change if a macro can be edited only by the owner of the macro or by anyone by using the command !togglemacroeditability . Example: !togglemacroeditability WalkingCircles will make it so the macro WalkingCircles can be edited by anyone, and sending !togglemacroeditability WalkingCircles again will make it so the macro WalkingCircles can be edited only by the owner of the macro.", "!togglemacroeditability can be executed only by the owner of the macro. By default, when a new macro is created, it can only be edited by the owner of the macro.", - "You can set a single input per message by using the command !setsettablemacro . Example: up+left;500 0 will set Up+Left for 500 milliseconds (half second) at position 0. Starting position is 0, final position is 63.", + "You can set a single input per message by using the command !setsettablemacro . Example: up+left;30 0 will set Up+Left for 30 frames (half second) at position 0. Starting position is 0, final position is 63.", "You can list all inputs currently set by using the command !listsettablemacro . Example: !listsettablemacro 5 will list the first 5 inputs currently set. Starting position is 0, final position is 63. If there's no number provided, all of the inputs currently set will be listed.", "You can execute all inputs currently set by using the command !execsettablemacro . Example: !execsettablemacro 5 2 will execute the first 5 inputs currently set 1 time then repeat 2 more times. Starting position is 0, final position is 63. If there's no second number provided, the macro will be executed only 1 time. Currently, you can't save macros that were set using the !setsettablemacro command." ], diff --git a/backend/overlay_576p.html b/backend/overlay_576p.html index 5d7941e2..014abdec 100644 --- a/backend/overlay_576p.html +++ b/backend/overlay_576p.html @@ -3,7 +3,7 @@ - + diff --git a/backend/overlay_576p.js b/backend/overlay_576p.js index 0c3e1f65..e33a616d 100644 --- a/backend/overlay_576p.js +++ b/backend/overlay_576p.js @@ -163,6 +163,8 @@ var globalConfig = { github_repo: "", run_id: -1, notes: "To test server: Set game_title as TEST RUN 0, set stream_title as TEST RUN 1, set next_game_title as TEST RUN 2, set main_database_name as test_database_main, set chatters_collection_name as test_database_chatters, set run_name as test_database_run_name, set global_database_name as test_database_global, set inputter_database_name as test_database_inputters, set macro_database_name as test_database_macro, set run_id as -1", + overlay_enable_hourly_beeps: false, + overlay_enable_secondary_beeps: false, overlay_header_text: "Restarting overlay", overlay_advanced_mode_help_message_to_display: "\n\n\n\n\n!help to learn how to play", overlay_text_rotation: [ @@ -262,6 +264,10 @@ var advancedModeHelpMessageToDisplay = globalConfig.overlay_advanced_mode_help_m var secondCurrent = 0; var secondOld = 0; +var minuteCurrent = 0; +var minuteOld = 0; +var hourCurrent = 0; +var hourOld = 0; var currentValueToDisplay = 0; var font; @@ -272,6 +278,9 @@ var controllerMotorOffGraphics = [0, 0, 0, 0]; var controllerLedOnGraphics = [0, 0, 0, 0]; var controllerLedOffGraphics = [0, 0, 0, 0]; +var hourlyBeepSoundEffects = [0, 0]; +var secondaryBeepSoundEffects = [0, 0]; + var socket; var inputQueue = []; var isTtsBusy = false; @@ -409,6 +418,12 @@ function preload() { controllerLedOffGraphics[1] = loadImage("placeholder.png"); // LED 2 Off controllerLedOffGraphics[2] = loadImage("placeholder.png"); // LED 3 Off controllerLedOffGraphics[3] = loadImage("placeholder.png"); // LED 4 Off + + hourlyBeepSoundEffects[0] = loadSound("watch_beep_1.mp3"); + hourlyBeepSoundEffects[1] = loadSound("watch_beep_2.mp3"); + + secondaryBeepSoundEffects[0] = loadSound("watch_beep_1_short.mp3"); + secondaryBeepSoundEffects[1] = loadSound("watch_beep_2_short.mp3"); if (controllerConfig.use_controller_graphics == true) { controllerGraphics = loadImage(controllerConfig.controller_graphics); } @@ -895,6 +910,8 @@ function draw() { let playTimeStringNoMillis = playTimeDays + "d " + playTimeHours + "h " + playTimeMinutes + "m " + playTimeSeconds + "s"; //console.log(playTimeDays + "d" + playTimeHours + "h" + playTimeMinutes + "m" + playTimeSeconds + "s" + playTimeMillis + "ms"); secondCurrent = new Date().getUTCSeconds(); + minuteCurrent = new Date().getUTCMinutes(); + hourCurrent = new Date().getUTCHours(); //ttsAudioStatus = ttsAudio.isLoaded(); //var inputToHighlight = 0; inputToHighlight = inputQueueLength - inputQueue.length; @@ -1274,6 +1291,28 @@ function draw() { if (globalConfig.overlay_text_rotation.length > 0) { if (secondCurrent != secondOld) { + if (minuteCurrent != minuteOld) { + if (globalConfig.overlay_enable_secondary_beeps == true) { + if (minuteCurrent == 15 || minuteCurrent == 30 || minuteCurrent == 45) { + if (secondaryBeepSoundEffects.length > 0) { + let randomSecondaryBeepSoundEffectIndex = Math.floor(Math.random() * secondaryBeepSoundEffects.length); + //console.log(new Date().toISOString() + " randomSecondaryBeepSoundEffectIndex = " + randomSecondaryBeepSoundEffectIndex); + secondaryBeepSoundEffects[randomSecondaryBeepSoundEffectIndex].play(); + } + } + } + if (globalConfig.overlay_enable_hourly_beeps == true) { + if (minuteCurrent == 0) { + if (hourCurrent != hourOld) { + if (hourlyBeepSoundEffects.length > 0) { + let randomHourlyBeepSoundEffectIndex = Math.floor(Math.random() * hourlyBeepSoundEffects.length); + //console.log(new Date().toISOString() + " randomHourlyBeepSoundEffectIndex = " + randomHourlyBeepSoundEffectIndex); + hourlyBeepSoundEffects[randomHourlyBeepSoundEffectIndex].play(); + } + } + } + } + } if (secondCurrent % 3 == 0) { currentValueToDisplay++; if (currentValueToDisplay > globalConfig.overlay_text_rotation.length - 1) { @@ -1800,6 +1839,8 @@ function draw() { //image(controllerGraphics, 40, 40, 13, 19, 13, 50, 13, 19); // Position X on Canvas, Position Y on Canvas, Width on Canvas, Height on Canvas, Origin X on Image, Origin Y on Image, Width on image, Height on Image } secondOld = secondCurrent; + minuteOld = minuteCurrent; + hourOld = hourCurrent; isTtsBusyPrevious = isTtsBusy; //ttsAudioStatusPrevious = ttsAudioStatus; } \ No newline at end of file diff --git a/backend/ps2.json b/backend/ps2.json index 59a06eff..aad411df 100644 --- a/backend/ps2.json +++ b/backend/ps2.json @@ -206,8 +206,8 @@ "Valid inputs are X, Square, O, Triangle, L1, L2, L3, R1, R2, R3, Start, Select (Buttons), Up, Down, Left, Right (Left Analog Stick), Rup, Rdown, Rleft, Rright (Right Analog Stick), and Dup, Ddown, Dleft, Dright (D Pad). It's exactly what you'd see if you looked at a PlayStation 2 controller! Typos work too!", "Up to {{simultaneous_different_advanced_buttons_allowed}} different inputs can be executed at the same time by using + to combine inputs. Example: X+Up+Rright will press the X Button, pull Up on the Left Analog Stick and pull Right on the Right Analog Stick. It is not needed to start your message with ! mark. Commands are NOT case sensitive: left and lEft will both pull Left on the Left Analog Stick.", "Normal duration of inputs is {{default_duration_per_precision_input_millis}} {{time_unit}}. You can separate multiple inputs by using spaces or commas to execute multiple inputs in rapid succession.", - "Example: Up+Right+Square;120 X+O+Down;60 *5 Will pull Up and Right on the Left Analog Stick and press the Square Button for 120 {{time_unit}}, then press the X and O Buttons and pull Down on the Left Analog Stick for 60 {{time_unit}}, and *5 means the input will be executed once, then it will be repeated 5 times. There is no delay between inputs.", - "You can use square brackets to make smaller loops. Example: [X+Square;60 O+Triangle;30*4] Start [L1+R1 Up+Left*2] 2 will press X+Square then O+Triangle 4 times, then will press Start, then will press L1+R1 then Up+Left on the Left Analog Stick 2 times, and everything will be repeated 2 times.", + "Example: Up+Right+Square;120 X+O+Down;60 *5 Will pull Up and Right on the Left Analog Stick and press the Square Button for 120 {{time_unit}} (2 seconds), then press the X and O Buttons and pull Down on the Left Analog Stick for 60 {{time_unit}} (1 second), and *5 means the input will be executed once, then it will be repeated 5 times. There is no delay between inputs.", + "You can use square brackets to make smaller loops. Example: [X+Square;60 O+Triangle;30*4] Start [L1+R1 Up+Left*2] 2 will press X+Square then O+Triangle 4 times, then will press Start, then will press L1+R1 then pull Up+Left on the Left Analog Stick 2 times, and everything will be repeated 2 times.", "There is no delay between inputs, but sometimes you'll need a delay between inputs, you can use Wait or Stop to add a delay between inputs. Example: X Wait *{{max_times_to_repeat_macro}} will press the X Button for {{default_duration_per_precision_input_millis}} {{time_unit}} then wait for another {{default_duration_per_precision_input_millis}} {{time_unit}}, and will repeat that macro {{max_times_to_repeat_macro}} times, basically mashing the X Button {{max_times_to_repeat_macro}}+1 times. Macros can be repeated up to {{max_times_to_repeat_macro}} times. Up to {{advanced_input_macros_allowed}} inputs can be chained in a macro.", "You can execute commands backwards if you start your message with Invert. Example: Invert Triangle O Square X will execute commands as X Square O Triangle. You can invert directions if you start you message with Opposite. Example: Opposite Up Down Left Right will execute commands as Down Up Right Left.", "You can use both Invert and Opposite at the same time. Example: Opposite Invert X+Up O+Down Square+Left Triangle+Right Select Up Down will execute commands as Up Down Select Triangle+Left Square+Right O+Up X+Down.", diff --git a/backend/ps2_controller.json b/backend/ps2_controller.json index b8e2b4e6..4b0ffada 100644 --- a/backend/ps2_controller.json +++ b/backend/ps2_controller.json @@ -4996,6 +4996,8 @@ "input_value": "0x00207F7F7F7F0000L", "input_name": "O", "input_alias": [ + "Ball", + "Sphere", "O", "ᄋ", "0", @@ -5018,6 +5020,9 @@ "input_value": "0x00407F7F7F7F0000L", "input_name": "X", "input_alias": [ + "Times", + "Multiplication", + "MultiplicationSign", "X", "Ecs", "Eks", @@ -5039,6 +5044,8 @@ "input_value": "0x00807F7F7F7F0000L", "input_name": "Sq", "input_alias": [ + "Box", + "Cube", "Q", "Sq", "[]", diff --git a/backend/ps2_controller_digital.json b/backend/ps2_controller_digital.json index 48815a2f..2baf8153 100644 --- a/backend/ps2_controller_digital.json +++ b/backend/ps2_controller_digital.json @@ -8673,6 +8673,8 @@ "input_value": "0x00207F7F7F7F0000L", "input_name": "O", "input_alias": [ + "Ball", + "Sphere", "O", "ᄋ", "0", @@ -8695,6 +8697,9 @@ "input_value": "0x00407F7F7F7F0000L", "input_name": "X", "input_alias": [ + "Times", + "Multiplication", + "MultiplicationSign", "X", "Ecs", "Eks", @@ -8716,6 +8721,8 @@ "input_value": "0x00807F7F7F7F0000L", "input_name": "Sq", "input_alias": [ + "Box", + "Cube", "Q", "Sq", "[]", diff --git a/backend/ps2_digital.json b/backend/ps2_digital.json index 1ad33cc0..696efc2b 100644 --- a/backend/ps2_digital.json +++ b/backend/ps2_digital.json @@ -206,8 +206,8 @@ "Valid inputs are X, Square, O, Triangle, L1, L2, L3, R1, R2, R3, Start, Select (Buttons), Up, Down, Left, Right (D Pad), Lup, Ldown, Lleft, Lright (Left Analog Stick), and Rup, Rdown, Rleft, Rright (Right Analog Stick). It's exactly what you'd see if you looked at a PlayStation 2 controller! Typos work too!", "Up to {{simultaneous_different_advanced_buttons_allowed}} different inputs can be executed at the same time by using + to combine inputs. Example: X+Up+Rright will press the X Button, press Up on the D Pad and pull Right on the Right Analog Stick. It is not needed to start your message with ! mark. Commands are NOT case sensitive: left and lEft will both press Left on the D Pad.", "Normal duration of inputs is {{default_duration_per_precision_input_millis}} {{time_unit}}. You can separate multiple inputs by using spaces or commas to execute multiple inputs in rapid succession.", - "Example: Up+Right+Square;120 X+O+Down;60 *5 Will press Up and Right on the D Pad and press the Square Button for 120 {{time_unit}}, then press the X and O Buttons and press Down on the D Pad for 60 {{time_unit}}, and *5 means the input will be executed once, then it will be repeated 5 times. There is no delay between inputs.", - "You can use square brackets to make smaller loops. Example: [X+Square;60 O+Triangle;30*4] Start [L1+R1 Up+Left*2] 2 will press X+Square then O+Triangle 4 times, then will press Start, then will press L1+R1 then Up+Left on the D Pad 2 times, and everything will be repeated 2 times.", + "Example: Up+Right+Square;120 X+O+Down;60 *5 Will press Up and Right on the D Pad and press the Square Button for 120 {{time_unit}} (2 seconds), then press the X and O Buttons and press Down on the D Pad for 60 {{time_unit}} (1 second), and *5 means the input will be executed once, then it will be repeated 5 times. There is no delay between inputs.", + "You can use square brackets to make smaller loops. Example: [X+Square;60 O+Triangle;30*4] Start [L1+R1 Up+Left*2] 2 will press X+Square then O+Triangle 4 times, then will press Start, then will press L1+R1 then press Up+Left on the D Pad 2 times, and everything will be repeated 2 times.", "There is no delay between inputs, but sometimes you'll need a delay between inputs, you can use Wait or Stop to add a delay between inputs. Example: X Wait *{{max_times_to_repeat_macro}} will press the X Button for {{default_duration_per_precision_input_millis}} {{time_unit}} then wait for another {{default_duration_per_precision_input_millis}} {{time_unit}}, and will repeat that macro {{max_times_to_repeat_macro}} times, basically mashing the X Button {{max_times_to_repeat_macro}}+1 times. Macros can be repeated up to {{max_times_to_repeat_macro}} times. Up to {{advanced_input_macros_allowed}} inputs can be chained in a macro.", "You can execute commands backwards if you start your message with Invert. Example: Invert Triangle O Square X will execute commands as X Square O Triangle. You can invert directions if you start you message with Opposite. Example: Opposite Up Down Left Right will execute commands as Down Up Right Left.", "You can use both Invert and Opposite at the same time. Example: Opposite Invert X+Up O+Down Square+Left Triangle+Right Select Up Down will execute commands as Up Down Select Triangle+Left Square+Right O+Up X+Down.", diff --git a/backend/run_ids_reference_list.txt b/backend/run_ids_reference_list.txt new file mode 100644 index 00000000..c74f877b --- /dev/null +++ b/backend/run_ids_reference_list.txt @@ -0,0 +1,11 @@ +run_id -1 = TEST ONLY +run_id 1 = Paper Mario TTYD (Wii) +run_id 2 = Mario RPG (SNES) +run_id 3 = Chrono Trigger (SNES) +run_id 4 = ALTTP (SNES) +run_id 5 = PS2 Test Stream (PS2) +run_id 6 = Final Fantasy (NES) +run_id 7 = KH2 Revisit (PS2) +run_id 8 = Final Fantasy 4 (SNES) +run_id 9 = Final Fantasy 6 (SNES) +run_id 10 = KH2 Re-Revisit (PS2) \ No newline at end of file diff --git a/backend/watch_beep_1.mp3 b/backend/watch_beep_1.mp3 new file mode 100644 index 0000000000000000000000000000000000000000..7ca4a723933f1a1a3f8d662c9fac7c70d5e1d312 GIT binary patch literal 17280 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 K7yk!F;C}!w!ogtx literal 0 HcmV?d00001 diff --git a/backend/watch_beep_1_long.mp3 b/backend/watch_beep_1_long.mp3 new file mode 100644 index 0000000000000000000000000000000000000000..88e20965d92bced5390b0ac493e30906df6ab38d GIT binary patch literal 42240 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

+;}`|m=b%*J5Q-Cu-j$R?#SVwBVfpX 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 Y*$r}XHa0d>Q`7&0LG%BY|AQ9zFD?A1d;kCd literal 0 HcmV?d00001 diff --git a/backend/watch_beep_1_short.mp3 b/backend/watch_beep_1_short.mp3 new file mode 100644 index 0000000000000000000000000000000000000000..824bfa6532501cfb5930423c64d6de930d814f97 GIT binary patch literal 16320 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 literal 0 HcmV?d00001 diff --git a/backend/watch_beep_2.mp3 b/backend/watch_beep_2.mp3 new file mode 100644 index 0000000000000000000000000000000000000000..26737380e4a27f2959492ff515370372edc114e3 GIT binary patch literal 19200 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%0A|8dHXMt+b|)L|v#x zR7Y`{n{Ox-gE=(dB0H93M#KuKAAY_kGq90tr=k@}B^W=y)vwns1tLL^+}So>eI`yA z`j8s#Aj+7&%~3PM`6J??TjfFHr_NjNe1Afe8&21*bbE$*(EBJuJwaD5N*BDus;NfYc1-vlnWC=ToEQ|u_@Ev4%t z%IO!t!YU#(soro!qvI4bR53*lJQ4O-n0$4Dx9(xSrpbf=gJD#} zc`8AWbpGrfNRM~FdC-cVwgv&q; zg}_C^JF$0&vd~c2CR{>s(O>F=F|Uy`=S>X`2D922`~{+Bl9Qh#-5wjE;o8o&qTC!@ zeA8Hx581o*vZ$)KY$n%zSf7lJt7LUF{XF(#I1vi^Td_+`nSjUJ{9pUuCGh_MVun6` literal 0 HcmV?d00001 diff --git a/backend/watch_beep_2_short.mp3 b/backend/watch_beep_2_short.mp3 new file mode 100644 index 0000000000000000000000000000000000000000..a231a91326b5a24f9df5550b328f03ab8a0d501e GIT binary patch literal 17280 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 z