diff --git a/Source/Client/Mode/GameModeMiniMap.cpp b/Source/Client/Mode/GameModeMiniMap.cpp
index 3a0f2b64e..9ad6f4ab3 100644
--- a/Source/Client/Mode/GameModeMiniMap.cpp
+++ b/Source/Client/Mode/GameModeMiniMap.cpp
@@ -46,7 +46,7 @@ __forceinline const char* TimeFontActionName() {
 
 // INLINED
 __forceinline const char* TimeFontSpriteName() {
-  const char source[] = {'\x89', '\xA1', '\xB9', '\x32', '\x01', '\xAF', '\x15', '\x45', '\x20', '\x00', '\x1A', '\xA5', '\xA8', '\x6F', '\x3D', '\x3F', '\x3A', '\x1D', '\x0D', '\xE3'};
+  const char source[] = CRYPT_CHARS(20, "이팩트\\TimeFont.spr", 0x114901C7E37F6D49ULL);
   // GLOBAL: gl_25509
   thread_local EncryptedName<sizeof(source), 0x114901C7E37F6D49ULL> name(source);
   return name.Text();
diff --git a/Source/Client/Stove/StoveMgr.cpp b/Source/Client/Stove/StoveMgr.cpp
index 88ec8c3d1..e3620f5e8 100644
--- a/Source/Client/Stove/StoveMgr.cpp
+++ b/Source/Client/Stove/StoveMgr.cpp
@@ -361,7 +361,7 @@ void CategoryProductsCallback::operator()(Stove::PCSDK::CallbackResult callbackR
         } else if (std::strcmp(categoryId.c_str(), "44C71118750747D") == 0) {
           list = 8;
         } else {
-          const char captionSource[] = {'\xAF', '\x27', '\xF2', '\x7A', '\x3A', '\x43', '\x2F'};
+          const char captionSource[] = CRYPT_CHARS(7, "메시지", 0xC52FB5FBB94FF917ULL);
           const char* caption = DecryptName<0xC52FB5FBB94FF917ULL>(captionSource);
           constexpr std::array<char, 34> messageSource = CRYPT_NAME("등록되지 않은 카테고리입니다 (%s)", 0x17359BF953C367B3ULL);
           const char* message = DecryptName<0x17359BF953C367B3ULL>(messageSource);
@@ -431,7 +431,7 @@ void CategoryProductsCallback::operator()(Stove::PCSDK::CallbackResult callbackR
       }
     }
   } else {
-    const char captionSource[] = {'\x89', '\x87', '\x96', '\xC2', '\xA0', '\x3B', '\x65'};
+    const char captionSource[] = CRYPT_CHARS(7, "메시지", 0x8B65CD61012B5931ULL);
     const char* caption = DecryptName<0x8B65CD61012B5931ULL>(captionSource);
     constexpr std::array<char, 56> messageSource = CRYPT_NAME("장애가 발생 하였습니다. STOVE 고객센터로 문의 바랍니다.", 0xF5657D1F3DE5CDC7ULL);
     const char* message = DecryptName<0xF5657D1F3DE5CDC7ULL>(messageSource);
@@ -471,9 +471,9 @@ EncryptedName<100, 0x4F1791FB1503C713ULL>& TokenCallbackFailureMessage::operator
 void InitializeCallback::operator()(Stove::PCSDK::CallbackResult callbackResult) const {
   g_stoveWaitingCallback = false;
   if (!callbackResult.GetResult().IsSuccessful()) {
-    const char captionSource[] = {'\xD5', '\x3D', '\xF8', '\x60', '\x2C', '\x37', '\xD7'};
+    const char captionSource[] = CRYPT_CHARS(7, "메시지", 0x31D7C1EDA345E36DULL);
     const char* caption = DecryptName<0x31D7C1EDA345E36DULL>(captionSource);
-    const char messageSource[] = {'\xCE', '\x63', '\xFB', '\xA9', '\xF9', '\xE6', '\x92', '\x13', '\xF5', '\x89', '\x87', '\x84', '\x67', '\xAA', '\xB5', '\x1F', '\x29', '\x14', '\x80', '\x99', '\x09', '\x9A', '\xBA', '\x6C', '\xA0', '\x89', '\xF7', '\x8B', '\x19', '\x8E', '\xB5', '\x68', '\x29', '\x68', '\xF9', '\xE8', '\x38', '\x9A', '\xA0', '\x67', '\xC6', '\x1D', '\x9E', '\x71', '\xD9'};
+    const char messageSource[] = CRYPT_CHARS(45, "필수 사전 작업이 실패하여 게임을 종료합니다.", 0xD3755DD95F47A909ULL);
     const char* message = DecryptName<0xD3755DD95F47A909ULL>(messageSource);
     MessageBoxA(hWnd, FormatOwnedString(message).c_str(), caption, MB_OK);
     PostQuitMessage(0);
diff --git a/Source/Contents/Effects/Core/EffectLists.cpp b/Source/Contents/Effects/Core/EffectLists.cpp
index 742f1e992..70058c065 100644
--- a/Source/Contents/Effects/Core/EffectLists.cpp
+++ b/Source/Contents/Effects/Core/EffectLists.cpp
@@ -547,11 +547,7 @@ CEffect* CEffectAllocator<CThunderingOrb>::Create() {
 
 // INLINED
 EncryptedName<0x3B, 0x39FF7FB50DEB998FULL>& WindBombName() {
-  const char source[] = {
-      '\xCB', '\xCB', '\xBE', '\x44', '\xF1', '\x23', '\xBB', '\x6B', '\xD0', '\xCE', '\xA2', '\x43', '\xF1', '\x20', '\xBD', '\x76',
-      '\xC2', '\xDB', '\xB7', '\x7A', '\xDC', '\x11', '\x9B', '\x66', '\xED', '\xF6', '\x86', '\x6F', '\xEA', '\x0B', '\x90', '\x4B',
-      '\xE1', '\xF8', '\x8F', '\x62', '\xE9', '\x08', '\x96', '\x57', '\xEB', '\xC6', '\x89', '\x62', '\xD8', '\x1D', '\xA0', '\x4D',
-      '\xE0', '\xEB', '\x85', '\x6C', '\xD1', '\x10', '\xD1', '\x4A', '\xFB', '\xEB', '\xEB'};
+  const char source[] = CRYPT_CHARS(59, "DRUID\\DR_WIND_BOMB\\wind_bomb_tornado\\wind_bomb_tornado.str", 0x39FF7FB50DEB998FULL);
   thread_local EncryptedName<sizeof(source), 0x39FF7FB50DEB998FULL> name(source);
   return name;
 }
diff --git a/Source/Contents/Emblems/EmblemDataUploadAsyncWork.cpp b/Source/Contents/Emblems/EmblemDataUploadAsyncWork.cpp
index 3312ab953..3991b1403 100644
--- a/Source/Contents/Emblems/EmblemDataUploadAsyncWork.cpp
+++ b/Source/Contents/Emblems/EmblemDataUploadAsyncWork.cpp
@@ -87,7 +87,8 @@ bool CEmblemDataUploadAsyncWork::Execute() {
   handler.AddField(DecryptName<0x59278F63D79F3DA1ULL>(authToken), this->m_token, 4);
   const std::uint8_t worldName[] = {0x48, 0x5E, 0xBF, 0x8B, 0x89, 0x3B, 0x0C, 0x70, 0x7A, 0x31};
   handler.AddField(DecryptName<0x1D6D75EDE7CD311FULL>(worldName), name, 4);
-  const std::uint8_t gdid[] = {0x12, 0xB9, 0xFC, 0x9F, 0xC7};
+  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};
   handler.AddField(DecryptName<0x0F0F8B6B8F9D19D1ULL>(imgType), imageType, 4);
diff --git a/Source/Contents/Party/LoadPartyListAsyncWork.cpp b/Source/Contents/Party/LoadPartyListAsyncWork.cpp
index 85cd81b96..da0a229b7 100644
--- a/Source/Contents/Party/LoadPartyListAsyncWork.cpp
+++ b/Source/Contents/Party/LoadPartyListAsyncWork.cpp
@@ -92,7 +92,8 @@ bool CLoadPartyListAsyncWork::Execute() {
 
   switch (this->m_search) {
   case 0: {
-    const std::uint8_t pageName[] = {0x85, 0x44, 0x34, 0x8C, 0xD7};
+    constexpr std::array<std::uint8_t, 5> pageNameArray = CRYPT_NAME("page", 0x2B8725D7E95325F5ULL);
+    const std::uint8_t (&pageName)[5] = pageNameArray._Elems;
     handler.AddField(DecryptName<0x2B8725D7E95325F5ULL>(pageName), page, 4);
     break;
   }
diff --git a/Source/Contents/Skills/SkillActionAlitea.cpp b/Source/Contents/Skills/SkillActionAlitea.cpp
index 48f7aa5ae..7744b2682 100644
--- a/Source/Contents/Skills/SkillActionAlitea.cpp
+++ b/Source/Contents/Skills/SkillActionAlitea.cpp
@@ -1095,8 +1095,7 @@ void CSkillObjectAction_AT_GLACIER_MONOLITH::OnSkillObjectRemove(CRenderObject*
   }()));
   effects = g_effectMgr;
   effects->Retire(object->render.accountId, CEZ2STREffectMgr::GetInstance()->EffectId([] {
-    const char bytes[] = {'\xBA', '\xB9', '\x28', '\x22', '\x1E', '\x70', '\x49', '\x72', '\xB0', '\xBA', '\x27', '\x2E', '\x1B', '\x7C', '\x4F', '\x45',
-                                  '\x82', '\xB9', '\x26', '\x2E', '\x07', '\x4A', '\x59', '\x42', '\xA9', '\xA1', '\x26', '\x2C', '\x77'};
+    const char bytes[] = CRYPT_CHARS(29, "glacier_monolith_loop_bottom", 0x2D3B15774149D5DDULL);
     thread_local EncryptedName<sizeof(bytes), 0x2D3B15774149D5DDULL> name(bytes);
     return name.Text();
   }()));
@@ -1246,8 +1245,8 @@ void CSkillAction_AT_ROARING_PIERCER::OnSkillEffect(int level, CGameActor* sourc
   }
 
   const int effectId = CEZ2STREffectMgr::GetInstance()->EffectId([] {
-    const std::uint8_t bytes[] = {0xBB, 0xD8, 0x44, 0xE5, 0xD2, 0x5D, 0xE4, 0x58, 0xB9, 0xDE, 0x40, 0xE5, 0xD8, 0x56, 0xF1, 0x58,
-                                  0xAE, 0xB7};
+    constexpr std::array<std::uint8_t, 18> bytesArray = CRYPT_NAME("roaring_piercer_g", 0x078333BB9725B7C9ULL);
+    const std::uint8_t (&bytes)[18] = bytesArray._Elems;
     thread_local EncryptedName<sizeof(bytes), 0x078333BB9725B7C9ULL> name(bytes);
     return name.Text();
   }());
@@ -1271,8 +1270,8 @@ void CSkillAction_AT_ROARING_PIERCEER_S::OnSkillEffect(int level, CGameActor* so
   }
 
   const int effectId = CEZ2STREffectMgr::GetInstance()->EffectId([] {
-    const std::uint8_t bytes[] = {0xC7, 0x1A, 0x00, 0x2D, 0x94, 0x35, 0x7C, 0xD0, 0xC5, 0x1C, 0x04, 0x2D, 0x9E, 0x3E, 0x69, 0xD0,
-                                  0xCC, 0x75};
+    constexpr std::array<std::uint8_t, 18> bytesArray = CRYPT_NAME("roaring_piercer_y", 0x8F1B5BFD5F6175B5ULL);
+    const std::uint8_t (&bytes)[18] = bytesArray._Elems;
     thread_local EncryptedName<sizeof(bytes), 0x8F1B5BFD5F6175B5ULL> name(bytes);
     return name.Text();
   }());
@@ -1509,20 +1508,19 @@ void CSkillAction_AT_AERO_SYNC::OnSkillEffect(int level, CGameActor* source, CGa
   if (source) {
     EffectLists* effects = g_effectMgr;
     effects->Spawn(source->render.accountId, CEZ2STREffectMgr::GetInstance()->EffectId([] {
-      const char bytes[] = {'\xBE', '\xBC', '\x2F', '\x06', '\x4C', '\xE0', '\x86', '\x6F', '\xBC', '\x86', '\x2E', '\x10', '\x7D', '\xF0', '\xFF'};
+      const char bytes[] = CRYPT_CHARS(15, "aero_sync_sync", 0x01FF9313695DD9DFULL);
       thread_local EncryptedName<sizeof(bytes), 0x01FF9313695DD9DFULL> name(bytes);
       return name.Text();
     }()), vector3d{0.0f, 0.0f, 0.0f}, 0, -1, 0, 0);
     effects = g_effectMgr;
     effects->Spawn(0, CEZ2STREffectMgr::GetInstance()->EffectId([] {
-      const char bytes[] = {'\xFA', '\xC8', '\x07', '\xA0', '\x8E', '\x4E', '\x94', '\x03', '\xF8', '\xF2', '\x18', '\xAE', '\xB8', '\x53', '\xED'};
+      const char bytes[] = CRYPT_CHARS(15, "aero_sync_main", 0x6DED3DD1CF75AD9BULL);
       thread_local EncryptedName<sizeof(bytes), 0x6DED3DD1CF75AD9BULL> name(bytes);
       return name.Text();
     }()), source->render.position, 0, -1, 0, 0);
     effects = g_effectMgr;
     effects->Spawn(0, CEZ2STREffectMgr::GetInstance()->EffectId([] {
-      const char bytes[] = {'\xA0', '\xB6', '\xA9', '\x18', '\xC4', '\x06', '\xBA', '\x27', '\xA2', '\x8C', '\xB6', '\x16', '\xF2', '\x1B', '\x9C', '\x2B',
-                                    '\xAE', '\xA7', '\xAF', '\x18', '\xF6', '\x75'};
+      const char bytes[] = CRYPT_CHARS(22, "aero_sync_main_bottom", 0x49C3759B77DBD3C1ULL);
       thread_local EncryptedName<sizeof(bytes), 0x49C3759B77DBD3C1ULL> name(bytes);
       return name.Text();
     }()), source->render.position, 0, -1, 0, 0);
@@ -1846,14 +1844,13 @@ void CSkillAction_AT_SAVAGE_LUNGE::OnSkillEffect(int level, CGameActor* source,
   }
   EffectLists* effects = g_effectMgr;
   effects->Spawn(0, CEZ2STREffectMgr::GetInstance()->EffectId([] {
-    const char bytes[] = {'\x9A', '\xB2', '\x4B', '\x66', '\x52', '\x4C', '\x54', '\x89', '\x9C', '\xBD', '\x5A', '\x62', '\x35'};
+    const char bytes[] = CRYPT_CHARS(13, "savage_lunge", 0xE50B2935073DD3E9ULL);
     thread_local EncryptedName<sizeof(bytes), 0xE50B2935073DD3E9ULL> name(bytes);
     return name.Text();
   }()), target->render.position, 0, -1, 0, 0);
   effects = g_effectMgr;
   effects->Spawn(0, CEZ2STREffectMgr::GetInstance()->EffectId([] {
-    const char bytes[] = {'\x82', '\xA2', '\x9F', '\xDC', '\xCA', '\x68', '\x2A', '\x11', '\x84', '\xAD', '\x8E', '\xD8', '\xF2', '\x6F', '\x1A', '\x09',
-                                  '\x85', '\xAC', '\x84', '\xBD'};
+    const char bytes[] = CRYPT_CHARS(20, "savage_lunge_bottom", 0x7D750DADBDE9C3F1ULL);
     thread_local EncryptedName<sizeof(bytes), 0x7D750DADBDE9C3F1ULL> name(bytes);
     return name.Text();
   }()), target->render.position, 0, -1, 0, 0);
diff --git a/Source/Contents/Skills/SkillActionDruid.cpp b/Source/Contents/Skills/SkillActionDruid.cpp
index f0ea21acb..977a132fa 100644
--- a/Source/Contents/Skills/SkillActionDruid.cpp
+++ b/Source/Contents/Skills/SkillActionDruid.cpp
@@ -1077,7 +1077,7 @@ void CSkillAction_DR_AROUND_FLOWER::OnSkillEffect(int level, CGameActor* source,
   EffectLists* effects = g_effectMgr;
   effects->Spawn(source->render.accountId, CEZ2STREffectMgr::GetInstance()->EffectId(effectName.Text()), 0.0f, 0.0f, 0.0f, 0, -1, 0, 0);
 
-  const char bottomSource[] = {'\xA0', '\xA1', '\xB4', '\x02', '\xF5', '\x11', '\x9C', '\x2F', '\xAD', '\xBC', '\xAC', '\x12', '\xE9', '\x2A', '\xA1', '\x26', '\xB5', '\xA7', '\xB4', '\x1A', '\x9B'};
+  const char bottomSource[] = CRYPT_CHARS(21, "around_flower_bottom", 0x49C3759B77DBD3C1ULL);
   thread_local EncryptedName<sizeof(bottomSource), 0x49C3759B77DBD3C1ULL> bottomName(bottomSource);
   effects = g_effectMgr;
   effects->Spawn(source->render.accountId, CEZ2STREffectMgr::GetInstance()->EffectId(bottomName.Text()), 0.0f, 0.0f, 0.0f, 0, -1, 0, 0);
@@ -1262,7 +1262,8 @@ void CSkillAction_DR_SHOOTING_FEATHER::OnSkillEffect(int level, CGameActor* sour
 
   EffectLists* effects = g_effectMgr;
   if (CEffect* effect = effects->Spawn(source->render.accountId, CEZ2STREffectMgr::GetInstance()->EffectId([] {
-    const std::uint8_t bytes[] = {0xB6, 0xA5, 0xE8, 0x9A, 0xD5, 0xCA, 0x89, 0xF4, 0x9A, 0xAB, 0xE2, 0x94, 0xD5, 0xCB, 0x82, 0xE1, 0xC5};
+    constexpr std::array<std::uint8_t, 17> bytesArray = CRYPT_NAME("shooting_feather", 0x93E7A3A1F587CDC5ULL);
+    const std::uint8_t (&bytes)[17] = bytesArray._Elems;
     thread_local EncryptedName<sizeof(bytes), 0x93E7A3A1F587CDC5ULL> name(bytes);
     return name.Text();
   }()), 0.0f, 0.0f, 0.0f, 0, -1, 0, 0)) {
diff --git a/Source/Contents/Skills/SkillActionKarnos.cpp b/Source/Contents/Skills/SkillActionKarnos.cpp
index bf7ec6270..6dd8c99ab 100644
--- a/Source/Contents/Skills/SkillActionKarnos.cpp
+++ b/Source/Contents/Skills/SkillActionKarnos.cpp
@@ -319,7 +319,7 @@ void CSkillAction_KR_EARTH_STAMP::OnGroundSkillEffect(vector3d position, int arg
   thread_local EncryptedName<sizeof(effectSource), 0x3FAF85D995034FD7ULL> effectName(effectSource.data);
   g_effectMgr->Spawn(0, CEZ2STREffectMgr::GetInstance()->EffectId(effectName.Text()), position, 0, -1, 0, 0);
 
-  const char bottomSource[] = {'\xDC', '\x6C', '\x5D', '\xD5', '\x2B', '\xA4', '\x7C', '\x3D', '\xD8', '\x60', '\x5F', '\xFE', '\x21', '\x94', '\x7B', '\x3D', '\xD6', '\x60', '\x2F'};
+  const char bottomSource[] = CRYPT_CHARS(19, "earth_stamp_bottom", 0x490FFB43A12F0DB9ULL);
   thread_local EncryptedName<sizeof(bottomSource), 0x490FFB43A12F0DB9ULL> bottomName(bottomSource);
   g_effectMgr->Spawn(0, CEZ2STREffectMgr::GetInstance()->EffectId(bottomName.Text()), position, 0, -1, 0, 0);
 }
@@ -556,25 +556,24 @@ void CSkillObjectAction_KR_ICE_PILLAR::OnSkillObjectCreate(int argument, CRender
 
   EffectLists* effects = g_effectMgr;
   effects->Spawn(object->render.accountId, CEZ2STREffectMgr::GetInstance()->EffectId([] {
-    const char bytes[] = {'\x8C', '\xEC', '\x28', '\x4A', '\x47', '\x68', '\x3F', '\x9B', '\x84', '\xFD', '\x12', '\x66', '\x43', '\x60', '\x21', '\x83', '\xE5'};
+    const char bytes[] = CRYPT_CHARS(17, "ice_pillar_start", 0xF7530137154D8FE5ULL);
     thread_local EncryptedName<sizeof(bytes), 0xF7530137154D8FE5ULL> name(bytes);
     return name.Text();
   }()), vector3d{0.0f, 0.0f, 0.0f}, 0, -1, 0, 0);
   effects = g_effectMgr;
   effects->Spawn(object->render.accountId, CEZ2STREffectMgr::GetInstance()->EffectId([] {
-    const char bytes[] = {'\xAA', '\xA0', '\xB0', '\xD4', '\x2B', '\x82', '\x53', '\xE7', '\xA2', '\xB1', '\x8A', '\xF8', '\x2F', '\x8A', '\x4D', '\xFF',
-                                  '\x9C', '\xA1', '\xBA', '\xFF', '\x2F', '\x84', '\x52', '\x8B'};
+    const char bytes[] = CRYPT_CHARS(24, "ice_pillar_start_bottom", 0x8B3FEB5B8BD5C3C3ULL);
     thread_local EncryptedName<sizeof(bytes), 0x8B3FEB5B8BD5C3C3ULL> name(bytes);
     return name.Text();
   }()), vector3d{0.0f, 0.0f, 0.0f}, 0, -1, 0, 0);
 
   if (CEffect* effect = g_effectMgr->Spawn(object->render.accountId, 2472, vector3d{0.0f, 0.0f, 0.0f}, 0, -1, 0, 0)) {
     static_cast<EffectResourceSwitcher*>(effect)->SetNames([] {
-      const char bytes[] = {'\xCE', '\xD0', '\x60', '\x96', '\xD5', '\x0A', '\x87', '\x67', '\xC6', '\xC1', '\x5A', '\xA5', '\xCA', '\x0C', '\x9B', '\x0B'};
+      const char bytes[] = CRYPT_CHARS(16, "ice_pillar_loop", 0x0BEB63A5C905B3A7ULL);
       thread_local EncryptedName<sizeof(bytes), 0x0BEB63A5C905B3A7ULL> name(bytes);
       return name.Text();
     }(), [] {
-      const char bytes[] = {'\xA0', '\xD4', '\x40', '\xC8', '\xCB', '\x5A', '\xEF', '\x6B', '\xA8', '\xC5', '\x7A', '\xF2', '\xD5', '\x57', '\x83'};
+      const char bytes[] = CRYPT_CHARS(15, "ice_pillar_end", 0x078333BB9725B7C9ULL);
       thread_local EncryptedName<sizeof(bytes), 0x078333BB9725B7C9ULL> name(bytes);
       return name.Text();
     }());
@@ -582,13 +581,11 @@ void CSkillObjectAction_KR_ICE_PILLAR::OnSkillObjectCreate(int argument, CRender
   }
   if (CEffect* effect = g_effectMgr->Spawn(object->render.accountId, 2473, vector3d{0.0f, 0.0f, 0.0f}, 0, -1, 0, 0)) {
     static_cast<EffectResourceSwitcher*>(effect)->SetNames([] {
-      const char bytes[] = {'\xDC', '\x16', '\x04', '\x00', '\x8D', '\x32', '\x77', '\xE3', '\xD4', '\x07', '\x3E', '\x33', '\x92', '\x34', '\x6B', '\xD0',
-                                    '\xD7', '\x1A', '\x15', '\x2B', '\x92', '\x36', '\x1B'};
+      const char bytes[] = CRYPT_CHARS(23, "ice_pillar_loop_bottom", 0x8F1B5BFD5F6175B5ULL);
       thread_local EncryptedName<sizeof(bytes), 0x8F1B5BFD5F6175B5ULL> name(bytes);
       return name.Text();
     }(), [] {
-      const char bytes[] = {'\x72', '\x6E', '\x5C', '\x56', '\xDF', '\x20', '\xE3', '\x37', '\x7A', '\x7F', '\x66', '\x6C', '\xC1', '\x2D', '\xD0', '\x39',
-                                    '\x74', '\x79', '\x4D', '\x66', '\xC2', '\x49'};
+      const char bytes[] = CRYPT_CHARS(22, "ice_pillar_end_bottom", 0x5B8F49AF09390D1BULL);
       thread_local EncryptedName<sizeof(bytes), 0x5B8F49AF09390D1BULL> name(bytes);
       return name.Text();
     }());
@@ -697,13 +694,14 @@ void CSkillAction_KR_SHARPEN_HAIL::OnSkillEffect(int level, CGameActor* source,
   }
 
   const int shotEffect = CEZ2STREffectMgr::GetInstance()->EffectId([] {
-    const std::uint8_t encrypted[] = {0x3E, 0xB9, 0xAA, 0xB5, 0x89, 0x12, 0xA3, 0x20, 0x25, 0xB0, 0xA2, 0xAB, 0xA6, 0x04, 0xA5, 0x10, 0x39, 0xD1};
+    constexpr std::array<std::uint8_t, 18> encryptedArray = CRYPT_NAME("sharpen_hail_shot", 0x7FCD77F9C7CBD14DULL);
+    const std::uint8_t (&encrypted)[18] = encryptedArray._Elems;
     thread_local EncryptedName<sizeof(encrypted), 0x7FCD77F9C7CBD14DULL> name(encrypted);
     return name.Text();
   }());
   const int bottomEffect = CEZ2STREffectMgr::GetInstance()->EffectId([] {
-    const std::uint8_t encrypted[] = {0x72, 0x3F, 0xF6, 0xAD, 0x63, 0xE0, 0x3D, 0x8E, 0x69, 0x36, 0xFE, 0xB3, 0x4C,
-                                      0xF6, 0x3B, 0xBE, 0x75, 0x08, 0xF5, 0xB0, 0x67, 0xF1, 0x3C, 0xBC, 0x01};
+    constexpr std::array<std::uint8_t, 25> encryptedArray = CRYPT_NAME("sharpen_hail_shot_bottom", 0xD1538513DF975701ULL);
+    const std::uint8_t (&encrypted)[25] = encryptedArray._Elems;
     thread_local EncryptedName<sizeof(encrypted), 0xD1538513DF975701ULL> name(encrypted);
     return name.Text();
   }());
@@ -953,7 +951,8 @@ void CEfstAction_CHOP_CHOP::OnEfstEnd(int efstId, int argument2, int argument3,
   for (;;) {
     EffectLists* effects = g_effectMgr;
     CEffect* effect = effects->Find(actor->render.accountId, CEZ2STREffectMgr::GetInstance()->EffectId([] {
-      const std::uint8_t source[] = {0xDC, 0xD5, 0xB0, 0x4F, 0x12, 0x4E, 0xEB, 0x5C, 0xCF, 0xE2, 0xAC, 0x4A, 0x2F, 0x2D};
+      constexpr std::array<std::uint8_t, 14> sourceArray = CRYPT_NAME("chop_chop_sub", 0x33832D4D3FDFBDBFULL);
+      const std::uint8_t (&source)[14] = sourceArray._Elems;
       thread_local EncryptedName<sizeof(source), 0x33832D4D3FDFBDBFULL> name(source);
       return name.Text();
     }()));
@@ -1020,7 +1019,8 @@ void CSkillAction_KR_NASTY_SLASH::OnSkillEffect(int level, CGameActor* source, C
   }
 
   const float angle = ScreenAngle(&source->render.position.x, &target->render.position.x, static_cast<CGameMode*>(g_modeMgr.GetGameMode())->camera->frame.view.values);
-  const std::uint8_t effectSource[] = {0x49, 0x60, 0x74, 0x19, 0x7A, 0x9A, 0x80, 0x43, 0x46, 0x72, 0x6F, 0x6D};
+  constexpr std::array<std::uint8_t, 12> effectSourceArray = CRYPT_NAME("nasty_slash", 0x2FF3C5036D070127ULL);
+  const std::uint8_t (&effectSource)[12] = effectSourceArray._Elems;
   thread_local EncryptedName<sizeof(effectSource), 0x2FF3C5036D070127ULL> effectName(effectSource);
   if (CEffect* effect = g_effectMgr->Spawn(target->render.accountId, CEZ2STREffectMgr::GetInstance()->EffectId(effectName.Text()), vector3d{0.0f, 0.0f, 0.0f}, 0, -1, 0, 0)) {
     effect->SetAngle(angle);
@@ -1037,14 +1037,16 @@ void CSkillAction_KR_FEATHER_SPRINKLE::OnSkillEffect(int level, CGameActor* sour
 
   EffectLists* effects = g_effectMgr;
   effects->Spawn(source->render.accountId, CEZ2STREffectMgr::GetInstance()->EffectId([] {
-    const std::uint8_t effectSource[] = {0x89, 0x46, 0xB4, 0x9B, 0x71, 0x34, 0xE3, 0x64, 0x9C, 0x53, 0xA7, 0x86, 0x77, 0x3A, 0xFD, 0x5E, 0xEF};
+    constexpr std::array<std::uint8_t, 17> effectSourceArray = CRYPT_NAME("feather_sprinkle", 0x3B915119EFD523EFULL);
+    const std::uint8_t (&effectSource)[17] = effectSourceArray._Elems;
     thread_local EncryptedName<sizeof(effectSource), 0x3B915119EFD523EFULL> effectName(effectSource);
     return effectName.Text();
   }()), vector3d{0.0f, 0.0f, 0.0f}, 0, -1, 0, 0);
 
   effects = g_effectMgr;
   effects->Spawn(source->render.accountId, CEZ2STREffectMgr::GetInstance()->EffectId([] {
-    const std::uint8_t bottomSource[] = {0x31, 0xE6, 0x88, 0xA1, 0xE9, 0xA0, 0x3F, 0x18, 0x24, 0xF3, 0x9B, 0xBC, 0xEF, 0xAE, 0x21, 0x22, 0x08, 0xE1, 0x86, 0xA1, 0xF5, 0xAA, 0x20, 0x47};
+    constexpr std::array<std::uint8_t, 24> bottomSourceArray = CRYPT_NAME("feather_sprinkle_bottom", 0x474DC581D5E98357ULL);
+    const std::uint8_t (&bottomSource)[24] = bottomSourceArray._Elems;
     thread_local EncryptedName<sizeof(bottomSource), 0x474DC581D5E98357ULL> bottomName(bottomSource);
     return bottomName.Text();
   }()), vector3d{0.0f, 0.0f, 0.0f}, 0, -1, 0, 0);
@@ -1088,7 +1090,8 @@ void CSkillAction_KR_IRON_HOWLING::OnSkillEffect(int level, CGameActor* source,
     return;
   }
 
-  const std::uint8_t effectSource[] = {0xF6, 0xB1, 0x28, 0xD3, 0xB4, 0x2F, 0x8E, 0xE6, 0xF3, 0xAA, 0x29, 0xDA, 0xEB};
+  constexpr std::array<std::uint8_t, 13> effectSourceArray = CRYPT_NAME("iron_howling", 0x91E147EBBD47C39FULL);
+  const std::uint8_t (&effectSource)[13] = effectSourceArray._Elems;
   thread_local EncryptedName<sizeof(effectSource), 0x91E147EBBD47C39FULL> effectName(effectSource);
   g_effectMgr->Spawn(source->render.accountId, CEZ2STREffectMgr::GetInstance()->EffectId(effectName.Text()), vector3d{0.0f, 0.0f, 0.0f}, 0, -1, 0, 0);
 }
@@ -1104,7 +1107,8 @@ void CSkillAction_SKID_KR_CHOP_CHOP::OnSkillEffect(int level, CGameActor* source
     effect->effectLifetime = 1;
   }
 
-  const std::uint8_t effectSource[] = {0x92, 0xAB, 0x86, 0xCD, 0xF2, 0x6E, 0x1D, 0x12, 0x81, 0x9C, 0x9A, 0xC8, 0xCF, 0x0D};
+  constexpr std::array<std::uint8_t, 14> effectSourceArray = CRYPT_NAME("chop_chop_sub", 0x7D750DADBDE9C3F1ULL);
+  const std::uint8_t (&effectSource)[14] = effectSourceArray._Elems;
   thread_local EncryptedName<sizeof(effectSource), 0x7D750DADBDE9C3F1ULL> effectName(effectSource);
   EffectLists* effects = g_effectMgr;
   if (CEffect* effect = effects->Spawn(source->render.accountId, CEZ2STREffectMgr::GetInstance()->EffectId(effectName.Text()), 0.0f, 0.0f, 0.0f, 0, -1, 0, 0)) {
diff --git a/Source/Contents/Time/ClientTiming.cpp b/Source/Contents/Time/ClientTiming.cpp
index e948cba6e..bc4fc84c0 100644
--- a/Source/Contents/Time/ClientTiming.cpp
+++ b/Source/Contents/Time/ClientTiming.cpp
@@ -717,15 +717,15 @@ void CSession::LoadRobeAlpha() {
     int period = 0;
     LuaScript* script = this->m_hotkeyScript;
 
-    const char signatureSource[] = {'\x15', '\x45', '\xC9', '\x0F', '\x21', '\x81', '\x73'};
+    const char signatureSource[] = CRYPT_CHARS(7, "d>dddd", 0x6373E5456BAD7B71ULL);
     const auto functionSource = CRYPT_NAME("querytransparentiteminfo", 0xD51953E763B94747ULL);
 
     if (!script->Call(DecryptName<0xD51953E763B94747ULL>(functionSource.data), DecryptName<0x6373E5456BAD7B71ULL>(signatureSource), index, &robeId, &from, &to, &period)) {
       char message[260];
       std::memset(message, 0, sizeof(message));
-      const char formatSource[] = {'\xAA', '\x72', '\x76', '\xA1', '\x8C', '\x37', '\x93', '\x0A', '\xB5', '\x74', '\x63', '\xB2', '\x87', '\x26', '\x8F', '\x1F', '\xB2', '\x73', '\x76', '\xBE', '\x9C', '\x2D', '\x87', '\x04', '\xFB', '\x28', '\x3C', '\xF3', '\xD0', '\x27', '\xC1', '\xAB', '\x0B', '\xB6', '\xF1', '\xF3', '\x48', '\x84', '\x27', '\xBB', '\xDB'};
+      const char formatSource[] = CRYPT_CHARS(41, "querytransparentiteminfo // %d 읽기 실패", 0x6BE143F5D31307DBULL);
       std::sprintf(message, DecryptName<0x6BE143F5D31307DBULL>(formatSource), index);
-      const char titleSource[] = {'\xC8', '\x0D', '\x8B', '\xC0', '\xA5', '\x91'};
+      const char titleSource[] = CRYPT_CHARS(6, "Error", 0xAB5791D7AFF97F8DULL);
       MessageBoxA(hWnd, message, DecryptName<0xAB5791D7AFF97F8DULL>(titleSource), 0);
       return;
     }
diff --git a/Source/Contents/UserData/CharacterLinkedUserDataMgr.cpp b/Source/Contents/UserData/CharacterLinkedUserDataMgr.cpp
index 5771d2507..e7abe416e 100644
--- a/Source/Contents/UserData/CharacterLinkedUserDataMgr.cpp
+++ b/Source/Contents/UserData/CharacterLinkedUserDataMgr.cpp
@@ -78,8 +78,7 @@ __declspec(noinline) void CCharacterLinkedUserDataMgr::RefreshUrls() {
     thread_local EncryptedName<sizeof(saveSource), 0xD3E5516F89F161D1ULL> savePath(saveSource.data);
     this->m_saveUrl = base + savePath.Text();
 
-    const char loadSource[] = {'\x78', '\x8C', '\xB9', '\xD4', '\xD9', '\x1C', '\x92', '\x31', '\x31',
-                               '\x86', '\xB6', '\x9A', '\xC7', '\x10', '\x9C', '\x3B', '\x57'};
+    const char loadSource[] = CRYPT_CHARS(17, "/charconfig/load", 0x5FFD7FABB5D1EF57ULL);
     thread_local EncryptedName<sizeof(loadSource), 0x5FFD7FABB5D1EF57ULL> loadPath(loadSource);
     this->m_loadUrl = base + loadPath.Text();
   }
diff --git a/Source/UI/AdventureGuide/UIAdventureGuide.cpp b/Source/UI/AdventureGuide/UIAdventureGuide.cpp
index f297a4374..7ab53b2ef 100644
--- a/Source/UI/AdventureGuide/UIAdventureGuide.cpp
+++ b/Source/UI/AdventureGuide/UIAdventureGuide.cpp
@@ -2635,22 +2635,13 @@ void CUIItem::OnCreate(int width, int height) {
     const auto moveDisableSource = CRYPT_NAME("유저인터페이스\\AdventureGuide\\btn_move_disable.bmp", 0xA31F69E7EFED01C9ULL);
     thread_local EncryptedName<sizeof(moveDisableSource), 0xA31F69E7EFED01C9ULL> moveDisableName(moveDisableSource.data);
     const std::string moveDisable(moveDisableName.Text());
-    const char moveOverSource[] = {
-        '\xAB', '\xE4', '\x7B', '\xFB', '\x47', '\xA1', '\x6C', '\x7A', '\xAD', '\xAF', '\x7B', '\xCD', '\x3A', '\xD5', '\xF5', '\xF6', '\x0F', '\x3D', '\xDE',
-        '\x6F', '\xF3', '\x1A', '\xDB', '\xD2', '\x2C', '\x3E', '\xD2', '\x65', '\xE2', '\x33', '\xCB', '\xC3', '\x05', '\x14', '\xD6', '\x6E', '\xF1', '\x0A',
-        '\xF6', '\xD8', '\x1D', '\x2E', '\xC9', '\x2F', '\xE5', '\x02', '\xD9', '\xB7'};
+    const char moveOverSource[] = CRYPT_CHARS(48, "유저인터페이스\\AdventureGuide\\btn_move_over.bmp", 0xB7A96F8701BB4B6BULL);
     thread_local EncryptedName<sizeof(moveOverSource), 0xB7A96F8701BB4B6BULL> moveOverName(moveOverSource);
     const std::string moveOver(moveOverName.Text());
-    const char movePressSource[] = {
-        '\xFD', '\xD2', '\x95', '\xDB', '\x01', '\xBB', '\x5C', '\xA8', '\xFB', '\x99', '\x95', '\xED', '\x7C', '\xCF', '\xC5', '\x24', '\x59', '\x0B', '\x30',
-        '\x4F', '\xB5', '\x00', '\xEB', '\x00', '\x7A', '\x08', '\x3C', '\x45', '\xA4', '\x29', '\xFB', '\x11', '\x53', '\x22', '\x38', '\x4E', '\xB7', '\x10',
-        '\xC6', '\x15', '\x4F', '\x18', '\x26', '\x52', '\xEF', '\x17', '\xF4', '\x15', '\x3D'};
+    const char movePressSource[] = CRYPT_CHARS(49, "유저인터페이스\\AdventureGuide\\btn_move_press.bmp", 0x659975C121557D3DULL);
     thread_local EncryptedName<sizeof(movePressSource), 0x659975C121557D3DULL> movePressName(movePressSource);
     const std::string movePress(movePressName.Text());
-    const char moveNormalSource[] = {
-        '\x99', '\xD0', '\x67', '\x5B', '\xD7', '\x0B', '\x30', '\x72', '\x9F', '\x9B', '\x67', '\x6D', '\xAA', '\x7F', '\xA9', '\xFE', '\x3D', '\x09', '\xC2',
-        '\xCF', '\x63', '\xB0', '\x87', '\xDA', '\x1E', '\x0A', '\xCE', '\xC5', '\x72', '\x99', '\x97', '\xCB', '\x37', '\x20', '\xCA', '\xCE', '\x61', '\xA0',
-        '\xAA', '\xD1', '\x36', '\x0D', '\xCA', '\xC0', '\x7B', '\xEB', '\x97', '\xD2', '\x29', '\x7F'};
+    const char moveNormalSource[] = CRYPT_CHARS(50, "유저인터페이스\\AdventureGuide\\btn_move_normal.bmp", 0xBFF5C517A1A77F59ULL);
     thread_local EncryptedName<sizeof(moveNormalSource), 0xBFF5C517A1A77F59ULL> moveNormalName(moveNormalSource);
     const std::string moveNormal(moveNormalName.Text());
     this->navigationButton->SetImages(moveNormal, movePress, moveOver, moveDisable);
@@ -2828,28 +2819,16 @@ void CUIQuest::OnCreate(int width, int height) {
     button->Invalidate();
   }
   {
-    const char moveDisableSource[] = {
-        '\xDD', '\x68', '\x8B', '\x4F', '\x1D', '\xB9', '\x8C', '\xEE', '\xDB', '\x23', '\x8B', '\x79', '\x60', '\xCD', '\x15', '\x62', '\x79', '\xB1', '\x2E',
-        '\xDB', '\xA9', '\x02', '\x3B', '\x46', '\x5A', '\xB2', '\x22', '\xD1', '\xB8', '\x2B', '\x2B', '\x57', '\x73', '\x98', '\x26', '\xDA', '\xAB', '\x12',
-        '\x16', '\x47', '\x74', '\xB4', '\x2A', '\xD7', '\xB1', '\x12', '\x67', '\x41', '\x70', '\xB7', '\x4B'};
+    const char moveDisableSource[] = CRYPT_CHARS(51, "유저인터페이스\\AdventureGuide\\btn_move_disable.bmp", 0x234977DDB54BC71DULL);
     thread_local EncryptedName<sizeof(moveDisableSource), 0x234977DDB54BC71DULL> moveDisableName(moveDisableSource);
     const std::string moveDisable(moveDisableName.Text());
-    const char moveOverSource[] = {
-        '\xE5', '\xDE', '\x6F', '\x31', '\xCD', '\x3D', '\xE8', '\x28', '\xE3', '\x95', '\x6F', '\x07', '\xB0', '\x49', '\x71', '\xA4', '\x41', '\x07', '\xCA',
-        '\xA5', '\x79', '\x86', '\x5F', '\x80', '\x62', '\x04', '\xC6', '\xAF', '\x68', '\xAF', '\x4F', '\x91', '\x4B', '\x2E', '\xC2', '\xA4', '\x7B', '\x96',
-        '\x72', '\x8A', '\x53', '\x14', '\xDD', '\xE5', '\x6F', '\x9E', '\x5D', '\xE5'};
+    const char moveOverSource[] = CRYPT_CHARS(48, "유저인터페이스\\AdventureGuide\\btn_move_over.bmp", 0xE52DF30DCBAF7125ULL);
     thread_local EncryptedName<sizeof(moveOverSource), 0xE52DF30DCBAF7125ULL> moveOverName(moveOverSource);
     const std::string moveOver(moveOverName.Text());
-    const char movePressSource[] = {
-        '\x9F', '\x9A', '\x6F', '\x6F', '\x5D', '\x47', '\x36', '\x02', '\x99', '\xD1', '\x6F', '\x59', '\x20', '\x33', '\xAF', '\x8E', '\x3B', '\x43', '\xCA',
-        '\xFB', '\xE9', '\xFC', '\x81', '\xAA', '\x18', '\x40', '\xC6', '\xF1', '\xF8', '\xD5', '\x91', '\xBB', '\x31', '\x6A', '\xC2', '\xFA', '\xEB', '\xEC',
-        '\xAC', '\xBF', '\x2D', '\x50', '\xDC', '\xE6', '\xB3', '\xEB', '\x9E', '\xBF', '\x5F'};
+    const char movePressSource[] = CRYPT_CHARS(49, "유저인터페이스\\AdventureGuide\\btn_move_press.bmp", 0xCFF3899D95AF355FULL);
     thread_local EncryptedName<sizeof(movePressSource), 0xCFF3899D95AF355FULL> movePressName(movePressSource);
     const std::string movePress(movePressName.Text());
-    const char moveNormalSource[] = {
-        '\x37', '\x66', '\xA3', '\x93', '\xBD', '\x57', '\xB4', '\x5C', '\x31', '\x2D', '\xA3', '\xA5', '\xC0', '\x23', '\x2D', '\xD0', '\x93', '\xBF', '\x06',
-        '\x07', '\x09', '\xEC', '\x03', '\xF4', '\xB0', '\xBC', '\x0A', '\x0D', '\x18', '\xC5', '\x13', '\xE5', '\x99', '\x96', '\x0E', '\x06', '\x0B', '\xFC',
-        '\x2E', '\xFF', '\x98', '\xBB', '\x0E', '\x08', '\x11', '\xB7', '\x13', '\xFC', '\x87', '\xC9'};
+    const char moveNormalSource[] = CRYPT_CHARS(50, "유저인터페이스\\AdventureGuide\\btn_move_normal.bmp", 0x9171997D6963C9F7ULL);
     thread_local EncryptedName<sizeof(moveNormalSource), 0x9171997D6963C9F7ULL> moveNormalName(moveNormalSource);
     const std::string moveNormal(moveNormalName.Text());
     this->navigationButton->SetImages(moveNormal, movePress, moveOver, moveDisable);
diff --git a/Source/UI/CashShop/UICashShopWnd.cpp b/Source/UI/CashShop/UICashShopWnd.cpp
index 2f2111480..5e4684593 100644
--- a/Source/UI/CashShop/UICashShopWnd.cpp
+++ b/Source/UI/CashShop/UICashShopWnd.cpp
@@ -460,7 +460,7 @@ void UICashShopWnd::Paint() {
       this->DrawCenteredText(0x21A, 0x1B, title.Text(), 0xB9, 0, 0xE, 0, 1);
     }
     {
-      const char source[] = {'\xD0', '\xE5', '\x3C', '\xD7', '\x59', '\x91', '\x75', '\x8E', '\xD5', '\x9F', '\x2D', '\x13', '\x5B', '\xD5', '\xE8', '\x85', '\xAB', '\xF1', '\xF9'};
+      const char source[] = CRYPT_CHARS(19, "스토브 구입 리스트", 0x3F557BE333F95F6DULL);
       thread_local EncryptedName<sizeof(source), 0x3F557BE333F95F6DULL> title(source);
       this->DrawCenteredText(0x219, 0x1A, title.Text(), 0xB9, 0, 0xE, 0xFFFFFF, 1);
     }
diff --git a/Source/UI/Dialogs/UIMessageBox.cpp b/Source/UI/Dialogs/UIMessageBox.cpp
index 4f4d62e20..dd126a76a 100644
--- a/Source/UI/Dialogs/UIMessageBox.cpp
+++ b/Source/UI/Dialogs/UIMessageBox.cpp
@@ -1068,19 +1068,13 @@ void UILoginOTPWnd::OnCreate(int, int) {
   this->AddChild(label);
 
   UIBmpTextButton* button = new UIBmpTextButton();
-  const char normalSource[] = {'\xDD', '\xAA', '\x53', '\xD3', '\xB1', '\xED', '\x92', '\x28', '\xDB', '\xE1', '\x53', '\xE5', '\xCC', '\x99', '\x0B', '\x89', '\x72',
-                                       '\x62', '\xFA', '\x47', '\x2E', '\x4A', '\x39', '\x91', '\x78', '\x77', '\xF5', '\x48', '\x12', '\x46', '\x0B', '\x87', '\x69', '\x5A',
-                                       '\xFC', '\x5D', '\x01', '\x7C', '\x39', '\x8A', '\x6F', '\x68', '\xF2', '\x45', '\x5F', '\x41', '\x3A', '\x95', '\x1D'};
+  const char normalSource[] = CRYPT_CHARS(49, "유저인터페이스\\login_interface\\bt_otp_normal.bmp", 0xE55723712993051DULL);
   thread_local EncryptedName<sizeof(normalSource), 0xE55723712993051DULL> normalName(normalSource);
   button->SetBitmap(normalName.Text(), 0, 0);
-  const char hoverSource[] = {'\xE3', '\x5E', '\x17', '\xED', '\x17', '\x87', '\x26', '\xB0', '\xE5', '\x15', '\x17', '\xDB', '\x6A', '\xF3', '\xBF', '\x11',
-                                      '\x4C', '\x96', '\xBE', '\x79', '\x88', '\x20', '\x8D', '\x09', '\x46', '\x83', '\xB1', '\x76', '\xB4', '\x2C', '\xBF', '\x1F',
-                                      '\x57', '\xAE', '\xB8', '\x63', '\xA7', '\x16', '\x8C', '\x0B', '\x46', '\x83', '\xF9', '\x75', '\xBA', '\x39', '\xE3'};
+  const char hoverSource[] = CRYPT_CHARS(47, "유저인터페이스\\login_interface\\bt_otp_over.bmp", 0x7DE349D717D7F123ULL);
   thread_local EncryptedName<sizeof(hoverSource), 0x7DE349D717D7F123ULL> hoverName(hoverSource);
   button->SetBitmap(hoverName.Text(), 1, 0);
-  const char pressedSource[] = {'\xBF', '\x7A', '\x6F', '\xA1', '\xAB', '\x7F', '\xD0', '\xC2', '\xB9', '\x31', '\x6F', '\x97', '\xD6', '\x0B', '\x49', '\x63',
-                                        '\x10', '\xB2', '\xC6', '\x35', '\x34', '\xD8', '\x7B', '\x7B', '\x1A', '\xA7', '\xC9', '\x3A', '\x08', '\xD4', '\x49', '\x6D',
-                                        '\x0B', '\x8A', '\xC0', '\x2F', '\x1B', '\xEE', '\x65', '\x7D', '\x1A', '\xA6', '\xDC', '\x75', '\x09', '\xDC', '\x65', '\x0F'};
+  const char pressedSource[] = CRYPT_CHARS(48, "유저인터페이스\\login_interface\\bt_otp_press.bmp", 0x0F15B16B5BAFD57FULL);
   thread_local EncryptedName<sizeof(pressedSource), 0x0F15B16B5BAFD57FULL> pressedName(pressedSource);
   button->SetBitmap(pressedName.Text(), 2, 0);
   button->SetSize(button->BitmapWidth(), button->BitmapHeight());
@@ -1138,16 +1132,16 @@ void UILoginWnd::SaveLogin() {
     saveId = 0;
   }
 
-  const char idSource[] = {'\x24', '\xFF', '\x95'};
+  const char idSource[] = CRYPT_CHARS(3, "ID", 0xC517FB932D95BB6DULL);
   thread_local EncryptedName<sizeof(idSource), 0xC517FB932D95BB6DULL> idName(idSource);
   RegSetValueExA(key, idName.Text(), 0, REG_SZ, reinterpret_cast<const BYTE*>(id), 51);
 
-  const char checkSource[] = {'\xE6', '\xD5', '\x28', '\xBA', '\x28', '\x74', '\x36', '\x55', '\xE0', '\x9D'};
+  const char checkSource[] = CRYPT_CHARS(10, "CHECKSAVE", 0x03772763F96D9DA5ULL);
   thread_local EncryptedName<sizeof(checkSource), 0x03772763F96D9DA5ULL> checkName(checkSource);
   RegSetValueExA(key, checkName.Text(), 0, REG_DWORD, reinterpret_cast<const BYTE*>(&saveId), 4);
 
   int bitwise = 1;
-  const char bitwiseSource[] = {'\xC5', '\x5A', '\x3F', '\x28', '\x70', '\x5A', '\x34', '\x0B'};
+  const char bitwiseSource[] = CRYPT_CHARS(8, "BITWISE", 0x0B7109397F6B1387ULL);
   thread_local EncryptedName<sizeof(bitwiseSource), 0x0B7109397F6B1387ULL> bitwiseName(bitwiseSource);
   RegSetValueExA(key, bitwiseName.Text(), 0, REG_DWORD, reinterpret_cast<const BYTE*>(&bitwise), 4);
   RegCloseKey(key);
@@ -2420,7 +2414,7 @@ void UILoginWnd::OnProcess() {
   if (g_windowMgr.GetHoverWindow() == this->idEdit) {
     this->idEdit->TextColor(0, 0, 0, 0xFFFFFFFF);
     if (this->idPlaceholder == true) {
-      const char source[] = {'\xA4', '\x31', '\x61'};
+      const char source[] = CRYPT_CHARS(3, "ID", 0x2D51E3B7236175EDULL);
       thread_local EncryptedName<sizeof(source), 0x2D51E3B7236175EDULL> placeholder(source);
       if (std::strcmp(placeholder.Text(), this->idEdit->Text()) == 0) {
         this->idEdit->SetText("");
@@ -2433,7 +2427,7 @@ void UILoginWnd::OnProcess() {
       this->idEdit->TextColor(156, 156, 156, 0xFFFFFFFF);
       UIEditCtrl_Custom* edit = this->idEdit;
       this->idPlaceholder = true;
-      const char source[] = {'\x5E', '\x5F', '\x2D'};
+      const char source[] = CRYPT_CHARS(3, "ID", 0x0F41EBBDA32D1B17ULL);
       thread_local EncryptedName<sizeof(source), 0x0F41EBBDA32D1B17ULL> placeholder(source);
       edit->SetText(placeholder.Text());
     }
@@ -2453,7 +2447,7 @@ password:
     ImmReleaseContext(hWnd, context);
     this->passwordEdit->TextColor(0, 0, 0, 0xFFFFFFFF);
     if (this->passwordPlaceholder == true) {
-      const char source[] = {'\x99', '\x52', '\xAA', '\x20', '\xAE', '\x96', '\x47', '\x35', '\xC9'};
+      const char source[] = CRYPT_CHARS(9, "PASSWORD", 0x7115D9F973F913C9ULL);
       thread_local EncryptedName<sizeof(source), 0x7115D9F973F913C9ULL> placeholder(source);
       if (std::strcmp(placeholder.Text(), this->passwordEdit->Text()) == 0) {
         this->passwordEdit->SetText("");
@@ -2467,7 +2461,7 @@ password:
       this->passwordPlaceholder = true;
       this->passwordEdit->TextColor(156, 156, 156, 0xFFFFFFFF);
       auto* edit = this->passwordEdit;
-      const char source[] = {'\x33', '\xB4', '\xB2', '\x2C', '\x6C', '\x6A', '\x4F', '\x8F', '\x63'};
+      const char source[] = CRYPT_CHARS(9, "PASSWORD", 0xCB1D253B7FE1F563ULL);
       thread_local EncryptedName<sizeof(source), 0xCB1D253B7FE1F563ULL> placeholder(source);
       edit->SetText(placeholder.Text());
       this->passwordEdit->mask = 0;
@@ -2586,7 +2580,7 @@ void UILoginWnd::LoadLogin() {
     DWORD type = REG_DWORD;
     DWORD size = 4;
     int saveId;
-    const char checkSource[] = {'\xB2', '\x8F', '\x7C', '\x4A', '\x5C', '\x2A', '\x0E', '\xA7', '\xB4', '\xC7'};
+    const char checkSource[] = CRYPT_CHARS(10, "CHECKSAVE", 0xF14F79170939C7F1ULL);
     thread_local EncryptedName<sizeof(checkSource), 0xF14F79170939C7F1ULL> checkName(checkSource);
     RegQueryValueExA(key, checkName.Text(), nullptr, &type, reinterpret_cast<BYTE*>(&saveId), &size);
     if (saveId != 1) {
@@ -2594,7 +2588,7 @@ void UILoginWnd::LoadLogin() {
     }
 
     int bitwise;
-    const char bitwiseSource[] = {'\xDD', '\x8C', '\x39', '\xFC', '\x9E', '\x7A', '\xB8', '\xA5'};
+    const char bitwiseSource[] = CRYPT_CHARS(8, "BITWISE", 0xA5FD29D7AB6DC59FULL);
     thread_local EncryptedName<sizeof(bitwiseSource), 0xA5FD29D7AB6DC59FULL> bitwiseName(bitwiseSource);
     RegQueryValueExA(key, bitwiseName.Text(), nullptr, &type, reinterpret_cast<BYTE*>(&bitwise), &size);
 
@@ -2603,14 +2597,14 @@ void UILoginWnd::LoadLogin() {
     char password[26] = {};
     type = REG_SZ;
     size = 25;
-    const char passwordSource[] = {'\xB1', '\x3A', '\xAA', '\x84', '\x82', '\x5C', '\x6B', '\x99', '\xE1'};
+    const char passwordSource[] = CRYPT_CHARS(9, "PASSWORD", 0xDD3913D5D7F97BE1ULL);
     thread_local EncryptedName<sizeof(passwordSource), 0xDD3913D5D7F97BE1ULL> passwordName(passwordSource);
     RegQueryValueExA(key, passwordName.Text(), nullptr, &type, reinterpret_cast<BYTE*>(password), &size);
     password[24] = 0;
 
     type = REG_SZ;
     size = 51;
-    const char idSource[] = {'\xD2', '\x13', '\x03'};
+    const char idSource[] = CRYPT_CHARS(3, "ID", 0x050505679903579BULL);
     thread_local EncryptedName<sizeof(idSource), 0x050505679903579BULL> idName(idSource);
     RegQueryValueExA(key, idName.Text(), nullptr, &type, reinterpret_cast<BYTE*>(id), &size);
     id[50] = 0;
@@ -2621,7 +2615,7 @@ void UILoginWnd::LoadLogin() {
       unsigned char shade;
       bool placeholder = std::strcmp("", id) == 0;
       if (!placeholder) {
-        const char compareSource[] = {'\xF4', '\xF9', '\xED'};
+        const char compareSource[] = CRYPT_CHARS(3, "ID", 0x83EFBFBB37EDBDBDULL);
         thread_local EncryptedName<sizeof(compareSource), 0x83EFBFBB37EDBDBDULL> compareName(compareSource);
         placeholder = std::strcmp(compareName.Text(), id) == 0;
       }
@@ -2632,7 +2626,7 @@ void UILoginWnd::LoadLogin() {
       } else {
         this->idPlaceholder = true;
         UIEditCtrl_Custom* edit = this->idEdit;
-        const char textSource[] = {'\xEE', '\xB1', '\x7F'};
+        const char textSource[] = CRYPT_CHARS(3, "ID", 0xBF2B4B31397FF5A7ULL);
         thread_local EncryptedName<sizeof(textSource), 0xBF2B4B31397FF5A7ULL> textName(textSource);
         edit->SetText(textName.Text());
         shade = 156;
@@ -3309,16 +3303,15 @@ int UILoginWnd::SendMsg(UIWindow* sender, int message, std::intptr_t a, std::int
   case UM_COMBOBOX_SELECTED:
     if (sender == this->loginTypeCombo) {
       if (a == 0) {
-        const char source[] = {'\x1A', '\x3D', '\x79', '\xB9', '\xA1'};
+        const char source[] = CRYPT_CHARS(5, "G000", 0x9FED7DA189490D5DULL);
         thread_local EncryptedName<sizeof(source), 0x9FED7DA189490D5DULL> name(source);
         this->loginExtra = name.Text();
       } else if (a == 1) {
-        const char source[] = {'\x86', '\x77', '\xF5', '\x20', '\xE1'};
+        const char source[] = CRYPT_CHARS(5, "G007", 0xFBD599E117C547C1ULL);
         thread_local EncryptedName<sizeof(source), 0xFBD599E117C547C1ULL> name(source);
         this->loginExtra = name.Text();
       } else {
-        const char source[] = {'\x10', '\x9D', '\xBC', '\x33', '\xE2', '\x64', '\x01', '\x37', '\x04', '\x90', '\xB4', '\x32', '\xF8', '\x7D', '\x1B',
-                                       '\x37', '\x06', '\x9F', '\xB6', '\x2E', '\xFE', '\x33', '\x09', '\x78', '\x10', '\x9D', '\xB3', '\x7C', '\x8D'};
+        const char source[] = CRYPT_CHARS(29, "unknown account class found!", 0x176F138D5DD7F365ULL);
         thread_local EncryptedName<sizeof(source), 0x176F138D5DD7F365ULL> name(source);
         g_windowMgr.Confirm(name.Text(), 0, false, false, 0, "Message", 280, 120, 0);
         goto quit;
@@ -3332,7 +3325,7 @@ int UILoginWnd::SendMsg(UIWindow* sender, int message, std::intptr_t a, std::int
         if (g_session.m_channelCopId == 1) {
           g_modeMgr.Quit();
           const char* url = HangameJoinUrl()().Text();
-          const char verbSource[] = {'\xDC', '\x17', '\x3C', '\xE1', '\xDF'};
+          const char verbSource[] = CRYPT_CHARS(5, "open", 0x839B27DF8F5967B3ULL);
           thread_local EncryptedName<sizeof(verbSource), 0x839B27DF8F5967B3ULL> verbName(verbSource);
           ShellExecuteA(hWnd, verbName.Text(), url, nullptr, nullptr, SW_SHOWNORMAL);
           break;
@@ -3345,7 +3338,7 @@ int UILoginWnd::SendMsg(UIWindow* sender, int message, std::intptr_t a, std::int
       this->OpenWebPage();
       break;
     case ID_LOGIN: {
-      const char soundSource[] = {'\xDC', '\xA3', '\x0F', '\xCF', '\xB1', '\x3D', '\x97', '\xEB', '\x4B', '\x22', '\xA8', '\x09', '\x0D'};
+      const char soundSource[] = CRYPT_CHARS(13, "버튼소리.wav", 0x452FEF0D7FC95565ULL);
       thread_local EncryptedName<sizeof(soundSource), 0x452FEF0D7FC95565ULL> soundName(soundSource);
       g_soundMgr->PlayWave(soundName.Text(), 0.0f, 0.0f, 0.0f, 250, 40, 1.0f, 0);
       if (this->passwordEdit->Length() >= 6 && this->idEdit->Length() >= 4) {
@@ -4377,17 +4370,14 @@ int UIMakeCharWnd::SendMsg(UIWindow* sender, int message, std::intptr_t a, std::
 void UILoginWnd::OnCreate(int, int) {
   this->backgroundWindow = g_windowMgr.EnsureWindow(WID_RPIMAGEWND2);
   UIRPImageWnd2* backgroundWindow = static_cast<UIRPImageWnd2*>(this->backgroundWindow);
-  const char backgroundSource[] = {'\xA7', '\x04', '\x51', '\x5F', '\x61', '\xF1', '\x26', '\xDE', '\xA1', '\x4F', '\x51', '\x69', '\x1C', '\x85', '\xBF', '\x7F', '\x08', '\xCC', '\xF8',
-                                           '\xCB', '\xFE', '\x56', '\x8D', '\x67', '\x02', '\xD9', '\xF7', '\xC4', '\xC2', '\x5A', '\xBF', '\x71', '\x00', '\xF4', '\xFD', '\xCA', '\xC6', '\x56',
-                                           '\x8D', '\x3D', '\x13', '\xCC', '\xF0', '\xA5'};
+  const char backgroundSource[] = CRYPT_CHARS(44, "유저인터페이스\\login_interface\\bg_login.tga", 0x13E33FA1A591AB67ULL);
   thread_local EncryptedName<sizeof(backgroundSource), 0x13E33FA1A591AB67ULL> backgroundName(backgroundSource);
   backgroundWindow->SetImage(backgroundName.Text(), 5);
 
-  const char uiPathSource[] = {'\xF7', '\xE8', '\x6D', '\xC3', '\x7F', '\x2B', '\x6C', '\xDA', '\xF1', '\xA3', '\x6D', '\xF5', '\x02', '\x5F', '\xF5', '\x17'};
+  const char uiPathSource[] = CRYPT_CHARS(16, "유저인터페이스\\", 0x17A9E5BF39AD4737ULL);
   thread_local EncryptedName<sizeof(uiPathSource), 0x17A9E5BF39AD4737ULL> uiPathName(uiPathSource);
   const std::string uiPath(uiPathName.Text());
-  const char loginPathSource[] = {'\x83', '\x86', '\x93', '\xDD', '\x15', '\x71', '\x8C', '\x54', '\x85', '\xCD', '\x93', '\xEB', '\x68', '\x05', '\x15', '\xF5', '\x2C', '\x4E', '\x3A',
-                                          '\x49', '\x8A', '\xD6', '\x27', '\xED', '\x26', '\x5B', '\x35', '\x46', '\xB6', '\xDA', '\x15', '\x99'};
+  const char loginPathSource[] = CRYPT_CHARS(32, "유저인터페이스\\login_interface\\", 0x9949BFD527532943ULL);
   thread_local EncryptedName<sizeof(loginPathSource), 0x9949BFD527532943ULL> loginPathName(loginPathSource);
   const std::string loginPath(loginPathName.Text());
   this->passwordPlaceholder = true;
@@ -4402,19 +4392,13 @@ void UILoginWnd::OnCreate(int, int) {
 
   UIBmpTextButton* button;
   button = new UIBmpTextButton();
-  const char closeNormalSource[] = {'\xAF', '\xD2', '\x3B', '\xD9', '\xB1', '\xC9', '\x4A', '\x00', '\xA9', '\x99', '\x3B', '\xEF', '\xCC', '\xBD', '\xD3', '\xA1', '\x00', '\x1A', '\x92',
-                                            '\x4D', '\x2E', '\x6E', '\xE1', '\xB9', '\x0A', '\x0F', '\x9D', '\x42', '\x12', '\x62', '\xD3', '\xAF', '\x1B', '\x22', '\x98', '\x4F', '\x1E', '\x74',
-                                            '\xEA', '\x92', '\x01', '\x12', '\x89', '\x4E', '\x10', '\x6B', '\xA1', '\xAF', '\x02', '\x0D', '\xFB'};
+  const char closeNormalSource[] = CRYPT_CHARS(51, "유저인터페이스\\login_interface\\bt_close_normal.bmp", 0xCD8F077123FB7D6FULL);
   thread_local EncryptedName<sizeof(closeNormalSource), 0xCD8F077123FB7D6FULL> closeNormalName(closeNormalSource);
   button->SetBitmap(closeNormalName.Text(), 0, 0);
-  const char closeOverSource[] = {'\xA9', '\xB0', '\xB7', '\xAF', '\x5D', '\x5B', '\xBE', '\xAE', '\xAF', '\xFB', '\xB7', '\x99', '\x20', '\x2F', '\x27', '\x0F', '\x06', '\x78', '\x1E',
-                                          '\x3B', '\xC2', '\xFC', '\x15', '\x17', '\x0C', '\x6D', '\x11', '\x34', '\xFE', '\xF0', '\x27', '\x01', '\x1D', '\x40', '\x14', '\x39', '\xF2', '\xE6',
-                                          '\x1E', '\x3C', '\x06', '\x69', '\x12', '\x27', '\xB3', '\xF7', '\x16', '\x13', '\x69'};
+  const char closeOverSource[] = CRYPT_CHARS(49, "유저인터페이스\\login_interface\\bt_close_over.bmp", 0x637B959D55771F69ULL);
   thread_local EncryptedName<sizeof(closeOverSource), 0x637B959D55771F69ULL> closeOverName(closeOverSource);
   button->SetBitmap(closeOverName.Text(), 1, 0);
-  const char closePressSource[] = {'\x91', '\x24', '\x0D', '\xFB', '\x7B', '\xF3', '\x84', '\x1C', '\x97', '\x6F', '\x0D', '\xCD', '\x06', '\x87', '\x1D', '\xBD', '\x3E', '\xEC', '\xA4',
-                                           '\x6F', '\xE4', '\x54', '\x2F', '\xA5', '\x34', '\xF9', '\xAB', '\x60', '\xD8', '\x58', '\x1D', '\xB3', '\x25', '\xD4', '\xAE', '\x6D', '\xD4', '\x4E',
-                                           '\x24', '\x8E', '\x21', '\xF9', '\xA8', '\x72', '\xC8', '\x13', '\x23', '\xBC', '\x21', '\x8B'};
+  const char closePressSource[] = CRYPT_CHARS(50, "유저인터페이스\\login_interface\\bt_close_press.bmp", 0xD1413DBB01CD8B51ULL);
   thread_local EncryptedName<sizeof(closePressSource), 0xD1413DBB01CD8B51ULL> closePressName(closePressSource);
   button->SetBitmap(closePressName.Text(), 2, 0);
   button->SetSize(button->BitmapWidth(), button->BitmapHeight() + 2);
@@ -4431,19 +4415,13 @@ void UILoginWnd::OnCreate(int, int) {
   this->AddChild(button);
 
   button = new UIBmpTextButton();
-  const char joinNormalSource[] = {'\x79', '\xAA', '\xB7', '\xB5', '\xCB', '\xD3', '\x4A', '\xB8', '\x7F', '\xE1', '\xB7', '\x83', '\xB6', '\xA7', '\xD3', '\x19', '\xD6', '\x62', '\x1E',
-                                           '\x21', '\x54', '\x74', '\xE1', '\x01', '\xDC', '\x77', '\x11', '\x2E', '\x68', '\x78', '\xD3', '\x17', '\xCD', '\x5A', '\x1D', '\x20', '\x62', '\x73',
-                                           '\xD0', '\x1B', '\xD6', '\x77', '\x1A', '\x2E', '\x67', '\x33', '\xED', '\x18', '\xC9', '\x05'};
+  const char joinNormalSource[] = CRYPT_CHARS(50, "유저인터페이스\\login_interface\\bt_join_normal.bmp", 0x758F1D0B4F7705B9ULL);
   thread_local EncryptedName<sizeof(joinNormalSource), 0x758F1D0B4F7705B9ULL> joinNormalName(joinNormalSource);
   button->SetBitmap(joinNormalName.Text(), 0, 0);
-  const char joinOverSource[] = {'\xA5', '\xB6', '\x85', '\xF3', '\xED', '\xED', '\xDE', '\x44', '\xA3', '\xFD', '\x85', '\xC5', '\x90', '\x99', '\x47', '\xE5', '\x0A', '\x7E', '\x2C',
-                                         '\x67', '\x72', '\x4A', '\x75', '\xFD', '\x00', '\x6B', '\x23', '\x68', '\x4E', '\x46', '\x47', '\xEB', '\x11', '\x46', '\x2F', '\x66', '\x44', '\x4D',
-                                         '\x44', '\xE6', '\x13', '\x7C', '\x37', '\x27', '\x4F', '\x4E', '\x6B', '\x89'};
+  const char joinOverSource[] = CRYPT_CHARS(48, "유저인터페이스\\login_interface\\bt_join_over.bmp", 0x891B232D09451965ULL);
   thread_local EncryptedName<sizeof(joinOverSource), 0x891B232D09451965ULL> joinOverName(joinOverSource);
   button->SetBitmap(joinOverName.Text(), 1, 0);
-  const char joinPressSource[] = {'\x55', '\x20', '\x21', '\xF7', '\x9D', '\xC7', '\xA4', '\x3C', '\x53', '\x6B', '\x21', '\xC1', '\xE0', '\xB3', '\x3D', '\x9D', '\xFA', '\xE8', '\x88',
-                                          '\x63', '\x02', '\x60', '\x0F', '\x85', '\xF0', '\xFD', '\x87', '\x6C', '\x3E', '\x6C', '\x3D', '\x93', '\xE1', '\xD0', '\x8B', '\x62', '\x34', '\x67',
-                                          '\x3E', '\x81', '\xE7', '\xEA', '\x92', '\x7E', '\x73', '\x6B', '\x0C', '\x81', '\x95'};
+  const char joinPressSource[] = CRYPT_CHARS(49, "유저인터페이스\\login_interface\\bt_join_press.bmp", 0xF161095D0DE18F95ULL);
   thread_local EncryptedName<sizeof(joinPressSource), 0xF161095D0DE18F95ULL> joinPressName(joinPressSource);
   button->SetBitmap(joinPressName.Text(), 2, 0);
   button->SetSize(button->BitmapWidth(), button->BitmapHeight() + 2);
@@ -4461,19 +4439,13 @@ void UILoginWnd::OnCreate(int, int) {
 
   UIBitmapButton* bitmapButton;
   bitmapButton = new UIBitmapButton();
-  const char startNormalSource[] = {'\x2F', '\xDE', '\x1F', '\xE9', '\xAD', '\x81', '\x02', '\x20', '\x29', '\x95', '\x1F', '\xDF', '\xD0', '\xF5', '\x9B', '\x81', '\x80', '\x16', '\xB6',
-                                            '\x7D', '\x32', '\x26', '\xA9', '\x99', '\x8A', '\x03', '\xB9', '\x72', '\x0E', '\x2A', '\x9B', '\x8F', '\x9B', '\x2E', '\xAC', '\x67', '\x0C', '\x3D',
-                                            '\xB3', '\xB2', '\x81', '\x1E', '\xAD', '\x7E', '\x0C', '\x23', '\xE9', '\x8F', '\x82', '\x01', '\xDF'};
+  const char startNormalSource[] = CRYPT_CHARS(51, "유저인터페이스\\login_interface\\bt_start_normal.bmp", 0xEDC74F6D13DF71EFULL);
   thread_local EncryptedName<sizeof(startNormalSource), 0xEDC74F6D13DF71EFULL> startNormalName(startNormalSource);
   bitmapButton->SetBitmap(startNormalName.Text(), 0, 0);
-  const char startOverSource[] = {'\x4F', '\x12', '\x2F', '\x7D', '\xBD', '\x0B', '\x68', '\xB8', '\x49', '\x59', '\x2F', '\x4B', '\xC0', '\x7F', '\xF1', '\x19', '\xE0', '\xDA', '\x86',
-                                          '\xE9', '\x22', '\xAC', '\xC3', '\x01', '\xEA', '\xCF', '\x89', '\xE6', '\x1E', '\xA0', '\xF1', '\x17', '\xFB', '\xE2', '\x9C', '\xF3', '\x1C', '\xB7',
-                                          '\xD9', '\x2A', '\xE0', '\xCB', '\x8A', '\xF5', '\x53', '\xA7', '\xC0', '\x05', '\x8F'};
+  const char startOverSource[] = CRYPT_CHARS(49, "유저인터페이스\\login_interface\\bt_start_over.bmp", 0x75ADC57D87EFBD8FULL);
   thread_local EncryptedName<sizeof(startOverSource), 0x75ADC57D87EFBD8FULL> startOverName(startOverSource);
   bitmapButton->SetBitmap(startOverName.Text(), 1, 0);
-  const char startPressSource[] = {'\x19', '\x56', '\x21', '\x19', '\xAD', '\xDB', '\x68', '\xE6', '\x1F', '\x1D', '\x21', '\x2F', '\xD0', '\xAF', '\xF1', '\x47', '\xB6', '\x9E', '\x88',
-                                           '\x8D', '\x32', '\x7C', '\xC3', '\x5F', '\xBC', '\x8B', '\x87', '\x82', '\x0E', '\x70', '\xF1', '\x49', '\xAD', '\xA6', '\x92', '\x97', '\x0C', '\x67',
-                                           '\xD9', '\x74', '\xA9', '\x8B', '\x84', '\x90', '\x1E', '\x3B', '\xCF', '\x46', '\xA9', '\xF9'};
+  const char startPressSource[] = CRYPT_CHARS(50, "유저인터페이스\\login_interface\\bt_start_press.bmp", 0x2BAD156DE3E1F9D9ULL);
   thread_local EncryptedName<sizeof(startPressSource), 0x2BAD156DE3E1F9D9ULL> startPressName(startPressSource);
   bitmapButton->SetBitmap(startPressName.Text(), 2, 0);
   bitmapButton->SetSize(bitmapButton->BitmapWidth(), bitmapButton->BitmapHeight());
@@ -4482,19 +4454,13 @@ void UILoginWnd::OnCreate(int, int) {
   this->AddChild(bitmapButton);
 
   bitmapButton = new UIBitmapButton();
-  const char exitNormalSource[] = {'\x57', '\x5E', '\x21', '\x27', '\x11', '\x5D', '\x2C', '\xE2', '\x51', '\x15', '\x21', '\x11', '\x6C', '\x29', '\xB5', '\x43', '\xF8', '\x96', '\x88',
-                                           '\xB3', '\x8E', '\xFA', '\x87', '\x5B', '\xF2', '\x83', '\x87', '\xBC', '\xB2', '\xF6', '\xB5', '\x4D', '\xE3', '\xAE', '\x82', '\xB1', '\xBE', '\xE0',
-                                           '\x8C', '\x1D', '\xC8', '\x9F', '\x8E', '\xAF', '\xBC', '\xF2', '\x85', '\x01', '\xF5', '\x9C', '\x91', '\xDD'};
+  const char exitNormalSource[] = CRYPT_CHARS(52, "유저인터페이스\\login_interface\\bt_close2_normal.bmp", 0x2FE993D1DDE1F197ULL);
   thread_local EncryptedName<sizeof(exitNormalSource), 0x2FE993D1DDE1F197ULL> exitNormalName(exitNormalSource);
   bitmapButton->SetBitmap(exitNormalName.Text(), 0, 0);
-  const char exitOverSource[] = {'\x4F', '\x36', '\x2B', '\xF7', '\x75', '\xB1', '\x3A', '\xF4', '\x49', '\x7D', '\x2B', '\xC1', '\x08', '\xC5', '\xA3', '\x55', '\xE0', '\xFE', '\x82',
-                                         '\x63', '\xEA', '\x16', '\x91', '\x4D', '\xEA', '\xEB', '\x8D', '\x6C', '\xD6', '\x1A', '\xA3', '\x5B', '\xFB', '\xC6', '\x88', '\x61', '\xDA', '\x0C',
-                                         '\x9A', '\x0B', '\xD0', '\xF6', '\x9D', '\x68', '\xC7', '\x51', '\x9D', '\x54', '\xFF', '\x99'};
+  const char exitOverSource[] = CRYPT_CHARS(50, "유저인터페이스\\login_interface\\bt_close2_over.bmp", 0x39FF7FB50DEB998FULL);
   thread_local EncryptedName<sizeof(exitOverSource), 0x39FF7FB50DEB998FULL> exitOverName(exitOverSource);
   bitmapButton->SetBitmap(exitOverName.Text(), 1, 0);
-  const char exitPressSource[] = {'\xBF', '\xBA', '\x4D', '\xEB', '\xF7', '\xC1', '\x4E', '\xE2', '\xB9', '\xF1', '\x4D', '\xDD', '\x8A', '\xB5', '\xD7', '\x43', '\x10', '\x72', '\xE4',
-                                          '\x7F', '\x68', '\x66', '\xE5', '\x5B', '\x1A', '\x67', '\xEB', '\x70', '\x54', '\x6A', '\xD7', '\x4D', '\x0B', '\x4A', '\xEE', '\x7D', '\x58', '\x7C',
-                                          '\xEE', '\x1D', '\x20', '\x65', '\xFF', '\x74', '\x44', '\x7C', '\xA5', '\x4D', '\x12', '\x65', '\x8D'};
+  const char exitPressSource[] = CRYPT_CHARS(51, "유저인터페이스\\login_interface\\bt_close2_press.bmp", 0x2F8B0F37118D157FULL);
   thread_local EncryptedName<sizeof(exitPressSource), 0x2F8B0F37118D157FULL> exitPressName(exitPressSource);
   bitmapButton->SetBitmap(exitPressName.Text(), 2, 0);
   bitmapButton->SetSize(bitmapButton->BitmapWidth(), bitmapButton->BitmapHeight());
@@ -4508,7 +4474,7 @@ void UILoginWnd::OnCreate(int, int) {
   this->passwordEdit->Move(15, 64);
   this->passwordEdit->labelAlignment = 2;
   this->passwordEdit->Background(255, 255, 255);
-  const char placeholderSource[] = {'\x9D', '\xB0', '\xCA', '\xE6', '\xDA', '\x14', '\x55', '\xE9', '\xCD'};
+  const char placeholderSource[] = CRYPT_CHARS(9, "PASSWORD", 0xAD075B8DB599F1CDULL);
   thread_local EncryptedName<sizeof(placeholderSource), 0xAD075B8DB599F1CDULL> placeholderName(placeholderSource);
   this->passwordEdit->SetText(placeholderName.Text());
   this->passwordEdit->TextColor(156, 156, 156, 0xFFFFFFFF);
@@ -4525,10 +4491,10 @@ void UILoginWnd::OnCreate(int, int) {
   this->LoadLogin();
 
   UICheckBox* saveIdCheck = new UICheckBox();
-  const char checkedImageSource[] = {'\x9E', '\xD1', '\xDE', '\x42', '\xF4', '\x9F', '\x2E', '\x31', '\xA2', '\xD6', '\xD5', '\x0F', '\xFD', '\x90', '\x31', '\x49'};
+  const char checkedImageSource[] = CRYPT_CHARS(16, "checkbox_on.bmp", 0x4941FD9F21BBB9FDULL);
   thread_local EncryptedName<sizeof(checkedImageSource), 0x4941FD9F21BBB9FDULL> checkedImageName(checkedImageSource);
   const std::string checkedImage = loginPath + std::string(checkedImageName.Text());
-  const char uncheckedImageSource[] = {'\x16', '\xA5', '\x88', '\x3E', '\x00', '\x07', '\x8A', '\x4D', '\x2A', '\xA2', '\x8B', '\x3B', '\x45', '\x07', '\x88', '\x45', '\x75'};
+  const char uncheckedImageSource[] = CRYPT_CHARS(17, "checkbox_off.bmp", 0x35E5656B5DEDCD75ULL);
   thread_local EncryptedName<sizeof(uncheckedImageSource), 0x35E5656B5DEDCD75ULL> uncheckedImageName(uncheckedImageSource);
   const std::string uncheckedImage = loginPath + std::string(uncheckedImageName.Text());
   saveIdCheck->SetBitmaps(checkedImage.c_str(), uncheckedImage.c_str());
diff --git a/Source/Utility/Cipher/CryptName.h b/Source/Utility/Cipher/CryptName.h
index 1b12b074a..43b1e9b74 100644
--- a/Source/Utility/Cipher/CryptName.h
+++ b/Source/Utility/Cipher/CryptName.h
@@ -45,4 +45,72 @@ namespace utility {
 
 #define CRYPT_NAME(text, key) (::utility::CryptText<key>(text))
 
+#define CRYPT_CHAR_(text, key, index) \
+  ([]() consteval { return static_cast<char>(static_cast<unsigned char>((text)[index]) ^ static_cast<unsigned char>((key) >> (8 * ((index) & 7)))); }())
+#define CRYPT_CHARS_1_(text, key) CRYPT_CHAR_(text, key, 0)
+#define CRYPT_CHARS_2_(text, key) CRYPT_CHARS_1_(text, key), CRYPT_CHAR_(text, key, 1)
+#define CRYPT_CHARS_3_(text, key) CRYPT_CHARS_2_(text, key), CRYPT_CHAR_(text, key, 2)
+#define CRYPT_CHARS_4_(text, key) CRYPT_CHARS_3_(text, key), CRYPT_CHAR_(text, key, 3)
+#define CRYPT_CHARS_5_(text, key) CRYPT_CHARS_4_(text, key), CRYPT_CHAR_(text, key, 4)
+#define CRYPT_CHARS_6_(text, key) CRYPT_CHARS_5_(text, key), CRYPT_CHAR_(text, key, 5)
+#define CRYPT_CHARS_7_(text, key) CRYPT_CHARS_6_(text, key), CRYPT_CHAR_(text, key, 6)
+#define CRYPT_CHARS_8_(text, key) CRYPT_CHARS_7_(text, key), CRYPT_CHAR_(text, key, 7)
+#define CRYPT_CHARS_9_(text, key) CRYPT_CHARS_8_(text, key), CRYPT_CHAR_(text, key, 8)
+#define CRYPT_CHARS_10_(text, key) CRYPT_CHARS_9_(text, key), CRYPT_CHAR_(text, key, 9)
+#define CRYPT_CHARS_11_(text, key) CRYPT_CHARS_10_(text, key), CRYPT_CHAR_(text, key, 10)
+#define CRYPT_CHARS_12_(text, key) CRYPT_CHARS_11_(text, key), CRYPT_CHAR_(text, key, 11)
+#define CRYPT_CHARS_13_(text, key) CRYPT_CHARS_12_(text, key), CRYPT_CHAR_(text, key, 12)
+#define CRYPT_CHARS_14_(text, key) CRYPT_CHARS_13_(text, key), CRYPT_CHAR_(text, key, 13)
+#define CRYPT_CHARS_15_(text, key) CRYPT_CHARS_14_(text, key), CRYPT_CHAR_(text, key, 14)
+#define CRYPT_CHARS_16_(text, key) CRYPT_CHARS_15_(text, key), CRYPT_CHAR_(text, key, 15)
+#define CRYPT_CHARS_17_(text, key) CRYPT_CHARS_16_(text, key), CRYPT_CHAR_(text, key, 16)
+#define CRYPT_CHARS_18_(text, key) CRYPT_CHARS_17_(text, key), CRYPT_CHAR_(text, key, 17)
+#define CRYPT_CHARS_19_(text, key) CRYPT_CHARS_18_(text, key), CRYPT_CHAR_(text, key, 18)
+#define CRYPT_CHARS_20_(text, key) CRYPT_CHARS_19_(text, key), CRYPT_CHAR_(text, key, 19)
+#define CRYPT_CHARS_21_(text, key) CRYPT_CHARS_20_(text, key), CRYPT_CHAR_(text, key, 20)
+#define CRYPT_CHARS_22_(text, key) CRYPT_CHARS_21_(text, key), CRYPT_CHAR_(text, key, 21)
+#define CRYPT_CHARS_23_(text, key) CRYPT_CHARS_22_(text, key), CRYPT_CHAR_(text, key, 22)
+#define CRYPT_CHARS_24_(text, key) CRYPT_CHARS_23_(text, key), CRYPT_CHAR_(text, key, 23)
+#define CRYPT_CHARS_25_(text, key) CRYPT_CHARS_24_(text, key), CRYPT_CHAR_(text, key, 24)
+#define CRYPT_CHARS_26_(text, key) CRYPT_CHARS_25_(text, key), CRYPT_CHAR_(text, key, 25)
+#define CRYPT_CHARS_27_(text, key) CRYPT_CHARS_26_(text, key), CRYPT_CHAR_(text, key, 26)
+#define CRYPT_CHARS_28_(text, key) CRYPT_CHARS_27_(text, key), CRYPT_CHAR_(text, key, 27)
+#define CRYPT_CHARS_29_(text, key) CRYPT_CHARS_28_(text, key), CRYPT_CHAR_(text, key, 28)
+#define CRYPT_CHARS_30_(text, key) CRYPT_CHARS_29_(text, key), CRYPT_CHAR_(text, key, 29)
+#define CRYPT_CHARS_31_(text, key) CRYPT_CHARS_30_(text, key), CRYPT_CHAR_(text, key, 30)
+#define CRYPT_CHARS_32_(text, key) CRYPT_CHARS_31_(text, key), CRYPT_CHAR_(text, key, 31)
+#define CRYPT_CHARS_33_(text, key) CRYPT_CHARS_32_(text, key), CRYPT_CHAR_(text, key, 32)
+#define CRYPT_CHARS_34_(text, key) CRYPT_CHARS_33_(text, key), CRYPT_CHAR_(text, key, 33)
+#define CRYPT_CHARS_35_(text, key) CRYPT_CHARS_34_(text, key), CRYPT_CHAR_(text, key, 34)
+#define CRYPT_CHARS_36_(text, key) CRYPT_CHARS_35_(text, key), CRYPT_CHAR_(text, key, 35)
+#define CRYPT_CHARS_37_(text, key) CRYPT_CHARS_36_(text, key), CRYPT_CHAR_(text, key, 36)
+#define CRYPT_CHARS_38_(text, key) CRYPT_CHARS_37_(text, key), CRYPT_CHAR_(text, key, 37)
+#define CRYPT_CHARS_39_(text, key) CRYPT_CHARS_38_(text, key), CRYPT_CHAR_(text, key, 38)
+#define CRYPT_CHARS_40_(text, key) CRYPT_CHARS_39_(text, key), CRYPT_CHAR_(text, key, 39)
+#define CRYPT_CHARS_41_(text, key) CRYPT_CHARS_40_(text, key), CRYPT_CHAR_(text, key, 40)
+#define CRYPT_CHARS_42_(text, key) CRYPT_CHARS_41_(text, key), CRYPT_CHAR_(text, key, 41)
+#define CRYPT_CHARS_43_(text, key) CRYPT_CHARS_42_(text, key), CRYPT_CHAR_(text, key, 42)
+#define CRYPT_CHARS_44_(text, key) CRYPT_CHARS_43_(text, key), CRYPT_CHAR_(text, key, 43)
+#define CRYPT_CHARS_45_(text, key) CRYPT_CHARS_44_(text, key), CRYPT_CHAR_(text, key, 44)
+#define CRYPT_CHARS_46_(text, key) CRYPT_CHARS_45_(text, key), CRYPT_CHAR_(text, key, 45)
+#define CRYPT_CHARS_47_(text, key) CRYPT_CHARS_46_(text, key), CRYPT_CHAR_(text, key, 46)
+#define CRYPT_CHARS_48_(text, key) CRYPT_CHARS_47_(text, key), CRYPT_CHAR_(text, key, 47)
+#define CRYPT_CHARS_49_(text, key) CRYPT_CHARS_48_(text, key), CRYPT_CHAR_(text, key, 48)
+#define CRYPT_CHARS_50_(text, key) CRYPT_CHARS_49_(text, key), CRYPT_CHAR_(text, key, 49)
+#define CRYPT_CHARS_51_(text, key) CRYPT_CHARS_50_(text, key), CRYPT_CHAR_(text, key, 50)
+#define CRYPT_CHARS_52_(text, key) CRYPT_CHARS_51_(text, key), CRYPT_CHAR_(text, key, 51)
+#define CRYPT_CHARS_53_(text, key) CRYPT_CHARS_52_(text, key), CRYPT_CHAR_(text, key, 52)
+#define CRYPT_CHARS_54_(text, key) CRYPT_CHARS_53_(text, key), CRYPT_CHAR_(text, key, 53)
+#define CRYPT_CHARS_55_(text, key) CRYPT_CHARS_54_(text, key), CRYPT_CHAR_(text, key, 54)
+#define CRYPT_CHARS_56_(text, key) CRYPT_CHARS_55_(text, key), CRYPT_CHAR_(text, key, 55)
+#define CRYPT_CHARS_57_(text, key) CRYPT_CHARS_56_(text, key), CRYPT_CHAR_(text, key, 56)
+#define CRYPT_CHARS_58_(text, key) CRYPT_CHARS_57_(text, key), CRYPT_CHAR_(text, key, 57)
+#define CRYPT_CHARS_59_(text, key) CRYPT_CHARS_58_(text, key), CRYPT_CHAR_(text, key, 58)
+#define CRYPT_CHARS_60_(text, key) CRYPT_CHARS_59_(text, key), CRYPT_CHAR_(text, key, 59)
+#define CRYPT_CHARS_61_(text, key) CRYPT_CHARS_60_(text, key), CRYPT_CHAR_(text, key, 60)
+#define CRYPT_CHARS_62_(text, key) CRYPT_CHARS_61_(text, key), CRYPT_CHAR_(text, key, 61)
+#define CRYPT_CHARS_63_(text, key) CRYPT_CHARS_62_(text, key), CRYPT_CHAR_(text, key, 62)
+#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)}
+
 #endif