Applies the XOR operator to a couple of booleans.

I/O contract
------------
<pre>
I    bool
I    bool
O    bool        Result of the XOR operation.
X    no
</pre>

@param I_O $IO
@return I_O
555228
public function EXE(I_O $IO)
    {
        return $IO->_O(
            $IO->I_(Type::BOOL) xor
            $IO->I_(Type::BOOL)
        );
    }
952615
public function where($column, $operator = null, $value = null, $boolean = 'and') {
        // If the column is an array, we will assume it is an array of key-value pairs
        // and can add them each as a where clause. We will maintain the boolean we
        // received when the method was called and pass it into the nested where.
        if (is_array($column)) {
            return $this->whereNested(function ($query) use ($column) {
                        foreach ($column as $key => $value) {
                            $query->where($key, '=', $value);
                        }
                    }, $boolean);
        }

        // Here we will make some assumptions about the operator. If only 2 values are
        // passed to the method, we will assume that the operator is an equals sign
        // and keep going. Otherwise, we'll require the operator to be passed in.
        if (func_num_args() == 2) {
            list($value, $operator) = [$operator, '='];
        } elseif ($this->invalidOperatorAndValue($operator, $value)) {
            throw new InvalidArgumentException('Illegal operator and value combination.');
        }

        // If the columns is actually a Closure instance, we will assume the developer
        // wants to begin a nested where statement which is wrapped in parenthesis.
        // We'll add that Closure to the query then return back out immediately.
        if ($column instanceof Closure) {
            return $this->whereNested($column, $boolean);
        }

        // If the given operator is not found in the list of valid operators we will
        // assume that the developer is just short-cutting the '=' operators and
        // we will set the operators to '=' and set the values appropriately.
        if (!in_array(strtolower($operator), $this->operators, true)) {
            list($value, $operator) = [$operator, '='];
        }

        // If the value is a Closure, it means the developer is performing an entire
        // sub-select within the query and we will need to compile the sub-select
        // within the where clause to get the appropriate query record results.
        if ($value instanceof Closure) {
            return $this->whereSub($column, $operator, $value, $boolean);
        }

        // If the value is "null", we will just assume the developer wants to add a
        // where null clause to the query. So, we will allow a short-cut here to
        // that method for convenience so the developer doesn't have to check.
        if (is_null($value)) {
            return $this->whereNull($column, $boolean, $operator != '=');
        }

        // Now that we are working with just a simple query we can put the elements
        // in our array and add the query binding to our array of bindings that
        // will be bound to each SQL statements when it is finally executed.
        $type = 'Basic';

        $this->wheres[] = compact('type', 'column', 'operator', 'value', 'boolean');

        if (!$value instanceof Expression) {
            $this->addBinding($value, 'where');
        }

        return $this;
    }
590728
private boolean isGoto(Instruction instruction) {
        return instruction.getOpcode() == Const.GOTO || instruction.getOpcode() == Const.GOTO_W;
    }
1221785
function xor(arr1, arr2) {
                var ans = new Array(arr1.length);
                for (var i = 0; i < arr1.length; i++)
                    ans[i] = arr1[i] ^ arr2[i];
                return ans;
            }
709827
public function executeByPath($arguments, array $options = [], IOInterface $io = null)
    {
        $io = $io ?: clone $this->io;

        // Path
        if (is_string($arguments)) {
            $arguments = str_replace('/', ' ', $arguments);
            $arguments = array_filter(explode(' ', $arguments), 'strlen');
        }

        $io->setArguments($arguments);

        // Options
        foreach ($options as $key => $value) {
            $io->setOption($key, $value);
        }

        return $this->getRootCommand()->setIO($io)->execute();
    }
190632
public OkCoinTradeResult futuresCancelOrder(long orderId, String symbol, FuturesContract contract)
      throws IOException {

    OkCoinTradeResult tradeResult =
        okCoin.futuresCancelOrder(
            apikey, String.valueOf(orderId), symbol, contract.getName(), signatureCreator());
    return returnOrThrow(tradeResult);
  }
