class AddressRange(GhidraWrapper):
    """Wraps a Ghidra AddressRange object."""

    @property
    def addresses(self):  # type: () -> list[int]
        """Return the addresses in this range."""
        return [a.getOffset() for a in self.raw.getAddresses(True)]

    def __iter__(self):  # type: () -> Iterator[int]
        """Iterate over the addresses in this range."""
        return self.addresses.__iter__()

    @property
    def start(self):  # type: () -> int
        """Get the first address in this range."""
        return self.raw.getMinAddress().getOffset()

    @property
    def end(self):  # type: () -> int
        """Get the last address in this range."""
        return self.raw.getMaxAddress().getOffset()

    @property
    def length(self):  # type: () -> int
        """Get the length of this range."""
        return self.raw.getLength()

    def __len__(self):  # type: () -> int
        """Get the length of this range."""
        return self.length

    def contains(self, addr):  # type: (Addr) -> bool
        """Return True if the given address is in this range.

        :param addr: address to check"""
        return self.raw.contains(resolve(addr))

    def __contains__(self, addr):  # type: (Addr) -> bool
        """Return True if the given address is in this range.
        :param addr: address to check"""
        return self.contains(addr)

    @property
    def is_empty(self):  # type: () -> bool
        """Return True if this range is empty."""
        return self.raw.isEmpty()

    def __nonzero__(self):  # type: () -> bool
        """Return True if this range is not empty."""
        return not self.is_empty

    def __and__(self, other):  # type: (AddressRange) -> AddressRange
        """Return the intersection of this range and the given range."""
        return AddressRange(self.raw.intersect(other.raw))

class AddressSet(GhidraWrapper):
    """Wraps a Ghidra AddressSetView object."""

    @staticmethod
    def empty():  # type: () -> AddressSet
        """Create a new empty address set"""
        return AddressSet(GhAddressSet())

    @staticmethod
    def create(start, length):  # type: (Addr, int) -> AddressSet
        """Create a new AddressSet with given address and length."""
        addr = resolve(start)
        return AddressSet(GhAddressSet(addr, addr.add(length - 1)))

    @property
    def addresses(self):  # type: () -> list[int]
        """Return the addresses in this set."""
        return [a.getOffset() for a in self.raw.getAddresses(True)]

    @property
    def ranges(self):  # type: () -> list[AddressRange]
        return [AddressRange(r) for r in self.raw.iterator(True)]

    def __iter__(self):  # type: () -> Iterator[int]
        return self.addresses.__iter__()

    def contains(self, addr):  # type: (Addr) -> bool
        """Return True if the given address is in this range."""
        return self.raw.contains(resolve(addr))

    def __contains__(self, addr):  # type: (Addr) -> bool
        """Return True if the given address is in this range."""
        return self.contains(addr)

    @property
    def is_empty(self):  # type: () -> bool
        """Return True if this range is empty."""
        return self.raw.isEmpty()

    def __nonzero__(self):  # type: () -> bool
        """Return True if this range is not empty."""
        return not self.is_empty

    def __and__(self, other):  # type: (AddressSet) -> AddressSet
        """Return the intersection of this set and the given set."""
        return AddressSet(self.raw.intersect(other.raw))

    def __sub__(self, other):  # type: (AddressSet) -> AddressSet
        """Subtract the given set from this set."""
        return AddressSet(self.raw.subtract(other.raw))

    def __xor__(self, other):  # type: (AddressSet) -> AddressSet
        """Computes the symmetric difference of this set and the given set."""
        return AddressSet(self.raw.xor(other.raw))

    def __or__(self, other):  # type: (AddressSet) -> AddressSet
        """Computes the union of this set and the given set."""
        return AddressSet(self.raw.union(other.raw))

    def __get_highlighter(self):  # type: () -> Any
        tool = getState().getTool()
        service = tool.getService(ColorizingService)
        if service is None:
            raise RuntimeError("Cannot highlight without the ColorizingService")
        return service

    def highlight(self, color=HIGHLIGHT_COLOR):  # type: (Color) -> None
        service = self.__get_highlighter()
        service.setBackgroundColor(self.raw, color)

    def unhighlight(self):  # type: (Color) -> None
        service = self.__get_highlighter()
        service.clearBackgroundColor(self.raw)

