docs: def __changed_bytes(self, other):
          """
          Gets the set of changed bytes between `self` and `other`.
  
          :type other:    SimPagedMemory
          :returns:       A set of differing bytes.
          """
          if self._page_size != other._page_size:
              raise SimMemoryError("SimPagedMemory page sizes differ. This is asking for disaster.")
  
          our_pages = set(self._pages.keys())
          their_pages = set(other._pages.keys())
          their_additions = their_pages - our_pages
          our_additions = our_pages - their_pages
          common_pages = our_pages & their_pages
  
          candidates = set()
          for p in their_additions:
              candidates.update(other._pages[p].keys())
          for p in our_additions:
              candidates.update(self._pages[p].keys())
  
          for p in common_pages:
              our_page = self._pages[p]
              their_page = other._pages[p]
  
              if our_page is their_page:
                  continue
  
              our_keys = set(our_page.keys())
              their_keys = set(their_page.keys())
              changes = (our_keys - their_keys) | (their_keys - our_keys) | {
                  i for i in (our_keys & their_keys) if our_page.load_mo(self.state, i) is not their_page.load_mo(self.state, i)
              }
              candidates.update(changes)
  
          #both_changed = our_changes & their_changes
          #ours_changed_only = our_changes - both_changed
          #theirs_changed_only = their_changes - both_changed
          #both_deleted = their_deletions & our_deletions
          #ours_deleted_only = our_deletions - both_deleted
          #theirs_deleted_only = their_deletions - both_deleted
  
          differences = set()
          for c in candidates:
              if c not in self and c in other:
                  differences.add(c)
              elif c in self and c not in other:
                  differences.add(c)
              else:
                  if type(self[c]) is not SimMemoryObject:
                      self[c] = SimMemoryObject(self.state.solver.BVV(ord(self[c]), self.byte_width), c, byte_width=self.byte_width)
                  if type(other[c]) is not SimMemoryObject:
                      other[c] = SimMemoryObject(self.state.solver.BVV(ord(other[c]), self.byte_width), c, byte_width=self.byte_width)
                  if c in self and self[c] != other[c]:
                      # Try to see if the bytes are equal
                      self_byte = self[c].bytes_at(c, 1)
                      other_byte = other[c].bytes_at(c, 1)
                      if self_byte is not other_byte:
                          #l.debug("%s: offset %x, two different bytes %s %s from %s %s", self.id, c,
                          #        self_byte, other_byte,
                          #        self[c].object.model, other[c].object.model)
                          differences.add(c)
                  else:
                      # this means the byte is in neither memory
                      pass
  
          return differences