475178
public function setIo(AuthAbstract $io)
  {
    $this->config->setIoClass(get_class($io));
    $this->io = $io;
  }
45385
private List applyOperationAndCheck(Operation op, MithraTransaction tx)
    {
        boolean oldEvaluationMode = tx.zIsInOperationEvaluationMode();
        List resultList = null;
        try
        {
            tx.zSetOperationEvaluationMode(true);
            if (this.isPureHome() || (!this.isOperationPartiallyCached(op) && !this.txParticipationRequired(tx, op)))
            {
                resultList = this.resolveOperationOnCache(op);
            }
            else
            {
                resultList = op.applyOperationToPartialCache();
                if (resultList == null && !this.isOperationPartiallyCached(op) && this.getTxParticipationMode(tx).mustParticipateInTxOnRead())
                {
                    // attempt to find what we have in cache to trigger waiting for potential other transactions
                    List untrustworthyResult = op.applyOperationToFullCache();
                    checkTransactionParticipationAndWaitForOtherTransactions(untrustworthyResult, tx);
                }
                resultList = checkTransactionParticipationAndWaitForOtherTransactions(resultList, tx);
            }
        }
        finally
        {
            tx.zSetOperationEvaluationMode(oldEvaluationMode);
        }
        if (this.isPureHome())
        {
            checkTransactionParticipationForPureObject(resultList, tx);
        }
        return resultList;
    }
433296
public function activate(Composer $composer, IOInterface $io)
    {
        /** composer and io properties are assgned for convenience */
        $this->composer = $composer;
        $this->io = $io;
    }
85380
private function getBoolQuery($field, array $values, $operator)
    {
        $type = ('or' === strtolower($operator) ? BoolQuery::SHOULD : BoolQuery::MUST);

        $query = new BoolQuery();
        foreach ($values as $value) {
            $query->add(new TermQuery($field, $value), $type);
        }

        return $query;
    }
1095962
private function printBindingTypeState(IO $io, $typeState)
    {
        switch ($typeState) {
            case BindingTypeState::ENABLED:
                $io->writeLine('The following binding types are currently enabled:');
                $io->writeLine('');

                return;
            case BindingTypeState::DUPLICATE:
                $io->writeLine('The following types have duplicate definitions and are disabled:');
                $io->writeLine('');

                return;
        }
    }
1135124
public function logicalXor(self $other){
		
		$l = \max(array($this->count(), $other->count()));
		$new = new static();
		
		for($i = 0; $i < $l; ++$i){

			if(isset($this[$i], $other[$i])){
				$new[$i] = (bool)($this[$i] ^ $other[$i]);
			}
			else{
				$new[$i] = false;
			}
			
		}
		
		return $new;
		
	}
1251591
private static byte[] xor(byte[] bytes) {
        byte[] xor_bytes = null;

        if (bytes != null) {
            xor_bytes = new byte[bytes.length];

            for (int i = 0; i < bytes.length; i++) {
                xor_bytes[i] = (byte) (XOR_MASK ^ bytes[i]);
            }
        }

        return xor_bytes;
    }
854203
public static long[] xorI(long[] v, long[] o) {
    assert (o.length <= v.length) : "Bit set sizes do not agree.";
    for(int i = 0; i < o.length; i++) {
      v[i] ^= o[i];
    }
    return v;
  }
1016893
public static function getInput(IOInterface $io)
    {
        $ref = new \ReflectionClass($io);

        if ($ref->hasProperty('input')) {
            $prop = $ref->getProperty('input');
            $prop->setAccessible(true);
            $input = $prop->getValue($io);

            if ($input instanceof InputInterface) {
                return $input;
            }
        }

        return new ArgvInput();
    }
1089727
public function setIo(Google_IO_Abstract $io)
  {
    $this->config->setIoClass(get_class($io));
    $this->io = $io;
  }
46403
private static boolean implementsInterface(final Object o) {
        final boolean retVal;
        retVal = (o instanceof Serializable) || (o instanceof Externalizable);
        return retVal;
    }