docs: public final QueryParser.or_return or() throws RecognitionException {
          QueryParser.or_return retval = new QueryParser.or_return();
          retval.start = input.LT(1);
  
          CommonTree root_0 = null;
  
          Token WS4=null;
          Token OR5=null;
          Token WS6=null;
          QueryParser.and_return and3 = null;
  
          QueryParser.and_return and7 = null;
  
  
          CommonTree WS4_tree=null;
          CommonTree OR5_tree=null;
          CommonTree WS6_tree=null;
  
          try {
              // src/riemann/Query.g:28:4: ( and ( ( WS )* OR ( WS )* and )* )
              // src/riemann/Query.g:28:6: and ( ( WS )* OR ( WS )* and )*
              {
              root_0 = (CommonTree)adaptor.nil();
  
              pushFollow(FOLLOW_and_in_or160);
              and3=and();
  
              state._fsp--;
  
              adaptor.addChild(root_0, and3.getTree());
              // src/riemann/Query.g:28:10: ( ( WS )* OR ( WS )* and )*
              loop3:
              do {
                  int alt3=2;
                  int LA3_0 = input.LA(1);
  
                  if ( (LA3_0==OR||LA3_0==WS) ) {
                      alt3=1;
                  }
  
  
                  switch (alt3) {
              	case 1 :
              	    // src/riemann/Query.g:28:11: ( WS )* OR ( WS )* and
              	    {
              	    // src/riemann/Query.g:28:11: ( WS )*
              	    loop1:
              	    do {
              	        int alt1=2;
              	        int LA1_0 = input.LA(1);
  
              	        if ( (LA1_0==WS) ) {
              	            alt1=1;
              	        }
  
  
              	        switch (alt1) {
              	    	case 1 :
              	    	    // src/riemann/Query.g:28:11: WS
              	    	    {
              	    	    WS4=(Token)match(input,WS,FOLLOW_WS_in_or163); 
              	    	    WS4_tree = (CommonTree)adaptor.create(WS4);
              	    	    adaptor.addChild(root_0, WS4_tree);
  
  
              	    	    }
              	    	    break;
  
              	    	default :
              	    	    break loop1;
              	        }
              	    } while (true);
  
              	    OR5=(Token)match(input,OR,FOLLOW_OR_in_or166); 
              	    OR5_tree = (CommonTree)adaptor.create(OR5);
              	    root_0 = (CommonTree)adaptor.becomeRoot(OR5_tree, root_0);
  
              	    // src/riemann/Query.g:28:19: ( WS )*
              	    loop2:
              	    do {
              	        int alt2=2;
              	        int LA2_0 = input.LA(1);
  
              	        if ( (LA2_0==WS) ) {
              	            alt2=1;
              	        }
  
  
              	        switch (alt2) {
              	    	case 1 :
              	    	    // src/riemann/Query.g:28:19: WS
              	    	    {
              	    	    WS6=(Token)match(input,WS,FOLLOW_WS_in_or169); 
              	    	    WS6_tree = (CommonTree)adaptor.create(WS6);
              	    	    adaptor.addChild(root_0, WS6_tree);
  
  
              	    	    }
              	    	    break;
  
              	    	default :
              	    	    break loop2;
              	        }
              	    } while (true);
  
              	    pushFollow(FOLLOW_and_in_or172);
              	    and7=and();
  
              	    state._fsp--;
  
              	    adaptor.addChild(root_0, and7.getTree());
  
              	    }
              	    break;
  
              	default :
              	    break loop3;
                  }
              } 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;
      }