class BasicBlock(AddressSet, BodyTrait):
    """Wraps a Ghidra CodeBlock object"""

    @staticmethod
    def _model(model):  # type: (str) -> Callable[[JavaObject], JavaObject]
        if model == "basic":
            return BasicBlockModel
        elif model == "simple":
            return SimpleBlockModel
        else:
            raise ValueError("Unsupported model type: %s" % model)

    @staticmethod
    def get(
        raw_or_address, model="basic"
    ):  # type: (JavaObject|str|Addr, str) -> BasicBlock|None
        """Get a BasicBlock object containing the given address, or return None.

        This function is tolerant and will accept different types of arguments:
        * address as int
        * Address object
        * symbol as string (will be resolved)
        * BasicBlock object (wrapped or unwrapped)

        :param raw_or_address: find basicblock that contains the given address.
        :param model: Ghidra supports different types of basic block "models".
        Supported options are "basic" and "simple"."""

        if raw_or_address is None:
            return None
        if can_resolve(raw_or_address):
            block_model = BasicBlock._model(model)(Program.current())
            addr = try_resolve(raw_or_address)
            if addr is None:
                return None
            raw = block_model.getFirstCodeBlockContaining(addr, TaskMonitor.DUMMY)
            if raw is None:
                return None
        else:
            raw = raw_or_address
        return BasicBlock(raw)

    @staticmethod
    def all(model="basic"):  # type: (str) -> list[BasicBlock]
        """Get a list of all basic blocks in the program."""
        block_model = BasicBlock._model(model)(Program.current())
        return [BasicBlock(b) for b in block_model.getCodeBlocks(TaskMonitor.DUMMY)]

    @property
    def name(self):  # type: () -> str
        """Get the name of this basic block.

        Return the symbol at the start of this basic block, if any. Otherwise,
        return the address of the first instruction as string."""
        return self.raw.getName()

    @property
    def address(self):  # type: () -> int
        """Get the address of the first instruction in this basic block."""
        return self.start_address

    @property
    def start_address(self):  # type: () -> int
        """Get the address of the first instruction in this basic block."""
        return self.raw.getMinAddress().getOffset()

    @property
    def end_address(self):  # type: () -> int
        """Get the address of the last byte in this basic block.

        Note: this is not the address of the last instruction.
        Note: end_address - start_address is equal to length - 1. For example,
        for one-byte basic block, start_address == end_address."""
        return self.raw.getMaxAddress().getOffset()

    @property
    def length(self):  # type: () -> int
        """Get the length of this basic block in bytes."""
        return self.end_address - self.start_address + 1

    @property
    def bytes(self):  # type: () -> bytes
        """Get the bytes of this basic block.

        :return: bytes of this basic block."""
        return read_bytes(self.start_address, self.length)

    @property
    def instructions(self):  # type: () -> list[Instruction]
        """Get a list of instructions in this basic block."""
        result = []
        instruction = getInstructionAt(resolve(self.start_address))
        while instruction and instruction.getAddress().getOffset() <= self.end_address:
            result.append(Instruction(instruction))
            instruction = instruction.getNext()
        return result

    @property
    def pcode(self):  # type: () -> list[PcodeOp]
        """Get a list of Pcode operations that this basic block was parsed to"""
        result = []
        for instruction in self.instructions:
            result.extend(instruction.pcode)
        return result

    @property
    def destinations(self):  # type: () -> list[BasicBlock]
        """Get a list of basic blocks that this basic block jumps to"""
        raw_refs = collect_iterator(self.raw.getDestinations(TaskMonitor.DUMMY))
        return [BasicBlock(raw.getDestinationBlock()) for raw in raw_refs]

    @property
    def sources(self):  # type: () -> list[BasicBlock]
        """Get a list of basic blocks that jump to this basic block"""
        raw_refs = collect_iterator(self.raw.getSources(TaskMonitor.DUMMY))
        return [BasicBlock(raw.getSourceBlock()) for raw in raw_refs]

    @property
    def body(self):  # type: () -> AddressSet
        """Get the address set of this basic block

        Technically BasicBlock (CodeBlock) is is already an AddressSet,
        but I think this is a useful distinction to keep."""
        return AddressSet(self.raw)

    @property
    def flow_type(self):  # type: () -> FlowType
        """Get the flow type of this basic block.

        In other words, if any weird things with control flow are happening
        in this node."""
        return FlowType(self.raw.getFlowType())

    def __eq__(self, other):  # type: (object) -> bool
        """Compare two basic blocks for equality.

        Apparently Ghidra doesn't know how to do this"""
        if not isinstance(other, BasicBlock):
            return False
        # This is not fully correct, but more correct than the default.
        return self.address == other.address

