utils.popWin ----------
341768
function getPopFrameOpt_(obj, popOption) {
  var frameEle = null,
      dFrame = popOption.frame || {},
      framePath = dFrame.path;
  if (framePath) {
    frameEle = obj.componentOf(framePath);
    frameEle = frameEle && frameEle.fullClone();
    if (!frameEle) {
      if (!W.__design__) delete popOption.frame; // next time use default frame
      console.log('warning: can not locate popup frame (' + framePath + ').');
    }
  }
  return frameEle || null;
}
452586
def pop(self):
        """"""
        e = self.data[self.start]
        self.start += 1
        if self.start > 5 and self.start > len(self.data)//2:
            self.data = self.data[self.start:]
            self.start = 0
        return e
659176
def _blocking_pop(self, pop_func, keys, timeout):
        """"""
        if not isinstance(timeout, (int, long)):
            raise RuntimeError('timeout is not an integer or out of range')

        if timeout is None or timeout == 0:
            timeout = self.blocking_timeout

        if isinstance(keys, basestring):
            keys = [keys]
        else:
            keys = list(keys)

        elapsed_time = 0
        start = time.time()
        while elapsed_time < timeout:
            key, val = self._pop_first_available(pop_func, keys)
            if val:
                return key, val
            # small delay to avoid high cpu utilization
            time.sleep(self.blocking_sleep_interval)
            elapsed_time = time.time() - start
        return None
861889
def zpopmin(self, key, count=None, *, encoding=_NOTSET):
        
        if count is not None and not isinstance(count, int):
            raise TypeError("count argument must be int")

        args = []
        if count is not None:
            args.extend([count])

        fut = self.execute(b'ZPOPMIN', key, *args, encoding=encoding)
        return fut
372091
function () {
            var t = this.dpop() >>> 0;
            var n = this.dpop() >>> 0;
            var nn = Long.fromValue(n, true);
            var tt = Long.fromValue(t, true);
            var ddd = nn.mul(tt);
            this.dpush(ddd.low);
            this.dpush(ddd.high);
        }
701595
def _update_pop(self, pop_size):
        """"""
        offspring = list(map(self.toolbox.clone, self.population))
        for _ in range(pop_size // 2):
            if random.random() < self.cxpb:
                child1, child2 = self.toolbox.select(self.population, 2, 6)
                temp1 = self.toolbox.clone(child1)
                temp2 = self.toolbox.clone(child2)
                self.toolbox.mate(temp1, temp2)
                del temp1.fitness.values
                del temp2.fitness.values
                offspring.append(temp1)
                offspring.append(temp2)
        for mutant in offspring:
            if random.random() < self.mutpb:
                self.toolbox.mutate(mutant)
                del mutant.fitness.values
        # simple bound checking
        for i in range(len(offspring)):
            for j in range(len(offspring[i])):
                if offspring[i][j] > 1:
                    offspring[i][j] = 1
                if offspring[i][j] < -1:
                    offspring[i][j] = -1
        self._model_count += len(
            [ind for ind in offspring if not ind.fitness.values])
        self.assign_fitnesses(
            [ind for ind in offspring if not ind.fitness.valid])
        offspring.sort(reverse=True, key=lambda x: x.fitness)
        if len(self.halloffame) != 0:
            # elitism- if none beat best so far it is reinserted
            if offspring[0].fitness < self.halloffame[0].fitness:
                offspring.insert(0, self.halloffame[0])
        self.population[:] = offspring[:pop_size]
        return
1297026
public T pop()
    {
        T val = beginChunk.values[beginPos];
        beginChunk.values[beginPos] = null;
        beginPos++;
        if (beginPos == size) {
            beginChunk = beginChunk.next;
            beginChunk.prev = null;
            beginPos = 0;
        }
        return val;
    }
654021
public static void bindPopped (final Value<Boolean> popped, final Thunk thunk)
    {
        Preconditions.checkNotNull(thunk, "thunk");
        popped.addListenerAndTrigger(new Value.Listener<Boolean>() {
            public void valueChanged (Boolean visible) {
                if (visible) {
                    popped.removeListener(this);
                    bindPopped(popped, thunk.createPopup());
                }
            }
        });
    }
1133662
def _update_pop(self, pop_size):
        """"""
        candidates = []
        for ind in self.population:
            candidates.append(self._crossover(ind))
        self._model_count += len(candidates)
        self.assign_fitnesses(candidates)
        for i in range(len(self.population)):
            if candidates[i].fitness > self.population[i].fitness:
                self.population[i] = candidates[i]
        return
375784
public void popTypeVariables (int count) {
		int n = argumentsSize, i = n - count;
		argumentsSize = i;
		while (i < n)
			arguments[i++] = null;
	}
579955
async def rpoplpush(self, src, dst):
        
        value = await self.rpop(src)

        if value:
            await self.lpush(dst, value)
            return value

        return None
1325352
def popitem(self):
        """"""
        try:
            key = next(iter(self.__order))
        except StopIteration:
            raise KeyError('%s is empty' % self.__class__.__name__)
        else:
            return (key, self.pop(key))
376698
function populateStack(stack, rootPath, files, callback) {
  stack.unshift(...files
    .filter(file => file.stats.isDirectory())
    .map(file => path.join(rootPath, file.path)));
  async.nextTick(callback, null, files);
}
1369144
function isExpoProject(projPath) {
	try {
		let module = resolveFrom(projPath, "expo");
		let appInfo = require(`${projPath}/app.json`);

		return !!(module && appInfo.expo);
	} catch (err) {
		return false;
	}
}
45667
def set_pop_service(username = nil, password = nil)
      self.user_name = username
      self.password  = password
      self.service   = Credential::Service::POP
    end
530542
function popcount(x) {
    x -= x >> 1 & 0x55555555;
    x = (x & 0x33333333) + (x >> 2 & 0x33333333);
    x = x + (x >> 4) & 0x0f0f0f0f;
    x += x >> 8;
    x += x >> 16;
    return x & 0x7f;
}
706249
void popOutputVar() {
    outputVars.pop();
    OutputVar outputVar = outputVars.peek(); // null if outputVars is now empty
    if (outputVar != null) {
      currOutputVarName = outputVar.name();
      currOutputVarIsInited = outputVar.isInited();
    } else {
      currOutputVarName = null;
      currOutputVarIsInited = false;
    }
  }