docs: public final EventFilterParser.compariable_value_function_return compariable_value_function() throws RecognitionException {
          EventFilterParser.compariable_value_function_return retval = new EventFilterParser.compariable_value_function_return();
          retval.start = input.LT(1);
  
  
          CommonTree root_0 = null;
  
          Token NUMBER92=null;
          EventFilterParser.time_millis_function_return time_millis_function93 =null;
  
          EventFilterParser.time_string_function_return time_string_function94 =null;
  
  
          CommonTree NUMBER92_tree=null;
          RewriteRuleTokenStream stream_NUMBER=new RewriteRuleTokenStream(adaptor,"token NUMBER");
  
          try {
              // EventFilter.g:181:2: ( NUMBER -> NUMBER | time_millis_function | time_string_function )
              int alt14=3;
              switch ( input.LA(1) ) {
              case NUMBER:
                  {
                  alt14=1;
                  }
                  break;
              case EOF:
              case AND:
              case OR:
              case TIME_MILLIS_FUN_NAME:
              case 34:
              case 35:
                  {
                  alt14=2;
                  }
                  break;
              case TIME_STRING_FUN_NAME:
                  {
                  alt14=3;
                  }
                  break;
              default:
                  NoViableAltException nvae =
                      new NoViableAltException("", 14, 0, input);
  
                  throw nvae;
  
              }
  
              switch (alt14) {
                  case 1 :
                      // EventFilter.g:181:4: NUMBER
                      {
                      NUMBER92=(Token)match(input,NUMBER,FOLLOW_NUMBER_in_compariable_value_function1102);
                      stream_NUMBER.add(NUMBER92);
  
  
                      // AST REWRITE
                      // elements: NUMBER
                      // 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();
                      // 181:11: -> NUMBER
                      {
                          adaptor.addChild(root_0,
                          new NumberTreeNode(stream_NUMBER.nextToken())
                          );
  
                      }
  
  
                      retval.tree = root_0;
  
                      }
                      break;
                  case 2 :
                      // EventFilter.g:182:3: time_millis_function
                      {
                      root_0 = (CommonTree)adaptor.nil();
  
  
                      pushFollow(FOLLOW_time_millis_function_in_compariable_value_function1114);
                      time_millis_function93=time_millis_function();
  
                      state._fsp--;
  
                      adaptor.addChild(root_0, time_millis_function93.getTree());
  
                      }
                      break;
                  case 3 :
                      // EventFilter.g:183:3: time_string_function
                      {
                      root_0 = (CommonTree)adaptor.nil();
  
  
                      pushFollow(FOLLOW_time_string_function_in_compariable_value_function1120);
                      time_string_function94=time_string_function();
  
                      state._fsp--;
  
                      adaptor.addChild(root_0, time_string_function94.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 {
          	// do for sure before leaving
          }
          return retval;
      }