class BlockGraph(PcodeBlock):
    @property
    def blocks(self):  # type: () -> list[PcodeBlock]
        return [_pcode_node(self.raw.getBlock(i)) for i in range(self.raw.getSize())]

class BodyTrait:
    """A trait for objects that have a body.

    It provides generic methods that work with anything that has a body
    (an assigned set of addresses in the program), such as highlighting."""

    @property
    @abstractmethod
    def body(self):  # type: () -> AddressSet
        """The body of this object"""

    def highlight(self, color=HIGHLIGHT_COLOR):  # type: (Color) -> None
        """Highlight this instruction in the listing."""
        self.body.highlight(color)

    def unhighlight(self):  # type: () -> None
        """Clear the highlight from this instruction."""
        self.body.unhighlight()

class ClangTokenGroup(GhidraWrapper):
    """Represents a group of clang tokens from a decompiler.

    Warning: Currently this class is experimental, and should not be relied upon,
    except to get the Java object (with .raw) or maybe dump (.dump())."""

    def _cleanup(self, token):  # type: (JavaObject) -> JavaObject
        new = GhClangTokenGroup(token.Parent())
        for token in list(token.iterator()):
            if isinstance(token, (ClangCommentToken, ClangBreak)):
                continue
            if isinstance(token, ClangSyntaxToken):
                if not token.getText() or token.getText().isspace():
                    continue
            if isinstance(token, GhClangTokenGroup):
                token = self._cleanup(token)
            new.AddTokenGroup(token)
        return new

    @property
    def cleaned(self):  # type: () -> ClangTokenGroup
        """Remove all whitespace and comments from this token group, recursively."""
        return ClangTokenGroup(self._cleanup(self.raw))

    def _dump(self, token, indent=0):  # type: (JavaObject, int) -> None
        if isinstance(token, GhClangTokenGroup):
            print("{}[group]".format(indent * "  ", token.__class__.__name__))
            for child in token.iterator():
                self._dump(child, indent + 1)
        else:
            print("{}{} ({})".format(indent * "  ", token, token.__class__.__name__))

    def dump(self):  # type: () -> None
        self._dump(self.raw)

