Помогите с чтением памяти.

#!/usr/bin/python
from ptrace.debugger.child import createChild
from ptrace.debugger import PtraceProcess
from ptrace.debugger import PtraceDebugger
from ptrace.binding import HAS_PTRACE_SINGLESTEP
from ptrace.disasm import HAS_DISASSEMBLER
from signal import SIGTRAP, SIGINT

PROGRAM=["./RainSlickEp2_bin"]
#instruction size, bytes
COOKIES=[
[0x080BAEEB,"\x0F\x94"],
[0x0819CF84,"\xeb"],
[0x0819CC6E,"\xeb"],
[0x0819C6A4,"\xeb"],
]


class loader():
    def __init__(self):
        self.program = PROGRAM
        self.debugger = PtraceDebugger()
    def run(self,args):
        return createChild(args, False , None)
    def attachProcess(self,pid):
        self.process = self.debugger.addProcess(pid,True)
    def step(self, enter_call, address=None):
        if (not HAS_PTRACE_SINGLESTEP) or (not enter_call):
            if address is None:
                address = self.process.getInstrPointer()
                size = self.readInstrSize(address, default_size=None)
                if not size:
                    return "Unable to read instruction size at %s" \
                        % str(address)
                address += size
            size = self.readInstrSize(address)

            # Set a breakpoint
            breakpoint = self.process.createBreakpoint(address, size)

            # Continue the process
            self.process.cont()
        else:
            # Use ptrace single step command
            self.process.singleStep()
            breakpoint = None

        # Execute processus until next TRAP
        try:
            self.process.waitSignals(SIGTRAP)
            if breakpoint:
                breakpoint.desinstall(set_ip=True)
        except:
            if breakpoint:
                breakpoint.desinstall()
            raise
        return None
    def readInstrSize(self, address, default_size=None):
        if not HAS_DISASSEMBLER:
            return default_size
        try:
            # Get address and size of instruction at specified address
            instr = self.process.disassembleOne(address)
            return instr.size
        except PtraceError, err:
            return default_size
    def Patch(self,cookie):
        print ""
        if HAS_DISASSEMBLER:
            print "Patching: " + str(self.process.disassembleOne(cookie[0]))
        else:
            print "Patching: " + str(cookie[0])

        self.process.writeBytes(cookie[0],cookie[1])

        if HAS_DISASSEMBLER:
            print "To: " + str(self.process.disassembleOne(cookie[0]))
    def main(self):
        self.pid = self.run(self.program)
        self.attachProcess(self.pid)
        print ("PID: " + str(self.pid))
        self.step(False)
        for cookie in COOKIES:
            self.Patch(cookie)
        self.process.detach()

if __name__ == "__main__":
    loader().main()

from ptrace.debugger.child import createChild
from ptrace.debugger import PtraceProcess
from ptrace.debugger import PtraceDebugger
from ptrace.binding import HAS_PTRACE_SINGLESTEP
from ptrace.disasm import HAS_DISASSEMBLER

 PROGRAM=["./RainSlickEp2_bin"]