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.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Threading.Tasks;
using ATL;
using BepInEx;
using Colossal.IO.AssetDatabase;
using Colossal.Json;
using Colossal.UI;
using Colossal.UI.Binding;
using ExtendedRadio.Patches;
using Game;
using Game.Audio;
using Game.Audio.Radio;
using Game.Common;
using Game.SceneFlow;
using Game.UI;
using Game.UI.InGame;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using UnityEngine;
using UnityEngine.Networking;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("ExtendedRadio")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyDescription("This mod aims to add features and improve existing ones for the game's radio player.")]
[assembly: AssemblyFileVersion("0.5.3.0")]
[assembly: AssemblyInformationalVersion("0.5.3+6018ba9d22e04f573031a76f9c84fa9e30059ab0")]
[assembly: AssemblyProduct("ExtendedRadio")]
[assembly: AssemblyTitle("ExtendedRadio")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.5.3.0")]
[module: UnverifiableCode]
[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;
		}
	}
}
namespace ExtendedRadio
{
	public class CustomRadios
	{
		private static readonly List<string> radioDirectories = new List<string>();

		internal static List<string> customeRadioChannelsName = new List<string>();

		private static readonly List<string> customeNetworksName = new List<string>();

		private static Dictionary<string, RadioNetwork> m_Networks = new Dictionary<string, RadioNetwork>();

		private static Dictionary<string, RuntimeRadioChannel> m_RadioChannels = new Dictionary<string, RuntimeRadioChannel>();

		private static int radioNetworkIndex;

		internal static void LoadCustomRadios()
		{
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Expected O, but got Unknown
			m_Networks = ExtendedRadio.radioTravers.Field("m_Networks").GetValue<Dictionary<string, RadioNetwork>>();
			m_RadioChannels = ExtendedRadio.radioTravers.Field("m_RadioChannels").GetValue<Dictionary<string, RuntimeRadioChannel>>();
			radioNetworkIndex = m_Networks.Count;
			foreach (string radioDirectory in radioDirectories)
			{
				string[] directories = Directory.GetDirectories(radioDirectory);
				foreach (string text in directories)
				{
					if (!(text != radioDirectory))
					{
						continue;
					}
					RadioNetwork val = new RadioNetwork();
					if (File.Exists(text + "//RadioNetwork.json"))
					{
						val = JsonToRadioNetwork(text);
					}
					else
					{
						val.name = new DirectoryInfo(text).Name;
						val.description = "A custom Network";
						val.descriptionId = "A custom Network";
						val.icon = (File.Exists(Path.Combine(text, "icon.svg")) ? (GameManager_InitializeThumbnails.COUIBaseLocation + "/CustomRadios/" + new DirectoryInfo(text).Name + "/icon.svg") : (GameManager_InitializeThumbnails.COUIBaseLocation + "/resources/DefaultIcon.svg"));
						val.allowAds = true;
					}
					RadioNetwork val2 = val;
					if (val2.icon == null)
					{
						val2.icon = GameManager_InitializeThumbnails.COUIBaseLocation + "/resources/DefaultIcon.svg";
					}
					val.nameId = val.name;
					val.uiPriority = radioNetworkIndex++;
					if (!m_Networks.ContainsKey(val.name))
					{
						customeNetworksName.Add(val.name);
						m_Networks.Add(val.name, val);
					}
					string[] directories2 = Directory.GetDirectories(text);
					foreach (string text2 in directories2)
					{
						RadioChannel val3 = (File.Exists(text2 + "//RadioChannel.json") ? JsonToRadio(text2, val.name) : CreateRadioFromPath(text2, val.name));
						ExtendedRadio.AddAudioToDataBase(val3);
						customeRadioChannelsName.Add(val3.name);
						m_RadioChannels.Add(val3.name, val3.CreateRuntime(text2));
						if (Settings.SaveLastRadio && Settings.LastRadio == val3.name)
						{
							ExtendedRadio.radio.currentChannel = m_RadioChannels[val3.name];
						}
					}
				}
			}
			ExtendedRadio.radioTravers.Field("m_Networks").SetValue((object)m_Networks);
			ExtendedRadio.radioTravers.Field("m_RadioChannels").SetValue((object)m_RadioChannels);
			ExtendedRadio.radioTravers.Field("m_CachedRadioChannelDescriptors").SetValue((object)null);
		}

		public static void RegisterCustomRadioDirectory(string path)
		{
			radioDirectories.Add(path);
		}

		public static bool AddRadioNetworkToTheGame(RadioNetwork radioNetwork)
		{
			if (m_Networks.ContainsKey(radioNetwork.name))
			{
				return false;
			}
			radioNetwork.uiPriority = radioNetworkIndex++;
			customeNetworksName.Add(radioNetwork.name);
			m_Networks.Add(radioNetwork.name, radioNetwork);
			return true;
		}

		public static bool AddRadioChannelToTheGame(RadioChannel radioChannel, string path = "")
		{
			if (customeRadioChannelsName.Contains(radioChannel.name))
			{
				return false;
			}
			ExtendedRadio.AddAudioToDataBase(radioChannel);
			customeRadioChannelsName.Add(radioChannel.name);
			m_RadioChannels.Add(radioChannel.name, radioChannel.CreateRuntime(path));
			return true;
		}

