Сканирование байтов в памяти, и получение начального адреса байтов

public int findsignature(int PID, byte[] signature)
        {
            long MaxAddr = 0x7fffffff;
            long Addr = 0;
            MEMORY_BASIC_INFORMATION m;
            var handle = OpenProcess(0x001F0FFF, false, PID);
            m.BaseAddress = IntPtr.Zero;
            m.RegionSize = IntPtr.Zero;
            byte[] buffer;
            while(Addr <= MaxAddr)
            {
                VirtualQueryEx(handle, (IntPtr)Addr, out m, (uint)Marshal.SizeOf(typeof(MEMORY_BASIC_INFORMATION)));
                buffer = new byte[(uint)m.RegionSize];
                int dammy = 0;
                ReadProcessMemory(handle, m.BaseAddress, buffer, (int)m.RegionSize, out dammy);
                if (Addr == (long)m.BaseAddress + (long)m.RegionSize)
                    break;
                int count = 0;
                Addr = (long)m.BaseAddress + (long)m.RegionSize;
                if(buffer.Length > signature.Length)
                {
                    for(int i=0; i< buffer.Length; i++)
                    {
                        if(buffer[i] == signature[0])
                        {
                            for(int q=0; q<signature.Length; q++)
                            {
                                try
                                {
                                    if (buffer[i + q] == signature[q] || signature[q] == -1)
                                    {
                                        count++;
                                        if (count == signature.Length)
                                        {
                                            return i + (int)m.BaseAddress;
                                        }
                                    }
                                    else
                                    {
                                        count = 0;
                                    }
                                }
                                catch { }
                            }
                        }
                    }
                }
            }
            return 0;
        }

public unsafe uint Find(byte[] pattern, string mask = "")
{
    if (this.Process == null)
        throw new Exception("Process exists");
 
    if (mask == "")
    {
        mask = new string('x', pattern.Length);
    }
    else
    {
        if (pattern.Length != mask.Length)
            throw new ArgumentException("Pattern and Mask lengths must be the same.");
 
        foreach (char c in mask)// check mask
        {
            if (c != 'x' && c != '!' && c != '?')
            {
                throw new ArgumentException("Bad sumbol: '" + c + "'", "mask");
            }
        }
    }
 
    var bytesRead = 0;
    var found = false;
    var size = Process.MainModule.ModuleMemorySize;
    var dataLenght = size - pattern.Length;
 
    var buffer = Marshal.AllocHGlobal(size);
 
    ReadProcessMemory(this.Handle, this.BaseAddress, (void*)buffer, size, out bytesRead);
 
    if (bytesRead != size)
        throw new Exception("ModuleMemorySize and BytesRead lengths must be the same.");
 
    var offset = 0u;
 
    for (; offset < dataLenght; offset++)
    {
        found = true;
        for (int index = 0; index < pattern.Length; index++)
        {
            byte element = ((byte*)buffer)[offset + index];
 
            if ((mask[index] == 'x' && pattern[index] != element)
             || (mask[index] == '!' && pattern[index] == element))
            {
                found = false;
                break;
            }
        }
 
        if (found)
            break;
    }
 
    Marshal.FreeHGlobal(buffer);
    return found ? offset + BaseAddress : 0u;
}