We believe this was a pointer and symbolized it before. Now we want to desymbolize it.

        The following actions are performed:
        - Reload content from memory
        - Mark the sort as 'unknown'

        :return: None
160380
def desymbolize(self):
        

        self.sort = 'unknown'
        content = self.binary.fast_memory_load(self.addr, self.size, bytes)
        self.content = [ content ]
907169
def pop(self, key=util_const.NoParam, default=util_const.NoParam):
        
        # Dictionary pop if key is specified
        if key is not util_const.NoParam:
            if default is util_const.NoParam:
                return (key, self._dict.pop(key))
            else:
                return (key, self._dict.pop(key, default))
        # Otherwise do a heap pop
        try:
            # Ammortized O(1)
            _heap = self._heap
            _dict = self._dict
            val, key = self._heappop(_heap)
            # Remove items marked for lazy deletion as they are encountered
            while key not in _dict or _dict[key] != val:
                val, key = self._heappop(_heap)
        except IndexError:
            if len(_heap) == 0:
                raise IndexError('queue is empty')
            else:
                raise
        del _dict[key]
        return key, val
196198
def copy_random_pointer_v2(head):
    
    copy = defaultdict(lambda: RandomListNode(0))
    copy[None] = None
    node = head
    while node:
        copy[node].label = node.label
        copy[node].next = copy[node.next]
        copy[node].random = copy[node.random]
        node = node.next
    return copy[head]
935790
def invalidate(self, assoc_handle, dumb):
        
        if dumb:
            key = self._dumb_key
        else:
            key = self._normal_key
        self.store.removeAssociation(key, assoc_handle)
1351735
def undelay(self):
        ''''''
        i = 0
        while i < len(self):
            op = self[i]
            i += 1
            if hasattr(op, 'arg1'):
                if isinstance(op.arg1,DelayedArg):
                    op.arg1 = op.arg1.resolve()
                if isinstance(op.arg1,CodeBlock):
                    op.arg1.undelay()
37628
def allocated_chunks(self):
        
        raise NotImplementedError("%s not implemented for %s" % (self.allocated_chunks.__func__.__name__,
                                                                 self.__class__.__name__))
409971
def heapify(self, key=__marker):
        
        if key is self.__marker:
            n = len(self._heap)
            for pos in reversed(range(n//2)):
                self._sink(pos)
        else:
            try:
                pos = self._position[key]
            except KeyError:
                raise KeyError(key)
            self._reheapify(pos)
120978
def deep_dup
      pointer = FFI::MemoryPointer.new(self.class.ary_type, max_size)
      pointer.write_bytes(self.bytes)
      self.class.new(pointer)
    end
377828
def __taint_load(self, instr):
        
        # Get memory address.
        op0_val = self.__emu.read_operand(instr.operands[0])

        # Get taint information.
        op0_taint = self.get_memory_taint(op0_val, instr.operands[2].size // 8)

        # Propagate taint.
        self.set_operand_taint(instr.operands[2], op0_taint)
439438
def _from_pointer(cls, pointer, incref):
        
        if pointer == ffi.NULL:
            raise ValueError('Null pointer')
        if incref:
            cairo.cairo_reference(pointer)
        self = object.__new__(cls)
        cls._init_pointer(self, pointer)
        return self
48410
def _ctypes_clean(parameter):
    
    if ("out" in parameter.direction and parameter.dimension is not None
        and ":" in parameter.dimension and ("pointer" in parameter.modifiers or
                                            "allocatable" in parameter.modifiers)):
        params = parameter.ctypes_parameter()
        result = []
        spacer = "    "
        #We get segfaults if we try to assign c-pointers to unallocated pointers or arrays.
        if "optional" in parameter.modifiers:
            if "pointer" in parameter.modifiers:
                result.append("{}if (associated({})) then".format(spacer, parameter.name))
                spacer += "  "
            elif "allocatable" in parameter.modifiers:
                result.append("{}if (allocated({})) then".format(spacer, parameter.name))
                spacer += "  "

        #We have to copy the values or at least update the pointer to access the
        #variables with 'target' and 'save' attributes.
        result.append("{0}{1}_t = {1}".format(spacer, parameter.name))
            
        if parameter.direction == "(inout)":
            result.append("{1}{0}_o = C_LOC({0}_t)".format(parameter.name, spacer))
            #Update the index variables for the dimensions of the output variable.
            for i, p in enumerate(params[1:-1]):
                result.append("{}{} = size({}, {})".format(spacer, p, parameter.name, i+1))
        else:
            #This is the case for intent(out)
            result.append("{1}{0}_c = C_LOC({0}_t)".format(parameter.name, spacer))
            for i, p in enumerate(params[1::]):
                result.append("{}{} = size({}, {})".format(spacer, p, parameter.name, i+1))

        if ("optional" in parameter.modifiers and
            ("pointer" in parameter.modifiers or "allocatable" in parameter.modifiers)):
            result.append("    end if")

        return ('\n'.join(result), True)
    elif parameter.dtype == "logical" and "out" in parameter.direction:
        return ("    {0}_c = {0}".format(parameter.name), False)
292106
def recursiveRepr(self, stuff, thunk=repr):
        
        ID = id(stuff)
        if ID in self.active:
            return '%s(...)' % (stuff.__class__.__name__,)
        else:
            try:
                self.active[ID] = stuff
                return thunk(stuff)
            finally:
                del self.active[ID]
496789
function (_e) {
										_draw(_e[0], uip);
										_currentInstance.removeClass(_e[0], "jsplumb-dragged");
										_currentInstance.select({source: _e[0]}).removeClass(_currentInstance.elementDraggingClass + " " + _currentInstance.sourceElementDraggingClass, true);
										_currentInstance.select({target: _e[0]}).removeClass(_currentInstance.elementDraggingClass + " " + _currentInstance.targetElementDraggingClass, true);
										_currentInstance.getDragManager().dragEnded(_e[0]);
									}
588098
private synchronized void removeTail() {

        I_CmsLruCacheObject oldTail = m_listTail;
        if (oldTail != null) {
            I_CmsLruCacheObject newTail = oldTail.getNextLruObject();

            // set the list pointers correct
            if (newTail != null) {
                // there are still objects remaining in the list
                newTail.setPreviousLruObject(null);
                m_listTail = newTail;
            } else {
                // we removed the last object from the list
                m_listTail = null;
                m_listHead = null;
            }

            // update cache stats. and notify the cached object
            decreaseCache(oldTail);
        }
    }
985047
def load_atomic(self, ptr, ordering, align, name=''):
        
        if not isinstance(ptr.type, types.PointerType):
            raise TypeError("cannot load from value of type %s (%r): not a pointer"
                            % (ptr.type, str(ptr)))
        ld = instructions.LoadAtomicInstr(self.block, ptr, ordering, align, name)
        self._insert(ld)
        return ld
1090979
private void leftDeleteNoPredecessor(
                                        GBSNode           p,
                                        Object            deleteKey,
                                        DeleteNode        point)
    {
        int idx = p.findDeleteInLeft(deleteKey);
        if (idx >= 0)
            point.setDelete(p, idx);
    }
381099
def chunk_from_mem(self, ptr):
        
        raise NotImplementedError("%s not implemented for %s" % (self.chunk_from_mem.__func__.__name__,
                                                                 self.__class__.__name__))