		public static RadioChannel JsonToRadio(string path, string radioNetwork = null)
		{
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0165: Expected O, but got Unknown
			//IL_01b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01be: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01df: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e8: Expected O, but got Unknown
			//IL_0295: Unknown result type (might be due to invalid IL or missing references)
			RadioChannel val = Decoder.Decode(File.ReadAllText(path + "\\RadioChannel.json")).Make<RadioChannel>();
			while (m_RadioChannels.ContainsKey(val.name))
			{
				val.name = val.name + "_" + ExtendedRadio.radioTravers.Method("MakeUniqueRandomName", new object[2] { val.name, 4 }).GetValue<string>();
			}
			val.nameId = val.name;
			if (radioNetwork != null)
			{
				val.network = radioNetwork;
			}
			if (Directory.GetFiles(Directory.GetDirectories(path)[0], "*.ogg").Length == 0)
			{
				string[] directories = Directory.GetDirectories(path);
				foreach (string text in directories)
				{
					Program val2 = (Program)((!File.Exists(text + "\\Program.json")) ? ((object)new Program
					{
						name = new DirectoryInfo(radioNetwork).Name,
						description = new DirectoryInfo(radioNetwork).Name,
						icon = GameManager_InitializeThumbnails.COUIBaseLocation + "/resources/DefaultIcon.svg",
						startTime = "00:00",
						endTime = "00:00",
						loopProgram = true,
						pairIntroOutro = false
					}) : ((object)Decoder.Decode(File.ReadAllText(text + "\\Program.json")).Make<Program>()));
					string[] directories2 = Directory.GetDirectories(text);
					foreach (string text2 in directories2)
					{
						Segment val3 = (Segment)((!File.Exists(text2 + "\\Segment.json")) ? ((object)new Segment
						{
							type = StringToSegmentType(new DirectoryInfo(radioNetwork).Name),
							tags = Array.Empty<string>(),
							clipsCap = 0
						}) : ((object)Decoder.Decode(File.ReadAllText(text2 + "\\Segment.json")).Make<Segment>()));
						if (val3.tags.Length == 0)
						{
							val3.tags = new string[3]
							{
								(((object)(SegmentType)(ref val3.type)).ToString() == "Playlist") ? "Music" : ((object)(SegmentType)(ref val3.type)).ToString(),
								val.name,
								val.network
							};
						}
						string[] directories3 = Directory.GetDirectories(text2);
						foreach (string path2 in directories3)
						{
							string[] files = Directory.GetFiles(path2, "*.ogg");
							foreach (string audioFilePath in files)
							{
								val3.clips = CollectionExtensions.AddToArray<AudioAsset>(val3.clips, MusicLoader.LoadAudioFile(audioFilePath, val3.type, val.network, val.name));
							}
						}
						if (!File.Exists(text2 + "\\Segment.json"))
						{
							val3.clipsCap = val3.clips.Length;
						}
						val2.segments = CollectionExtensions.AddToArray<Segment>(val2.segments, val3);
					}
					val.programs = CollectionExtensions.AddToArray<Program>(val.programs, val2);
				}
			}
			else
			{
				val = CreateRadioFromPath(path, val.network, val);
			}
			return val;
		}

		private static RadioChannel CreateRadioFromPath(string path, string radioNetwork, RadioChannel radioChannel = null)
		{
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Expected O, but got Unknown
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cd: Expected O, but got Unknown
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Expected O, but got Unknown
			//IL_017a: Unknown result type (might be due to invalid IL or missing references)
			if (radioChannel == null)
			{
				string text = new DirectoryInfo(path).Name;
				string icon = GameManager_InitializeThumbnails.COUIBaseLocation + "/resources/DefaultIcon.svg";
				if (File.Exists(path + "\\icon.svg"))
				{
					icon = GameManager_InitializeThumbnails.COUIBaseLocation + "/CustomRadios/" + new DirectoryInfo(path).Parent.Name + "/" + text + "/icon.svg";
				}
				while (m_RadioChannels.ContainsKey(text))
				{
					text = text + "_" + ExtendedRadio.radioTravers.Method("MakeUniqueRandomName", new object[2] { text, 4 }).GetValue<string>();
				}
				radioChannel = new RadioChannel
				{
					network = radioNetwork,
					name = text,
					nameId = text,
					description = text,
					icon = icon
				};
			}
			Segment val = new Segment();
			val.type = (SegmentType)0;
			val.clipsCap = 0;
			val.clips = Array.Empty<AudioAsset>();
			val.tags = new string[2] { "Music", radioChannel.name };
			Segment val2 = val;
			string[] directories = Directory.GetDirectories(path);
			foreach (string path2 in directories)
			{
				string[] files = Directory.GetFiles(path2, "*.ogg");
				foreach (string audioFilePath in files)
				{
					val2.clips = CollectionExtensions.AddToArray<AudioAsset>(val2.clips, MusicLoader.LoadAudioFile(audioFilePath, val2.type, radioChannel.network, radioChannel.name));
				}
			}
			val2.clipsCap = val2.clips.Length;
			Program val3 = new Program();
			val3.name = "My Custom Program";
			val3.description = "My Custom Program";
			val3.icon = GameManager_InitializeThumbnails.COUIBaseLocation + "/resources/DefaultIcon.svg";
			val3.startTime = "00:00";
			val3.endTime = "00:00";
			val3.loopProgram = true;
			val3.segments = (Segment[])(object)new Segment[1] { val2 };
			Program val4 = val3;
			radioChannel.programs = CollectionExtensions.AddToArray<Program>(radioChannel.programs, val4);
			return radioChannel;
		}

		public static RadioNetwork JsonToRadioNetwork(string path)
		{
			return Decoder.Decode(File.ReadAllText(path + "\\RadioNetwork.json")).Make<RadioNetwork>();
		}

		public static string RadioNetworkToJson(RadioNetwork radioNetwork)
		{
			return Encoder.Encode((object)radioNetwork, (EncodeOptions)0);
		}

		public static RadioChannel JsonToRadioChannel(string path)
		{
			return Decoder.Decode(File.ReadAllText(path + "\\RadioChannel.json")).Make<RadioChannel>();
		}

