public final AntlrPilarParser.guard_return guard()
      throws RecognitionException {
    AntlrPilarParser.guard_return retval = new AntlrPilarParser.guard_return();
    retval.start = input.LT(1);
    int guard_StartIndex = input.index();
    Object root_0 = null;

    Token t = null;
    Token string_literal231 = null;
    AntlrPilarParser.exp_return exp229 = null;

    AntlrPilarParser.annotationList_return annotationList230 = null;

    AntlrPilarParser.annotationList_return annotationList232 = null;

    Object t_tree = null;
    Object string_literal231_tree = null;
    RewriteRuleTokenStream stream_195 = new RewriteRuleTokenStream(adaptor,
        "token 195");
    RewriteRuleTokenStream stream_196 = new RewriteRuleTokenStream(adaptor,
        "token 196");
    RewriteRuleSubtreeStream stream_exp = new RewriteRuleSubtreeStream(adaptor,
        "rule exp");
    RewriteRuleSubtreeStream stream_annotationList = new RewriteRuleSubtreeStream(
        adaptor, "rule annotationList");
    try {
      if (state.backtracking > 0 && alreadyParsedRule(input, 60)) {
        return retval;
      }
      // /Users/robby/Repositories/sireum-parser/sireum-parser/src/main/java/org/sireum/pilar/parser/AntlrPilar.g:475:2: ( exp annotationList '+>' -> ^( EXP_GUARD exp annotationList ) | t= 'else' annotationList -> ^( ELSE_GUARD[$t] annotationList ) )
      int alt75 = 2;
      int LA75_0 = input.LA(1);

      if (((LA75_0 >= HEX_LIT && LA75_0 <= OCT_LIT) || LA75_0 == ID
          || LA75_0 == GLOBALID || (LA75_0 >= ADD_OP && LA75_0 <= RATIONAL_LIT)
          || LA75_0 == 169 || LA75_0 == 177 || LA75_0 == 204 || LA75_0 == 208
          || LA75_0 == 215 || (LA75_0 >= 217 && LA75_0 <= 221) || LA75_0 == 223)) {
        alt75 = 1;
      } else if ((LA75_0 == 196)) {
        alt75 = 2;
      } else {
        if (state.backtracking > 0) {
          state.failed = true;
          return retval;
        }
        NoViableAltException nvae = new NoViableAltException("", 75, 0, input);

        throw nvae;
      }
      switch (alt75) {
        case 1:
        // /Users/robby/Repositories/sireum-parser/sireum-parser/src/main/java/org/sireum/pilar/parser/AntlrPilar.g:475:4: exp annotationList '+>'
        {
          pushFollow(FOLLOW_exp_in_guard4288);
          exp229 = exp();

          state._fsp--;
          if (state.failed) return retval;
          if (state.backtracking == 0) stream_exp.add(exp229.getTree());
          pushFollow(FOLLOW_annotationList_in_guard4290);
          annotationList230 = annotationList();

          state._fsp--;
          if (state.failed) return retval;
          if (state.backtracking == 0)
            stream_annotationList.add(annotationList230.getTree());
          string_literal231 = (Token) match(input, 195, FOLLOW_195_in_guard4292);
          if (state.failed) return retval;
          if (state.backtracking == 0) stream_195.add(string_literal231);

          // AST REWRITE
          // elements: exp, annotationList
          // token labels: 
          // rule labels: retval
          // token list labels: 
          // rule list labels: 
          // wildcard labels: 
          if (state.backtracking == 0) {
            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(
                adaptor, "rule retval", retval != null ? retval.tree : null);

            root_0 = (Object) adaptor.nil();
            // 475:41: -> ^( EXP_GUARD exp annotationList )
            {
              // /Users/robby/Repositories/sireum-parser/sireum-parser/src/main/java/org/sireum/pilar/parser/AntlrPilar.g:475:44: ^( EXP_GUARD exp annotationList )
              {
                Object root_1 = (Object) adaptor.nil();
                root_1 = (Object) adaptor.becomeRoot(
                    (Object) adaptor.create(EXP_GUARD, "EXP_GUARD"),
                    root_1);

                adaptor.addChild(root_1, stream_exp.nextTree());
                adaptor.addChild(root_1, stream_annotationList.nextTree());

                adaptor.addChild(root_0, root_1);
              }

            }

            retval.tree = root_0;
          }
        }
          break;
        case 2:
        // /Users/robby/Repositories/sireum-parser/sireum-parser/src/main/java/org/sireum/pilar/parser/AntlrPilar.g:476:4: t= 'else' annotationList
        {
          t = (Token) match(input, 196, FOLLOW_196_in_guard4322);
          if (state.failed) return retval;
          if (state.backtracking == 0) stream_196.add(t);

          pushFollow(FOLLOW_annotationList_in_guard4324);
          annotationList232 = annotationList();

          state._fsp--;
          if (state.failed) return retval;
          if (state.backtracking == 0)
            stream_annotationList.add(annotationList232.getTree());

          // AST REWRITE
          // elements: annotationList
          // token labels: 
          // rule labels: retval
          // token list labels: 
          // rule list labels: 
          // wildcard labels: 
          if (state.backtracking == 0) {
            retval.tree = root_0;
            RewriteRuleSubtreeStream stream_retval = new RewriteRuleSubtreeStream(
                adaptor, "rule retval", retval != null ? retval.tree : null);

            root_0 = (Object) adaptor.nil();
            // 476:41: -> ^( ELSE_GUARD[$t] annotationList )
            {
              // /Users/robby/Repositories/sireum-parser/sireum-parser/src/main/java/org/sireum/pilar/parser/AntlrPilar.g:476:44: ^( ELSE_GUARD[$t] annotationList )
              {
                Object root_1 = (Object) adaptor.nil();
                root_1 = (Object) adaptor.becomeRoot(
                    (Object) adaptor.create(ELSE_GUARD, t),
                    root_1);

                adaptor.addChild(root_1, stream_annotationList.nextTree());

                adaptor.addChild(root_0, root_1);
              }

            }

            retval.tree = root_0;
          }
        }
          break;

      }
      retval.stop = input.LT(-1);

      if (state.backtracking == 0) {

        retval.tree = (Object) adaptor.rulePostProcessing(root_0);
        adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
      }
    } catch (RecognitionException re) {
      reportError(re);
      recover(input, re);
      retval.tree = (Object) adaptor.errorNode(
          input,
          retval.start,
          input.LT(-1),
          re);

    } finally {
      if (state.backtracking > 0) {
        memoize(input, 60, guard_StartIndex);
      }
    }
    return retval;
  }