Change (x not in y) to not(x in y).
348688
def ComplementMembership(*args, **kwargs):
    """"""
    return ast.Complement(
        ast.Membership(*args, **kwargs), **kwargs)
1021357
function omit(a, elt) {
  var index = a.indexOf(elt);
  if (index !== -1) {
    a.splice(index, 1);
  }
  return a;
}
890309
def adjust!(other)
      @x0 = other.x0 if other.x0 < @x0
      @y0 = other.y0 if other.y0 < @y0
      @x1 = other.x1 if other.x1 > @x1
      @y1 = other.y1 if other.y1 > @y1
    end
18147
def negate_gate(wordlen, input='x', output='~x'):
    """"""
    neg = bitwise_negate(wordlen, input, "tmp")
    inc = inc_gate(wordlen, "tmp", output)
    return neg >> inc
408027
public Formula not(final Formula operand) {
    if (operand.type() == LITERAL || operand.type() == FALSE || operand.type() == TRUE || operand.type() == NOT)
      return operand.negate();
    Not not = this.nots.get(operand);
    if (not == null) {
      not = new Not(operand, this);
      this.nots.put(operand, not);
    }
    return not;
  }
1076477
def lt(self, value):
        
        self.op = '<'
        self.negate_op = '>='
        self.value = self._value(value)
        return self
125714
function _not(val) {
    if (arguments.length === 1) {
      this._notFlag = val;
      return this;
    }
    var ret = this._notFlag;
    this._notFlag = false;
    return ret;
  }
1111491
def p_not_expression(tok):
        """"""
        if len(tok) == 3:
            tok[0] = UnaryOperationRule(tok[1], tok[2])
        else:
            tok[0] = tok[1]
465675
def move(self, x, y):
        """"""
        SetWindowPos(self._hwnd, None, x, y, 0, 0, SWP_NOSIZE)
967106
def _skip_to_nonblank(f, spacegroup, setting):
    """"""
    while True:
        line1 = f.readline()
        if not line1:
            raise SpacegroupNotFoundError(
                'invalid spacegroup %s, setting %i not found in data base' %
                ( spacegroup, setting ) )
        line1.strip()
        if line1 and not line1.startswith('#'):
            line2 = f.readline()
            break
    return line1, line2
622075
def _notin(expr, values):
    

    if isinstance(expr, SequenceExpr):
        return NotIn(_input=expr, _values=values, _data_type=types.boolean)
    elif isinstance(expr, Scalar):
        return NotIn(_input=expr, _values=values, _value_type=types.boolean)
371692
def not26(func):
    """"""

    @wraps(func)
    def errfunc(*args, **kwargs):
        raise NotImplementedError

    if hexversion < 0x02070000:
        return errfunc
    else:
        return func
393432
def negate(self):
        """"""
        self.from_value, self.to_value = self.to_value, self.from_value
        self.include_lower, self.include_upper = self.include_upper, self.include_lower
1039525
public void update(double x, double y)
    {
        boolean changed = false;
        if (x < xMin || Double.isNaN(xMin))
        {
            xMin = x;
            changed = true;
        }
        if (x > xMax || Double.isNaN(xMax))
        {
            xMax = x;
            changed = true;
        }
        if (y < yMin || Double.isNaN(yMin))
        {
            yMin = y;
            changed = true;
        }
        if (y > yMax || Double.isNaN(yMax))
        {
            yMax = y;
            changed = true;
        }
    }
715575
public Constraint not(Constraint constraint) {
        if (!(constraint instanceof Not))
            return new Not(constraint);

        return ((Not)constraint).getConstraint();
    }
182565
def _replace_bbox_none(self, bbox):
        """"""

        (bb_top, bb_left), (bb_bottom, bb_right) = bbox

        if bb_top is None:
            bb_top = 0

        if bb_left is None:
            bb_left = 0

        if bb_bottom is None:
            bb_bottom = self.code_array.shape[0] - 1

        if bb_right is None:
            bb_right = self.code_array.shape[1] - 1

        return (bb_top, bb_left), (bb_bottom, bb_right)
1142279
@Override
    public BooleanExpression not() {
        if (not == null) {
            // uses this, because it makes unwrapping easier
            not = Expressions.booleanOperation(Ops.NOT, this);
        }
        return not;
    }