$ANTLR start "LESSER_EQUAL"
325898
public final void mLESSER_EQUAL() throws RecognitionException {
        try {
            int _type = LESSER_EQUAL;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // src/riemann/Query.g:13:14: ( '<=' )
            // src/riemann/Query.g:13:16: '<='
            {
            match("<="); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }
612503
public ExpressionBuilder lessThanOrEquals(final SubordinateTrigger trigger, final Object compare) {
		BooleanExpression exp = new CompareExpression(CompareType.LESS_THAN_OR_EQUAL, trigger,
				compare);
		appendExpression(exp);

		return this;
	}
547968
public final QueryParser.greater_equal_return greater_equal() throws RecognitionException {
        QueryParser.greater_equal_return retval = new QueryParser.greater_equal_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token WS61=null;
        Token GREATER_EQUAL62=null;
        Token WS63=null;
        QueryParser.field_return field60 = null;

        QueryParser.value_return value64 = null;


        CommonTree WS61_tree=null;
        CommonTree GREATER_EQUAL62_tree=null;
        CommonTree WS63_tree=null;

        try {
            // src/riemann/Query.g:62:2: ( field ( WS )* GREATER_EQUAL ( WS )* value )
            // src/riemann/Query.g:62:4: field ( WS )* GREATER_EQUAL ( WS )* value
            {
            root_0 = (CommonTree)adaptor.nil();

            pushFollow(FOLLOW_field_in_greater_equal450);
            field60=field();

            state._fsp--;

            adaptor.addChild(root_0, field60.getTree());
            // src/riemann/Query.g:62:10: ( WS )*
            loop23:
            do {
                int alt23=2;
                int LA23_0 = input.LA(1);

                if ( (LA23_0==WS) ) {
                    alt23=1;
                }


                switch (alt23) {
            	case 1 :
            	    // src/riemann/Query.g:62:10: WS
            	    {
            	    WS61=(Token)match(input,WS,FOLLOW_WS_in_greater_equal452); 
            	    WS61_tree = (CommonTree)adaptor.create(WS61);
            	    adaptor.addChild(root_0, WS61_tree);


            	    }
            	    break;

            	default :
            	    break loop23;
                }
            } while (true);

            GREATER_EQUAL62=(Token)match(input,GREATER_EQUAL,FOLLOW_GREATER_EQUAL_in_greater_equal455); 
            GREATER_EQUAL62_tree = (CommonTree)adaptor.create(GREATER_EQUAL62);
            root_0 = (CommonTree)adaptor.becomeRoot(GREATER_EQUAL62_tree, root_0);

            // src/riemann/Query.g:62:29: ( WS )*
            loop24:
            do {
                int alt24=2;
                int LA24_0 = input.LA(1);

                if ( (LA24_0==WS) ) {
                    alt24=1;
                }


                switch (alt24) {
            	case 1 :
            	    // src/riemann/Query.g:62:29: WS
            	    {
            	    WS63=(Token)match(input,WS,FOLLOW_WS_in_greater_equal458); 
            	    WS63_tree = (CommonTree)adaptor.create(WS63);
            	    adaptor.addChild(root_0, WS63_tree);


            	    }
            	    break;

            	default :
            	    break loop24;
                }
            } while (true);

            pushFollow(FOLLOW_value_in_greater_equal461);
            value64=value();

            state._fsp--;

            adaptor.addChild(root_0, value64.getTree());

            }

            retval.stop = input.LT(-1);

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
655532
@SuppressWarnings("unchecked")
	@Override
	public T lessEqual(final String col, final Object value) {
		context().param(CaseFormat.CAMEL_CASE.convert(col), new LessEqual(col, value));
		this.useOperator = true;
		return (T) this;
	}
1264902
function applyLowerBound (comparators) {
  if (comparators[0].operator.charAt(0) === '<') {
    comparators.unshift(new semver.Comparator('>=0.0.0'))
  }
  return comparators
}
1063146
public final String entryRuleOpEquality() throws RecognitionException {
        String current = null;

        AntlrDatatypeRuleToken iv_ruleOpEquality = null;


        try {
            // InternalXbase.g:639:50: (iv_ruleOpEquality= ruleOpEquality EOF )
            // InternalXbase.g:640:2: iv_ruleOpEquality= ruleOpEquality EOF
            {
            if ( state.backtracking==0 ) {
               newCompositeNode(grammarAccess.getOpEqualityRule()); 
            }
            pushFollow(FOLLOW_1);
            iv_ruleOpEquality=ruleOpEquality();

            state._fsp--;
            if (state.failed) return current;
            if ( state.backtracking==0 ) {
               current =iv_ruleOpEquality.getText(); 
            }
            match(input,EOF,FOLLOW_2); if (state.failed) return current;

            }

        }

            catch (RecognitionException re) {
                recover(input,re);
                appendSkippedTokens();
            }
        finally {
        }
        return current;
    }
849307
@Override
    public Object visitEqualityExpression(ExcellentParser.EqualityExpressionContext ctx) {
        Pair<Object, Object> args = Conversions.toSame(visit(ctx.expression(0)), visit(ctx.expression(1)), m_evalContext);
        boolean equal;

        if (args.getLeft() instanceof String) {
            // string equality is case-insensitive
            equal = ((String) args.getLeft()).equalsIgnoreCase((String) args.getRight());
        }
        else if (args.getLeft() instanceof BigDecimal) {
            // compareTo doesn't take scale into account
            equal = ((BigDecimal) args.getLeft()).compareTo((BigDecimal) args.getRight()) == 0;
        }
        else {
            equal = args.getLeft().equals(args.getRight());
        }

        return ctx.EQ() != null ? equal : !equal;
    }
1134898
public final QueryParser.lesser_return lesser() throws RecognitionException {
        QueryParser.lesser_return retval = new QueryParser.lesser_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        Token WS46=null;
        Token LESSER47=null;
        Token WS48=null;
        QueryParser.field_return field45 = null;

        QueryParser.value_return value49 = null;


        CommonTree WS46_tree=null;
        CommonTree LESSER47_tree=null;
        CommonTree WS48_tree=null;

        try {
            // src/riemann/Query.g:57:8: ( field ( WS )* LESSER ( WS )* value )
            // src/riemann/Query.g:57:10: field ( WS )* LESSER ( WS )* value
            {
            root_0 = (CommonTree)adaptor.nil();

            pushFollow(FOLLOW_field_in_lesser394);
            field45=field();

            state._fsp--;

            adaptor.addChild(root_0, field45.getTree());
            // src/riemann/Query.g:57:16: ( WS )*
            loop17:
            do {
                int alt17=2;
                int LA17_0 = input.LA(1);

                if ( (LA17_0==WS) ) {
                    alt17=1;
                }


                switch (alt17) {
            	case 1 :
            	    // src/riemann/Query.g:57:16: WS
            	    {
            	    WS46=(Token)match(input,WS,FOLLOW_WS_in_lesser396); 
            	    WS46_tree = (CommonTree)adaptor.create(WS46);
            	    adaptor.addChild(root_0, WS46_tree);


            	    }
            	    break;

            	default :
            	    break loop17;
                }
            } while (true);

            LESSER47=(Token)match(input,LESSER,FOLLOW_LESSER_in_lesser399); 
            LESSER47_tree = (CommonTree)adaptor.create(LESSER47);
            root_0 = (CommonTree)adaptor.becomeRoot(LESSER47_tree, root_0);

            // src/riemann/Query.g:57:28: ( WS )*
            loop18:
            do {
                int alt18=2;
                int LA18_0 = input.LA(1);

                if ( (LA18_0==WS) ) {
                    alt18=1;
                }


                switch (alt18) {
            	case 1 :
            	    // src/riemann/Query.g:57:28: WS
            	    {
            	    WS48=(Token)match(input,WS,FOLLOW_WS_in_lesser402); 
            	    WS48_tree = (CommonTree)adaptor.create(WS48);
            	    adaptor.addChild(root_0, WS48_tree);


            	    }
            	    break;

            	default :
            	    break loop18;
                }
            } while (true);

            pushFollow(FOLLOW_value_in_lesser405);
            value49=value();

            state._fsp--;

            adaptor.addChild(root_0, value49.getTree());

            }

            retval.stop = input.LT(-1);

            retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
            adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
    	retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);

        }
        finally {
        }
        return retval;
    }
1343773
def p_expression_lesseq(self, p):
        ''
        p[0] = LessEq(p[1], p[3], lineno=p.lineno(1))
        p.set_lineno(0, p.lineno(1))
373430
public final void integerLiteral() throws RecognitionException {
		int integerLiteral_StartIndex = input.index();

		try {
			if ( state.backtracking>0 && alreadyParsedRule(input, 62) ) { return; }

			// src/main/resources/org/drools/compiler/semantics/java/parser/Java.g:596:5: ( HexLiteral | OctalLiteral | DecimalLiteral )
			// src/main/resources/org/drools/compiler/semantics/java/parser/Java.g:
			{
			if ( input.LA(1)==DecimalLiteral||input.LA(1)==HexLiteral||input.LA(1)==OctalLiteral ) {
				input.consume();
				state.errorRecovery=false;
				state.failed=false;
			}
			else {
				if (state.backtracking>0) {state.failed=true; return;}
				MismatchedSetException mse = new MismatchedSetException(null,input);
				throw mse;
			}
			}

		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
		}
		finally {
			// do for sure before leaving
			if ( state.backtracking>0 ) { memoize(input, 62, integerLiteral_StartIndex); }

		}
	}
106185
function getLowerBoundMatcher(compare, query) {
		// No lower bound
		if (!query.hasOwnProperty('$gt') && !query.hasOwnProperty('$gte')) {
			return function(){return true;};
		}
		if (query.hasOwnProperty('$gt') && query.hasOwnProperty('$gte')) {
			if (compare(query.$gte, query.$gt) === 0) {
				return function (key) { return compare(key, query.$gt) > 0; };
			}
			if (compare(query.$gte, query.$gt) > 0) {
				return function (key) { return compare(key, query.$gte) >= 0; };
			} else {
				return function (key) { return compare(key, query.$gt) > 0; };
			}
		}
		if (query.hasOwnProperty('$gt')) {
			return function (key) { return compare(key, query.$gt) > 0; };
		} else {
			return function (key) { return compare(key, query.$gte) >= 0; };
		}
	}
1113918
public final void mLESS() throws RecognitionException {
		try {
			int _type = LESS;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// src/main/resources/org/drools/compiler/lang/DRL5Lexer.g:230:5: ( '<' )
			// src/main/resources/org/drools/compiler/lang/DRL5Lexer.g:230:7: '<'
			{
			match('<'); if (state.failed) return;
			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
696830
public final void shiftOp() throws RecognitionException {
		try {
			// src/main/resources/org/drools/compiler/lang/DRL5Expressions.g:451:5: ( ( LESS LESS | GREATER GREATER GREATER | GREATER GREATER ) )
			// src/main/resources/org/drools/compiler/lang/DRL5Expressions.g:451:7: ( LESS LESS | GREATER GREATER GREATER | GREATER GREATER )
			{
			// src/main/resources/org/drools/compiler/lang/DRL5Expressions.g:451:7: ( LESS LESS | GREATER GREATER GREATER | GREATER GREATER )
			int alt46=3;
			int LA46_0 = input.LA(1);
			if ( (LA46_0==LESS) ) {
				alt46=1;
			}
			else if ( (LA46_0==GREATER) ) {
				int LA46_2 = input.LA(2);
				if ( (LA46_2==GREATER) ) {
					int LA46_3 = input.LA(3);
					if ( (LA46_3==GREATER) ) {
						alt46=2;
					}
					else if ( (LA46_3==EOF||LA46_3==BOOL||(LA46_3 >= DECIMAL && LA46_3 <= DECR)||LA46_3==FLOAT||LA46_3==HEX||(LA46_3 >= ID && LA46_3 <= INCR)||(LA46_3 >= LEFT_PAREN && LA46_3 <= LESS)||LA46_3==MINUS||LA46_3==NEGATION||LA46_3==NULL||LA46_3==PLUS||(LA46_3 >= STAR && LA46_3 <= TIME_INTERVAL)) ) {
						alt46=3;
					}

					else {
						if (state.backtracking>0) {state.failed=true; return;}
						int nvaeMark = input.mark();
						try {
							for (int nvaeConsume = 0; nvaeConsume < 3 - 1; nvaeConsume++) {
								input.consume();
							}
							NoViableAltException nvae =
								new NoViableAltException("", 46, 3, input);
							throw nvae;
						} finally {
							input.rewind(nvaeMark);
						}
					}

				}

				else {
					if (state.backtracking>0) {state.failed=true; return;}
					int nvaeMark = input.mark();
					try {
						input.consume();
						NoViableAltException nvae =
							new NoViableAltException("", 46, 2, input);
						throw nvae;
					} finally {
						input.rewind(nvaeMark);
					}
				}

			}

			else {
				if (state.backtracking>0) {state.failed=true; return;}
				NoViableAltException nvae =
					new NoViableAltException("", 46, 0, input);
				throw nvae;
			}

			switch (alt46) {
				case 1 :
					// src/main/resources/org/drools/compiler/lang/DRL5Expressions.g:451:9: LESS LESS
					{
					match(input,LESS,FOLLOW_LESS_in_shiftOp2100); if (state.failed) return;
					match(input,LESS,FOLLOW_LESS_in_shiftOp2102); if (state.failed) return;
					}
					break;
				case 2 :
					// src/main/resources/org/drools/compiler/lang/DRL5Expressions.g:452:11: GREATER GREATER GREATER
					{
					match(input,GREATER,FOLLOW_GREATER_in_shiftOp2114); if (state.failed) return;
					match(input,GREATER,FOLLOW_GREATER_in_shiftOp2116); if (state.failed) return;
					match(input,GREATER,FOLLOW_GREATER_in_shiftOp2118); if (state.failed) return;
					}
					break;
				case 3 :
					// src/main/resources/org/drools/compiler/lang/DRL5Expressions.g:453:11: GREATER GREATER
					{
					match(input,GREATER,FOLLOW_GREATER_in_shiftOp2130); if (state.failed) return;
					match(input,GREATER,FOLLOW_GREATER_in_shiftOp2132); if (state.failed) return;
					}
					break;

			}

			}

		}

		catch (RecognitionException re) {
		    throw re;
		}

		finally {
			// do for sure before leaving
		}
	}
160285
public ExpressionBuilder lessThan(final SubordinateTrigger trigger, final Object compare) {
		BooleanExpression exp = new CompareExpression(CompareType.LESS_THAN, trigger, compare);
		appendExpression(exp);

		return this;
	}
253744
public final void mEQUALS() throws RecognitionException {
		try {
			int _type = EQUALS;
			int _channel = DEFAULT_TOKEN_CHANNEL;
			// src/main/resources/org/drools/compiler/lang/dsl/DSLMap.g:312:8: ( '=' )
			// src/main/resources/org/drools/compiler/lang/dsl/DSLMap.g:312:10: '='
			{
			match('='); if (state.failed) return;
			}

			state.type = _type;
			state.channel = _channel;
		}
		finally {
			// do for sure before leaving
		}
	}
616428
public ZealotKhala lessEqual(String field, Object value) {
        return this.doNormal(ZealotConst.ONE_SPACE, field, value, ZealotConst.LTE_SUFFIX, true);
    }
1170023
public final void mNOT_EQUAL() throws RecognitionException {
        try {
            int _type = NOT_EQUAL;
            int _channel = DEFAULT_TOKEN_CHANNEL;
            // src/riemann/Query.g:10:11: ( '!=' )
            // src/riemann/Query.g:10:13: '!='
            {
            match("!="); 


            }

            state.type = _type;
            state.channel = _channel;
        }
        finally {
        }
    }