public final AntlrPilarParser.location_return location()
      throws RecognitionException {
    AntlrPilarParser.location_return retval = new AntlrPilarParser.location_return();
    retval.start = input.LT(1);
    int location_StartIndex = input.index();
    Object root_0 = null;

    Token t = null;
    Token char_literal224 = null;
    AntlrPilarParser.angleGroupedAnnotationList_return angleGroupedAnnotationList222 = null;

    AntlrPilarParser.transformation_return transformation223 = null;

    AntlrPilarParser.transformation_return transformation225 = null;

    Object t_tree = null;
    Object char_literal224_tree = null;
    RewriteRuleTokenStream stream_194 = new RewriteRuleTokenStream(adaptor,
        "token 194");
    RewriteRuleTokenStream stream_LOCID = new RewriteRuleTokenStream(adaptor,
        "token LOCID");
    RewriteRuleSubtreeStream stream_transformation = new RewriteRuleSubtreeStream(
        adaptor, "rule transformation");
    RewriteRuleSubtreeStream stream_angleGroupedAnnotationList = new RewriteRuleSubtreeStream(
        adaptor, "rule angleGroupedAnnotationList");
    try {
      if (state.backtracking > 0 && alreadyParsedRule(input, 58)) {
        return retval;
      }
      // /Users/robby/Repositories/sireum-parser/sireum-parser/src/main/java/org/sireum/pilar/parser/AntlrPilar.g:463:2: (t= LOCID angleGroupedAnnotationList ( transformation ( '|' transformation )* )? -> ^( LOCATION[$t] LOCID angleGroupedAnnotationList ^( LIST ( transformation )* ) ) )
      // /Users/robby/Repositories/sireum-parser/sireum-parser/src/main/java/org/sireum/pilar/parser/AntlrPilar.g:463:4: t= LOCID angleGroupedAnnotationList ( transformation ( '|' transformation )* )?
      {
        t = (Token) match(input, LOCID, FOLLOW_LOCID_in_location4124);
        if (state.failed) return retval;
        if (state.backtracking == 0) stream_LOCID.add(t);

        pushFollow(FOLLOW_angleGroupedAnnotationList_in_location4126);
        angleGroupedAnnotationList222 = angleGroupedAnnotationList();

        state._fsp--;
        if (state.failed) return retval;
        if (state.backtracking == 0)
          stream_angleGroupedAnnotationList.add(angleGroupedAnnotationList222
              .getTree());
        // /Users/robby/Repositories/sireum-parser/sireum-parser/src/main/java/org/sireum/pilar/parser/AntlrPilar.g:464:4: ( transformation ( '|' transformation )* )?
        int alt73 = 2;
        switch (input.LA(1)) {
          case HEX_LIT:
          case DEC_LIT:
          case OCT_LIT:
          case ID:
          case GLOBALID:
          case ADD_OP:
          case MUL_OP:
          case UN_OP:
          case CHAR_LIT:
          case STRING_LIT:
          case SYMBOL_LIT:
          case RAW_LIT:
          case BIN_LIT:
          case FLOAT_LIT:
          case RATIONAL_LIT:
          case 169:
          case 177:
          case 194:
          case 196:
          case 197:
          case 198:
          case 199:
          case 201:
          case 204:
          case 205:
          case 206:
          case 207:
          case 208:
          case 215:
          case 217:
          case 218:
          case 219:
          case 220:
          case 221:
          case 223: {
            alt73 = 1;
          }
            break;
          case EOF: {
            int LA73_2 = input.LA(2);

            if ((synpred85_AntlrPilar())) {
              alt73 = 1;
            }
          }
            break;
          case 211: {
            int LA73_3 = input.LA(2);

            if ((synpred85_AntlrPilar())) {
              alt73 = 1;
            }
          }
            break;
          case 178: {
            int LA73_4 = input.LA(2);

            if ((synpred85_AntlrPilar())) {
              alt73 = 1;
            }
          }
            break;
          case LOCID: {
            int LA73_5 = input.LA(2);

            if ((synpred85_AntlrPilar())) {
              alt73 = 1;
            }
          }
            break;
        }

        switch (alt73) {
          case 1:
          // /Users/robby/Repositories/sireum-parser/sireum-parser/src/main/java/org/sireum/pilar/parser/AntlrPilar.g:464:6: transformation ( '|' transformation )*
          {
            pushFollow(FOLLOW_transformation_in_location4134);
            transformation223 = transformation();

            state._fsp--;
            if (state.failed) return retval;
            if (state.backtracking == 0)
              stream_transformation.add(transformation223.getTree());
            // /Users/robby/Repositories/sireum-parser/sireum-parser/src/main/java/org/sireum/pilar/parser/AntlrPilar.g:465:6: ( '|' transformation )*
            loop72: do {
              int alt72 = 2;
              int LA72_0 = input.LA(1);

              if ((LA72_0 == 194)) {
                alt72 = 1;
              }

              switch (alt72) {
                case 1:
                // /Users/robby/Repositories/sireum-parser/sireum-parser/src/main/java/org/sireum/pilar/parser/AntlrPilar.g:465:8: '|' transformation
                {
                  char_literal224 = (Token) match(
                      input,
                      194,
                      FOLLOW_194_in_location4144);
                  if (state.failed) return retval;
                  if (state.backtracking == 0) stream_194.add(char_literal224);

                  pushFollow(FOLLOW_transformation_in_location4146);
                  transformation225 = transformation();

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

                }
                  break;

                default:
                  break loop72;
              }
            } while (true);

          }
            break;

        }

        // AST REWRITE
        // elements: LOCID, angleGroupedAnnotationList, transformation
        // 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();
          // 466:41: -> ^( LOCATION[$t] LOCID angleGroupedAnnotationList ^( LIST ( transformation )* ) )
          {
            // /Users/robby/Repositories/sireum-parser/sireum-parser/src/main/java/org/sireum/pilar/parser/AntlrPilar.g:466:44: ^( LOCATION[$t] LOCID angleGroupedAnnotationList ^( LIST ( transformation )* ) )
            {
              Object root_1 = (Object) adaptor.nil();
              root_1 = (Object) adaptor.becomeRoot(
                  (Object) adaptor.create(LOCATION, t),
                  root_1);

              adaptor.addChild(root_1, stream_LOCID.nextNode());
              adaptor.addChild(
                  root_1,
                  stream_angleGroupedAnnotationList.nextTree());
              // /Users/robby/Repositories/sireum-parser/sireum-parser/src/main/java/org/sireum/pilar/parser/AntlrPilar.g:466:92: ^( LIST ( transformation )* )
              {
                Object root_2 = (Object) adaptor.nil();
                root_2 = (Object) adaptor.becomeRoot(
                    (Object) adaptor.create(LIST, "LIST"),
                    root_2);

                // /Users/robby/Repositories/sireum-parser/sireum-parser/src/main/java/org/sireum/pilar/parser/AntlrPilar.g:466:99: ( transformation )*
                while (stream_transformation.hasNext()) {
                  adaptor.addChild(root_2, stream_transformation.nextTree());

                }
                stream_transformation.reset();

                adaptor.addChild(root_1, root_2);
              }

              adaptor.addChild(root_0, root_1);
            }

          }

          retval.tree = root_0;
        }
      }

      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, 58, location_StartIndex);
      }
    }
    return retval;
  }