		public static Program JsonToProgram(string path)
		{
			return Decoder.Decode(File.ReadAllText(path + "\\Program.json")).Make<Program>();
		}

		public static Segment JsonToSegment(string path)
		{
			return Decoder.Decode(File.ReadAllText(path + "\\Segment.json")).Make<Segment>();
		}

		public static SegmentType StringToSegmentType(string s)
		{
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			if (1 == 0)
			{
			}
			SegmentType result = (SegmentType)(s switch
			{
				"Playlist" => 0, 
				"Talkshow" => 1, 
				"PSA" => 2, 
				"Weather" => 3, 
				"News" => 4, 
				"Commercial" => 5, 
				"Emergency" => 6, 
				_ => 0, 
			});
			if (1 == 0)
			{
			}
			return result;
		}
	}
	public class ExtendedRadio
	{
		public delegate void OnRadioLoad();

		internal static readonly Dictionary<string, Dictionary<string, Dictionary<string, Dictionary<SegmentType, List<AudioAsset>>>>> audioDataBase = new Dictionary<string, Dictionary<string, Dictionary<string, Dictionary<SegmentType, List<AudioAsset>>>>>();

		public static Traverse radioTravers = null;

		public static Radio radio = null;

		public static event OnRadioLoad CallOnRadioLoad;

		internal static void OnLoadRadio(Radio __instance)
		{
			audioDataBase.Clear();
			radio = __instance;
			radioTravers = Traverse.Create((object)__instance);
			CustomRadios.LoadCustomRadios();
			RadioAddons.LoadRadioAddons();
			try
			{
				ExtendedRadio.CallOnRadioLoad();
			}
			catch
			{
			}
		}

		internal static void AddAudioToDataBase(RadioChannel radioChannel)
		{
			//IL_0314: Unknown result type (might be due to invalid IL or missing references)
			//IL_0319: Unknown result type (might be due to invalid IL or missing references)
			//IL_027b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0280: Unknown result type (might be due to invalid IL or missing references)
			//IL_0359: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_018a: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0233: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cf: Unknown result type (might be due to invalid IL or missing references)
			Program[] programs = radioChannel.programs;
			foreach (Program val in programs)
			{
				Segment[] segments = val.segments;
				foreach (Segment val2 in segments)
				{
					if (audioDataBase.ContainsKey(radioChannel.network))
					{
						if (audioDataBase[radioChannel.network].ContainsKey(radioChannel.name))
						{
							if (audioDataBase[radioChannel.network][radioChannel.name].ContainsKey(val.name))
							{
								if (audioDataBase[radioChannel.network][radioChannel.name][val.name].ContainsKey(val2.type))
								{
									List<AudioAsset> list = audioDataBase[radioChannel.network][radioChannel.name][val.name][val2.type];
									AudioAsset[] clips = val2.clips;
									int num = 0;
									AudioAsset[] array = (AudioAsset[])(object)new AudioAsset[clips.Length];
									AudioAsset[] array2 = clips;
									foreach (AudioAsset val3 in array2)
									{
										array[num] = val3;
										num++;
									}
									list.AddRange(new <>z__ReadOnlyArray<AudioAsset>(array));
								}
								else
								{
									Dictionary<SegmentType, List<AudioAsset>> dictionary = audioDataBase[radioChannel.network][radioChannel.name][val.name];
									SegmentType type = val2.type;
									AudioAsset[] clips2 = val2.clips;
									List<AudioAsset> list2 = new List<AudioAsset>(clips2.Length);
									AudioAsset[] array3 = clips2;
									foreach (AudioAsset val3 in array3)
									{
										list2.Add(val3);
									}
									dictionary.Add(type, list2);
								}
							}
							else
							{
								Dictionary<SegmentType, List<AudioAsset>> dictionary2 = new Dictionary<SegmentType, List<AudioAsset>>();
								Dictionary<SegmentType, List<AudioAsset>> dictionary3 = dictionary2;
								SegmentType type2 = val2.type;
								AudioAsset[] clips3 = val2.clips;
								List<AudioAsset> list3 = new List<AudioAsset>(clips3.Length);
								AudioAsset[] array4 = clips3;
								foreach (AudioAsset val3 in array4)
								{
									list3.Add(val3);
								}
								dictionary3.Add(type2, list3);
								audioDataBase[radioChannel.network][radioChannel.name].Add(val.name, dictionary2);
							}
						}
						else
						{
							Dictionary<SegmentType, List<AudioAsset>> dictionary4 = new Dictionary<SegmentType, List<AudioAsset>>();
							Dictionary<SegmentType, List<AudioAsset>> dictionary5 = dictionary4;
							SegmentType type3 = val2.type;
							AudioAsset[] clips4 = val2.clips;
							List<AudioAsset> list4 = new List<AudioAsset>(clips4.Length);
							AudioAsset[] array5 = clips4;
							foreach (AudioAsset val3 in array5)
							{
								list4.Add(val3);
							}
							dictionary5.Add(type3, list4);
							Dictionary<string, Dictionary<SegmentType, List<AudioAsset>>> dictionary6 = new Dictionary<string, Dictionary<SegmentType, List<AudioAsset>>>();
							dictionary6.Add(val.name, dictionary4);
							audioDataBase[radioChannel.network].Add(radioChannel.name, dictionary6);
						}
					}
					else
					{
						Dictionary<SegmentType, List<AudioAsset>> dictionary7 = new Dictionary<SegmentType, List<AudioAsset>>();
						Dictionary<SegmentType, List<AudioAsset>> dictionary8 = dictionary7;
						SegmentType type4 = val2.type;
						AudioAsset[] clips5 = val2.clips;
						List<AudioAsset> list5 = new List<AudioAsset>(clips5.Length);
						AudioAsset[] array6 = clips5;
						foreach (AudioAsset val3 in array6)
						{
							list5.Add(val3);
						}
						dictionary8.Add(type4, list5);
						Dictionary<string, Dictionary<SegmentType, List<AudioAsset>>> dictionary9 = new Dictionary<string, Dictionary<SegmentType, List<AudioAsset>>>();
						dictionary9.Add(val.name, dictionary7);
						Dictionary<string, Dictionary<string, Dictionary<SegmentType, List<AudioAsset>>>> dictionary10 = new Dictionary<string, Dictionary<string, Dictionary<SegmentType, List<AudioAsset>>>>();
						dictionary10.Add(radioChannel.name, dictionary9);
						audioDataBase.Add(radioChannel.network, dictionary10);
					}
				}
			}
		}

