docs: public final QueryParser.simple_return simple() throws RecognitionException {
          QueryParser.simple_return retval = new QueryParser.simple_return();
          retval.start = input.LT(1);
  
          CommonTree root_0 = null;
  
          QueryParser.t_return t23 = null;
  
          QueryParser.f_return f24 = null;
  
          QueryParser.nil_return nil25 = null;
  
          QueryParser.tagged_return tagged26 = null;
  
          QueryParser.approximately_return approximately27 = null;
  
          QueryParser.regex_match_return regex_match28 = null;
  
          QueryParser.lesser_return lesser29 = null;
  
          QueryParser.lesser_equal_return lesser_equal30 = null;
  
          QueryParser.greater_return greater31 = null;
  
          QueryParser.greater_equal_return greater_equal32 = null;
  
          QueryParser.not_equal_return not_equal33 = null;
  
          QueryParser.equal_return equal34 = null;
  
  
  
          try {
              // src/riemann/Query.g:41:8: ( ( t | f | nil | tagged | approximately | regex_match | lesser | lesser_equal | greater | greater_equal | not_equal | equal ) )
              // src/riemann/Query.g:41:10: ( t | f | nil | tagged | approximately | regex_match | lesser | lesser_equal | greater | greater_equal | not_equal | equal )
              {
              root_0 = (CommonTree)adaptor.nil();
  
              // src/riemann/Query.g:41:10: ( t | f | nil | tagged | approximately | regex_match | lesser | lesser_equal | greater | greater_equal | not_equal | equal )
              int alt12=12;
              alt12 = dfa12.predict(input);
              switch (alt12) {
                  case 1 :
                      // src/riemann/Query.g:41:12: t
                      {
                      pushFollow(FOLLOW_t_in_simple282);
                      t23=t();
  
                      state._fsp--;
  
                      adaptor.addChild(root_0, t23.getTree());
  
                      }
                      break;
                  case 2 :
                      // src/riemann/Query.g:41:16: f
                      {
                      pushFollow(FOLLOW_f_in_simple286);
                      f24=f();
  
                      state._fsp--;
  
                      adaptor.addChild(root_0, f24.getTree());
  
                      }
                      break;
                  case 3 :
                      // src/riemann/Query.g:41:20: nil
                      {
                      pushFollow(FOLLOW_nil_in_simple290);
                      nil25=nil();
  
                      state._fsp--;
  
                      adaptor.addChild(root_0, nil25.getTree());
  
                      }
                      break;
                  case 4 :
                      // src/riemann/Query.g:42:5: tagged
                      {
                      pushFollow(FOLLOW_tagged_in_simple296);
                      tagged26=tagged();
  
                      state._fsp--;
  
                      adaptor.addChild(root_0, tagged26.getTree());
  
                      }
                      break;
                  case 5 :
                      // src/riemann/Query.g:43:5: approximately
                      {
                      pushFollow(FOLLOW_approximately_in_simple302);
                      approximately27=approximately();
  
                      state._fsp--;
  
                      adaptor.addChild(root_0, approximately27.getTree());
  
                      }
                      break;
                  case 6 :
                      // src/riemann/Query.g:44:5: regex_match
                      {
                      pushFollow(FOLLOW_regex_match_in_simple308);
                      regex_match28=regex_match();
  
                      state._fsp--;
  
                      adaptor.addChild(root_0, regex_match28.getTree());
  
                      }
                      break;
                  case 7 :
                      // src/riemann/Query.g:45:5: lesser
                      {
                      pushFollow(FOLLOW_lesser_in_simple314);
                      lesser29=lesser();
  
                      state._fsp--;
  
                      adaptor.addChild(root_0, lesser29.getTree());
  
                      }
                      break;
                  case 8 :
                      // src/riemann/Query.g:46:5: lesser_equal
                      {
                      pushFollow(FOLLOW_lesser_equal_in_simple320);
                      lesser_equal30=lesser_equal();
  
                      state._fsp--;
  
                      adaptor.addChild(root_0, lesser_equal30.getTree());
  
                      }
                      break;
                  case 9 :
                      // src/riemann/Query.g:47:5: greater
                      {
                      pushFollow(FOLLOW_greater_in_simple326);
                      greater31=greater();
  
                      state._fsp--;
  
                      adaptor.addChild(root_0, greater31.getTree());
  
                      }
                      break;
                  case 10 :
                      // src/riemann/Query.g:48:5: greater_equal
                      {
                      pushFollow(FOLLOW_greater_equal_in_simple332);
                      greater_equal32=greater_equal();
  
                      state._fsp--;
  
                      adaptor.addChild(root_0, greater_equal32.getTree());
  
                      }
                      break;
                  case 11 :
                      // src/riemann/Query.g:49:5: not_equal
                      {
                      pushFollow(FOLLOW_not_equal_in_simple338);
                      not_equal33=not_equal();
  
                      state._fsp--;
  
                      adaptor.addChild(root_0, not_equal33.getTree());
  
                      }
                      break;
                  case 12 :
                      // src/riemann/Query.g:50:5: equal
                      {
                      pushFollow(FOLLOW_equal_in_simple344);
                      equal34=equal();
  
                      state._fsp--;
  
                      adaptor.addChild(root_0, equal34.getTree());
  
                      }
                      break;
  
              }
  
  
              }
  
              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;
      }