<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
 def read_across_link(self, address, length_bytes, x, y, link):
 """Read a bytestring from an address in memory on a neigbouring chip. .. warning:: This function is intended for low-level debug use only and is not optimised for performance nor intended for more general use. This method instructs a monitor processor to send 'PEEK' nearest-neighbour packets to a neighbouring chip. These packets are handled directly by the SpiNNaker router in the neighbouring chip, potentially allowing advanced debug or recovery of a chip rendered otherwise unreachable. Parameters address : int The address at which to start reading the data. Only addresses in the system-wide address map may be accessed. Addresses must be word aligned. length_bytes : int The number of bytes to read from memory. Must be a multiple of four (i.e. a whole number of words). Large reads are transparently broken into multiple SCP link-read commands. x : int y : int The coordinates of the chip from which the command will be sent, *not* the coordinates of the chip on which the read will be performed. link : :py:class:`rig.links.Links` The link down which the read should be sent. Returns ------- :py:class:`bytes` The data is read back from memory as a bytestring. """

        if address % 4:
            raise ValueError("Addresses must be word-aligned.")
        if length_bytes % 4:
            raise ValueError("Lengths must be multiples of words.")

        # Prepare the buffer to receive the incoming data
        data = bytearray(length_bytes)
        mem = memoryview(data)

        # Read the requested data, one SCP packet worth at a time
        while length_bytes > 0:
            to_read = min(length_bytes, (self.scp_data_length & ~0b11))
            response = self._send_scp(x, y, 0, SCPCommands.link_read,
                                      arg1=address,
                                      arg2=to_read,
                                      arg3=int(link),
                                      expected_args=0)

            # Accumulate the incoming data and advance the memoryview through
            # the buffer.
            mem[:to_read] = response.data
            mem = mem[to_read:]

            # Move to the next block to read
            address += to_read
            length_bytes -= to_read

        return bytes(data)