		internal static void AddAudioToDataBase(string network, string radioChannel, string program, SegmentType segmentType, List<AudioAsset> audioAssets)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			audioDataBase[network][radioChannel][program][segmentType].AddRange(audioAssets);
		}

		internal static void AddAudioToDataBase(string network, string radioChannel, string program, SegmentType segmentType, AudioAsset audioAssets)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			audioDataBase[network][radioChannel][program][segmentType].Add(audioAssets);
		}

		internal static List<AudioAsset> GetAudioAssetsFromAudioDataBase(Radio radio, SegmentType type)
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			return audioDataBase[radio.currentChannel.network][radio.currentChannel.name][radio.currentChannel.currentProgram.name][type];
		}

		internal static Stream GetEmbedded(string embeddedPath)
		{
			return Assembly.GetExecutingAssembly().GetManifestResourceStream("ExtendedRadio.embedded." + embeddedPath);
		}
	}
	public class MusicLoader
	{
		public static AudioAsset LoadAudioFile(string audioFilePath, SegmentType segmentType, string networkName = null, string radioChannelName = null)
		{
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Expected O, but got Unknown
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Expected O, but got Unknown
			string text = audioFilePath;
			int num = ".ogg".Count();
			JsonAudioAsset jsonAudioAsset;
			if (File.Exists(text.Substring(0, text.Length - num) + ".json"))
			{
				text = audioFilePath;
				num = ".ogg".Count();
				jsonAudioAsset = Decoder.Decode(File.ReadAllText(text.Substring(0, text.Length - num) + ".json")).Make<JsonAudioAsset>();
			}
			else
			{
				jsonAudioAsset = new JsonAudioAsset();
			}
			AudioAsset val = new AudioAsset();
			((AssetData)val).AddTag("AudioFilePath=" + audioFilePath);
			((AssetData)val).AddTag("AudioFileFormat=" + jsonAudioAsset.AudioFileFormat.ToUpper());
			Dictionary<Metatag, string> dictionary = new Dictionary<Metatag, string>();
			Traverse val2 = Traverse.Create((object)val);
			Track val3 = new Track(audioFilePath, true);
			AddMetaTag(val, dictionary, (Metatag)0, jsonAudioAsset.Title ?? val3.Title);
			AddMetaTag(val, dictionary, (Metatag)1, jsonAudioAsset.Album ?? val3.Album);
			AddMetaTag(val, dictionary, (Metatag)2, jsonAudioAsset.Artist ?? val3.Artist);
			AddMetaTag(val, dictionary, (Metatag)3, val3, "TYPE", jsonAudioAsset.Type ?? ((((object)(SegmentType)(ref segmentType)).ToString() == "Playlist") ? "Music" : ((object)(SegmentType)(ref segmentType)).ToString()));
			AddMetaTag(val, dictionary, (Metatag)4, val3, "BRAND", jsonAudioAsset.Brand);
			AddMetaTag(val, dictionary, (Metatag)5, val3, "RADIO STATION", networkName ?? jsonAudioAsset.RadioStation);
			AddMetaTag(val, dictionary, (Metatag)6, val3, "RADIO CHANNEL", radioChannelName ?? jsonAudioAsset.RadioChannel);
			AddMetaTag(val, dictionary, (Metatag)7, val3, "PSA TYPE", jsonAudioAsset.PSAType);
			AddMetaTag(val, dictionary, (Metatag)8, val3, "ALERT TYPE", jsonAudioAsset.AlertType);
			AddMetaTag(val, dictionary, (Metatag)9, val3, "NEWS TYPE", jsonAudioAsset.NewsType);
			AddMetaTag(val, dictionary, (Metatag)10, val3, "WEATHER TYPE", jsonAudioAsset.WeatherType);
			val2.Field("m_Metatags").SetValue((object)dictionary);
			val2.Field("durationMs").SetValue((object)val3.DurationMs);
			val2.Field("m_Instance").SetValue((object)null);
			if (jsonAudioAsset.loopStart == -1.0 && GetTimeTag(val3, "LOOPSTART", out double time))
			{
				val2.Field("loopStart").SetValue((object)time);
			}
			else
			{
				val2.Field("loopStart").SetValue((object)jsonAudioAsset.loopStart);
			}
			if (jsonAudioAsset.loopEnd == -1.0 && GetTimeTag(val3, "LOOPEND", out time))
			{
				val2.Field("loopEnd").SetValue((object)time);
			}
			else
			{
				val2.Field("loopEnd").SetValue((object)jsonAudioAsset.loopEnd);
			}
			if (jsonAudioAsset.alternativeStart == -1.0 && GetTimeTag(val3, "ALTERNATIVESTART", out time))
			{
				val2.Field("alternativeStart").SetValue((object)time);
			}
			else
			{
				val2.Field("alternativeStart").SetValue((object)jsonAudioAsset.alternativeStart);
			}
			if (jsonAudioAsset.fadeoutTime == -1f && GetTimeTag(val3, "FADEOUTTIME", out float time2))
			{
				val2.Field("fadeoutTime").SetValue((object)time2);
			}
			else
			{
				val2.Field("fadeoutTime").SetValue((object)jsonAudioAsset.fadeoutTime);
			}
			return val;
		}

		internal static void AddMetaTag(AudioAsset audioAsset, Dictionary<Metatag, string> m_Metatags, Metatag tag, string value)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			((AssetData)audioAsset).AddTag(value);
			m_Metatags[tag] = value;
		}

		internal static void AddMetaTag(AudioAsset audioAsset, Dictionary<Metatag, string> m_Metatags, Metatag tag, Track trackMeta, string oggTag, string value = null)
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			string text = value ?? GetExtendedTag(trackMeta, oggTag);
			if (!string.IsNullOrEmpty(text))
			{
				((AssetData)audioAsset).AddTag(oggTag.ToLower() + ":" + text);
				AddMetaTag(audioAsset, m_Metatags, tag, text);
			}
		}

		private static string GetExtendedTag(Track trackMeta, string tag)
		{
			if (trackMeta.AdditionalFields.TryGetValue(tag, out var value))
			{
				return value;
			}
			return null;
		}

		private static bool GetTimeTag(Track trackMeta, string tag, out double time)
		{
			if (trackMeta.AdditionalFields.TryGetValue(tag, out var value) && double.TryParse(value, out time))
			{
				return true;
			}
			time = -1.0;
			return false;
		}

		private static bool GetTimeTag(Track trackMeta, string tag, out float time)
		{
			if (trackMeta.AdditionalFields.TryGetValue(tag, out var value) && float.TryParse(value, out time))
			{
				return true;
			}
			time = -1f;
			return false;
		}

		internal static string GetClipPathFromAudiAsset(AudioAsset audioAsset)
		{
			foreach (string tag in ((AssetData)audioAsset).tags)
			{
				if (tag.Contains("AudioFilePath="))
				{
					string text = tag;
					int length = "AudioFilePath=".Length;
					return text.Substring(length, text.Length - length);
				}
			}
			return "";
		}

		internal static AudioType GetClipFormatFromAudiAsset(AudioAsset audioAsset)
		{
			//IL_0247: Unknown result type (might be due to invalid IL or missing references)
			//IL_024b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0220: Unknown result type (might be due to invalid IL or missing references)
			//IL_0227: Unknown result type (might be due to invalid IL or missing references)
			//IL_0228: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_021b: Unknown result type (might be due to invalid IL or missing references)
			//IL_020c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0202: Unknown result type (might be due to invalid IL or missing references)
			//IL_0216: Unknown result type (might be due to invalid IL or missing references)
			//IL_0207: Unknown result type (might be due to invalid IL or missing references)
			//IL_0211: Unknown result type (might be due to invalid IL or missing references)
			foreach (string tag in ((AssetData)audioAsset).tags)
			{
				if (tag.Contains("AudioFileFormat="))
				{
					string text = tag;
					int length = "AudioFileFormat=".Length;
					string text2 = text.Substring(length, text.Length - length);
					if (1 == 0)
					{
					}
					AudioType result = (AudioType)(text2 switch
					{
						"ACC" => 1, 
						"AIFF" => 2, 
						"IT" => 10, 
						"MOD" => 12, 
						"MPEG" => 13, 
						"S3M" => 17, 
						"WAV" => 20, 
						"XM" => 21, 
						"XMA" => 22, 
						"VAG" => 23, 
						"AUDIOQUEUE" => 24, 
						_ => 14, 
					});
					if (1 == 0)
					{
					}
					return result;
				}
			}
			return (AudioType)14;
		}
	}
	[Serializable]
	public class JsonAudioAsset
	{
		public string AudioFileFormat = "OGG";

		public string Title = null;

		public string Album = null;

		public string Artist = null;

		public string Type = null;

		public string Brand = null;

		public string RadioStation = null;

		public string RadioChannel = null;

		public string PSAType = null;

		public string AlertType = null;

		public string NewsType = null;

		public string WeatherType = null;

		public double loopStart = -1.0;

		public double loopEnd = -1.0;

		public double alternativeStart = -1.0;

		public float fadeoutTime = 1f;
	}
	public class RadioAddons
	{
		private static readonly List<string> addonsDirectories = new List<string>();

		internal static void LoadRadioAddons()
		{
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			foreach (string addonsDirectory in addonsDirectories)
			{
				string[] directories = Directory.GetDirectories(addonsDirectory);
				foreach (string text in directories)
				{
					if (!File.Exists(text + "\\RadioAddon.json"))
					{
						continue;
					}
					RadioAddon radioAddon = Decoder.Decode(File.ReadAllText(text + "\\RadioAddon.json")).Make<RadioAddon>();
					string[] directories2 = Directory.GetDirectories(text);
					foreach (string path in directories2)
					{
						string[] files = Directory.GetFiles(path, "*.ogg");
						foreach (string audioFilePath in files)
						{
							ExtendedRadio.AddAudioToDataBase(radioAddon.RadioNetwork, radioAddon.RadioChannel, radioAddon.Program, CustomRadios.StringToSegmentType(radioAddon.SegmentType), MusicLoader.LoadAudioFile(audioFilePath, CustomRadios.StringToSegmentType(radioAddon.SegmentType), radioAddon.RadioNetwork, radioAddon.RadioChannel));
						}
					}
				}
			}
		}

		public static void RegisterRadioAddonsDirectory(string path)
		{
			addonsDirectories.Add(path);
		}
	}
	[Serializable]
	public class RadioAddon
	{
		public string RadioNetwork = null;

		public string RadioChannel = null;

		public string Program = null;

		public string SegmentType = null;
	}
	public class Settings
	{
		public static bool customNetworkUI = true;

		public static bool DisableAdsOnStartup = false;

		public static bool SaveLastRadio = false;

		public static string LastRadio = null;

		internal static void LoadSettings()
		{
			if (Directory.Exists(GameManager_InitializeThumbnails.PathToMods) && File.Exists(GameManager_InitializeThumbnails.PathToMods + "\\settings.json"))
			{
				JsonToSettings(Decoder.Decode(File.ReadAllText(GameManager_InitializeThumbnails.PathToMods + "\\settings.json")).Make<SettingsJSON>());
			}
		}

		internal static void SaveSettings()
		{
			if (!Directory.Exists(GameManager_InitializeThumbnails.PathToMods))
			{
				Directory.CreateDirectory(GameManager_InitializeThumbnails.PathToMods);
			}
			File.WriteAllText(GameManager_InitializeThumbnails.PathToMods + "\\settings.json", Encoder.Encode((object)SettingsToJSON(), (EncodeOptions)0));
		}

		private static SettingsJSON SettingsToJSON()
		{
			return new SettingsJSON
			{
				customNetworkUI = customNetworkUI,
				DisableAdsOnStartup = DisableAdsOnStartup,
				SaveLastRadio = SaveLastRadio,
				LastRadio = LastRadio
			};
		}

		private static void JsonToSettings(SettingsJSON settingsJSON)
		{
			customNetworkUI = settingsJSON.customNetworkUI;
			DisableAdsOnStartup = settingsJSON.DisableAdsOnStartup;
			SaveLastRadio = settingsJSON.SaveLastRadio;
			LastRadio = settingsJSON.LastRadio;
		}
	}
	[Serializable]
	public class SettingsJSON
	{
		public bool customNetworkUI = true;

		public bool DisableAdsOnStartup = false;

		public bool SaveLastRadio = false;

		public string LastRadio = null;
	}
	internal class ExtendedRadioUI : UISystemBase
	{
		private GetterValueBinding<bool> customnetworkui;

		private GetterValueBinding<bool> DisableAdsOnStartup;

		private GetterValueBinding<bool> SaveLastRadio;

		protected override void OnCreate()
		{
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Expected O, but got Unknown
			((UISystemBase)this).OnCreate();
			((UISystemBase)this).AddBinding((IBinding)(object)(customnetworkui = new GetterValueBinding<bool>("extended_radio_settings", "customnetworkui", (Func<bool>)(() => Settings.customNetworkUI), (IWriter<bool>)null, (EqualityComparer<bool>)null)));
			((UISystemBase)this).AddBinding((IBinding)(object)new TriggerBinding<bool>("extended_radio_settings", "customnetworkui", (Action<bool>)UpdateSettings_customNetworkUi, (IReader<bool>)null));
			((UISystemBase)this).AddBinding((IBinding)(object)(DisableAdsOnStartup = new GetterValueBinding<bool>("extended_radio_settings", "DisableAdsOnStartup", (Func<bool>)(() => Settings.DisableAdsOnStartup), (IWriter<bool>)null, (EqualityComparer<bool>)null)));
			((UISystemBase)this).AddBinding((IBinding)(object)new TriggerBinding<bool>("extended_radio_settings", "DisableAdsOnStartup", (Action<bool>)UpdateSettings_disableAdsOnStartup, (IReader<bool>)null));
			((UISystemBase)this).AddBinding((IBinding)(object)(SaveLastRadio = new GetterValueBinding<bool>("extended_radio_settings", "SaveLastRadio", (Func<bool>)(() => Settings.SaveLastRadio), (IWriter<bool>)null, (EqualityComparer<bool>)null)));
			((UISystemBase)this).AddBinding((IBinding)(object)new TriggerBinding<bool>("extended_radio_settings", "SaveLastRadio", (Action<bool>)UpdateSettings_saveLastRadio, (IReader<bool>)null));
			((UISystemBase)this).AddBinding((IBinding)new TriggerBinding("extended_radio", "reloadradio", (Action)ReloadRadio));
		}

		private void UpdateSettings_customNetworkUi(bool newValue)
		{
			Settings.customNetworkUI = newValue;
			Settings.SaveSettings();
			customnetworkui.Update();
		}

		private void UpdateSettings_disableAdsOnStartup(bool newValue)
		{
			Settings.DisableAdsOnStartup = newValue;
			Settings.SaveSettings();
			DisableAdsOnStartup.Update();
		}

		private void UpdateSettings_saveLastRadio(bool newValue)
		{
			Settings.SaveLastRadio = newValue;
			if (newValue)
			{
				Settings.LastRadio = ExtendedRadio.radio.currentChannel.name;
			}
			Settings.SaveSettings();
			SaveLastRadio.Update();
		}

		private void ReloadRadio()
		{
			ExtendedRadio.radio.Reload(true);
		}

		internal static string GetStringFromEmbbededJSFile(string path)
		{
			return new StreamReader(ExtendedRadio.GetEmbedded("UI." + path)).ReadToEnd();
		}
	}
	internal class ExtendedRadioUI_Mono : MonoBehaviour
	{
		internal void ChangeUiNextFrame(string js)
		{
			((MonoBehaviour)this).StartCoroutine(ChangeUI(js));
		}

		private IEnumerator ChangeUI(string js)
		{
			yield return (object)new WaitForEndOfFrame();
			GameManager.instance.userInterface.view.View.ExecuteScript(js);
			yield return null;
		}
	}
	[BepInPlugin("ExtendedRadio", "ExtendedRadio", "0.5.3")]
	public class Plugin : BaseUnityPlugin
	{
		private void Awake()
		{
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Plugin ExtendedRadio is loaded!");
			Harmony val = Harmony.CreateAndPatchAll(Assembly.GetExecutingAssembly(), "ExtendedRadio_Cities2Harmony");
			MethodBase[] array = val.GetPatchedMethods().ToArray();
			((BaseUnityPlugin)this).Logger.LogInfo((object)("Plugin ExtendedRadio made patches! Patched methods: " + array.Length));
			MethodBase[] array2 = array;
			foreach (MethodBase methodBase in array2)
			{
				((BaseUnityPlugin)this).Logger.LogInfo((object)("Patched method: " + methodBase.Module.Name + ":" + methodBase.Name));
			}
		}
	}
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "ExtendedRadio";

		public const string PLUGIN_NAME = "ExtendedRadio";

		public const string PLUGIN_VERSION = "0.5.3";
	}
}
namespace ExtendedRadio.Patches
{
	[HarmonyPatch(typeof(SystemOrder), "Initialize")]
	public static class SystemOrderPatch
	{
		public static void Postfix(UpdateSystem updateSystem)
		{
			updateSystem.UpdateAt<ExtendedRadioUI>((SystemUpdatePhase)22);
		}
	}
	[HarmonyPatch(typeof(GameManager), "InitializeThumbnails")]
	internal class GameManager_InitializeThumbnails
	{
		internal static GameObject extendedRadioGameObject = new GameObject();

