using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Serialization.Formatters.Binary;
using System.Runtime.Versioning;
using System.Security.Cryptography;
using System.Text;
using System.Text.RegularExpressions;
using BepInEx;
using BepInEx.Logging;
using GameNetcodeStuff;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using TMPro;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.InputSystem;
using UnityEngine.InputSystem.Controls;
using UnityEngine.SceneManagement;
using UnityEngine.UI;
using UnityEngine.Video;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("RadiationIsCool")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("RadiationIsCool")]
[assembly: AssemblyCopyright("Copyright ©  2023")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("8ee335db-0cbe-470c-8fbc-69263f01b35a")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyVersion("1.0.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
public class TextureReplacer : MonoBehaviour
{
	public class SelectTexture
	{
		public string SelectName;

		public Dictionary<string, string> items;

		public SelectTexture(string name = "")
		{
			SelectName = name;
			items = new Dictionary<string, string>();
		}

		public bool IsExistItemKey(string itemkey)
		{
			return items.ContainsKey(itemkey);
		}
	}

	public static Dictionary<string, string> images = new Dictionary<string, string>();

	public static Dictionary<string, string> unique_keys = new Dictionary<string, string>();

	public static List<string> doCheckMD5_keys = new List<string>();

	public static List<int> checked_instanceID = new List<int>();

	public static bool need_clear_checked_instanceID = false;

	public static Dictionary<string, string> changed = new Dictionary<string, string>();

	public static int select_textures_index = -1;

	public static int? OldSceneId = null;

	public static int lastTextureCount = 0;

	public static bool DoDump = false;

	public static bool IsDoingDump = false;

	public TimeSpan LoopTimeLimit = new TimeSpan(0, 0, 0, 0, 1);

	public static DateTime? next_check = null;

	public static TimeSpan check_span = new TimeSpan(0, 0, 0, 2);

	public static List<SelectTexture> select_textures = new List<SelectTexture>();

	public static string imagesPath_str = "";

	public static string imagesDumpPath_str = "LCKR_Tex_Dump";

	public static string select_folder = "select";

	public static Texture2D[] Textures = (Texture2D[])(object)new Texture2D[0];

	public static int TextureIndex = -1;

	public static int TextureCount = -1;

	public static bool bOnDumping = false;

	public static char[] invalid = Path.GetInvalidFileNameChars();

	public static bool CanUseThread = true;

	public static bool DoingReplace = false;

	public static string toast_txt = "";

	public static DateTime? dtStartToast = null;

	internal static TextureReplacer Instance { get; private set; }

	public static string imagesPath { get; set; } = "";


	public static string imagesDumpPath { get; set; } = "";


	public static void Setup()
	{
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		//IL_000c: Expected O, but got Unknown
		GameObject val = new GameObject("TextureReplacer");
		Object.DontDestroyOnLoad((Object)(object)val);
		((Object)val).hideFlags = (HideFlags)61;
		Instance = val.AddComponent<TextureReplacer>();
		string directoryName = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
		imagesPath = Path.Combine(directoryName, imagesPath_str);
		imagesDumpPath = Path.Combine(directoryName, imagesDumpPath_str);
		getImages();
		Textures = (Texture2D[])(object)new Texture2D[0];
	}

	private static void getImages()
	{
		if (!Directory.Exists(imagesPath))
		{
			Directory.CreateDirectory(imagesPath);
		}
		try
		{
			images = new Dictionary<string, string>();
			unique_keys = new Dictionary<string, string>();
			doCheckMD5_keys = new List<string>();
			string[] files = Directory.GetFiles(imagesPath, "*.png", SearchOption.AllDirectories);
			Array.Sort(files);
			string[] array = files;
			foreach (string text in array)
			{
				string[] array2 = text.Split(new char[1] { Path.DirectorySeparatorChar });
				string select_str = string.Empty;
				if (array2.Count() > 5)
				{
					for (int j = 1; j < array2.Count(); j++)
					{
						if (array2[j - 1] == imagesPath_str && array2[j].ToLower() == select_folder && j + 2 < array2.Count())
						{
							select_str = array2[j + 1];
							break;
						}
					}
				}
				bool flag = false;
				string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(text);
				string text2 = fileNameWithoutExtension;
				if (!images.ContainsKey(fileNameWithoutExtension))
				{
					images.Add(fileNameWithoutExtension, text);
				}
				else
				{
					flag = true;
				}
				int num = fileNameWithoutExtension.LastIndexOf('_');
				if (num > 0)
				{
					text2 = fileNameWithoutExtension.Substring(0, num);
					bool flag2 = true;
					if (fileNameWithoutExtension.Length > num + 1 && fileNameWithoutExtension.Substring(num + 1).Length == 32)
					{
						flag2 = false;
						if (!doCheckMD5_keys.Contains(text2))
						{
							doCheckMD5_keys.Add(text2);
						}
					}
					if (flag2)
					{
						if (select_str == string.Empty)
						{
							if (!doCheckMD5_keys.Contains(text2))
							{
								if (unique_keys.ContainsKey(text2))
								{
									unique_keys.Remove(text2);
									doCheckMD5_keys.Add(text2);
								}
								else
								{
									unique_keys.Add(text2, text);
								}
							}
						}
						else if (!unique_keys.ContainsKey(text2))
						{
							unique_keys.Add(text2, text);
						}
					}
				}
				else if (select_str == string.Empty)
				{
					if (!doCheckMD5_keys.Contains(text2))
					{
						if (unique_keys.ContainsKey(text2))
						{
							unique_keys.Remove(text2);
							doCheckMD5_keys.Add(text2);
						}
						else
						{
							unique_keys.Add(text2, text);
						}
					}
				}
				else if (!unique_keys.ContainsKey(text2))
				{
					unique_keys.Add(text2, text);
				}
				if (!(select_str != string.Empty))
				{
					continue;
				}
				if (fileNameWithoutExtension.Length > num + 1 && fileNameWithoutExtension.Substring(num + 1).Length == 32)
				{
					text2 = fileNameWithoutExtension;
				}
				SelectTexture selectTexture = select_textures.Find((SelectTexture x) => x.SelectName == select_str);
				if (selectTexture == null)
				{
					select_textures.Add(new SelectTexture(select_str));
					selectTexture = select_textures.Find((SelectTexture x) => x.SelectName == select_str);
				}
				if (selectTexture != null && !selectTexture.IsExistItemKey(text2))
				{
					selectTexture.items[text2] = text;
					flag = false;
				}
			}
			if (select_textures.Count() > 0)
			{
				select_textures_index = 0;
				ChangeTextures(select_textures_index);
			}
		}
		catch (Exception ex)
		{
			Debug.LogError((object)ex);
		}
	}

	public static Texture2D duplicateTexture(Texture2D source)
	{
		//IL_003a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0040: Expected O, but got Unknown
		//IL_0059: Unknown result type (might be due to invalid IL or missing references)
		RenderTexture temporary = RenderTexture.GetTemporary(((Texture)source).width, ((Texture)source).height, 0, (RenderTextureFormat)0, (RenderTextureReadWrite)0, 1);
		RenderTexture active = RenderTexture.active;
		Graphics.Blit((Texture)(object)source, temporary);
		RenderTexture.active = temporary;
		Texture2D val = new Texture2D(((Texture)source).width, ((Texture)source).height, (TextureFormat)5, true);
		val.ReadPixels(new Rect(0f, 0f, (float)((Texture)temporary).width, (float)((Texture)temporary).height), 0, 0);
		val.Apply();
		RenderTexture.active = active;
		RenderTexture.ReleaseTemporary(temporary);
		return val;
	}

	private bool DumpFile(Texture2D tex, string tex_name)
	{
		bool result = false;
		string text = Path.Combine(imagesDumpPath, Application.loadedLevel.ToString());
		if (!Directory.Exists(text))
		{
			Directory.CreateDirectory(text);
		}
		bool flag = IsReadable(tex);
		string path = Path.Combine(text, tex_name + "_" + MakeCheckSum(tex, flag) + ".png");
		if (!File.Exists(path))
		{
			byte[] bytes;
			if (flag)
			{
				bytes = ImageConversion.EncodeToPNG(tex);
			}
			else
			{
				Texture2D val = duplicateTexture(tex);
				bytes = ImageConversion.EncodeToPNG(val);
				Object.DestroyImmediate((Object)(object)val);
			}
			File.WriteAllBytes(path, bytes);
			result = true;
		}
		return result;
	}

	private static string MakeCheckSum(Texture2D source, bool? Readable = null)
	{
		//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00fc: Expected O, but got Unknown
		//IL_0121: Unknown result type (might be due to invalid IL or missing references)
		//IL_0180: Unknown result type (might be due to invalid IL or missing references)
		//IL_0197: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
		MD5 mD = MD5.Create();
		if (!Readable.HasValue)
		{
			Readable = IsReadable(source);
		}
		if (Readable == true)
		{
			byte[] rawTextureData = source.GetRawTextureData();
			if (rawTextureData != null)
			{
				byte[] array = new byte[4];
				for (int i = 0; i < rawTextureData.Length; i += 16)
				{
					mD.TransformBlock(rawTextureData, i, 4, array, 0);
				}
				mD.TransformFinalBlock(array, 0, 0);
			}
		}
		if (Readable == false)
		{
			RenderTexture temporary = RenderTexture.GetTemporary(64, 64, 0, (RenderTextureFormat)7, (RenderTextureReadWrite)2);
			temporary.DiscardContents();
			RenderTexture active = RenderTexture.active;
			RenderTexture.active = temporary;
			((Texture)temporary).filterMode = (FilterMode)0;
			Graphics.Blit((Texture)(object)source, temporary);
			Texture2D val = new Texture2D(64, 64, (TextureFormat)5, false, false);
			((Texture)val).filterMode = (FilterMode)0;
			val.ReadPixels(new Rect(0f, 0f, (float)((Texture)temporary).width, (float)((Texture)temporary).height), 0, 0);
			val.Apply(true);
			RenderTexture.active = active;
			float[] array2 = new float[4];
			int[,] array3 = new int[3, 4096];
			float num = 6f;
			float[] array4 = new float[3];
			for (int j = 0; j < 64; j++)
			{
				for (int k = 0; k < 64; k++)
				{
					array4[0] = num * val.GetPixel(k, j).r;
					array4[1] = num * val.GetPixel(k, j).g;
					array4[2] = num * val.GetPixel(k, j).b;
					for (int l = 0; l < 3; l++)
					{
						array3[l, k * j] = (int)Math.Round(array4[l]);
						array2[l] += array4[l];
					}
				}
			}
			for (int m = 0; m < 3; m++)
			{
				if (array2[m] > 0f)
				{
					array2[m] /= 4096f;
				}
			}
			byte[] array5 = new byte[4096];
			for (int n = 0; n < 64; n++)
			{
				for (int num2 = 0; num2 < 64; num2++)
				{
					byte b = 0;
					if (array2[0] < (float)array3[0, num2 * n])
					{
						b = (byte)(b | 1u);
					}
					if (array2[1] < (float)array3[1, num2 * n])
					{
						b = (byte)(b | 2u);
					}
					if (array2[2] < (float)array3[2, num2 * n])
					{
						b = (byte)(b | 4u);
					}
					array5[num2 * n] = b;
				}
			}
			mD.ComputeHash(array5);
			Object.Destroy((Object)(object)val);
			RenderTexture.ReleaseTemporary(temporary);
		}
		string result = "";
		if (mD.Hash != null)
		{
			result = BitConverter.ToString(mD.Hash).Replace("-", "").ToLower();
		}
		return result;
	}

	private static bool IsReadable(Texture2D tex)
	{
		return false;
	}

	private static void ReplaceFile(Texture2D tex, string path)
	{
		ImageConversion.LoadImage(tex, File.ReadAllBytes(path));
	}

	private static string toValidFilename(string fileName)
	{
		char[] array = invalid;
		foreach (char oldChar in array)
		{
			fileName = fileName.Replace(oldChar, '_');
		}
		return fileName;
	}

	private static void ChangeTextures(int index)
	{
		foreach (KeyValuePair<string, string> item in select_textures[index].items)
		{
			if (images.ContainsKey(item.Key))
			{
				images[item.Key] = item.Value;
			}
			else if (unique_keys.ContainsKey(item.Key))
			{
				unique_keys[item.Key] = item.Value;
			}
		}
		TextureIndex = -1;
		need_clear_checked_instanceID = true;
	}

	private static byte[] ObjectToByteArray(object obj)
	{
		if (obj == null)
		{
			return null;
		}
		BinaryFormatter binaryFormatter = new BinaryFormatter();
		byte[] result;
		using (MemoryStream memoryStream = new MemoryStream())
		{
			binaryFormatter.Serialize(memoryStream, obj);
			result = memoryStream.ToArray();
		}
		return result;
	}

	public void OnGUI()
	{
		if (DoingReplace)
		{
			return;
		}
		if (((ButtonControl)Keyboard.current.upArrowKey).wasPressedThisFrame)
		{
			if (((ButtonControl)Keyboard.current.f11Key).wasPressedThisFrame && Keyboard.current.altKey.wasPressedThisFrame)
			{
				bOnDumping = !bOnDumping;
				toast_txt = "Dumping mode " + (bOnDumping ? "ON" : "OFF");
				dtStartToast = DateTime.Now;
				lastTextureCount = 0;
				TextureIndex = -1;
			}
			else if (select_textures_index > -1 && ((ButtonControl)Keyboard.current.f12Key).wasPressedThisFrame)
			{
				if (DoingReplace)
				{
					toast_txt = "In changing textures. please try later.";
				}
				else
				{
					select_textures_index = ((select_textures_index < select_textures.Count() - 1) ? (select_textures_index + 1) : 0);
					ChangeTextures(select_textures_index);
					toast_txt = "Change texture set to " + select_textures[select_textures_index].SelectName;
				}
				dtStartToast = DateTime.Now;
			}
		}
		if (dtStartToast.HasValue)
		{
			DateTime now = DateTime.Now;
			DateTime? dateTime = dtStartToast;
			if (now - dateTime > new TimeSpan(0, 0, 0, 2))
			{
				dtStartToast = null;
			}
		}
		int num = TextureIndex + 1;
		if (need_clear_checked_instanceID)
		{
			checked_instanceID.Clear();
			need_clear_checked_instanceID = false;
		}
		if (OldSceneId.HasValue && OldSceneId == Application.loadedLevel)
		{
			if (next_check.HasValue && TextureCount > 0 && TextureIndex >= 0 && TextureCount > TextureIndex)
			{
				DateTime now2 = DateTime.Now;
				if (TextureIndex >= TextureCount)
				{
					TextureIndex = TextureCount;
				}
				else if (!bOnDumping)
				{
					do
					{
						try
						{
							string text = toValidFilename(((Object)Textures[TextureIndex]).name);
							if (text.Length > 0 && ((Texture)Textures[TextureIndex]).width > 16 && ((Texture)Textures[TextureIndex]).height > 16)
							{
								int instanceID = ((Object)Textures[TextureIndex]).GetInstanceID();
								if (text.Length > 0 && checked_instanceID.IndexOf(instanceID) < 0)
								{
									checked_instanceID.Add(instanceID);
									if (unique_keys.ContainsKey(text))
									{
										ReplaceFile(Textures[TextureIndex], unique_keys[text]);
									}
									else if (doCheckMD5_keys.Contains(text))
									{
										string text2 = text + "_" + MakeCheckSum(Textures[TextureIndex]);
										if (select_textures_index > -1)
										{
											while (changed.ContainsKey(text2) && !(text2 == changed[text2]))
											{
												text2 = changed[text2];
											}
										}
										if (images.ContainsKey(text2))
										{
											ReplaceFile(Textures[TextureIndex], images[text2]);
											if (select_textures_index > -1)
											{
												changed.Add(text + "_" + MakeCheckSum(Textures[TextureIndex]), text2);
											}
										}
									}
								}
							}
						}
						catch (NullReferenceException)
						{
							TextureIndex = -2;
						}
						catch (Exception)
						{
						}
						TextureIndex++;
					}
					while (TextureIndex > -1 && TextureIndex < TextureCount && DateTime.Now - now2 < LoopTimeLimit);
				}
				else
				{
					if (IsDoingDump)
					{
						return;
					}
					if (lastTextureCount != TextureCount)
					{
						lastTextureCount = TextureCount;
						DoDump = true;
					}
					if (!DoDump)
					{
						return;
					}
					IsDoingDump = true;
					do
					{
						try
						{
							string text3 = toValidFilename(((Object)Textures[TextureIndex]).name);
							if (TextureIndex < TextureCount && text3.Length > 0 && ((Texture)Textures[TextureIndex]).width > 16 && ((Texture)Textures[TextureIndex]).height > 16)
							{
								int num2 = num * 100 / TextureCount;
								toast_txt = $"Checking {num} / {TextureCount} {text3} [{num2}%]";
								dtStartToast = DateTime.Now;
								if (DumpFile(Textures[TextureIndex], text3))
								{
									toast_txt = $"Dumped: {text3} [{num2}%]";
									dtStartToast = DateTime.Now;
								}
								else
								{
									toast_txt = $"Passed: {text3} [{num2}%]";
									dtStartToast = DateTime.Now;
								}
							}
						}
						catch (NullReferenceException)
						{
							TextureIndex = -2;
						}
						catch (Exception ex4)
						{
							Debug.LogError((object)ex4);
						}
						TextureIndex++;
						num = TextureIndex + 1;
					}
					while (TextureIndex > -1 && TextureIndex < TextureCount && DateTime.Now - now2 < LoopTimeLimit);
					if (TextureIndex >= TextureCount)
					{
						DoDump = false;
						toast_txt = "Scene dumping completed.";
						dtStartToast = DateTime.Now;
					}
					IsDoingDump = false;
				}
			}
			else if (!next_check.HasValue || next_check < DateTime.Now)
			{
				Textures = Resources.FindObjectsOfTypeAll<Texture2D>();
				if (Textures == null)
				{
					Textures = (Texture2D[])(object)new Texture2D[0];
				}
				TextureCount = Textures.Count();
				if (TextureCount > 0)
				{
					TextureIndex = 0;
				}
				next_check = DateTime.Now + check_span;
			}
		}
		else
		{
			lastTextureCount = 0;
			need_clear_checked_instanceID = true;
			next_check = null;
			OldSceneId = Application.loadedLevel;
		}
	}
}
public static class Const
{
	public const int ImageDiv = 16;

	public const int ImageCompareSize = 64;
}
namespace LCKorean
{
	[BepInPlugin("Piggy.LCKorean", "LCKorean", "1.3.10")]
	public class Plugin : BaseUnityPlugin
	{
		private const string modGUID = "Piggy.LCKorean";

		private const string modName = "LCKorean";

		private const string modVersion = "1.3.10";

		private readonly Harmony harmony = new Harmony("Piggy.LCKorean");

		private static Plugin Instance;

		public static ManualLogSource mls;

		public static AssetBundle Bundle;

		public static TMP_FontAsset font3270_HUDIngame;

		public static TMP_FontAsset font3270_HUDIngame_Variant;

		public static TMP_FontAsset font3270_HUDIngameB;

		public static TMP_FontAsset font3270_Regular_SDF;

		public static TMP_FontAsset font3270_b;

		public static TMP_FontAsset font3270_DialogueText;

		public static TMP_FontAsset fontEdunline;

		public static Texture2D artificeHint;

		public static Texture2D endgameAllPlayersDead;

		public static Texture2D endgameStatsBoxes;

		public static Texture2D endgameStatsDeceased;

		public static Texture2D endgameStatsMissing;

		public static Texture2D flashbangBottleTexture;

		public static Texture2D manual1;

		public static Texture2D manual2v2;

		public static Texture2D manual3v2;

		public static Texture2D manual4v2;

		public static Texture2D playerLevelStickers;

		public static Texture2D playerLevelStickers1;

		public static Texture2D posters;

		public static Texture2D TipsPoster2;

		public static Texture2D powerBoxTextures;

		public static Texture2D RedUIPanelGlitchBWarningRadiation;

		public static Texture2D RedUIPanelGlitchBWarningRadiationB;

		public static Texture2D RedUIPanelGlitchBWarningRadiationC;

		public static Texture2D RedUIPanelGlitchBWarningRadiationD;

		public static Texture2D StickyNoteTex;

		public static Texture2D yieldSignTex;

		public static Texture2D stopSignTex;

		public static VideoClip snareKorean;

		public static bool fullyKoreanMoons;

		public static string confirmString;

		public static string denyString;

		public static bool translateModdedContent;

		public static bool translatePlanet;

		public static bool patchFont;

		public static bool thumperTranslation;

		public static bool toKG;

		public static bool artificePronounce;

		public static string deathText;

		public static string quotaReached;

		public static string firedText;

		public static string sellText;

		public static string injuryText;

		public static string systemOnlineText;

		public static string allDead1;

		public static string allDead2;

		public static string autoTakeoff1;

		public static string autoTakeoff2;

		public static string midnightWarning;

		public static string PluginDirectory;

		private void Awake()
		{
			if ((Object)(object)Instance == (Object)null)
			{
				Instance = this;
			}
			PluginDirectory = ((BaseUnityPlugin)this).Info.Location;
			LoadAssets();
			TextureReplacer.Setup();
			patchFont = ((BaseUnityPlugin)this).Config.Bind<bool>("폰트", "폰트 변경", true, "기본값은 true입니다.\nFontPatcher 등 외부 폰트 모드를 사용하려면 이 값을 false로 설정하세요. false로 설정하면 본 모드에서 폰트를 변경하지 않습니다.").Value;
			fullyKoreanMoons = ((BaseUnityPlugin)this).Config.Bind<bool>("접근성", "터미널 카탈로그 한글 입력", false, "기본값은 false입니다.\n위성 카탈로그 \"MOONS\"나 상점 카탈로그 \"STORE\"같은 키워드를 \"위성\", \"상점\"으로 변경합니다.\n(help => 도움말, moons => 위성, store => 상점, bestiary => 도감, other => 기타, eject => 사출, sigurd는 그대로입니다.)").Value;
			confirmString = ((BaseUnityPlugin)this).Config.Bind<string>("접근성", "확정 키워드", "confirm", "기본값은 confirm입니다.\n컨펌 노드 (Confirm)를 설정합니다. *초성, 띄어쓰기와 한 글자는 인식하지 못합니다!*").Value;
			denyString = ((BaseUnityPlugin)this).Config.Bind<string>("접근성", "취소 키워드", "deny", "기본값은 deny입니다.\n디나이 노드 (Deny)를 설정합니다. *초성, 띄어쓰기와 한 글자는 인식하지 못합니다!*").Value;
			translateModdedContent = ((BaseUnityPlugin)this).Config.Bind<bool>("번역", "모드 번역", true, "기본값은 true입니다.\n다른 모드의 여러 컨텐츠(아이템, 행성)를 한글로 번역합니다.\n\n지원 모드:\nImmersiveScrap(XuXiaolan), ").Value;
			thumperTranslation = ((BaseUnityPlugin)this).Config.Bind<bool>("번역", "Thumper 번역", false, "기본값은 false입니다.\ntrue로 설정하면 \"Thumper\"를 썸퍼로 번역합니다. false로 설정하면 덤퍼로 설정됩니다.").Value;
			toKG = ((BaseUnityPlugin)this).Config.Bind<bool>("번역", "KG 변환", true, "기본값은 true입니다.\ntrue로 설정하면 무게 수치를 kg으로 변환합니다.").Value;
			deathText = ((BaseUnityPlugin)this).Config.Bind<string>("번역", "사망 텍스트", "[생명 신호: 오프라인]", "기본값은 《[생명 신호: 오프라인]》 입니다.\n사망 시 화면에 출력되는 텍스트를 수정합니다.").Value;
			quotaReached = ((BaseUnityPlugin)this).Config.Bind<string>("번역", "할당량 달성 텍스트", "할당량을 달성했습니다!", "기본값은 《할당량을 달성했습니다!》 입니다.\n할당량 달성 시 화면에 출력되는 텍스트를 수정합니다.").Value;
			firedText = ((BaseUnityPlugin)this).Config.Bind<string>("번역", "해고 텍스트", "해고당했습니다.", "기본값은 《해고당했습니다.》 입니다.\n해고 시 출력되는 텍스트를 수정합니다.").Value;
			sellText = ((BaseUnityPlugin)this).Config.Bind<string>("번역", "판매 텍스트", "급여를 받았습니다!", "기본값은 《급여를 받았습니다!》 입니다.\n아이템 판매 시 패널에 출력되는 텍스트를 수정합니다.").Value;
			injuryText = ((BaseUnityPlugin)this).Config.Bind<string>("번역", "치명적인 부상 텍스트", "치명적인 부상", "기본값은 《치명적인 부상》 입니다.\n치명적인 부상 발생 시 화면에 출력되는 텍스트를 수정합니다.").Value;
			systemOnlineText = ((BaseUnityPlugin)this).Config.Bind<string>("번역", "시스템 온라인 텍스트", "시스템 온라인", "기본값은 《시스템 온라인》 입니다.\n로비 접속 시 화면에 출력되는 텍스트를 수정합니다.").Value;
			allDead1 = ((BaseUnityPlugin)this).Config.Bind<string>("파일럿 컴퓨터 대사 번역", "전원 사망 1", "경고! 모든 팀원이 응답하지 않으며 함선에 돌아오지 않았습니다. 긴급 코드가 활성화되었습니다.", "기본값은\n《경고! 모든 팀원이 응답하지 않으며 함선에 돌아오지 않았습니다. 긴급 코드가 활성화되었습니다.》\n입니다.\n전원 사망 시 화면에 출력되는 텍스트를 수정합니다.").Value;
			allDead2 = ((BaseUnityPlugin)this).Config.Bind<string>("파일럿 컴퓨터 대사 번역", "전원 사망 2", "가까운 기지로 이동합니다. 모든 폐품을 분실했습니다.", "기본값은\n《가까운 기지로 이동합니다. 모든 폐품을 분실했습니다.》\n입니다.\n전원 사망 시 화면에 출력되는 텍스트를 수정합니다.").Value;
			autoTakeoff1 = ((BaseUnityPlugin)this).Config.Bind<string>("파일럿 컴퓨터 대사 번역", "자동 이륙1", "경고! 위험한 상황으로 인해 함선이 이륙하고 있습니다.", "기본값은\n《경고! 위험한 상황으로 인해 함선이 이륙하고 있습니다.》\n입니다.\n자동 이륙 시 화면에 출력되는 텍스트를 수정합니다.").Value;
			autoTakeoff2 = ((BaseUnityPlugin)this).Config.Bind<string>("파일럿 컴퓨터 대사 번역", "자동 이륙2", "회사는 독점 하드웨어에 대한 손상 위험을 최소화해야 합니다. 안녕히 계세요!", "기본값은\n《회사는 독점 하드웨어에 대한 손상 위험을 최소화해야 합니다. 안녕히 계세요!》\n입니다.\n자동 이륙 시 화면에 출력되는 텍스트를 수정합니다.").Value;
			midnightWarning = ((BaseUnityPlugin)this).Config.Bind<string>("파일럿 컴퓨터 대사 번역", "자정 경고", "경고!!! 함선이 자정에 이륙합니다. 빠르게 복귀하세요.", "기본값은\n《경고!!! 함선이 자정에 이륙합니다. 빠르게 복귀하세요.》\n입니다.\n자정 경고 시 화면에 출력되는 텍스트를 수정합니다.").Value;
			translatePlanet = ((BaseUnityPlugin)this).Config.Bind<bool>("개발자 기능", "행성 내부명(이름 아님!) 번역", false, "기본값은 false입니다.\n이 설정이 어떤 역할을 하는지 잘 모른다면 항상 비활성화 상태로 설정하세요! 타 모드와의 구성이 꼬여버릴 수 있습니다.\n코드에서 사용되는 행성의 내부 이름을 한글화합니다. 플레이에서 달라지는 부분은 없지만 true로 하면 모드 내부 맵의 구성을 변경할 때 행성 이름을 한글로 입력해야 합니다. false면 행성 이름을 영어로 입력하시면 됩니다.").Value;
			mls = Logger.CreateLogSource("Piggy.LCKorean");
			mls.LogInfo((object)"LC Korean is loaded");
			Harmony.CreateAndPatchAll(Assembly.GetExecutingAssembly(), (string)null);
		}

		private void LoadAssets()
		{
			try
			{
				Bundle = AssetBundle.LoadFromFile(Path.Combine(Path.GetDirectoryName(PluginDirectory), "lckorean"));
			}
			catch (Exception ex)
			{
				mls.LogError((object)("Couldn't load asset bundle: " + ex.Message));
				return;
			}
			try
			{
				font3270_HUDIngame = Bundle.LoadAsset<TMP_FontAsset>("3270-HUDIngame.asset");
				font3270_HUDIngame_Variant = Bundle.LoadAsset<TMP_FontAsset>("3270-HUDIngame - Variant.asset");
				font3270_HUDIngameB = Bundle.LoadAsset<TMP_FontAsset>("3270-HUDIngameB.asset");
				font3270_Regular_SDF = Bundle.LoadAsset<TMP_FontAsset>("3270-Regular SDF.asset");
				font3270_b = Bundle.LoadAsset<TMP_FontAsset>("b.asset");
				font3270_DialogueText = Bundle.LoadAsset<TMP_FontAsset>("DialogueText.asset");
				fontEdunline = Bundle.LoadAsset<TMP_FontAsset>("edunline SDF.asset");
				stopSignTex = Bundle.LoadAsset<Texture2D>("StopSignTex.png");
				yieldSignTex = Bundle.LoadAsset<Texture2D>("YieldSignTex.png");
				StickyNoteTex = Bundle.LoadAsset<Texture2D>("StickyNoteTex.png");
				artificeHint = Bundle.LoadAsset<Texture2D>("artificeHint.png");
				endgameAllPlayersDead = Bundle.LoadAsset<Texture2D>("endgameAllPlayersDead.png");
				endgameStatsBoxes = Bundle.LoadAsset<Texture2D>("endgameStatsBoxes.png");
				endgameStatsDeceased = Bundle.LoadAsset<Texture2D>("endgameStatsDeceased.png");
				endgameStatsMissing = Bundle.LoadAsset<Texture2D>("endgameStatsMissing.png");
				flashbangBottleTexture = Bundle.LoadAsset<Texture2D>("FlashbangBottleTexture.png");
				manual1 = Bundle.LoadAsset<Texture2D>("manual1.png");
				manual2v2 = Bundle.LoadAsset<Texture2D>("manual2v2.png");
				manual3v2 = Bundle.LoadAsset<Texture2D>("manual3v2.png");
				manual4v2 = Bundle.LoadAsset<Texture2D>("manual4v2.png");
				playerLevelStickers = Bundle.LoadAsset<Texture2D>("PlayerLevelStickers.png");
				playerLevelStickers1 = Bundle.LoadAsset<Texture2D>("PlayerLevelStickers 1.png");
				posters = Bundle.LoadAsset<Texture2D>("posters.png");
				TipsPoster2 = Bundle.LoadAsset<Texture2D>("TipsPoster2.png");
				powerBoxTextures = Bundle.LoadAsset<Texture2D>("powerBoxTextures.png");
				RedUIPanelGlitchBWarningRadiation = Bundle.LoadAsset<Texture2D>("RedUIPanelGlitchBWarningRadiation.png");
				RedUIPanelGlitchBWarningRadiationB = Bundle.LoadAsset<Texture2D>("RedUIPanelGlitchBWarningRadiationB.png");
				RedUIPanelGlitchBWarningRadiationC = Bundle.LoadAsset<Texture2D>("RedUIPanelGlitchBWarningRadiationC.png");
				RedUIPanelGlitchBWarningRadiationD = Bundle.LoadAsset<Texture2D>("RedUIPanelGlitchBWarningRadiationD.png");
				snareKorean = Bundle.LoadAsset<VideoClip>("SnareFleaTipChannel2.m4v");
				((BaseUnityPlugin)this).Logger.LogInfo((object)"Successfully loaded assets!");
			}
			catch (Exception ex2)
			{
				((BaseUnityPlugin)this).Logger.LogError((object)("Couldn't load assets: " + ex2.Message));
			}
		}

		private void ReplaceImageFile()
		{
			string location = Assembly.GetExecutingAssembly().Location;
			string directoryName = Path.GetDirectoryName(location);
			string text = "example.png";
			string text2 = Path.Combine(directoryName, text);
			if (!File.Exists(text2))
			{
				((BaseUnityPlugin)this).Logger.LogError((object)("이미지 파일이 " + text2 + "에 없습니다."));
				return;
			}
			string text3 = Path.Combine("게임_이미지_파일_경로", text);
			if (!File.Exists(text3))
			{
				((BaseUnityPlugin)this).Logger.LogError((object)("게임 내 이미지 파일이 " + text3 + "에 없습니다."));
				return;
			}
			try
			{
				File.Copy(text2, text3, overwrite: true);
				((BaseUnityPlugin)this).Logger.LogInfo((object)("이미지 파일 " + text + "이 " + text3 + "에 성공적으로 덮어쓰기되었습니다."));
			}
			catch (Exception ex)
			{
				((BaseUnityPlugin)this).Logger.LogError((object)("이미지 파일 덮어쓰기 중 오류 발생: " + ex.Message));
			}
		}
	}
}
namespace LCKorean.Patches
{
	public static class CoroutineManager
	{
		internal class CoroutineManagerBehaviour : MonoBehaviour
		{
		}

		private static MonoBehaviour _instance;

		private static MonoBehaviour instance
		{
			get
			{
				//IL_0016: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)_instance == (Object)null)
				{
					_instance = (MonoBehaviour)(object)new GameObject("CoroutineManager").AddComponent<CoroutineManagerBehaviour>();
				}
				return _instance;
			}
		}

		public static Coroutine StartCoroutine(IEnumerator routine)
		{
			return instance.StartCoroutine(routine);
		}
	}
	[HarmonyPatch(typeof(IngamePlayerSettings))]
	internal class IngamePlayerSettingsPatch
	{
		[HarmonyPrefix]
		[HarmonyPatch("SetSettingsOptionsText")]
		private static void SetSettingsOptionsText_Prefix(SettingsOptionType optionType, string setToText)
		{
			setToText = setToText.Replace("Current input device:", "현재 입력 장치:");
			setToText = setToText.Replace("No device found \n (click to refresh)", "장치 발견되지 않음 \n (클릭하여 새로고침)");
			setToText = setToText.Replace("MODE: Push to talk", "모드: 눌러서 말하기");
			setToText = setToText.Replace("MODE: Voice activation", "모드: 음성 감지");
		}
	}
	[HarmonyPatch(typeof(EntranceTeleport))]
	internal class EntranceTeleportPatch
	{
		[HarmonyPostfix]
		[HarmonyPatch("Update")]
		private static void Update_Postfix(EntranceTeleport __instance)
		{
			InteractTrigger component = ((Component)__instance).gameObject.GetComponent<InteractTrigger>();
			component.hoverTip = component.hoverTip.Replace("[Near activity detected!]", "[근처에서 활동이 감지되었습니다!]");
			component.hoverTip = component.hoverTip.Replace("Enter :", "들어가기 :");
		}
	}
	[HarmonyPatch(typeof(QuickMenuManager))]
	internal class QuickMenuManagerPatch
	{
		[HarmonyPrefix]
		[HarmonyPatch("Update")]
		private static void Update_Prefix(ref TextMeshProUGUI ___settingsBackButton)
		{
			if ((Object)(object)___settingsBackButton != (Object)null)
			{
				((TMP_Text)___settingsBackButton).text = ((TMP_Text)___settingsBackButton).text.Replace("Discard changes", "변경 사항 취소");
				((TMP_Text)___settingsBackButton).text = ((TMP_Text)___settingsBackButton).text.Replace("Back", "뒤로");
			}
		}
	}
	[HarmonyPatch(typeof(ShipTeleporter))]
	internal class ShipTeleporterPatch
	{
		[HarmonyPostfix]
		[HarmonyPatch("Update")]
		private static void Update_Postfix(ref InteractTrigger ___buttonTrigger)
		{
			___buttonTrigger.disabledHoverTip = ___buttonTrigger.disabledHoverTip.Replace("Cooldown", "재사용 대기 중");
			___buttonTrigger.disabledHoverTip = ___buttonTrigger.disabledHoverTip.Replace(" sec.", "초 남음.");
		}
	}
	[HarmonyPatch(typeof(ShotgunItem))]
	internal class ShotgunItemPatch
	{
		[HarmonyPostfix]
		[HarmonyPatch("SetSafetyControlTip")]
		private static void SetSafetyControlTip_Postfix(ShotgunItem __instance, ref bool ___safetyOn)
		{
			string text = ((!___safetyOn) ? "안전 모드 설정하기: [Q]" : "안전 모드 해제하기: [Q]");
			if (((NetworkBehaviour)__instance).IsOwner)
			{
				HUDManager.Instance.ChangeControlTip(3, text, false);
			}
		}
	}
	[HarmonyPatch(typeof(GameNetworkManager))]
	internal class GameNetworkManagerPatch
	{
		[HarmonyPrefix]
		[HarmonyPatch("SaveItemsInShip")]
		private static void SaveItemsInShip_Prefix()
		{
			try
			{
				UntranslateItem();
			}
			catch (Exception ex)
			{
				Plugin.mls.LogError((object)("아이템 번역을 해제하는 과정에서 오류가 발생했습니다!\n" + ex));
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch("SaveItemsInShip")]
		private static void SaveItemsInShip_Postfix()
		{
			try
			{
				TranslateItem();
			}
			catch (Exception ex)
			{
				Plugin.mls.LogError((object)("아이템을 재번역하는 과정에서 오류가 발생했습니다!\n" + ex));
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch("Disconnect")]
		private static void Disconnect_Postfix()
		{
			try
			{
				UntranslateItem();
			}
			catch (Exception ex)
			{
				Plugin.mls.LogError((object)("아이템을 재번역하는 과정에서 오류가 발생했습니다!\n" + ex));
			}
		}

		private static void UntranslateItem()
		{
			Plugin.mls.LogInfo((object)"Untranslating Items");
			foreach (Item items in StartOfRound.Instance.allItemsList.itemsList)
			{
				switch (items.itemName)
				{
				case "붐박스":
					items.itemName = "Boombox";
					break;
				case "손전등":
					items.itemName = "Flashlight";
					break;
				case "제트팩":
					items.itemName = "Jetpack";
					break;
				case "열쇠":
					items.itemName = "Key";
					break;
				case "자물쇠 따개":
					items.itemName = "Lockpicker";
					break;
				case "장치":
					items.itemName = "Apparatus";
					break;
				case "프로 손전등":
					items.itemName = "Pro-flashlight";
					break;
				case "철제 삽":
					items.itemName = "Shovel";
					break;
				case "기절 수류탄":
					items.itemName = "Stun grenade";
					break;
				case "연장형 사다리":
					items.itemName = "Extension ladder";
					break;
				case "TZP-흡입제":
					items.itemName = "TZP-Inhalant";
					break;
				case "무전기":
					items.itemName = "Walkie-talkie";
					break;
				case "잽건":
					items.itemName = "Zap gun";
					break;
				case "마법의 7번 공":
					items.itemName = "Magic 7 ball";
					break;
				case "에어혼":
					items.itemName = "Airhorn";
					break;
				case "종":
					items.itemName = "Bell";
					break;
				case "큰 나사":
					items.itemName = "Big bolt";
					break;
				case "병 묶음":
					items.itemName = "Bottles";
					break;
				case "빗":
					items.itemName = "Brush";
					break;
				case "사탕":
					items.itemName = "Candy";
					break;
				case "금전 등록기":
					items.itemName = "Cash register";
					break;
				case "화학 용기":
					items.itemName = "Chemical jug";
					break;
				case "광대 나팔":
					items.itemName = "Clown horn";
					break;
				case "대형 축":
					items.itemName = "Large axle";
					break;
				case "틀니":
					items.itemName = "Teeth";
					break;
				case "쓰레받기":
					items.itemName = "Dust pan";
					break;
				case "달걀 거품기":
					items.itemName = "Egg beater";
					break;
				case "V형 엔진":
					items.itemName = "V-type engine";
					break;
				case "황금 컵":
					items.itemName = "Golden cup";
					break;
				case "멋진 램프":
					items.itemName = "Fancy lamp";
					break;
				case "그림":
					items.itemName = "Painting";
					break;
				case "플라스틱 물고기":
					items.itemName = "Plastic fish";
					break;
				case "레이저 포인터":
					items.itemName = "Laser pointer";
					break;
				case "금 주괴":
					items.itemName = "Gold bar";
					break;
				case "헤어 드라이기":
					items.itemName = "Hairdryer";
					break;
				case "돋보기":
					items.itemName = "Magnifying glass";
					break;
				case "금속 판":
					items.itemName = "Metal sheet";
					break;
				case "쿠키 틀":
					items.itemName = "Cookie mold pan";
					break;
				case "머그잔":
					items.itemName = "Mug";
					break;
				case "향수 병":
					items.itemName = "Perfume bottle";
					break;
				case "구식 전화기":
					items.itemName = "Old phone";
					break;
				case "피클 병":
					items.itemName = "Jar of pickles";
					break;
				case "약 병":
					items.itemName = "Pill bottle";
					break;
				case "리모컨":
					items.itemName = "Remote";
					break;
				case "반지":
					items.itemName = "Ring";
					break;
				case "장난감 로봇":
					items.itemName = "Toy robot";
					break;
				case "고무 오리":
					items.itemName = "Rubber Ducky";
					break;
				case "빨간색 소다":
					items.itemName = "Red soda";
					break;
				case "운전대":
					items.itemName = "Steering wheel";
					break;
				case "정지 표지판":
					items.itemName = "Stop sign";
					break;
				case "찻주전자":
					items.itemName = "Tea kettle";
					break;
				case "치약":
					items.itemName = "Toothpaste";
					break;
				case "장난감 큐브":
					items.itemName = "Toy cube";
					break;
				case "벌집":
					items.itemName = "Hive";
					break;
				case "레이더 부스터":
					items.itemName = "Radar-booster";
					break;
				case "양보 표지판":
					items.itemName = "Yield sign";
					break;
				case "산탄총":
					items.itemName = "Shotgun";
					break;
				case "탄약":
					items.itemName = "Ammo";
					break;
				case "페인트 스프레이":
					items.itemName = "Spray paint";
					break;
				case "사제 섬광탄":
					items.itemName = "Homemade flashbang";
					break;
				case "선물":
					items.itemName = "Gift";
					break;
				case "플라스크":
					items.itemName = "Flask";
					break;
				case "비극":
					items.itemName = "Tragedy";
					break;
				case "희극":
					items.itemName = "Comedy";
					break;
				case "방귀 쿠션":
					items.itemName = "Whoopie cushion";
					break;
				case "식칼":
					items.itemName = "Kitchen knife";
					break;
				case "부활절 달걀":
					items.itemName = "Easter egg";
					break;
				}
			}
		}

		private static void UntranslateModdedItem()
		{
			Plugin.mls.LogInfo((object)"Untranslating Modded Items");
			foreach (Item items in StartOfRound.Instance.allItemsList.itemsList)
			{
				switch (items.itemName)
				{
				case "알코올 플라스크":
					items.itemName = "Alcohol Flask";
					break;
				case "모루":
					items.itemName = "Anvil";
					break;
				case "야구 방망이":
					items.itemName = "Baseball bat";
					break;
				case "맥주 캔":
					items.itemName = "Beer can";
					break;
				case "벽돌":
					items.itemName = "Brick";
					break;
				case "망가진 엔진":
					items.itemName = "Broken engine";
					break;
				case "양동이":
					items.itemName = "Bucket";
					break;
				case "페인트 캔":
					items.itemName = "Can paint";
					break;
				case "수통":
					items.itemName = "Canteen";
					break;
				case "자동차 배터리":
					items.itemName = "Car battery";
					break;
				case "조임틀":
					items.itemName = "Clamp";
					break;
				case "시계":
					items.itemName = "Clock";
					break;
				case "멋진 그림":
					items.itemName = "Fancy Painting";
					break;
				case "선풍기":
					items.itemName = "Fan";
					break;
				case "소방 도끼":
					items.itemName = "Fireaxe";
					break;
				case "소화기":
					items.itemName = "Fire extinguisher";
					break;
				case "소화전":
					items.itemName = "Fire hydrant";
					break;
				case "통조림":
					items.itemName = "Food can";
					break;
				case "게임보이":
					items.itemName = "Gameboy";
					break;
				case "쓰레기":
					items.itemName = "Garbage";
					break;
				case "망치":
					items.itemName = "Hammer";
					break;
				case "기름통":
					items.itemName = "Jerrycan";
					break;
				case "키보드":
					items.itemName = "Keyboard";
					break;
				case "랜턴":
					items.itemName = "Lantern";
					break;
				case "도서관 램프":
					items.itemName = "Library lamp";
					break;
				case "식물":
					items.itemName = "Plant";
					break;
				case "플라이어":
					items.itemName = "Pliers";
					break;
				case "뚫어뻥":
					items.itemName = "Plunger";
					break;
				case "레트로 장난감":
					items.itemName = "Retro Toy";
					break;
				case "스크류 드라이버":
					items.itemName = "Screwdriver";
					break;
				case "싱크대":
					items.itemName = "Sink";
					break;
				case "소켓 렌치":
					items.itemName = "Socket Wrench";
					break;
				case "고무 오리":
					items.itemName = "Squeaky toy";
					break;
				case "여행 가방":
					items.itemName = "Suitcase";
					break;
				case "토스터기":
					items.itemName = "Toaster";
					break;
				case "공구 상자":
					items.itemName = "Toolbox";
					break;
				case "실크햇":
					items.itemName = "Top hat";
					break;
				case "라바콘":
					items.itemName = "Traffic cone";
					break;
				case "환풍구":
					items.itemName = "Vent";
					break;
				case "물뿌리개":
					items.itemName = "Watering Can";
					break;
				case "바퀴":
					items.itemName = "Wheel";
					break;
				case "와인 병":
					items.itemName = "Wine bottle";
					break;
				case "렌치":
					items.itemName = "Wrench";
					break;
				case "주사기":
					items.itemName = "Syringe";
					break;
				case "주사기총":
					items.itemName = "Syringe Gun";
					break;
				case "코너 파이프":
					items.itemName = "Corner Pipe";
					break;
				case "작은 파이프":
					items.itemName = "Small Pipe";
					break;
				case "파이프":
					items.itemName = "Flow Pipe";
					break;
				case "뇌가 담긴 병":
					items.itemName = "Brain Jar";
					break;
				case "호두까기 인형 장난감":
					items.itemName = "Toy Nutcracker";
					break;
				case "시험관":
					items.itemName = "Test Tube";
					break;
				case "시험관 랙":
					items.itemName = "Test Tube Rack";
					break;
				case "호두까기 인형 눈":
					items.itemName = "Nutcracker Eye";
					break;
				case "파란색 시험관":
					items.itemName = "Blue Test Tube";
					break;
				case "노란색 시험관":
					items.itemName = "Yellow Test Tube";
					break;
				case "빨간색 시험관":
					items.itemName = "Red Test Tube";
					break;
				case "초록색 시험관":
					items.itemName = "Green Test Tube";
					break;
				case "쇠지렛대":
					items.itemName = "Crowbar";
					break;
				case "플젠":
					items.itemName = "Plzen";
					break;
				case "컵":
					items.itemName = "Cup";
					break;
				case "전자레인지":
					items.itemName = "Microwave";
					break;
				case "비눗방울 총":
					items.itemName = "bubblegun";
					break;
				case "망가진 P88":
					items.itemName = "Broken P88";
					break;
				case "직원":
					items.itemName = "employee";
					break;
				case "지뢰":
					items.itemName = "Mine";
					break;
				case "탄약 상자":
					items.itemName = "Ammo crate";
					break;
				case "음료수":
					items.itemName = "Drink";
					break;
				case "라디오":
					items.itemName = "Radio";
					break;
				case "마우스":
					items.itemName = "Mouse";
					break;
				case "모니터":
					items.itemName = "Monitor";
					break;
				case "건전지":
					items.itemName = "Battery";
					break;
				case "대포":
					items.itemName = "Cannon";
					break;
				case "건강 음료":
					items.itemName = "Health Drink";
					break;
				case "화학 약품":
					items.itemName = "Chemical";
					break;
				case "소독용 알코올":
					items.itemName = "Disinfecting Alcohol";
					break;
				case "앰풀":
					items.itemName = "Ampoule";
					break;
				case "혈액 팩":
					items.itemName = "Blood Pack";
					break;
				case "라이터":
					items.itemName = "Flip Lighter";
					break;
				case "고무 공":
					items.itemName = "Rubber Ball";
					break;
				case "비디오 테이프":
					items.itemName = "Video Tape";
					break;
				case "구급 상자":
					items.itemName = "First Aid Kit";
					break;
				case "금메달":
					items.itemName = "Gold Medallion";
					break;
				case "금속 파이프":
					items.itemName = "Steel Pipe";
					break;
				case "도끼":
					items.itemName = "Axe";
					break;
				case "비상용 망치":
					items.itemName = "Emergency Hammer";
					break;
				case "카타나":
					items.itemName = "Katana";
					break;
				case "은메달":
					items.itemName = "Silver Medallion";
					break;
				case "휴대용 라디오":
					items.itemName = "Pocket Radio";
					break;
				case "곰 인형":
					items.itemName = "Teddy Plush";
					break;
				case "Hyper Acid 실험 기록":
					items.itemName = "Experiment Log Hyper Acid";
					break;
				case "희극 가면 실험 기록":
					items.itemName = "Experiment Log Comedy Mask";
					break;
				case "저주받은 동전 실험 기록":
					items.itemName = "Experiment Log Cursed Coin";
					break;
				case "바이오 HXNV7 실험 기록":
					items.itemName = "Experiment Log BIO HXNV7";
					break;
				case "파란색 폴더":
					items.itemName = "Blue Folder";
					break;
				case "빨간색 폴더":
					items.itemName = "Red Folder";
					break;
				case "코일":
					items.itemName = "Coil";
					break;
				case "타자기":
					items.itemName = "Typewriter";
					break;
				case "서류 더미":
					items.itemName = "Documents";
					break;
				case "스테이플러":
					items.itemName = "Stapler";
					break;
				case "구식 컴퓨터":
					items.itemName = "Old Computer";
					break;
				case "브론즈 트로피":
					items.itemName = "Bronze Trophy";
					break;
				case "바나나":
					items.itemName = "Banana";
					break;
				case "스턴봉":
					items.itemName = "Stun Baton";
					break;
				case "바이오-HXNV7":
					items.itemName = "BIO-HXNV7";
					break;
				case "복구된 비밀 일지":
					items.itemName = "Recovered Secret Log";
					break;
				case "황금 단검 실험 기록":
					items.itemName = "Experiment Log Golden Dagger";
					break;
				case "대합":
					items.itemName = "Clam";
					break;
				case "거북이 등딱지":
					items.itemName = "Turtle Shell";
					break;
				case "생선 뼈":
					items.itemName = "Fish Bones";
					break;
				case "뿔 달린 껍질":
					items.itemName = "Horned Shell";
					break;
				case "도자기 찻잔":
					items.itemName = "Porcelain Teacup";
					break;
				case "대리석":
					items.itemName = "Marble";
					break;
				case "도자기 병":
					items.itemName = "Porcelain Bottle";
					break;
				case "도자기 향수 병":
					items.itemName = "Porcelain Perfume Bottle";
					break;
				case "발광구":
					items.itemName = "Glowing Orb";
					break;
				case "황금 해골":
					items.itemName = "Golden Skull";
					break;
				case "코스모코스 지도":
					items.itemName = "Map of Cosmocos";
					break;
				case "젖은 노트 1":
					items.itemName = "Wet Note 1";
					break;
				case "젖은 노트 2":
					items.itemName = "Wet Note 2";
					break;
				case "젖은 노트 3":
					items.itemName = "Wet Note 3";
					break;
				case "젖은 노트 4":
					items.itemName = "Wet Note 4";
					break;
				case "우주빛 파편":
					items.itemName = "Cosmic Shard";
					break;
				case "우주 생장물":
					items.itemName = "Cosmic Growth";
					break;
				case "천상의 두뇌 덩어리":
					items.itemName = "Chunk of Celestial Brain";
					break;
				case "파편이 든 양동이":
					items.itemName = "Bucket of Shards";
					break;
				case "우주빛 손전등":
					items.itemName = "Cosmic Flashlight";
					break;
				case "잊혀진 일지 1":
					items.itemName = "Forgotten Log 1";
					break;
				case "잊혀진 일지 2":
					items.itemName = "Forgotten Log 2";
					break;
				case "잊혀진 일지 3":
					items.itemName = "Forgotten Log 3";
					break;
				case "안경":
					items.itemName = "Glasses";
					break;
				case "생장한 배양 접시":
					items.itemName = "Grown Petri Dish";
					break;
				case "배양 접시":
					items.itemName = "Petri Dish";
					break;
				case "코스모채드":
					items.itemName = "Cosmochad";
					break;
				case "죽어가는 우주빛 손전등":
					items.itemName = "Dying Cosmic Flashlight";
					break;
				case "죽어가는 우주 생장물":
					items.itemName = "Dying Cosmic Growth";
					break;
				case "혈액 배양 접시":
					items.itemName = "Blood Petri Dish";
					break;
				case "악마 코스모채드":
					items.itemName = "Evil Cosmochad";
					break;
				case "악마 코스모":
					items.itemName = "Evil Cosmo";
					break;
				case "릴 코스모":
					items.itemName = "Lil Cosmo";
					break;
				case "죽어가는 생장물 배양 접시":
					items.itemName = "Dying Grown Petri Dish";
					break;
				case "감시하는 배양 접시":
					items.itemName = "Watching Petri Dish";
					break;
				case "현미경":
					items.itemName = "Microscope";
					break;
				case "원통형 바일":
					items.itemName = "Round Vile";
					break;
				case "사각형 바일":
					items.itemName = "Square Vile";
					break;
				case "타원형 바일":
					items.itemName = "Oval Vile";
					break;
				case "해링턴 일지 1":
					items.itemName = "Harrington Log 1";
					break;
				case "해링턴 일지 2":
					items.itemName = "Harrington Log 2";
					break;
				case "해링턴 일지 3":
					items.itemName = "Harrington Log 3";
					break;
				case "해링턴 일지 4":
					items.itemName = "Harrington Log 4";
					break;
				case "생장물이 든 병":
					items.itemName = "Jar of Growth";
					break;
				case "테이프 플레이어 일지 1":
					items.itemName = "Tape Player Log 1";
					break;
				case "테이프 플레이어 일지 2":
					items.itemName = "Tape Player Log 2";
					break;
				case "테이프 플레이어 일지 3":
					items.itemName = "Tape Player Log 3";
					break;
				case "테이프 플레이어 일지 4":
					items.itemName = "Tape Player Log 4";
					break;
				}
			}
		}

		private static void TranslateItem()
		{
			Plugin.mls.LogInfo((object)"Translating Items");
			foreach (Item items in StartOfRound.Instance.allItemsList.itemsList)
			{
				switch (items.itemName)
				{
				case "Boombox":
					items.itemName = "붐박스";
					items.toolTips[0] = "음악 전환하기 : [RMB]";
					break;
				case "Flashlight":
					items.itemName = "손전등";
					items.toolTips[0] = "전등 전환하기 : [RMB]";
					break;
				case "Jetpack":
					items.itemName = "제트팩";
					items.toolTips[0] = "제트팩 사용하기 : [RMB]";
					break;
				case "Key":
					items.itemName = "열쇠";
					items.toolTips[0] = "열쇠 사용하기 : [RMB]";
					break;
				case "Lockpicker":
					items.itemName = "자물쇠 따개";
					items.toolTips[0] = "문에 설치하기 : [RMB]";
					break;
				case "Apparatus":
					items.itemName = "장치";
					break;
				case "Pro-flashlight":
					items.itemName = "프로 손전등";
					items.toolTips[0] = "전등 전환하기 : [RMB]";
					break;
				case "Shovel":
					items.itemName = "철제 삽";
					items.toolTips[0] = "삽 휘두르기: [RMB]";
					break;
				case "Stun grenade":
					items.itemName = "기절 수류탄";
					items.toolTips[0] = "수류탄 사용하기 : [RMB]";
					break;
				case "Extension ladder":
					items.itemName = "연장형 사다리";
					items.toolTips[0] = "사다리 꺼내기 : [RMB]";
					break;
				case "TZP-Inhalant":
					items.itemName = "TZP-흡입제";
					items.toolTips[0] = "TZP 흡입하기 : [RMB]";
					break;
				case "Walkie-talkie":
					items.itemName = "무전기";
					items.toolTips[0] = "전원 버튼 : [Q]";
					items.toolTips[1] = "목소리 송신하기 : [RMB]";
					break;
				case "Zap gun":
					items.itemName = "잽건";
					items.toolTips[0] = "위협 감지하기 : [RMB]";
					break;
				case "Magic 7 ball":
					items.itemName = "마법의 7번 공";
					break;
				case "Airhorn":
					items.itemName = "에어혼";
					items.toolTips[0] = "에어혼 사용하기 : [RMB]";
					break;
				case "Bell":
					items.itemName = "종";
					break;
				case "Big bolt":
					items.itemName = "큰 나사";
					break;
				case "Bottles":
					items.itemName = "병 묶음";
					break;
				case "Brush":
					items.itemName = "빗";
					break;
				case "Candy":
					items.itemName = "사탕";
					break;
				case "Cash register":
					items.itemName = "금전 등록기";
					items.toolTips[0] = "금전 등록기 사용하기 : [RMB]";
					break;
				case "Chemical jug":
					items.itemName = "화학 용기";
					break;
				case "Clown horn":
					items.itemName = "광대 나팔";
					items.toolTips[0] = "광대 나팔 사용하기 : [RMB]";
					break;
				case "Large axle":
					items.itemName = "대형 축";
					break;
				case "Teeth":
					items.itemName = "틀니";
					break;
				case "Dust pan":
					items.itemName = "쓰레받기";
					break;
				case "Egg beater":
					items.itemName = "달걀 거품기";
					break;
				case "V-type engine":
					items.itemName = "V형 엔진";
					break;
				case "Golden cup":
					items.itemName = "황금 컵";
					break;
				case "Fancy lamp":
					items.itemName = "멋진 램프";
					break;
				case "Painting":
					items.itemName = "그림";
					break;
				case "Plastic fish":
					items.itemName = "플라스틱 물고기";
					break;
				case "Laser pointer":
					items.itemName = "레이저 포인터";
					items.toolTips[0] = "레이저 전환하기 : [RMB]";
					break;
				case "Gold bar":
					items.itemName = "금 주괴";
					break;
				case "Hairdryer":
					items.itemName = "헤어 드라이기";
					items.toolTips[0] = "헤어 드라이기 사용하기 : [RMB]";
					break;
				case "Magnifying glass":
					items.itemName = "돋보기";
					break;
				case "Metal sheet":
					items.itemName = "금속 판";
					break;
				case "Cookie mold pan":
					items.itemName = "쿠키 틀";
					break;
				case "Mug":
					items.itemName = "머그잔";
					break;
				case "Perfume bottle":
					items.itemName = "향수 병";
					break;
				case "Old phone":
					items.itemName = "구식 전화기";
					break;
				case "Jar of pickles":
					items.itemName = "피클 병";
					break;
				case "Pill bottle":
					items.itemName = "약 병";
					break;
				case "Remote":
					items.itemName = "리모컨";
					items.toolTips[0] = "리모컨 사용하기 : [RMB]";
					break;
				case "Ring":
					items.itemName = "반지";
					break;
				case "Toy robot":
					items.itemName = "장난감 로봇";
					break;
				case "Rubber Ducky":
					items.itemName = "고무 오리";
					break;
				case "Red soda":
					items.itemName = "빨간색 소다";
					break;
				case "Steering wheel":
					items.itemName = "운전대";
					break;
				case "Stop sign":
					items.itemName = "정지 표지판";
					items.toolTips[0] = "표지판 사용하기 : [RMB]";
					break;
				case "Tea kettle":
					items.itemName = "찻주전자";
					break;
				case "Toothpaste":
					items.itemName = "치약";
					break;
				case "Toy cube":
					items.itemName = "장난감 큐브";
					break;
				case "Hive":
					items.itemName = "벌집";
					break;
				case "Radar-booster":
					items.itemName = "레이더 부스터";
					items.toolTips[0] = "부스터 켜기 : [RMB]";
					break;
				case "Yield sign":
					items.itemName = "양보 표지판";
					items.toolTips[0] = "표지판 사용하기 : [RMB]";
					break;
				case "Shotgun":
					items.itemName = "산탄총";
					items.toolTips[0] = "격발 : [RMB]";
					items.toolTips[1] = "재장전 : [E]";
					items.toolTips[2] = "안전 모드 해제 : [Q]";
					break;
				case "Ammo":
					items.itemName = "탄약";
					break;
				case "Spray paint":
					items.itemName = "페인트 스프레이";
					items.toolTips[0] = "스프레이 뿌리기 : [RMB]";
					items.toolTips[1] = "캔 흔들기 : [Q]";
					break;
				case "Homemade flashbang":
					items.itemName = "사제 섬광탄";
					items.toolTips[0] = "사제 섬광탄 사용하기 : [RMB]";
					break;
				case "Gift":
					items.itemName = "선물";
					items.toolTips[0] = "선물 열기 : [RMB]";
					break;
				case "Flask":
					items.itemName = "플라스크";
					break;
				case "Tragedy":
					items.itemName = "비극";
					items.toolTips[0] = "가면 쓰기 : [RMB]";
					break;
				case "Comedy":
					items.itemName = "희극";
					items.toolTips[0] = "가면 쓰기 : [RMB]";
					break;
				case "Whoopie cushion":
					items.itemName = "방귀 쿠션";
					break;
				case "Kitchen knife":
					items.itemName = "식칼";
					items.toolTips[0] = "찌르기 : [RMB]";
					break;
				case "Easter egg":
					items.itemName = "부활절 달걀";
					break;
				}
			}
		}
	}
	[HarmonyPatch(typeof(StunGrenadeItem))]
	internal class StunGrenadeItemPatch
	{
		[HarmonyPostfix]
		[HarmonyPatch("SetControlTipForGrenade")]
		private static void SetControlTipForGrenade_Postfix()
		{
		}
	}
	[HarmonyPatch]
	internal class FontLoader
	{
		[HarmonyPrefix]
		[HarmonyPatch(typeof(TextMeshProUGUI), "Awake")]
		private static void PatchTextAwake(TextMeshProUGUI __instance)
		{
			if ((Object)(object)((TMP_Text)__instance).font == (Object)null || !Plugin.patchFont)
			{
				return;
			}
			string name = ((Object)((TMP_Text)__instance).font).name;
			switch (name)
			{
			case "3270-HUDIngame":
				((TMP_Text)__instance).font = Plugin.font3270_HUDIngame;
				break;
			case "3270-HUDIngame - Variant":
				if (((Object)((Component)__instance).gameObject).name == "BodyText" && ((Object)((Component)((TMP_Text)__instance).transform.parent.parent).gameObject).name == "GlobalNotification")
				{
					((TMP_Asset)((TMP_Text)__instance).font).material = ((TMP_Asset)Plugin.font3270_HUDIngame_Variant).material;
					((TMP_Text)__instance).fontSize = ((TMP_Text)__instance).fontSize - 0.2f;
					((TMP_Text)__instance).characterSpacing = -3.5f;
					((TMP_Text)__instance).font.fallbackFontAssetTable.Add(Plugin.font3270_HUDIngame_Variant);
				}
				break;
			case "3270-HUDIngameB":
				((TMP_Text)__instance).font = Plugin.font3270_HUDIngameB;
				break;
			case "3270-Regular SDF":
				((TMP_Text)__instance).font = Plugin.font3270_Regular_SDF;
				break;
			case "b":
				((TMP_Text)__instance).font = Plugin.font3270_b;
				break;
			case "DialogueText":
				((TMP_Text)__instance).font = Plugin.font3270_DialogueText;
				break;
			default:
				if (name.Contains("edunline"))
				{
					((TMP_Text)__instance).font = Plugin.fontEdunline;
				}
				break;
			}
		}

		private static void DisableFont(TMP_FontAsset font)
		{
			font.characterLookupTable.Clear();
			font.atlasPopulationMode = (AtlasPopulationMode)0;
		}
	}
	[HarmonyPatch(typeof(PlayerControllerB))]
	internal class PlayerControllerBPatch
	{
		[HarmonyPostfix]
		[HarmonyPatch("SetHoverTipAndCurrentInteractTrigger")]
		private static void SetHoverTipAndCurrentInteractTrigger_Postfix(ref TextMeshProUGUI ___cursorTip)
		{
			((TMP_Text)___cursorTip).text = ((TMP_Text)___cursorTip).text.Replace("Inventory full!", "인벤토리 가득 참!");
			((TMP_Text)___cursorTip).text = ((TMP_Text)___cursorTip).text.Replace("(Cannot hold until ship has landed)", "(함선이 착륙하기 전까지 집을 수 없음)");
			((TMP_Text)___cursorTip).text = ((TMP_Text)___cursorTip).text.Replace("[Hands full]", "[양 손 사용 중]");
			((TMP_Text)___cursorTip).text = ((TMP_Text)___cursorTip).text.Replace("Grab", "줍기");
			((TMP_Text)___cursorTip).text = ((TMP_Text)___cursorTip).text.Replace("Locked", "잠김");
			((TMP_Text)___cursorTip).text = ((TMP_Text)___cursorTip).text.Replace("Picking lock", "자물쇠 따는 중");
			((TMP_Text)___cursorTip).text = ((TMP_Text)___cursorTip).text.Replace(" sec.", "초 남음.");
			((TMP_Text)___cursorTip).text = ((TMP_Text)___cursorTip).text.Replace("Use door", "문 사용하기");
		}

		[HarmonyPostfix]
		[HarmonyPatch("SpawnDeadBody")]
		private static void SpawnDeadBody_Postfix()
		{
			DeadBodyInfo[] array = Object.FindObjectsOfType<DeadBodyInfo>();
			DeadBodyInfo[] array2 = array;
			foreach (DeadBodyInfo val in array2)
			{
				ScanNodeProperties componentInChildren = ((Component)val).gameObject.GetComponentInChildren<ScanNodeProperties>();
				if (!componentInChildren.headerText.Contains("의 시체"))
				{
					componentInChildren.headerText = componentInChildren.headerText.Replace("Body of ", "");
					componentInChildren.headerText += "의 시체";
				}
				componentInChildren.subText = componentInChildren.subText.Replace("Cause of death: ", "사인:");
				componentInChildren.subText = componentInChildren.subText.Replace("Unknown", "알 수 없음");
				componentInChildren.subText = componentInChildren.subText.Replace("Bludgeoning", "구타");
				componentInChildren.subText = componentInChildren.subText.Replace("Gravity", "중력");
				componentInChildren.subText = componentInChildren.subText.Replace("Blast", "폭사");
				componentInChildren.subText = componentInChildren.subText.Replace("Kicking", "걷어차임");
				componentInChildren.subText = componentInChildren.subText.Replace("Strangulation", "교살");
				componentInChildren.subText = componentInChildren.subText.Replace("Suffocation", "질식");
				componentInChildren.subText = componentInChildren.subText.Replace("Mauling", "공격당함");
				componentInChildren.subText = componentInChildren.subText.Replace("Gunshots", "총격");
				componentInChildren.subText = componentInChildren.subText.Replace("Crushing", "압사");
				componentInChildren.subText = componentInChildren.subText.Replace("Drowning", "익사");
				componentInChildren.subText = componentInChildren.subText.Replace("Abandoned", "실종");
				componentInChildren.subText = componentInChildren.subText.Replace("Electrocution", "감전사");
				componentInChildren.subText = componentInChildren.subText.Replace("Burning", "불탐");
				componentInChildren.subText = componentInChildren.subText.Replace("Stabbing", "찔림");
				componentInChildren.subText = componentInChildren.subText.Replace("Fan", "환풍기");
				componentInChildren.subText = componentInChildren.subText.Replace("Inertia", "관성");
				componentInChildren.subText = componentInChildren.subText.Replace("Snipped", "절단됨");
			}
		}
	}
	[HarmonyPatch(typeof(GrabbableObject))]
	internal class GrabbableObjectPatch
	{
		[HarmonyPostfix]
		[HarmonyPatch("Start")]
		private static void Start_Postfix(GrabbableObject __instance, ref Item ___itemProperties)
		{
			if (___itemProperties.itemName == "clipboard")
			{
				___itemProperties.itemName = "클립보드";
				___itemProperties.toolTips[0] = "자세히 보기: [Z]";
				___itemProperties.toolTips[1] = "페이지 넘기기 : [Q/E]";
			}
			else if (___itemProperties.itemName == "Sticky note")
			{
				___itemProperties.itemName = "스티커 메모";
				___itemProperties.toolTips[0] = "자세히 보기: [Z]";
			}
		}
	}
	[HarmonyPatch(typeof(RoundManager))]
	internal class RoundManagerPatch
	{
		[HarmonyPostfix]
		[HarmonyPatch("GenerateNewLevelClientRpc")]
		private static void GenerateNewLevelClientRpc_Postfix()
		{
			if (((TMP_Text)HUDManager.Instance.loadingText).text.Contains("Random seed"))
			{
				((TMP_Text)HUDManager.Instance.loadingText).text = ((TMP_Text)HUDManager.Instance.loadingText).text.Replace("Random seed", "무작위 시드");
			}
		}
	}
	[HarmonyPatch(typeof(ShipBuildModeManager))]
	internal class ShipBuildModeManagerPatch
	{
		[HarmonyPostfix]
		[HarmonyPatch("CreateGhostObjectAndHighlight")]
		private static void CreateGhostObjectAndHighlight_Postfix()
		{
			string text = ((TMP_Text)HUDManager.Instance.buildModeControlTip).text.Replace("Confirm", "배치");
			text = text.Replace("Rotate", "회전");
			text = text.Replace("Store", "보관");
			((TMP_Text)HUDManager.Instance.buildModeControlTip).text = text;
		}
	}
	[HarmonyPatch(typeof(ManualCameraRenderer))]
	internal class ManualCameraRendererPatch
	{
		[HarmonyPostfix]
		[HarmonyPatch("Update")]
		private static void Update_Postfix(UnlockableSuit __instance)
		{
			((TMP_Text)StartOfRound.Instance.mapScreenPlayerName).text = ((TMP_Text)StartOfRound.Instance.mapScreenPlayerName).text.Replace("MONITORING", "모니터링 중");
		}
	}
	[HarmonyPatch(typeof(TVScript))]
	internal class TVScriptPatch
	{
		[HarmonyPostfix]
		[HarmonyPatch("SetTVScreenMaterial")]
		private static void SetTVScreenMaterial_Postfix(ref VideoClip[] ___tvClips)
		{
			for (int i = 0; i < ___tvClips.Length; i++)
			{
				if (((Object)___tvClips[i]).name == "SnareFleaTipChannel2")
				{
					___tvClips[i] = Plugin.snareKorean;
				}
			}
		}
	}
	[HarmonyPatch(typeof(UnlockableSuit))]
	internal class UnlockableSuitPatch
	{
		[HarmonyPostfix]
		[HarmonyPatch("Update")]
		private static void Update_Postfix(UnlockableSuit __instance)
		{
			((Component)__instance).GetComponent<InteractTrigger>().hoverTip = "슈트 변경하기: " + StartOfRound.Instance.unlockablesList.unlockables[__instance.suitID].unlockableName;
		}
	}
	[HarmonyPatch(typeof(TimeOfDay))]
	internal class TimeOfDayPatch
	{
		[HarmonyPostfix]
		[HarmonyPatch("UpdateProfitQuotaCurrentTime")]
		private static void UpdateProfitQuotaCurrentTime_Postfix(ref int ___daysUntilDeadline, ref float ___timeUntilDeadline, ref float ___totalTime, ref int ___hoursUntilDeadline, ref float ___lengthOfHours, ref int ___numberOfHours, ref int ___quotaFulfilled, ref int ___profitQuota)
		{
			if (StartOfRound.Instance.isChallengeFile)
			{
				((TMP_Text)StartOfRound.Instance.deadlineMonitorText).text = "가능한  한\n많은  수익을\n얻으세요";
				((TMP_Text)StartOfRound.Instance.profitQuotaMonitorText).text = "환영합니다!\n이곳은:\n" + GameNetworkManager.Instance.GetNameForWeekNumber(-1);
				return;
			}
			if (___timeUntilDeadline <= 0f)
			{
				((TMP_Text)StartOfRound.Instance.deadlineMonitorText).text = "마감일:\n 지금";
			}
			else
			{
				((TMP_Text)StartOfRound.Instance.deadlineMonitorText).text = $"마감일:\n{___daysUntilDeadline}일";
			}
			((TMP_Text)StartOfRound.Instance.profitQuotaMonitorText).text = $"수익\n할당량:\n${___quotaFulfilled} / ${___profitQuota}";
		}

		[HarmonyPostfix]
		[HarmonyPatch("Update")]
		private static void Update_Postfix()
		{
			((TMP_Text)HUDManager.Instance.clockNumber).text = ((TMP_Text)HUDManager.Instance.clockNumber).text.Replace("AM", "오전");
			((TMP_Text)HUDManager.Instance.clockNumber).text = ((TMP_Text)HUDManager.Instance.clockNumber).text.Replace("PM", "오후");
		}

		[HarmonyPostfix]
		[HarmonyPatch("VoteShipToLeaveEarly")]
		private static void VoteShipToLeaveEarly_Postfix(ref DialogueSegment[] ___shipLeavingEarlyDialogue)
		{
			___shipLeavingEarlyDialogue[0].bodyText = ___shipLeavingEarlyDialogue[0].bodyText.Replace("AM", "오전");
			___shipLeavingEarlyDialogue[0].bodyText = ___shipLeavingEarlyDialogue[0].bodyText.Replace("PM", "오후");
		}
	}
	[HarmonyPatch(typeof(InteractTrigger))]
	internal class InteractTriggerPatch
	{
		[HarmonyPostfix]
		[HarmonyPatch("Update")]
		private static void Update_Postfix(ref string ___hoverTip, ref string ___disabledHoverTip, ref string ___holdTip)
		{
			TranslateHudTip(___hoverTip, ___disabledHoverTip, ___holdTip);
		}

		[HarmonyPostfix]
		[HarmonyPatch("Start")]
		private static void Start_Prefix(ref string ___hoverTip, ref string ___disabledHoverTip, ref string ___holdTip)
		{
			___hoverTip = ___hoverTip.Replace("Play record", "레코드 재생하기");
			___hoverTip = ___hoverTip.Replace("Flush", "물 내리기");
			___hoverTip = ___hoverTip.Replace("Squeeze", "인형 만지기");
			___hoverTip = ___hoverTip.Replace("Pull cord", "코드 당기기");
			___hoverTip = ___hoverTip.Replace("(Hold)", "(길게 누르기)");
			___hoverTip = ___hoverTip.Replace("Set candles", "양초 켜기");
			___hoverTip = ___hoverTip.Replace("Hit pumpkin", "호박 치기");
			___hoverTip = ___hoverTip.Replace("Switch water", "샤워기 전환하기");
			___hoverTip = ___hoverTip.Replace("Lift glass", "덮개 여닫기");
			___hoverTip = ___hoverTip.Replace("Push", "밀기");
			___hoverTip = ___hoverTip.Replace("Eject", "비상 탈출");
			___holdTip = ___holdTip.Replace("Eject", "비상 탈출");
			___hoverTip = ___hoverTip.Replace("Tune radio", "라디오 조정하기");
			___hoverTip = ___hoverTip.Replace("Toggle radio", "라디오 전원 전환하기");
			___hoverTip = ___hoverTip.Replace("Pull up", "문 올리기");
			___hoverTip = ___hoverTip.Replace("Pull down", "문 내리기");
			___hoverTip = ___hoverTip.Replace("Place item", "아이템 배치하기");
			___hoverTip = ___hoverTip.Replace("Remove key", "열쇠 제거하기");
			___hoverTip = ___hoverTip.Replace("Try ignition", "시동 걸기");
			___holdTip = ___holdTip.Replace("Trying ignition", "시동 거는 중");
			___hoverTip = ___hoverTip.Replace("Drive", "전진");
			___hoverTip = ___hoverTip.Replace("Reverse", "후진");
			___hoverTip = ___hoverTip.Replace("Park", "주차");
			___hoverTip = ___hoverTip.Replace("Sit down", "앉기");
			___hoverTip = ___hoverTip.Replace("Honk", "경적 울리기");
			___holdTip = ___holdTip.Replace("Honking", "경적 울리는 중");
			___hoverTip = ___hoverTip.Replace("Switch headlights", "전조등 전환하기");
			___hoverTip = ___hoverTip.Replace("Toggle cabin window", "트렁크 창문 전환하기");
			___hoverTip = ___hoverTip.Replace("Toggle wipers", "와이퍼 전환하기");
			___hoverTip = ___hoverTip.Replace("Open/shut hood", "후드 열기/닫기");
			___holdTip = ___holdTip.Replace("Open/shut hood", "후드 열기/닫기");
			___hoverTip = ___hoverTip.Replace("Beam up", "작동하기");
			___hoverTip = ___hoverTip.Replace("Beam up", "작동하기");
			if (___hoverTip == "Charge item : [LMB]")
			{
				___hoverTip = "아이템 충전하기 : [LMB]";
			}
			else if (___hoverTip == "Access terminal : [LMB]")
			{
				___hoverTip = "터미널 접근하기 : [LMB]";
			}
			else if (___hoverTip == "Disable speaker: [LMB]")
			{
				___hoverTip = "스피커 끄기: [LMB]";
			}
			else if (___hoverTip == "Switch lights : [LMB]")
			{
				___hoverTip = "전등 전환하기 : [LMB]";
			}
			else if (___hoverTip == "Change suit")
			{
				___hoverTip = "슈트 변경하기";
			}
			else if (___hoverTip == "Open : [LMB]")
			{
				___hoverTip = "열기 : [LMB]";
			}
			else if (___hoverTip == "Open: [LMB]")
			{
				___hoverTip = "열기: [LMB]";
			}
			else if (___hoverTip == "Open door : [LMB]")
			{
				___hoverTip = "문 열기 : [LMB]";
			}
			else if (___hoverTip == "Close door : [LMB]")
			{
				___hoverTip = "문 닫기 : [LMB]";
			}
			else if (___hoverTip == "Enter : [LMB]")
			{
				___hoverTip = "들어가기 : [LMB]";
			}
			else if (___hoverTip == "Exit : [LMB]")
			{
				___hoverTip = "나가기 : [LMB]";
			}
			else if (___hoverTip == "Use door : [LMB]")
			{
				___hoverTip = "문 사용하기 : [LMB]";
			}
			else if (___hoverTip == "Store item : [LMB]")
			{
				___hoverTip = "아이템 보관하기 : [LMB]";
			}
			else if (___hoverTip == "Use ladder : [LMB]")
			{
				___hoverTip = "사다리 사용하기 : [LMB]";
			}
			else if (___hoverTip == "Climb : [LMB]")
			{
				___hoverTip = "오르기 : [LMB]";
			}
			else if (___hoverTip == "Let go : [LMB]")
			{
				___hoverTip = "내리기 : [LMB]";
			}
			else if (___hoverTip == "Switch camera : [LMB]")
			{
				___hoverTip = "카메라 전환하기 : [LMB]";
			}
			else if (___hoverTip.Contains("Switch TV"))
			{
				___hoverTip = ___hoverTip.Replace("Switch TV", "TV 전환하기");
			}
			if (___disabledHoverTip == "(Requires battery-powered item)")
			{
				___disabledHoverTip = "(배터리로 작동하는 아이템 필요)";
			}
			else if (___disabledHoverTip == "[Nothing to store]")
			{
				___disabledHoverTip = "[보관할 아이템이 없음]";
			}
			else if (___disabledHoverTip == "Locked")
			{
				___disabledHoverTip = "잠김";
			}
			___hoverTip = ___hoverTip.Replace("Ring bell", "종 울리기");
			___hoverTip = ___hoverTip.Replace("Pull switch", "스위치 당기기");
			___hoverTip = ___hoverTip.Replace("Flip switch", "스위치 전환하기");
			___hoverTip = ___hoverTip.Replace("Pull valve", "밸브 돌리기");
			___holdTip = ___holdTip.Replace("[Pulling valve]", "[밸브 돌리는 중]");
			___disabledHoverTip = ___disabledHoverTip.Replace("[Cannot pull valve]", "[밸브를 돌릴 수 없음]");
		}

		private static void TranslateHudTip(string ___hoverTip, string ___disabledHoverTip, string ___holdTip)
		{
			if (___hoverTip != null)
			{
				___hoverTip = ___hoverTip.Replace("Let go", "내리기");
				___hoverTip = ___hoverTip.Replace("Climb", "오르기");
				___hoverTip = ___hoverTip.Replace("Use ladder", "사다리 사용하기");
				___hoverTip = ___hoverTip.Replace("Locked (pickable)", "잠김 (자물쇠 따개 사용 가능)");
				___hoverTip = ___hoverTip.Replace("Use door", "문 사용하기");
			}
			else if (___disabledHoverTip != null)
			{
				___disabledHoverTip = ___disabledHoverTip.Replace("Picking lock", "자물쇠 따는 중");
				___disabledHoverTip = ___disabledHoverTip.Replace(" sec.", "초 남음.");
				___disabledHoverTip = ___disabledHoverTip.Replace("Use key", "열쇠 사용하기");
				___disabledHoverTip = ___disabledHoverTip.Replace("Locked", "잠김");
			}
			else if (___holdTip != null)
			{
				___holdTip = ___holdTip.Replace("Picking lock", "자물쇠 따는 중");
			}
		}
	}
	[HarmonyPatch(typeof(SaveFileUISlot))]
	internal class SaveFileUISlotPatch
	{
		[HarmonyPostfix]
		[HarmonyPatch("OnEnable")]
		private static void OnEnable_Postfix(SaveFileUISlot __instance, ref string ___fileString)
		{
			if (__instance.fileNum == -1)
			{
				((TMP_Text)__instance.fileNameText).text = GameNetworkManager.Instance.GetNameForWeekNumber(-1);
			}
			if (ES3.FileExists(___fileString) && __instance.fileNum != -1)
			{
				int num = ES3.Load<int>("GroupCredits", ___fileString, 0);
				int num2 = ES3.Load<int>("Stats_DaysSpent", ___fileString, 0);
				((TMP_Text)__instance.fileStatsText).text = $"${num}\n{num2}일차";
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch("SetFileToThis")]
		private static void SetFileToThis_Postfix(ref TextMeshProUGUI ___specialTipText)
		{
			if ((Object)(object)___specialTipText != (Object)null && ((Behaviour)___specialTipText).enabled)
			{
				((TMP_Text)___specialTipText).text = ((TMP_Text)___specialTipText).text.Replace("This is the weekly challenge moon. You have one day to make as much profit as possible.", "주간 챌린지 위성입니다.하루 안에 가능한 한 많은 수익을 획득하세요.");
			}
		}
	}
	[HarmonyPatch(typeof(PreInitSceneScript))]
	internal class PreInitSceneScriptPatch
	{
		[HarmonyPostfix]
		[HarmonyPatch("PressContinueButton")]
		private static void PressContinueButton_Postfix(ref int ___currentLaunchSettingPanel, ref GameObject[] ___LaunchSettingsPanels, ref Animator ___blackTransition, ref GameObject ___continueButton, ref TextMeshProUGUI ___headerText)
		{
			if (((TMP_Text)___headerText).text == "LAUNCH MODE")
			{
				((TMP_Text)___headerText).text = "실행 모드";
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch("SkipToFinalSetting")]
		private static void SkipToFinalSetting_Postfix(ref TextMeshProUGUI ___headerText)
		{
			((TMP_Text)___headerText).text = "실행 모드";
		}
	}
	[HarmonyPatch(typeof(MenuManager))]
	internal class MenuManagerPatch
	{
		[HarmonyPostfix]
		[HarmonyPatch("DisplayMenuNotification")]
		private static void DisplayMenuNotification_Prefix(string notificationText, string buttonText, ref GameObject ___menuNotification, ref TextMeshProUGUI ___menuNotificationText, ref TextMeshProUGUI ___menuNotificationButtonText)
		{
			if (notificationText.Contains("Some of your save files may not be compatible"))
			{
				((TMP_Text)___menuNotificationText).text = $"일부 저장 파일은 버전 {GameNetworkManager.Instance.compatibleFileCutoffVersion}과 호환되지 않을 수 있으며, 플레이할 경우 손상될 수 있습니다.";
				((TMP_Text)___menuNotificationButtonText).text = "[ 닫기 ]";
				___menuNotification.SetActive(true);
				EventSystem.current.SetSelectedGameObject(((Component)___menuNotification.GetComponentInChildren<Button>()).gameObject);
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch("HostSetLobbyPublic")]
		private static void HostSetLobbyPublic_Postfix(ref TextMeshProUGUI ___privatePublicDescription)
		{
			if (((TMP_Text)___privatePublicDescription).text.Contains("PUBLIC"))
			{
				((TMP_Text)___privatePublicDescription).text = "공개로 설정하면 모든 사람이 볼 수 있도록 서버가 서버 목록에 표시됩니다.";
			}
			else
			{
				((TMP_Text)___privatePublicDescription).text = "비공개로 설정하면 Steam을 통해 플레이어에게 초대를 보내야 합니다.";
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch("Update")]
		private static void Update_Prefix(ref TextMeshProUGUI ___settingsBackButton)
		{
			if ((Object)(object)___settingsBackButton != (Object)null)
			{
				((TMP_Text)___settingsBackButton).text = ((TMP_Text)___settingsBackButton).text.Replace("DISCARD", "취소");
				((TMP_Text)___settingsBackButton).text = ((TMP_Text)___settingsBackButton).text.Replace("BACK", "뒤로");
			}
		}
	}
	[HarmonyPatch(typeof(StartMatchLever))]
	internal class StartMatchLeverPatch
	{
		[HarmonyPrefix]
		[HarmonyPatch("Update")]
		private static void Update_Prefix(ref InteractTrigger ___triggerScript)
		{
			if (___triggerScript.hoverTip == "Land ship : [LMB]")
			{
				___triggerScript.hoverTip = "함선 착륙하기 : [LMB]";
			}
			else if (___triggerScript.hoverTip == "Start game : [LMB]")
			{
				___triggerScript.hoverTip = "게임 시작하기 : [LMB]";
			}
			else if (___triggerScript.hoverTip == "Start ship : [LMB]")
			{
				___triggerScript.hoverTip = "함선 출발하기 : [LMB]";
			}
			if (___triggerScript.disabledHoverTip == "[Wait for ship to land]")
			{
				___triggerScript.disabledHoverTip = "[함선이 완전히 이착륙할 때까지 기다리세요]";
			}
			if (___triggerScript.disabledHoverTip == "[Ship in motion]")
			{
				___triggerScript.disabledHoverTip = "[함선이 이동하고 있습니다]";
			}
		}
	}
	[HarmonyPatch(typeof(TMP_Dropdown))]
	internal class TMP_DropdownPatch
	{
		[HarmonyPostfix]
		[HarmonyPatch("Awake")]
		private static void Awake_Postfix(TMP_Dropdown __instance)
		{
			if (__instance.options[0].text == "Sort: near")
			{
				__instance.options[0].text = "정렬: 가까운 서버";
				__instance.options[1].text = "정렬: 먼 서버";
				__instance.options[2].text = "정렬: 전 세계";
			}
			else if (__instance.options[0].text == "Use monitor (V-Sync)")
			{
				__instance.options[0].text = "모니터 사용 (수직 동기화)";
				__instance.options[1].text = "제한 없음";
			}
			else if (__instance.options[0].text == "Fullscreen")
			{
				__instance.options[0].text = "전체 화면";
				__instance.options[1].text = "테두리 없는 창";
				__instance.options[2].text = "최대화된 창";
				__instance.options[3].text = "창 모드";
			}
			else if (__instance.options[0].text == "Inside")
			{
				__instance.options[0].text = "내부 적";
				__instance.options[1].text = "외부 적";
				__instance.options[2].text = "주간 적";
			}
		}
	}
	[HarmonyPatch(typeof(TextMeshProUGUI))]
	internal class TextMeshProUGUIPatch
	{
		[HarmonyPostfix]
		[HarmonyPatch("Awake")]
		private static void Awake_Postfix(TextMeshProUGUI __instance)
		{
			try
			{
				Translate(__instance);
			}
			catch (Exception ex)
			{
				Plugin.mls.LogError((object)("TMP 텍스트를 번역하는 과정에서 오류가 발생했습니다!\n" + ex));
			}
		}

		private static void Translate(TextMeshProUGUI __instance)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0278: Unknown result type (might be due to invalid IL or missing references)
			//IL_027d: Unknown result type (might be due to invalid IL or missing references)
			Scene activeScene = SceneManager.GetActiveScene();
			if (((Scene)(ref activeScene)).name == "ColdOpen1")
			{
				((TMP_Text)__instance).text = ((TMP_Text)__instance).text.Replace("Detecting difficulties...", "문제 감지 중...");
				((TMP_Text)__instance).text = ((TMP_Text)__instance).text.Replace("Running reboot diagnostic...", "재부팅 진단 실행 중...");
				((TMP_Text)__instance).text = ((TMP_Text)__instance).text.Replace("UNABLE TO START.", "시작할 수 없습니다.");
				((TMP_Text)__instance).text = ((TMP_Text)__instance).text.Replace("PLEASE FIX ISSUES", "문제를 해결해주세요");
				((TMP_Text)__instance).text = ((TMP_Text)__instance).text.Replace("I BELIEVE IN YOU", "당신을 믿습니다");
			}
			else
			{
				activeScene = SceneManager.GetActiveScene();
				if (((Scene)(ref activeScene)).name == "MainMenu")
				{
					((TMP_Text)__instance).text = ((TMP_Text)__instance).text.Replace("Welcome back!", "돌아오신 것을 환영합니다!");
					((TMP_Text)__instance).text = ((TMP_Text)__instance).text.Replace("This update includes a new moon, a new creature, and a bunny suit, as well as many adjustments.", "이번 업데이트에는 새로운 위성, 생명체, 토끼 슈트와 많은 조정 사항이 포함되어 있습니다.");
					((TMP_Text)__instance).text = ((TMP_Text)__instance).text.Replace("This update includes the Company Cruiser truck and a couple new creatures.", "이번 업데이트에는 회사 크루저 트럭과 몇 가지 새로운 생명체가 포함되어 있습니다.");
					((TMP_Text)__instance).text = ((TMP_Text)__instance).text.Replace("This update introduces the mineshaft, a new creature, and new scrap to collect.", "이번 업데이트에서는 폐광, 새로운 생명체, 그리고 수집할 수 있는 새로운 폐품이 추가되었습니다.");
					((TMP_Text)__instance).text = ((TMP_Text)__instance).text.Replace("Others must update their game to play with you on this version.", "이 버전에서 당신과 함께 플레이하려면 다른 사람들도 게임을 업데이트해야 합니다.");
					((TMP_Text)__instance).text = ((TMP_Text)__instance).text.Replace("Good luck!", "행운을 빕니다!");
					((TMP_Text)__instance).text = ((TMP_Text)__instance).text.Replace("Have fun!", "즐거운 시간 되세요!");
					((TMP_Text)__instance).text = ((TMP_Text)__instance).text.Replace("Thanks to PuffoThePufferfish and Blueray901165 for helping shape this game. They were the closest with it through the entire process, helping me test and improve it every step of the way.", "이 게임을 만드는 데 도움을 준 PuffoThePufferfish와 Blueray901165에게 감사드립니다. 이 두 사람은 게임을 만드는 모든 과정에서 가장 가까이에 있었고, 게임을 테스트하고 개선하는 데 도움을 주었습니다.");
					((TMP_Text)__instance).text = ((TMP_Text)__instance).text.Replace("Thanks to my patrons who have generously supported me throughout this game's long and sometimes-rocky development:", "이 게임의 길고 때로는 험난했던 개발 기간 동안 아낌없는 성원을 보내주신 후원자 여러분께 감사드립니다:");
					((TMP_Text)__instance).text = ((TMP_Text)__instance).text.Replace("Thanks to Zenonclaw for modelling the shovel and the old elevator, which was scrapped long ago but still used for its parts.", "삽과 오래 전에 폐기되었지만 일부분 사용되고 있는 엘리베이터를 모델링해준 Zenonclaw에게 감사드립니다.");
					((TMP_Text)__instance).text = ((TMP_Text)__instance).text.Replace("Thanks to ZedFox for one of the boombox tracks (the good one) and the disco ball music.", "붐박스 트랙 중 하나(좋은 거)와 디스코 볼 음악을 제공한 ZedFox에게 감사드립니다.");
					((TMP_Text)__instance).text = ((TMP_Text)__instance).text.Replace("Thanks to youreashotgun for the snare flea TV channel.", "올무 벼룩 TV 채널을 보내주신 youreashotgun에게 감사드립니다.");
					((TMP_Text)__instance).text = ((TMP_Text)__instance).text.Replace("And thanks to Noah, Seth, Null, Sam, Zenonclaw, ZedFox, and Joseph for helping playtest throughout early development.", "그리고 초기 개발 기간 동안 플레이 테스트를 도와준 Noah, Seth, Null, Sam, Zenonclaw, ZedFox와 Joseph에게도 감사의 인사를 전합니다.");
					((TMP_Text)__instance).text = ((TMP_Text)__instance).text.Replace("Thanks to psyberartist for \"copperplate\" licensed under CC BY 2.0 Deed:", "CC BY 2.0 저작자표시허락을 받은 \"copperplate\"에 대해 psyberartist에게 감사드립니다:");
					((TMP_Text)__instance).text = ((TMP_Text)__instance).text.Replace("Sound effects from Freesound.org, licensed under CC-BY (Attribution). Thank you:", "CC-BY(저작자표시)에 따라 라이선스가 부여된 Freesound.org의 효과음의 저자에게도 감사의 말씀을 드립니다:");
				}
				else
				{
					activeScene = SceneManager.GetActiveScene();
					if (((Scene)(ref activeScene)).name == "InitSceneLaunchOptions")
					{
						((TMP_Text)__instance).text = ((TMP_Text)__instance).text.Replace("This experience has been designed for in-game voice chat, so I recommend giving it a try.", "이 게임은 게임 내 음성 채팅을 사용하는 것을 전제로 설계되었습니다. 게임 내 음성 채팅 사용을 권장합니다.");
						((TMP_Text)__instance).text = ((TMP_Text)__instance).text.Replace("Adjust screen brightness until the symbol on the right is barely visible.", "오른쪽 아이콘이 거의 보이지 않을 때까지 화면 밝기를 조정하세요.");
					}
				}
			}
			switch (((TMP_Text)__instance).text)
			{
			case "  Online":
				((TMP_Text)__instance).text = "  온라인";
				break;
			case "> Online":
				((TMP_Text)__instance).text = "> 온라인";
				break;
			case "(Recommended)":
				((TMP_Text)__instance).text = "(권장)";
				break;
			case " SET-UP":
				((TMP_Text)__instance).text = "설정";
				break;
			case "SET-UP":
				((TMP_Text)__instance).text = "설정";
				break;
			case "Tip: This may occur due to an antivirus or other software halting the save file from being read.":
				((TMP_Text)__instance).text = "팁: 이는 바이러스 백신이나 기타 소프트웨어로 인해 저장 파일 읽기가 중단되었기 때문에 발생할 수 있습니다.";
				break;
			case "Your files could not be loaded and may be corrupted. To start the game, the files can be deleted.":
				((TMP_Text)__instance).text = "파일을 불러올 수 없습니다. 저장 파일이 손상되었을 수 있습니다. 파일을 삭제하면 게임이 정상적으로 실행될 것입니다.";
				break;
			case "The game will now close so you can restart it.":
				((TMP_Text)__instance).text = "이제 게임이 종료됩니다. 게임을 재시작하세요.";
				break;
			case "[ Delete files and restart]":
				((TMP_Text)__instance).text = "[모든 저장 파일 삭제하기]";
				break;
			case "> Host":
				((TMP_Text)__instance).text = "> 호스트";
				break;
			case "> Join a crew":
				((TMP_Text)__instance).text = "> 팀에 합류하기";
				break;
			case "> Join LAN session":
				((TMP_Text)__instance).text = "> LAN 세션 합류하기";
				break;
			case "> Settings":
				((TMP_Text)__instance).text = "> 설정";
				break;
			case "> Credits":
				((TMP_Text)__instance).text = "> 크레딧";
				break;
			case "> Quit":
				((TMP_Text)__instance).text = "> 종료";
				break;
			case "> Resume":
				((TMP_Text)__instance).text = "> 계속하기";
				break;
			case "Would you like to leave the game?":
				((TMP_Text)__instance).text = "정말 게임을 떠나시겠습니까?";
				break;
			case "> Invite friends":
				((TMP_Text)__instance).text = "> 친구 초대하기";
				break;
			case "ACCESSIBILITY":
				((TMP_Text)__instance).text = "접근성";
				break;
			case "Unconfirmed changes!":
				((TMP_Text)__instance).text = "변경 사항이 저장되지 않음!";
				break;
			case "CONTROLS":
				((TMP_Text)__instance).text = "조작";
				break;
			case "REMAP CONTROLS":
				((TMP_Text)__instance).text = "조작 키 재설정";
				break;
			case "DISPLAY":
				((TMP_Text)__instance).text = "디스플레이";
				break;
			case "ENABLED":
				((TMP_Text)__instance).text = "활성화됨";
				break;
			case "Save File":
				((TMP_Text)__instance).text = "저장 파일";
				break;
			case "Server name:":
				((TMP_Text)__instance).text = "서버 이름:";
				break;
			case "Host LAN Server:":
				((TMP_Text)__instance).text = "LAN 서버 호스트하기:";
				break;
			case "Sort: worldwide":
				((TMP_Text)__instance).text = "정렬: 전 세계";
				break;
			case "Sort: Friends":
				((TMP_Text)__instance).text = "정렬: 친구";
				break;
			case "Sort: near":
				((TMP_Text)__instance).text = "정렬: 가까운 서버";
				break;
			case "Sort: far":
				((TMP_Text)__instance).text = "정렬: 먼 서버";
				break;
			case "Fullscreen":
				((TMP_Text)__instance).text = "전체 화면";
				break;
			case "Use monitor (V-Sync)":
				((TMP_Text)__instance).text = "모니터 사용 (수직 동기화)";
				break;
			case "Display mode:":
				((TMP_Text)__instance).text = "디스플레이 모드:";
				break;
			case "Frame rate cap:":
				((TMP_Text)__instance).text = "프레임 제한:";
				break;
			case "(Launched in LAN mode)":
				((TMP_Text)__instance).text = "(LAN 모드로 실행됨)";
				break;
			case "Servers":
				((TMP_Text)__instance).text = "서버";
				break;
			case "Weekly Challenge Results":
				((TMP_Text)__instance).text = "주간 챌린지 결과";
				break;
			case "Loading server list...":
				((TMP_Text)__instance).text = "서버 목록 불러오는 중...";
				break;
			case "Loading ranking...":
				((TMP_Text)__instance).text = "순위 불러오는 중...";
				break;
			case "Loading...":
				((TMP_Text)__instance).text = "로딩 중...";
				break;
			case "Join":
				((TMP_Text)__instance).text = "참가";
				break;
			case "Version 50 is here!":
				((TMP_Text)__instance).text = "버전 50이 출시되었습니다!";
				break;
			case "Version 55 is here!":
				((TMP_Text)__instance).text = "버전 55가 출시되었습니다!";
				break;
			case "Version 60 is here!":
				((TMP_Text)__instance).text = "버전 60이 출시되었습니다!";
				break;
			case "Credits":
				((TMP_Text)__instance).text = "크레딧";
				break;
			case "An error occured!":
				((TMP_Text)__instance).text = "오류가 발생했습니다!";
				break;
			case "Do you want to delete File 1?":
				((TMP_Text)__instance).text = "정말 파일 1을 삭제할까요?";
				break;
			case "Confirm changes?":
				((TMP_Text)__instance).text = "변경 사항을 저장할까요?";
				break;
			case "You are in LAN mode. When allowing remote connections through LAN, please ensure you have sufficient network security such as a firewall and/or VPN.":
				((TMP_Text)__instance).text = "LAN 모드에 있습니다. LAN을 통한 원격 연결을 허용하는 경우 방화벽 및/또는 VPN과 같은 네트워크 보안이 충분한지 확인하십시오.";
				break;
			case "Enter a tag...":
				((TMP_Text)__instance).text = "태그를 입력하세요...";
				break;
			case "Enter server tag...":
				((TMP_Text)__instance).text = "서버 태그를 입력하세요...";
				break;
			case "Name your server...":
				((TMP_Text)__instance).text = "서버 이름을 입력하세요...";
				break;
			case "PRIVATE means you must send invites through Steam for players to join.":
				((TMP_Text)__instance).text = "비공개로 설정하면 Steam을 통해 플레이어에게 초대를 보내야 합니다.";
				break;
			case "MODE: Voice activation":
				((TMP_Text)__instance).text = "모드: 음성 감지";
				break;
			case "Push to talk:":
				((TMP_Text)__instance).text = "눌러서 말하기";
				break;
			case "Gamma/Brightness:":
				((TMP_Text)__instance).text = "감마/밝기:";
				break;
			case "Master volume:":
				((TMP_Text)__instance).text = "주 음량:";
				break;
			case "Look sensitivity:":
				((TMP_Text)__instance).text = "마우스 감도:";
				break;
			case "Invert Y-Axis":
				((TMP_Text)__instance).text = "Y축 반전";
				break;
			case "Arachnophobia Mode":
				((TMP_Text)__instance).text = "거미공포증 모드";
				break;
			case "Discard":
				((TMP_Text)__instance).text = "취소";
				break;
			case "Confirm":
				((TMP_Text)__instance).text = "확인";
				break;
			case "> Set to defaults":
				((TMP_Text)__instance).text = "> 기본값으로 설정";
				break;
			case "> Reset all to default":
				((TMP_Text)__instance).text = "> 기본값으로 재설정";
				break;
			case "> Back":
				((TMP_Text)__instance).text = "> 뒤로";
				break;
			case "> Confirm changes":
				((TMP_Text)__instance).text = "> 변경 사항 저장";
				break;
			case "> Confirm":
				((TMP_Text)__instance).text = "> 확인";
				break;
			case "> Cancel":
				((TMP_Text)__instance).text = "> 취소";
				break;
			case "> CONFIRM":
				((TMP_Text)__instance).text = "> 확인";
				break;
			case "  CONFIRM":
				((TMP_Text)__instance).text = "  확인";
				break;
			case "> Change keybinds":
				((TMP_Text)__instance).text = "> 조작 키 변경";
				break;
			case "[ Refresh ]":
				((TMP_Text)__instance).text = "[ 새로고침 ]";
				break;
			case "> Back to menu":
				((TMP_Text)__instance).text = "> 메뉴로 돌아가기";
				break;
			case "With challenge moon":
				((TMP_Text)__instance).text = "챌린지 달 포함";
				break;
			case "[ Back ]":
				((TMP_Text)__instance).text = "[ 뒤로 ]";
				break;
			case "[ Confirm ]":
				((TMP_Text)__instance).text = "[ 확인 ]";
				break;
			case "[ Remove my score ]":
				((TMP_Text)__instance).text = "[ 점수 삭제하기 ]";
				break;
			case "[ Play again ]":
				((TMP_Text)__instance).text = "[ 다시 하기 ]";
				break;
			case "Local-only":
				((TMP_Text)__instance).text = "로컬 전용";
				break;
			case "File 1":
				((TMP_Text)__instance).text = "파일 1";
				break;
			case "File 2":
				((TMP_Text)__instance).text = "파일 2";
				break;
			case "File 3":
				((TMP_Text)__instance).text = "파일 3";
				break;
			case "Input: ":
				((TMP_Text)__instance).text = "입력: ";
				break;
			case "CHALLENGE":
				((TMP_Text)__instance).text = "챌린지";
				break;
			case "[ Continue ]":
				((TMP_Text)__instance).text = "[ 계속 ]";
				break;
			case "Delete":
				((TMP_Text)__instance).text = "삭제";
				break;
			case "Public":
				((TMP_Text)__instance).text = "공개";
				break;
			case "Friends-only":
				((TMP_Text)__instance).text = "친구 전용";
				break;
			case "Allow remote connections":
				((TMP_Text)__instance).text = "원격 연결 허용";
				break;
			case "Go back":
				((TMP_Text)__instance).text = "뒤로 가기";
				break;
			case "File incompatible!":
				((TMP_Text)__instance).text = "파일 호환되지 않음!";
				break;
			case "Waiting for input":
				((TMP_Text)__instance).text = "입력 대기 중";
				break;
			case "HANDS FULL":
				((TMP_Text)__instance).text = "양 손 사용 중";
				break;
			case "Walk : [W/A/S/D]":
				((TMP_Text)__instance).text = "걷기 : [W/A/S/D]";
				break;
			case "Sprint: [Shift]":
				((TMP_Text)__instance).text = "달리기: [Shift]";
				break;
			case "Scan : [RMB]":
				((TMP_Text)__instance).text = "스캔 : [RMB]";
				break;
			case "SYSTEMS ONLINE":
				((TMP_Text)__instance).text = Plugin.systemOnlineText;
				break;
			case "Typing...":
				((TMP_Text)__instance).text = "입력 중...";
				break;
			case "Press \"/\" to talk.":
				((TMP_Text)__instance).text = "\"/\"를 눌러 대화합니다.";
				break;
			case "(Some were too far to receive your message.)":
				((TMP_Text)__instance).text = "(일부는 너무 멀어 메세지를 받지 못했습니다.)";
				break;
			case "Confirm: [V]   |   Rotate: [R]   |   Store: [X]":
				((TMP_Text)__instance).text = "확정: [V]   |   회전: [R]   |   보관: [X]";
				break;
			case "CRITICAL INJURY":
				((TMP_Text)__instance).text = Plugin.injuryText;
				break;
			case "Paycheck!":
				((TMP_Text)__instance).text = Plugin.sellText;
				break;
			case "TOTAL:":
				((TMP_Text)__instance).text = "합계:";
				break;
			case "YOU ARE FIRED.":
				((TMP_Text)__instance).text = Plugin.firedText;
				break;
			case "You will keep your employee rank. Your ship and credits will be reset.":
				((TMP_Text)__instance).text = "직원 계급은 유지되지만, 당신의 함선과 크레딧은 초기화됩니다.";
				break;
			case "You did not meet the profit quota before the deadline.":
				((TMP_Text)__instance).text = "마감일 전까지 수익 할당량을 충족하지 못했습니다.";
				break;
			case "TO MEET PROFIT QUOTA":
				((TMP_Text)__instance).text = "수익 할당량 충족까지";
				break;
			case "QUOTA REACHED!":
				((TMP_Text)__instance).text = "<size=65>" + Plugin.quotaReached + "</size>";
				break;
			case "NEW PROFIT QUOTA:":
				((TMP_Text)__instance).text = "새로운 수익 할당량:";
				break;
			case "Stats":
				((TMP_Text)__instance).text = "통계";
				break;
			case "[LIFE SUPPORT: OFFLINE]":
				((TMP_Text)__instance).text = Plugin.deathText;
				break;
			case "(Dead)":
				((TMP_Text)__instance).text = "(사망)";
				break;
			case "Tell autopilot ship to leave early : [RMB] (Hold)":
				((TMP_Text)__instance).text = "함선에게 일찍 출발하라고 지시하기\n: [RMB] (Hold)";
				break;
			case "HAZARD LEVEL:":
				((TMP_Text)__instance).text = "위험 수준:";
				break;
			case "Notes:":
				((TMP_Text)__instance).text = "노트:";
				break;
			case "PERFORMANCE REPORT":
				((TMP_Text)__instance).text = "성과 보고서";
				break;
			case "DEBUG/TEST":
				((TMP_Text)__instance).text = "디버그/테스트";
				break;
			case "Enemy type:":
				((TMP_Text)__instance).text = "적 종류:";
				break;
			case "Enemy:":
				((TMP_Text)__instance).text = "적:";
				break;
			case "Number to spawn:":
				((TMP_Text)__instance).text = "생성할 수:";
				break;
			case "Enter text...":
				((TMP_Text)__instance).text = "텍스트를 입력하세요...";
				break;
			case "Spawn creature":