stitch delta together in reverse
2736
private BlockedDelta reverseCompute() {
        int contentSize = getValue(_next).remaining();
        UUID correctChangeId = getChangeId(_next);
        int numBlocks = 1;

        if (_list == null) {
            _list = Lists.newArrayListWithCapacity(3);
        }

        _list.add(_next);


        _oldDelta = _next;

        while (_iterator.hasNext() && getChangeId(_next = _iterator.next()).equals(correctChangeId)) {
            numBlocks++;
            _list.add(_next);
            contentSize += getValue(_next).remaining();
            _next = null;
        }

        Collections.reverse(_list);

        // delta is fragmented if the first block is not zero. In this case, we skip it.
        if (getBlock(_list.get(0)) != 0) {
            // We must also clear the list of the fragmented delta blocks to avoid them being stitched in with
            // the next delta, which will cause a buffer overflow
            _list.clear();
            return null;
        }

        int expectedBlocks = getNumBlocks(_list.get(0));

        while (expectedBlocks != _list.size()) {
            contentSize -= getValue(_list.remove(_list.size() - 1)).remaining();
        }

        return new BlockedDelta(numBlocks, stitchContent(contentSize));

    }
1368104
def delta(to)
      diff = (to.to_f - self.to_f).abs % FULL_ANGLE
      diff = -(FULL_ANGLE - diff) if diff > Math::PI
      to.to_f < self.to_f ? -diff : diff
    end
194702
def abs_timedelta(delta):
    """"""
    if delta.days < 0:
        now = _now()
        return now - (now + delta)
    return delta
149182
function merge(prev, current, next) {
  return prev
    .concat()
    .reverse()
    .concat([current], next)
}
640693
def reverse_fd(inf, outf):
    '''
    '''
    inf.seek(0, 2)
    size = inf.tell()
    if not size:
        return

    chunks = split_size(size)
    for chunk in reversed(chunks):
        inf.seek(chunk[0], 0)
        data = inf.read(chunk[1])
        if len(data) != chunk[1]:
            raise IOError('incomplete I/O operation')
        outf.write(data[::-1])
350414
private Deque<MutablePair<DeltaType, Object>> combineDeltas(
      LinkedList<MutablePair<DeltaType, Object>> deltas) {
    if (deltas.size() < 2) {
      return deltas;
    }
    int size = deltas.size();
    MutablePair<DeltaType, Object> d1 = deltas.peekLast();
    MutablePair<DeltaType, Object> d2 = deltas.get(size - 2);
    MutablePair<DeltaType, Object> out = isDuplicate(d1, d2);
    if (out != null) {
      Deque<MutablePair<DeltaType, Object>> newDeltas = new LinkedList<>();
      newDeltas.addAll(deltas.subList(0, size - 2));
      newDeltas.add(out);
      return newDeltas;
    }
    return deltas;
  }
877554
def reversed(self):
        """"""
        new_quad = QuadraticBezier(self.end, self.control, self.start)
        if self._length_info['length']:
            new_quad._length_info = self._length_info
            new_quad._length_info['bpoints'] = (
                self.end, self.control, self.start)
        return new_quad
857798
def reversed(self):
		'''
			
		'''
		alphabet = self.alphabet

		# Start from a composite "state-set" consisting of all final states.
		# If there are no final states, this set is empty and we'll find that
		# no other states get generated.
		initial = frozenset(self.finals)

		# Find every possible way to reach the current state-set
		# using this symbol.
		def follow(current, symbol):
			next = frozenset([
				prev
				for prev in self.map
				for state in current
				if symbol in self.map[prev] and self.map[prev][symbol] == state
			])
			if len(next) == 0:
				raise OblivionError
			return next

		# A state-set is final if the initial state is in it.
		def final(state):
			return self.initial in state

		# Man, crawl() is the best!
		return crawl(alphabet, initial, final, follow)
1045944
def consolidate_reverse_exprs(initial_state):
    
    initial_state.inspect.b('mem_read', when=angr.BP_AFTER, action=_read_consolidate)
    initial_state.inspect.b('reg_read', when=angr.BP_AFTER, action=_read_consolidate)
778140
def inverse(d):
    
    output = {}
    for k, v in unwrap(d).items():
        output[v] = output.get(v, [])
        output[v].append(k)
    return output
441574
def delta(text):
    '''
    
    '''
    text = text.strip().lower()

    _, offs = _noms(text, 0, ' \t\r\n')

    sign = '+'
    if text and text[0] in ('+', '-'):
        sign = text[0]
        offs += 1

    _, offs = _noms(text, offs, ' \t\r\n')

    sizetext, offs = _noms(text, offs, '0123456789')

    _, offs = _noms(text, offs, ' \t\r\n')

    unittext = text[offs:]

    size = int(sizetext, 0)

    if sign == '-':
        size = -size

    base = timeunits.get(unittext)
    if base is None:
        mesg = f'unknown time delta units: {unittext}'
        raise s_exc.BadTypeValu(name='time', valu=text, mesg=mesg)

    return size * base
605902
private Delta<E> toDelta(difflib.Delta<E> delta) throws DiffException
    {
        Delta<E> newDelta;

        switch (delta.getType()) {
            case CHANGE:
                newDelta = new ChangeDelta<E>(delta.getOriginal(), delta.getRevised());
                break;
            case DELETE:
                newDelta = new DeleteDelta<E>(delta.getOriginal(), delta.getRevised());
                break;
            case INSERT:
                newDelta = new InsertDelta<E>(delta.getOriginal(), delta.getRevised());
                break;
            default:
                throw new DiffException(String.format("Failed to convert [%s] info [%s]. Unknown type [%s]", delta
                    .getClass().getName(), Delta.class.getName(), delta.getType().toString()));
        }

        return newDelta;
    }
862238
def inverse_transform(self, X):
        """"""
        non_cat = pd.DataFrame(X[:, :len(self.non_cat_columns_)],
                               columns=self.non_cat_columns_)
        cats = []
        for col, cat in self.cat_map_.items():
            slice_ = self.cat_blocks_[col]
            codes = X[:, slice_].argmax(1)
            series = pd.Series(pd.Categorical.from_codes(
                codes, cat.categories, ordered=cat.ordered
            ), name=col)
            cats.append(series)
        df = pd.concat([non_cat] + cats, axis=1)[self.columns_]
        return df
625975
def _get_deltas(event):
        """"""
        delta_x = round(event.deltaX())
        delta_y = round(event.deltaY())
        delta_z = round(event.deltaZ())
        return delta_x, delta_y, delta_z
1154160
def fix_symbol(self, symbol, reverse=False):
        
        if not self.symbol_mapping:
            return symbol

        for old, new in self.symbol_mapping:
            if reverse:
                if symbol == new:
                    return old
            else:
                if symbol == old:
                    return new

        return symbol
151227
def _Delta(a, b):
  """"""
  if a+1 == b:
    if a%2 == 0:
      return 'EvenOdd'
    else:
      return 'OddEven'
  if a == b+1:
    if a%2 == 0:
      return 'OddEven'
    else:
      return 'EvenOdd'
  return b - a
646511
void reverse( Grid g ) {
		work.clear();
		int N = g.rows*g.columns;
		for (int i = 0; i < N; i++) {
			work.add( g.ellipses.get(N-i-1));
		}

		g.ellipses.clear();
		g.ellipses.addAll(work);
	}