class DataType(GhidraWrapper):
    @staticmethod
    def get(name_or_raw):  # type: (DataT) -> DataType|None
        """Gets a data type by name, or returns None if not found.

        Warning: this method is relatively slow, since it scans
        all data types in all data type managers.

            >>> DataType.get("int")
            int

        :param name_or_raw: the name of the data type
        :return: the data type, or None if not found"""
        if not isinstance(name_or_raw, Str):
            return DataType(name_or_raw)

        for datatype in DataType.all():
            if datatype.name == name_or_raw:
                return DataType(datatype)
        return None

    @staticmethod
    def all(only_local=False):  # type: (bool) -> list[DataType]
        """Get all data types

        :param only_local: if True, return only local data types. Otherwise,
          will scan all data types in all data type managers."""
        datatypes = list(Program.current().getDataTypeManager().getAllDataTypes())
        if not only_local:
            managers = (
                getState()
                .getTool()
                .getService(DataTypeManagerService)
                .getDataTypeManagers()
            )
            for manager in managers:
                for datatype in manager.getAllDataTypes():
                    datatypes.append(datatype)
        return [DataType(raw) for raw in datatypes]

    @property
    def name(self):  # type: () -> str
        """Get a name of this data type

            >>> DataType('int').name
            'int'
        .
        """
        return self.raw.getName()

    def get_name(self, value):  # type: (int) -> str
        """If this data type is an enum, get the name of the value.

        :param value: the value to get the name of"""
        return self.raw.getName(value)

    def length(self):  # type: () -> int
        """Get the length of this data type in bytes

            >>> DataType('int').length()
            4
        .
        """
        return self.raw.getLength()

    __len__ = length

    @staticmethod
    def from_c(c_code, insert=True):  # type: (str, bool) -> DataType
        """Parse C structure definition and return the parsed DataType.

        If insert (true by default), add it to current program.
        Example of a valid c_code is `typedef void* HINTERNET;`

            >>> DataType.from_c('typedef void* HINTERNET;')
            HINTERNET
            >>> DataType.from_c("struct test { short a; short b; short c;};")
            pack()
            Structure test {
            0   short   2   a   ""
            2   short   2   b   ""
            4   short   2   c   ""
            }
            Length: 6 Alignment: 2

        :param c_code: the C structure definition
        :param insert: if True, add the data type to the current program
        """
        dtm = Program.current().getDataTypeManager()
        parser = CParser(dtm)

        new_dt = parser.parse(c_code)

        if insert:
            transaction = dtm.startTransaction("Adding new data")
            dtm.addDataType(new_dt, None)
            dtm.endTransaction(transaction, True)

        return new_dt

