вот решил добавить тему о создании обычного трейнера
Вот видео
вот коды
Process[] aProcesses = Process.GetProcessesByName("Game");
if (aProcesses.Length != 0)
{
//-----------------------------------------ОБХОД--------------\\
VAMemory memory = new VAMemory("Game"); //сюда пишется процесс игры warface у warface он Gam.exe но здесь пишем то ко Game
int num = сюда адрес; //сюда адрес обхода
byte[] pBytes = new byte[] { сюда байты }; //сюда байты включения обхода
memory.WriteByteArray((IntPtr)сюда num, pBytes);
//-------------------------ЖЕЛЕЗО------------------\\ железо добавлять не обязательно
int num = сюда адрес; //сюда адрес обхода бана железу
byte[] pBytes = new byte[] { сюда байты };//сюда байты обхода бана по железу
memory.WriteByteArray((IntPtr) num, pBytes);
}
}
}
}
private void checkBox1_CheckedChanged(object sender, EventArgs e)
{
if (checkBox1.Checked)
{
VAMemory memory = new VAMemory("Game");//сюда пишется процесс игры warface у warface он Gam.exe но здесь пишем то ко Game
int num = сюда адрес; //сюда адрес функции
byte[] pBytes = new byte[] { сюда байты }; //сюда байты включения функции
memory.WriteByteArray((IntPtr)num, pBytes);if (checkBox1.Checked == false);
}
else
{
VAMemory memory = new VAMemory("Game"); //сюда пишется процесс игры warface у warface он Gam.exe но здесь пишем то ко Game
int num переменную = сюда адрес; //сюда адрес функции
byte[] pBytes = new byte[] { сюда байты }; //сюда байты выключения функции
memory.WriteByteArray((IntPtr)num, pBytes);
if (checkBox1.Checked == true);
}
}
}
}
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;namespace MGMT_Enterprise
{
public class VAMemory
{private enum ProcessAccessFlags : uint
{
All = 0x1f0fff,
CreateThread = 2,
DupHandle = 0x40,
QueryInformation = 0x400,
SetInformation = 0x200,
Synchronize = 0x100000,
Terminate = 1,
VMOperation = 8,
VMRead = 0x10,
VMWrite = 0x20}
private enum VirtualMemoryProtection : uint
{
PAGE_EXECUTE = 0x10,
PAGE_EXECUTE_READ = 0x20,
PAGE_EXECUTE_READWRITE = 0x40,
PAGE_EXECUTE_WRITECOPY = 0x80,
PAGE_GUARD = 0x100,
PAGE_NOACCESS = 1,
PAGE_NOCACHE = 0x200,
PAGE_READONLY = 2,
PAGE_READWRITE = 4,
PAGE_WRITECOPY = 8,
PROCESS_ALL_ACCESS = 0x1f0fff}
public static bool debugMode = false;
private IntPtr baseAddress;
private ProcessModule processModule;
private Process[] mainProcess;
private IntPtr processHandle;
public string processName
{
get;
set;
}
public long getBaseAddress
{
get
{
this.baseAddress = (IntPtr)0;
this.processModule = this.mainProcess[0].MainModule;
this.baseAddress = this.processModule.BaseAddress;
return (long)this.baseAddress;
}
}
[DllImport("kernel32.dll", SetLastError = true)]
private static extern bool ReadProcessMemory(IntPtr hProcess, IntPtr lpBaseAddress, byte[] lpBuffer, uint dwSize, uint lpNumberOfBytesRead);
[DllImport("kernel32.dll")]
private static extern bool WriteProcessMemory(IntPtr hProcess, IntPtr lpBaseAddress, byte[] lpBuffer, uint nSize, uint lpNumberOfBytesWritten);
[DllImport("kernel32.dll")]
private static extern IntPtr OpenProcess(uint dwDesiredAccess, bool bInheritHandle, int dwProcessId);
[DllImport("kernel32.dll")]
private static extern bool CloseHandle(IntPtr hObject);
[DllImport("kernel32.dll")]
private static extern bool VirtualProtectEx(IntPtr hProcess, IntPtr lpAddress, UIntPtr dwSize, uint flNewProtect, out uint lpflOldProtect);
[DllImport("kernel32.dll", ExactSpelling = true, SetLastError = true)]
private static extern IntPtr VirtualAllocEx(IntPtr hProcess, IntPtr lpAddress, uint dwSize, uint flAllocationType, uint flProtect);
public VAMemory()
{
}
public VAMemory(string pProcessName)
{
this.processName = pProcessName;
}
public bool CheckProcess()
{
bool result;
if (this.processName != null)
{
this.mainProcess = Process.GetProcessesByName(this.processName);
if (this.mainProcess.Length == 0)
{
this.ErrorProcessNotFound(this.processName);
result = false;
}
else
{
this.processHandle = VAMemory.OpenProcess(2035711u, false, this.mainProcess[0].Id);
if (this.processHandle == IntPtr.Zero)
{
this.ErrorProcessNotFound(this.processName);
result = false;
}
else
{
result = true;
}
}
}
else
{
MessageBox.Show("Programmer, define process name first!");
result = false;
}
return result;
}
public byte[] ReadByteArray(IntPtr pOffset, uint pSize)
{
if (this.processHandle == IntPtr.Zero)
{
this.CheckProcess();
}
byte[] result;
try
{
uint flNewProtect;
VAMemory.VirtualProtectEx(this.processHandle, pOffset, (UIntPtr)pSize, 4u, out flNewProtect);
byte[] array = new byte[pSize];
VAMemory.ReadProcessMemory(this.processHandle, pOffset, array, pSize, 0u);
VAMemory.VirtualProtectEx(this.processHandle, pOffset, (UIntPtr)pSize, flNewProtect, out flNewProtect);
result = array;
}
catch (Exception ex)
{
if (VAMemory.debugMode)
{
Console.WriteLine("Error: ReadByteArray" + ex.ToString());
}
result = new byte[1];
}
return result;
}
public string ReadStringUnicode(IntPtr pOffset, uint pSize)
{
if (this.processHandle == IntPtr.Zero)
{
this.CheckProcess();
}
string result;
try
{
result = Encoding.Unicode.GetString(this.ReadByteArray(pOffset, pSize), 0, (int)pSize);
}
catch (Exception ex)
{
if (VAMemory.debugMode)
{
Console.WriteLine("Error: ReadStringUnicode" + ex.ToString());
}
result = "";
}
return result;
}
public string ReadStringASCII(IntPtr pOffset, uint pSize)
{
if (this.processHandle == IntPtr.Zero)
{
this.CheckProcess();
}
string result;
try
{
result = Encoding.ASCII.GetString(this.ReadByteArray(pOffset, pSize), 0, (int)pSize);
}
catch (Exception ex)
{
if (VAMemory.debugMode)
{
Console.WriteLine("Error: ReadStringASCII" + ex.ToString());
}
result = "";
}
return result;
}
public char ReadChar(IntPtr pOffset)
{
if (this.processHandle == IntPtr.Zero)
{
this.CheckProcess();
}
char result;
try
{
result = BitConverter.ToChar(this.ReadByteArray(pOffset, 1u), 0);
}
catch (Exception ex)
{
if (VAMemory.debugMode)
{
Console.WriteLine("Error: ReadChar" + ex.ToString());
}
result = ' ';
}
return result;
}
public bool ReadBoolean(IntPtr pOffset)
{
if (this.processHandle == IntPtr.Zero)
{
this.CheckProcess();
}
bool result;
try
{
result = BitConverter.ToBoolean(this.ReadByteArray(pOffset, 1u), 0);
}
catch (Exception ex)
{
if (VAMemory.debugMode)
{
Console.WriteLine("Error: ReadByte" + ex.ToString());
}
result = false;
}
return result;
}
public byte ReadByte(IntPtr pOffset)
{
if (this.processHandle == IntPtr.Zero)
{
this.CheckProcess();
}
byte result;
try
{
result = this.ReadByteArray(pOffset, 1u)[0];
}
catch (Exception ex)
{
if (VAMemory.debugMode)
{
Console.WriteLine("Error: ReadByte" + ex.ToString());
}
result = 0;
}
return result;
}
public short ReadInt16(IntPtr pOffset)
{
if (this.processHandle == IntPtr.Zero)
{
this.CheckProcess();
}
short result;
try
{
result = BitConverter.ToInt16(this.ReadByteArray(pOffset, 2u), 0);
}
catch (Exception ex)
{
if (VAMemory.debugMode)
{
Console.WriteLine("Error: ReadInt16" + ex.ToString());
}
result = 0;
}
return result;
}
public short ReadShort(IntPtr pOffset)
{
if (this.processHandle == IntPtr.Zero)
{
this.CheckProcess();
}
short result;
try
{
result = BitConverter.ToInt16(this.ReadByteArray(pOffset, 2u), 0);
}
catch (Exception ex)
{
if (VAMemory.debugMode)
{
Console.WriteLine("Error: ReadInt16" + ex.ToString());
}
result = 0;
}
return result;
}
public int ReadInt32(IntPtr pOffset)
{
if (this.processHandle == IntPtr.Zero)
{
this.CheckProcess();
}
int result;
try
{
result = BitConverter.ToInt32(this.ReadByteArray(pOffset, 4u), 0);
}
catch (Exception ex)
{
if (VAMemory.debugMode)
{
Console.WriteLine("Error: ReadInt32" + ex.ToString());
}
result = 0;
}
return result;
}
public int ReadInteger(IntPtr pOffset)
{
if (this.processHandle == IntPtr.Zero)
{
this.CheckProcess();
}
int result;
try
{
result = BitConverter.ToInt32(this.ReadByteArray(pOffset, 4u), 0);
}
catch (Exception ex)
{
if (VAMemory.debugMode)
{
Console.WriteLine("Error: ReadInteger" + ex.ToString());
}
result = 0;
}
return result;
}
public long ReadInt64(IntPtr pOffset)
{
if (this.processHandle == IntPtr.Zero)
{
this.CheckProcess();
}
long result;
try
{
result = BitConverter.ToInt64(this.ReadByteArray(pOffset, 8u), 0);
}
catch (Exception ex)
{
if (VAMemory.debugMode)
{
Console.WriteLine("Error: ReadInt64" + ex.ToString());
}
result = 0L;
}
return result;
}
public long ReadLong(IntPtr pOffset)
{
if (this.processHandle == IntPtr.Zero)
{
this.CheckProcess();
}
long result;
try
{
result = BitConverter.ToInt64(this.ReadByteArray(pOffset, 8u), 0);
}
catch (Exception ex)
{
if (VAMemory.debugMode)
{
Console.WriteLine("Error: ReadLong" + ex.ToString());
}
result = 0L;
}
return result;
}
public ushort ReadUInt16(IntPtr pOffset)
{
if (this.processHandle == IntPtr.Zero)
{
this.CheckProcess();
}
ushort result;
try
{
result = BitConverter.ToUInt16(this.ReadByteArray(pOffset, 2u), 0);
}
catch (Exception ex)
{
if (VAMemory.debugMode)
{
Console.WriteLine("Error: ReadUInt16" + ex.ToString());
}
result = 0;
}
return result;
}
public ushort ReadUShort(IntPtr pOffset)
{
if (this.processHandle == IntPtr.Zero)
{
this.CheckProcess();
}
ushort result;
try
{
result = BitConverter.ToUInt16(this.ReadByteArray(pOffset, 2u), 0);
}
catch (Exception ex)
{
if (VAMemory.debugMode)
{
Console.WriteLine("Error: ReadUShort" + ex.ToString());
}
result = 0;
}
return result;
}
public uint ReadUInt32(IntPtr pOffset)
{
if (this.processHandle == IntPtr.Zero)
{
this.CheckProcess();
}
uint result;
try
{
result = BitConverter.ToUInt32(this.ReadByteArray(pOffset, 4u), 0);
}
catch (Exception ex)
{
if (VAMemory.debugMode)
{
Console.WriteLine("Error: ReadUInt32" + ex.ToString());
}
result = 0u;
}
return result;
}
public uint ReadUInteger(IntPtr pOffset)
{
if (this.processHandle == IntPtr.Zero)
{
this.CheckProcess();
}
uint result;
try
{
result = BitConverter.ToUInt32(this.ReadByteArray(pOffset, 4u), 0);
}
catch (Exception ex)
{
if (VAMemory.debugMode)
{
Console.WriteLine("Error: ReadUInteger" + ex.ToString());
}
result = 0u;
}
return result;
}
public ulong ReadUInt64(IntPtr pOffset)
{
if (this.processHandle == IntPtr.Zero)
{
this.CheckProcess();
}
ulong result;
try
{
result = BitConverter.ToUInt64(this.ReadByteArray(pOffset, 8u), 0);
}
catch (Exception ex)
{
if (VAMemory.debugMode)
{
Console.WriteLine("Error: ReadUInt64" + ex.ToString());
}
result = 0uL;
}
return result;
}
public long ReadULong(IntPtr pOffset)
{
if (this.processHandle == IntPtr.Zero)
{
this.CheckProcess();
}
long result;
try
{
result = (long)BitConverter.ToUInt64(this.ReadByteArray(pOffset, 8u), 0);
}
catch (Exception ex)
{
if (VAMemory.debugMode)
{
Console.WriteLine("Error: ReadULong" + ex.ToString());
}
result = 0L;
}
return result;
}
public float ReadFloat(IntPtr pOffset)
{
if (this.processHandle == IntPtr.Zero)
{
this.CheckProcess();
}
float result;
try
{
result = BitConverter.ToSingle(this.ReadByteArray(pOffset, 4u), 0);
}
catch (Exception ex)
{
if (VAMemory.debugMode)
{
Console.WriteLine("Error: ReadFloat" + ex.ToString());
}
result = 0f;
}
return result;
}
public double ReadDouble(IntPtr pOffset)
{
if (this.processHandle == IntPtr.Zero)
{
this.CheckProcess();
}
double result;
try
{
result = BitConverter.ToDouble(this.ReadByteArray(pOffset, 8u), 0);
}
catch (Exception ex)
{
if (VAMemory.debugMode)
{
Console.WriteLine("Error: ReadDouble" + ex.ToString());
}
result = 0.0;
}
return result;
}
public bool WriteByteArray(IntPtr pOffset, byte[] pBytes)
{
if (this.processHandle == IntPtr.Zero)
{
this.CheckProcess();
}
bool result;
try
{
uint flNewProtect;
VAMemory.VirtualProtectEx(this.processHandle, pOffset, (UIntPtr)((ulong)((long)pBytes.Length)), 4u, out flNewProtect);
bool flag = VAMemory.WriteProcessMemory(this.processHandle, pOffset, pBytes, (uint)pBytes.Length, 0u);
VAMemory.VirtualProtectEx(this.processHandle, pOffset, (UIntPtr)((ulong)((long)pBytes.Length)), flNewProtect, out flNewProtect);
result = flag;
}
catch (Exception ex)
{
if (VAMemory.debugMode)
{
Console.WriteLine("Error: WriteByteArray" + ex.ToString());
}
result = false;
}
return result;
}
public bool WriteStringUnicode(IntPtr pOffset, string pData)
{
if (this.processHandle == IntPtr.Zero)
{
this.CheckProcess();
}
bool result;
try
{
result = this.WriteByteArray(pOffset, Encoding.Unicode.GetBytes(pData));
}
catch (Exception ex)
{
if (VAMemory.debugMode)
{
Console.WriteLine("Error: WriteStringUnicode" + ex.ToString());
}
result = false;
}
return result;
}
public bool WriteStringASCII(IntPtr pOffset, string pData)
{
if (this.processHandle == IntPtr.Zero)
{
this.CheckProcess();
}
bool result;
try
{
result = this.WriteByteArray(pOffset, Encoding.ASCII.GetBytes(pData));
}
catch (Exception ex)
{
if (VAMemory.debugMode)
{
Console.WriteLine("Error: WriteStringASCII" + ex.ToString());
}
result = false;
}
return result;
}
public bool WriteBoolean(IntPtr pOffset, bool pData)
{
if (this.processHandle == IntPtr.Zero)
{
this.CheckProcess();
}
bool result;
try
{
result = this.WriteByteArray(pOffset, BitConverter.GetBytes(pData));
}
catch (Exception ex)
{
if (VAMemory.debugMode)
{
Console.WriteLine("Error: WriteBoolean" + ex.ToString());
}
result = false;
}
return result;
}
public bool WriteChar(IntPtr pOffset, char pData)
{
if (this.processHandle == IntPtr.Zero)
{
this.CheckProcess();
}
bool result;
try
{
result = this.WriteByteArray(pOffset, BitConverter.GetBytes(pData));
}
catch (Exception ex)
{
if (VAMemory.debugMode)
{
Console.WriteLine("Error: WriteChar" + ex.ToString());
}
result = false;
}
return result;
}
public bool WriteByte(IntPtr pOffset, byte pData)
{
if (this.processHandle == IntPtr.Zero)
{
this.CheckProcess();
}
bool result;
try
{
result = this.WriteByteArray(pOffset, BitConverter.GetBytes((short)pData));
}
catch (Exception ex)
{
if (VAMemory.debugMode)
{
Console.WriteLine("Error: WriteByte" + ex.ToString());
}
result = false;
}
return result;
}
public bool WriteInt16(IntPtr pOffset, short pData)
{
if (this.processHandle == IntPtr.Zero)
{
this.CheckProcess();
}
bool result;
try
{
result = this.WriteByteArray(pOffset, BitConverter.GetBytes(pData));
}
catch (Exception ex)
{
if (VAMemory.debugMode)
{
Console.WriteLine("Error: WriteInt16" + ex.ToString());
}
result = false;
}
return result;
}
public bool WriteShort(IntPtr pOffset, short pData)
{
if (this.processHandle == IntPtr.Zero)
{
this.CheckProcess();
}
bool result;
try
{
result = this.WriteByteArray(pOffset, BitConverter.GetBytes(pData));
}
catch (Exception ex)
{
if (VAMemory.debugMode)
{
Console.WriteLine("Error: WriteShort" + ex.ToString());
}
result = false;
}
return result;
}
public bool WriteInt32(IntPtr pOffset, int pData)
{
if (this.processHandle == IntPtr.Zero)
{
this.CheckProcess();
}
bool result;
try
{
result = this.WriteByteArray(pOffset, BitConverter.GetBytes(pData));
}
catch (Exception ex)
{
if (VAMemory.debugMode)
{
Console.WriteLine("Error: WriteInt32" + ex.ToString());
}
result = false;
}
return result;
}
public bool WriteInteger(IntPtr pOffset, int pData)
{
if (this.processHandle == IntPtr.Zero)
{
this.CheckProcess();
}
bool result;
try
{
result = this.WriteByteArray(pOffset, BitConverter.GetBytes(pData));
}
catch (Exception ex)
{
if (VAMemory.debugMode)
{
Console.WriteLine("Error: WriteInt" + ex.ToString());
}
result = false;
}
return result;
}
public bool WriteInt64(IntPtr pOffset, long pData)
{
if (this.processHandle == IntPtr.Zero)
{
this.CheckProcess();
}
bool result;
try
{
result = this.WriteByteArray(pOffset, BitConverter.GetBytes(pData));
}
catch (Exception ex)
{
if (VAMemory.debugMode)
{
Console.WriteLine("Error: WriteInt64" + ex.ToString());
}
result = false;
}
return result;
}
public bool WriteLong(IntPtr pOffset, long pData)
{
if (this.processHandle == IntPtr.Zero)
{
this.CheckProcess();
}
bool result;
try
{
result = this.WriteByteArray(pOffset, BitConverter.GetBytes(pData));
}
catch (Exception ex)
{
if (VAMemory.debugMode)
{
Console.WriteLine("Error: WriteLong" + ex.ToString());
}
result = false;
}
return result;
}
public bool WriteUInt16(IntPtr pOffset, ushort pData)
{
if (this.processHandle == IntPtr.Zero)
{
this.CheckProcess();
}
bool result;
try
{
result = this.WriteByteArray(pOffset, BitConverter.GetBytes(pData));
}
catch (Exception ex)
{
if (VAMemory.debugMode)
{
Console.WriteLine("Error: WriteUInt16" + ex.ToString());
}
result = false;
}
return result;
}
public bool WriteUShort(IntPtr pOffset, ushort pData)
{
if (this.processHandle == IntPtr.Zero)
{
this.CheckProcess();
}
bool result;
try
{
result = this.WriteByteArray(pOffset, BitConverter.GetBytes(pData));
}
catch (Exception ex)
{
if (VAMemory.debugMode)
{
Console.WriteLine("Error: WriteShort" + ex.ToString());
}
result = false;
}
return result;
}
public bool WriteUInt32(IntPtr pOffset, uint pData)
{
if (this.processHandle == IntPtr.Zero)
{
this.CheckProcess();
}
bool result;
try
{
result = this.WriteByteArray(pOffset, BitConverter.GetBytes(pData));
}
catch (Exception ex)
{
if (VAMemory.debugMode)
{
Console.WriteLine("Error: WriteUInt32" + ex.ToString());
}
result = false;
}
return result;
}
public bool WriteUInteger(IntPtr pOffset, uint pData)
{
if (this.processHandle == IntPtr.Zero)
{
this.CheckProcess();
}
bool result;
try
{
result = this.WriteByteArray(pOffset, BitConverter.GetBytes(pData));
}
catch (Exception ex)
{
if (VAMemory.debugMode)
{
Console.WriteLine("Error: WriteUInt" + ex.ToString());
}
result = false;
}
return result;
}
public bool WriteUInt64(IntPtr pOffset, ulong pData)
{
if (this.processHandle == IntPtr.Zero)
{
this.CheckProcess();
}
bool result;
try
{
result = this.WriteByteArray(pOffset, BitConverter.GetBytes(pData));
}
catch (Exception ex)
{
if (VAMemory.debugMode)
{
Console.WriteLine("Error: WriteUInt64" + ex.ToString());
}
result = false;
}
return result;
}
public bool WriteULong(IntPtr pOffset, ulong pData)
{
if (this.processHandle == IntPtr.Zero)
{
this.CheckProcess();
}
bool result;
try
{
result = this.WriteByteArray(pOffset, BitConverter.GetBytes(pData));
}
catch (Exception ex)
{
if (VAMemory.debugMode)
{
Console.WriteLine("Error: WriteULong" + ex.ToString());
}
result = false;
}
return result;
}
public bool WriteFloat(IntPtr pOffset, float pData)
{
if (this.processHandle == IntPtr.Zero)
{
this.CheckProcess();
}
bool result;
try
{
result = this.WriteByteArray(pOffset, BitConverter.GetBytes(pData));
}
catch (Exception ex)
{
if (VAMemory.debugMode)
{
Console.WriteLine("Error: WriteFloat" + ex.ToString());
}
result = false;
}
return result;
}
public bool WriteDouble(IntPtr pOffset, double pData)
{
if (this.processHandle == IntPtr.Zero)
{
this.CheckProcess();
}
bool result;
try
{
result = this.WriteByteArray(pOffset, BitConverter.GetBytes(pData));
}
catch (Exception ex)
{
if (VAMemory.debugMode)
{
Console.WriteLine("Error: WriteDouble" + ex.ToString());
}
result = false;
}
return result;
}
private void ErrorProcessNotFound(string pProcessName)
{
MessageBox.Show(this.processName + " is not running or has not been found. Please check and try again", "Process Not Found", MessageBoxButtons.OK, MessageBoxIcon.Hand);
}
}
}
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Linq;
using System.Security.Principal;
using System.Windows.Forms;namespace SimpleTrainer
{
static class Program
{
/// <summary>
/// The main entry point for the application.
/// </summary>[STAThread]
static void Main()
{WindowsPrincipal pricipal = new WindowsPrincipal(WindowsIdentity.GetCurrent());
bool hasAdministrativeRight = pricipal.IsInRole(WindowsBuiltInRole.Administrator);
if (hasAdministrativeRight == false)
{ProcessStartInfo processInfo = new ProcessStartInfo();
processInfo.Verb = "runas";
processInfo.FileName = Application.ExecutablePath;
try
{Process.Start(processInfo);
}
catch (Win32Exception)
{
}
Application.Exit();}
else
{Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new Form1());}
}
}
}
а ещё на Form1.cs
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
это удалитьэто удаляем и вместо этого вставляем
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Diagnostics;это вставить
вот исход этого трейнера но без адресов и байтов ищите сами