		internal static ExtendedRadioUI_Mono extendedRadioUi;

		private static readonly string IconsResourceKey = "ExtendedRadio".ToLower() ?? "";

		public static readonly string COUIBaseLocation = "coui://" + IconsResourceKey;

		internal static readonly string resources = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "resources");

		public static readonly string CustomRadiosPath = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "CustomRadios");

		private static readonly string PathToParent = Directory.GetParent(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location)).FullName;

		public static readonly string PathToMods = Path.Combine(PathToParent, "ExtendedRadio_mods");

		public static readonly string ModsFolderCustomRadio = Path.Combine(PathToMods, "CustomRadios");

		public static readonly string ModsFolderRadioAddons = Path.Combine(PathToMods, "RadioAddons");

		private static void Prefix(GameManager __instance)
		{
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Expected O, but got Unknown
			List<string> list = new List<string>(1) { Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location) };
			Directory.CreateDirectory(CustomRadiosPath);
			CustomRadios.RegisterCustomRadioDirectory(CustomRadiosPath);
			if (!Directory.Exists(resources))
			{
				Directory.CreateDirectory(resources);
				File.Move(Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "DefaultIcon.svg"), Path.Combine(resources, "DefaultIcon.svg"));
			}
			if (Directory.Exists(ModsFolderCustomRadio))
			{
				CustomRadios.RegisterCustomRadioDirectory(ModsFolderCustomRadio);
				list.Add(PathToMods);
			}
			if (Directory.Exists(ModsFolderRadioAddons))
			{
				RadioAddons.RegisterRadioAddonsDirectory(ModsFolderRadioAddons);
			}
			GameUIResourceHandler val = (GameUIResourceHandler)GameManager.instance.userInterface.view.uiSystem.resourceHandler;
			if (val == null)
			{
				Debug.LogError((object)"Failed retrieving GameManager's GameUIResourceHandler instance, exiting.");
				return;
			}
			((DefaultResourceHandler)val).HostLocationsMap.Add(IconsResourceKey, list);
			extendedRadioUi = extendedRadioGameObject.AddComponent<ExtendedRadioUI_Mono>();
		}
	}
	[HarmonyPatch(typeof(Radio), "LoadRadio")]
	internal class Radio_LoadRadio
	{
		private static void Postfix(Radio __instance)
		{
			ExtendedRadio.OnLoadRadio(__instance);
		}
	}
	[HarmonyPatch(typeof(RadioUISystem), "OnCreate")]
	internal class RadioUISystem_OnCreate
	{
		private static void Prefix(RadioUISystem __instance)
		{
			Settings.LoadSettings();
			AudioManager.instance.radio.skipAds = Settings.DisableAdsOnStartup;
		}
	}
	[HarmonyPatch(typeof(RadioUISystem), "SelectStation", new Type[] { typeof(string) })]
	internal class RadioUISystem_SelectStation
	{
		private static void Postfix(string name)
		{
			if (Settings.SaveLastRadio)
			{
				Settings.LastRadio = name;
				Settings.SaveSettings();
			}
		}
	}
	[HarmonyPatch(typeof(AudioAsset), "LoadAsync")]
	internal class AudioAssetLoadAsyncPatch
	{
		private static bool Prefix(AudioAsset __instance, ref Task<AudioClip> __result)
		{
			if (!CustomRadios.customeRadioChannelsName.Contains(__instance.GetMetaTag((Metatag)6)))
			{
				return true;
			}
			__result = LoadAudioFile(__instance);
			return false;
		}

		private static async Task<AudioClip> LoadAudioFile(AudioAsset audioAsset)
		{
			Traverse audioAssetTravers = Traverse.Create((object)audioAsset);
			if (audioAssetTravers.Field("m_Instance").GetValue() == null)
			{
				string sPath = MusicLoader.GetClipPathFromAudiAsset(audioAsset);
				UnityWebRequest www = UnityWebRequestMultimedia.GetAudioClip("file://" + sPath, MusicLoader.GetClipFormatFromAudiAsset(audioAsset));
				try
				{
					((DownloadHandlerAudioClip)www.downloadHandler).streamAudio = true;
					UnityWebRequestAwaiter val = ExtensionMethods.GetAwaiter(www.SendWebRequest());
					if (!val.IsCompleted)
					{
						await val;
						object obj = default(object);
						val = (UnityWebRequestAwaiter)obj;
					}
					val.GetResult();
					AudioClip clip = DownloadHandlerAudioClip.GetContent(www);
					www.Dispose();
					((Object)clip).name = sPath;
					((Object)clip).hideFlags = (HideFlags)52;
					audioAssetTravers.Field("m_Instance").SetValue((object)clip);
				}
				finally
				{
					((IDisposable)www)?.Dispose();
				}
			}
			return (AudioClip)audioAssetTravers.Field("m_Instance").GetValue();
		}
	}
	[HarmonyPatch(typeof(Radio), "GetPlaylistClips")]
	internal class Radio_GetPlaylistClips
	{
		private static bool Prefix(Radio __instance, RuntimeSegment segment)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			if (CustomRadios.customeRadioChannelsName.Contains(__instance.currentChannel.name))
			{
				IEnumerable<AudioAsset> audioAssetsFromAudioDataBase = ExtendedRadio.GetAudioAssetsFromAudioDataBase(__instance, segment.type);
				List<AudioAsset> list = new List<AudioAsset>();
				foreach (AudioAsset item in audioAssetsFromAudioDataBase)
				{
					list.Add(item);
				}
				List<AudioAsset> list2 = list;
				Random rnd = new Random();
				List<int> list3 = (from x in Enumerable.Range(0, list2.Count)
					orderby rnd.Next()
					select x).Take(segment.clipsCap).ToList();
				AudioAsset[] array = (AudioAsset[])(object)new AudioAsset[segment.clipsCap];
				for (int i = 0; i < array.Length; i++)
				{
					array[i] = list2[list3[i]];
				}
				segment.clips = array;
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(Radio), "GetCommercialClips")]
	internal class Radio_GetCommercialClips
	{
		private static bool Prefix(Radio __instance, RuntimeSegment segment)
		{
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			if (CustomRadios.customeRadioChannelsName.Contains(__instance.currentChannel.name))
			{
				Dictionary<string, RadioNetwork> value = Traverse.Create((object)__instance).Field("m_Networks").GetValue<Dictionary<string, RadioNetwork>>();
				if (!value.TryGetValue(__instance.currentChannel.network, out var value2) || !value2.allowAds)
				{
					return false;
				}
				IEnumerable<AudioAsset> audioAssetsFromAudioDataBase = ExtendedRadio.GetAudioAssetsFromAudioDataBase(__instance, segment.type);
				List<AudioAsset> list = new List<AudioAsset>();
				foreach (AudioAsset item in audioAssetsFromAudioDataBase)
				{
					list.Add(item);
				}
				List<AudioAsset> list2 = list;
				Random rnd = new Random();
				List<int> list3 = (from x in Enumerable.Range(0, list2.Count)
					orderby rnd.Next()
					select x).Take(segment.clipsCap).ToList();
				AudioAsset[] array = (AudioAsset[])(object)new AudioAsset[segment.clipsCap];
				for (int i = 0; i < array.Length; i++)
				{
					array[i] = list2[list3[i]];
				}
				segment.clips = array;
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(GamePanelUISystem), "ShowPanel", new Type[] { typeof(GamePanel) })]
	internal class GamePanelUISystem_TogglePanel : UISystemBase
	{
		private static void Postfix(GamePanelUISystem __instance, GamePanel panel)
		{
			if (panel is RadioPanel)
			{
				GameManager_InitializeThumbnails.extendedRadioUi.ChangeUiNextFrame(ExtendedRadioUI.GetStringFromEmbbededJSFile("Setup.js"));
				GameManager_InitializeThumbnails.extendedRadioUi.ChangeUiNextFrame(ExtendedRadioUI.GetStringFromEmbbededJSFile("ExtendedRadioSettings.js"));
				if (Settings.customNetworkUI)
				{
					GameManager_InitializeThumbnails.extendedRadioUi.ChangeUiNextFrame(ExtendedRadioUI.GetStringFromEmbbededJSFile("RadioNetworkFix.js"));
				}
			}
		}
	}
}
internal sealed class <>z__ReadOnlyArray<T> : IEnumerable, IEnumerable<T>, IReadOnlyCollection<T>, IReadOnlyList<T>, ICollection<T>, IList<T>
{
	int IReadOnlyCollection<T>.Count => _items.Length;

