using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.IO.Compression;
using System.Net.Http;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using Costura;
using GameNetcodeStuff;
using HarmonyLib;
using LethalShock.Patches;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json;
using Unity.Netcode;
using UnityEngine;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyCompany("LethalShock")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyDescription("PiShock integration")]
[assembly: AssemblyFileVersion("1.1.1.0")]
[assembly: AssemblyInformationalVersion("1.1.1+f8c3f4bfa95eff76c57b83de7654e650ae2e55d7")]
[assembly: AssemblyProduct("LethalShock")]
[assembly: AssemblyTitle("LethalShock")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.1.1.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
internal class <Module>
{
static <Module>()
{
AssemblyLoader.Attach();
}
}
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 LethalShock
{
public class PiShockApi
{
private string apiEndpoint = "https://do.pishock.com/api/apioperate/";
public string username { private get; set; }
public string apiKey { private get; set; }
public string code { private get; set; }
public string senderName { private get; set; }
public async Task Shock(int intensity, int duration)
{
HttpClient client = new HttpClient();
try
{
var requestData = new
{
Username = username,
Name = senderName,
Code = code,
Intensity = intensity,
Duration = duration,
Apikey = apiKey,
Op = 0
};
string jsonBody = JsonConvert.SerializeObject((object)requestData);
HttpContent content = (HttpContent)new StringContent(jsonBody, Encoding.UTF8, "application/json");
try
{
HttpResponseMessage response = await client.PostAsync(apiEndpoint, content);
if (response.IsSuccessStatusCode)
{
Console.WriteLine("Request sent successfully.");
return;
}
Console.WriteLine($"Error: {response.StatusCode} - {response.ReasonPhrase}");
Console.WriteLine("Response Content: " + await response.Content.ReadAsStringAsync());
}
finally
{
((IDisposable)content)?.Dispose();
}
}
finally
{
((IDisposable)client)?.Dispose();
}
}
public async Task Vibrate(int intensity, int duration)
{
HttpClient client = new HttpClient();
try
{
var requestData = new
{
Username = username,
Name = senderName,
Code = code,
Intensity = intensity,
Duration = duration,
Apikey = apiKey,
Op = 1
};
string jsonBody = JsonConvert.SerializeObject((object)requestData);
HttpContent content = (HttpContent)new StringContent(jsonBody, Encoding.UTF8, "application/json");
try
{
HttpResponseMessage response = await client.PostAsync(apiEndpoint, content);
if (response.IsSuccessStatusCode)
{
Console.WriteLine("Request sent successfully.");
return;
}
Console.WriteLine($"Error: {response.StatusCode} - {response.ReasonPhrase}");
Console.WriteLine("Response Content: " + await response.Content.ReadAsStringAsync());
}
finally
{
((IDisposable)content)?.Dispose();
}
}
finally
{
((IDisposable)client)?.Dispose();
}
}
public async Task Beep(int duration)
{
HttpClient client = new HttpClient();
try
{
var requestData = new
{
Username = username,
Name = senderName,
Code = code,
Duration = duration,
Apikey = apiKey,
Op = 2
};
string jsonBody = JsonConvert.SerializeObject((object)requestData);
HttpContent content = (HttpContent)new StringContent(jsonBody, Encoding.UTF8, "application/json");
try
{
HttpResponseMessage response = await client.PostAsync(apiEndpoint, content);
if (response.IsSuccessStatusCode)
{
Console.WriteLine("Request sent successfully.");
return;
}
Console.WriteLine($"Error: {response.StatusCode} - {response.ReasonPhrase}");
Console.WriteLine("Response Content: " + await response.Content.ReadAsStringAsync());
}
finally
{
((IDisposable)content)?.Dispose();
}
}
finally
{
((IDisposable)client)?.Dispose();
}
}
}
[BepInPlugin("LethalShock", "LethalShock", "1.1.1")]
public class LethalShock : BaseUnityPlugin
{
internal enum ShockModes
{
FIRST,
LAST,
RANDOM,
ROUND_ROBIN,
RANDOM_ALL,
ALL
}
private readonly Harmony harmony = new Harmony("LethalShock");
internal readonly string pishockLogId = "LethalShock (Lethal company)";
private readonly Random rnd = new Random();
internal static LethalShock instance;
internal ManualLogSource mls;
internal ConfigEntry<string> pishockUsername;
internal ConfigEntry<string> pishockApiKey;
internal ConfigEntry<string> pishockCodes;
internal ConfigEntry<bool> shockOnDeath;
internal ConfigEntry<bool> shockOnDamage;
internal ConfigEntry<bool> vibrateOnly;
internal ConfigEntry<bool> warningVibration;
internal ConfigEntry<bool> shockBasedOnHealth;
internal ConfigEntry<bool> shockOnFired;
internal ConfigEntry<int> duration;
internal ConfigEntry<int> maxIntensity;
internal ConfigEntry<int> minIntensity;
internal ConfigEntry<ShockModes> shockMode;
internal ConfigEntry<int> durationDeath;
internal ConfigEntry<int> intensityDeath;
internal ConfigEntry<ShockModes> modeDeath;
internal ConfigEntry<int> durationFired;
internal ConfigEntry<int> intensityFired;
internal ConfigEntry<ShockModes> modeFired;
internal ConfigEntry<bool> enableInterval;
internal ConfigEntry<int> interval;
internal ConfigEntry<bool> xtoysEnabled;
internal ConfigEntry<string> xtoysApiKey;
internal DateTime lastShock;
private bool DidDeath = false;
private bool DidFired = false;
private int roundRobin = 0;
private void Awake()
{
//IL_0170: Unknown result type (might be due to invalid IL or missing references)
//IL_017a: Expected O, but got Unknown
//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
//IL_01ad: Expected O, but got Unknown
mls = Logger.CreateLogSource("LethalShock");
mls.LogInfo((object)"LethalShock initiated");
pishockUsername = ((BaseUnityPlugin)this).Config.Bind<string>("LethalShock", "username", "", (ConfigDescription)null);
pishockApiKey = ((BaseUnityPlugin)this).Config.Bind<string>("LethalShock", "apikey", "", (ConfigDescription)null);
pishockCodes = ((BaseUnityPlugin)this).Config.Bind<string>("LethalShock", "codes", "code1,code2", (ConfigDescription)null);
shockOnDeath = ((BaseUnityPlugin)this).Config.Bind<bool>("LethalShock", "shockOnDeath", true, "Enable to get shocked when you die");
shockOnDamage = ((BaseUnityPlugin)this).Config.Bind<bool>("LethalShock", "shockOnDamage", true, "Enable to get shocked when you take damage (Based on the damage value)");
vibrateOnly = ((BaseUnityPlugin)this).Config.Bind<bool>("LethalShock", "vibrateOnly", false, "Enable to only use vibrations");
warningVibration = ((BaseUnityPlugin)this).Config.Bind<bool>("LethalShock", "warnning", true, "Enable to get a warning vibration before a shock");
shockBasedOnHealth = ((BaseUnityPlugin)this).Config.Bind<bool>("LethalShock", "shockByHealth", false, "Enable to calculate shock intensity based on your remaining health instead of the damage taken (shockOnDeath must be enabled)");
duration = ((BaseUnityPlugin)this).Config.Bind<int>("LethalShock", "duration", 1, "Duration of the shock/vibration");
maxIntensity = ((BaseUnityPlugin)this).Config.Bind<int>("LethalShock", "max", 80, new ConfigDescription("Maximum intensity of the shock/vibration", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 100), Array.Empty<object>()));
minIntensity = ((BaseUnityPlugin)this).Config.Bind<int>("LethalShock", "min", 1, new ConfigDescription("Minimum intensity of the shock/vibration", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 100), Array.Empty<object>()));
shockMode = ((BaseUnityPlugin)this).Config.Bind<ShockModes>("LethalShock", "mode", ShockModes.RANDOM, "What to do when you have multiple shockers?");
durationDeath = ((BaseUnityPlugin)this).Config.Bind<int>("LethalShock", "durationDeath", 5, "Duration of the shock/vibration when you die");
intensityDeath = ((BaseUnityPlugin)this).Config.Bind<int>("LethalShock", "intensityDeath", 100, "The intensity of the shock/vibration when you die");
modeDeath = ((BaseUnityPlugin)this).Config.Bind<ShockModes>("LethalShock", "modeDeath", ShockModes.ALL, "What to do when you have multiple shockers when you die");
durationFired = ((BaseUnityPlugin)this).Config.Bind<int>("LethalShock", "durationFired", 10, "Duration of the the shock/vibration when you get fired (gameover)");
intensityFired = ((BaseUnityPlugin)this).Config.Bind<int>("LethalShock", "intensityFired", 100, "Intensity of the shock/vibration when you get fired (gameover)");
modeFired = ((BaseUnityPlugin)this).Config.Bind<ShockModes>("LethalShock", "modeFired", ShockModes.ALL, "What to do when you have multiple shockers when you get fired (gameover)");
shockOnFired = ((BaseUnityPlugin)this).Config.Bind<bool>("LethalShock", "shockOnFired", true, "Should you get shocked when fired?");
enableInterval = ((BaseUnityPlugin)this).Config.Bind<bool>("LethalShock", "enableInterval", true, "Should there be a interval between damage shocks? (This makes bees and snear fleas bearable)");
interval = ((BaseUnityPlugin)this).Config.Bind<int>("LethalShock", "interval", 10, "Whats the interval between damage shocks?");
xtoysEnabled = ((BaseUnityPlugin)this).Config.Bind<bool>("LethalShock", "xtoysEnabled", false, "Use Xtoys instead of pishock? (Use XToys scripted located here: https://xtoys.app/scripts/lethalcompany");
xtoysApiKey = ((BaseUnityPlugin)this).Config.Bind<string>("LethalShock", "xtoysApiKey", "", "Apikey for Xtoys");
lastShock = DateTime.Now;
harmony.PatchAll(typeof(LethalShock));
harmony.PatchAll(typeof(PlayerControllerBPatch));
harmony.PatchAll(typeof(StartOfRoundPatch));
if ((Object)(object)instance == (Object)null)
{
instance = this;
}
}
internal void DoDamage(int dmg, int health)
{
TimeSpan timeSpan = DateTime.Now - lastShock;
if (enableInterval.Value && timeSpan < TimeSpan.FromSeconds(interval.Value))
{
((BaseUnityPlugin)this).Logger.LogDebug((object)("Didn't shock due to interval. LastShock: " + lastShock.ToLongTimeString()));
return;
}
int intensity = Mathf.Clamp(dmg, minIntensity.Value, maxIntensity.Value);
int num = 100 - health;
int intensity2 = Mathf.Clamp(num, minIntensity.Value, maxIntensity.Value);
if (shockBasedOnHealth.Value)
{
mls.LogInfo((object)("Shocking based on health for " + intensity2));
DoOperation(intensity2, duration.Value, shockMode.Value);
}
else if (shockOnDamage.Value)
{
mls.LogInfo((object)("Shocking based on damage for " + intensity));
DoOperation(intensity, duration.Value, shockMode.Value);
}
lastShock = DateTime.Now;
}
internal void DoDeath()
{
if (!DidDeath && shockOnDeath.Value)
{
((BaseUnityPlugin)this).Logger.LogInfo((object)"Death shock");
DoOperation(intensityDeath.Value, durationDeath.Value, modeDeath.Value);
DidDeath = true;
Task.Run(async delegate
{
await Task.Delay(20000);
DidDeath = false;
});
}
}
internal void DoFired()
{
if (!DidFired)
{
mls.LogInfo((object)"Fired shock");
DoOperation(intensityFired.Value, durationFired.Value, modeFired.Value);
DidFired = true;
Task.Run(async delegate
{
await Task.Delay(durationFired.Value * 1000);
DidFired = false;
});
}
}
private async void DoOperation(int intensity, int duration, ShockModes mode)
{
string[] codes = pishockCodes.Value.Split(new char[1] { ',' });
bool[] picked = PickShockers(mode, codes.Length);
if (!xtoysEnabled.Value)
{
for (int i = 0; i < codes.Length; i++)
{
mls.LogDebug((object)("Running DoOperation for shocker coded " + codes[i]));
if (!picked[i])
{
continue;
}
PiShockApi user = new PiShockApi
{
username = pishockUsername.Value,
apiKey = pishockApiKey.Value,
code = codes[i],
senderName = pishockLogId
};
if (vibrateOnly.Value || warningVibration.Value)
{
await user.Vibrate(intensity, duration);
if (!vibrateOnly.Value)
{
mls.LogDebug((object)"Vibrating with delay");
await Task.Delay(duration + 1000);
mls.LogDebug((object)"Shocking after delay");
await user.Shock(intensity, duration);
}
}
else
{
await user.Shock(intensity, duration);
}
}
return;
}
XToysApi xtoysApi = new XToysApi
{
apiKey = xtoysApiKey.Value
};
if (vibrateOnly.Value || warningVibration.Value)
{
await xtoysApi.Vibrate(intensity, duration);
if (!vibrateOnly.Value)
{
await Task.Delay(duration + 1000);
await xtoysApi.Shock(intensity, duration);
}
}
else
{
await xtoysApi.Shock(intensity, duration);
}
}
public bool NextBoolean(Random random)
{
return random.Next() > 1073741823;
}
private bool[] PickShockers(ShockModes mode, int length)
{
bool[] array = new bool[length];
int num = rnd.Next(0, length);
if (roundRobin >= length)
{
roundRobin = 0;
}
for (int i = 0; i < length; i++)
{
switch (mode)
{
case ShockModes.ALL:
array[i] = true;
break;
case ShockModes.RANDOM_ALL:
array[i] = NextBoolean(rnd);
break;
case ShockModes.RANDOM:
array[i] = i == num;
break;
case ShockModes.FIRST:
array[i] = i == 0;
break;
case ShockModes.LAST:
array[i] = i == length - 1;
break;
case ShockModes.ROUND_ROBIN:
array[i] = i == roundRobin;
break;
}
}
roundRobin++;
if (mode == ShockModes.RANDOM_ALL)
{
bool flag = false;
bool[] array2 = array;
for (int j = 0; j < array2.Length; j++)
{
if (array2[j])
{
flag = true;
break;
}
}
if (!flag)
{
array[num] = true;
}
}
return array;
}
}
public class XToysApi
{
private string apiEndpoint = "https://webhook.xtoys.app/";
public string apiKey { private get; set; }
public async Task Shock(int intensity, int duration)
{
HttpClient client = new HttpClient();
try
{
var requestData = new
{
intensity = intensity,
duration = duration,
action = "shock"
};
string jsonBody = JsonConvert.SerializeObject((object)requestData);
HttpContent content = (HttpContent)new StringContent(jsonBody, Encoding.UTF8, "application/json");
try
{
HttpResponseMessage response = await client.PostAsync(apiEndpoint + apiKey, content);
if (response.IsSuccessStatusCode)
{
Console.WriteLine("Request sent successfully. (XToys)");
return;
}
Console.WriteLine($"Error: {response.StatusCode} - {response.ReasonPhrase}");
Console.WriteLine("Response Content: " + await response.Content.ReadAsStringAsync());
}
finally
{
((IDisposable)content)?.Dispose();
}
}
finally
{
((IDisposable)client)?.Dispose();
}
}
public async Task Vibrate(int intensity, int duration)
{
HttpClient client = new HttpClient();
try
{
var requestData = new
{
intensity = intensity,
duration = duration,
action = "vibrate"
};
string jsonBody = JsonConvert.SerializeObject((object)requestData);
HttpContent content = (HttpContent)new StringContent(jsonBody, Encoding.UTF8, "application/json");
try
{
HttpResponseMessage response = await client.PostAsync(apiEndpoint + apiKey, content);
if (response.IsSuccessStatusCode)
{
Console.WriteLine("Request sent successfully. (XToys)");
return;
}
Console.WriteLine($"Error: {response.StatusCode} - {response.ReasonPhrase}");
Console.WriteLine("Response Content: " + await response.Content.ReadAsStringAsync());
}
finally
{
((IDisposable)content)?.Dispose();
}
}
finally
{
((IDisposable)client)?.Dispose();
}
}
public async Task Beep(int duration, int intensity)
{
HttpClient client = new HttpClient();
try
{
var requestData = new
{
duration = duration,
intensity = intensity,
action = "beep"
};
string jsonBody = JsonConvert.SerializeObject((object)requestData);
HttpContent content = (HttpContent)new StringContent(jsonBody, Encoding.UTF8, "application/json");
try
{
HttpResponseMessage response = await client.PostAsync(apiEndpoint + apiKey, content);
if (response.IsSuccessStatusCode)
{
Console.WriteLine("Request sent successfully.");
return;
}
Console.WriteLine($"Error: {response.StatusCode} - {response.ReasonPhrase}");
Console.WriteLine("Response Content: " + await response.Content.ReadAsStringAsync());
}
finally
{
((IDisposable)content)?.Dispose();
}
}
finally
{
((IDisposable)client)?.Dispose();
}
}
}
public static class PluginInfo
{
public const string PLUGIN_GUID = "LethalShock";
public const string PLUGIN_NAME = "LethalShock";
public const string PLUGIN_VERSION = "1.1.1";
}
}
namespace LethalShock.Patches
{
internal class PlayerControllerBPatch
{
[HarmonyPatch(typeof(PlayerControllerB), "KillPlayer")]
[HarmonyPostfix]
private static void DeathPatch(PlayerControllerB __instance)
{
if (((NetworkBehaviour)__instance).IsOwner)
{
LethalShock.instance.DoDeath();
}
}
[HarmonyPatch(typeof(PlayerControllerB), "DamagePlayer")]
[HarmonyPostfix]
private static void DamagePatch(int ___health, int damageNumber)
{
LethalShock.instance.DoDamage(damageNumber, ___health);
}
}
internal class StartOfRoundPatch
{
[HarmonyPatch(typeof(StartOfRound), "FirePlayersAfterDeadlineClientRpc")]
[HarmonyPostfix]
private static void FirePlayersAfterDeadlinePatch()
{
LethalShock.instance.DoFired();
}
}
}
namespace Costura
{
[CompilerGenerated]
internal static class AssemblyLoader
{
private static object nullCacheLock = new object();
private static Dictionary<string, bool> nullCache = new Dictionary<string, bool>();
private static Dictionary<string, string> assemblyNames = new Dictionary<string, string>();
private static Dictionary<string, string> symbolNames = new Dictionary<string, string>();
private static int isAttached;
private static string CultureToString(CultureInfo culture)
{
if (culture == null)
{
return "";
}
return culture.Name;
}
private static Assembly ReadExistingAssembly(AssemblyName name)
{
AppDomain currentDomain = AppDomain.CurrentDomain;
Assembly[] assemblies = currentDomain.GetAssemblies();
Assembly[] array = assemblies;
foreach (Assembly assembly in array)
{
AssemblyName name2 = assembly.GetName();
if (string.Equals(name2.Name, name.Name, StringComparison.InvariantCultureIgnoreCase) && string.Equals(CultureToString(name2.CultureInfo), CultureToString(name.CultureInfo), StringComparison.InvariantCultureIgnoreCase))
{
return assembly;
}
}
return null;
}
private static void CopyTo(Stream source, Stream destination)
{
byte[] array = new byte[81920];
int count;
while ((count = source.Read(array, 0, array.Length)) != 0)
{
destination.Write(array, 0, count);
}
}
private static Stream LoadStream(string fullName)
{
Assembly executingAssembly = Assembly.GetExecutingAssembly();
if (fullName.EndsWith(".compressed"))
{
using (Stream stream = executingAssembly.GetManifestResourceStream(fullName))
{
using DeflateStream source = new DeflateStream(stream, CompressionMode.Decompress);
MemoryStream memoryStream = new MemoryStream();
CopyTo(source, memoryStream);
memoryStream.Position = 0L;
return memoryStream;
}
}
return executingAssembly.GetManifestResourceStream(fullName);
}
private static Stream LoadStream(Dictionary<string, string> resourceNames, string name)
{
if (resourceNames.TryGetValue(name, out var value))
{
return LoadStream(value);
}
return null;
}
private static byte[] ReadStream(Stream stream)
{
byte[] array = new byte[stream.Length];
stream.Read(array, 0, array.Length);
return array;
}
private static Assembly ReadFromEmbeddedResources(Dictionary<string, string> assemblyNames, Dictionary<string, string> symbolNames, AssemblyName requestedAssemblyName)
{
string text = requestedAssemblyName.Name.ToLowerInvariant();
if (requestedAssemblyName.CultureInfo != null && !string.IsNullOrEmpty(requestedAssemblyName.CultureInfo.Name))
{
text = requestedAssemblyName.CultureInfo.Name + "." + text;
}
byte[] rawAssembly;
using (Stream stream = LoadStream(assemblyNames, text))
{
if (stream == null)
{
return null;
}
rawAssembly = ReadStream(stream);
}
using (Stream stream2 = LoadStream(symbolNames, text))
{
if (stream2 != null)
{
byte[] rawSymbolStore = ReadStream(stream2);
return Assembly.Load(rawAssembly, rawSymbolStore);
}
}
return Assembly.Load(rawAssembly);
}
public static Assembly ResolveAssembly(object sender, ResolveEventArgs e)
{
lock (nullCacheLock)
{
if (nullCache.ContainsKey(e.Name))
{
return null;
}
}
AssemblyName assemblyName = new AssemblyName(e.Name);
Assembly assembly = ReadExistingAssembly(assemblyName);
if ((object)assembly != null)
{
return assembly;
}
assembly = ReadFromEmbeddedResources(assemblyNames, symbolNames, assemblyName);
if ((object)assembly == null)
{
lock (nullCacheLock)
{
nullCache[e.Name] = true;
}
if ((assemblyName.Flags & AssemblyNameFlags.Retargetable) != 0)
{
assembly = Assembly.Load(assemblyName);
}
}
return assembly;
}
static AssemblyLoader()
{
assemblyNames.Add("costura", "costura.costura.dll.compressed");
symbolNames.Add("costura", "costura.costura.pdb.compressed");
assemblyNames.Add("newtonsoft.json", "costura.newtonsoft.json.dll.compressed");
assemblyNames.Add("system.diagnostics.diagnosticsource", "costura.system.diagnostics.diagnosticsource.dll.compressed");
}
public static void Attach()
{
if (Interlocked.Exchange(ref isAttached, 1) == 1)
{
return;
}
AppDomain currentDomain = AppDomain.CurrentDomain;
currentDomain.AssemblyResolve += delegate(object sender, ResolveEventArgs e)
{
lock (nullCacheLock)
{
if (nullCache.ContainsKey(e.Name))
{
return null;
}
}
AssemblyName assemblyName = new AssemblyName(e.Name);
Assembly assembly = ReadExistingAssembly(assemblyName);
if ((object)assembly != null)
{
return assembly;
}
assembly = ReadFromEmbeddedResources(assemblyNames, symbolNames, assemblyName);
if ((object)assembly == null)
{
lock (nullCacheLock)
{
nullCache[e.Name] = true;
}
if ((assemblyName.Flags & AssemblyNameFlags.Retargetable) != 0)
{
assembly = Assembly.Load(assemblyName);
}
}
return assembly;
};
}
}
}
internal class LethalShock_ProcessedByFody
{
internal const string FodyVersion = "6.8.0.0";
internal const string Costura = "5.7.0";
}
