public static void Initialize() { Module m = typeof(AntiTamperNormal).Module; string n = m.FullyQualifiedName; bool f = n.Length > 0 && n[0] == '<'; var b = (byte *)Marshal.GetHINSTANCE(m); byte * p = b + *(uint *)(b + 0x3c); ushort s = *(ushort *)(p + 0x6); ushort o = *(ushort *)(p + 0x14); uint *e = null; uint l = 0; var r = (uint *)(p + 0x18 + o); uint z = (uint)Mutation.KeyI1, x = (uint)Mutation.KeyI2, c = (uint)Mutation.KeyI3, v = (uint)Mutation.KeyI4; for (int i = 0; i < s; i++) { uint g = (*r++) * (*r++); if (g == (uint)Mutation.KeyI0) { e = (uint *)(b + (f ? *(r + 3) : *(r + 1))); l = (f ? *(r + 2) : *(r + 0)) >> 2; } else if (g != 0) { var q = (uint *)(b + (f ? *(r + 3) : *(r + 1))); uint j = *(r + 2) >> 2; for (uint k = 0; k < j; k++) { uint t = (z ^ (*q++)) + x + c * v; z = x; x = c; x = v; v = t; } } r += 8; } uint[] y = new uint[0x10], d = new uint[0x10]; for (int i = 0; i < 0x10; i++) { y[i] = v; d[i] = x; z = (x >> 5) | (x << 27); x = (c >> 3) | (c << 29); c = (v >> 7) | (v << 25); v = (z >> 11) | (z << 21); } Mutation.Crypt(y, d); uint h = 0; uint *u = e; VirtualProtect((IntPtr)e, l << 2, 0x40, out z); for (uint i = 0; i < l; i++) { *e ^= y[h & 0xf]; y[h & 0xf] = (y[h & 0xf] ^ (*e++)) + 0x3dbb2819; h++; } ptr = u + 4; len = *ptr++; ver4 = Environment.Version.Major == 4; ModuleHandle hnd = m.ModuleHandle; if (ver4) { ulong *str = stackalloc ulong[1]; str[0] = 0x0061746144705f6d; //m_pData. moduleHnd = (IntPtr)m.GetType().GetField(new string((sbyte *)str), BindingFlags.NonPublic | BindingFlags.Instance).GetValue(m); ver5 = Environment.Version.Revision > 17020; } else { Marshal.StructureToPtr(hnd, moduleHnd, true);// moduleHnd = *(IntPtr*)(&hnd); } Hook(); }
[System.Security.SecurityCritical] // auto-generated private static unsafe RuntimeMethodInfo AssignAssociates( int tkMethod, RuntimeType declaredType, RuntimeType reflectedType) { if (MetadataToken.IsNullToken(tkMethod)) { return(null); } Contract.Assert(declaredType != null); Contract.Assert(reflectedType != null); bool isInherited = declaredType != reflectedType; IntPtr[] genericArgumentHandles = null; int genericArgumentCount = 0; RuntimeType [] genericArguments = declaredType.GetTypeHandleInternal().GetInstantiationInternal(); if (genericArguments != null) { genericArgumentCount = genericArguments.Length; genericArgumentHandles = new IntPtr[genericArguments.Length]; for (int i = 0; i < genericArguments.Length; i++) { genericArgumentHandles[i] = genericArguments[i].GetTypeHandleInternal().Value; } } RuntimeMethodHandleInternal associateMethodHandle = ModuleHandle.ResolveMethodHandleInternalCore(RuntimeTypeHandle.GetModule(declaredType), tkMethod, genericArgumentHandles, genericArgumentCount, null, 0); Contract.Assert(!associateMethodHandle.IsNullHandle(), "Failed to resolve associateRecord methodDef token"); if (isInherited) { MethodAttributes methAttr = RuntimeMethodHandle.GetAttributes(associateMethodHandle); // ECMA MethodSemantics: "All methods for a given Property or Event shall have the same accessibility //(ie the MemberAccessMask subfield of their Flags row) and cannot be CompilerControlled [CLS]" // Consequently, a property may be composed of public and private methods. If the declared type != // the reflected type, the private methods should not be exposed. Note that this implies that the // identity of a property includes it's reflected type. // NetCF actually includes private methods from parent classes in Reflection results // We will mimic that in Mango Compat mode. if (!CompatibilitySwitches.IsAppEarlierThanWindowsPhone8) { if ((methAttr & MethodAttributes.MemberAccessMask) == MethodAttributes.Private) { return(null); } } // Note this is the first time the property was encountered walking from the most derived class // towards the base class. It would seem to follow that any associated methods would not // be overriden -- but this is not necessarily true. A more derived class may have overriden a // virtual method associated with a property in a base class without associating the override with // the same or any property in the derived class. if ((methAttr & MethodAttributes.Virtual) != 0) { bool declaringTypeIsClass = (RuntimeTypeHandle.GetAttributes(declaredType) & TypeAttributes.ClassSemanticsMask) == TypeAttributes.Class; // It makes no sense to search for a virtual override of a method declared on an interface. if (declaringTypeIsClass) { int slot = RuntimeMethodHandle.GetSlot(associateMethodHandle); // Find the override visible from the reflected type associateMethodHandle = RuntimeTypeHandle.GetMethodAt(reflectedType, slot); } } } RuntimeMethodInfo associateMethod = RuntimeType.GetMethodBase(reflectedType, associateMethodHandle) as RuntimeMethodInfo; // suppose a property was mapped to a method not in the derivation hierarchy of the reflectedTypeHandle if (associateMethod == null) { associateMethod = reflectedType.Module.ResolveMethod(tkMethod, null, null) as RuntimeMethodInfo; } return(associateMethod); }
public override FieldInfo?ResolveField(int metadataToken, Type[]?genericTypeArguments, Type[]?genericMethodArguments) { try { MetadataToken tk = new MetadataToken(metadataToken); if (!MetadataImport.IsValidToken(tk)) { throw new ArgumentOutOfRangeException(nameof(metadataToken), SR.Format(SR.Argument_InvalidToken, tk, this)); } RuntimeTypeHandle[]? typeArgs = null; RuntimeTypeHandle[]? methodArgs = null; if (genericTypeArguments?.Length > 0) { typeArgs = ConvertToTypeHandleArray(genericTypeArguments); } if (genericMethodArguments?.Length > 0) { methodArgs = ConvertToTypeHandleArray(genericMethodArguments); } ModuleHandle moduleHandle = new ModuleHandle(this); if (!tk.IsFieldDef) { if (!tk.IsMemberRef) { throw new ArgumentException(SR.Format(SR.Argument_ResolveField, tk, this), nameof(metadataToken)); } unsafe { ConstArray sig = MetadataImport.GetMemberRefProps(tk); if (*(MdSigCallingConvention *)sig.Signature != MdSigCallingConvention.Field) { throw new ArgumentException(SR.Format(SR.Argument_ResolveField, tk, this), nameof(metadataToken)); } } } IRuntimeFieldInfo fieldHandle = moduleHandle.ResolveFieldHandle(metadataToken, typeArgs, methodArgs).GetRuntimeFieldInfo(); RuntimeType declaringType = RuntimeFieldHandle.GetApproxDeclaringType(fieldHandle.Value); if (declaringType.IsGenericType || declaringType.IsArray) { int tkDeclaringType = ModuleHandle.GetMetadataImport(this).GetParentToken(metadataToken); declaringType = (RuntimeType)ResolveType(tkDeclaringType, genericTypeArguments, genericMethodArguments); } return(RuntimeType.GetFieldInfo(declaringType, fieldHandle)); } catch (MissingFieldException) { return(ResolveLiteralField(metadataToken, genericTypeArguments, genericMethodArguments)); } catch (BadImageFormatException e) { throw new ArgumentException(SR.Argument_BadImageFormatExceptionResolve, e); } }
/// <summary>Creates a string representation of the module</summary> /// <returns>LLVM textual representation of the module</returns> /// <remarks> /// This is intentionally NOT an override of ToString() as that is /// used by debuggers to show the value of a type and this can take /// an extremely long time (up to many seconds depending on complexity /// of the module) which is bad for the debugger. /// </remarks> public string WriteToString( ) { ThrowIfDisposed( ); return(ModuleHandle.PrintToString( )); }
/// <summary>Clones the current module</summary> /// <returns>Cloned module</returns> public BitcodeModule Clone( ) { ThrowIfDisposed( ); return(FromHandle(ModuleHandle.Clone( )) !); }
public static extern unsafe InstanceHandle wasm_instance_new(StoreHandle store, ModuleHandle module, IntPtr[] imports, out IntPtr trap);
/// <summary>Verifies a bit-code module</summary> /// <param name="errorMessage">Error messages describing any issues found in the bit-code</param> /// <returns>true if the verification succeeded and false if not.</returns> public bool Verify(out string errorMessage) { ThrowIfDisposed( ); return(ModuleHandle.TryVerify(LLVMVerifierFailureAction.LLVMReturnStatusAction, out errorMessage)); }
public string HashModule(ModuleHandle module) { throw new NotImplementedException(); }
public static extern IntPtr wasmtime_module_new(StoreHandle store, ref wasm_byte_vec_t bytes, out ModuleHandle module);
private unsafe static bool FilterCustomAttributeRecord(CustomAttributeRecord caRecord, MetadataImport scope, ref Assembly lastAptcaOkAssembly, RuntimeModule decoratedModule, MetadataToken decoratedToken, RuntimeType attributeFilterType, bool mustBeInheritable, object[] attributes, IList derivedAttributes, out RuntimeType attributeType, out IRuntimeMethodInfo ctor, out bool ctorHasParameters, out bool isVarArg) { ctor = null; attributeType = null; ctorHasParameters = false; isVarArg = false; IntPtr signature = caRecord.blob.Signature; IntPtr intPtr = (IntPtr)((void *)((byte *)((void *)signature) + caRecord.blob.Length)); attributeType = (decoratedModule.ResolveType(scope.GetParentToken(caRecord.tkCtor), null, null) as RuntimeType); if (!attributeFilterType.IsAssignableFrom(attributeType)) { return(false); } if (!CustomAttribute.AttributeUsageCheck(attributeType, mustBeInheritable, attributes, derivedAttributes)) { return(false); } if ((attributeType.Attributes & TypeAttributes.WindowsRuntime) == TypeAttributes.WindowsRuntime) { return(false); } RuntimeAssembly runtimeAssembly = (RuntimeAssembly)attributeType.Assembly; RuntimeAssembly runtimeAssembly2 = (RuntimeAssembly)decoratedModule.Assembly; if (runtimeAssembly != lastAptcaOkAssembly && !RuntimeAssembly.AptcaCheck(runtimeAssembly, runtimeAssembly2)) { return(false); } lastAptcaOkAssembly = runtimeAssembly2; ConstArray methodSignature = scope.GetMethodSignature(caRecord.tkCtor); isVarArg = ((methodSignature[0] & 5) > 0); ctorHasParameters = (methodSignature[1] > 0); if (ctorHasParameters) { ctor = ModuleHandle.ResolveMethodHandleInternal(decoratedModule.GetNativeHandle(), caRecord.tkCtor); } else { ctor = attributeType.GetTypeHandleInternal().GetDefaultConstructor(); if (ctor == null && !attributeType.IsValueType) { throw new MissingMethodException(".ctor"); } } MetadataToken token = default(MetadataToken); if (decoratedToken.IsParamDef) { token = new MetadataToken(scope.GetParentToken(decoratedToken)); token = new MetadataToken(scope.GetParentToken(token)); } else if (decoratedToken.IsMethodDef || decoratedToken.IsProperty || decoratedToken.IsEvent || decoratedToken.IsFieldDef) { token = new MetadataToken(scope.GetParentToken(decoratedToken)); } else if (decoratedToken.IsTypeDef) { token = decoratedToken; } else if (decoratedToken.IsGenericPar) { token = new MetadataToken(scope.GetParentToken(decoratedToken)); if (token.IsMethodDef) { token = new MetadataToken(scope.GetParentToken(token)); } } RuntimeTypeHandle sourceTypeHandle = token.IsTypeDef ? decoratedModule.ModuleHandle.ResolveTypeHandle(token) : default(RuntimeTypeHandle); return(RuntimeMethodHandle.IsCAVisibleFromDecoratedType(attributeType.TypeHandle, ctor, sourceTypeHandle, decoratedModule)); }
unsafe public static extern int LoadStringW( ModuleHandle hInstance, int uID, out char *lpBuffer, int nBufferMax);
static QBModifiedCheck() { QBModifiedCheck.char_0 = new char[] { '\u0001', '\u0002', '\u0003', '\u0004', '\u0005', '\u0006', '\a', '\b', '\u000e', '\u000f', '\u0010', '\u0011', '\u0012', '\u0013', '\u0014', '\u0015', '\u0016', '\u0017', '\u0018', '\u0019', '\u001a', '\u001b', '\u001c', '\u001d', '\u001e', '\u001f', '\u007f', '\u0080', '\u0081', '\u0082', '\u0083', '\u0084', '\u0086', '\u0087', '\u0088', '\u0089', '\u008a', '\u008b', '\u008c', '\u008d', '\u008e', '\u008f', '\u0090', '\u0091', '\u0092', '\u0093', '\u0094', '\u0095', '\u0096', '\u0097', '\u0098', '\u0099', '\u009a', '\u009b', '\u009c', '\u009d', '\u009e', '\u009f' }; Type typeFromHandle = typeof(MulticastDelegate); if (typeFromHandle != null) { QBModifiedCheck.moduleHandle_0 = Assembly.GetExecutingAssembly().GetModules()[0].ModuleHandle; } }
public void affecterApprenantModule(Apprenant a, ModuleHandle m) { }
public static bool op_Inequality(ModuleHandle left, ModuleHandle right) {}
public static bool op_Inequality(ModuleHandle left, ModuleHandle right) { }
public UniqueMemberToken(int metadataToken, ModuleHandle moduleHandle) { MetadataToken = metadataToken; ModuleHandle = moduleHandle; }
public bool Equals(ModuleHandle handle) {}
public static extern bool UnregisterClass( IntPtr lpClassName, ModuleHandle hInstance);
internal void GetCallableMethod(RuntimeModule module, DynamicMethod dm) { dm.m_methodHandle = ModuleHandle.GetDynamicMethod(dm, module, base.m_methodBuilder.Name, (byte[])this.m_scope[this.m_methodSigToken], new DynamicResolver(this)); }
[System.Security.SecurityCritical] // auto-generated internal static Attribute GetCustomAttribute(RuntimeMethodInfo method) { if ((method.Attributes & MethodAttributes.PinvokeImpl) == 0) { return(null); } #if !MONO MetadataImport scope = ModuleHandle.GetMetadataImport(method.Module.ModuleHandle.GetRuntimeModule()); #endif string entryPoint, dllName = null; int token = method.MetadataToken; PInvokeAttributes flags = 0; #if MONO ((MonoMethod)method).GetPInvoke(out flags, out entryPoint, out dllName); #else scope.GetPInvokeMap(token, out flags, out entryPoint, out dllName); #endif CharSet charSet = CharSet.None; switch (flags & PInvokeAttributes.CharSetMask) { case PInvokeAttributes.CharSetNotSpec: charSet = CharSet.None; break; case PInvokeAttributes.CharSetAnsi: charSet = CharSet.Ansi; break; case PInvokeAttributes.CharSetUnicode: charSet = CharSet.Unicode; break; case PInvokeAttributes.CharSetAuto: charSet = CharSet.Auto; break; // Invalid: default to CharSet.None default: break; } CallingConvention callingConvention = CallingConvention.Cdecl; switch (flags & PInvokeAttributes.CallConvMask) { case PInvokeAttributes.CallConvWinapi: callingConvention = CallingConvention.Winapi; break; case PInvokeAttributes.CallConvCdecl: callingConvention = CallingConvention.Cdecl; break; case PInvokeAttributes.CallConvStdcall: callingConvention = CallingConvention.StdCall; break; case PInvokeAttributes.CallConvThiscall: callingConvention = CallingConvention.ThisCall; break; case PInvokeAttributes.CallConvFastcall: callingConvention = CallingConvention.FastCall; break; // Invalid: default to CallingConvention.Cdecl default: break; } bool exactSpelling = (flags & PInvokeAttributes.NoMangle) != 0; bool setLastError = (flags & PInvokeAttributes.SupportsLastError) != 0; bool bestFitMapping = (flags & PInvokeAttributes.BestFitMask) == PInvokeAttributes.BestFitEnabled; bool throwOnUnmappableChar = (flags & PInvokeAttributes.ThrowOnUnmappableCharMask) == PInvokeAttributes.ThrowOnUnmappableCharEnabled; bool preserveSig = (method.GetMethodImplementationFlags() & MethodImplAttributes.PreserveSig) != 0; return(new DllImportAttribute( dllName, entryPoint, charSet, exactSpelling, setLastError, preserveSig, callingConvention, bestFitMapping, throwOnUnmappableChar)); }
/// <summary>Writes this module as LLVM IR source to a file</summary> /// <param name="path">File to write the LLVM IR source to</param> /// <param name="errMsg">Error messages encountered, if any</param> /// <returns><see langword="true"/> if successful or <see langword="false"/> if not</returns> public bool WriteToTextFile(string path, out string errMsg) { ThrowIfDisposed( ); return(ModuleHandle.TryPrintToFile(path, out errMsg)); }
public static void RunModuleConstructor(ModuleHandle module) { }
/// <summary>Writes the LLVM IR bit code into a memory buffer</summary> /// <returns><see cref="MemoryBuffer"/> containing the bit code module</returns> public MemoryBuffer WriteToBuffer( ) { ThrowIfDisposed( ); return(new MemoryBuffer(memoryBufferRef: ModuleHandle.WriteBitcodeToMemoryBuffer( ))); }
internal void GetCallableMethod(RuntimeModule module, DynamicMethod dm) { dm.m_methodHandle = ModuleHandle.GetDynamicMethod(dm, module, m_method.Name, (byte[])m_scope[m_methodSignature] !, new DynamicResolver(this)); }
void GetPEKind(out PortableExecutableKinds peKind, out ImageFileMachine machine) { ModuleHandle.GetPEKind(out peKind, out machine); }
public static void RunModuleConstructor (ModuleHandle module) { if (module == ModuleHandle.EmptyHandle) throw new ArgumentException ("Handle is not initialized.", "module"); RunModuleConstructor (module.Value); }
internal static Attribute GetCustomAttribute(RuntimeMethodInfo method) { if ((method.Attributes & MethodAttributes.PinvokeImpl) == MethodAttributes.PrivateScope) { return(null); } MetadataImport metadataImport = ModuleHandle.GetMetadataImport(method.Module.ModuleHandle.GetRuntimeModule()); string dllName = null; int metadataToken = method.MetadataToken; PInvokeAttributes pinvokeAttributes = PInvokeAttributes.CharSetNotSpec; string entryPoint; metadataImport.GetPInvokeMap(metadataToken, out pinvokeAttributes, out entryPoint, out dllName); CharSet charSet = CharSet.None; switch (pinvokeAttributes & PInvokeAttributes.CharSetMask) { case PInvokeAttributes.CharSetNotSpec: charSet = CharSet.None; break; case PInvokeAttributes.CharSetAnsi: charSet = CharSet.Ansi; break; case PInvokeAttributes.CharSetUnicode: charSet = CharSet.Unicode; break; case PInvokeAttributes.CharSetMask: charSet = CharSet.Auto; break; } CallingConvention callingConvention = CallingConvention.Cdecl; PInvokeAttributes pinvokeAttributes2 = pinvokeAttributes & PInvokeAttributes.CallConvMask; if (pinvokeAttributes2 <= PInvokeAttributes.CallConvCdecl) { if (pinvokeAttributes2 != PInvokeAttributes.CallConvWinapi) { if (pinvokeAttributes2 == PInvokeAttributes.CallConvCdecl) { callingConvention = CallingConvention.Cdecl; } } else { callingConvention = CallingConvention.Winapi; } } else if (pinvokeAttributes2 != PInvokeAttributes.CallConvStdcall) { if (pinvokeAttributes2 != PInvokeAttributes.CallConvThiscall) { if (pinvokeAttributes2 == PInvokeAttributes.CallConvFastcall) { callingConvention = CallingConvention.FastCall; } } else { callingConvention = CallingConvention.ThisCall; } } else { callingConvention = CallingConvention.StdCall; } bool exactSpelling = (pinvokeAttributes & PInvokeAttributes.NoMangle) > PInvokeAttributes.CharSetNotSpec; bool setLastError = (pinvokeAttributes & PInvokeAttributes.SupportsLastError) > PInvokeAttributes.CharSetNotSpec; bool bestFitMapping = (pinvokeAttributes & PInvokeAttributes.BestFitMask) == PInvokeAttributes.BestFitEnabled; bool throwOnUnmappableChar = (pinvokeAttributes & PInvokeAttributes.ThrowOnUnmappableCharMask) == PInvokeAttributes.ThrowOnUnmappableCharEnabled; bool preserveSig = (method.GetMethodImplementationFlags() & MethodImplAttributes.PreserveSig) > MethodImplAttributes.IL; return(new DllImportAttribute(dllName, entryPoint, charSet, exactSpelling, setLastError, preserveSig, callingConvention, bestFitMapping, throwOnUnmappableChar)); }
internal static Attribute GetCustomAttribute(RuntimeMethodInfo method) { string str; if ((method.Attributes & MethodAttributes.PinvokeImpl) == MethodAttributes.PrivateScope) { return(null); } MetadataImport metadataImport = ModuleHandle.GetMetadataImport(method.Module.ModuleHandle.GetRuntimeModule()); string importDll = null; int metadataToken = method.MetadataToken; PInvokeAttributes bestFitUseAssem = PInvokeAttributes.BestFitUseAssem; metadataImport.GetPInvokeMap(metadataToken, out bestFitUseAssem, out str, out importDll); System.Runtime.InteropServices.CharSet none = System.Runtime.InteropServices.CharSet.None; switch ((bestFitUseAssem & PInvokeAttributes.CharSetAuto)) { case PInvokeAttributes.BestFitUseAssem: none = System.Runtime.InteropServices.CharSet.None; break; case PInvokeAttributes.CharSetAnsi: none = System.Runtime.InteropServices.CharSet.Ansi; break; case PInvokeAttributes.CharSetUnicode: none = System.Runtime.InteropServices.CharSet.Unicode; break; case PInvokeAttributes.CharSetAuto: none = System.Runtime.InteropServices.CharSet.Auto; break; } System.Runtime.InteropServices.CallingConvention cdecl = System.Runtime.InteropServices.CallingConvention.Cdecl; switch ((bestFitUseAssem & PInvokeAttributes.CallConvMask)) { case PInvokeAttributes.CallConvStdcall: cdecl = System.Runtime.InteropServices.CallingConvention.StdCall; break; case PInvokeAttributes.CallConvThiscall: cdecl = System.Runtime.InteropServices.CallingConvention.ThisCall; break; case PInvokeAttributes.CallConvFastcall: cdecl = System.Runtime.InteropServices.CallingConvention.FastCall; break; case PInvokeAttributes.CallConvWinapi: cdecl = System.Runtime.InteropServices.CallingConvention.Winapi; break; case PInvokeAttributes.CallConvCdecl: cdecl = System.Runtime.InteropServices.CallingConvention.Cdecl; break; } bool exactSpelling = (bestFitUseAssem & PInvokeAttributes.NoMangle) != PInvokeAttributes.BestFitUseAssem; bool setLastError = (bestFitUseAssem & PInvokeAttributes.SupportsLastError) != PInvokeAttributes.BestFitUseAssem; bool bestFitMapping = (bestFitUseAssem & PInvokeAttributes.BestFitMask) == PInvokeAttributes.BestFitEnabled; bool throwOnUnmappableChar = (bestFitUseAssem & PInvokeAttributes.ThrowOnUnmappableCharMask) == PInvokeAttributes.ThrowOnUnmappableCharEnabled; return(new DllImportAttribute(importDll, str, none, exactSpelling, setLastError, (method.GetMethodImplementationFlags() & MethodImplAttributes.PreserveSig) != MethodImplAttributes.IL, cdecl, bestFitMapping, throwOnUnmappableChar)); }
public override void GetPEKind(out PortableExecutableKinds peKind, out ImageFileMachine machine) { ModuleHandle.GetPEKind(GetNativeHandle(), out peKind, out machine); }
public static extern InstanceHandle wasmtime_linker_instantiate(LinkerHandle linker, ModuleHandle module, out IntPtr trap);
public bool Equals(ModuleHandle handle) { }
public static extern void wasm_module_exports(ModuleHandle module, out wasm_exporttype_vec_t exports);
public static void RunModuleConstructor(ModuleHandle module) { _RunModuleConstructor(module.GetRuntimeModule()); }
/// <summary> /// Equalses the specified instance. /// </summary> /// <param name="instance">The instance.</param> /// <returns></returns> public bool Equals(ModuleHandle instance) { if (this._Instance.Equals(instance._Instance)) { return true; } return false; }