public final AntlrPilarParser.assignment_return assignment()
      throws RecognitionException {
    AntlrPilarParser.assignment_return retval = new AntlrPilarParser.assignment_return();
    retval.start = input.LT(1);
    int assignment_StartIndex = input.index();
    Object root_0 = null;

    Token t = null;
    Token char_literal264 = null;
    Token char_literal267 = null;
    AntlrPilarParser.lhsList_return lhsList262 = null;

    AntlrPilarParser.rhs_return rhs263 = null;

    AntlrPilarParser.rhs_return rhs265 = null;

    AntlrPilarParser.annotationList_return annotationList266 = null;

    Object t_tree = null;
    Object char_literal264_tree = null;
    Object char_literal267_tree = null;
    RewriteRuleTokenStream stream_175 = new RewriteRuleTokenStream(adaptor,
        "token 175");
    RewriteRuleTokenStream stream_172 = new RewriteRuleTokenStream(adaptor,
        "token 172");
    RewriteRuleTokenStream stream_200 = new RewriteRuleTokenStream(adaptor,
        "token 200");
    RewriteRuleTokenStream stream_ACTION_EXT_OP = new RewriteRuleTokenStream(
        adaptor, "token ACTION_EXT_OP");
    RewriteRuleSubtreeStream stream_annotationList = new RewriteRuleSubtreeStream(
        adaptor, "rule annotationList");
    RewriteRuleSubtreeStream stream_lhsList = new RewriteRuleSubtreeStream(
        adaptor, "rule lhsList");
    RewriteRuleSubtreeStream stream_rhs = new RewriteRuleSubtreeStream(adaptor,
        "rule rhs");
    try {
      if (state.backtracking > 0 && alreadyParsedRule(input, 65)) {
        return retval;
      }
      // /Users/robby/Repositories/sireum-parser/sireum-parser/src/main/java/org/sireum/pilar/parser/AntlrPilar.g:505:2: ( lhsList (t= ':=' | t= ACTION_EXT_OP ) rhs ( ',' rhs )* annotationList ';' -> ^( ASSIGN lhsList $t ^( LIST ( rhs )+ ) annotationList ) )
      // /Users/robby/Repositories/sireum-parser/sireum-parser/src/main/java/org/sireum/pilar/parser/AntlrPilar.g:505:4: lhsList (t= ':=' | t= ACTION_EXT_OP ) rhs ( ',' rhs )* annotationList ';'
      {
        pushFollow(FOLLOW_lhsList_in_assignment4729);
        lhsList262 = lhsList();

        state._fsp--;
        if (state.failed) return retval;
        if (state.backtracking == 0) stream_lhsList.add(lhsList262.getTree());
        // /Users/robby/Repositories/sireum-parser/sireum-parser/src/main/java/org/sireum/pilar/parser/AntlrPilar.g:506:4: (t= ':=' | t= ACTION_EXT_OP )
        int alt80 = 2;
        int LA80_0 = input.LA(1);

        if ((LA80_0 == 200)) {
          alt80 = 1;
        } else if ((LA80_0 == ACTION_EXT_OP)) {
          alt80 = 2;
        } else {
          if (state.backtracking > 0) {
            state.failed = true;
            return retval;
          }
          NoViableAltException nvae = new NoViableAltException("", 80, 0, input);

          throw nvae;
        }
        switch (alt80) {
          case 1:
          // /Users/robby/Repositories/sireum-parser/sireum-parser/src/main/java/org/sireum/pilar/parser/AntlrPilar.g:506:6: t= ':='
          {
            t = (Token) match(input, 200, FOLLOW_200_in_assignment4739);
            if (state.failed) return retval;
            if (state.backtracking == 0) stream_200.add(t);

          }
            break;
          case 2:
          // /Users/robby/Repositories/sireum-parser/sireum-parser/src/main/java/org/sireum/pilar/parser/AntlrPilar.g:507:6: t= ACTION_EXT_OP
          {
            t = (Token) match(
                input,
                ACTION_EXT_OP,
                FOLLOW_ACTION_EXT_OP_in_assignment4749);
            if (state.failed) return retval;
            if (state.backtracking == 0) stream_ACTION_EXT_OP.add(t);

          }
            break;

        }

        pushFollow(FOLLOW_rhs_in_assignment4755);
        rhs263 = rhs();

        state._fsp--;
        if (state.failed) return retval;
        if (state.backtracking == 0) stream_rhs.add(rhs263.getTree());
        // /Users/robby/Repositories/sireum-parser/sireum-parser/src/main/java/org/sireum/pilar/parser/AntlrPilar.g:508:8: ( ',' rhs )*
        loop81: do {
          int alt81 = 2;
          int LA81_0 = input.LA(1);

          if ((LA81_0 == 172)) {
            alt81 = 1;
          }

          switch (alt81) {
            case 1:
            // /Users/robby/Repositories/sireum-parser/sireum-parser/src/main/java/org/sireum/pilar/parser/AntlrPilar.g:508:10: ',' rhs
            {
              char_literal264 = (Token) match(
                  input,
                  172,
                  FOLLOW_172_in_assignment4759);
              if (state.failed) return retval;
              if (state.backtracking == 0) stream_172.add(char_literal264);

              pushFollow(FOLLOW_rhs_in_assignment4761);
              rhs265 = rhs();

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

            }
              break;

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

        pushFollow(FOLLOW_annotationList_in_assignment4769);
        annotationList266 = annotationList();

        state._fsp--;
        if (state.failed) return retval;
        if (state.backtracking == 0)
          stream_annotationList.add(annotationList266.getTree());
        char_literal267 = (Token) match(
            input,
            175,
            FOLLOW_175_in_assignment4771);
        if (state.failed) return retval;
        if (state.backtracking == 0) stream_175.add(char_literal267);

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

          root_0 = (Object) adaptor.nil();
          // 509:41: -> ^( ASSIGN lhsList $t ^( LIST ( rhs )+ ) annotationList )
          {
            // /Users/robby/Repositories/sireum-parser/sireum-parser/src/main/java/org/sireum/pilar/parser/AntlrPilar.g:509:44: ^( ASSIGN lhsList $t ^( LIST ( rhs )+ ) annotationList )
            {
              Object root_1 = (Object) adaptor.nil();
              root_1 = (Object) adaptor.becomeRoot(
                  (Object) adaptor.create(ASSIGN, "ASSIGN"),
                  root_1);

              adaptor.addChild(root_1, stream_lhsList.nextTree());
              adaptor.addChild(root_1, stream_t.nextNode());
              // /Users/robby/Repositories/sireum-parser/sireum-parser/src/main/java/org/sireum/pilar/parser/AntlrPilar.g:509:64: ^( LIST ( rhs )+ )
              {
                Object root_2 = (Object) adaptor.nil();
                root_2 = (Object) adaptor.becomeRoot(
                    (Object) adaptor.create(LIST, "LIST"),
                    root_2);

                if (!(stream_rhs.hasNext())) {
                  throw new RewriteEarlyExitException();
                }
                while (stream_rhs.hasNext()) {
                  adaptor.addChild(root_2, stream_rhs.nextTree());

                }
                stream_rhs.reset();

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

              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, 65, assignment_StartIndex);
      }
    }
    return retval;
  }