Return the memory objects overlapping with the provided slice.
        :param start: the start address
        :param end: the end address (non-inclusive)
        :returns: tuples of (starting_addr, memory_object)
185530
def load_slice(self, state, start, end):
        
        items = []
        if start > self._page_addr + self._page_size or end < self._page_addr:
            l.warning("Calling load_slice on the wrong page.")
            return items

        for addr in range(max(start, self._page_addr), min(
                end, self._page_addr + self._page_size)):
            i = addr - self._page_addr
            mo = self._storage[i]
            if mo is None and hasattr(self, "from_dbg"):
                byte_val = get_debugger().get_byte(addr)
                mo = SimMemoryObject(claripy.BVV(byte_val, 8), addr)
                self._storage[i] = mo
            if mo is not None and (not items or items[-1][1] is not mo):
                items.append((addr, mo))
        #print filter(lambda x: x != None, self._storage)
        return items
82130
def get_additional_occurrences(self, start, end):
        
        return [occ for key, occ in self.lookup.items() if (
            (end and occ.start < end) and
            occ.end >= start and not occ.cancelled)]
129037
def _getdata(self, data_source, start=None, end=None):
        """"""
        assert start is not None or end is not None, 'should at least specify start or end'
        start = start if start is not None else 0
        if end is None:
            end = data_source[0][1].shape[0] if data_source else 0
        s = slice(start, end)
        return [
            x[1][s]
            if isinstance(x[1], (np.ndarray, NDArray)) else
            # h5py (only supports indices in increasing order)
            array(x[1][sorted(self.idx[s])][[
                list(self.idx[s]).index(i)
                for i in sorted(self.idx[s])
            ]]) for x in data_source
        ]
999554
def slice(self, start=0, end=0):
        """"""
        tmp = Gauged.map_new()
        if tmp is None:
            raise MemoryError
        if not Gauged.map_concat(tmp, self.ptr, start, end, 0):
            Gauged.map_free(tmp)  # pragma: no cover
            raise MemoryError
        return SparseMap(tmp)
57116
def getrange(self, key, start, end, *, encoding=_NOTSET):
        
        if not isinstance(start, int):
            raise TypeError("start argument must be int")
        if not isinstance(end, int):
            raise TypeError("end argument must be int")
        return self.execute(b'GETRANGE', key, start, end, encoding=encoding)
582022
def _startstop_bool(startb, stopb, runflag, stopextend):
    
    # All false at start
    res = np.zeros(len(startb)) == True  # NOQA

    start_slices = slicelist(startb)
    stop_slices = slicelist(stopb)

    # Special case when there is a start but no stop slice or vice versa:
    # if start_slices and not stop_slices:
    if runflag == 'startonly':
        try:
            start = start_slices[0]
            # Make True from first start and rest of array.
            res[start.start:] = True
            return res
        except IndexError:
            # Only start specified but no start condition
            # fullfilled. Return all False.
            return res

    elif runflag == 'stoponly':
        try:
            stop = stop_slices[0]
            res[:stop.start + stopextend] = True  # Make True up to first stop.
            return res
        except IndexError:
            # Only stop specified but no stop condition fullfilled
            # Return all True
            return res == False  # NOQA

    stop = slice(0, 0)           # For first check
    start = slice(0, 0)          # For a possibly empty list start_slices.
    for start in start_slices:
        if start.start < stop.start:
            continue
        for stop in stop_slices:
            if stop.start > start.start:
                res[start.start: stop.start + stopextend] = True
                break           # Next start
        else:
            # On a given start slice, the entire list of stop slices was
            # exhausted, none being later than the given start. It must mean
            # that from this given start, the rest is to be True:
            break

    # There was no stop for the last start in loop
    if start.start > stop.start:
        res[start.start:] = True

    return res
576673
def get_sectors(self, start, end=None):
        
        s = self.get_sector_slice(start, end)
        return self.bytes[s], self.style[s]
725038
def buckets(self, start, end):
    '''
    
    '''
    start_bucket = self.to_bucket(start)
    end_bucket = self.to_bucket(end)
    return range(start_bucket, end_bucket+1)
1254783
def slice(self, begin, end):
        
        jrdds = self._jdstream.slice(self._jtime(begin), self._jtime(end))
        return [RDD(jrdd, self._sc, self._jrdd_deserializer) for jrdd in jrdds]
704275
function(start, end) {
        let _that = this[PRIVATE];
        start = Math.max(start, 0);
        end = Math.min(end, _that.gameboy.memory.length);

        return _that.gameboy.memory;
        //return _that.gameboy.memory.slice(start, end); //Why are you doing this functionally instead of just returning the entire object?
        //Is it for speed?
    }
1297417
def get_range(self, start=None, stop=None):
		
		return self.from_iterable(self.ranges(start, stop))
922213
public ByteBuffer[] getBuffers(int start, int len)
    {
        if (len == 0)
        {
            return ar0;
        }
        if (len > capacity)
        {
            throw new IllegalArgumentException("len="+len+" > capacity="+capacity);
        }
        int s = start % capacity;
        int e = (start+len) % capacity;
        return getBuffersForSpan(s, e);
    }
1000542
def slice_sequence(self,start,end):
     
     #find the sequence length
     l = self.length
     indexstart = start
     indexend = end
     ns = []
     tot = 0
     for r in self._rngs:
        tot += r.length
        n = r.copy()
        if indexstart > r.length:  
           indexstart-=r.length
           continue
        n.start = n.start+indexstart
        if tot > end: 
           diff = tot-end
           n.end -= diff
           tot = end
        indexstart = 0
        ns.append(n)
        if tot == end: break
     if len(ns)==0: return None
     return MappingGeneric(ns,self._options)
730021
def get_history(self, start, end):
        
        return self.history_table.set_index(
            'datetime',
            drop=False
        ).loc[slice(pd.Timestamp(start),
                    pd.Timestamp(end))]
350465
def memory_used(self):
        
        if self._end_memory:
            memory_used = self._end_memory - self._start_memory
            return memory_used
        else:
            return None
337428
def get_blocks(self, chrom, start, end):
    
    if chrom not in self.block_trees:
      return []
    return self.block_trees[chrom].intersectingInterval(start, end)
390966
def get_additional_occurrences(self, start, end):
        
        return [occ for _, occ in list(self.lookup.items()) if (occ.start < end and occ.end >= start and not occ.cancelled)]