pc is increased by 1.
493158
public void emitGeneric(int opcode, Object[] args) {
        Instruction instr;
        InstructionType type;

        type = Set.TYPES[opcode];
        instr = new Instruction(-1, type, args);
        instructions.add(instr);
    }
767303
@ColorInt public static int increaseOpacity(Context context, @ColorRes int res, int alpha) {
        int c = resolveColor(res, context);
        return increaseOpacityFromInt(context, resolveColor(res, context), alpha);
    }
576371
def increment(self, amount=1):
        
        self._primaryProgressBar.setValue(self.value() + amount)
        QApplication.instance().processEvents()
1325282
private void enlargeCapacity(int key) {
	int diff = offCount - offset;

	int newSize = arr.length;
	if (newSize < 1) newSize = 1;
	while (newSize < key + offset + diff) {
	    newSize *= 2;
	}
	if (newSize > arr.length) {
	    Object[] na = new Object[newSize];
	    for (int i = offset; i < offset + size; i++) {
		na[i + diff] = arr[i];
	    }
	    arr = na;
	    offset += diff;
	}
    }
332293
public final void pcmpestrm(XMMRegister dst, XMMRegister src, Immediate imm8)
  {
    emitX86(INST_PCMPESTRM, dst, src, imm8);
  }
1358508
private void increaseSizeTo(int newSize) {
    assert (newSize > pointers.length);
    double[][] pointersBuf = new double[newSize][];
    boolean[] sparseBuf = new boolean[newSize];
    boolean[] copyOnWriteBuf = new boolean[newSize];
    System.arraycopy(pointers, 0, pointersBuf, 0, pointers.length);
    System.arraycopy(sparse, 0, sparseBuf, 0, pointers.length);
    System.arraycopy(copyOnWrite, 0, copyOnWriteBuf, 0, pointers.length);
    pointers = pointersBuf;
    sparse = sparseBuf;
    copyOnWrite = copyOnWriteBuf;
  }
471672
def increment(key, amount = 1, options = {})
      @cache.delete(key, options)
      @adapter.increment(key, amount, options)
    end
421179
def ones_comp_sum16(num1: int, num2: int) -> int:
    

    carry = 1 << 16
    result = num1 + num2
    return result if result < carry else result + 1 - carry
119786
public static Boolean greaterThan( Number n1 , Number n2 )
    {
        Class<?> type = getComputationType(n1,n2);
        Number val1 = convertTo(n1,type);
        Number val2 = convertTo(n2,type);

        if (type == Long.class)
            return val1.longValue() > val2.longValue() ? Boolean.TRUE : Boolean.FALSE;
        return val1.doubleValue() > val2.doubleValue() ? Boolean.TRUE : Boolean.FALSE;
    }
1062815
def _multiply(self, x1, x2, out):
        """"""
        for spc, xp, yp, outp in zip(self.spaces, x1.parts, x2.parts,
                                     out.parts):
            spc._multiply(xp, yp, outp)
818872
def increase_step(self) -> str:
        
        if self._steps_index < len(self._steps) - 1:
            self._steps_index = self._steps_index + 1
        return 'step: {}'.format(self.current_step())
564218
public synchronized boolean increase(Bitmap bitmap) {
    final int bitmapSize = BitmapUtil.getSizeInBytes(bitmap);
    if (mCount >= mMaxCount || mSize + bitmapSize > mMaxSize) {
      return false;
    }
    mCount++;
    mSize += bitmapSize;
    return true;
  }
246856
def increment(self):
        ''''''

        for i in xrange(len(self._counter) - 1, -1, -1):
            self._counter[i] += 1

            if self._counter[i] < 256: break

            # Carry the one
            self._counter[i] = 0

        # Overflow
        else:
            self._counter = [ 0 ] * len(self._counter)
810199
private void increaseLevel(boolean list)
	{
		level++;
		if(hasData.length == level)
		{
			// Grow lists when needed
			hasData = Arrays.copyOf(hasData, hasData.length * 2);
			lists = Arrays.copyOf(lists, hasData.length * 2);
		}

		hasData[level] = false;
		lists[level] = list;
	}
774212
public function increaseBy($key, $value) {
		$valueOld = $this->get($key, 0);
		if (is_numeric($value) && is_numeric($valueOld)) {
			$this->add($key, $value + $valueOld);
			return $value + $valueOld;
		}
	}
1368221
private void increment( TldFernFeature f , boolean positive ) {
		if( positive ) {
			f.incrementP();
			if( f.numP > maxP )
				maxP = f.numP;
		} else {
			f.incrementN();
			if( f.numN > maxN )
				maxN = f.numN;
		}
	}
149084
function(){
        var h=this.maxY-this.minY;
        var d=this.maxZ-this.minZ;
        return 2*((this.maxX-this.minX)*(h+d)+h*d);
    }