	T IReadOnlyList<T>.this[int index] => _items[index];

	int ICollection<T>.Count => _items.Length;

	bool ICollection<T>.IsReadOnly => true;

	T IList<T>.this[int index]
	{
		get
		{
			return _items[index];
		}
		set
		{
			throw new NotSupportedException();
		}
	}

	public <>z__ReadOnlyArray(T[] items)
	{
		_items = items;
	}

	IEnumerator IEnumerable.GetEnumerator()
	{
		return ((IEnumerable)_items).GetEnumerator();
	}

	IEnumerator<T> IEnumerable<T>.GetEnumerator()
	{
		return ((IEnumerable<T>)_items).GetEnumerator();
	}

	void ICollection<T>.Add(T item)
	{
		throw new NotSupportedException();
	}

	void ICollection<T>.Clear()
	{
		throw new NotSupportedException();
	}

	bool ICollection<T>.Contains(T item)
	{
		return ((ICollection<T>)_items).Contains(item);
	}

	void ICollection<T>.CopyTo(T[] array, int arrayIndex)
	{
		((ICollection<T>)_items).CopyTo(array, arrayIndex);
	}

	bool ICollection<T>.Remove(T item)
	{
		throw new NotSupportedException();
	}

	int IList<T>.IndexOf(T item)
	{
		return ((IList<T>)_items).IndexOf(item);
	}

	void IList<T>.Insert(int index, T item)
	{
		throw new NotSupportedException();
	}

	void IList<T>.RemoveAt(int index)
	{
		throw new NotSupportedException();
	}
}