static extern int ComDBClaimPort(IntPtr hComDB, out int ComNumber)

static extern int ComDBClaimPort(IntPtr hComDB, int ComNumber, [MarshalAs(UnmanagedType.Bool)] bool ForceClaim, [MarshalAs(UnmanagedType.Bool)] out bool Forced);

static extern int ComDBClose(IntPtr hComDB);

static extern int ComDBOpen(out IntPtr hComDB);

static extern int ComDBReleasePort(IntPtr hComDB, int ComNumber);

static extern void DeleteArray(IntPtr ptr, IntPtr junk);

     DeleteArray((IntPtr)xmlOutPointer, IntPtr.Zero);

  static extern uint SHFullScreen(IntPtr hwndRequester, uint dwState);

  Public Shared Function SHFullScreen( hWnd as IntPtr, flags as Integer ) as Integer

static extern bool SHFullScreen(IntPtr hwndRequester, uint dwState);

public static extern IntPtr GetCapture();

   IntPtr hwnd = GetCapture();

   public IntPtr hwndClient = IntPtr.Zero;

static bool RecognizeGesture(IntPtr hWnd, int x, int y)

static extern bool SHSipPreference(IntPtr hwnd, SIPSTATE st);

Declare Function SHSipPreference Lib "aygshell.dll" (hwnd as IntPtr, st as Integer) As Bool

static extern bool SHSipPreference(IntPtr hwnd, SIPSTATE st);

    static extern IntPtr SndPlaySync(string Path, uint Flags);

        IntPtr ip;

static extern bool IcmpCloseHandle(IntPtr handle);

Declare Function IcmpCloseHandle Lib "icmp.dll" (IntPtr handle) As Boolean

static extern IntPtr IcmpCreateFile();

Declare Function IcmpCreateFile Lib "icmp.dll" () As IntPtr

static extern Int32 IcmpSendEcho(IntPtr icmpHandle, Int32 destinationAddress, IntPtr requestData, Int16 requestSize, IntPtr requestOptions, IntPtr replyBuffer, Int32 replySize, Int32 timeout);

Declare Function IcmpSendEcho Lib "icmp.dll" (icmpHandle as IntPtr, destinationAddress as Int32, requestData as IntPtr, requestSize as Int16, requestOptions as IntPtr, replyBuffer as IntPtr, replySize as Int32, timeout as Int32) As Int32

requestOptions is an IP_OPTION_INFORMATION, or IntPtr.Zero.

            public IntPtr OptionsData;

            public IntPtr DataPtr;

        private static extern IntPtr IcmpCreateFile();

        private static extern bool IcmpCloseHandle(IntPtr handle);

        private static extern int IcmpSendEcho(IntPtr icmpHandle, int destinationAddress, string requestData, short requestSize, ref ICMP_OPTIONS requestOptions, ref ICMP_ECHO_REPLY replyBuffer, int replySize, int timeout);

            IntPtr icmpHandle = IcmpCreateFile();

static extern int AVIFileCreateStream(IntPtr pfile, out IntPtr ppavi, ref AVISTREAMINFO psi);

Declare Function AVIFileCreateStream Lib "avifil32.dll" Alias "AVIFileCreateStreamA" (ByVal pfile As IntPtr, ByRef ppavi As IntPtr, ByRef psi As AVISTREAMINFO) As Integer

public static extern int AVIFileOpenW(ref IntPtr ppfile, [MarshalAs(UnmanagedType.LPWStr)]string szFile, int uMode, IntPtr pclsidHandler);

static extern uint AVIFileRelease(IntPtr pfile);

    Public Shared Function AVIFileRelease(ByVal pfile As IntPtr) As Integer

