we could always escape if we wanted to.
500583
private void printEscaped(String s, boolean isAttributeValue) {
        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            switch (c) {
                case '<':
                    out.print("&lt;");
                    break;
                case '>':
                    out.print("&gt;");
                    break;
                case '&':
                    out.print("&amp;");
                    break;
                case '\'':
                    if (isAttributeValue && quote.equals("'"))
                        out.print("&apos;");
                    else
                        out.print(c);
                    break;
                case '"':
                    if (isAttributeValue && quote.equals("\""))
                        out.print("&quot;");
                    else
                        out.print(c);
                    break;
                case '\n':
                    if (isAttributeValue)
                        out.print("&#10;");
                    else
                        out.print(c);
                    break;
                case '\r':
                    if (isAttributeValue)
                        out.print("&#13;");
                    else
                        out.print(c);
                    break;
                default:
                    out.print(c);
            }
        }
    }
99578
function alwaysReturns(node) {
            if (node.type === "BlockStatement") {

                // If we have a BlockStatement, check each consequent body node.
                return node.body.some(checkForReturnOrIf);
            }

            /*
             * If not a block statement, make sure the consequent isn't a
             * ReturnStatement or an IfStatement with returns on both paths.
             */
            return checkForReturnOrIf(node);
        }
72287
function exit(inst, state, fin) {
    return fin(_wrapError(_outOfGasError(inst), inst, state), state);
}
773629
public static <T> Predicate<T> always() {
        return new Predicate<T>() {
            @Override
            public boolean test( T input ) {
                return true;
            }
        };
    }
500913
public boolean canMove(NsType nsType) {
		boolean rv;
		switch(nsType) {
			case DOT:
			case ROOT:
			case COMPANY:
			case UNKNOWN:
				rv = false;
				break;
			default:
				rv = true;
		}
		return rv;
	}
1059114
def compatible(self, a, b):
        """"""
        return len(set([a] + self.descendants(a))
                   .intersection([b] + self.descendants(b))) > 0
379457
def safely(*args, &block)
      previous_state = @rye_safe
      enable_safe_mode
      ret = self.instance_exec *args, &block
      @rye_safe = previous_state
      ret
    end
194899
def jump(self, addr):
        
        self.inhibit_autoret = True
        self._exit_action(self.state, addr)
        self.successors.add_successor(self.state, addr, self.state.solver.true, 'Ijk_Boring')
1191420
def run_forever(self):
        """"""
        res = self.slack.rtm.start()
        self.log.info("current channels: %s",
                      ','.join(c['name'] for c in res.body['channels']
                               if c['is_member']))
        self.id = res.body['self']['id']
        self.name = res.body['self']['name']
        self.my_mention = "<@%s>" % self.id

        self.ws = websocket.WebSocketApp(
            res.body['url'],
            on_message=self._on_message,
            on_error=self._on_error,
            on_close=self._on_close,
            on_open=self._on_open)
        self.prepare_connection(self.config)
        self.ws.run_forever()
1090066
def exit(self):
        ''''''
        self.output.write("Happy hacking!")
        self.output.nextLine()
        self.output.loseConnection()
211865
def being(self):
		
		try:
			if self.connection is not None:
				self.lock()
				c = self.getCursor()
				c.execute('BEGIN;')
				c.close()
		except Exception, e:
			pass
149932
def allows(self):
        '''
        

        '''
        tick = time.time()
        passed = tick - self.lasttick

        self.allowance = min(self.rate, self.allowance + (passed * self.persec))

        self.lasttick = tick

        if self.allowance < 1.0:
            return False

        self.allowance -= 1.0
        return True
802498
def StringFinish(self, **_):
    """"""
    if self.state == "ARG":
      return self.InsertArg(string=self.string)
564714
async def handle_forever(self):
        
        while self.connected:
            data = await self.connection.recv()
            if not data:
                if self.connected:
                    await self.disconnect(expected=False)
                break
            await self.on_data(data)
335966
public void finest(String format, Object... args)
    {
        if (isLoggable(FINEST))
        {
            logIt(FINEST, String.format(format, args));
        }
    }
156087
function all(iterable){
    var C          = this
      , capability = newPromiseCapability(C)
      , resolve    = capability.resolve
      , reject     = capability.reject;
    var abrupt = perform(function(){
      var values    = []
        , index     = 0
        , remaining = 1;
      _forOf(iterable, false, function(promise){
        var $index        = index++
          , alreadyCalled = false;
        values.push(undefined);
        remaining++;
        C.resolve(promise).then(function(value){
          if(alreadyCalled)return;
          alreadyCalled  = true;
          values[$index] = value;
          --remaining || resolve(values);
        }, reject);
      });
      --remaining || resolve(values);
    });
    if(abrupt)reject(abrupt.error);
    return capability.promise;
  }
459603
public void doFinally() {
        if (conn != null) {
            try {
                if ((isolation != Connection.TRANSACTION_NONE)
                        && (isolation != origIsolation)) {
                    conn.setTransactionIsolation(origIsolation);
                }
                conn.setAutoCommit(true);
                conn.close();
            } catch (SQLException e) {
                // Not much we can do
            }
        }
        conn = null;
        isolation = Connection.TRANSACTION_NONE;
    }