using System;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using CSync.Extensions;
using CSync.Lib;
using GameNetcodeStuff;
using HarmonyLib;
using LobbyCompatibility.Attributes;
using Microsoft.CodeAnalysis;
using Unity.Netcode;
using UnityEngine;
using VirtualInsanity.Patches;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("justsunnit.virtual_insanity")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.1.6.0")]
[assembly: AssemblyInformationalVersion("1.1.6+65701cab9770b4cc315a62059137b963e9e06243")]
[assembly: AssemblyProduct("VirtualInsanity")]
[assembly: AssemblyTitle("justsunnit.virtual_insanity")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.1.6.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.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
internal sealed class NullableAttribute : Attribute
{
public readonly byte[] NullableFlags;
public NullableAttribute(byte P_0)
{
NullableFlags = new byte[1] { P_0 };
}
public NullableAttribute(byte[] P_0)
{
NullableFlags = P_0;
}
}
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
internal sealed class NullableContextAttribute : Attribute
{
public readonly byte Flag;
public NullableContextAttribute(byte P_0)
{
Flag = P_0;
}
}
[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 VirtualInsanity
{
public class Tools
{
public static bool checkNear(Vector3 Player, Vector3 target, int range)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
//IL_0012: Unknown result type (might be due to invalid IL or missing references)
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
//IL_0023: Unknown result type (might be due to invalid IL or missing references)
//IL_0029: Unknown result type (might be due to invalid IL or missing references)
//IL_0034: Unknown result type (might be due to invalid IL or missing references)
//IL_003a: Unknown result type (might be due to invalid IL or missing references)
if (Player.x > target.x - (float)range && Player.x < target.x + (float)range && Player.z > target.z - (float)range && Player.z < target.z - (float)range)
{
return true;
}
return false;
}
}
[BepInPlugin("justsunnit.virtual_insanity", "VirtualInsanity", "1.1.6")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency("com.sigurd.csync", "5.0.0")]
[LobbyCompatibility(/*Could not decode attribute arguments.*/)]
public class VirtualInsanity : BaseUnityPlugin
{
internal static VirtualInsanityConfig Config;
public static VirtualInsanity Instance { get; private set; }
internal static ManualLogSource Logger { get; private set; }
internal static Harmony? Harmony { get; set; }
private void Awake()
{
Logger = ((BaseUnityPlugin)this).Logger;
Instance = this;
Config = new VirtualInsanityConfig(((BaseUnityPlugin)this).Config);
Patch();
Logger.LogInfo((object)"justsunnit.virtual_insanity v1.1.6 has loaded!");
}
internal static void Patch()
{
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
//IL_0012: Unknown result type (might be due to invalid IL or missing references)
//IL_0018: Expected O, but got Unknown
if (Harmony == null)
{
Harmony = new Harmony("justsunnit.virtual_insanity");
}
Logger.LogDebug((object)"Patching...");
Harmony.PatchAll(typeof(PlayerPatches));
Harmony.PatchAll(typeof(JesterPatches));
Harmony.PatchAll(typeof(BlobPatches));
Harmony.PatchAll(typeof(BarberPatches));
Harmony.PatchAll(typeof(TerminalPatches));
Harmony.PatchAll(typeof(CoilHeadPatches));
Harmony.PatchAll(typeof(ThumperPatches));
Harmony.PatchAll(typeof(RoundPatches));
Harmony.PatchAll(typeof(SickAssRobot));
Harmony.PatchAll(typeof(SnareFleaPatches));
Harmony.PatchAll(typeof(BabyPatches));
Harmony.PatchAll(typeof(TimeODay));
Harmony.PatchAll(typeof(deezNutcrackerPatches));
Harmony.PatchAll(typeof(HudPatches));
Harmony.PatchAll(typeof(LeverPatches));
Logger.LogDebug((object)"Finished patching!");
}
internal static void Unpatch()
{
Logger.LogDebug((object)"Unpatching...");
Harmony? harmony = Harmony;
if (harmony != null)
{
harmony.UnpatchSelf();
}
Logger.LogDebug((object)"Finished unpatching!");
}
}
public class VirtualInsanityConfig : SyncedConfig2<VirtualInsanityConfig>
{
[SyncedEntryField]
public SyncedEntry<bool> DieOnExhaustion;
[SyncedEntryField]
public SyncedEntry<bool> DieOnWater;
[SyncedEntryField]
public SyncedEntry<bool> DieOnInsanity;
[SyncedEntryField]
public SyncedEntry<float> Drunkness;
[SyncedEntryField]
public SyncedEntry<bool> CanPullLever;
[SyncedEntryField]
public SyncedEntry<bool> ThumperChangesEnabled;
[SyncedEntryField]
public SyncedEntry<bool> JesterChangesEnabled;
[SyncedEntryField]
public SyncedEntry<bool> BabyChangesEnabled;
[SyncedEntryField]
public SyncedEntry<bool> BarberChangesEnabled;
[SyncedEntryField]
public SyncedEntry<bool> NutcrackerChangesEnabled;
[SyncedEntryField]
public SyncedEntry<bool> SnareChangesEnabled;
[SyncedEntryField]
public SyncedEntry<bool> RobotChangesEnabled;
[SyncedEntryField]
public SyncedEntry<bool> BlobChangesEnabled;
[SyncedEntryField]
public SyncedEntry<bool> CoilChangesEnabled;
[SyncedEntryField]
public SyncedEntry<bool> MeteorEnabled;
[SyncedEntryField]
public SyncedEntry<bool> EclipseEnabled;
[SyncedEntryField]
public SyncedEntry<bool> ElevatorBreakdownEnabled;
[SyncedEntryField]
public SyncedEntry<int> QuotaMultiplier;
public VirtualInsanityConfig(ConfigFile cfg)
: base("justsunnit.virtual_insanity")
{
//IL_008b: Unknown result type (might be due to invalid IL or missing references)
//IL_0095: Expected O, but got Unknown
//IL_0225: Unknown result type (might be due to invalid IL or missing references)
//IL_022f: Expected O, but got Unknown
DieOnExhaustion = SyncedBindingExtensions.BindSyncedEntry<bool>(cfg, "Player", "Die On Exhaustion", true, "Player dies upon exhaustion.");
DieOnWater = SyncedBindingExtensions.BindSyncedEntry<bool>(cfg, "Player", "Die On Water Contact", true, "Player dies upon water contact.");
DieOnInsanity = SyncedBindingExtensions.BindSyncedEntry<bool>(cfg, "Player", "Die On Max Insanity", true, "Player dies upon reaching maximum insanity.");
Drunkness = SyncedBindingExtensions.BindSyncedEntry<float>(cfg, "Player", "Drunkness", 0.2f, new ConfigDescription("Player's initial level of drunkness.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), Array.Empty<object>()));
CanPullLever = SyncedBindingExtensions.BindSyncedEntry<bool>(cfg, "Misc", "Can Pull Lever", true, "Allow players to pull the lever.");
ThumperChangesEnabled = SyncedBindingExtensions.BindSyncedEntry<bool>(cfg, "Enemies", "Thumper Changes Enabled", true, "Enable changes for Thumper enemy.");
JesterChangesEnabled = SyncedBindingExtensions.BindSyncedEntry<bool>(cfg, "Enemies", "Jester Changes Enabled", true, "Enable changes for Jester enemy.");
BabyChangesEnabled = SyncedBindingExtensions.BindSyncedEntry<bool>(cfg, "Enemies", "Baby Changes Enabled", true, "Enable changes for Baby enemy.");
BarberChangesEnabled = SyncedBindingExtensions.BindSyncedEntry<bool>(cfg, "Enemies", "Barber Changes Enabled", true, "Enable changes for Barber enemy.");
NutcrackerChangesEnabled = SyncedBindingExtensions.BindSyncedEntry<bool>(cfg, "Enemies", "Nutcracker Changes Enabled", true, "Enable changes for Nutcracker enemy.");
SnareChangesEnabled = SyncedBindingExtensions.BindSyncedEntry<bool>(cfg, "Enemies", "Snare Changes Enabled", true, "Enable changes for Snare enemy.");
RobotChangesEnabled = SyncedBindingExtensions.BindSyncedEntry<bool>(cfg, "Enemies", "Robot Changes Enabled", true, "Enable changes for Robot enemy.");
BlobChangesEnabled = SyncedBindingExtensions.BindSyncedEntry<bool>(cfg, "Enemies", "Blob Changes Enabled", true, "Enable changes for Blob enemy.");
CoilChangesEnabled = SyncedBindingExtensions.BindSyncedEntry<bool>(cfg, "Enemies", "Coil Changes Enabled", true, "Enable changes for Coil enemy.");
MeteorEnabled = SyncedBindingExtensions.BindSyncedEntry<bool>(cfg, "Environment", "Meteors Enabled", true, "Enable meteor events.");
EclipseEnabled = SyncedBindingExtensions.BindSyncedEntry<bool>(cfg, "Environment", "Eclipse All Planets Enabled", true, "Enable eclipses for all planets.");
ElevatorBreakdownEnabled = SyncedBindingExtensions.BindSyncedEntry<bool>(cfg, "Environment", "Elevator Breakdown Enabled", true, "Enable elevator breakdowns.");
QuotaMultiplier = SyncedBindingExtensions.BindSyncedEntry<int>(cfg, "Money", "Quota Multiplier", 2, new ConfigDescription("Multiplier for quotas.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 10), Array.Empty<object>()));
ConfigManager.Register<VirtualInsanityConfig>((SyncedConfig2<VirtualInsanityConfig>)(object)this);
Console.WriteLine("Config registered");
}
}
public static class MyPluginInfo
{
public const string PLUGIN_GUID = "justsunnit.virtual_insanity";
public const string PLUGIN_NAME = "VirtualInsanity";
public const string PLUGIN_VERSION = "1.1.6";
}
}
namespace VirtualInsanity.Patches
{
[HarmonyPatch(typeof(CaveDwellerAI), "Start")]
public class BabyPatches
{
[HarmonyPostfix]
public static void BabyPathes(CaveDwellerAI __instance)
{
if (VirtualInsanity.Config.BabyChangesEnabled.Value)
{
__instance.TransformIntoAdult();
}
}
}
[HarmonyPatch(typeof(ClaySurgeonAI), "HourChanged")]
public class BarberPatches
{
[HarmonyPostfix]
private static void BarberPatch(ClaySurgeonAI __instance)
{
if (VirtualInsanity.Config.BarberChangesEnabled.Value)
{
__instance.currentInterval = 1f;
}
}
}
[HarmonyPatch(typeof(BlobAI), "Update")]
public class BlobPatches
{
[HarmonyPostfix]
private static void BlobPatch(BlobAI __instance)
{
if (VirtualInsanity.Config.BlobChangesEnabled.Value)
{
__instance.tamedTimer = 0f;
}
}
}
[HarmonyPatch(typeof(SpringManAI), "Update")]
public class CoilHeadPatches
{
[HarmonyPostfix]
private static void CoilHeadPatch(SpringManAI __instance)
{
if (VirtualInsanity.Config.CoilChangesEnabled.Value)
{
__instance.loseAggroTimer = 0f;
}
}
}
[HarmonyPatch(typeof(NutcrackerEnemyAI), "Start")]
public class deezNutcrackerPatches
{
[HarmonyPostfix]
public static void NutcrakerPatch(NutcrackerEnemyAI __instance)
{
if (VirtualInsanity.Config.NutcrackerChangesEnabled.Value)
{
((EnemyAI)__instance).agent.speed = 10f;
__instance.torsoTurnSpeed = 2500f;
}
}
}
[HarmonyPatch(typeof(HUDManager), "Update")]
public class HudPatches
{
public static HUDManager Instance;
[HarmonyPostfix]
public static void Postfix(HUDManager __instance)
{
Instance = __instance;
}
}
[HarmonyPatch(typeof(JesterAI), "SetJesterInitialValues")]
public class JesterPatches
{
[HarmonyPostfix]
private static void JesterPatch(JesterAI __instance)
{
if (VirtualInsanity.Config.JesterChangesEnabled.Value)
{
__instance.popUpTimer = Random.Range(1f, 5f);
}
}
}
[HarmonyPatch(typeof(StartMatchLever), "Update")]
public class LeverPatches
{
[HarmonyPrefix]
public static void LeverPatch(StartMatchLever __instance)
{
if (__instance.playersManager.shipHasLanded && VirtualInsanity.Config.CanPullLever.Value)
{
if (RoundPatches.currentlevel.planetHasTime)
{
__instance.triggerScript.interactable = false;
}
else
{
__instance.triggerScript.interactable = true;
}
}
}
}
[HarmonyPatch(typeof(PlayerControllerB), "Update")]
public class PlayerPatches
{
public static bool playerInFacilty;
[HarmonyPostfix]
public static void PlayerPatch(PlayerControllerB __instance)
{
//IL_0041: Unknown result type (might be due to invalid IL or missing references)
//IL_004b: Unknown result type (might be due to invalid IL or missing references)
//IL_0051: Unknown result type (might be due to invalid IL or missing references)
//IL_0090: Unknown result type (might be due to invalid IL or missing references)
//IL_009a: Unknown result type (might be due to invalid IL or missing references)
//IL_00a0: 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_00e4: Unknown result type (might be due to invalid IL or missing references)
//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
if (!RoundPatches.ShipPhase)
{
if (VirtualInsanity.Config.DieOnExhaustion.Value && __instance.isExhausted)
{
__instance.KillPlayer(new Vector3(0f, 0f, 0f), true, (CauseOfDeath)0, 0, default(Vector3));
}
if (__instance.insanityLevel >= __instance.maxInsanityLevel && VirtualInsanity.Config.DieOnInsanity.Value)
{
__instance.KillPlayer(new Vector3(0f, 0f, 0f), true, (CauseOfDeath)0, 0, default(Vector3));
}
if (__instance.isUnderwater && VirtualInsanity.Config.DieOnWater.Value)
{
__instance.KillPlayer(new Vector3(0f, 0f, 0f), true, (CauseOfDeath)0, 0, default(Vector3));
}
__instance.drunkness = VirtualInsanity.Config.Drunkness.Value;
playerInFacilty = __instance.isInsideFactory;
}
else if (RoundPatches.ShipPhase)
{
__instance.drunkness = 0f;
}
}
}
public class RoundPatches
{
public static int time = 5;
public static bool tryDeath;
public static bool elevatorRunning;
public static SelectableLevel currentlevel = null;
public static bool ShipPhase;
[HarmonyPatch(typeof(StartOfRound), "Update")]
[HarmonyPostfix]
private static void StartOfRoundPatch(StartOfRound __instance)
{
//IL_0012: Unknown result type (might be due to invalid IL or missing references)
//IL_0022: Unknown result type (might be due to invalid IL or missing references)
//IL_0027: Unknown result type (might be due to invalid IL or missing references)
//IL_002c: Unknown result type (might be due to invalid IL or missing references)
//IL_0041: Unknown result type (might be due to invalid IL or missing references)
//IL_0055: Unknown result type (might be due to invalid IL or missing references)
//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
//IL_00bd: 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)
currentlevel = __instance.currentLevel;
Vector3 val = __instance.elevatorTransform.position + ((Component)__instance.localPlayerController).transform.position;
if (((Vector3)(ref val)).magnitude >= 5f && __instance.elevatorTransform.position != new Vector3(0f, 0f, 0f) && !tryDeath && elevatorRunning && PlayerPatches.playerInFacilty)
{
if (Random.RandomRangeInt(1, 11) == 1 && VirtualInsanity.Config.ElevatorBreakdownEnabled.Value)
{
PlayerControllerB localPlayerController = __instance.localPlayerController;
Vector3 val2 = new Vector3(0f, 0f, 0f);
val = default(Vector3);
localPlayerController.KillPlayer(val2, true, (CauseOfDeath)0, 0, val);
tryDeath = true;
HudPatches.Instance.DisplayTip("Death Reason", "Elevator Broke Down", true, false, "LC_EclipseTip");
}
else
{
tryDeath = true;
}
}
ShipPhase = __instance.inShipPhase;
}
[HarmonyPatch(typeof(StartOfRound), "OnShipLandedMiscEvents")]
[HarmonyPrefix]
public static bool StartOfRoundOnShipLandedMiscEventsPatch(StartOfRound __instance)
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_000c: Invalid comparison between Unknown and I4
if ((int)TimeOfDay.Instance.currentLevelWeather == 5)
{
switch (Random.RandomRangeInt(1, 4))
{
case 1:
HudPatches.Instance.DisplayTip("Caution", "Loitering On The Ship Will Not be Tolerated >:(", true, false, "LC_EclipseTip");
break;
case 2:
HudPatches.Instance.DisplayTip("Caution", "Ship Lever Is Broken Sowwy :c", true, false, "LC_EclipseTip");
break;
case 3:
HudPatches.Instance.DisplayTip("Caution", "GO BE PRODUCTIVE, FOR THE COMPANY!!!", true, false, "LC_EclipseTip");
break;
}
}
else
{
HudPatches.Instance.DisplayTip("71-Gordion", "Time to be Financially responsible", true, false, "LC_EclipseTip");
}
return true;
}
[HarmonyPatch(typeof(MineshaftElevatorController), "Update")]
[HarmonyPostfix]
public static void ElevatorControllerPatch(MineshaftElevatorController __instance)
{
elevatorRunning = __instance.elevatorJingleMusic.isPlaying;
if (!__instance.elevatorJingleMusic.isPlaying)
{
tryDeath = false;
}
}
}
public class SickAssRobot
{
[HarmonyPatch(typeof(RadMechAI), "Update")]
[HarmonyPostfix]
private static void Postfix(RadMechAI __instance)
{
if (VirtualInsanity.Config.RobotChangesEnabled.Value)
{
__instance.fireRate = 0.1f;
}
}
}
public class SnareFleaPatches
{
[HarmonyPatch(typeof(CentipedeAI), "Update")]
[HarmonyPostfix]
private static void CentipedePatch(CentipedeAI __instance)
{
if (VirtualInsanity.Config.SnareChangesEnabled.Value)
{
__instance.damagePlayerInterval = 0f;
}
}
}
[HarmonyPatch(typeof(Terminal), "Update")]
public class TerminalPatches
{
[HarmonyPostfix]
private static void ApplyMoonWeather(ref Terminal __instance)
{
//IL_0029: Unknown result type (might be due to invalid IL or missing references)
if (VirtualInsanity.Config.EclipseEnabled.Value)
{
SelectableLevel[] moonsCatalogueList = __instance.moonsCatalogueList;
foreach (SelectableLevel val in moonsCatalogueList)
{
val.currentWeather = (LevelWeatherType)5;
val.maxEnemyPowerCount = 40;
val.maxOutsideEnemyPowerCount = 60;
}
}
}
}
public class ThumperPatches
{
[HarmonyPatch(typeof(CrawlerAI), "Update")]
private static void ThumperPatch(CrawlerAI __instance)
{
if (VirtualInsanity.Config.ThumperChangesEnabled.Value)
{
((EnemyAI)__instance).agent.acceleration = 10f;
}
}
}
public class TimeODay
{
[HarmonyPatch(typeof(TimeOfDay), "DecideRandomDayEvents")]
[HarmonyPostfix]
public static void MeteorPatch(TimeOfDay __instance)
{
if (VirtualInsanity.Config.MeteorEnabled.Value)
{
__instance.meteorShowerAtTime = 0.1f;
}
}
[HarmonyPatch(typeof(TimeOfDay), "SetNewProfitQuota")]
[HarmonyPrefix]
public static void SetNewProfitQuota(TimeOfDay __instance)
{
if (!((NetworkBehaviour)__instance).IsServer)
{
return;
}
__instance.timesFulfilledQuota++;
int num = __instance.quotaFulfilled - __instance.profitQuota;
float num2 = Mathf.Clamp((float)(1.0 + (double)__instance.timesFulfilledQuota * ((double)__instance.timesFulfilledQuota / (double)__instance.quotaVariables.increaseSteepness)), 0f, 10000f);
__instance.CalculateLuckValue();
float num3 = Random.Range(0f, 1f);
Debug.Log((object)$"Randomizer amount before: {num3}");
float num4 = num3 * Mathf.Abs(__instance.luckValue - 1f);
Debug.Log((object)$"Randomizer amount after: {num4}");
float num5 = (float)((double)__instance.quotaVariables.baseIncrease * (double)num2 * ((double)__instance.quotaVariables.randomizerCurve.Evaluate(num4) * (double)__instance.quotaVariables.randomizerMultiplier + 1.0));
Debug.Log((object)$"Amount to increase quota:{num5}");
__instance.profitQuota = (int)Mathf.Clamp((float)__instance.profitQuota + num5, 0f, 1E+09f) * VirtualInsanity.Config.QuotaMultiplier.Value;
__instance.quotaFulfilled = 0;
__instance.timeUntilDeadline = __instance.totalTime * 4f;
int num6 = num / 5 + 15 * __instance.daysUntilDeadline;
__instance.furniturePlacedAtQuotaStart.Clear();
AutoParentToShip[] array = Object.FindObjectsByType<AutoParentToShip>((FindObjectsSortMode)0);
for (int i = 0; i < array.Length; i++)
{
if (array[i].unlockableID != -1)
{
__instance.furniturePlacedAtQuotaStart.Add(array[i].unlockableID);
}
}
__instance.SyncNewProfitQuotaClientRpc(__instance.profitQuota, num6, __instance.timesFulfilledQuota);
}
}
}
namespace System.Runtime.CompilerServices
{
[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
internal sealed class IgnoresAccessChecksToAttribute : Attribute
{
public IgnoresAccessChecksToAttribute(string assemblyName)
{
}
}
}
