Gets the set of changed bytes between `self` and `other`.

        :type other:    SimPagedMemory
        :returns:       A set of differing bytes.
12301
def __changed_bytes(self, other):
        
        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
748603
def sgt(self, other):
        
        self._check_match(other)
        return self.to_sint() > other.to_sint()
531681
def symmetric_difference_update(self, other):
        # type: (Iterable[Any]) -> _BaseSet
        
        intersect = self.intersection(other)
        self.remove(*intersect)
        for elem in set(other).difference(intersect):
            self.add(elem)
        return self
607245
def difference(self, *others):
        
        return self.copy(super(NGram, self).difference(*others))
380594
def difference(self, other):
        """"""
        return self.operation(other, lambda x, y: x - y)
1131479
def difference (b, a):
    
    a = set(a)
    result = []
    for item in b:
        if item not in a:
            result.append(item)
    return result
362505
def difference_update(self, *others):
        
        return self._op_update_helper(
            tuple(others), operator.sub, 'sdiffstore', update=True
        )
1220113
def difference(self, other):
        
        ivs = set()
        for iv in self:
            if iv not in other:
                ivs.add(iv)
        return IntervalTree(ivs)
313238
def _swap(self, other):
        
        self.__dict__, other.__dict__ = other.__dict__, self.__dict__
1010490
def sdiff(self, *other_sets):
        
        return self.db.sdiff([self.key] + [s.key for s in other_sets])
1074754
def difference(self, *iterables):
        
        diff = self._set.difference(*iterables)
        return self._fromset(diff, key=self._key)
436973
def sims(self):
        
        if self._sims is None:
            self._sims = SimList(self)
        return self._sims
1237207
public IntDoubleSortedVector getDiff(IntDoubleVector other) {
        IntDoubleSortedVector diff = new IntDoubleSortedVector(this);
        diff.subtract(other);
        return diff;
    }
419132
def get(self, start, end):
        
        return [self.read_byte(addr) for addr in range(start, end)]
861277
def symmetric_difference(self, other):
        
        return self.copy(super(NGram, self).symmetric_difference(other))
516116
def difference(self, *iterables):
        
        diff = self._set.difference(*iterables)
        new_set = self.__class__(key=self._key, load=self._load, _set=diff)
        return new_set
605208
def _other_to_dict(self, other):
    
    if isinstance(other, ModelBase):
      return other.to_dict()
    elif isinstance(other, list):
      # TODO: what if it's not a list?
      return [self._other_to_dict(i) for i in other]
    else:
      return other