docs: public final QueryParser.and_return and() throws RecognitionException {
          QueryParser.and_return retval = new QueryParser.and_return();
          retval.start = input.LT(1);
  
          CommonTree root_0 = null;
  
          Token WS10=null;
          Token AND11=null;
          Token WS12=null;
          QueryParser.not_return not8 = null;
  
          QueryParser.primary_return primary9 = null;
  
          QueryParser.not_return not13 = null;
  
          QueryParser.primary_return primary14 = null;
  
  
          CommonTree WS10_tree=null;
          CommonTree AND11_tree=null;
          CommonTree WS12_tree=null;
  
          try {
              // src/riemann/Query.g:30:5: ( ( not | primary ) ( ( WS )* AND ( WS )* ( not | primary ) )* )
              // src/riemann/Query.g:30:7: ( not | primary ) ( ( WS )* AND ( WS )* ( not | primary ) )*
              {
              root_0 = (CommonTree)adaptor.nil();
  
              // src/riemann/Query.g:30:7: ( not | primary )
              int alt4=2;
              int LA4_0 = input.LA(1);
  
              if ( (LA4_0==NOT) ) {
                  alt4=1;
              }
              else if ( (LA4_0==TAGGED||LA4_0==25||(LA4_0>=27 && LA4_0<=38)) ) {
                  alt4=2;
              }
              else {
                  NoViableAltException nvae =
                      new NoViableAltException("", 4, 0, input);
  
                  throw nvae;
              }
              switch (alt4) {
                  case 1 :
                      // src/riemann/Query.g:30:8: not
                      {
                      pushFollow(FOLLOW_not_in_and183);
                      not8=not();
  
                      state._fsp--;
  
                      adaptor.addChild(root_0, not8.getTree());
  
                      }
                      break;
                  case 2 :
                      // src/riemann/Query.g:30:14: primary
                      {
                      pushFollow(FOLLOW_primary_in_and187);
                      primary9=primary();
  
                      state._fsp--;
  
                      adaptor.addChild(root_0, primary9.getTree());
  
                      }
                      break;
  
              }
  
              // src/riemann/Query.g:30:23: ( ( WS )* AND ( WS )* ( not | primary ) )*
              loop8:
              do {
                  int alt8=2;
                  alt8 = dfa8.predict(input);
                  switch (alt8) {
              	case 1 :
              	    // src/riemann/Query.g:30:24: ( WS )* AND ( WS )* ( not | primary )
              	    {
              	    // src/riemann/Query.g:30:24: ( WS )*
              	    loop5:
              	    do {
              	        int alt5=2;
              	        int LA5_0 = input.LA(1);
  
              	        if ( (LA5_0==WS) ) {
              	            alt5=1;
              	        }
  
  
              	        switch (alt5) {
              	    	case 1 :
              	    	    // src/riemann/Query.g:30:24: WS
              	    	    {
              	    	    WS10=(Token)match(input,WS,FOLLOW_WS_in_and191); 
              	    	    WS10_tree = (CommonTree)adaptor.create(WS10);
              	    	    adaptor.addChild(root_0, WS10_tree);
  
  
              	    	    }
              	    	    break;
  
              	    	default :
              	    	    break loop5;
              	        }
              	    } while (true);
  
              	    AND11=(Token)match(input,AND,FOLLOW_AND_in_and194); 
              	    AND11_tree = (CommonTree)adaptor.create(AND11);
              	    root_0 = (CommonTree)adaptor.becomeRoot(AND11_tree, root_0);
  
              	    // src/riemann/Query.g:30:33: ( WS )*
              	    loop6:
              	    do {
              	        int alt6=2;
              	        int LA6_0 = input.LA(1);
  
              	        if ( (LA6_0==WS) ) {
              	            alt6=1;
              	        }
  
  
              	        switch (alt6) {
              	    	case 1 :
              	    	    // src/riemann/Query.g:30:33: WS
              	    	    {
              	    	    WS12=(Token)match(input,WS,FOLLOW_WS_in_and197); 
              	    	    WS12_tree = (CommonTree)adaptor.create(WS12);
              	    	    adaptor.addChild(root_0, WS12_tree);
  
  
              	    	    }
              	    	    break;
  
              	    	default :
              	    	    break loop6;
              	        }
              	    } while (true);
  
              	    // src/riemann/Query.g:30:37: ( not | primary )
              	    int alt7=2;
              	    int LA7_0 = input.LA(1);
  
              	    if ( (LA7_0==NOT) ) {
              	        alt7=1;
              	    }
              	    else if ( (LA7_0==TAGGED||LA7_0==25||(LA7_0>=27 && LA7_0<=38)) ) {
              	        alt7=2;
              	    }
              	    else {
              	        NoViableAltException nvae =
              	            new NoViableAltException("", 7, 0, input);
  
              	        throw nvae;
              	    }
              	    switch (alt7) {
              	        case 1 :
              	            // src/riemann/Query.g:30:38: not
              	            {
              	            pushFollow(FOLLOW_not_in_and201);
              	            not13=not();
  
              	            state._fsp--;
  
              	            adaptor.addChild(root_0, not13.getTree());
  
              	            }
              	            break;
              	        case 2 :
              	            // src/riemann/Query.g:30:44: primary
              	            {
              	            pushFollow(FOLLOW_primary_in_and205);
              	            primary14=primary();
  
              	            state._fsp--;
  
              	            adaptor.addChild(root_0, primary14.getTree());
  
              	            }
              	            break;
  
              	    }
  
  
              	    }
              	    break;
  
              	default :
              	    break loop8;
                  }
              } while (true);
  
  
              }
  
              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;
      }