Returns new context stack, which doesn't contain few levels
344713
def pop(self, count):
        
        if len(self._contexts) - 1 < count:
            _logger.error("#pop value is too big %d", len(self._contexts))
            if len(self._contexts) > 1:
                return ContextStack(self._contexts[:1], self._data[:1])
            else:
                return self

        return ContextStack(self._contexts[:-count], self._data[:-count])
1228111
function liftContext(ctx, func) {
  if (!ctx.pure) {
    throw new Error("no monad's definition is provided");
  }
  return function() {
    var saved;
    saved = context;
    context = ctx;
    try {
      return func.apply(null, arguments);
    } finally {
      context = saved;
    }
  };
}
491769
def append(self, context, data):
        
        return ContextStack(self._contexts + [context], self._data + [data])
230928
def skip_common_stack_elements(stacktrace, base_case):
  """"""
  for i, (trace, base) in enumerate(zip(stacktrace, base_case)):
    if trace != base:
      return stacktrace[i:]
  return stacktrace[-1:]
815806
function _createContext(context) {
  let newContext = context || _defaultContext
  if (_isString(newContext) || _isArray(newContext)) {
    newContext = {
      any: _arrayify(newContext),
    }
  } else {
    newContext = _arrayizeContext(context)
  }
  return newContext
}
33227
def process_instrs(queue, stack, body, context):
    
    next_instr = queue.popleft
    while queue:
        newcontext = _process_instr(next_instr(), queue, stack, body, context)
        if newcontext is not None:
            context = newcontext
51521
def push(new_scope = {})
      @scopes.unshift(new_scope)
      raise StackLevelError, "Nesting too deep".freeze if @scopes.length > Block::MAX_DEPTH
    end
388569
def stack_push(self, thing):
        
        # increment sp
        sp = self.regs.sp + self.arch.stack_change
        self.regs.sp = sp
        return self.memory.store(sp, thing, endness=self.arch.memory_endness)
263066
function(context) {
        var contextObj = {};
        for(var i=0; i<context.length; i++) {
            if(context[i] !== '0') {
                contextObj[this.dimensionsList[i]] = this.numberToValue[context[i]];
            }
        }
        return contextObj;
    }
309492
def context
      c = Thread.current.thread_variable_get(NAME)

      if c.nil?
        c = if Thread.current.thread_variable_get(STACK_NAME)
          flatten(stack)
        else
          Hash.new
        end
        Thread.current.thread_variable_set(NAME, c)
      end

      return c
    end
53934
function(context, descriptor, args, stack) {
		var opt = args[0],
			template = args[1],
			sod = new SOD();
		secondPass(template, context, sod, stack);
		if (sod.children)
			descriptor.children += sod.children;
	}
1175374
function(context, args, stack) {
		var path = args[0],
			template = args[1],
			pathIsString = typeof path === 'string';
		ctx = new Context(pathIsString ? context.get(path) : path, context, pathIsString ? path : null);
		stack.push(ctx);
		firstPass(template, ctx, stack);
	}
242994
def nested(*contexts):
    
    with ExitStack() as stack:
        results = [
            stack.enter_context(context)
            for context in contexts
        ]
        yield results
1219202
function pushContext(data) {
                        
                        // Some data is not needed on subchildren
                        if (depth === 0) {
                            data.timestamp = Date.now() - responseEndTime;
                            data.loadingStep = phantomas.currentStep || '';
                        }

                        // Some data is not needed on subchildren
                        if (depth > 0) {
                            if (data.backtrace) {
                                delete data.backtrace;
                            }
                            if (data.resultsNumber) {
                                delete data.resultsNumber;
                            }
                        }

                        currentContext.addChild(data);
                    }
700016
def context(self, key, method):
        
        ctx = stack.top
        if ctx is not None:
            if not hasattr(ctx, key):
                setattr(ctx, key, method())
            return getattr(ctx, key)
997807
def level_for_context(context)
      lvl = self.levels_cache[nil]
      root = []
      context.to_s.split('::').each do |part|
        root << part
        path = root.join '::'
        lvl = self.levels_cache[path] if self.levels_cache.key? path
      end
      lvl
    end
1078685
function _maskContext(context) {
    var Component = this._currentElement.type;
    var contextTypes = Component.contextTypes;
    if (!contextTypes) {
      return emptyObject;
    }
    var maskedContext = {};
    for (var contextName in contextTypes) {
      maskedContext[contextName] = context[contextName];
    }
    return maskedContext;
  }