docs: public final EventFilterParser.between_predicate_return between_predicate() throws RecognitionException {
          EventFilterParser.between_predicate_return retval = new EventFilterParser.between_predicate_return();
          retval.start = input.LT(1);
  
  
          CommonTree root_0 = null;
  
          Token BETWEEN37=null;
          Token char_literal38=null;
          Token NUMBER39=null;
          Token char_literal40=null;
          Token NUMBER41=null;
          Token char_literal42=null;
          Token BETWEEN44=null;
          Token char_literal45=null;
          Token char_literal47=null;
          Token char_literal49=null;
          Token BETWEEN51=null;
          Token char_literal52=null;
          Token char_literal54=null;
          Token char_literal56=null;
          EventFilterParser.path_function_return path_function36 =null;
  
          EventFilterParser.path_function_return path_function43 =null;
  
          EventFilterParser.time_millis_function_return time_millis_function46 =null;
  
          EventFilterParser.time_millis_function_return time_millis_function48 =null;
  
          EventFilterParser.path_function_return path_function50 =null;
  
          EventFilterParser.time_string_function_return time_string_function53 =null;
  
          EventFilterParser.time_string_function_return time_string_function55 =null;
  
  
          CommonTree BETWEEN37_tree=null;
          CommonTree char_literal38_tree=null;
          CommonTree NUMBER39_tree=null;
          CommonTree char_literal40_tree=null;
          CommonTree NUMBER41_tree=null;
          CommonTree char_literal42_tree=null;
          CommonTree BETWEEN44_tree=null;
          CommonTree char_literal45_tree=null;
          CommonTree char_literal47_tree=null;
          CommonTree char_literal49_tree=null;
          CommonTree BETWEEN51_tree=null;
          CommonTree char_literal52_tree=null;
          CommonTree char_literal54_tree=null;
          CommonTree char_literal56_tree=null;
          RewriteRuleTokenStream stream_35=new RewriteRuleTokenStream(adaptor,"token 35");
          RewriteRuleTokenStream stream_33=new RewriteRuleTokenStream(adaptor,"token 33");
          RewriteRuleTokenStream stream_BETWEEN=new RewriteRuleTokenStream(adaptor,"token BETWEEN");
          RewriteRuleTokenStream stream_34=new RewriteRuleTokenStream(adaptor,"token 34");
          RewriteRuleTokenStream stream_NUMBER=new RewriteRuleTokenStream(adaptor,"token NUMBER");
          RewriteRuleSubtreeStream stream_time_string_function=new RewriteRuleSubtreeStream(adaptor,"rule time_string_function");
          RewriteRuleSubtreeStream stream_time_millis_function=new RewriteRuleSubtreeStream(adaptor,"rule time_millis_function");
          RewriteRuleSubtreeStream stream_path_function=new RewriteRuleSubtreeStream(adaptor,"rule path_function");
          try {
              // EventFilter.g:138:2: ( path_function BETWEEN '(' NUMBER ',' NUMBER ')' -> ^( BETWEEN path_function NUMBER NUMBER ) | path_function BETWEEN '(' time_millis_function ',' time_millis_function ')' -> ^( BETWEEN path_function time_millis_function time_millis_function ) | path_function BETWEEN '(' time_string_function ',' time_string_function ')' -> ^( BETWEEN path_function time_string_function time_string_function ) )
              int alt7=3;
              int LA7_0 = input.LA(1);
  
              if ( (LA7_0==XPATH_FUN_NAME) ) {
                  int LA7_1 = input.LA(2);
  
                  if ( (LA7_1==33) ) {
                      int LA7_2 = input.LA(3);
  
                      if ( (LA7_2==STRING) ) {
                          int LA7_3 = input.LA(4);
  
                          if ( (LA7_3==34) ) {
                              int LA7_4 = input.LA(5);
  
                              if ( (LA7_4==BETWEEN) ) {
                                  int LA7_5 = input.LA(6);
  
                                  if ( (LA7_5==33) ) {
                                      switch ( input.LA(7) ) {
                                      case NUMBER:
                                          {
                                          alt7=1;
                                          }
                                          break;
                                      case TIME_MILLIS_FUN_NAME:
                                      case 35:
                                          {
                                          alt7=2;
                                          }
                                          break;
                                      case TIME_STRING_FUN_NAME:
                                          {
                                          alt7=3;
                                          }
                                          break;
                                      default:
                                          NoViableAltException nvae =
                                              new NoViableAltException("", 7, 6, input);
  
                                          throw nvae;
  
                                      }
  
                                  }
                                  else {
                                      NoViableAltException nvae =
                                          new NoViableAltException("", 7, 5, input);
  
                                      throw nvae;
  
                                  }
                              }
                              else {
                                  NoViableAltException nvae =
                                      new NoViableAltException("", 7, 4, input);
  
                                  throw nvae;
  
                              }
                          }
                          else {
                              NoViableAltException nvae =
                                  new NoViableAltException("", 7, 3, input);
  
                              throw nvae;
  
                          }
                      }
                      else {
                          NoViableAltException nvae =
                              new NoViableAltException("", 7, 2, input);
  
                          throw nvae;
  
                      }
                  }
                  else {
                      NoViableAltException nvae =
                          new NoViableAltException("", 7, 1, input);
  
                      throw nvae;
  
                  }
              }
              else {
                  NoViableAltException nvae =
                      new NoViableAltException("", 7, 0, input);
  
                  throw nvae;
  
              }
              switch (alt7) {
                  case 1 :
                      // EventFilter.g:138:4: path_function BETWEEN '(' NUMBER ',' NUMBER ')'
                      {
                      pushFollow(FOLLOW_path_function_in_between_predicate673);
                      path_function36=path_function();
  
                      state._fsp--;
  
                      stream_path_function.add(path_function36.getTree());
  
                      BETWEEN37=(Token)match(input,BETWEEN,FOLLOW_BETWEEN_in_between_predicate675);
                      stream_BETWEEN.add(BETWEEN37);
  
  
                      char_literal38=(Token)match(input,33,FOLLOW_33_in_between_predicate677);
                      stream_33.add(char_literal38);
  
  
                      NUMBER39=(Token)match(input,NUMBER,FOLLOW_NUMBER_in_between_predicate679);
                      stream_NUMBER.add(NUMBER39);
  
  
                      char_literal40=(Token)match(input,35,FOLLOW_35_in_between_predicate681);
                      stream_35.add(char_literal40);
  
  
                      NUMBER41=(Token)match(input,NUMBER,FOLLOW_NUMBER_in_between_predicate683);
                      stream_NUMBER.add(NUMBER41);
  
  
                      char_literal42=(Token)match(input,34,FOLLOW_34_in_between_predicate685);
                      stream_34.add(char_literal42);
  
  
                      // AST REWRITE
                      // elements: NUMBER, path_function, NUMBER, BETWEEN
                      // token labels:
                      // rule labels: retval
                      // token list labels:
                      // rule list labels:
                      // wildcard labels:
                      retval.tree = root_0;
                      RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
  
                      root_0 = (CommonTree)adaptor.nil();
                      // 139:4: -> ^( BETWEEN path_function NUMBER NUMBER )
                      {
                          // EventFilter.g:139:7: ^( BETWEEN path_function NUMBER NUMBER )
                          {
                          CommonTree root_1 = (CommonTree)adaptor.nil();
                          root_1 = (CommonTree)adaptor.becomeRoot(
                          new BetweenTreeNode(stream_BETWEEN.nextToken())
                          , root_1);
  
                          adaptor.addChild(root_1, stream_path_function.nextTree());
  
                          adaptor.addChild(root_1,
                          new NumberTreeNode(stream_NUMBER.nextToken())
                          );
  
                          adaptor.addChild(root_1,
                          new NumberTreeNode(stream_NUMBER.nextToken())
                          );
  
                          adaptor.addChild(root_0, root_1);
                          }
  
                      }
  
  
                      retval.tree = root_0;
  
                      }
                      break;
                  case 2 :
                      // EventFilter.g:140:3: path_function BETWEEN '(' time_millis_function ',' time_millis_function ')'
                      {
                      pushFollow(FOLLOW_path_function_in_between_predicate716);
                      path_function43=path_function();
  
                      state._fsp--;
  
                      stream_path_function.add(path_function43.getTree());
  
                      BETWEEN44=(Token)match(input,BETWEEN,FOLLOW_BETWEEN_in_between_predicate718);
                      stream_BETWEEN.add(BETWEEN44);
  
  
                      char_literal45=(Token)match(input,33,FOLLOW_33_in_between_predicate720);
                      stream_33.add(char_literal45);
  
  
                      pushFollow(FOLLOW_time_millis_function_in_between_predicate722);
                      time_millis_function46=time_millis_function();
  
                      state._fsp--;
  
                      stream_time_millis_function.add(time_millis_function46.getTree());
  
                      char_literal47=(Token)match(input,35,FOLLOW_35_in_between_predicate724);
                      stream_35.add(char_literal47);
  
  
                      pushFollow(FOLLOW_time_millis_function_in_between_predicate726);
                      time_millis_function48=time_millis_function();
  
                      state._fsp--;
  
                      stream_time_millis_function.add(time_millis_function48.getTree());
  
                      char_literal49=(Token)match(input,34,FOLLOW_34_in_between_predicate728);
                      stream_34.add(char_literal49);
  
  
                      // AST REWRITE
                      // elements: time_millis_function, BETWEEN, time_millis_function, path_function
                      // token labels:
                      // rule labels: retval
                      // token list labels:
                      // rule list labels:
                      // wildcard labels:
                      retval.tree = root_0;
                      RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
  
                      root_0 = (CommonTree)adaptor.nil();
                      // 141:4: -> ^( BETWEEN path_function time_millis_function time_millis_function )
                      {
                          // EventFilter.g:141:7: ^( BETWEEN path_function time_millis_function time_millis_function )
                          {
                          CommonTree root_1 = (CommonTree)adaptor.nil();
                          root_1 = (CommonTree)adaptor.becomeRoot(
                          new BetweenTimeMillisTreeNode(stream_BETWEEN.nextToken())
                          , root_1);
  
                          adaptor.addChild(root_1, stream_path_function.nextTree());
  
                          adaptor.addChild(root_1, stream_time_millis_function.nextTree());
  
                          adaptor.addChild(root_1, stream_time_millis_function.nextTree());
  
                          adaptor.addChild(root_0, root_1);
                          }
  
                      }
  
  
                      retval.tree = root_0;
  
                      }
                      break;
                  case 3 :
                      // EventFilter.g:142:3: path_function BETWEEN '(' time_string_function ',' time_string_function ')'
                      {
                      pushFollow(FOLLOW_path_function_in_between_predicate753);
                      path_function50=path_function();
  
                      state._fsp--;
  
                      stream_path_function.add(path_function50.getTree());
  
                      BETWEEN51=(Token)match(input,BETWEEN,FOLLOW_BETWEEN_in_between_predicate755);
                      stream_BETWEEN.add(BETWEEN51);
  
  
                      char_literal52=(Token)match(input,33,FOLLOW_33_in_between_predicate757);
                      stream_33.add(char_literal52);
  
  
                      pushFollow(FOLLOW_time_string_function_in_between_predicate759);
                      time_string_function53=time_string_function();
  
                      state._fsp--;
  
                      stream_time_string_function.add(time_string_function53.getTree());
  
                      char_literal54=(Token)match(input,35,FOLLOW_35_in_between_predicate761);
                      stream_35.add(char_literal54);
  
  
                      pushFollow(FOLLOW_time_string_function_in_between_predicate763);
                      time_string_function55=time_string_function();
  
                      state._fsp--;
  
                      stream_time_string_function.add(time_string_function55.getTree());
  
                      char_literal56=(Token)match(input,34,FOLLOW_34_in_between_predicate765);
                      stream_34.add(char_literal56);
  
  
                      // AST REWRITE
                      // elements: time_string_function, path_function, BETWEEN, time_string_function
                      // token labels:
                      // rule labels: retval
                      // token list labels:
                      // rule list labels:
                      // wildcard labels:
                      retval.tree = root_0;
                      RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
  
                      root_0 = (CommonTree)adaptor.nil();
                      // 143:4: -> ^( BETWEEN path_function time_string_function time_string_function )
                      {
                          // EventFilter.g:143:7: ^( BETWEEN path_function time_string_function time_string_function )
                          {
                          CommonTree root_1 = (CommonTree)adaptor.nil();
                          root_1 = (CommonTree)adaptor.becomeRoot(
                          new BetweenTimeStringTreeNode(stream_BETWEEN.nextToken())
                          , root_1);
  
                          adaptor.addChild(root_1, stream_path_function.nextTree());
  
                          adaptor.addChild(root_1, stream_time_string_function.nextTree());
  
                          adaptor.addChild(root_1, stream_time_string_function.nextTree());
  
                          adaptor.addChild(root_0, root_1);
                          }
  
                      }
  
  
                      retval.tree = root_0;
  
                      }
                      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 {
          	// do for sure before leaving
          }
          return retval;
      }