docs: 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;
      }