docs: def as_binary(self,
                    minimum_address=None,
                    maximum_address=None,
                    padding=None):
          """Return a byte string of all data within given address range.
  
          `minimum_address` is the absolute minimum address of the
          resulting binary data.
  
          `maximum_address` is the absolute maximum address of the
          resulting binary data (non-inclusive).
  
          `padding` is the word value of the padding between
          non-adjacent segments. Give as a bytes object of length 1 when
          the word size is 8 bits, length 2 when the word size is 16
          bits, and so on.
  
          >>> binfile.as_binary()
          bytearray(b'!F\\x016\\x01!G\\x016\\x00~\\xfe\\t\\xd2\\x19\\x01!F\\x01~\\x17\\xc2\\x00\\x01
          \\xff_\\x16\\x00!H\\x01\\x19\\x19Ny#F#\\x96Wx#\\x9e\\xda?\\x01\\xb2\\xca?\\x01Vp+^q+r+s!
          F\\x014!')
  
          """
  
          if len(self._segments) == 0:
              return b''
  
          if minimum_address is None:
              current_maximum_address = self.minimum_address
          else:
              current_maximum_address = minimum_address
  
          if maximum_address is None:
              maximum_address = self.maximum_address
  
          if current_maximum_address >= maximum_address:
              return b''
  
          if padding is None:
              padding = b'\xff' * self.word_size_bytes
  
          binary = bytearray()
  
          for address, data in self._segments:
              length = len(data) // self.word_size_bytes
  
              # Discard data below the minimum address.
              if address < current_maximum_address:
                  if address + length <= current_maximum_address:
                      continue
  
                  offset = (current_maximum_address - address) * self.word_size_bytes
                  data = data[offset:]
                  length = len(data) // self.word_size_bytes
                  address = current_maximum_address
  
              # Discard data above the maximum address.
              if address + length > maximum_address:
                  if address < maximum_address:
                      size = (maximum_address - address) * self.word_size_bytes
                      data = data[:size]
                      length = len(data) // self.word_size_bytes
                  elif maximum_address >= current_maximum_address:
                      binary += padding * (maximum_address - current_maximum_address)
                      break
  
              binary += padding * (address - current_maximum_address)
              binary += data
              current_maximum_address = address + length
  
          return binary