static extern int AVIGetStreamInfo(IntPtr pavi, out AVISTREAMINFO psi, int lSize);

    Public Shared Function AVIFileInfo(ByVal pfile As IntPtr,

    Public Shared Function AVIStreamGetFrameOpen(ByVal pAVIStream As IntPtr, _

static extern uint AVIStreamLength(IntPtr pavi);

static extern int AVIStreamReadFormat(IntPtr pavi, int lPos, out WAVEFORMATEX lpFormat, out int lpcbFormat);

      Public Shared Function AVIStreamReadFormat(ByVal aviStream As IntPtr,

    Public Shared Function AVIStreamReadFormat(ByVal aviStream As IntPtr,

    Public Shared Function AVIStreamReadFormat2(ByVal aviStream As IntPtr, ByVal lPos As Int32, ByRef lpFormat As BITMAPINFOHEADER, ByRef cbFormat As Int32) As Integer

static extern int AVIStreamReadFormat(IntPtr pavi, int lPos, out WAVEFORMATEX lpFormat, out int lpcbFormat);

      Public Shared Function AVIStreamReadFormat(ByVal aviStream As IntPtr,

    Public Shared Function AVIStreamReadFormat(ByVal aviStream As IntPtr,

    Public Shared Function AVIStreamReadFormat2(ByVal aviStream As IntPtr, ByVal lPos As Int32, ByRef lpFormat As BITMAPINFOHEADER, ByRef cbFormat As Int32) As Integer

static extern int AVIStreamRelease(IntPtr pavi);

Declare Function AVIStreamRelease Lib "avifil32.dll" (pavi As IntPtr) As Integer

private static extern IntPtr BluetoothFindFirstRadio(ref BluetoothFindRadioParams pbtfrp, out IntPtr phRadio);

Declare Function Mierda Lib "avifil32.dll" (ByRef LaPutaQueTePario As IntPtr, ByVal QueTeLaMetan As String) As Integer

    public IntPtr ElementValue;

    public IntPtr ReservedForClient;

    public IntPtr Data;

static List<IntPtr> _allocations = new List<IntPtr>();

static IntPtr AllocStructure(object structure) {

    IntPtr result = Marshal.AllocHGlobal(Marshal.SizeOf(structure));

static IntPtr AllocByteArray(byte[] array) {

    IntPtr result = Marshal.AllocHGlobal(array.Length);

    foreach (IntPtr allocation in _allocations)

    IntPtr ClientInfo);

    Marshal.StructureToPtr(ClientInfo, IntPtr.op_Explicit(bufptr), True)

    public extern static int NetApiBufferFree(IntPtr lpBuffer);

    IntPtr ClientInfo);

    public extern static int NetApiBufferFree(IntPtr lpBuffer);

        //IntPtr bufptr = IntPtr.Zero;

    Marshal.StructureToPtr(ClientInfo, (IntPtr)bufptr, true);

    int result = DhcpDeleteClientInfo(dhcpServer, (IntPtr)bufptr);

    NetApiBufferFree((IntPtr)bufptr);

        out IntPtr Servers,

        public IntPtr Servers;

        IntPtr svrs;

        IntPtr outArray = dsArray.Servers;

        IntPtr current = outArray;

            current = (IntPtr)((int)current + Marshal.SizeOf(serverList[i]));

    out IntPtr ClientInfo,

Declare Unicode Function DhcpEnumSubnetClients Lib "Dhcpsapi" (ByVal ServerIpAddress As String, ByVal SubnetAddress As Integer, ByRef ResumeHandle As Integer, ByVal PreferredMaximum As Integer, ByRef ClientInfo As IntPtr, ByRef ClientsRead As Integer, ByRef ClientsTotal As Integer) As Integer

Declare Unicode Function DhcpEnumSubnetClients Lib "dhcpsapi" (ByVal ServerIpAddress As String, ByVal SubnetAddress As Int32, ByRef ResumeHandle As IntPtr, ByVal PreferredMaximum As Integer, ByRef ClientInfo As IntPtr, ByRef ClientsRead As Integer, ByRef ClientsTotal As Integer) As Integer

    Dim Elements As IntPtr

    Dim Clients As IntPtr

    Dim Data As IntPtr

        Dim pt As IntPtr

        Dim Rem_Handle As IntPtr

        pt = Marshal.ReadIntPtr(Client_Array.Clients, j)

        pt = IntPtr.Zero

    public IntPtr Clients;

    public IntPtr Data;

        IntPtr info_array_ptr;

        IntPtr[] ptr_array = new IntPtr[size];

        IntPtr current = clients.Clients;

        ptr_array[i] = Marshal.ReadIntPtr(current);

        current = (IntPtr)((int)current + (int)Marshal.SizeOf(typeof(IntPtr)));

        // current = (IntPtr)((int)current + (int)Marshal.SizeOf(curr_element));

        out IntPtr ClientInfo,

    ref IntPtr EnumElementInfo,

    public IntPtr Elements;

    public IntPtr ElementValue;

    IntPtr enumInfo = IntPtr.Zero;

        if ((result != NativeMethods.ERROR_SUCCESS && result != NativeMethods.ERROR_MORE_DATA) || enumInfo == IntPtr.Zero)

            IntPtr p = (IntPtr) ((int) data.Elements + (i * Marshal.SizeOf(typeof(NativeMethods.DHCP_SUBNET_ELEMENT_DATA_V5))));

    out IntPtr EnumInfo,

Declare Unicode Function DhcpEnumSubnets Lib "Dhcpsapi" (ByVal ServerIpAddress As String, ByRef ResumeHandle As Integer, ByVal PreferredMaximum As Integer, ByRef EnumInfo As IntPtr, ByRef ElementsRead As Integer, ByRef ElementsTotal As Integer) As Integer

EnumInfo - [out] Pointer to a DHCP_IP_ARRAY [IntPtr] structure that contains the subnet IDs available on the DHCP server. If no subnets are defined, this value will be null.

    IntPtr ips;

       IntPtr outArray = ipArray.IPAddresses;

       IntPtr current = outArray;

      current = (IntPtr)((int)current + Marshal.SizeOf(ipAddressArray[i]));

    out IntPtr EnumInfo,

    public IntPtr IPAddresses;

   out IntPtr ci);

        ByRef ClientInfo As IntPtr) As UInt32

        Dim hClientInfo As IntPtr

        If DHCPResult = ERROR_SUCCESS And Not hClientInfo = IntPtr.Zero Then

        IntPtr pClientInfo;

        if (DHCPResult == 0 && pClientInfo != IntPtr.Zero)

        IntPtr oInfo;

        if (res == 0 && oInfo != IntPtr.Zero)

    public IntPtr ElementValue;

    public IntPtr ReservedForClient;

    public IntPtr Data;

static List<IntPtr> _allocations = new List<IntPtr>();

static IntPtr AllocStructure(object structure) {

    IntPtr result = Marshal.AllocHGlobal(Marshal.SizeOf(structure));

static IntPtr AllocByteArray(byte[] array) {

    IntPtr result = Marshal.AllocHGlobal(array.Length);

    foreach (IntPtr allocation in _allocations)

static extern void DhcpRpcFreeMemory(IntPtr BufferPointer);

Declare Unicode Sub DhcpRpcFreeMemory Lib "Dhcpsapi" (ByVal BufferPointer As IntPtr)

   public IntPtr Data;

                    IntPtr phContext,

    IntPtr PAuthenticationID,//_LUID AuthenticationID,//pvLogonID, //PLUID

    IntPtr pAuthData,//PVOID

    IntPtr pvGetKeyArgument, //PVOID

    IntPtr phContext, //PCtxtHandle

    IntPtr pInput, //PSecBufferDesc SecBufferDesc

    ByVal phContext As IntPtr, _

    ByVal pInput As IntPtr, _

using HANDLE = System.IntPtr;

    IntPtr dwLower; // ULONG_PTR translates to IntPtr not to uint

    IntPtr dwUpper; // this is crucial for 64-Bit Platforms

    public IntPtr pvBuffer;

        if(pvBuffer != IntPtr.Zero)

            pvBuffer = IntPtr.Zero;

    public IntPtr pBuffers; //Point to SecBuffer

            Marshal.WriteIntPtr(pBuffers,CurrentOffset + Marshal.SizeOf(ThisSecBuffer.cbBuffer)+Marshal.SizeOf(ThisSecBuffer.BufferType),ThisSecBuffer.pvBuffer);

        if(pBuffers != IntPtr.Zero)

                    IntPtr SecBufferpvBuffer = Marshal.ReadIntPtr(pBuffers,CurrentOffset + Marshal.SizeOf(typeof(int))+Marshal.SizeOf(typeof(int)));

            pBuffers = IntPtr.Zero;

        if(pBuffers == IntPtr.Zero)

                IntPtr SecBufferpvBuffer = Marshal.ReadIntPtr(pBuffers,CurrentOffset + Marshal.SizeOf(typeof(int))+Marshal.SizeOf(typeof(int)));

        if(pBuffers == IntPtr.Zero)

    public IntPtr LowPart;

    public IntPtr HighPart;

    LowPart = HighPart = IntPtr.Zero;

    IntPtr PAuthenticationID,//_LUID AuthenticationID,//pvLogonID, //PLUID

    IntPtr pAuthData,//PVOID

    IntPtr pvGetKeyArgument, //PVOID

    IntPtr phContext, //PCtxtHandle

    IntPtr pInput, //PSecBufferDesc SecBufferDesc

                                                IntPtr phContext,

                                            IntPtr.Zero,IntPtr.Zero,0,IntPtr.Zero,

                        IntPtr.Zero,

                        IntPtr.Zero,    //Always zero first time around...

                        out ClientLifeTime); //ref IntPtr ptsExpiry ); //PTimeStamp

                            out ClientLifeTime); //ref IntPtr ptsExpiry ); //PTimeStamp

                                            IntPtr.Zero,IntPtr.Zero,0,IntPtr.Zero,

                        IntPtr.Zero,                // [in/out] handle of partially formed context.  Always NULL the first time through

        IntPtr LsaHandle,

        IntPtr ProtocolSubmitBuffer,

        out IntPtr ProtocolReturnBuffer,

public static extern WinStatusCodes LsaConnectUntrusted([Out] out IntPtr LsaHandle);

    public static extern WinStatusCodes LsaDeregisterLogonProcess([In] IntPtr LsaHandle);

private static extern NtStatus LsaEnumerateLogonSessions(out uint LogonSessionCount, out IntPtr LogonSessionList);

public static extern NtStatus LsaFreeReturnBuffer([In] IntPtr buffer);

private static extern uint LsaFreeReturnBuffer(IntPtr buffer);

private static extern uint LsaEnumerateLogonSessions(out UInt64 LogonSessionCount, out IntPtr LogonSessionList);

private static extern uint LsaGetLogonSessionData(IntPtr luid, out IntPtr ppLogonSessionData);

    public IntPtr buffer;

    public IntPtr PSiD;

  IntPtr luidPtr = IntPtr.Zero;

  IntPtr iter = luidPtr;      //set the pointer to the start of the array

      IntPtr sessionData;

      if (data.PSiD != IntPtr.Zero)

      iter = (IntPtr)((int)iter + Marshal.SizeOf(typeof(LUID)));  //move the pointer forward

                    [In] IntPtr LsaHandle,

                    [In] IntPtr AuthenticationInformation,

                    [In] /*PTOKEN_GROUPS*/ IntPtr LocalGroups,

                    [Out] /*PVOID*/ out IntPtr ProfileBuffer,

                    [Out] out IntPtr Token,

                    public IntPtr Buffer;

                    public /*PCHAR*/ IntPtr Buffer;

                        if (_string.Buffer != IntPtr.Zero)

                            _string.Buffer = IntPtr.Zero;

                        if (_bufferContent == IntPtr.Zero)

                            IntPtr curPtr = new IntPtr(_bufferContent.ToInt32()+Marshal.SizeOf(typeof(KERB_S4U_LOGON)));

                                curPtr = new IntPtr(curPtr.ToInt32()+clientUpnLen*2);

                                baseStructure.ClientUpn.Buffer = IntPtr.Zero;

                                baseStructure.ClientRealm.Buffer = IntPtr.Zero;

                    private IntPtr _bufferContent;

                    public IntPtr Ptr

                        if (_bufferContent != IntPtr.Zero)

                            _bufferContent = IntPtr.Zero;

                public static extern int CloseHandle(IntPtr hObject);

                    [In] IntPtr LsaHandle,

                    [In] IntPtr AuthenticationInformation,

                    [In] /*PTOKEN_GROUPS*/ IntPtr LocalGroups,

                    [Out] /*PVOID*/ out IntPtr ProfileBuffer,

                    [Out] out IntPtr Token,

                    [In] IntPtr buffer);

                public static extern WinStatusCodes LsaConnectUntrusted([Out] out IntPtr LsaHandle);

                public static extern WinStatusCodes LsaDeregisterLogonProcess([In] IntPtr LsaHandle);

                public static extern WinStatusCodes LsaLookupAuthenticationPackage([In] IntPtr LsaHandle,[In] ref LSA_STRING PackageName,[Out] out UInt32 AuthenticationPackage);

                private IntPtr m_hToken = IntPtr.Zero;

                        IntPtr lsaHandle;

                                System.IntPtr profileBuffer = IntPtr.Zero;

                                    IntPtr.Zero,

                                if (profileBuffer != IntPtr.Zero)

                        if (!m_hToken.Equals(IntPtr.Zero))

                            m_hToken = IntPtr.Zero;

   public static extern WinStatusCodes LsaLookupAuthenticationPackage([In] IntPtr LsaHandle,[In] ref LSA_STRING PackageName,[Out] out UInt32 AuthenticationPackage);

        IntPtr LogonProcessName,

        out IntPtr LsaHandle,

static extern long QuerySecurityPackageInfo(string pszPackageName, out IntPtr ppPackageInfo);

IntPtr packagePtr;

if (error == 0 && packagePtr != IntPtr.Zero)

static extern void WTSCloseServer(IntPtr hServer);

Private Shared Sub WTSCloseServer(ByVal hServer As IntPtr)

     static extern bool WTSDisconnectSession(IntPtr hServer, int sessionId, bool bWait);

     Private Shared Function WTSDisconnectSession(ByVal hServer As IntPtr, ByVal SessionId As Integer, ByVal bWait As Boolean) As Boolean

    Dim ptrOpenedServer As IntPtr

    IntPtr serverHandle, // Handle to a terminal server.

    ref IntPtr ppProcessInfo, // pointer to array of WTS_PROCESS_INFO

     ByRef ppProcessInfo As IntPtr, _

private static extern void WTSFreeMemory(IntPtr pMemory);

private static HANDLE WTS_CURRENT_SERVER_HANDLE = (IntPtr)null;

    IntPtr pProcessInfo = IntPtr.Zero;

    IntPtr pMemory = pProcessInfo;

        pProcessInfo = (IntPtr)((int)pProcessInfo + Marshal.SizeOf(processInfos[i]));

Dim ptrProcessInfo As IntPtr

        strucProcessInfo = Marshal.PtrToStructure(New IntPtr(lngPtrPos), strucProcessInfo.GetType)

        strProcessName = Marshal.PtrToStringAnsi(New IntPtr(strucProcessInfo.ProcessName))

   ref IntPtr ppServerInfo,

        ref IntPtr ppServerInfo,

    static extern void WTSFreeMemory(IntPtr pMemory);

        IntPtr pInfo = IntPtr.Zero;

            WTS_SERVER_INFO WTScsi = (WTS_SERVER_INFO)Marshal.PtrToStructure((IntPtr)current, typeof(WTS_SERVER_INFO));

                System.IntPtr hServer,

                ref System.IntPtr ppSessionInfo,

                System.IntPtr hServer,

                ref System.IntPtr ppSessionInfo,

        System.IntPtr hServer,

        ref System.IntPtr ppSessionInfo,

    static extern IntPtr WTSOpenServer([MarshalAs(UnmanagedType.LPStr)] String pServerName);

    static extern void WTSCloseServer(IntPtr hServer);

        IntPtr hServer,

        ref IntPtr ppSessionInfo,

    static extern void WTSFreeMemory(IntPtr pMemory);

    public static IntPtr OpenServer(String Name)

        IntPtr server = WTSOpenServer(Name);

    public static void CloseServer(IntPtr ServerHandle)

        IntPtr server = IntPtr.Zero;

        IntPtr ppSessionInfo = IntPtr.Zero;

            WTS_SESSION_INFO si = (WTS_SESSION_INFO)Marshal.PtrToStructure((System.IntPtr)current, typeof(WTS_SESSION_INFO));

         System.IntPtr hServer,

         ref System.IntPtr ppSessionInfo,

public static extern IntPtr WTSOpenServer(string pServerName);

     IntPtr hServer,

    ByVal hServer As IntPtr, _

    ByRef ppSessionInfo As IntPtr, _

    ByVal hServer As IntPtr, _

    ByRef ppSessionInfo As IntPtr, _

    Private Shared Sub WTSFreeMemory(ByVal pMemory As IntPtr)

     Private Shared Function WTSOpenServer(ByVal pServerName As String) As IntPtr

     Private Shared Sub WTSCloseServer(ByVal hServer As IntPtr)

    Dim ptrOpenedServer As IntPtr

        Dim ppSessionInfo As IntPtr = IntPtr.Zero

            sessionInfo(i) = CType(Marshal.PtrToStructure(New IntPtr(current), GetType(WTS_SESSION_INFO)), WTS_SESSION_INFO)

public static extern void WTSFreeMemory( IntPtr memory );

Private Shared Sub WTSFreeMemory(ByVal pMemory As IntPtr)

     static extern bool WTSLogoffSession(IntPtr hServer, int SessionId, bool bWait)

     Private Shared Function WTSLogoffSession(ByVal hServer As IntPtr, ByVal SessionId As Integer, ByVal bWait As Boolean) As Integer

    Dim ptrOpenedServer As IntPtr

static extern IntPtr WTSOpenServer(string pServerName);

Private Shared Function WTSOpenServer(ByVal pServerName As String) As IntPtr

    System.IntPtr hServer, int sessionId, WTSInfoClass wtsInfoClass, out System.IntPtr ppBuffer, out uint pBytesReturned);

     ByRef ppBuffer As IntPtr, _

    private static extern bool WTSQuerySessionInformation(IntPtr hServer, int sessionId, WTS_INFO_CLASS wtsInfoClass, out IntPtr ppBuffer, out int pBytesReturned);

    private static extern void WTSFreeMemory(IntPtr pointer);

        IntPtr buffer;

        if (WTSQuerySessionInformation(IntPtr.Zero, sessionId, WTS_INFO_CLASS.WTSUserName, out buffer, out strLen) && strLen > 1)

        if (WTSQuerySessionInformation(IntPtr.Zero, sessionId, WTS_INFO_CLASS.WTSDomainName, out buffer, out strLen) && strLen > 1)

                System.IntPtr hServer, int sessionId, WTSInfoClass wtsInfoClass, out System.IntPtr ppBuffer, out uint pBytesReturned);

            public static extern void WTSFreeMemory( IntPtr memory );

                System.IntPtr buffer = IntPtr.Zero;

                    bool sessionInfo = WTSQuerySessionInformation( System.IntPtr.Zero, WTS_CURRENT_SESSION, WTSInfoClass.WTSSessionId, out buffer, out bytesReturned );

                    buffer = IntPtr.Zero;

static extern bool WTSQueryUserToken(UInt32 sessionId, out IntPtr Token);

Declare Function WTSQueryUserToken Lib "wtsapi32.dll" (ByVal SessionId As UInt32, ByRef Token As IntPtr) As Boolean

static extern bool WTSRegisterSessionNotification(IntPtr hWnd, [MarshalAs(UnmanagedType.U4)] int dwFlags);

Declare Function WTSRegisterSessionNotification Lib "wtsapi32.dll" (ByVal hWnd as IntPtr, ByVal dwFlags as Int32) As Boolean

        private static extern bool WTSRegisterSessionNotification(IntPtr hWnd, [MarshalAs(UnmanagedType.U4)]int dwFlags);

        private static extern bool WTSUnRegisterSessionNotification(IntPtr hWnd);

            IntPtr hServer,

  Private Shared Function WTSSendMessage(ByVal hServer As IntPtr, ByVal SessionId As Int32, ByVal title As String, ByVal titleLength As UInt32, ByVal message As String, ByVal messageLength As UInt32, ByVal style As UInt32, ByVal timeout As UInt32, ByRef pResponse As UInt32, ByVal bWait As Boolean) As Boolean

        IntPtr hServer,

    public static IntPtr WTS_CURRENT_SERVER_HANDLE = IntPtr.Zero;

    public static IntPtr WTS_CURRENT_SERVER_HANDLE = IntPtr.Zero;

    Private Shared Function WTSSendMessage(ByVal hServer As IntPtr, ByVal SessionId As Int32, ByVal title As String, ByVal titleLength As UInt32, ByVal message As String, ByVal messageLength As UInt32, ByVal style As UInt32, ByVal timeout As UInt32, ByRef pResponse As UInt32, ByVal bWait As Boolean) As Boolean

    Public Shared WTS_CURRENT_SERVER_HANDLE As IntPtr = IntPtr.Zero

        IntPtr hServer,