diff --git a/Source/Client/Mode/GameModePackets.cpp b/Source/Client/Mode/GameModePackets.cpp
index cc69e48b6..10632a1f5 100644
--- a/Source/Client/Mode/GameModePackets.cpp
+++ b/Source/Client/Mode/GameModePackets.cpp
@@ -15641,7 +15641,7 @@ void CGameMode::ReceiveRefineStatusGraded(const char* playerName, int itemId, un
   const std::uint8_t (&signatureSource)[4] = signatureSourceArray._Elems;
   thread_local EncryptedName<sizeof(signatureSource), 0xED796785D1DF137FULL> signature(signatureSource);
   const char* signatureText = signature.Text();
-  const std::uint8_t functionSource[] = {0xB6, 0xA2, 0x4D, 0x4C, 0x66, 0x0C, 0x26, 0x81, 0xBB, 0xA8, 0x5B, 0x09};
+  const std::uint8_t functionSource[] = CRYPT_BYTES(12, "GetEquipJob", 0xF14F79170939C7F1ULL);
   thread_local EncryptedName<sizeof(functionSource), 0xF14F79170939C7F1ULL> function(functionSource);
   g_session.m_hotkeyScript->Call(function.Text(), signatureText, itemId, &job);
   if (job != 0) {
diff --git a/Source/Client/Mode/LoginMode.cpp b/Source/Client/Mode/LoginMode.cpp
index fe28a9fee..476df81e3 100644
--- a/Source/Client/Mode/LoginMode.cpp
+++ b/Source/Client/Mode/LoginMode.cpp
@@ -2851,7 +2851,7 @@ void CLoginMode::PollNetworkStatus() {
       GetRagConnection().Close();
       const int code = packet->result;
       const char* text = LookupMessage(message);
-      const std::array<std::uint8_t, 7> source = {0xC4, 0x08, 0xD1, 0xF2, 0xB1, 0x3A, 0x39};
+      const std::array<std::uint8_t, 7> source = CRYPT_BYTES(7, "%s(%d)", 0xDD3913D5D7F97BE1ULL);
       thread_local EncryptedName<sizeof(source), 0xDD3913D5D7F97BE1ULL> format(source);
       g_windowMgr.Confirm(FormatString(format.Text(), text, code), 0, true, false, 0, "Message", 280, 120, 0);
       g_charServerAccountIdPending = 0;
@@ -3186,16 +3186,16 @@ int CLoginMode::SendMsg(int event, int argument1, int argument2, int argument3,
         constexpr std::array<std::uint8_t, 5> prefixSource = CRYPT_NAME("uae\\", 0x23BBD58F8B5FF5C9ULL);
         thread_local EncryptedName<sizeof(prefixSource), 0x23BBD58F8B5FF5C9ULL> prefix(prefixSource);
         g_serverLanguage->SetServicePrefix(prefix.Text());
-        const std::array<std::uint8_t, 5> suffixSource = {0xF2, 0x72, 0x0E, 0x23, 0x39};
+        const std::array<std::uint8_t, 5> suffixSource = CRYPT_BYTES(5, "uae\\", 0x0B7109397F6B1387ULL);
         thread_local EncryptedName<sizeof(suffixSource), 0x0B7109397F6B1387ULL> suffixName(suffixSource);
         suffix = suffixName.Text();
       } else {
         g_tipOfTheDayEnglish = false;
         g_serverLanguage->alternateLanguage = 9;
-        const std::array<std::uint8_t, 9> prefixSource = {0xC0, 0xF3, 0x0A, 0x95, 0x0A, 0x54, 0x1F, 0x5F, 0xA5};
+        const std::array<std::uint8_t, 9> prefixSource = CRYPT_BYTES(9, "english\\", 0x03772763F96D9DA5ULL);
         thread_local EncryptedName<sizeof(prefixSource), 0x03772763F96D9DA5ULL> prefix(prefixSource);
         g_serverLanguage->SetServicePrefix(prefix.Text());
-        const std::array<std::uint8_t, 9> suffixSource = {0x8A, 0x1F, 0xB8, 0x7F, 0x04, 0x3C, 0xAF, 0xB1, 0xEF};
+        const std::array<std::uint8_t, 9> suffixSource = CRYPT_BYTES(9, "english\\", 0xEDC74F6D13DF71EFULL);
         thread_local EncryptedName<sizeof(suffixSource), 0xEDC74F6D13DF71EFULL> suffixName(suffixSource);
         suffix = suffixName.Text();
       }
@@ -3242,13 +3242,13 @@ int CLoginMode::SendMsg(int event, int argument1, int argument2, int argument3,
     g_session.m_accountName = servers[argument1].address.name;
     const int selected = *reinterpret_cast<int*>(this->selectedServerStorage);
     const std::uint32_t ip = servers[selected].address.ip;
-    const std::array<std::uint8_t, 12> ipFormatSource = {0xB0, 0xEB, 0xCF, 0x28, 0x39, 0x27, 0x44, 0x95, 0xBB, 0xAA, 0x85, 0x0D};
+    const std::array<std::uint8_t, 12> ipFormatSource = CRYPT_BYTES(12, "%d.%d.%d.%d", 0xF161095D0DE18F95ULL);
     thread_local EncryptedName<sizeof(ipFormatSource), 0xF161095D0DE18F95ULL> ipFormat(ipFormatSource);
     CharServerEndpoint endpoint;
     wsprintfA(endpoint.ip, ipFormat.Text(), ip & 0xFF, (ip >> 8) & 0xFF, (ip >> 16) & 0xFF, ip >> 24);
     const int selected2 = *reinterpret_cast<int*>(this->selectedServerStorage);
     endpoint.port = servers[selected2].address.port;
-    const std::array<std::uint8_t, 3> hostFormatSource = {0xFC, 0x8A, 0xE1};
+    const std::array<std::uint8_t, 3> hostFormatSource = CRYPT_BYTES(3, "%s", 0x2BAD156DE3E1F9D9ULL);
     thread_local EncryptedName<sizeof(hostFormatSource), 0x2BAD156DE3E1F9D9ULL> hostFormat(hostFormatSource);
     StringFormat(endpoint.host, sizeof(endpoint.host), static_cast<std::size_t>(-1), hostFormat.Text(), servers[selected2].domain);
     g_charServerEndpoint = endpoint;
@@ -3634,19 +3634,17 @@ void CLoginMode::OnChangeState(int value) {
     std::memset(&endpoint, 0, sizeof(endpoint));
     if (!std::strstr(g_session.clientVersion, "Dev")) {
       const int port = rand() % 3 + 6951;
-      const std::array<std::uint8_t, 26> hostSource = {0x24, 0xD3, 0xA0, 0x18, 0x02, 0xB0, 0x24, 0x17, 0x2C, 0xD8, 0xE1, 0x47, 0x02,
-                                                       0xB0, 0x2F, 0x18, 0x3D, 0xCE, 0xA4, 0x1B, 0x00, 0xB8, 0x6F, 0x12, 0x3D, 0xA1};
+      const std::array<std::uint8_t, 26> hostSource = CRYPT_BYTES(26, "kro-agency.ragnarok.co.kr", 0x7941D76335CFA14FULL);
       thread_local EncryptedName<sizeof(hostSource), 0x7941D76335CFA14FULL> host(hostSource);
       const char* hostText = host.Text();
-      const std::array<std::uint8_t, 6> formatSource = {0xC4, 0xEA, 0xBD, 0x6A, 0xE5, 0xC3};
+      const std::array<std::uint8_t, 6> formatSource = CRYPT_BYTES(6, "%s:%d", 0x7321C3814F8799E1ULL);
       thread_local EncryptedName<sizeof(formatSource), 0x7321C3814F8799E1ULL> format(formatSource);
       StringFormat(endpoint.host, sizeof(endpoint.host), static_cast<std::size_t>(-1), format.Text(), hostText, port);
     } else {
-      const std::array<std::uint8_t, 34> hostSource = {0xA2, 0x61, 0x96, 0x5E, 0x88, 0xB4, 0x38, 0x10, 0xAE, 0x76, 0x97, 0x10, 0x80, 0xF7, 0x67, 0x10, 0xAE,
-                                                       0x7D, 0x98, 0x01, 0x96, 0xB2, 0x3B, 0x12, 0xA6, 0x3D, 0x92, 0x01, 0xC3, 0xEF, 0x2C, 0x44, 0xF8, 0x13};
+      const std::array<std::uint8_t, 34> hostSource = CRYPT_BYTES(34, "kro-qm-agency.ragnarok.co.kr:6951", 0x7115D9F973F913C9ULL);
       thread_local EncryptedName<sizeof(hostSource), 0x7115D9F973F913C9ULL> host(hostSource);
       const char* hostText = host.Text();
-      const std::array<std::uint8_t, 3> formatSource = {0x46, 0x86, 0xE1};
+      const std::array<std::uint8_t, 3> formatSource = CRYPT_BYTES(3, "%s", 0xCB1D253B7FE1F563ULL);
       thread_local EncryptedName<sizeof(formatSource), 0xCB1D253B7FE1F563ULL> format(formatSource);
       StringFormat(endpoint.host, sizeof(endpoint.host), static_cast<std::size_t>(-1), format.Text(), hostText);
     }
@@ -3663,18 +3661,18 @@ void CLoginMode::OnChangeState(int value) {
     ZoneLoginPacket packet;
     std::memset(&packet, 0, sizeof(packet));
     packet.id = ID_CT_AUTH;
-    const std::array<std::uint8_t, 5> codeSource = {0x7F, 0x57, 0xDC, 0xB4, 0x09};
+    const std::array<std::uint8_t, 5> codeSource = CRYPT_BYTES(5, "0011", 0x793F370985ED674FULL);
     thread_local EncryptedName<sizeof(codeSource), 0x793F370985ED674FULL> code(codeSource);
     std::memcpy(packet.code, code.Text(), sizeof(packet.code));
-    const std::array<std::uint8_t, 3> nameFormatSource = {0x38, 0xB4, 0x4B};
+    const std::array<std::uint8_t, 3> nameFormatSource = CRYPT_BYTES(3, "%s", 0x234977DDB54BC71DULL);
     thread_local EncryptedName<sizeof(nameFormatSource), 0x234977DDB54BC71DULL> nameFormat(nameFormatSource);
     StringFormat(packet.name, sizeof(packet.name), static_cast<std::size_t>(-1), nameFormat.Text(), reinterpret_cast<const char*>(&this->loginCredentials[0x40]));
     char password[33] = {};
-    const std::array<std::uint8_t, 3> passwordFormatSource = {0xE0, 0x5E, 0x2B};
+    const std::array<std::uint8_t, 3> passwordFormatSource = CRYPT_BYTES(3, "%s", 0xEF6D1D893F2B2DC5ULL);
     thread_local EncryptedName<sizeof(passwordFormatSource), 0xEF6D1D893F2B2DC5ULL> passwordFormat(passwordFormatSource);
     StringFormat(password, sizeof(password), static_cast<std::size_t>(-1), passwordFormat.Text(), reinterpret_cast<const char*>(this->loginCredentials));
     DecryptRijndael256(password, packet.password);
-    const std::array<std::uint8_t, 3> extraFormatSource = {0x7E, 0x20, 0x5F};
+    const std::array<std::uint8_t, 3> extraFormatSource = CRYPT_BYTES(3, "%s", 0x39A39F87DD5F535BULL);
     thread_local EncryptedName<sizeof(extraFormatSource), 0x39A39F87DD5F535BULL> extraFormat(extraFormatSource);
     StringFormat(packet.extra, sizeof(packet.extra), static_cast<std::size_t>(-1), extraFormat.Text(), reinterpret_cast<const char*>(this->loginExtra));
     GetRagConnection().Send(sizeof(packet), &packet);
@@ -3722,7 +3720,7 @@ void CLoginMode::OnChangeState(int value) {
     this->wallpaperName = g_loginWallpaperName;
     g_windowMgr.SetBackgroundSurface(reinterpret_cast<CBitmapRes*>(ResourceMgr::Instance().Load(Resolve(this->wallpaperName.c_str()))));
     UISelectServerWnd* window = static_cast<UISelectServerWnd*>(g_windowMgr.EnsureWindow(WID_SELECTSERVERWND));
-    const std::array<std::uint8_t, 10> countNameSource = {0x39, 0xC2, 0xCA, 0x4E, 0x66, 0x01, 0xB7, 0x2A, 0x25, 0x97};
+    const std::array<std::uint8_t, 10> countNameSource = CRYPT_BYTES(10, "NUMSERVER", 0x6FE153231D879777ULL);
     thread_local EncryptedName<sizeof(countNameSource), 0x6FE153231D879777ULL> countName(countNameSource);
     window->SendMsg(nullptr, UM_SET_TARGET, 10003, reinterpret_cast<std::intptr_t>(countName.Text()), 0, 0);
 
@@ -3866,19 +3864,17 @@ void CLoginMode::OnChangeState(int value) {
     this->wallpaperName = g_loginWallpaperName;
     g_windowMgr.SetBackgroundSurface(reinterpret_cast<CBitmapRes*>(ResourceMgr::Instance().Load(Resolve(this->wallpaperName.c_str()))));
     if (!std::strstr(g_session.clientVersion, "Dev")) {
-      const std::array<std::uint8_t, 29> hostSource = {0xBA, 0x29, 0xF8, 0xC8, 0x58, 0xE4, 0x88, 0x1E, 0xFF, 0x29, 0xF6, 0x82, 0x57, 0xE6, 0x99,
-                                                       0x40, 0xBA, 0x75, 0xF4, 0x8A, 0x17, 0xEC, 0x99, 0x15, 0xE7, 0x62, 0xA7, 0xD5, 0x39};
+      const std::array<std::uint8_t, 29> hostSource = CRYPT_BYTES(29, "kro-acc1.ragnarok.co.kr:6900", 0x2FEB8739E5975BD1ULL);
       thread_local EncryptedName<sizeof(hostSource), 0x2FEB8739E5975BD1ULL> host(hostSource);
       host.Text();
-      const std::array<std::uint8_t, 3> formatSource = {0xE8, 0x70, 0xCD};
+      const std::array<std::uint8_t, 3> formatSource = CRYPT_BYTES(3, "%s", 0x33133B977BCD03CDULL);
       thread_local EncryptedName<sizeof(formatSource), 0x33133B977BCD03CDULL> format(formatSource);
       format.Text();
     } else {
-      const std::array<std::uint8_t, 30> hostSource = {0x44, 0xA5, 0x2A, 0x08, 0x48, 0xC6, 0x00, 0x90, 0x4E, 0xF9, 0x37, 0x44, 0x5E, 0xC5, 0x4C,
-                                                       0xD3, 0x40, 0xBC, 0x6B, 0x46, 0x56, 0x85, 0x46, 0xD3, 0x15, 0xE1, 0x7C, 0x15, 0x09, 0xAB};
+      const std::array<std::uint8_t, 30> hostSource = CRYPT_BYTES(30, "kro-qm-1a.ragnarok.co.kr:6900", 0xA12DAB392545D72FULL);
       thread_local EncryptedName<sizeof(hostSource), 0xA12DAB392545D72FULL> host(hostSource);
       host.Text();
-      const std::array<std::uint8_t, 3> formatSource = {0x50, 0x48, 0x03};
+      const std::array<std::uint8_t, 3> formatSource = CRYPT_BYTES(3, "%s", 0x6BA1C1132F033B75ULL);
       thread_local EncryptedName<sizeof(formatSource), 0x6BA1C1132F033B75ULL> format(formatSource);
       format.Text();
     }
@@ -4036,14 +4032,14 @@ void CLoginMode::OnChangeState(int value) {
     g_packetReassembler->Notify(1);
     char keyName[MAX_PATH];
     std::strcpy(keyName, g_subKey);
-    const std::array<std::uint8_t, 9> cashKeySource = {0xD1, 0xF5, 0xAA, 0x14, 0xD2, 0xC6, 0xEC, 0xDB, 0x8D};
+    const std::array<std::uint8_t, 9> cashKeySource = CRYPT_BYTES(9, "\\NeoCash", 0xB39FA7917BCFBB8DULL);
     thread_local EncryptedName<sizeof(cashKeySource), 0xB39FA7917BCFBB8DULL> cashKey(cashKeySource);
     std::strcat(keyName, cashKey.Text());
     DWORD category = 0;
     DWORD disposition = 0;
     HKEY key;
     if (RegCreateKeyExA(HKEY_LOCAL_MACHINE, keyName, 0, nullptr, 0, KEY_ALL_ACCESS, nullptr, &key, &disposition) == ERROR_SUCCESS) {
-      const std::array<std::uint8_t, 14> valueNameSource = {0xB4, 0x52, 0x78, 0xE7, 0xAE, 0x4C, 0x5C, 0xD9, 0xB2, 0x54, 0x64, 0xFD, 0xA8, 0x0F};
+      const std::array<std::uint8_t, 14> valueNameSource = CRYPT_BYTES(14, "CASH_CATEGORY", 0x8D1D0FF1AF2B13F7ULL);
       thread_local EncryptedName<sizeof(valueNameSource), 0x8D1D0FF1AF2B13F7ULL> valueName(valueNameSource);
       RegSetValueExA(key, valueName.Text(), 0, REG_DWORD, reinterpret_cast<const BYTE*>(&category), sizeof(category));
       RegCloseKey(key);
@@ -4079,9 +4075,7 @@ void CLoginMode::OnChangeState(int value) {
     const unsigned char flags = g_serviceOptions.Get(0x6C);
     g_session.SetServiceFlags(flags, flags);
     reinterpret_cast<Replay&>(ReplayFileList::Instance()).SetBaseFrame(reinterpret_cast<std::uint32_t>(&Replay::Instance()));
-    const std::array<std::uint8_t, 44> wallpaperSource = {0x77, 0x9E, 0x2F, 0x39, 0xC3, 0x11, 0x5C, 0x82, 0x71, 0xD5, 0x2F, 0x0F, 0xBE, 0x65, 0xC5,
-                                                          0x23, 0xD8, 0x56, 0x86, 0xAD, 0x5C, 0xB6, 0xF7, 0x3B, 0xD2, 0x43, 0x89, 0xA2, 0x60, 0xBA,
-                                                          0xC5, 0x38, 0xD6, 0x43, 0x81, 0xAA, 0x6D, 0xB8, 0xAB, 0x61, 0xD5, 0x5C, 0x9F, 0xC3};
+    const std::array<std::uint8_t, 44> wallpaperSource = CRYPT_BYTES(44, "유저인터페이스\\login_interface\\warning2.bmp", 0x4F99DF03C3EF31B7ULL);
     thread_local EncryptedName<sizeof(wallpaperSource), 0x4F99DF03C3EF31B7ULL> wallpaper(wallpaperSource);
     this->wallpaperName = std::string(wallpaper.Text());
     g_windowMgr.SetBackgroundSurface(reinterpret_cast<CBitmapRes*>(ResourceMgr::Instance().Load(Resolve(this->wallpaperName.c_str()))));
@@ -4160,7 +4154,7 @@ void CLoginMode::OnChangeState(int value) {
   }
   case 30: {
     UISelectServerWnd* window = static_cast<UISelectServerWnd*>(g_windowMgr.EnsureWindow(WID_SELECTSERVERWND));
-    const std::array<std::uint8_t, 8> countNameSource = {0xB9, 0x9C, 0x2E, 0x33, 0x32, 0xD7, 0x34, 0x91};
+    const std::array<std::uint8_t, 8> countNameSource = CRYPT_BYTES(8, "NUMZONE", 0x9171997D6963C9F7ULL);
     thread_local EncryptedName<sizeof(countNameSource), 0x9171997D6963C9F7ULL> countName(countNameSource);
     window->SendMsg(nullptr, UM_SET_TARGET, 10028, reinterpret_cast<std::intptr_t>(countName.Text()), 0, 0);
     for (unsigned int i = 0; i < this->mapStates.size(); ++i) {
diff --git a/Source/Client/Session/Session.cpp b/Source/Client/Session/Session.cpp
index 6e8e547b4..26af1b981 100644
--- a/Source/Client/Session/Session.cpp
+++ b/Source/Client/Session/Session.cpp
@@ -2909,7 +2909,7 @@ void CSession::LoadExternalSettings() {
   this->m_hotkeyScript->Call(std::string("GetTableIntValueForC", 20), "ss>d", "MaxLevelTable", "JobLevel4th", &*reinterpret_cast<int*>(&this->jobLevelLimits[0x78]));
 
   if (*reinterpret_cast<int*>(&this->jobLevelLimits[0x74]) == -1 || *reinterpret_cast<int*>(&this->jobLevelLimits[0x78]) == -1) {
-    const std::array<char, 27> source = {'\xC2', '\x6B', '\x53', '\x54', '\x97', '\x4F', '\xEC', '\xE5', '\xF3', '\x7C', '\x53', '\x55', '\xB6', '\x0A', '\xDD', '\xE9', '\xEE', '\x77', '\x46', '\x48', '\xC5', '\x39', '\xC8', '\xF1', '\xF2', '\x7C', '\x21'};
+    const std::array<char, 27> source = CRYPT_CHARS(27, "Error ExternSettings Value", 0x9DA96FE53B211987ULL);
     thread_local EncryptedName<sizeof(source), 0x9DA96FE53B211987ULL> name(source);
     ShowErrorDialog(name.Text(), 0);
   }
@@ -2918,7 +2918,7 @@ void CSession::LoadExternalSettings() {
   this->m_hotkeyScript->Call(std::string("GetTableIntValueForC", 20), "ss>d", "MaxLevelTable", "JobLevelDoram", &*reinterpret_cast<int*>(&this->jobLevelLimits[0x2C]));
 
   if (*reinterpret_cast<int*>(&this->jobLevelLimits[0x2C]) == -1) {
-    const std::array<char, 27> source = {'\x84', '\x29', '\xA1', '\x34', '\x8D', '\xA7', '\xC6', '\xDF', '\xB5', '\x3E', '\xA1', '\x35', '\xAC', '\xE2', '\xF7', '\xD3', '\xA8', '\x35', '\xB4', '\x28', '\xDF', '\xD1', '\xE2', '\xCB', '\xB4', '\x3E', '\xD3'};
+    const std::array<char, 27> source = CRYPT_CHARS(27, "Error ExternSettings Value", 0xA78387FF5BD35BC1ULL);
     thread_local EncryptedName<sizeof(source), 0xA78387FF5BD35BC1ULL> name(source);
     ShowErrorDialog(name.Text(), 0);
   }
@@ -2945,7 +2945,7 @@ void CSession::LoadExternalSettings() {
   this->m_hotkeyScript->Call(std::string("GetTableIntValueForC", 20), "ss>d", "MaxLevelAuraTable", "MaxLevelEffect4th_sub", &this->m_maxLevelEffect4thSub);
 
   if (this->m_maxLevelEffect4th == -1 || this->m_maxLevelEffect4thSub == -1) {
-    const std::array<char, 27> source = {'\x66', '\x23', '\xB5', '\x54', '\xA1', '\x55', '\x94', '\xF9', '\x57', '\x34', '\xB5', '\x55', '\x80', '\x10', '\xA5', '\xF5', '\x4A', '\x3F', '\xA0', '\x48', '\xF3', '\x23', '\xB0', '\xED', '\x56', '\x34', '\xC7'};
+    const std::array<char, 27> source = CRYPT_CHARS(27, "Error ExternSettings Value", 0x81D175D33BC75123ULL);
     thread_local EncryptedName<sizeof(source), 0x81D175D33BC75123ULL> name(source);
     ShowErrorDialog(name.Text(), 0);
   }
@@ -2962,15 +2962,15 @@ void CSession::Init() {
   const char* fileName = std::strrchr(modulePath, '\\');
   std::strncpy(directory, modulePath, std::strlen(modulePath) - std::strlen(fileName + 1));
 
-  const std::array<char, 32> keySource = {'\xC4', '\x9E', '\x87', '\xA9', '\xA6', '\xF2', '\x9B', '\x4A', '\xCB', '\xB6', '\x93', '\xBC', '\xA7', '\xFA', '\x9D', '\x56', '\xCB', '\xA3', '\x80', '\xBA', '\xBF', '\xF2', '\x9B', '\x40', '\xFC', '\xBE', '\x8F', '\xB1', '\xB8', '\xFD', '\x8C', '\x2F'};
+  const std::array<char, 32> keySource = CRYPT_CHARS(32, "Software\\Gravity\\RagnarokOnline", 0x2FE993D1DDE1F197ULL);
   thread_local EncryptedName<sizeof(keySource), 0x2FE993D1DDE1F197ULL> keyName(keySource);
   HKEY key;
   if (RegCreateKeyExA(HKEY_CURRENT_USER, keyName.Text(), 0, nullptr, 0, KEY_ALL_ACCESS, nullptr, &key, nullptr) == ERROR_SUCCESS) {
-    const std::array<char, 8> pathSource = {'\xAF', '\xB6', '\x2A', '\xF9', '\xD4', '\xFB', '\xFF', '\xE7'};
+    const std::array<char, 8> pathSource = CRYPT_CHARS(8, "RagPath", 0xE7978FB5A94DD7FDULL);
     thread_local EncryptedName<sizeof(pathSource), 0xE7978FB5A94DD7FDULL> pathName(pathSource);
     std::string valueName = pathName.Text();
     if (g_serviceMode == 1) {
-      const std::array<char, 11> sakraySource = {'\x38', '\xD8', '\xAC', '\x7D', '\x06', '\xF6', '\xAD', '\xD6', '\x1F', '\xD1', '\xC7'};
+      const std::array<char, 11> sakraySource = CRYPT_CHARS(11, "SakrayPath", 0xB7FD8F670FC7B96BULL);
       thread_local EncryptedName<sizeof(sakraySource), 0xB7FD8F670FC7B96BULL> sakrayName(sakraySource);
       std::string sakrayValueName = sakrayName.Text();
     }
@@ -4779,42 +4779,42 @@ CSession::CSession() {
   CSpecialPopupMgr::Create();
   CRuneSystemMgr::Create();
   if (!CUserHotkeyMgr::Initialize()) {
-    const std::array<char, 6> captionSource = {'\x3A', '\x61', '\xAD', '\xBE', '\xF7', '\x67'};
+    const std::array<char, 6> captionSource = CRYPT_CHARS(6, "Error", 0xED796785D1DF137FULL);
     thread_local EncryptedName<sizeof(captionSource), 0xED796785D1DF137FULL> caption(captionSource);
     const char* captionText = caption.Text();
-    const std::array<char, 33> textSource = {'\xB2', '\x92', '\x4A', '\x6C', '\x65', '\x31', '\x20', '\x85', '\x9A', '\xA2', '\x40', '\x44', '\x70', '\x0B', '\x75', '\xCB', '\xB2', '\xB5', '\x5C', '\x68', '\x63', '\x1C', '\x06', '\x9F', '\x82', '\xB3', '\x58', '\x67', '\x74', '\x1C', '\x67', '\xD8', '\xF1'};
+    const std::array<char, 33> textSource = CRYPT_CHARS(33, "CUserHotkeyMgr::CreateInstance()", 0xF14F79170939C7F1ULL);
     thread_local EncryptedName<sizeof(textSource), 0xF14F79170939C7F1ULL> text(textSource);
     MessageBoxA(nullptr, text.Text(), captionText, MB_OK);
   }
   if (!CBarterMarketItemMgr::CreateInstance()) {
-    const std::array<char, 6> captionSource = {'\xE2', '\x87', '\x0D', '\x56', '\x43', '\x4B'};
+    const std::array<char, 6> captionSource = CRYPT_CHARS(6, "Error", 0xBF2B4B31397FF5A7ULL);
     thread_local EncryptedName<sizeof(captionSource), 0xBF2B4B31397FF5A7ULL> caption(captionSource);
     const char* captionText = caption.Text();
-    const std::array<char, 47> textSource = {'\x40', '\x49', '\x5C', '\xCF', '\xDC', '\x33', '\x1E', '\xBC', '\x4A', '\x65', '\x4E', '\xC9', '\xC9', '\x38', '\x0F', '\x94', '\x68', '\x55', '\x44', '\xDE', '\xC9', '\x14', '\x09', '\xBC', '\x64', '\x6A', '\x48', '\xC9', '\x87', '\x67', '\x3E', '\xAB', '\x6C', '\x46', '\x5B', '\xDE', '\xF4', '\x33', '\x0E', '\xAD', '\x68', '\x49', '\x4C', '\xDE', '\x95', '\x74', '\x7D'};
+    const std::array<char, 47> textSource = CRYPT_CHARS(47, "InstanceCBarterMarketItemMgr::CreateInstance()", 0xD97D5DBDBB2F2709ULL);
     thread_local EncryptedName<sizeof(textSource), 0xD97D5DBDBB2F2709ULL> text(textSource);
     MessageBoxA(nullptr, text.Text(), captionText, MB_OK);
   }
   if (!CExpandedBarterMarketItemMgr::CreateInstance()) {
-    const std::array<char, 6> captionSource = {'\xDE', '\x25', '\x71', '\xF6', '\x15', '\x05'};
+    const std::array<char, 6> captionSource = CRYPT_CHARS(6, "Error", 0x050505679903579BULL);
     thread_local EncryptedName<sizeof(captionSource), 0x050505679903579BULL> caption(captionSource);
     const char* captionText = caption.Text();
-    const std::array<char, 48> textSource = {'\xF4', '\xD3', '\x9E', '\x43', '\xDA', '\xD1', '\x8C', '\xE6', '\xFE', '\xFF', '\x8C', '\x45', '\xCF', '\xDA', '\x9D', '\xCE', '\xDC', '\xCF', '\x86', '\x52', '\xCF', '\xF6', '\x9B', '\xE6', '\xD0', '\x8F', '\xA0', '\x50', '\xC9', '\x85', '\xD5', '\xC0', '\xCF', '\xD8', '\x8C', '\x43', '\xDE', '\xF6', '\x81', '\xF0', '\xC9', '\xDC', '\x83', '\x54', '\xDE', '\x97', '\xC6', '\x83'};
+    const std::array<char, 48> textSource = CRYPT_CHARS(48, "InstanceCBarterMarketItem2Mgr::CreateInstance()", 0x83EFBFBB37EDBDBDULL);
     thread_local EncryptedName<sizeof(textSource), 0x83EFBFBB37EDBDBDULL> text(textSource);
     MessageBoxA(nullptr, text.Text(), captionText, MB_OK);
   }
   if (!CPetEvolutionMgr::Create()) {
-    const std::array<char, 6> captionSource = {'\x88', '\x83', '\xEB', '\xDA', '\xFF', '\x5B'};
+    const std::array<char, 6> captionSource = CRYPT_CHARS(6, "Error", 0xAD075B8DB599F1CDULL);
     thread_local EncryptedName<sizeof(captionSource), 0xAD075B8DB599F1CDULL> caption(captionSource);
     const char* captionText = caption.Text();
-    const std::array<char, 27> textSource = {'\xA2', '\x2B', '\x9C', '\xA3', '\x90', '\x65', '\x56', '\xB1', '\x94', '\x0F', '\x90', '\xB8', '\xBB', '\x5E', '\x5E', '\xAF', '\xC1', '\x1D', '\x90', '\xBB', '\xB0', '\x33', '\x70', '\xB3', '\x88', '\x0F', '\xF9'};
+    const std::array<char, 27> textSource = CRYPT_CHARS(27, "CPetEvolutionMgr file Init", 0xDD3913D5D7F97BE1ULL);
     thread_local EncryptedName<sizeof(textSource), 0xDD3913D5D7F97BE1ULL> text(textSource);
     MessageBoxA(nullptr, text.Text(), captionText, MB_OK);
   }
   if (!CAchievementMgr::CreateInstance()) {
-    const std::array<char, 6> captionSource = {'\xCA', '\xEB', '\x99', '\x62', '\xC7', '\x7F'};
+    const std::array<char, 6> captionSource = CRYPT_CHARS(6, "Error", 0x39FF7FB50DEB998FULL);
     thread_local EncryptedName<sizeof(captionSource), 0x39FF7FB50DEB998FULL> caption(captionSource);
     const char* captionText = caption.Text();
-    const std::array<char, 26> textSource = {'\x3C', '\x54', '\xEE', '\x79', '\x5E', '\x6A', '\xFD', '\x4A', '\x12', '\x70', '\xE3', '\x65', '\x7A', '\x68', '\xF9', '\x0F', '\x19', '\x7C', '\xE1', '\x74', '\x17', '\x66', '\xE5', '\x46', '\x0B', '\x15'};
+    const std::array<char, 26> textSource = CRYPT_CHARS(26, "CAchievementMgr file init", 0x2F8B0F37118D157FULL);
     thread_local EncryptedName<sizeof(textSource), 0x2F8B0F37118D157FULL> text(textSource);
     MessageBoxA(nullptr, text.Text(), captionText, MB_OK);
   }
@@ -4869,7 +4869,7 @@ void CSession::LoadLuaDataFiles() {
   this->m_hotkeyScript->Load("Lua Files\\DataInfo\\jobName_F", true, false);
   this->m_hotkeyScript->Load("Lua Files\\DataInfo\\jobName", true, false);
   {
-    const std::array<char, 27> source = {'\x39', '\xB8', '\x8C', '\x7D', '\x2D', '\x0C', '\x89', '\x50', '\x06', '\x91', '\xA9', '\x3C', '\x1F', '\x04', '\xAC', '\x5B', '\x13', '\xA2', '\xB1', '\x0D', '\x0E', '\x11', '\xAC', '\x5B', '\x13', '\xA2', '\xED'};
+    const std::array<char, 27> source = CRYPT_CHARS(27, "Lua Files\\DataInfo\\PetInfo", 0x35E5656B5DEDCD75ULL);
     thread_local EncryptedName<sizeof(source), 0x35E5656B5DEDCD75ULL> name(source);
     this->m_hotkeyScript->Load(name.Text(), true, false);
   }
@@ -4888,12 +4888,12 @@ void CSession::LoadLuaDataFiles() {
   this->m_hotkeyScript->Load("Lua Files\\SkillInfoz\\jobinheritlist", true, false);
   this->m_hotkeyScript->Load("Lua Files\\SkillInfoz\\SkillID", true, false);
   {
-    const std::array<char, 35> source = {'\xB1', '\xCC', '\xDA', '\x01', '\xD9', '\x94', '\x2D', '\x2C', '\x8E', '\xE5', '\xE8', '\x4A', '\xF6', '\x91', '\x2D', '\x00', '\x93', '\xDF', '\xD4', '\x5B', '\xC3', '\xAE', '\x2A', '\x20', '\x91', '\xD5', '\xF2', '\x4F', '\xF9', '\x92', '\x0D', '\x20', '\x8E', '\xCD', '\xBB'};
+    const std::array<char, 35> source = CRYPT_CHARS(35, "Lua Files\\SkillInfoz\\SkillInfoList", 0x4941FD9F21BBB9FDULL);
     thread_local EncryptedName<sizeof(source), 0x4941FD9F21BBB9FDULL> name(source);
     this->m_hotkeyScript->Load(name.Text(), true, false);
   }
   {
-    const std::array<char, 35> source = {'\x29', '\x6C', '\x24', '\x29', '\x6B', '\x4A', '\x77', '\xEC', '\x16', '\x45', '\x16', '\x62', '\x44', '\x4F', '\x77', '\xC0', '\x0B', '\x7F', '\x2A', '\x73', '\x71', '\x70', '\x70', '\xE0', '\x09', '\x75', '\x01', '\x6C', '\x5E', '\x40', '\x69', '\xE0', '\x15', '\x6D', '\x45'};
+    const std::array<char, 35> source = CRYPT_CHARS(35, "Lua Files\\SkillInfoz\\SkillDescript", 0x891B232D09451965ULL);
     thread_local EncryptedName<sizeof(source), 0x891B232D09451965ULL> name(source);
     this->m_hotkeyScript->Load(name.Text(), true, false);
   }
@@ -4902,7 +4902,7 @@ void CSession::LoadLuaDataFiles() {
   this->m_hotkeyScript->Load("Lua Files\\SkillInfoz\\skilltreeview", true, false);
   this->m_hotkeyScript->Load("Lua Files\\StateIcon\\EFSTIDs", true, false);
   {
-    const std::array<char, 34> source = {'\xF5', '\x70', '\x16', '\x6F', '\x4D', '\x74', '\xE3', '\x10', '\xCA', '\x59', '\x24', '\x3B', '\x6A', '\x69', '\xEA', '\x3C', '\xDA', '\x6A', '\x19', '\x13', '\x58', '\x69', '\xEE', '\x01', '\xDC', '\x4C', '\x14', '\x20', '\x65', '\x54', '\xE1', '\x13', '\xD6', '\x05'};
+    const std::array<char, 34> source = CRYPT_CHARS(34, "Lua Files\\StateIcon\\StateIconInfo", 0x758F1D0B4F7705B9ULL);
     thread_local EncryptedName<sizeof(source), 0x758F1D0B4F7705B9ULL> name(source);
     this->m_hotkeyScript->Load(name.Text(), true, false);
   }
@@ -4948,7 +4948,7 @@ void CSession::LoadLuaDataFiles() {
   this->LoadNavigationScripts();
   this->m_hotkeyScript->Load("Lua Files\\DataInfo\\HelpMsgStr", true, false);
   {
-    const std::array<char, 36> source = {'\x1D', '\xFE', '\xAC', '\x21', '\xFD', '\x54', '\x2D', '\xB4', '\x22', '\xD7', '\x88', '\x6F', '\xCF', '\x4F', '\x38', '\x80', '\x24', '\xEE', '\xB8', '\x64', '\xE7', '\x78', '\x2F', '\xA5', '\x23', '\xF2', '\x9C', '\x74', '\xDE', '\x48', '\x24', '\x9D', '\x38', '\xF8', '\xB9', '\x01'};
+    const std::array<char, 36> source = CRYPT_CHARS(36, "Lua Files\\EntryQueue\\EntryQueueList", 0xD1413DBB01CD8B51ULL);
     thread_local EncryptedName<sizeof(source), 0xD1413DBB01CD8B51ULL> name(source);
     this->m_hotkeyScript->Load(name.Text(), true, false);
   }
@@ -4982,7 +4982,7 @@ void CSession::LoadLuaDataFiles() {
 
   this->m_hotkeyScript->Load("Lua Files\\SignBoardList_F", true, false);
   {
-    const std::array<char, 24> source = {'\x25', '\x6A', '\x16', '\x75', '\xDB', '\xFC', '\x17', '\x06', '\x1A', '\x43', '\x24', '\x3C', '\xFA', '\xFB', '\x39', '\x0C', '\x08', '\x6D', '\x13', '\x19', '\xF4', '\xE6', '\x0F', '\x63'};
+    const std::array<char, 24> source = CRYPT_CHARS(24, "Lua Files\\SignBoardList", 0x637B959D55771F69ULL);
     thread_local EncryptedName<sizeof(source), 0x637B959D55771F69ULL> name(source);
     this->m_hotkeyScript->Load(name.Text(), true, false);
   }
@@ -4992,12 +4992,12 @@ void CSession::LoadLuaDataFiles() {
   this->m_hotkeyScript->Load("Lua Files\\OffsetItemPos\\OffsetItemPos_F", true, false);
   this->m_hotkeyScript->Load("Lua Files\\OffsetItemPos\\OffsetItemPos", true, false);
   {
-    const std::array<char, 37> source = {'\x95', '\x8C', '\x80', '\xC3', '\x2B', '\x7C', '\xC1', '\x4E', '\xAA', '\xA5', '\x85', '\x82', '\x19', '\x74', '\xC4', '\x45', '\xBF', '\x96', '\xBD', '\xAF', '\x0C', '\x65', '\xC4', '\x45', '\xBC', '\xBD', '\x85', '\x96', '\x06', '\x51', '\xE9', '\x4A', '\xB2', '\xBB', '\x8E', '\x9B', '\x6D'};
+    const std::array<char, 37> source = CRYPT_CHARS(37, "Lua Files\\datainfo\\LapineDdukDDakBox", 0x2BAD156DE3E1F9D9ULL);
     thread_local EncryptedName<sizeof(source), 0x2BAD156DE3E1F9D9ULL> name(source);
     this->m_hotkeyScript->Load(name.Text(), true, false);
   }
   {
-    const std::array<char, 36> source = {'\xC3', '\xC8', '\x8E', '\xA7', '\x3B', '\xAC', '\xC1', '\x10', '\xFC', '\xE1', '\x8B', '\xE6', '\x09', '\xA4', '\xC4', '\x1B', '\xE9', '\xD2', '\xB3', '\xCB', '\x1C', '\xB5', '\xC4', '\x1B', '\xEA', '\xE8', '\x9F', '\xE0', '\x0F', '\xA4', '\xC9', '\x10', '\xCD', '\xD2', '\x97', '\x87'};
+    const std::array<char, 36> source = CRYPT_CHARS(36, "Lua Files\\datainfo\\LapineUpgradeBox", 0x75ADC57D87EFBD8FULL);
     thread_local EncryptedName<sizeof(source), 0x75ADC57D87EFBD8FULL> name(source);
     this->m_hotkeyScript->Load(name.Text(), true, false);
   }
@@ -5009,28 +5009,28 @@ void CSession::LoadLuaDataFiles() {
   this->m_hotkeyScript->Load("Lua Files\\datainfo\\tb_cashshop_banner", true, false);
   this->m_hotkeyScript->Load("Lua Files\\datainfo\\tb_stoveshop_banner", true, false);
   {
-    const std::array<char, 26> source = {'\xA3', '\x04', '\xBE', '\x33', '\x2B', '\x26', '\xAB', '\x88', '\x9C', '\x2D', '\x9E', '\x74', '\x04', '\x3B', '\x9B', '\xAC', '\x88', '\x18', '\xAB', '\x50', '\x02', '\x21', '\xA1', '\x84', '\x88', '\x71'};
+    const std::array<char, 26> source = CRYPT_CHARS(26, "Lua Files\\Agit\\AgitConfig", 0xEDC74F6D13DF71EFULL);
     thread_local EncryptedName<sizeof(source), 0xEDC74F6D13DF71EFULL> name(source);
     this->m_hotkeyScript->Load(name.Text(), true, false);
   }
   {
-    const std::array<char, 28> source = {'\xD9', '\xFA', '\x80', '\x2D', '\x1B', '\x60', '\x0D', '\x94', '\xE6', '\xD3', '\xA0', '\x6A', '\x34', '\x7D', '\x3D', '\xB0', '\xF2', '\xE6', '\x95', '\x4E', '\x32', '\x67', '\x07', '\x98', '\xF2', '\xD0', '\xA7', '\x0D'};
+    const std::array<char, 28> source = CRYPT_CHARS(28, "Lua Files\\Agit\\AgitConfig_F", 0xF161095D0DE18F95ULL);
     thread_local EncryptedName<sizeof(source), 0xF161095D0DE18F95ULL> name(source);
     this->m_hotkeyScript->Load(name.Text(), true, false);
   }
   this->m_hotkeyScript->Load("Lua Files\\datainfo\\tb_checkAttendance_banner", true, false);
   {
-    const std::array<char, 36> source = {'\xCB', '\x66', '\x0A', '\x5F', '\x7F', '\x60', '\x1D', '\x6E', '\xF4', '\x4F', '\x2F', '\x1E', '\x54', '\x68', '\x16', '\x6E', '\xD4', '\x78', '\x02', '\x11', '\x65', '\x4D', '\x10', '\x66', '\xE6', '\x74', '\x0E', '\x2C', '\x52', '\x60', '\x1F', '\x47', '\xEE', '\x60', '\x1F', '\x7F'};
+    const std::array<char, 36> source = CRYPT_CHARS(36, "Lua Files\\DamageSkin\\DamageSkinList", 0x0B7109397F6B1387ULL);
     thread_local EncryptedName<sizeof(source), 0x0B7109397F6B1387ULL> name(source);
     this->m_hotkeyScript->Load(name.Text(), true, false);
   }
   {
-    const std::array<char, 36> source = {'\xE9', '\xE8', '\x0C', '\xD9', '\x25', '\x4E', '\x1B', '\x66', '\xD6', '\xC1', '\x29', '\x98', '\x0E', '\x46', '\x10', '\x66', '\xF6', '\xF6', '\x04', '\x97', '\x3F', '\x63', '\x16', '\x6E', '\xC4', '\xFA', '\x08', '\xAA', '\x08', '\x4E', '\x19', '\x4A', '\xCB', '\xFB', '\x02', '\xF9'};
+    const std::array<char, 36> source = CRYPT_CHARS(36, "Lua Files\\DamageSkin\\DamageSkinInfo", 0x03772763F96D9DA5ULL);
     thread_local EncryptedName<sizeof(source), 0x03772763F96D9DA5ULL> name(source);
     this->m_hotkeyScript->Load(name.Text(), true, false);
   }
   {
-    const std::array<char, 38> source = {'\x21', '\xCE', '\xF4', '\x0D', '\xD5', '\x92', '\x7B', '\xA0', '\x1E', '\xE7', '\xD1', '\x4C', '\xFE', '\x9A', '\x70', '\xA0', '\x3E', '\xD0', '\xFC', '\x43', '\xCF', '\xBF', '\x76', '\xA8', '\x0C', '\xDC', '\xF0', '\x7E', '\xF8', '\x92', '\x79', '\x8C', '\x03', '\xDD', '\xFA', '\x72', '\xD5', '\xFB'};
+    const std::array<char, 38> source = CRYPT_CHARS(38, "Lua Files\\DamageSkin\\DamageSkinInfo_F", 0xC517FB932D95BB6DULL);
     thread_local EncryptedName<sizeof(source), 0xC517FB932D95BB6DULL> name(source);
     this->m_hotkeyScript->Load(name.Text(), true, false);
   }
diff --git a/Source/Contents/Actors/RenderObject.cpp b/Source/Contents/Actors/RenderObject.cpp
index 4ad102c9f..d85ed0311 100644
--- a/Source/Contents/Actors/RenderObject.cpp
+++ b/Source/Contents/Actors/RenderObject.cpp
@@ -3005,12 +3005,12 @@ static std::string ShapeShiftName(int form, int job) {
       return name.Text();
     }
     case JT_ALITEA: {
-      const std::uint8_t source[] = {0x5E, 0x62, 0x7D, 0xFE, 0xEA, 0x12, 0x31, 0x9F, 0x3A, 0x27};
+      const std::uint8_t source[] = CRYPT_BYTES(10, "WEREWOLF3", 0xD97D5DBDBB2F2709ULL);
       thread_local EncryptedName<sizeof(source), 0xD97D5DBDBB2F2709ULL> name(source);
       return name.Text();
     }
     default: {
-      const std::uint8_t source[] = {0x28, 0x56, 0x8D, 0x94, 0xD2, 0x28, 0x35, 0xAB, 0x7F};
+      const std::uint8_t source[] = CRYPT_BYTES(9, "WEREWOLF", 0xED796785D1DF137FULL);
       thread_local EncryptedName<sizeof(source), 0xED796785D1DF137FULL> name(source);
       return name.Text();
     }
@@ -3019,17 +3019,17 @@ static std::string ShapeShiftName(int form, int job) {
     switch (job) {
     case JT_KARNOS:
     case JT_KARNOS_B: {
-      const std::uint8_t source[] = {0xEA, 0xF8, 0xBF, 0x72, 0xE9, 0xFE, 0xBF, 0xD7, 0xF2, 0xEF, 0xDF, 0x37};
+      const std::uint8_t source[] = CRYPT_BYTES(12, "WERERAPTOR2", 0x83EFBFBB37EDBDBDULL);
       thread_local EncryptedName<sizeof(source), 0x83EFBFBB37EDBDBDULL> name(source);
       return name.Text();
     }
     case JT_ALITEA: {
-      const std::uint8_t source[] = {0xF0, 0xB0, 0x2D, 0x7C, 0x63, 0x0A, 0x7B, 0xEB, 0xE8, 0xA7, 0x4C, 0x39};
+      const std::uint8_t source[] = CRYPT_BYTES(12, "WERERAPTOR3", 0xBF2B4B31397FF5A7ULL);
       thread_local EncryptedName<sizeof(source), 0xBF2B4B31397FF5A7ULL> name(source);
       return name.Text();
     }
     default: {
-      const std::uint8_t source[] = {0xB6, 0x3E, 0xAB, 0x92, 0x87, 0x52, 0x69, 0x89, 0xAE, 0x29, 0xF9};
+      const std::uint8_t source[] = CRYPT_BYTES(11, "WERERAPTOR", 0xDD3913D5D7F97BE1ULL);
       thread_local EncryptedName<sizeof(source), 0xDD3913D5D7F97BE1ULL> name(source);
       return name.Text();
     }
diff --git a/Source/Contents/Configuration/ServiceConfiguration.cpp b/Source/Contents/Configuration/ServiceConfiguration.cpp
index e6ad98436..6c285d966 100644
--- a/Source/Contents/Configuration/ServiceConfiguration.cpp
+++ b/Source/Contents/Configuration/ServiceConfiguration.cpp
@@ -231,39 +231,36 @@ void InitializeServiceStrings() {
     constexpr std::array<std::uint8_t, 14> clientArray = CRYPT_NAME("RagIndoor.exe", 0xC399B7091589B50BULL);
     const std::uint8_t (&client)[14] = clientArray._Elems;
     g_clientExeName = DecryptText<0xC399B7091589B50BULL>(client);
-    const std::uint8_t patcher[] = {0x50, 0x03, 0xAB, 0x90, 0x32, 0x73, 0xB4, 0x0F, 0x37, 0x08, 0xB7, 0x9A, 0x5D};
+    const std::uint8_t patcher[] = CRYPT_BYTES(13, "Indoorup.exe", 0x7FC1015DFFCF6D19ULL);
     g_patcherExeName = DecryptText<0x7FC1015DFFCF6D19ULL>(patcher);
     const auto message = CRYPT_NAME("Please run RagIndoor.exe", 0x0753A7E1EFA9E139ULL);
     g_runPatcherMessage = DecryptString<0x0753A7E1EFA9E139ULL>(message.data);
     break;
   }
   case 3: {
-    const std::uint8_t client[] = {0x1F, 0xB0, 0xAC, 0x80, 0x8C, 0x1E, 0xA1, 0x1B, 0x63, 0xB4, 0xB3, 0xA2, 0xF9};
+    const std::uint8_t client[] = CRYPT_BYTES(13, "RagGuild.exe", 0x7FCD77F9C7CBD14DULL);
     g_clientExeName = DecryptText<0x7FCD77F9C7CBD14DULL>(client);
-    const std::uint8_t patcher[] = {0x64, 0xF6, 0xB2, 0xEF, 0x25, 0xC8, 0x4F, 0xE5, 0x46, 0xFB, 0xBE, 0x83};
+    const std::uint8_t patcher[] = CRYPT_BYTES(12, "Guildup.exe", 0xCB3FBD4183DB8323ULL);
     g_patcherExeName = DecryptText<0xCB3FBD4183DB8323ULL>(patcher);
-    const char message[] = {'\xBF', '\x4F', '\xB0', '\x8E', '\x6A', '\x34', '\xB1', '\x49', '\x9A', '\x4D', '\xF5', '\xBD',
-                                    '\x78', '\x36', '\xD6', '\x4E', '\x86', '\x4F', '\xB1', '\xC1', '\x7C', '\x29', '\xF4', '\x3B'};
+    const char message[] = CRYPT_CHARS(24, "Please run RagGuild.exe", 0x3B915119EFD523EFULL);
     g_runPatcherMessage = DecryptString<0x3B915119EFD523EFULL>(message);
     break;
   }
   default: {
-    const std::uint8_t dev[] = {0xEB, 0x2A, 0x5D, 0xE3};
+    const std::uint8_t dev[] = CRYPT_BYTES(4, "Dev", 0x3F5315DFE32B4FAFULL);
     if (std::strstr(g_launchServerName, DecryptText<0x3F5315DFE32B4FAFULL>(dev))) {
-      const std::uint8_t client[] = {0xED, 0xDC, 0xB8, 0x51, 0x2C, 0x5F, 0xEC, 0x58, 0xEE, 0xF0, 0xF1, 0x5A, 0x35, 0x48, 0x83};
+      const std::uint8_t client[] = CRYPT_BYTES(15, "RagnarokQM.exe", 0x33832D4D3FDFBDBFULL);
       g_clientExeName = DecryptText<0x33832D4D3FDFBDBFULL>(client);
-      const std::uint8_t patcher[] = {0xA1, 0xA2, 0x9D, 0xDE, 0xC5, 0x78, 0x05, 0x2C, 0xBC, 0xED, 0x8C, 0xC5, 0xC8, 0x0D};
+      const std::uint8_t patcher[] = CRYPT_BYTES(14, "PatchupQM.exe", 0x7D750DADBDE9C3F1ULL);
       g_patcherExeName = DecryptText<0x7D750DADBDE9C3F1ULL>(patcher);
-      const char message[] = {'\x45', '\xFF', '\xD6', '\xA0', '\x94', '\x26', '\x71', '\x9F', '\x60', '\xFD', '\x93', '\x93', '\x86',
-                                      '\x24', '\x3F', '\x8C', '\x67', '\xFC', '\xD8', '\x90', '\xAA', '\x6D', '\x34', '\x95', '\x70', '\x93'};
+      const char message[] = CRYPT_CHARS(26, "Please run RagnarokQM.exe", 0xED5143E7C1B39315ULL);
       g_runPatcherMessage = DecryptString<0xED5143E7C1B39315ULL>(message);
     } else {
-      const std::uint8_t client[] = {0x8B, 0x58, 0x74, 0x17, 0xAA, 0xF1, 0x12, 0x94, 0xF7, 0x5C, 0x6B, 0x1C, 0xCB};
+      const std::uint8_t client[] = CRYPT_BYTES(13, "Ragnarok.exe", 0xFF7D83CB791339D9ULL);
       g_clientExeName = DecryptText<0xFF7D83CB791339D9ULL>(client);
-      const std::uint8_t patcher[] = {0xC5, 0x9C, 0x65, 0xD0, 0x39, 0x10, 0xE5, 0x1F, 0xF0, 0x85, 0x74, 0xB3};
+      const std::uint8_t patcher[] = CRYPT_BYTES(12, "Patchup.exe", 0x31956551B311FD95ULL);
       g_patcherExeName = DecryptText<0x31956551B311FD95ULL>(patcher);
-      const char message[] = {'\xC1', '\xAF', '\xD8', '\x00', '\x16', '\xF4', '\x1D', '\x4B', '\xE4', '\xAD', '\x9D', '\x33',
-                                      '\x04', '\xF6', '\x53', '\x58', '\xE3', '\xAC', '\xD6', '\x4F', '\x00', '\xE9', '\x58', '\x39'};
+      const char message[] = CRYPT_CHARS(24, "Please run Ragnarok.exe", 0x393D916561BDC391ULL);
       g_runPatcherMessage = DecryptString<0x393D916561BDC391ULL>(message);
     }
     break;
@@ -472,7 +469,7 @@ void InitializeLanguage() {
 // OFFSET: 0x00AD1C90
 // FUNCTION: fn_17817
 void InitializeServiceConfiguration() {
-  const std::uint8_t portSource[] = {0xED, 0xBA, 0xF1, 0x3F, 0xAB};
+  const std::uint8_t portSource[] = CRYPT_BYTES(5, "6900", 0xEB3D4FAB0FC183DBULL);
   g_servicePort = DecryptText<0xEB3D4FAB0FC183DBULL>(portSource);
 
   constexpr auto webPageSourceText = CRYPT_NAME("http://www.ragnarok.co.kr", 0xFFBF43D1FFD5FF49ULL);
@@ -497,7 +494,7 @@ void InitializeServiceConfiguration() {
 
       constexpr auto addressSourceText = CRYPT_NAME("kro-qm-1a.ragnarok.co.kr:6951", 0x2D33791F67AD47DFULL);
       const auto& addressSource = addressSourceText.data;
-      const std::uint8_t formatSource[] = {0xAC, 0x4E, 0x6D};
+      const std::uint8_t formatSource[] = CRYPT_BYTES(3, "%s", 0x2F2701A7E56D3D89ULL);
       StringFormat(g_serviceAddress, sizeof(g_serviceAddress), static_cast<std::size_t>(-1), DecryptText<0x2F2701A7E56D3D89ULL>(formatSource), DecryptString<0x2D33791F67AD47DFULL>(addressSource));
     } else {
       constexpr auto keySourceText = CRYPT_NAME("kro-acc3.ragnarok.co.kr:6900", 0x6B3301E1A3079125ULL);
@@ -506,7 +503,7 @@ void InitializeServiceConfiguration() {
 
       constexpr auto addressSourceText = CRYPT_NAME("kro-agency-s.ragnarok.co.kr:6954", 0xC39FB559A17D3963ULL);
       const auto& addressSource = addressSourceText.data;
-      const std::uint8_t formatSource[] = {0xAC, 0x4E, 0x6D};
+      const std::uint8_t formatSource[] = CRYPT_BYTES(3, "%s", 0x2F2701A7E56D3D89ULL);
       StringFormat(g_serviceAddress, sizeof(g_serviceAddress), static_cast<std::size_t>(-1), DecryptText<0x2F2701A7E56D3D89ULL>(formatSource), DecryptString<0xC39FB559A17D3963ULL>(addressSource));
     }
     g_adminAccountIds.assign(std::begin(s_adminIds), std::end(s_adminIds));
@@ -515,7 +512,7 @@ void InitializeServiceConfiguration() {
   }
   case 2: {
     g_serviceFlag07 = 14;
-    const std::uint8_t hostSource[] = {0x9E, 0x98, 0xF7, 0x19, 0x26, 0x5F, 0x8F, 0x5F, 0x9A, 0x8F, 0xF0, 0x05, 0x17};
+    const std::uint8_t hostSource[] = CRYPT_BYTES(13, "192.168.5.52", 0x71B7691737C5A1AFULL);
     g_serviceHost = DecryptText<0x71B7691737C5A1AFULL>(hostSource);
     break;
   }
@@ -524,7 +521,7 @@ void InitializeServiceConfiguration() {
     const auto& hostSource = hostSourceText.data;
     g_serviceHost = DecryptString<0x899D11BB83695B0DULL>(hostSource);
     g_serviceFlag07 = 29;
-    const std::uint8_t portSource[] = {0xC3, 0x1C, 0x63, 0xD9, 0xD7};
+    const std::uint8_t portSource[] = CRYPT_BYTES(5, "6900", 0x2B8725D7E95325F5ULL);
     g_servicePort = DecryptText<0x2B8725D7E95325F5ULL>(portSource);
     g_adminAccountIds.assign(std::begin(s_adminIds), std::end(s_adminIds));
     g_monsterJobs.assign(std::begin(s_monsterJobIds), std::end(s_monsterJobIds));
diff --git a/Source/Contents/Emblems/EmblemDataMgr.cpp b/Source/Contents/Emblems/EmblemDataMgr.cpp
index c7e19f015..c4be36feb 100644
--- a/Source/Contents/Emblems/EmblemDataMgr.cpp
+++ b/Source/Contents/Emblems/EmblemDataMgr.cpp
@@ -66,7 +66,7 @@ void CEmblemDataMgr::RefreshUrls(LuaScript& settings, LuaScript& tables, const c
       this->m_uploadUrl = base + name.Text();
     }
     {
-      const std::uint8_t source[] = {0xEA, 0xA8, 0xEA, 0x97, 0xCD, 0xC6, 0x8A, 0xBC, 0xA1, 0xA2, 0xF0, 0x9B, 0xCD, 0xCC, 0x86, 0xF7, 0xC5};
+      const std::uint8_t source[] = CRYPT_BYTES(17, "/emblem/download", 0x93E7A3A1F587CDC5ULL);
       thread_local EncryptedName<sizeof(source), 0x93E7A3A1F587CDC5ULL> name(source);
       this->m_downloadUrl = base + name.Text();
     }
diff --git a/Source/Contents/Emblems/EmblemDataUploadAsyncWork.cpp b/Source/Contents/Emblems/EmblemDataUploadAsyncWork.cpp
index 3991b1403..b042ba190 100644
--- a/Source/Contents/Emblems/EmblemDataUploadAsyncWork.cpp
+++ b/Source/Contents/Emblems/EmblemDataUploadAsyncWork.cpp
@@ -85,22 +85,22 @@ bool CEmblemDataUploadAsyncWork::Execute() {
   constexpr std::array<std::uint8_t, 10> authTokenArray = CRYPT_NAME("AuthToken", 0x59278F63D79F3DA1ULL);
   const std::uint8_t (&authToken)[10] = authTokenArray._Elems;
   handler.AddField(DecryptName<0x59278F63D79F3DA1ULL>(authToken), this->m_token, 4);
-  const std::uint8_t worldName[] = {0x48, 0x5E, 0xBF, 0x8B, 0x89, 0x3B, 0x0C, 0x70, 0x7A, 0x31};
+  const std::uint8_t worldName[] = CRYPT_BYTES(10, "WorldName", 0x1D6D75EDE7CD311FULL);
   handler.AddField(DecryptName<0x1D6D75EDE7CD311FULL>(worldName), name, 4);
   constexpr std::array<std::uint8_t, 5> gdidArray = CRYPT_NAME("GDID", 0x3375B1C7DBB5FD55ULL);
   const std::uint8_t (&gdid)[5] = gdidArray._Elems;
   handler.AddField(DecryptName<0x3375B1C7DBB5FD55ULL>(gdid), guild, 4);
-  const std::uint8_t imgType[] = {0x98, 0x74, 0xFA, 0xDB, 0x12, 0xFB, 0x6A, 0x0F};
+  const std::uint8_t imgType[] = CRYPT_BYTES(8, "ImgType", 0x0F0F8B6B8F9D19D1ULL);
   handler.AddField(DecryptName<0x0F0F8B6B8F9D19D1ULL>(imgType), imageType, 4);
-  const std::uint8_t img[] = {0x24, 0x0E, 0x52, 0x2D};
+  const std::uint8_t img[] = CRYPT_BYTES(4, "Img", 0xD98F03A52D35636DULL);
   handler.AddField(DecryptName<0xD98F03A52D35636DULL>(img), path, 10);
 
   if (handler.Perform() == 0) {
     this->m_response = g_curlMgr->FromUtf8(handler.Response());
-    const std::uint8_t good[] = {0x0A, 0x8C, 0x2A, 0xC7, 0xED};
+    const std::uint8_t good[] = CRYPT_BYTES(5, "good", 0x31D7C1EDA345E36DULL);
     Report(this->m_diagnostic, true, DecryptName<0x31D7C1EDA345E36DULL>(good), 100);
   } else {
-    const std::uint8_t fail[] = {0x6F, 0xC8, 0x2E, 0x33, 0xD9};
+    const std::uint8_t fail[] = CRYPT_BYTES(5, "fail", 0xD3755DD95F47A909ULL);
     Report(this->m_diagnostic, false, DecryptName<0xD3755DD95F47A909ULL>(fail), 109);
   }
 
diff --git a/Source/Contents/Party/LoadPartyListAsyncWork.cpp b/Source/Contents/Party/LoadPartyListAsyncWork.cpp
index da0a229b7..7ebc29260 100644
--- a/Source/Contents/Party/LoadPartyListAsyncWork.cpp
+++ b/Source/Contents/Party/LoadPartyListAsyncWork.cpp
@@ -87,7 +87,7 @@ bool CLoadPartyListAsyncWork::Execute() {
   constexpr std::array<std::uint8_t, 10> worldNameArray = CRYPT_NAME("WorldName", 0x71B7691737C5A1AFULL);
   const std::uint8_t (&worldName)[10] = worldNameArray._Elems;
   handler.AddField(DecryptName<0x71B7691737C5A1AFULL>(worldName), world, 4);
-  const std::uint8_t authToken[] = {0x22, 0x4C, 0x09, 0xC9, 0x0D, 0xDA, 0xF4, 0xA6, 0x0D, 0x39};
+  const std::uint8_t authToken[] = CRYPT_BYTES(10, "AuthToken", 0xC39FB559A17D3963ULL);
   handler.AddField(DecryptName<0xC39FB559A17D3963ULL>(authToken), this->m_token, 4);
 
   switch (this->m_search) {
@@ -100,51 +100,51 @@ bool CLoadPartyListAsyncWork::Execute() {
   case 1: {
     char minimum[10] = {};
     StringFormat(minimum, sizeof(minimum), _TRUNCATE, "%d", this->m_filter.minimumLevel);
-    const std::uint8_t minLevel[] = {0x40, 0x32, 0x07, 0xCF, 0xED, 0x11};
+    const std::uint8_t minLevel[] = CRYPT_BYTES(6, "MinLV", 0x899D11BB83695B0DULL);
     handler.AddField(DecryptName<0x899D11BB83695B0DULL>(minLevel), minimum, 4);
     char maximum[10] = {};
     StringFormat(maximum, sizeof(maximum), _TRUNCATE, "%d", this->m_filter.maximumLevel);
-    const std::uint8_t maxLevel[] = {0x26, 0x6A, 0xDD, 0x89, 0xD1, 0xDD};
+    const std::uint8_t maxLevel[] = CRYPT_BYTES(6, "MaxLV", 0xBDADDD87C5A50B6BULL);
     handler.AddField(DecryptName<0xBDADDD87C5A50B6BULL>(maxLevel), maximum, 4);
 
     if (this->m_filter.tanker) {
-      const std::uint8_t tankerOn[] = {0x66, 0xEF};
-      const std::uint8_t tanker[] = {0xE9, 0xFC, 0x55, 0x8C, 0x68, 0xF1, 0x89};
+      const std::uint8_t tankerOn[] = CRYPT_BYTES(2, "1", 0x5FFD7FABB5D1EF57ULL);
+      const std::uint8_t tanker[] = CRYPT_BYTES(7, "Tanker", 0x7989830DE73B9DBDULL);
       handler.AddField(DecryptName<0x7989830DE73B9DBDULL>(tanker), DecryptName<0x5FFD7FABB5D1EF57ULL>(tankerOn), 4);
     }
 
     if (this->m_filter.dealer) {
-      const std::uint8_t dealerOn[] = {0xBC, 0x13};
-      const std::uint8_t dealer[] = {0x9B, 0xFE, 0x5E, 0x95, 0xE0, 0x6B, 0x47};
+      const std::uint8_t dealerOn[] = CRYPT_BYTES(2, "1", 0xF535E561137F138DULL);
+      const std::uint8_t dealer[] = CRYPT_BYTES(7, "Dealer", 0xA7471985F93F9BDFULL);
       handler.AddField(DecryptName<0xA7471985F93F9BDFULL>(dealer), DecryptName<0xF535E561137F138DULL>(dealerOn), 4);
     }
 
     if (this->m_filter.healer) {
-      const std::uint8_t healerOn[] = {0xEE, 0x5D};
-      const std::uint8_t healer[] = {0x99, 0x04, 0x90, 0xE5, 0x0A, 0x23, 0xE5};
+      const std::uint8_t healerOn[] = CRYPT_BYTES(2, "1", 0x01E7898D9D235DDFULL);
+      const std::uint8_t healer[] = CRYPT_BYTES(7, "Healer", 0xD3E5516F89F161D1ULL);
       handler.AddField(DecryptName<0xD3E5516F89F161D1ULL>(healer), DecryptName<0x01E7898D9D235DDFULL>(healerOn), 4);
     }
 
     if (this->m_filter.assist) {
-      const std::uint8_t assistOn[] = {0x40, 0x2F};
-      const std::uint8_t assist[] = {0x38, 0x98, 0x52, 0xF6, 0x4E, 0xC7, 0xF5};
+      const std::uint8_t assistOn[] = CRYPT_BYTES(2, "1", 0x9DEFC105A1EB2F71ULL);
+      const std::uint8_t assist[] = CRYPT_BYTES(7, "Assist", 0x0DF5B33D9F21EB79ULL);
       handler.AddField(DecryptName<0x0DF5B33D9F21EB79ULL>(assist), DecryptName<0x9DEFC105A1EB2F71ULL>(assistOn), 4);
     }
 
     if (this->m_filter.type != 0) {
       char type[10] = {};
       StringFormat(type, sizeof(type), _TRUNCATE, "%d", this->m_filter.type);
-      const std::uint8_t typeName[] = {0x57, 0xDA, 0xE9, 0x0C, 0x05};
+      const std::uint8_t typeName[] = CRYPT_BYTES(5, "Type", 0x6961FF056999A303ULL);
       handler.AddField(DecryptName<0x6961FF056999A303ULL>(typeName), type, 4);
     }
 
     if (!this->m_filter.memo.empty()) {
       std::string memo = CCURLMgr::GetInstance()->ToUtf8(this->m_filter.memo);
-      const std::uint8_t memoName[] = {0xB0, 0x34, 0xD8, 0x36, 0x01};
+      const std::uint8_t memoName[] = CRYPT_BYTES(5, "Memo", 0xBD3F430159B551FDULL);
       handler.AddField(DecryptName<0xBD3F430159B551FDULL>(memoName), memo, 4);
     }
 
-    const std::uint8_t pageName[] = {0x3B, 0xB2, 0x10, 0xE0, 0xF1};
+    const std::uint8_t pageName[] = CRYPT_BYTES(5, "page", 0xC7FB6DF18577D34BULL);
     handler.AddField(DecryptName<0xC7FB6DF18577D34BULL>(pageName), page, 4);
     break;
   }
@@ -152,7 +152,7 @@ bool CLoadPartyListAsyncWork::Execute() {
 
   if (handler.Perform() == 0) {
     this->m_response = CCURLMgr::GetInstance()->FromUtf8(handler.Response());
-    const std::uint8_t success[] = {0xE4, 0x04, 0xC4, 0xDE, 0x04, 0x50, 0xF0, 0x5B};
+    const std::uint8_t success[] = CRYPT_BYTES(8, "success", 0x5B832361BDA77197ULL);
     AsyncDiagnostic diagnostic = Diagnostic(true, DecryptName<0x5B832361BDA77197ULL>(success), 138);
     this->m_diagnostic.MoveFrom(diagnostic);
   }
diff --git a/Source/Contents/Skills/SkillActionDruid.cpp b/Source/Contents/Skills/SkillActionDruid.cpp
index 977a132fa..184c21d35 100644
--- a/Source/Contents/Skills/SkillActionDruid.cpp
+++ b/Source/Contents/Skills/SkillActionDruid.cpp
@@ -560,8 +560,7 @@ void CSkillAction_DR_FLICKING_TONADO::OnSkillEffect(int level, CGameActor* sourc
   thread_local EncryptedName<sizeof(effectSource), 0x2FF3C5036D070127ULL> effectName(effectSource);
   g_effectMgr->Spawn(target->render.accountId, CEZ2STREffectMgr::GetInstance()->EffectId(effectName.Text()), vector3d{0.0f, 0.0f, 0.0f}, 0, -1, 0, 0);
 
-  const std::uint8_t bottomSource[] = {0xD5, 0x0B, 0xAA, 0x30, 0x92, 0xF2, 0x5B, 0x70, 0xEC, 0x13, 0xAC, 0x3D, 0x98, 0xFF, 0x5A, 0x48,
-                                       0xD1, 0x08, 0xB7, 0x27, 0x96, 0xF6, 0x35};
+  const std::uint8_t bottomSource[] = CRYPT_BYTES(23, "flicking_tonado_bottom", 0x17359BF953C367B3ULL);
   thread_local EncryptedName<sizeof(bottomSource), 0x17359BF953C367B3ULL> bottomName(bottomSource);
   g_effectMgr->Spawn(target->render.accountId, CEZ2STREffectMgr::GetInstance()->EffectId(bottomName.Text()), vector3d{0.0f, 0.0f, 0.0f}, 0, -1, 0, 0);
 }
diff --git a/Source/Contents/UserData/AccountLinkedUserDataSaveAsyncWork.cpp b/Source/Contents/UserData/AccountLinkedUserDataSaveAsyncWork.cpp
index 08d8cf8b9..b0e9d9f88 100644
--- a/Source/Contents/UserData/AccountLinkedUserDataSaveAsyncWork.cpp
+++ b/Source/Contents/UserData/AccountLinkedUserDataSaveAsyncWork.cpp
@@ -82,9 +82,9 @@ bool CAccountLinkedUserDataSaveAsyncWork::Execute() {
   constexpr std::array<std::uint8_t, 10> tokenArray = CRYPT_NAME("AuthToken", 0x93E7A3A1F587CDC5ULL);
   const std::uint8_t (&token)[10] = tokenArray._Elems;
   handler.AddField(DecryptName<0x93E7A3A1F587CDC5ULL>(token), this->m_token, 4);
-  const std::uint8_t worldName[] = {0x70, 0x6E, 0x75, 0x01, 0x67, 0x8B, 0x92, 0x42, 0x42, 0x01};
+  const std::uint8_t worldName[] = CRYPT_BYTES(10, "WorldName", 0x2FF3C5036D070127ULL);
   handler.AddField(DecryptName<0x2FF3C5036D070127ULL>(worldName), name, 4);
-  const std::uint8_t data[] = {0xD7, 0x06, 0xB7, 0x32, 0xF9};
+  const std::uint8_t data[] = CRYPT_BYTES(5, "data", 0x17359BF953C367B3ULL);
   handler.AddField(DecryptName<0x17359BF953C367B3ULL>(data), this->m_data, 4);
 
   if (handler.Perform() != 0) {
@@ -92,7 +92,7 @@ bool CAccountLinkedUserDataSaveAsyncWork::Execute() {
     const std::uint8_t (&error)[5] = errorArray._Elems;
     Report(this->m_diagnostic, false, DecryptName<0x91651D81F559F971ULL>(error), 102);
   } else {
-    const std::uint8_t good[] = {0x6C, 0x14, 0xB0, 0x05, 0x4B};
+    const std::uint8_t good[] = CRYPT_BYTES(5, "good", 0x73D1674B61DF7B0BULL);
     Report(this->m_diagnostic, true, DecryptName<0x73D1674B61DF7B0BULL>(good), 106);
   }
 
diff --git a/Source/UI/Dialogs/UILocaleTextWnd.cpp b/Source/UI/Dialogs/UILocaleTextWnd.cpp
index 6d26f0b92..c170c0c59 100644
--- a/Source/UI/Dialogs/UILocaleTextWnd.cpp
+++ b/Source/UI/Dialogs/UILocaleTextWnd.cpp
@@ -39,9 +39,7 @@ void CUISubTab::OnCreate(int width, int height) {
   this->stampImage->Move(58, 0);
   {
     CUIStaticImage* stamp = this->stampImage;
-    const std::array<char, 54> stampSource = {'\x9D', '\x44', '\xB3', '\xB3', '\x5B', '\x87', '\xA4', '\xC2', '\x9B', '\x0F', '\xB3', '\x85', '\x26', '\xF3', '\x3D', '\x4E', '\x39', '\x9D',
-                                        '\x16', '\x27', '\xEF', '\x3C', '\x13', '\x6A', '\x1A', '\x9E', '\x1A', '\x2D', '\xFE', '\x15', '\x12', '\x7B', '\x3C', '\x86', '\x03', '\x16',
-                                        '\xF8', '\x26', '\x0C', '\x7F', '\x31', '\x8E', '\x07', '\x2C', '\xFF', '\x16', '\x12', '\x7A', '\x3F', '\xC5', '\x11', '\x24', '\xEB', '\x49'};
+    const std::array<char, 54> stampSource = CRYPT_CHARS(54, "유저인터페이스\\AdventureGuide\\stamp_completed_sub.bmp", 0x0F61499B4973EB5DULL);
     thread_local EncryptedName<sizeof(stampSource), 0x0F61499B4973EB5DULL> stampName(stampSource);
     stamp->SetImage(stampName.Text());
   }
@@ -103,7 +101,7 @@ void CUITabInfo::OnCreate(int width, int height) {
   this->descriptionText->SetAlign(0, 6);
   {
     CUIStaticText* text = this->descriptionText;
-    const std::uint8_t fontSource[] = {0x04, 0x5C, 0x3F, 0x4E, 0xB8, 0xBF};
+    const std::uint8_t fontSource[] = CRYPT_BYTES(6, "Gulim", 0x9949BFD527532943ULL);
     thread_local EncryptedName<sizeof(fontSource), 0x9949BFD527532943ULL> fontName(fontSource);
     text->SetFont(fontName.Text());
   }
diff --git a/Source/UI/Skill/UINewSkillListWnd.cpp b/Source/UI/Skill/UINewSkillListWnd.cpp
index fb8c533a1..5d06ee399 100644
--- a/Source/UI/Skill/UINewSkillListWnd.cpp
+++ b/Source/UI/Skill/UINewSkillListWnd.cpp
@@ -46,6 +46,7 @@
 #include "Resource/Sprites/SpriteResource.h"
 #include "Client/Mode/CMode.h"
 #include "Utility/Cipher/LocalEncryptedName.h"
+#include "Utility/Cipher/CryptName.h"
 
 #include "Resource/MSGSTRINGID.h"
 #include <cstdio>
@@ -472,10 +473,7 @@ std::list<CSkillInfo>& UINewSkillListWnd::SkillList(int tab, bool live) {
 // FUNCTION: fn_13810
 void UINewSkillListWnd::InitTabs() {
   const int initialTabCount = this->m_tabs->labels.size();
-  const std::uint8_t source[23] = {
-    0xEF, 0xF2, 0x0F, 0xAA, 0x08, 0x4E, 0x1B, 0x6F, 0xF1, 0xFC, 0x0F, 0xA6,
-    0x24, 0x42, 0x03, 0x57, 0xC4, 0xFF, 0x23, 0x98, 0x0E, 0x42, 0x77
-  };
+  const std::uint8_t source[] = CRYPT_BYTES(23, "JobSkillTab_GetTabName", 0x03772763F96D9DA5ULL);
   thread_local EncryptedName<sizeof(source), 0x03772763F96D9DA5ULL> funcName(source);
   const char* func = funcName.Text();
 
diff --git a/Source/Utility/Cipher/CryptName.h b/Source/Utility/Cipher/CryptName.h
index 43b1e9b74..534d0db05 100644
--- a/Source/Utility/Cipher/CryptName.h
+++ b/Source/Utility/Cipher/CryptName.h
@@ -113,4 +113,72 @@ namespace utility {
 #define CRYPT_CHARS_64_(text, key) CRYPT_CHARS_63_(text, key), CRYPT_CHAR_(text, key, 63)
 #define CRYPT_CHARS(length, text, key) {CRYPT_CHARS_##length##_(text, key)}
 
+#define CRYPT_BYTE_(text, key, index) \
+  ([]() consteval { return static_cast<std::uint8_t>(static_cast<unsigned char>((text)[index]) ^ static_cast<unsigned char>((key) >> (8 * ((index) & 7)))); }())
+#define CRYPT_BYTES_1_(text, key) CRYPT_BYTE_(text, key, 0)
+#define CRYPT_BYTES_2_(text, key) CRYPT_BYTES_1_(text, key), CRYPT_BYTE_(text, key, 1)
+#define CRYPT_BYTES_3_(text, key) CRYPT_BYTES_2_(text, key), CRYPT_BYTE_(text, key, 2)
+#define CRYPT_BYTES_4_(text, key) CRYPT_BYTES_3_(text, key), CRYPT_BYTE_(text, key, 3)
+#define CRYPT_BYTES_5_(text, key) CRYPT_BYTES_4_(text, key), CRYPT_BYTE_(text, key, 4)
+#define CRYPT_BYTES_6_(text, key) CRYPT_BYTES_5_(text, key), CRYPT_BYTE_(text, key, 5)
+#define CRYPT_BYTES_7_(text, key) CRYPT_BYTES_6_(text, key), CRYPT_BYTE_(text, key, 6)
+#define CRYPT_BYTES_8_(text, key) CRYPT_BYTES_7_(text, key), CRYPT_BYTE_(text, key, 7)
+#define CRYPT_BYTES_9_(text, key) CRYPT_BYTES_8_(text, key), CRYPT_BYTE_(text, key, 8)
+#define CRYPT_BYTES_10_(text, key) CRYPT_BYTES_9_(text, key), CRYPT_BYTE_(text, key, 9)
+#define CRYPT_BYTES_11_(text, key) CRYPT_BYTES_10_(text, key), CRYPT_BYTE_(text, key, 10)
+#define CRYPT_BYTES_12_(text, key) CRYPT_BYTES_11_(text, key), CRYPT_BYTE_(text, key, 11)
+#define CRYPT_BYTES_13_(text, key) CRYPT_BYTES_12_(text, key), CRYPT_BYTE_(text, key, 12)
+#define CRYPT_BYTES_14_(text, key) CRYPT_BYTES_13_(text, key), CRYPT_BYTE_(text, key, 13)
+#define CRYPT_BYTES_15_(text, key) CRYPT_BYTES_14_(text, key), CRYPT_BYTE_(text, key, 14)
+#define CRYPT_BYTES_16_(text, key) CRYPT_BYTES_15_(text, key), CRYPT_BYTE_(text, key, 15)
+#define CRYPT_BYTES_17_(text, key) CRYPT_BYTES_16_(text, key), CRYPT_BYTE_(text, key, 16)
+#define CRYPT_BYTES_18_(text, key) CRYPT_BYTES_17_(text, key), CRYPT_BYTE_(text, key, 17)
+#define CRYPT_BYTES_19_(text, key) CRYPT_BYTES_18_(text, key), CRYPT_BYTE_(text, key, 18)
+#define CRYPT_BYTES_20_(text, key) CRYPT_BYTES_19_(text, key), CRYPT_BYTE_(text, key, 19)
+#define CRYPT_BYTES_21_(text, key) CRYPT_BYTES_20_(text, key), CRYPT_BYTE_(text, key, 20)
+#define CRYPT_BYTES_22_(text, key) CRYPT_BYTES_21_(text, key), CRYPT_BYTE_(text, key, 21)
+#define CRYPT_BYTES_23_(text, key) CRYPT_BYTES_22_(text, key), CRYPT_BYTE_(text, key, 22)
+#define CRYPT_BYTES_24_(text, key) CRYPT_BYTES_23_(text, key), CRYPT_BYTE_(text, key, 23)
+#define CRYPT_BYTES_25_(text, key) CRYPT_BYTES_24_(text, key), CRYPT_BYTE_(text, key, 24)
+#define CRYPT_BYTES_26_(text, key) CRYPT_BYTES_25_(text, key), CRYPT_BYTE_(text, key, 25)
+#define CRYPT_BYTES_27_(text, key) CRYPT_BYTES_26_(text, key), CRYPT_BYTE_(text, key, 26)
+#define CRYPT_BYTES_28_(text, key) CRYPT_BYTES_27_(text, key), CRYPT_BYTE_(text, key, 27)
+#define CRYPT_BYTES_29_(text, key) CRYPT_BYTES_28_(text, key), CRYPT_BYTE_(text, key, 28)
+#define CRYPT_BYTES_30_(text, key) CRYPT_BYTES_29_(text, key), CRYPT_BYTE_(text, key, 29)
+#define CRYPT_BYTES_31_(text, key) CRYPT_BYTES_30_(text, key), CRYPT_BYTE_(text, key, 30)
+#define CRYPT_BYTES_32_(text, key) CRYPT_BYTES_31_(text, key), CRYPT_BYTE_(text, key, 31)
+#define CRYPT_BYTES_33_(text, key) CRYPT_BYTES_32_(text, key), CRYPT_BYTE_(text, key, 32)
+#define CRYPT_BYTES_34_(text, key) CRYPT_BYTES_33_(text, key), CRYPT_BYTE_(text, key, 33)
+#define CRYPT_BYTES_35_(text, key) CRYPT_BYTES_34_(text, key), CRYPT_BYTE_(text, key, 34)
+#define CRYPT_BYTES_36_(text, key) CRYPT_BYTES_35_(text, key), CRYPT_BYTE_(text, key, 35)
+#define CRYPT_BYTES_37_(text, key) CRYPT_BYTES_36_(text, key), CRYPT_BYTE_(text, key, 36)
+#define CRYPT_BYTES_38_(text, key) CRYPT_BYTES_37_(text, key), CRYPT_BYTE_(text, key, 37)
+#define CRYPT_BYTES_39_(text, key) CRYPT_BYTES_38_(text, key), CRYPT_BYTE_(text, key, 38)
+#define CRYPT_BYTES_40_(text, key) CRYPT_BYTES_39_(text, key), CRYPT_BYTE_(text, key, 39)
+#define CRYPT_BYTES_41_(text, key) CRYPT_BYTES_40_(text, key), CRYPT_BYTE_(text, key, 40)
+#define CRYPT_BYTES_42_(text, key) CRYPT_BYTES_41_(text, key), CRYPT_BYTE_(text, key, 41)
+#define CRYPT_BYTES_43_(text, key) CRYPT_BYTES_42_(text, key), CRYPT_BYTE_(text, key, 42)
+#define CRYPT_BYTES_44_(text, key) CRYPT_BYTES_43_(text, key), CRYPT_BYTE_(text, key, 43)
+#define CRYPT_BYTES_45_(text, key) CRYPT_BYTES_44_(text, key), CRYPT_BYTE_(text, key, 44)
+#define CRYPT_BYTES_46_(text, key) CRYPT_BYTES_45_(text, key), CRYPT_BYTE_(text, key, 45)
+#define CRYPT_BYTES_47_(text, key) CRYPT_BYTES_46_(text, key), CRYPT_BYTE_(text, key, 46)
+#define CRYPT_BYTES_48_(text, key) CRYPT_BYTES_47_(text, key), CRYPT_BYTE_(text, key, 47)
+#define CRYPT_BYTES_49_(text, key) CRYPT_BYTES_48_(text, key), CRYPT_BYTE_(text, key, 48)
+#define CRYPT_BYTES_50_(text, key) CRYPT_BYTES_49_(text, key), CRYPT_BYTE_(text, key, 49)
+#define CRYPT_BYTES_51_(text, key) CRYPT_BYTES_50_(text, key), CRYPT_BYTE_(text, key, 50)
+#define CRYPT_BYTES_52_(text, key) CRYPT_BYTES_51_(text, key), CRYPT_BYTE_(text, key, 51)
+#define CRYPT_BYTES_53_(text, key) CRYPT_BYTES_52_(text, key), CRYPT_BYTE_(text, key, 52)
+#define CRYPT_BYTES_54_(text, key) CRYPT_BYTES_53_(text, key), CRYPT_BYTE_(text, key, 53)
+#define CRYPT_BYTES_55_(text, key) CRYPT_BYTES_54_(text, key), CRYPT_BYTE_(text, key, 54)
+#define CRYPT_BYTES_56_(text, key) CRYPT_BYTES_55_(text, key), CRYPT_BYTE_(text, key, 55)
+#define CRYPT_BYTES_57_(text, key) CRYPT_BYTES_56_(text, key), CRYPT_BYTE_(text, key, 56)
+#define CRYPT_BYTES_58_(text, key) CRYPT_BYTES_57_(text, key), CRYPT_BYTE_(text, key, 57)
+#define CRYPT_BYTES_59_(text, key) CRYPT_BYTES_58_(text, key), CRYPT_BYTE_(text, key, 58)
+#define CRYPT_BYTES_60_(text, key) CRYPT_BYTES_59_(text, key), CRYPT_BYTE_(text, key, 59)
+#define CRYPT_BYTES_61_(text, key) CRYPT_BYTES_60_(text, key), CRYPT_BYTE_(text, key, 60)
+#define CRYPT_BYTES_62_(text, key) CRYPT_BYTES_61_(text, key), CRYPT_BYTE_(text, key, 61)
+#define CRYPT_BYTES_63_(text, key) CRYPT_BYTES_62_(text, key), CRYPT_BYTE_(text, key, 62)
+#define CRYPT_BYTES_64_(text, key) CRYPT_BYTES_63_(text, key), CRYPT_BYTE_(text, key, 63)
+#define CRYPT_BYTES(length, text, key) {CRYPT_BYTES_##length##_(text, key)}
+
 #endif