class Emulator(GhidraWrapper):
    """Wraps a Ghidra EmulatorHelper object."""

    def __init__(self):  # type: () -> None
        """Create a new Emulator object."""
        raw = EmulatorHelper(Program.current())
        GhidraWrapper.__init__(self, raw)

        # Use max_addr/2-0x8000 as stack pointer - this is 0x7fff8000 on 32-bit CPU.
        max_pointer = toAddr(0).getAddressSpace().getMaxAddress().getOffset()
        max_pointer = max_pointer % 2**64  # Java signed ints everywhere strike again.
        stack_off = ((max_pointer + 1) >> 1) - 0x8000
        self.raw.writeRegister(self.raw.getStackPointerRegister(), stack_off)

        # TODO: add a simple allocation manager
        self._hooks = {}  # type: dict[int, Callable[[Emulator], str|None]]

    def add_hook(
        self, address, hook
    ):  # type: (Addr, Callable[[Emulator], str|None]) -> None
        """Add a hook at a specified address.

        Hook is a function that gets emulator as parameter. It can return one of:

        * 'continue' or None, to continue execution normally
        * 'break' to stop execution
        * 'skip' to skip the next instruction

        Note: multiple hooks at the same address are not currently supported."""
        addr = resolve(address).getOffset()
        if addr in self._hooks:
            raise ValueError("Multiple hooks at the same address are not supported")
        self._hooks[addr] = hook

    def has_hook_at(self, address):  # type: (Addr) -> bool
        addr = resolve(address).getOffset()
        return addr in self._hooks

    def delete_hook_at(self, address):  # type: (Addr) -> None
        addr = resolve(address).getOffset()
        del self._hooks[addr]

    @property
    def pc(self):  # type: () -> int
        """Get the program counter of the emulated program."""
        return self.raw.getExecutionAddress().getOffset()

    @pc.setter
    def pc(self, address):  # type: (Addr) -> None
        """Set the program counter of the emulated program."""
        self.set_pc(address)

    def set_pc(self, address):  # type: (Addr) -> None
        """Set the program counter of the emulated program."""
        pc = self.raw.getPCRegister()
        self.raw.writeRegister(pc, resolve(address).getOffset())

    @property
    def sp_register(self):  # type: () -> str
        """Get the stack pointer register name for the emulated architecture."""
        return self.raw.getStackPointerRegister().getName()

    @property
    def sp(self):  # type: () -> int
        """Get the current stack pointer register value."""
        return self.read_register(self.sp_register)

    @sp.setter
    def sp(self, value):  # type: (Addr) -> None
        """Set the current stack pointer register value.

        :param value: new stack pointer value."""
        self.set_sp(value)

    def set_sp(self, value):  # type: (Addr) -> None
        """Set the current stack pointer register value.

        :param value: new stack pointer value."""
        self.write_register(self.sp_register, resolve(value).getOffset())

    def __getitem__(self, reg):  # type: (Reg|int) -> int
        """Read the register of the emulated program.

            >>> emulator.write_register("eax", 1337)
            >>> emulator["eax"]
            1337

        :param reg: the register or address to read from"""
        return self.read_register(reg)

    def __setitem__(self, reg, value):  # type: (Reg, int) -> None
        """Write to the register of the emulated program.

            >>> emulator["eax"] = 1234
            >>> emulator.read_register("eax")
            1337

        :param reg: the register to write to
        :param value: the value to write"""
        self.write_register(reg, value)

    def read_register(self, reg):  # type: (Reg) -> int
        """Read from the register of the emulated program.

            >>> emulator.write_register("eax", 1337)
            >>> emulator.read_register("eax")
            1337

        :param reg: the register to read from."""
        return _python_int(self.raw.readRegister(reg))

    def read_bytes(self, address, length):  # type: (Addr, int) -> bytes
        """Read `length` bytes at `address` from the emulated program.

            >>> emulator.write_bytes(0x1000, "1")
            >>> emulator.read_bytes(0x1000, 1)
            '1'

        :param address: the address to read from
        :param length: the length to read"""
        bytelist = self.raw.readMemory(resolve(address), length)
        return _bytes_from_bytelist(bytelist)

    def read_u8(self, address):  # type: (Addr) -> int
        """Read a byte from the emulated program.

            >>> emulator.write_u8(0x1000, 13)
            >>> emulator.read_u8(0x1000)
            13

        :param address: the address to read from"""
        return from_bytes(self.read_bytes(address, 1))

    def read_u16(self, address):  # type: (Addr) -> int
        """Read a 16bit unsigned integer from the emulated program.

            >>> emulator.write_u16(0x1000, 123)
            >>> emulator.read_u16(0x1000)
            123

        :param address: the address to read from"""
        return from_bytes(self.read_bytes(address, 2))

    def read_u32(self, address):  # type: (Addr) -> int
        """Read a 32bit unsigned integer from the emulated program.

            >>> emulator.write_u32(0x1000, 123)
            >>> emulator.read_u32(0x1000)
            123

        :param address: the address to read from"""
        return from_bytes(self.read_bytes(address, 4))

    def read_u64(self, address):  # type: (Addr) -> int
        """Read a 64bit unsigned integer from the emulated program.

            >>> emulator.write_u64(0x1000, 123)
            >>> emulator.read_u64(0x1000)
            123

        :param address: the address to read from"""
        return from_bytes(self.read_bytes(address, 8))

    def read_cstring(self, address):  # type: (Addr) -> str
        """Read a null-terminated string from the emulated program.

        This function reads bytes until a nullbyte is encountered.

            >>> emu.read_cstring(0x1000)
            'Hello, world!'

        :param address: address from which to start reading."""
        addr = resolve(address)
        string = ""
        while True:
            c = self.read_u8(addr)
            if c == 0:
                break
            string += chr(c)
            addr = addr.add(1)
        return string

    def read_unicode(self, address):  # type: (Addr) -> str
        """Read a null-terminated utf-16 string from the emulated program.

        This function reads bytes until a null character is encountered.

            >>> emu.read_unicode(0x1000)
            'Hello, world!'

        :param address: address from which to start reading."""
        addr = resolve(address)
        string = ""
        while True:
            c = self.read_u16(addr)
            if c == 0:
                break
            string += chr(c)
            addr = addr.add(2)
        return string

    def read_varnode(self, varnode):  # type: (Varnode) -> int
        """Read from the varnode from the emulated program.

        This method can't read hash varnodes.

            >>> fnc = Function("AddNumbers")
            >>> emu = Emulator()
            >>> emu.write_varnode(fnc.parameters[0].varnode, 2)
            >>> emu.write_varnode(fnc.parameters[1].varnode, 2)
            >>> emu.emulate(fnc.entrypoint, stop_when=lambda emu: emu.pc not in fnc.body)
            >>> emu.read_varnode(func.return_variable.varnode)
            4

        :param varnode: the varnode to read from."""
        varnode = Varnode(varnode)
        if varnode.is_constant:
            return varnode.offset
        elif varnode.is_address:
            rawnum = self.read_bytes(varnode.offset, varnode.size)
            return from_bytes(rawnum)
        elif varnode.is_unique:
            space = Program.current().getAddressFactory().getUniqueSpace()
            offset = space.getAddress(varnode.offset)
            rawnum = self.read_bytes(offset, varnode.size)
            return from_bytes(rawnum)
        elif varnode.is_stack:
            return self.raw.readStackValue(varnode.offset, varnode.size, False)
        elif varnode.is_register:
            language = Program.current().getLanguage()
            reg = language.getRegister(varnode.raw.getAddress(), varnode.size)
            return self.read_register(reg)
        raise RuntimeError("Unsupported varnode type")

    def write_register(self, reg, value):  # type: (Reg, int) -> None
        """Write to the register of the emulated program.

            >>> emulator.write_register("eax", 1)
            >>> emulator.read_register("eax")
            1

        :param reg: the register to write to
        :param value: the value to write"""
        self.raw.writeRegister(reg, value)

    def write_bytes(self, address, value):  # type: (Addr, bytes) -> None
        """Write to the memory of the emulated program.

            >>> emulator.write_bytes(0x1000, "1")
            >>> emulator.read_bytes(0x1000, 1)
            '1'

        :param address: the address to write to
        :param value: the value to write"""
        self.raw.writeMemory(resolve(address), value)

    def write_u8(self, address, value):  # type: (Addr, int) -> None
        """Write a byte to the emulated program.

            >>> emulator.write_u8(0x1000, 13)
            >>> emulator.read_u8(0x1000)
            13

        :param address: the address to write to"""
        assert 0 <= value < 2**8, "value out of range"
        self.write_bytes(address, to_bytes(value, 1))

    def write_u16(self, address, value):  # type: (Addr, int) -> None
        """Write a 16bit unsigned integer to the emulated program.

            >>> emulator.write_u16(0x1000, 13)
            >>> emulator.read_u16(0x1000)
            13

        :param address: the address to write to"""
        assert 0 <= value < 2**16, "value out of range"
        self.write_bytes(address, to_bytes(value, 2))

    def write_u32(self, address, value):  # type: (Addr, int) -> None
        """Write a 32bit unsigned integer to the emulated program.

            >>> emulator.write_u32(0x1000, 13)
            >>> emulator.read_u32(0x1000)
            13

        :param address: the address to write to"""
        assert 0 <= value < 2**32, "value out of range"
        self.write_bytes(address, to_bytes(value, 4))

    def write_u64(self, address, value):  # type: (Addr, int) -> None
        """Write a 64bit unsigned integer to the emulated program.

            >>> emulator.write_u64(0x1000, 13)
            >>> emulator.read_u64(0x1000)
            13

        :param address: the address to write to"""
        assert 0 <= value < 2**64, "value out of range"
        self.write_bytes(address, to_bytes(value, 8))

    def write_varnode(self, varnode, value):  # type: (Varnode, int) -> None
        """Set a varnode value in the emulated context.

        This method can't set hash and constant varnodes.

            >>> fnc = Function("AddNumbers")
            >>> emu = Emulator()
            >>> emu.write_varnode(fnc.parameters[0].varnode, 2)
            >>> emu.write_varnode(fnc.parameters[1].varnode, 2)
            >>> emu.emulate(fnc.entrypoint, stop_when=lambda emu: emu.pc not in fnc.body)
            >>> emu.read_varnode(func.return_variable.varnode)
            4

        :param varnode: the varnode to read from."""
        varnode = Varnode(varnode)
        if varnode.is_constant:
            raise ValueError("Can't set value of a constant varnodes")
        elif varnode.is_address:
            self.write_bytes(varnode.offset, to_bytes(value, varnode.size))
        elif varnode.is_unique:
            space = Program.current().getAddressFactory().getUniqueSpace()
            offset = space.getAddress(varnode.offset)
            self.write_bytes(offset, to_bytes(value, varnode.size))
        elif varnode.is_stack:
            self.raw.writeStackValue(varnode.offset, varnode.size, value)
        elif varnode.is_register:
            language = Program.current().getLanguage()
            reg = language.getRegister(varnode.raw.getAddress(), varnode.size)
            self.raw.writeRegister(reg, value)
        else:
            raise RuntimeError("Unsupported varnode type")

    def __run_with_hooks(self):  # type: () -> bool
        """Run the Ghidra emulator, and transparently handle all hooks.

        :return: True if emulator stopped at a breakpoint, or
          hook asked emulator to stop (by returning break)."""

        while not getMonitor().isCancelled():
            is_breakpoint = self.raw.run(getMonitor())
            if self.pc not in self._hooks:
                return is_breakpoint

            result = self._hooks[self.pc](self)
            if self.__handle_hook_result(result):
                return True

        return False

    def add_breakpoint(self, address):  # type: (Addr) -> None
        """Add a breakpoint at the given address.

        :param address: the address to break on"""
        self.raw.setBreakpoint(resolve(address))

    def clear_breakpoint(self, address):  # type: (Addr) -> None
        """Clear a breakpoint at the given address.

        :param address: the address to clear breakpoint from"""
        self.raw.clearBreakpoint(resolve(address))

    def emulate_fast(self, start, ends):  # type: (Addr, Addr|list[Addr]) -> None
        """Emulate from start to end address, using Ghidra for fast emulation.

        The main loop of this function is in Java, which makes it faster, but makes
        some features (like callbacks) impossible. This function stops on error,
        when PC reaches one of the ends, and will also call hooks.

        This method will set a breakpoint at the end address, and clear it after
        the emulation is done.

            >>> emulator.write_bytes(0x2000, "1")
            >>> emulator.emulate_fast(0x1000, 0x1005)
            >>> emulator.read_bytes(0x2000, 1)
            '0'

        :param start: the start address to emulate
        :param ends: one or many end address"""
        self.set_pc(start)

        if not isinstance(ends, (list, tuple)):
            ends = [ends]

        for end in ends:
            self.add_breakpoint(end)

        is_breakpoint = self.__run_with_hooks()

        for end in ends:
            self.clear_breakpoint(end)

        if not is_breakpoint:
            err = self.raw.getLastError()
            raise RuntimeError("Error when running: {}".format(err))

    def __handle_hook_result(self, result):  # type: (str|None) -> bool
        """Handle a hook return value and return True if emulation should stop."""
        if result is None or result == "continue":
            return False
        elif result == "skip":
            self.pc = Instruction(self.pc).next.address
            return False
        elif result == "break":
            return True
        else:
            raise RuntimeError("Invalid hook return value: {}".format(result))

    def single_step(self):  # type: () -> bool
        """Do a single emulation step. This will step into calls.

        Note: This method *will* call hooks.

        :return: True if the emulation should be stopped, False otherwise."""
        success = self.raw.step(getMonitor())
        if not success:
            err = self.raw.getLastError()
            raise RuntimeError("Error at {}: {}".format(self.pc, err))

        if self.pc in self._hooks:
            result = self._hooks[self.pc](self)
            return self.__handle_hook_result(result)
        if self.is_at_breakpoint:
            return True
        return False

    @staticmethod
    def new(
        start,
        ends=[],
        callback=lambda emu: None,
        stop_when=lambda emu: False,
        maxsteps=2**48,
    ):  # type: (Addr, Addr|list[Addr], Callable[[Emulator], str|None], Callable[[Emulator], bool], int) -> Emulator
        """Emulate from start to end address, with callback for each executed address.

            >>> Emulator.new("main", maxsteps=100)["EAX"]
            128

        This function is a convenience wrapper around emulate and can be always
        replaced by three lines of code. The above is equivalent to:

            >>> emu = Emulator()
            >>> emu.emulate("main", maxsteps=100)
            >>> emu["EAX"]
            128

        This function may be used for quickly doing one-off emulations.

        See `emulate` documentation for info about this method parameters."""
        emu = Emulator()
        emu.emulate(start, ends, callback, stop_when, maxsteps)
        return emu

    def emulate(
        self,
        start,
        ends=[],
        callback=lambda emu: None,
        stop_when=lambda emu: False,
        maxsteps=2**48,
    ):  # type: (Addr, Addr|list[Addr], Callable[[Emulator], str|None], Callable[[Emulator], bool], int) -> None
        """Emulate from start to end address, with callback for each executed address.

            >>> emu = Emulator()
            >>> def callback(emu):
            >>>     print("executing {:x}'.format(emu.pc))
            >>> emu.emulate(Function("main").entrypoint, callback=callback, maxsteps=3)
            SUB ESP,0x2d4
            PUSH EBX
            PUSH EBP

        Callback should return one of:

        * 'continue' or None, to continue execution normally
        * 'break' to stop execution
        * 'skip' to skip the next instruction
        * 'retry' like continue, but call the callback again (useful after pc change)
        * 'continue_then_break' to execute one last instruction before stopping

        Returning another value will cause an exception Callback is executed before
        stop_when condition is checked.

        This method is very flexible, but because of that it may be slower than
        pure Ghidra implementation. Consider .emulate_fast() when this method is too
        slow for you.

        :param start: the start address to emulate
        :param end: the end address to emulate
        :param callback: the callback to call before each executed instruction.
          Return one of the predefined constants here (see the docs for more info).
        :param stop_when: the callback to call before each executed instruction.
          Return True here to stop emulation.
        :param maxsteps: the maximum number of steps to execute"""
        self.set_pc(start)

        if not isinstance(ends, (list, tuple)):
            ends = [ends]
        ends = [resolve(e).getOffset() for e in ends]

        while maxsteps > 0:
            maxsteps -= 1
            if self.pc in ends:
                break

            command = callback(self)
            if command == "retry":
                continue
            elif command == "continue_then_break":
                maxsteps = 0
            elif self.__handle_hook_result(command):
                return

            if stop_when(self):
                return

            if self.single_step():
                return

    @property
    def is_at_breakpoint(self):  # type: () -> bool
        """Check if the emulator is at a breakpoint"""
        return self.raw.getEmulator().isAtBreakpoint()

    # Basic unicorn compatibility, because why not
    # You may prefer these aliases if you already know Unicorn API.
    reg_write = write_register
    reg_read = read_register
    mem_write = write_bytes
    mem_read = read_bytes
    mem_map = (
        lambda _1, _2, _3: None
    )  # This is a noop - all memory is already available.
    emu_start = lambda self, begin, until: self.emulate(begin, until)