Source Code of org.openquark.cal.compiler.CALParser

// $ANTLR 2.7.6 (2005-12-22): "CAL.g" -> "CALParser.java"$


// Package declaration
package org.openquark.cal.compiler;


import antlr.TokenBuffer;
import antlr.TokenStreamException;
import antlr.TokenStreamIOException;
import antlr.ANTLRException;
import antlr.LLkParser;
import antlr.Token;
import antlr.TokenStream;
import antlr.RecognitionException;
import antlr.NoViableAltException;
import antlr.MismatchedTokenException;
import antlr.SemanticException;
import antlr.ParserSharedInputState;
import antlr.collections.impl.BitSet;
import antlr.collections.AST;
import java.util.Hashtable;
import antlr.ASTFactory;
import antlr.ASTPair;
import antlr.collections.impl.ASTArray;


/*************************************** 
 * CAL grammar definition starts here  *   
 ***************************************/
@SuppressWarnings(\u0022all\u0022) final class CALParser extends antlr.LLkParser       implements CALTokenTypes
 {


    // Add declarations for CALParser class here


    private CALCompiler compiler;  
 
    /**
     * Construct CALParser from a CALCompiler
     */ 
    CALParser (CALCompiler compiler, TokenStream tStream) {
        this (tStream);
        this.compiler = compiler;
    }


    /**
     * @return a SourceRange representing the position of the syntax error as contained in the given exception.
     */
    public static SourceRange makeSourceRangeFromException(RecognitionException ex) {
        // This is the best we can do given the information from ANTLR
        final SourcePosition startSourcePosition = new SourcePosition(ex.getLine(), ex.getColumn(), ex.getFilename());
        final SourcePosition endSourcePosition = new SourcePosition(ex.getLine(), ex.getColumn()+1, ex.getFilename());
        return new SourceRange(startSourcePosition, endSourcePosition);
    }
    
    /**
     * @return a SourcePosition representing the position of a token.
     */
    private static SourceRange makeSourceRangeFromToken(Token token) {
        // This is the best we can do given the information from ANTLR
        final SourcePosition startSourcePosition = new SourcePosition(token.getLine(), token.getColumn(), token.getFilename());
        final SourcePosition endSourcePosition = new SourcePosition(token.getLine(), token.getColumn()+1, token.getFilename());
        return new SourceRange(startSourcePosition, endSourcePosition);
    }
    
    /**
     * Override reportError method to direct standard error handling through to the CALCompiler error scheme
     * @param ex the recognition exception that originated the problem
     */
    public void reportError (RecognitionException ex) {
        SourceRange sourceRange = makeSourceRangeFromException(ex);
        
        // Special handling of a syntax error arising from having a CALDoc comment in an inadmissible location.
        if (isCALDocAppearingInInadmissibleLocation(ex)) {
            compiler.logMessage(new CompilerMessage(sourceRange, new MessageKind.Error.CALDocCommentCannotAppearHere(), ex));
            // to prevent a bunch of meaningless errors from occuring right after this, we consume
            // everything until we see a CALDOC_CLOSE, so that we can regain sanity and resume the parsing properly
            try {
                consumeUntil(CALDOC_CLOSE);
                match(CALDOC_CLOSE);
            } catch (MismatchedTokenException e) {
            } catch (TokenStreamException e) {
            }
        } else {
            // Standard handling of syntax errors
            compiler.logMessage(new CompilerMessage(sourceRange, new MessageKind.Error.SyntaxError(), ex));
        }
    }
    
    /**
     * Convenience method for custom exception handlers; includes the default resync calls.
     * @param ex the recognition exception that caused the problem to be reported
     * @param followSet The $FOLLOW set for the current rule.  Used to consume tokens in
     *                  an attempt to keep compiling after errors.
     */
    private void reportError (RecognitionException ex, BitSet followSet) throws RecognitionException, TokenStreamException {
        reportError(ex);
        consume();
        consumeUntil(followSet);
    }
    
    /**
     * @return true if the exception represents the syntax error of having a CALDoc comment in an inadmissible location; false otherwise.
     */
    private boolean isCALDocAppearingInInadmissibleLocation(RecognitionException ex) {
        if (ex instanceof NoViableAltException) {
            NoViableAltException noViableAltEx = (NoViableAltException)ex;
            return noViableAltEx.token != null && noViableAltEx.token.getType() == CALDOC_OPEN;
        } else if (ex instanceof CALMismatchedTokenException) {
            CALMismatchedTokenException mismatchedTokenEx = (CALMismatchedTokenException)ex;
            return mismatchedTokenEx.token != null && mismatchedTokenEx.token.getType() == CALDOC_OPEN;
        }
        return false;
    }
    
    /**
     * Reports an error for having encountered an unknown CALDoc tag.
     */
    private void reportUnrecognizedTagInCALDocCommentError(Token unknownTag) {
        SourceRange sourceRange = makeSourceRangeFromToken(unknownTag);
        compiler.logMessage(new CompilerMessage(sourceRange, new MessageKind.Error.UnrecognizedTagInCALDocComment(unknownTag.getText())));
    }
    
    /**
     * Reports an error for having encountered an unknown CALDoc inline tag.
     */
    private void reportUnrecognizedInlineTagInCALDocCommentError(Token unknownTag) {
        SourceRange sourceRange = makeSourceRangeFromToken(unknownTag);
        compiler.logMessage(new CompilerMessage(sourceRange, new MessageKind.Error.UnrecognizedInlineTagInCALDocComment("{@" + unknownTag.getText() + "}")));
    }
    
    /**
     * Reports an error for having encountered a CALDoc inline tag in an inadmissable location.
     */
    private void reportCALDocInlineTagAppearingInInadmissibleLocationError(Token openInlineTag, Token surroundingInlineTag) {
        SourceRange sourceRange = makeSourceRangeFromToken(openInlineTag);
        compiler.logMessage(new CompilerMessage(sourceRange, new MessageKind.Error.InlineTagCannotAppearHereInsideCALDocCommentInlineTag("{@" + surroundingInlineTag.getText() + "}")));
    }
    
    /**
     * Reports an error for having encountered a CALDoc inline tag without a corresponding closing tag.
     */
    private void reportMaybeCALDocInlineBlockNotClosedBeforeEndOfTextBlockError(Token openInlineTag, MismatchedTokenException ex) {
        // report a custom error if the expected token is a '@}'.
        if (ex.expecting == CALDOC_CLOSE_INLINE_TAG) {
            SourceRange sourceRange = makeSourceRangeFromToken(openInlineTag);
            compiler.logMessage(new CompilerMessage(sourceRange, new MessageKind.Error.InlineTagBlockMissingClosingTagInCALDocComment()));
        } else {
            // it is not the case that the expected token is a '@}', so fall back to the standard reportError mechanism.
            reportError(ex);
        }
    }
    
    /**
     * Reports an error for having encountered a missing context for a CALDoc "@see" or "@link" block.
     */
    private void reportMaybeMissingSeeOrLinkBlockContextInCALDocCommentError(NoViableAltException ex) {
        // report a custom error if the token causing the exception is an EQUALS, i.e. the '=' appears immediately after the "@see" or "@link" tag.
        if (ex.token != null && ex.token.getType() == EQUALS) {
            SourceRange sourceRange = makeSourceRangeFromException(ex);
            compiler.logMessage(new CompilerMessage(sourceRange, new MessageKind.Error.MissingSeeOrLinkBlockContextInCALDocComment(), ex));
        } else {
            // it is not the case that the '=' appears immediately after the "@see" or "@link" tag, so fall back to the standard reportError mechanism.
            reportError(ex);
        }
    }
    
    /**
     * Reports an error for having encountered an unknown context for a CALDoc "@see" or "@link" block.
     */
    private void reportUnrecognizedSeeOrLinkBlockContextInCALDocCommentError(ParseTreeNode unknownContext) {
        SourceRange sourceRange = unknownContext.getSourceRange();
        compiler.logMessage(new CompilerMessage(sourceRange, new MessageKind.Error.UnrecognizedSeeOrLinkBlockContextInCALDocComment(unknownContext.getText())));
    }
    
    /**
     * Reports an error for having encountered an unassociated CALDoc comment.
     */
    private void reportUnassociatedCALDocCommentError(ParseTreeNode unassociatedComment) {
        SourceRange sourceRange = unassociatedComment.getSourceRange();
        compiler.logMessage(new CompilerMessage(sourceRange, new MessageKind.Error.UnassociatedCALDocComment()));
    }
    
    /**
     * Reports an error for having encountered an invalid reference in a CALDoc "@see" or "@link" block.
     */
    private void reportMaybeUnrecognizedSeeOrLinkBlockReferenceInCALDocCommentError(NoViableAltException ex) {
        // report a custom error if the token causing the exception is a CALDOC_SEE_TAG_UNKNOWN_REFERENCE, i.e. an invalid reference in a CALDoc @see block
        // a VAR_ID, i.e. a lowercase identifier when an uppercase one is expected, or a CONS_ID, i.e. an uppercase identifier when a loewrcase one is expected.
        if (ex.token != null && (ex.token.getType() == CALDOC_SEE_TAG_UNKNOWN_REFERENCE || ex.token.getType() == VAR_ID || ex.token.getType() == CONS_ID)) {
            SourceRange sourceRange = makeSourceRangeFromException(ex);
            compiler.logMessage(new CompilerMessage(sourceRange, new MessageKind.Error.UnrecognizedSeeOrLinkBlockReferenceInCALDocComment(ex.token.getText())));
        } else {
            // it is not an invalid reference in a CALDoc @see block, so fall back to the standard reportError mechanism.
            reportError(ex);
        }
    }
    
    /**
     * Reports an error for having encountered a CALDoc comment for a local pattern match decl.
     */
    private void reportLocalPatternMatchDeclCannotHaveCALDocComment(final ParseTreeNode unassociatedComment) {
        SourceRange sourceRange = unassociatedComment.getSourceRange();
        compiler.logMessage(new CompilerMessage(sourceRange, new MessageKind.Error.LocalPatternMatchDeclCannotHaveCALDocComment()));
    }
    
    /**
     * Reports an error for having encountered a wildcard pattern in a pattern match declaration in a let block.
     */
    private void reportInvalidLocalPatternMatchWildcardPatternError(final ParseTreeNode node) {
        SourceRange sourceRange = node.getSourceRange();
        compiler.logMessage(new CompilerMessage(sourceRange, new MessageKind.Error.InvalidLocalPatternMatchWildcardPattern()));
    }
    
    /**
     * Reports an error for having encountered a Nil pattern in a pattern match declaration in a let block.
     */
    private void reportInvalidLocalPatternMatchNilPatternError(final ParseTreeNode node) {
        SourceRange sourceRange = node.getSourceRange();
        compiler.logMessage(new CompilerMessage(sourceRange, new MessageKind.Error.InvalidLocalPatternMatchNilPattern()));
    }
    
    /**
     * Reports an error for having encountered a multiple data cons pattern in a pattern match declaration in a let block.
     */
    private void reportInvalidLocalPatternMatchMultipleDataConsPatternError(final ParseTreeNode node) {
        SourceRange sourceRange = node.getAssemblySourceRange();
        compiler.logMessage(new CompilerMessage(sourceRange, new MessageKind.Error.InvalidLocalPatternMatchMultipleDataConsPattern()));
    }
    
    /**
     * Reports an error for having encountered an int pattern in a pattern match declaration in a let block.
     */
    private void reportInvalidLocalPatternMatchIntPatternError(final ParseTreeNode node) {
        SourceRange sourceRange = node.getAssemblySourceRange();
        compiler.logMessage(new CompilerMessage(sourceRange, new MessageKind.Error.InvalidLocalPatternMatchIntPattern()));
    }
    
    /**
     * Reports an error for having encountered an char pattern in a pattern match declaration in a let block.
     */
    private void reportInvalidLocalPatternMatchCharPatternError(final ParseTreeNode node) {
        SourceRange sourceRange = node.getAssemblySourceRange();
        compiler.logMessage(new CompilerMessage(sourceRange, new MessageKind.Error.InvalidLocalPatternMatchCharPattern()));
    }
    
    /**
     * Report a NoViableAltException from a context that provides a paraphrase.  The parser
     * state will be resynched in the standard way using the provided followSet.
     *
     * @param contextToken Token The first token in the context (this is probably not the next token
     *                     in the current lookahead)
     * @param paraphrase String The string to use as the paraphrase for this context
     * @param firstSet  The $FIRST set for the current rule
     * @param followSet The $FOLLOW set for the current rule.  We will consume the current
     *                  token and then carry on until the follow set in an attempt to resync
     *                  so that we can keep compiling after an error (this mirrors the default
     *                  handling for all RecognitionExceptions)
     */
    private void reportWithParaphrase(RecognitionException ex, Token contextToken, String paraphrase, BitSet firstSet, BitSet followSet) throws RecognitionException, TokenStreamException {


        if(contextToken != null && paraphrase != null && firstSet != null && followSet != null) {
                
            if(!firstSet.member(LA(1))) {
                Token errorToken = LT(1);
                SourceRange errorRange = makeSourceRangeFromToken(errorToken);
                String[] expectedTokens = bitsetToStringArray(firstSet);


                if(expectedTokens.length == 1) {
                    compiler.logMessage(new CompilerMessage(errorRange, new MessageKind.Error.SyntaxErrorWithParaphraseSingleExpected(getTokenDescription(errorToken), expectedTokens[0], getTokenDescription(contextToken), paraphrase)));
                } else {
                  compiler.logMessage(new CompilerMessage(errorRange, new MessageKind.Error.SyntaxErrorWithParaphrase(getTokenDescription(errorToken), expectedTokens, getTokenDescription(contextToken), paraphrase)));
                }


            } else if(!followSet.member(LA(2))) {
                Token errorToken = LT(2);
                SourceRange errorRange = makeSourceRangeFromToken(errorToken);
                String[] expectedTokens = bitsetToStringArray(followSet);
                
                if(expectedTokens.length == 1) {
                    compiler.logMessage(new CompilerMessage(errorRange, new MessageKind.Error.SyntaxErrorWithParaphraseSingleExpected(getTokenDescription(errorToken), expectedTokens[0], getTokenDescription(contextToken), paraphrase)));
                } else {
                    compiler.logMessage(new CompilerMessage(errorRange, new MessageKind.Error.SyntaxErrorWithParaphrase(getTokenDescription(errorToken), expectedTokens, getTokenDescription(contextToken), paraphrase)));
                }


            } else {
                reportError(ex);
            }


        } else {
            reportError(ex);
        }


        consume();
        consumeUntil(followSet);
    }
    
    /**
     * Converts a bitset of token IDs to an array of token names.
     * @param set The BitSet to convert
     * @return a String array of token names
     */
    private String[] bitsetToStringArray(BitSet set) {
        
        String[] stringArray = new String[set.degree()];
        
        int[] tokenIDs = set.toArray();
        for(int i = 0; i < tokenIDs.length; i++) {
            stringArray[i] = _tokenNames[tokenIDs[i]];
        }
        
        return stringArray;
    }


    /**
     * @param token The token to fetch a description for
     * @return String containing either the actual consumed text of the token if available, or the name of the token
     *          (for special tokens such as EOF that consume no text)
     */
    private String getTokenDescription(Token token) {
        String text = token.getText();
        if(text == null) {
            return _tokenNames[token.getType()];
        }
        
        return text;
    }


    /**
     * Report a syntax error along with a suggestion for how to fix it (e.g., by using '==' instead
     * of '=').  Unlike reportWithParaphrase, no resynch is performed (on the assumption that we will
     * instead parse as if we had encountered the suggestion).
     *
     * @param unexpectedToken Token The token that was not expected 
     * @param suggestion String The suggested token
     */
    private void reportWithSuggestion(Token unexpectedToken, String suggestion) {
        SourceRange sourceRange = makeSourceRangeFromToken(unexpectedToken);
        compiler.logMessage(new CompilerMessage(sourceRange, new MessageKind.Error.SyntaxErrorWithSuggestion(unexpectedToken.getText(), suggestion)));
    }
        
    /**
     * Make sure current lookahead symbol matches token type <tt>t</tt>.
     * Throw an exception upon mismatch, which is catch by either the
     * error handler or by the syntactic predicate.
     */
    public void match(int t) throws MismatchedTokenException, TokenStreamException {
        if (LA(1) != t) {
            throw new CALMismatchedTokenException(tokenNames, LT(1), t, getFilename());
        } else {
            // mark token as consumed -- fetch next token deferred until LA/LT
            consume();
        }
    }    


protected CALParser(TokenBuffer tokenBuf, int k) {
  super(tokenBuf,k);
  tokenNames = _tokenNames;
  buildTokenTypeASTClassMap();
  astFactory = new ASTFactory(getTokenTypeToASTClassMap());
}


public CALParser(TokenBuffer tokenBuf) {
  this(tokenBuf,2);
}


protected CALParser(TokenStream lexer, int k) {
  super(lexer,k);
  tokenNames = _tokenNames;
  buildTokenTypeASTClassMap();
  astFactory = new ASTFactory(getTokenTypeToASTClassMap());
}


public CALParser(TokenStream lexer) {
  this(lexer,2);
}


public CALParser(ParserSharedInputState state) {
  super(state,2);
  tokenNames = _tokenNames;
  buildTokenTypeASTClassMap();
  astFactory = new ASTFactory(getTokenTypeToASTClassMap());
}


  public final void codeGemExpr() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST codeGemExpr_AST = null;
    
    try {      // for error handling
      expr(LT(1), "a valid expression");
      astFactory.addASTChild(currentAST, returnAST);
      match(Token.EOF_TYPE);
      codeGemExpr_AST = (AST)currentAST.root;
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        recover(ex,_tokenSet_0);
      } else {
        throw ex;
      }
    }
    returnAST = codeGemExpr_AST;
  }
  
  public final void expr(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST expr_AST = null;
    Token  node = null;
    AST node_AST = null;
    
    try {      // for error handling
      switch ( LA(1)) {
      case LITERAL_let:
      {
        AST tmp2_AST = null;
        tmp2_AST = astFactory.create(LT(1));
        astFactory.makeASTRoot(currentAST, tmp2_AST);
        match(LITERAL_let);
        letDefnList(LT(1), "a valid list of let definitions");
        astFactory.addASTChild(currentAST, returnAST);
        match(LITERAL_in);
        expr(LT(1), "a valid let body");
        astFactory.addASTChild(currentAST, returnAST);
        expr_AST = (AST)currentAST.root;
        break;
      }
      case LITERAL_if:
      {
        AST tmp4_AST = null;
        tmp4_AST = astFactory.create(LT(1));
        astFactory.makeASTRoot(currentAST, tmp4_AST);
        match(LITERAL_if);
        expr(LT(1), "a valid conditional expression for an if expression");
        astFactory.addASTChild(currentAST, returnAST);
        match(LITERAL_then);
        expr(LT(1), "a valid then-clause expression");
        astFactory.addASTChild(currentAST, returnAST);
        match(LITERAL_else);
        expr(LT(1), "a valid else-clause expression");
        astFactory.addASTChild(currentAST, returnAST);
        expr_AST = (AST)currentAST.root;
        break;
      }
      case LITERAL_case:
      {
        AST tmp7_AST = null;
        tmp7_AST = astFactory.create(LT(1));
        astFactory.makeASTRoot(currentAST, tmp7_AST);
        match(LITERAL_case);
        expr(LT(1), "a valid condition expression for a case expression");
        astFactory.addASTChild(currentAST, returnAST);
        match(LITERAL_of);
        altList(LT(1), "a list of case alternatives");
        astFactory.addASTChild(currentAST, returnAST);
        expr_AST = (AST)currentAST.root;
        break;
      }
      case BACKSLASH:
      {
        node = LT(1);
        node_AST = astFactory.create(node);
        astFactory.makeASTRoot(currentAST, node_AST);
        match(BACKSLASH);
        if ( inputState.guessing==0 ) {
          node_AST.setType (LAMBDA_DEFN);
        }
        lambdaParamList(LT(1), "a valid parameter list for a lambda expression");
        astFactory.addASTChild(currentAST, returnAST);
        match(RARROW);
        expr(LT(1), "a valid defining expression for a lambda expression");
        astFactory.addASTChild(currentAST, returnAST);
        expr_AST = (AST)currentAST.root;
        break;
      }
      case CONS_ID:
      case VAR_ID:
      case OPEN_PAREN:
      case OPEN_BRACKET:
      case OPEN_BRACE:
      case STRING_LITERAL:
      case MINUS:
      case CHAR_LITERAL:
      case INTEGER_LITERAL:
      case FLOAT_LITERAL:
      {
        typeSignatureExpr(contextToken, paraphrase);
        astFactory.addASTChild(currentAST, returnAST);
        expr_AST = (AST)currentAST.root;
        break;
      }
      default:
      {
        throw new NoViableAltException(LT(1), getFilename());
      }
      }
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_1, _tokenSet_2);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_2);
      } else {
        throw ex;
      }
    }
    returnAST = expr_AST;
  }
  
  public final void startTypeSignature() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST startTypeSignature_AST = null;
    
    try {      // for error handling
      typeSignature(LT(1), "a valid type signature");
      astFactory.addASTChild(currentAST, returnAST);
      match(Token.EOF_TYPE);
      startTypeSignature_AST = (AST)currentAST.root;
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        recover(ex,_tokenSet_0);
      } else {
        throw ex;
      }
    }
    returnAST = startTypeSignature_AST;
  }
  
  public final void typeSignature(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST typeSignature_AST = null;
    
    try {      // for error handling
      typeContextList(LT(1), "a type context");
      astFactory.addASTChild(currentAST, returnAST);
      type(LT(1), "a type");
      astFactory.addASTChild(currentAST, returnAST);
      if ( inputState.guessing==0 ) {
        typeSignature_AST = (AST)currentAST.root;
        typeSignature_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(TYPE_SIGNATURE,"TYPE_SIGNATURE")).add(typeSignature_AST));
        currentAST.root = typeSignature_AST;
        currentAST.child = typeSignature_AST!=null &&typeSignature_AST.getFirstChild()!=null ?
          typeSignature_AST.getFirstChild() : typeSignature_AST;
        currentAST.advanceChildToEnd();
      }
      typeSignature_AST = (AST)currentAST.root;
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_3, _tokenSet_4);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_4);
      } else {
        throw ex;
      }
    }
    returnAST = typeSignature_AST;
  }
  
  public final void module() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST module_AST = null;
    
    try {      // for error handling
      optionalDocComment();
      astFactory.addASTChild(currentAST, returnAST);
      moduleNameDecl(LT(1), "a valid module name");
      astFactory.addASTChild(currentAST, returnAST);
      importDeclarationList(LT(1), "a list of import declarations");
      astFactory.addASTChild(currentAST, returnAST);
      friendDeclarationList(LT(1), "a list of friend declarations");
      astFactory.addASTChild(currentAST, returnAST);
      outerDefnList(LT(1), "a list of top-level definitions");
      astFactory.addASTChild(currentAST, returnAST);
      match(Token.EOF_TYPE);
      if ( inputState.guessing==0 ) {
        module_AST = (AST)currentAST.root;
        module_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(MODULE_DEFN,"MODULE_DEFN")).add(module_AST));
        currentAST.root = module_AST;
        currentAST.child = module_AST!=null &&module_AST.getFirstChild()!=null ?
          module_AST.getFirstChild() : module_AST;
        currentAST.advanceChildToEnd();
      }
      module_AST = (AST)currentAST.root;
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        recover(ex,_tokenSet_0);
      } else {
        throw ex;
      }
    }
    returnAST = module_AST;
  }
  
  public final void optionalDocComment() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST optionalDocComment_AST = null;
    AST comment_AST = null;
    AST moreComments_AST = null;
    
    try {      // for error handling
      switch ( LA(1)) {
      case CALDOC_OPEN:
      {
        docComment();
        comment_AST = (AST)returnAST;
        {
        switch ( LA(1)) {
        case CONS_ID:
        case VAR_ID:
        case LITERAL_module:
        case LITERAL_class:
        case OPEN_PAREN:
        case OPEN_BRACKET:
        case OPEN_BRACE:
        case LITERAL_data:
        case LITERAL_foreign:
        case LITERAL_instance:
        case LITERAL_primitive:
        case LITERAL_public:
        case LITERAL_private:
        case LITERAL_protected:
        case MINUS:
        case UNDERSCORE:
        case CHAR_LITERAL:
        case INTEGER_LITERAL:
        {
          if ( inputState.guessing==0 ) {
            optionalDocComment_AST = (AST)currentAST.root;
            optionalDocComment_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(OPTIONAL_CALDOC_COMMENT,"OPTIONAL_CALDOC_COMMENT")).add(comment_AST));
            currentAST.root = optionalDocComment_AST;
            currentAST.child = optionalDocComment_AST!=null &&optionalDocComment_AST.getFirstChild()!=null ?
              optionalDocComment_AST.getFirstChild() : optionalDocComment_AST;
            currentAST.advanceChildToEnd();
          }
          break;
        }
        case CALDOC_OPEN:
        {
          if ( inputState.guessing==0 ) {
            reportUnassociatedCALDocCommentError((ParseTreeNode)comment_AST);
          }
          moreDocComments();
          moreComments_AST = (AST)returnAST;
          if ( inputState.guessing==0 ) {
            optionalDocComment_AST = (AST)currentAST.root;
            optionalDocComment_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(OPTIONAL_CALDOC_COMMENT,"OPTIONAL_CALDOC_COMMENT")).add(moreComments_AST));
            currentAST.root = optionalDocComment_AST;
            currentAST.child = optionalDocComment_AST!=null &&optionalDocComment_AST.getFirstChild()!=null ?
              optionalDocComment_AST.getFirstChild() : optionalDocComment_AST;
            currentAST.advanceChildToEnd();
          }
          break;
        }
        default:
        {
          throw new NoViableAltException(LT(1), getFilename());
        }
        }
        }
        optionalDocComment_AST = (AST)currentAST.root;
        break;
      }
      case CONS_ID:
      case VAR_ID:
      case LITERAL_module:
      case LITERAL_class:
      case OPEN_PAREN:
      case OPEN_BRACKET:
      case OPEN_BRACE:
      case LITERAL_data:
      case LITERAL_foreign:
      case LITERAL_instance:
      case LITERAL_primitive:
      case LITERAL_public:
      case LITERAL_private:
      case LITERAL_protected:
      case MINUS:
      case UNDERSCORE:
      case CHAR_LITERAL:
      case INTEGER_LITERAL:
      {
        if ( inputState.guessing==0 ) {
          optionalDocComment_AST = (AST)currentAST.root;
          optionalDocComment_AST = (AST)astFactory.make( (new ASTArray(1)).add(astFactory.create(OPTIONAL_CALDOC_COMMENT,"OPTIONAL_CALDOC_COMMENT")));
          currentAST.root = optionalDocComment_AST;
          currentAST.child = optionalDocComment_AST!=null &&optionalDocComment_AST.getFirstChild()!=null ?
            optionalDocComment_AST.getFirstChild() : optionalDocComment_AST;
          currentAST.advanceChildToEnd();
        }
        optionalDocComment_AST = (AST)currentAST.root;
        break;
      }
      default:
      {
        throw new NoViableAltException(LT(1), getFilename());
      }
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        recover(ex,_tokenSet_5);
      } else {
        throw ex;
      }
    }
    returnAST = optionalDocComment_AST;
  }
  
  public final void moduleNameDecl(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST moduleNameDecl_AST = null;
    
    try {      // for error handling
      match(LITERAL_module);
      moduleName(LT(1), "a semicolon-terminated module name");
      astFactory.addASTChild(currentAST, returnAST);
      match(SEMICOLON);
      moduleNameDecl_AST = (AST)currentAST.root;
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_6, _tokenSet_7);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_7);
      } else {
        throw ex;
      }
    }
    returnAST = moduleNameDecl_AST;
  }
  
  public final void importDeclarationList(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST importDeclarationList_AST = null;
    
    try {      // for error handling
      {
      _loop14:
      do {
        if ((LA(1)==LITERAL_import)) {
          importDeclaration(LT(1), "an import declaration");
          astFactory.addASTChild(currentAST, returnAST);
        }
        else {
          break _loop14;
        }
        
      } while (true);
      }
      if ( inputState.guessing==0 ) {
        importDeclarationList_AST = (AST)currentAST.root;
        importDeclarationList_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(IMPORT_DECLARATION_LIST,"IMPORT_DECLARATION_LIST")).add(importDeclarationList_AST));
        currentAST.root = importDeclarationList_AST;
        currentAST.child = importDeclarationList_AST!=null &&importDeclarationList_AST.getFirstChild()!=null ?
          importDeclarationList_AST.getFirstChild() : importDeclarationList_AST;
        currentAST.advanceChildToEnd();
      }
      importDeclarationList_AST = (AST)currentAST.root;
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_7, _tokenSet_8);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_8);
      } else {
        throw ex;
      }
    }
    returnAST = importDeclarationList_AST;
  }
  
  public final void friendDeclarationList(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST friendDeclarationList_AST = null;
    
    try {      // for error handling
      {
      _loop35:
      do {
        if ((LA(1)==LITERAL_friend)) {
          friendDeclaration(LT(1), "a friend declaration");
          astFactory.addASTChild(currentAST, returnAST);
        }
        else {
          break _loop35;
        }
        
      } while (true);
      }
      if ( inputState.guessing==0 ) {
        friendDeclarationList_AST = (AST)currentAST.root;
        friendDeclarationList_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(FRIEND_DECLARATION_LIST,"FRIEND_DECLARATION_LIST")).add(friendDeclarationList_AST));
        currentAST.root = friendDeclarationList_AST;
        currentAST.child = friendDeclarationList_AST!=null &&friendDeclarationList_AST.getFirstChild()!=null ?
          friendDeclarationList_AST.getFirstChild() : friendDeclarationList_AST;
        currentAST.advanceChildToEnd();
      }
      friendDeclarationList_AST = (AST)currentAST.root;
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_8, _tokenSet_9);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_9);
      } else {
        throw ex;
      }
    }
    returnAST = friendDeclarationList_AST;
  }
  
  public final void outerDefnList(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST outerDefnList_AST = null;
    
    try {      // for error handling
      {
      _loop39:
      do {
        if ((_tokenSet_10.member(LA(1)))) {
          outerDefn(LT(1), "an outer definition");
          astFactory.addASTChild(currentAST, returnAST);
        }
        else {
          break _loop39;
        }
        
      } while (true);
      }
      if ( inputState.guessing==0 ) {
        outerDefnList_AST = (AST)currentAST.root;
        outerDefnList_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(OUTER_DEFN_LIST,"OUTER_DEFN_LIST")).add(outerDefnList_AST));
        currentAST.root = outerDefnList_AST;
        currentAST.child = outerDefnList_AST!=null &&outerDefnList_AST.getFirstChild()!=null ?
          outerDefnList_AST.getFirstChild() : outerDefnList_AST;
        currentAST.advanceChildToEnd();
      }
      outerDefnList_AST = (AST)currentAST.root;
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_9, _tokenSet_0);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_0);
      } else {
        throw ex;
      }
    }
    returnAST = outerDefnList_AST;
  }
  
  public final void moduleHeader() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST moduleHeader_AST = null;
    
    try {      // for error handling
      optionalDocComment();
      astFactory.addASTChild(currentAST, returnAST);
      moduleNameDecl(LT(1), "a valid module name");
      astFactory.addASTChild(currentAST, returnAST);
      importDeclarationList(LT(1), "a list of import declarations");
      astFactory.addASTChild(currentAST, returnAST);
      if ( inputState.guessing==0 ) {
        moduleHeader_AST = (AST)currentAST.root;
        moduleHeader_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(MODULE_DEFN,"MODULE_DEFN")).add(moduleHeader_AST));
        currentAST.root = moduleHeader_AST;
        currentAST.child = moduleHeader_AST!=null &&moduleHeader_AST.getFirstChild()!=null ?
          moduleHeader_AST.getFirstChild() : moduleHeader_AST;
        currentAST.advanceChildToEnd();
      }
      moduleHeader_AST = (AST)currentAST.root;
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        recover(ex,_tokenSet_0);
      } else {
        throw ex;
      }
    }
    returnAST = moduleHeader_AST;
  }
  
  public final void adjunct() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST adjunct_AST = null;
    
    try {      // for error handling
      adjunctDefnList(LT(1), "a list of adjunct definitions");
      astFactory.addASTChild(currentAST, returnAST);
      match(Token.EOF_TYPE);
      adjunct_AST = (AST)currentAST.root;
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        recover(ex,_tokenSet_0);
      } else {
        throw ex;
      }
    }
    returnAST = adjunct_AST;
  }
  
  public final void adjunctDefnList(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST adjunctDefnList_AST = null;
    
    try {      // for error handling
      {
      _loop8:
      do {
        if ((_tokenSet_11.member(LA(1)))) {
          adjunctDefn(LT(1), "a valid adjunct definition");
          astFactory.addASTChild(currentAST, returnAST);
        }
        else {
          break _loop8;
        }
        
      } while (true);
      }
      if ( inputState.guessing==0 ) {
        adjunctDefnList_AST = (AST)currentAST.root;
        adjunctDefnList_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(OUTER_DEFN_LIST,"ADJUNCT_DEFN_LIST")).add(adjunctDefnList_AST));
        currentAST.root = adjunctDefnList_AST;
        currentAST.child = adjunctDefnList_AST!=null &&adjunctDefnList_AST.getFirstChild()!=null ?
          adjunctDefnList_AST.getFirstChild() : adjunctDefnList_AST;
        currentAST.advanceChildToEnd();
      }
      adjunctDefnList_AST = (AST)currentAST.root;
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_12, _tokenSet_0);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_0);
      } else {
        throw ex;
      }
    }
    returnAST = adjunctDefnList_AST;
  }
  
  public final void adjunctDefn(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST adjunctDefn_AST = null;
    AST doc_AST = null;
    
    try {      // for error handling
      optionalDocComment();
      doc_AST = (AST)returnAST;
      {
      if ((LA(1)==VAR_ID) && (LA(2)==COLONCOLON)) {
        topLevelTypeDeclarationWithOptionalDocComment(doc_AST, LT(1), "top level type declaration");
        astFactory.addASTChild(currentAST, returnAST);
      }
      else if ((LA(1)==LITERAL_instance)) {
        instanceDefnWithOptionalDocComment(doc_AST, LT(1), "instance definition");
        astFactory.addASTChild(currentAST, returnAST);
      }
      else if ((_tokenSet_13.member(LA(1))) && (_tokenSet_14.member(LA(2)))) {
        topLevelFunctionWithOptionalDocComment(doc_AST, LT(1), "top level function definition");
        astFactory.addASTChild(currentAST, returnAST);
      }
      else {
        throw new NoViableAltException(LT(1), getFilename());
      }
      
      }
      adjunctDefn_AST = (AST)currentAST.root;
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_11, _tokenSet_12);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_12);
      } else {
        throw ex;
      }
    }
    returnAST = adjunctDefn_AST;
  }
  
  public final void topLevelTypeDeclarationWithOptionalDocComment(
    AST doc, Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST topLevelTypeDeclarationWithOptionalDocComment_AST = null;
    
    try {      // for error handling
      typeDeclaration(LT(1), "a type declaration for a top-level function");
      astFactory.addASTChild(currentAST, returnAST);
      if ( inputState.guessing==0 ) {
        topLevelTypeDeclarationWithOptionalDocComment_AST = (AST)currentAST.root;
        topLevelTypeDeclarationWithOptionalDocComment_AST = (AST)astFactory.make( (new ASTArray(3)).add(astFactory.create(TOP_LEVEL_TYPE_DECLARATION,"TOP_LEVEL_TYPE_DECLARATION")).add(doc).add(topLevelTypeDeclarationWithOptionalDocComment_AST));
        currentAST.root = topLevelTypeDeclarationWithOptionalDocComment_AST;
        currentAST.child = topLevelTypeDeclarationWithOptionalDocComment_AST!=null &&topLevelTypeDeclarationWithOptionalDocComment_AST.getFirstChild()!=null ?
          topLevelTypeDeclarationWithOptionalDocComment_AST.getFirstChild() : topLevelTypeDeclarationWithOptionalDocComment_AST;
        currentAST.advanceChildToEnd();
      }
      topLevelTypeDeclarationWithOptionalDocComment_AST = (AST)currentAST.root;
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_15, _tokenSet_9);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_9);
      } else {
        throw ex;
      }
    }
    returnAST = topLevelTypeDeclarationWithOptionalDocComment_AST;
  }
  
  public final void instanceDefnWithOptionalDocComment(
    AST doc, Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST instanceDefnWithOptionalDocComment_AST = null;
    Token  node = null;
    AST node_AST = null;
    
    try {      // for error handling
      node = LT(1);
      node_AST = astFactory.create(node);
      astFactory.makeASTRoot(currentAST, node_AST);
      match(LITERAL_instance);
      if ( inputState.guessing==0 ) {
        node_AST.initialize (INSTANCE_DEFN, "instance");
      }
      instanceName(LT(1), "an instance name");
      astFactory.addASTChild(currentAST, returnAST);
      match(LITERAL_where);
      instanceMethodList(LT(1), "a list of instance method definitions");
      astFactory.addASTChild(currentAST, returnAST);
      match(SEMICOLON);
      if ( inputState.guessing==0 ) {
        instanceDefnWithOptionalDocComment_AST = (AST)currentAST.root;
        
        AST firstChild = instanceDefnWithOptionalDocComment_AST.getFirstChild();
        doc.setNextSibling(firstChild);
        instanceDefnWithOptionalDocComment_AST.setFirstChild(doc);
        
      }
      instanceDefnWithOptionalDocComment_AST = (AST)currentAST.root;
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_16, _tokenSet_9);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_9);
      } else {
        throw ex;
      }
    }
    returnAST = instanceDefnWithOptionalDocComment_AST;
  }
  
  public final void topLevelFunctionWithOptionalDocComment(
    AST doc, Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST topLevelFunctionWithOptionalDocComment_AST = null;
    Token  node = null;
    AST node_AST = null;
    Token  semicolonNode = null;
    AST semicolonNode_AST = null;
    
    try {      // for error handling
      accessModifier(LT(1), "an access modifier");
      astFactory.addASTChild(currentAST, returnAST);
      functionName(LT(1), "a top-level function name");
      astFactory.addASTChild(currentAST, returnAST);
      functionParamList(LT(1), "a parameter list for a top-level function");
      astFactory.addASTChild(currentAST, returnAST);
      node = LT(1);
      node_AST = astFactory.create(node);
      astFactory.makeASTRoot(currentAST, node_AST);
      match(EQUALS);
      if ( inputState.guessing==0 ) {
        node_AST.initialize (TOP_LEVEL_FUNCTION_DEFN, "TOP_LEVEL_FUNCTION_DEFN");
      }
      expr(LT(1), "a valid defining expression for a top-level function");
      astFactory.addASTChild(currentAST, returnAST);
      semicolonNode = LT(1);
      semicolonNode_AST = astFactory.create(semicolonNode);
      match(SEMICOLON);
      if ( inputState.guessing==0 ) {
        ((ParseTreeNode)node_AST).addOmittedDelimiter(semicolonNode_AST);
      }
      if ( inputState.guessing==0 ) {
        topLevelFunctionWithOptionalDocComment_AST = (AST)currentAST.root;
        
        AST firstChild = topLevelFunctionWithOptionalDocComment_AST.getFirstChild();
        doc.setNextSibling(firstChild);
        topLevelFunctionWithOptionalDocComment_AST.setFirstChild(doc);
        
      }
      topLevelFunctionWithOptionalDocComment_AST = (AST)currentAST.root;
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_13, _tokenSet_9);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_9);
      } else {
        throw ex;
      }
    }
    returnAST = topLevelFunctionWithOptionalDocComment_AST;
  }
  
  public final void moduleName(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST moduleName_AST = null;
    AST bareCons_AST = null;
    Token  dot = null;
    AST dot_AST = null;
    
    try {      // for error handling
      cons();
      bareCons_AST = (AST)returnAST;
      astFactory.addASTChild(currentAST, returnAST);
      if ( inputState.guessing==0 ) {
        moduleName_AST = (AST)currentAST.root;
        moduleName_AST = (AST)astFactory.make( (new ASTArray(3)).add(astFactory.create(HIERARCHICAL_MODULE_NAME,"HIERARCHICAL_MODULE_NAME")).add(astFactory.create(HIERARCHICAL_MODULE_NAME_EMPTY_QUALIFIER,"HIERARCHICAL_MODULE_NAME_EMPTY_QUALIFIER")).add(bareCons_AST));
        currentAST.root = moduleName_AST;
        currentAST.child = moduleName_AST!=null &&moduleName_AST.getFirstChild()!=null ?
          moduleName_AST.getFirstChild() : moduleName_AST;
        currentAST.advanceChildToEnd();
      }
      {
      _loop32:
      do {
        if ((LA(1)==DOT) && (LA(2)==CONS_ID)) {
          dot = LT(1);
          dot_AST = astFactory.create(dot);
          astFactory.makeASTRoot(currentAST, dot_AST);
          match(DOT);
          if ( inputState.guessing==0 ) {
            dot_AST.initialize(HIERARCHICAL_MODULE_NAME, "HIERARCHICAL_MODULE_NAME");
          }
          cons();
          astFactory.addASTChild(currentAST, returnAST);
        }
        else {
          break _loop32;
        }
        
      } while (true);
      }
      moduleName_AST = (AST)currentAST.root;
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_17, _tokenSet_18);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_18);
      } else {
        throw ex;
      }
    }
    returnAST = moduleName_AST;
  }
  
  public final void importDeclaration(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST importDeclaration_AST = null;
    Token  importNode = null;
    AST importNode_AST = null;
    Token  semicolonNode = null;
    AST semicolonNode_AST = null;
    
    try {      // for error handling
      importNode = LT(1);
      importNode_AST = astFactory.create(importNode);
      astFactory.makeASTRoot(currentAST, importNode_AST);
      match(LITERAL_import);
      moduleName(LT(1), "a valid module name");
      astFactory.addASTChild(currentAST, returnAST);
      maybeUsingClause(LT(1), "a semicolon or a using clause");
      astFactory.addASTChild(currentAST, returnAST);
      semicolonNode = LT(1);
      semicolonNode_AST = astFactory.create(semicolonNode);
      match(SEMICOLON);
      if ( inputState.guessing==0 ) {
        ((ParseTreeNode)importNode_AST).addOmittedDelimiter(semicolonNode_AST);
      }
      importDeclaration_AST = (AST)currentAST.root;
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_19, _tokenSet_7);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_7);
      } else {
        throw ex;
      }
    }
    returnAST = importDeclaration_AST;
  }
  
  public final void maybeUsingClause(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST maybeUsingClause_AST = null;
    
    try {      // for error handling
      {
      switch ( LA(1)) {
      case LITERAL_using:
      {
        usingClause(LT(1), "a semicolon-terminated using clause");
        astFactory.addASTChild(currentAST, returnAST);
        break;
      }
      case SEMICOLON:
      {
        break;
      }
      default:
      {
        throw new NoViableAltException(LT(1), getFilename());
      }
      }
      }
      maybeUsingClause_AST = (AST)currentAST.root;
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_20, _tokenSet_21);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_21);
      } else {
        throw ex;
      }
    }
    returnAST = maybeUsingClause_AST;
  }
  
  public final void usingClause(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST usingClause_AST = null;
    
    try {      // for error handling
      AST tmp17_AST = null;
      tmp17_AST = astFactory.create(LT(1));
      astFactory.makeASTRoot(currentAST, tmp17_AST);
      match(LITERAL_using);
      {
      _loop20:
      do {
        if (((LA(1) >= LITERAL_function && LA(1) <= LITERAL_typeClass))) {
          usingItem(LT(1), "a valid using item starting with 'function =', 'typeConstructor =', 'dataConstructor =', or 'typeClass ='");
          astFactory.addASTChild(currentAST, returnAST);
        }
        else {
          break _loop20;
        }
        
      } while (true);
      }
      usingClause_AST = (AST)currentAST.root;
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_22, _tokenSet_21);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_21);
      } else {
        throw ex;
      }
    }
    returnAST = usingClause_AST;
  }
  
  public final void usingItem(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST usingItem_AST = null;
    
    try {      // for error handling
      switch ( LA(1)) {
      case LITERAL_function:
      {
        AST tmp18_AST = null;
        tmp18_AST = astFactory.create(LT(1));
        astFactory.makeASTRoot(currentAST, tmp18_AST);
        match(LITERAL_function);
        match(EQUALS);
        usingVarList(LT(1), "a semicolon-terminated list of function names");
        astFactory.addASTChild(currentAST, returnAST);
        match(SEMICOLON);
        usingItem_AST = (AST)currentAST.root;
        break;
      }
      case LITERAL_typeConstructor:
      {
        AST tmp21_AST = null;
        tmp21_AST = astFactory.create(LT(1));
        astFactory.makeASTRoot(currentAST, tmp21_AST);
        match(LITERAL_typeConstructor);
        match(EQUALS);
        usingConsList(LT(1), "a semicolon-terminated list of type constructor names");
        astFactory.addASTChild(currentAST, returnAST);
        match(SEMICOLON);
        usingItem_AST = (AST)currentAST.root;
        break;
      }
      case LITERAL_dataConstructor:
      {
        AST tmp24_AST = null;
        tmp24_AST = astFactory.create(LT(1));
        astFactory.makeASTRoot(currentAST, tmp24_AST);
        match(LITERAL_dataConstructor);
        match(EQUALS);
        usingConsList(LT(1), "a semicolon-terminated list of data constructor names");
        astFactory.addASTChild(currentAST, returnAST);
        match(SEMICOLON);
        usingItem_AST = (AST)currentAST.root;
        break;
      }
      case LITERAL_typeClass:
      {
        AST tmp27_AST = null;
        tmp27_AST = astFactory.create(LT(1));
        astFactory.makeASTRoot(currentAST, tmp27_AST);
        match(LITERAL_typeClass);
        match(EQUALS);
        usingConsList(LT(1), "a semicolon-terminated list of type class names");
        astFactory.addASTChild(currentAST, returnAST);
        match(SEMICOLON);
        usingItem_AST = (AST)currentAST.root;
        break;
      }
      default:
      {
        throw new NoViableAltException(LT(1), getFilename());
      }
      }
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_23, _tokenSet_24);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_24);
      } else {
        throw ex;
      }
    }
    returnAST = usingItem_AST;
  }
  
  public final void usingVarList(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST usingVarList_AST = null;
    
    try {      // for error handling
      {
      var();
      astFactory.addASTChild(currentAST, returnAST);
      {
      _loop29:
      do {
        if ((LA(1)==COMMA)) {
          match(COMMA);
          var();
          astFactory.addASTChild(currentAST, returnAST);
        }
        else {
          break _loop29;
        }
        
      } while (true);
      }
      }
      usingVarList_AST = (AST)currentAST.root;
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_15, _tokenSet_21);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_21);
      } else {
        throw ex;
      }
    }
    returnAST = usingVarList_AST;
  }
  
  public final void usingConsList(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST usingConsList_AST = null;
    
    try {      // for error handling
      {
      cons();
      astFactory.addASTChild(currentAST, returnAST);
      {
      _loop25:
      do {
        if ((LA(1)==COMMA)) {
          match(COMMA);
          cons();
          astFactory.addASTChild(currentAST, returnAST);
        }
        else {
          break _loop25;
        }
        
      } while (true);
      }
      }
      usingConsList_AST = (AST)currentAST.root;
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_17, _tokenSet_21);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_21);
      } else {
        throw ex;
      }
    }
    returnAST = usingConsList_AST;
  }
  
  public final void cons() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST cons_AST = null;
    
    try {      // for error handling
      AST tmp32_AST = null;
      tmp32_AST = astFactory.create(LT(1));
      astFactory.addASTChild(currentAST, tmp32_AST);
      match(CONS_ID);
      cons_AST = (AST)currentAST.root;
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        recover(ex,_tokenSet_25);
      } else {
        throw ex;
      }
    }
    returnAST = cons_AST;
  }
  
  public final void var() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST var_AST = null;
    
    try {      // for error handling
      AST tmp33_AST = null;
      tmp33_AST = astFactory.create(LT(1));
      astFactory.addASTChild(currentAST, tmp33_AST);
      match(VAR_ID);
      var_AST = (AST)currentAST.root;
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        recover(ex,_tokenSet_26);
      } else {
        throw ex;
      }
    }
    returnAST = var_AST;
  }
  
  public final void friendDeclaration(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST friendDeclaration_AST = null;
    
    try {      // for error handling
      AST tmp34_AST = null;
      tmp34_AST = astFactory.create(LT(1));
      astFactory.makeASTRoot(currentAST, tmp34_AST);
      match(LITERAL_friend);
      moduleName(LT(1), "a valid module name");
      astFactory.addASTChild(currentAST, returnAST);
      match(SEMICOLON);
      friendDeclaration_AST = (AST)currentAST.root;
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_27, _tokenSet_8);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_8);
      } else {
        throw ex;
      }
    }
    returnAST = friendDeclaration_AST;
  }
  
  public final void outerDefn(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST outerDefn_AST = null;
    AST doc_AST = null;
    
    try {      // for error handling
      optionalDocComment();
      doc_AST = (AST)returnAST;
      {
      switch ( LA(1)) {
      case LITERAL_instance:
      {
        instanceDefnWithOptionalDocComment(doc_AST, LT(1), "an instance definition");
        astFactory.addASTChild(currentAST, returnAST);
        break;
      }
      case LITERAL_primitive:
      {
        primitiveFunctionDeclarationWithOptionalDocComment(doc_AST, LT(1), "a primitive function declaration");
        astFactory.addASTChild(currentAST, returnAST);
        break;
      }
      case LITERAL_foreign:
      {
        foreignFunctionDeclarationWithOptionalDocComment(doc_AST, LT(1), "a foreign function declaration");
        astFactory.addASTChild(currentAST, returnAST);
        break;
      }
      default:
        if ((LA(1)==VAR_ID) && (LA(2)==COLONCOLON)) {
          topLevelTypeDeclarationWithOptionalDocComment(doc_AST, LT(1), "a top-level type declaration");
          astFactory.addASTChild(currentAST, returnAST);
        }
        else if ((_tokenSet_13.member(LA(1))) && (_tokenSet_14.member(LA(2)))) {
          topLevelFunctionWithOptionalDocComment(doc_AST, LT(1), "a top-level function definition");
          astFactory.addASTChild(currentAST, returnAST);
        }
        else if ((LA(1)==LITERAL_data) && (LA(2)==LITERAL_foreign)) {
          foreignDataDeclarationWithOptionalDocComment(doc_AST, LT(1), "a foreign data declaration");
          astFactory.addASTChild(currentAST, returnAST);
        }
        else if ((LA(1)==LITERAL_data) && (_tokenSet_28.member(LA(2)))) {
          dataDeclarationWithOptionalDocComment(doc_AST, LT(1), "a data declaration");
          astFactory.addASTChild(currentAST, returnAST);
        }
        else {
          boolean synPredMatched43 = false;
          if (((_tokenSet_29.member(LA(1))) && (_tokenSet_30.member(LA(2))))) {
            int _m43 = mark();
            synPredMatched43 = true;
            inputState.guessing++;
            try {
              {
              accessModifier(null,null);
              match(LITERAL_class);
              }
            }
            catch (RecognitionException pe) {
              synPredMatched43 = false;
            }
            rewind(_m43);
inputState.guessing--;
          }
          if ( synPredMatched43 ) {
            typeClassDefnWithOptionalDocComment(doc_AST, LT(1), "a class definition");
            astFactory.addASTChild(currentAST, returnAST);
          }
        else {
          throw new NoViableAltException(LT(1), getFilename());
        }
        }}
        }
        outerDefn_AST = (AST)currentAST.root;
      }
      catch (NoViableAltException ex) {
        if (inputState.guessing==0) {
          reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_10, _tokenSet_9);
        } else {
          throw ex;
        }
      }
      catch (RecognitionException ex) {
        if (inputState.guessing==0) {
          reportError(ex, _tokenSet_9);
        } else {
          throw ex;
        }
      }
      returnAST = outerDefn_AST;
    }
    
  public final void foreignDataDeclarationWithOptionalDocComment(
    AST doc, Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST foreignDataDeclarationWithOptionalDocComment_AST = null;
    Token  node = null;
    AST node_AST = null;
    
    try {      // for error handling
      node = LT(1);
      node_AST = astFactory.create(node);
      astFactory.makeASTRoot(currentAST, node_AST);
      match(LITERAL_data);
      if ( inputState.guessing==0 ) {
        node_AST.initialize (FOREIGN_DATA_DECLARATION, "foreignData");
      }
      match(LITERAL_foreign);
      match(LITERAL_unsafe);
      match(LITERAL_import);
      match(LITERAL_jvm);
      accessModifier(LT(1), "an access modifier");
      astFactory.addASTChild(currentAST, returnAST);
      externalName();
      astFactory.addASTChild(currentAST, returnAST);
      accessModifier(LT(1), "an access modifier");
      astFactory.addASTChild(currentAST, returnAST);
      cons();
      astFactory.addASTChild(currentAST, returnAST);
      maybeDerivingClause(LT(1), "a deriving clause or a semicolon");
      astFactory.addASTChild(currentAST, returnAST);
      match(SEMICOLON);
      if ( inputState.guessing==0 ) {
        foreignDataDeclarationWithOptionalDocComment_AST = (AST)currentAST.root;
        
        AST firstChild = foreignDataDeclarationWithOptionalDocComment_AST.getFirstChild();
        doc.setNextSibling(firstChild);
        foreignDataDeclarationWithOptionalDocComment_AST.setFirstChild(doc);
        
      }
      foreignDataDeclarationWithOptionalDocComment_AST = (AST)currentAST.root;
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_31, _tokenSet_9);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_9);
      } else {
        throw ex;
      }
    }
    returnAST = foreignDataDeclarationWithOptionalDocComment_AST;
  }
  
  public final void dataDeclarationWithOptionalDocComment(
    AST doc, Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST dataDeclarationWithOptionalDocComment_AST = null;
    Token  node = null;
    AST node_AST = null;
    
    try {      // for error handling
      node = LT(1);
      node_AST = astFactory.create(node);
      astFactory.makeASTRoot(currentAST, node_AST);
      match(LITERAL_data);
      if ( inputState.guessing==0 ) {
        node_AST.initialize (DATA_DECLARATION, "data");
      }
      simpleType(LT(1), "a type constructor");
      astFactory.addASTChild(currentAST, returnAST);
      match(EQUALS);
      dataDeclarationBody(LT(1), "a bar-separated list of data constructor definitions");
      astFactory.addASTChild(currentAST, returnAST);
      match(SEMICOLON);
      if ( inputState.guessing==0 ) {
        dataDeclarationWithOptionalDocComment_AST = (AST)currentAST.root;
        
        AST firstChild = dataDeclarationWithOptionalDocComment_AST.getFirstChild();
        doc.setNextSibling(firstChild);
        dataDeclarationWithOptionalDocComment_AST.setFirstChild(doc);
        
      }
      dataDeclarationWithOptionalDocComment_AST = (AST)currentAST.root;
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_31, _tokenSet_9);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_9);
      } else {
        throw ex;
      }
    }
    returnAST = dataDeclarationWithOptionalDocComment_AST;
  }
  
  public final void accessModifier(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST accessModifier_AST = null;
    
    try {      // for error handling
      {
      switch ( LA(1)) {
      case LITERAL_public:
      {
        AST tmp43_AST = null;
        tmp43_AST = astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp43_AST);
        match(LITERAL_public);
        break;
      }
      case LITERAL_private:
      {
        AST tmp44_AST = null;
        tmp44_AST = astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp44_AST);
        match(LITERAL_private);
        break;
      }
      case LITERAL_protected:
      {
        AST tmp45_AST = null;
        tmp45_AST = astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp45_AST);
        match(LITERAL_protected);
        break;
      }
      case CONS_ID:
      case VAR_ID:
      case LITERAL_class:
      case STRING_LITERAL:
      {
        break;
      }
      default:
      {
        throw new NoViableAltException(LT(1), getFilename());
      }
      }
      }
      if ( inputState.guessing==0 ) {
        accessModifier_AST = (AST)currentAST.root;
        accessModifier_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(ACCESS_MODIFIER,"ACCESS_MODIFIER")).add(accessModifier_AST));
        currentAST.root = accessModifier_AST;
        currentAST.child = accessModifier_AST!=null &&accessModifier_AST.getFirstChild()!=null ?
          accessModifier_AST.getFirstChild() : accessModifier_AST;
        currentAST.advanceChildToEnd();
      }
      accessModifier_AST = (AST)currentAST.root;
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_32, _tokenSet_33);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_33);
      } else {
        throw ex;
      }
    }
    returnAST = accessModifier_AST;
  }
  
  public final void typeClassDefnWithOptionalDocComment(
    AST doc, Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST typeClassDefnWithOptionalDocComment_AST = null;
    Token  node = null;
    AST node_AST = null;
    
    try {      // for error handling
      accessModifier(LT(1), "an access modifier");
      astFactory.addASTChild(currentAST, returnAST);
      node = LT(1);
      node_AST = astFactory.create(node);
      astFactory.makeASTRoot(currentAST, node_AST);
      match(LITERAL_class);
      if ( inputState.guessing==0 ) {
        node_AST.initialize (TYPE_CLASS_DEFN, "class");
      }
      classContextList(LT(1), "a class context");
      astFactory.addASTChild(currentAST, returnAST);
      typeClassName(LT(1), "a type class name");
      astFactory.addASTChild(currentAST, returnAST);
      typeClassParam(LT(1), "a type variable");
      astFactory.addASTChild(currentAST, returnAST);
      match(LITERAL_where);
      classMethodList(LT(1), "a list of class method definitions");
      astFactory.addASTChild(currentAST, returnAST);
      match(SEMICOLON);
      if ( inputState.guessing==0 ) {
        typeClassDefnWithOptionalDocComment_AST = (AST)currentAST.root;
        
        AST firstChild = typeClassDefnWithOptionalDocComment_AST.getFirstChild();
        doc.setNextSibling(firstChild);
        typeClassDefnWithOptionalDocComment_AST.setFirstChild(doc);
        
      }
      typeClassDefnWithOptionalDocComment_AST = (AST)currentAST.root;
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_29, _tokenSet_9);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_9);
      } else {
        throw ex;
      }
    }
    returnAST = typeClassDefnWithOptionalDocComment_AST;
  }
  
  public final void primitiveFunctionDeclarationWithOptionalDocComment(
    AST doc, Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST primitiveFunctionDeclarationWithOptionalDocComment_AST = null;
    Token  node = null;
    AST node_AST = null;
    
    try {      // for error handling
      node = LT(1);
      node_AST = astFactory.create(node);
      astFactory.makeASTRoot(currentAST, node_AST);
      match(LITERAL_primitive);
      if ( inputState.guessing==0 ) {
        node_AST.initialize (PRIMITIVE_FUNCTION_DECLARATION, "primitiveFunc");
      }
      accessModifier(LT(1), "an access modifier");
      astFactory.addASTChild(currentAST, returnAST);
      typeDeclaration(LT(1), "a type declaration for a primitive function");
      astFactory.addASTChild(currentAST, returnAST);
      if ( inputState.guessing==0 ) {
        primitiveFunctionDeclarationWithOptionalDocComment_AST = (AST)currentAST.root;
        
        AST firstChild = primitiveFunctionDeclarationWithOptionalDocComment_AST.getFirstChild();
        doc.setNextSibling(firstChild);
        primitiveFunctionDeclarationWithOptionalDocComment_AST.setFirstChild(doc);
        
      }
      primitiveFunctionDeclarationWithOptionalDocComment_AST = (AST)currentAST.root;
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_34, _tokenSet_9);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_9);
      } else {
        throw ex;
      }
    }
    returnAST = primitiveFunctionDeclarationWithOptionalDocComment_AST;
  }
  
  public final void foreignFunctionDeclarationWithOptionalDocComment(
    AST doc, Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST foreignFunctionDeclarationWithOptionalDocComment_AST = null;
    Token  node = null;
    AST node_AST = null;
    
    try {      // for error handling
      node = LT(1);
      node_AST = astFactory.create(node);
      astFactory.makeASTRoot(currentAST, node_AST);
      match(LITERAL_foreign);
      if ( inputState.guessing==0 ) {
        node_AST.initialize (FOREIGN_FUNCTION_DECLARATION, "foreignFunction");
      }
      match(LITERAL_unsafe);
      match(LITERAL_import);
      match(LITERAL_jvm);
      externalName();
      astFactory.addASTChild(currentAST, returnAST);
      accessModifier(LT(1), "an access modifier");
      astFactory.addASTChild(currentAST, returnAST);
      typeDeclaration(LT(1), "a type declaration for a foreign function");
      astFactory.addASTChild(currentAST, returnAST);
      if ( inputState.guessing==0 ) {
        foreignFunctionDeclarationWithOptionalDocComment_AST = (AST)currentAST.root;
        
        AST firstChild = foreignFunctionDeclarationWithOptionalDocComment_AST.getFirstChild();
        doc.setNextSibling(firstChild);
        foreignFunctionDeclarationWithOptionalDocComment_AST.setFirstChild(doc);
        
      }
      foreignFunctionDeclarationWithOptionalDocComment_AST = (AST)currentAST.root;
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_35, _tokenSet_9);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_9);
      } else {
        throw ex;
      }
    }
    returnAST = foreignFunctionDeclarationWithOptionalDocComment_AST;
  }
  
  public final void topLevelTypeDeclaration(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST topLevelTypeDeclaration_AST = null;
    AST doc_AST = null;
    
    try {      // for error handling
      optionalDocComment();
      doc_AST = (AST)returnAST;
      topLevelTypeDeclarationWithOptionalDocComment(doc_AST, LT(1), "a top-level type declaration");
      astFactory.addASTChild(currentAST, returnAST);
      topLevelTypeDeclaration_AST = (AST)currentAST.root;
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_36, _tokenSet_0);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_0);
      } else {
        throw ex;
      }
    }
    returnAST = topLevelTypeDeclaration_AST;
  }
  
  public final void typeDeclaration(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST typeDeclaration_AST = null;
    Token  node = null;
    AST node_AST = null;
    
    try {      // for error handling
      var();
      astFactory.addASTChild(currentAST, returnAST);
      node = LT(1);
      node_AST = astFactory.create(node);
      astFactory.makeASTRoot(currentAST, node_AST);
      match(COLONCOLON);
      if ( inputState.guessing==0 ) {
        node_AST.initialize (TYPE_DECLARATION, "::");
      }
      typeSignature(LT(1), "a valid type signature for a variable");
      astFactory.addASTChild(currentAST, returnAST);
      match(SEMICOLON);
      typeDeclaration_AST = (AST)currentAST.root;
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_15, _tokenSet_37);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_37);
      } else {
        throw ex;
      }
    }
    returnAST = typeDeclaration_AST;
  }
  
  public final void letDefnTypeDeclarationWithOptionalDocComment(
    AST doc, Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST letDefnTypeDeclarationWithOptionalDocComment_AST = null;
    
    try {      // for error handling
      typeDeclaration(LT(1), "a type declaration for a let definition");
      astFactory.addASTChild(currentAST, returnAST);
      if ( inputState.guessing==0 ) {
        letDefnTypeDeclarationWithOptionalDocComment_AST = (AST)currentAST.root;
        letDefnTypeDeclarationWithOptionalDocComment_AST = (AST)astFactory.make( (new ASTArray(3)).add(astFactory.create(LET_DEFN_TYPE_DECLARATION,"LET_DEFN_TYPE_DECLARATION")).add(doc).add(letDefnTypeDeclarationWithOptionalDocComment_AST));
        currentAST.root = letDefnTypeDeclarationWithOptionalDocComment_AST;
        currentAST.child = letDefnTypeDeclarationWithOptionalDocComment_AST!=null &&letDefnTypeDeclarationWithOptionalDocComment_AST.getFirstChild()!=null ?
          letDefnTypeDeclarationWithOptionalDocComment_AST.getFirstChild() : letDefnTypeDeclarationWithOptionalDocComment_AST;
        currentAST.advanceChildToEnd();
      }
      letDefnTypeDeclarationWithOptionalDocComment_AST = (AST)currentAST.root;
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_15, _tokenSet_38);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_38);
      } else {
        throw ex;
      }
    }
    returnAST = letDefnTypeDeclarationWithOptionalDocComment_AST;
  }
  
  public final void typeContextList(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST typeContextList_AST = null;
    Token  openParenNode = null;
    AST openParenNode_AST = null;
    Token  closeParenNode = null;
    AST closeParenNode_AST = null;
    
    try {      // for error handling
      boolean synPredMatched51 = false;
      if (((LA(1)==CONS_ID||LA(1)==VAR_ID) && (_tokenSet_39.member(LA(2))))) {
        int _m51 = mark();
        synPredMatched51 = true;
        inputState.guessing++;
        try {
          {
          typeContext(null,null);
          match(IMPLIES);
          }
        }
        catch (RecognitionException pe) {
          synPredMatched51 = false;
        }
        rewind(_m51);
inputState.guessing--;
      }
      if ( synPredMatched51 ) {
        typeContext(LT(1), "a type context");
        astFactory.addASTChild(currentAST, returnAST);
        match(IMPLIES);
        if ( inputState.guessing==0 ) {
          typeContextList_AST = (AST)currentAST.root;
          typeContextList_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(TYPE_CONTEXT_SINGLETON,"TYPE_CONTEXT_SINGLETON")).add(typeContextList_AST));
          currentAST.root = typeContextList_AST;
          currentAST.child = typeContextList_AST!=null &&typeContextList_AST.getFirstChild()!=null ?
            typeContextList_AST.getFirstChild() : typeContextList_AST;
          currentAST.advanceChildToEnd();
        }
        typeContextList_AST = (AST)currentAST.root;
      }
      else {
        boolean synPredMatched53 = false;
        if (((LA(1)==OPEN_PAREN) && (_tokenSet_40.member(LA(2))))) {
          int _m53 = mark();
          synPredMatched53 = true;
          inputState.guessing++;
          try {
            {
            match(OPEN_PAREN);
            typeContextZeroOrMore(null, null);
            match(CLOSE_PAREN);
            match(IMPLIES);
            }
          }
          catch (RecognitionException pe) {
            synPredMatched53 = false;
          }
          rewind(_m53);
inputState.guessing--;
        }
        if ( synPredMatched53 ) {
          openParenNode = LT(1);
          openParenNode_AST = astFactory.create(openParenNode);
          astFactory.makeASTRoot(currentAST, openParenNode_AST);
          match(OPEN_PAREN);
          if ( inputState.guessing==0 ) {
            openParenNode_AST.initialize (TYPE_CONTEXT_LIST, "TYPE_CONTEXT_LIST");
          }
          typeContextZeroOrMore(LT(1), "a comma-separated list of type contexts");
          astFactory.addASTChild(currentAST, returnAST);
          closeParenNode = LT(1);
          closeParenNode_AST = astFactory.create(closeParenNode);
          match(CLOSE_PAREN);
          if ( inputState.guessing==0 ) {
            ((ParseTreeNode)openParenNode_AST).addOmittedDelimiter(closeParenNode_AST);
          }
          match(IMPLIES);
          typeContextList_AST = (AST)currentAST.root;
        }
        else if ((_tokenSet_3.member(LA(1))) && (_tokenSet_41.member(LA(2)))) {
          if ( inputState.guessing==0 ) {
            typeContextList_AST = (AST)currentAST.root;
            typeContextList_AST = (AST)astFactory.make( (new ASTArray(1)).add(astFactory.create(TYPE_CONTEXT_NOTHING,"TYPE_CONTEXT_NOTHING")));
            currentAST.root = typeContextList_AST;
            currentAST.child = typeContextList_AST!=null &&typeContextList_AST.getFirstChild()!=null ?
              typeContextList_AST.getFirstChild() : typeContextList_AST;
            currentAST.advanceChildToEnd();
          }
          typeContextList_AST = (AST)currentAST.root;
        }
        else {
          throw new NoViableAltException(LT(1), getFilename());
        }
        }
      }
      catch (NoViableAltException ex) {
        if (inputState.guessing==0) {
          reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_3, _tokenSet_3);
        } else {
          throw ex;
        }
      }
      catch (RecognitionException ex) {
        if (inputState.guessing==0) {
          reportError(ex, _tokenSet_3);
        } else {
          throw ex;
        }
      }
      returnAST = typeContextList_AST;
    }
    
  public final void type(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST type_AST = null;
    Token  node = null;
    AST node_AST = null;
    
    try {      // for error handling
      typeApplication(LT(1), "a type application");
      astFactory.addASTChild(currentAST, returnAST);
      {
      switch ( LA(1)) {
      case RARROW:
      {
        node = LT(1);
        node_AST = astFactory.create(node);
        astFactory.makeASTRoot(currentAST, node_AST);
        match(RARROW);
        if ( inputState.guessing==0 ) {
          node_AST.initialize (FUNCTION_TYPE_CONSTRUCTOR, "->");
        }
        type(LT(1), "a type application");
        astFactory.addASTChild(currentAST, returnAST);
        break;
      }
      case EOF:
      case COMMA:
      case SEMICOLON:
      case CLOSE_PAREN:
      case CLOSE_BRACKET:
      case CLOSE_BRACE:
      case BAR:
      case LITERAL_default:
      case LITERAL_then:
      case LITERAL_else:
      case LITERAL_of:
      {
        break;
      }
      default:
      {
        throw new NoViableAltException(LT(1), getFilename());
      }
      }
      }
      type_AST = (AST)currentAST.root;
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_3, _tokenSet_4);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_4);
      } else {
        throw ex;
      }
    }
    returnAST = type_AST;
  }
  
  public final void typeContext(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST typeContext_AST = null;
    
    try {      // for error handling
      switch ( LA(1)) {
      case CONS_ID:
      {
        classContext(LT(1), "a class context");
        astFactory.addASTChild(currentAST, returnAST);
        typeContext_AST = (AST)currentAST.root;
        break;
      }
      case VAR_ID:
      {
        lacksFieldContext(LT(1), "a lacks constraint");
        astFactory.addASTChild(currentAST, returnAST);
        typeContext_AST = (AST)currentAST.root;
        break;
      }
      default:
      {
        throw new NoViableAltException(LT(1), getFilename());
      }
      }
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_42, _tokenSet_43);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_43);
      } else {
        throw ex;
      }
    }
    returnAST = typeContext_AST;
  }
  
  public final void typeContextZeroOrMore(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST typeContextZeroOrMore_AST = null;
    
    try {      // for error handling
      {
      switch ( LA(1)) {
      case CONS_ID:
      case VAR_ID:
      {
        typeContext(LT(1), "a type context");
        astFactory.addASTChild(currentAST, returnAST);
        {
        _loop62:
        do {
          if ((LA(1)==COMMA)) {
            match(COMMA);
            typeContext(LT(1), "a type context");
            astFactory.addASTChild(currentAST, returnAST);
          }
          else {
            break _loop62;
          }
          
        } while (true);
        }
        break;
      }
      case CLOSE_PAREN:
      {
        break;
      }
      default:
      {
        throw new NoViableAltException(LT(1), getFilename());
      }
      }
      }
      typeContextZeroOrMore_AST = (AST)currentAST.root;
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_40, _tokenSet_44);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_44);
      } else {
        throw ex;
      }
    }
    returnAST = typeContextZeroOrMore_AST;
  }
  
  public final void classContextList(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST classContextList_AST = null;
    Token  openParenNode = null;
    AST openParenNode_AST = null;
    Token  closeParenNode = null;
    AST closeParenNode_AST = null;
    
    try {      // for error handling
      boolean synPredMatched56 = false;
      if (((LA(1)==CONS_ID) && (LA(2)==VAR_ID||LA(2)==DOT))) {
        int _m56 = mark();
        synPredMatched56 = true;
        inputState.guessing++;
        try {
          {
          classContext(null,null);
          match(IMPLIES);
          }
        }
        catch (RecognitionException pe) {
          synPredMatched56 = false;
        }
        rewind(_m56);
inputState.guessing--;
      }
      if ( synPredMatched56 ) {
        classContext(LT(1), "a class context");
        astFactory.addASTChild(currentAST, returnAST);
        match(IMPLIES);
        if ( inputState.guessing==0 ) {
          classContextList_AST = (AST)currentAST.root;
          classContextList_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(CLASS_CONTEXT_SINGLETON,"CLASS_CONTEXT_SINGLETON")).add(classContextList_AST));
          currentAST.root = classContextList_AST;
          currentAST.child = classContextList_AST!=null &&classContextList_AST.getFirstChild()!=null ?
            classContextList_AST.getFirstChild() : classContextList_AST;
          currentAST.advanceChildToEnd();
        }
        classContextList_AST = (AST)currentAST.root;
      }
      else {
        boolean synPredMatched58 = false;
        if (((LA(1)==OPEN_PAREN))) {
          int _m58 = mark();
          synPredMatched58 = true;
          inputState.guessing++;
          try {
            {
            match(OPEN_PAREN);
            classContextZeroOrMore(null, null);
            match(CLOSE_PAREN);
            match(IMPLIES);
            }
          }
          catch (RecognitionException pe) {
            synPredMatched58 = false;
          }
          rewind(_m58);
inputState.guessing--;
        }
        if ( synPredMatched58 ) {
          openParenNode = LT(1);
          openParenNode_AST = astFactory.create(openParenNode);
          astFactory.makeASTRoot(currentAST, openParenNode_AST);
          match(OPEN_PAREN);
          if ( inputState.guessing==0 ) {
            openParenNode_AST.initialize (CLASS_CONTEXT_LIST, "CLASS_CONTEXT_LIST");
          }
          classContextZeroOrMore(LT(1), "a comma-separated list of class contexts");
          astFactory.addASTChild(currentAST, returnAST);
          closeParenNode = LT(1);
          closeParenNode_AST = astFactory.create(closeParenNode);
          match(CLOSE_PAREN);
          if ( inputState.guessing==0 ) {
            ((ParseTreeNode)openParenNode_AST).addOmittedDelimiter(closeParenNode_AST);
          }
          match(IMPLIES);
          classContextList_AST = (AST)currentAST.root;
        }
        else if ((LA(1)==CONS_ID) && (_tokenSet_45.member(LA(2)))) {
          if ( inputState.guessing==0 ) {
            classContextList_AST = (AST)currentAST.root;
            classContextList_AST = (AST)astFactory.make( (new ASTArray(1)).add(astFactory.create(CLASS_CONTEXT_NOTHING,"CLASS_CONTEXT_NOTHING")));
            currentAST.root = classContextList_AST;
            currentAST.child = classContextList_AST!=null &&classContextList_AST.getFirstChild()!=null ?
              classContextList_AST.getFirstChild() : classContextList_AST;
            currentAST.advanceChildToEnd();
          }
          classContextList_AST = (AST)currentAST.root;
        }
        else {
          throw new NoViableAltException(LT(1), getFilename());
        }
        }
      }
      catch (NoViableAltException ex) {
        if (inputState.guessing==0) {
          reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_46, _tokenSet_17);
        } else {
          throw ex;
        }
      }
      catch (RecognitionException ex) {
        if (inputState.guessing==0) {
          reportError(ex, _tokenSet_17);
        } else {
          throw ex;
        }
      }
      returnAST = classContextList_AST;
    }
    
  public final void classContext(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST classContext_AST = null;
    
    try {      // for error handling
      qualifiedCons(LT(1), "a class name");
      astFactory.addASTChild(currentAST, returnAST);
      var();
      astFactory.addASTChild(currentAST, returnAST);
      if ( inputState.guessing==0 ) {
        classContext_AST = (AST)currentAST.root;
        classContext_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(CLASS_CONTEXT,"CLASS_CONTEXT")).add(classContext_AST));
        currentAST.root = classContext_AST;
        currentAST.child = classContext_AST!=null &&classContext_AST.getFirstChild()!=null ?
          classContext_AST.getFirstChild() : classContext_AST;
        currentAST.advanceChildToEnd();
      }
      classContext_AST = (AST)currentAST.root;
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_17, _tokenSet_43);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_43);
      } else {
        throw ex;
      }
    }
    returnAST = classContext_AST;
  }
  
  public final void classContextZeroOrMore(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST classContextZeroOrMore_AST = null;
    
    try {      // for error handling
      {
      switch ( LA(1)) {
      case CONS_ID:
      {
        classContext(LT(1), "a class context");
        astFactory.addASTChild(currentAST, returnAST);
        {
        _loop66:
        do {
          if ((LA(1)==COMMA)) {
            match(COMMA);
            classContext(LT(1), "a class context");
            astFactory.addASTChild(currentAST, returnAST);
          }
          else {
            break _loop66;
          }
          
        } while (true);
        }
        break;
      }
      case CLOSE_PAREN:
      {
        break;
      }
      default:
      {
        throw new NoViableAltException(LT(1), getFilename());
      }
      }
      }
      classContextZeroOrMore_AST = (AST)currentAST.root;
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_47, _tokenSet_44);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_44);
      } else {
        throw ex;
      }
    }
    returnAST = classContextZeroOrMore_AST;
  }
  
  public final void lacksFieldContext(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST lacksFieldContext_AST = null;
    Token  backslash = null;
    AST backslash_AST = null;
    
    try {      // for error handling
      var();
      astFactory.addASTChild(currentAST, returnAST);
      backslash = LT(1);
      backslash_AST = astFactory.create(backslash);
      astFactory.makeASTRoot(currentAST, backslash_AST);
      match(BACKSLASH);
      if ( inputState.guessing==0 ) {
        backslash_AST.initialize (LACKS_FIELD_CONTEXT, "LACKS_FIELD_CONTEXT");
      }
      fieldName(LT(1), "a valid record-field name");
      astFactory.addASTChild(currentAST, returnAST);
      lacksFieldContext_AST = (AST)currentAST.root;
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_15, _tokenSet_43);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_43);
      } else {
        throw ex;
      }
    }
    returnAST = lacksFieldContext_AST;
  }
  
  public final void qualifiedCons(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST qualifiedCons_AST = null;
    
    try {      // for error handling
      boolean synPredMatched231 = false;
      if (((LA(1)==CONS_ID) && (LA(2)==DOT))) {
        int _m231 = mark();
        synPredMatched231 = true;
        inputState.guessing++;
        try {
          {
          cons();
          match(DOT);
          }
        }
        catch (RecognitionException pe) {
          synPredMatched231 = false;
        }
        rewind(_m231);
inputState.guessing--;
      }
      if ( synPredMatched231 ) {
        qualifiedCons_qualified(contextToken, paraphrase);
        astFactory.addASTChild(currentAST, returnAST);
        qualifiedCons_AST = (AST)currentAST.root;
      }
      else if ((LA(1)==CONS_ID) && (_tokenSet_48.member(LA(2)))) {
        qualifiedCons_unqualified(contextToken, paraphrase);
        astFactory.addASTChild(currentAST, returnAST);
        qualifiedCons_AST = (AST)currentAST.root;
      }
      else {
        throw new NoViableAltException(LT(1), getFilename());
      }
      
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_17, _tokenSet_48);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_48);
      } else {
        throw ex;
      }
    }
    returnAST = qualifiedCons_AST;
  }
  
  public final void fieldName(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST fieldName_AST = null;
    
    try {      // for error handling
      switch ( LA(1)) {
      case VAR_ID:
      {
        var();
        astFactory.addASTChild(currentAST, returnAST);
        fieldName_AST = (AST)currentAST.root;
        break;
      }
      case ORDINAL_FIELD_NAME:
      {
        AST tmp58_AST = null;
        tmp58_AST = astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp58_AST);
        match(ORDINAL_FIELD_NAME);
        fieldName_AST = (AST)currentAST.root;
        break;
      }
      default:
      {
        throw new NoViableAltException(LT(1), getFilename());
      }
      }
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_49, _tokenSet_50);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_50);
      } else {
        throw ex;
      }
    }
    returnAST = fieldName_AST;
  }
  
  public final void typeApplication(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST typeApplication_AST = null;
    
    try {      // for error handling
      {
      int _cnt74=0;
      _loop74:
      do {
        if ((_tokenSet_3.member(LA(1)))) {
          atomicType(LT(1), "an atomic type");
          astFactory.addASTChild(currentAST, returnAST);
        }
        else {
          if ( _cnt74>=1 ) { break _loop74; } else {throw new NoViableAltException(LT(1), getFilename());}
        }
        
        _cnt74++;
      } while (true);
      }
      if ( inputState.guessing==0 ) {
        typeApplication_AST = (AST)currentAST.root;
        typeApplication_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(TYPE_APPLICATION,"@")).add(typeApplication_AST));
        currentAST.root = typeApplication_AST;
        currentAST.child = typeApplication_AST!=null &&typeApplication_AST.getFirstChild()!=null ?
          typeApplication_AST.getFirstChild() : typeApplication_AST;
        currentAST.advanceChildToEnd();
      }
      typeApplication_AST = (AST)currentAST.root;
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_3, _tokenSet_51);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_51);
      } else {
        throw ex;
      }
    }
    returnAST = typeApplication_AST;
  }
  
  public final void atomicType(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST atomicType_AST = null;
    Token  openParenNode = null;
    AST openParenNode_AST = null;
    Token  closeParenNode = null;
    AST closeParenNode_AST = null;
    Token  openBracketNode = null;
    AST openBracketNode_AST = null;
    Token  closeBracketNode = null;
    AST closeBracketNode_AST = null;
    
    try {      // for error handling
      switch ( LA(1)) {
      case CONS_ID:
      {
        qualifiedCons(LT(1), "a type constructor");
        astFactory.addASTChild(currentAST, returnAST);
        atomicType_AST = (AST)currentAST.root;
        break;
      }
      case VAR_ID:
      {
        var();
        astFactory.addASTChild(currentAST, returnAST);
        atomicType_AST = (AST)currentAST.root;
        break;
      }
      case OPEN_PAREN:
      {
        openParenNode = LT(1);
        openParenNode_AST = astFactory.create(openParenNode);
        astFactory.makeASTRoot(currentAST, openParenNode_AST);
        match(OPEN_PAREN);
        if ( inputState.guessing==0 ) {
          openParenNode_AST.initialize (TUPLE_TYPE_CONSTRUCTOR, "Tuple");
        }
        typeListZeroOrMore(LT(1), "a comma-separated list of component types");
        astFactory.addASTChild(currentAST, returnAST);
        closeParenNode = LT(1);
        closeParenNode_AST = astFactory.create(closeParenNode);
        match(CLOSE_PAREN);
        if ( inputState.guessing==0 ) {
          ((ParseTreeNode)openParenNode_AST).addOmittedDelimiter(closeParenNode_AST);
        }
        atomicType_AST = (AST)currentAST.root;
        break;
      }
      case OPEN_BRACKET:
      {
        openBracketNode = LT(1);
        openBracketNode_AST = astFactory.create(openBracketNode);
        astFactory.makeASTRoot(currentAST, openBracketNode_AST);
        match(OPEN_BRACKET);
        if ( inputState.guessing==0 ) {
          openBracketNode_AST.initialize (LIST_TYPE_CONSTRUCTOR, "List");
        }
        type(LT(1), "an element type");
        astFactory.addASTChild(currentAST, returnAST);
        closeBracketNode = LT(1);
        closeBracketNode_AST = astFactory.create(closeBracketNode);
        match(CLOSE_BRACKET);
        if ( inputState.guessing==0 ) {
          ((ParseTreeNode)openBracketNode_AST).addOmittedDelimiter(closeBracketNode_AST);
        }
        atomicType_AST = (AST)currentAST.root;
        break;
      }
      case OPEN_BRACE:
      {
        recordType(LT(1), "a record type");
        astFactory.addASTChild(currentAST, returnAST);
        atomicType_AST = (AST)currentAST.root;
        break;
      }
      default:
      {
        throw new NoViableAltException(LT(1), getFilename());
      }
      }
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_3, _tokenSet_52);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_52);
      } else {
        throw ex;
      }
    }
    returnAST = atomicType_AST;
  }
  
  public final void typeListZeroOrMore(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST typeListZeroOrMore_AST = null;
    
    try {      // for error handling
      {
      switch ( LA(1)) {
      case CONS_ID:
      case VAR_ID:
      case OPEN_PAREN:
      case OPEN_BRACKET:
      case OPEN_BRACE:
      {
        type(contextToken, paraphrase);
        astFactory.addASTChild(currentAST, returnAST);
        {
        _loop92:
        do {
          if ((LA(1)==COMMA)) {
            match(COMMA);
            type(contextToken, paraphrase);
            astFactory.addASTChild(currentAST, returnAST);
          }
          else {
            break _loop92;
          }
          
        } while (true);
        }
        break;
      }
      case CLOSE_PAREN:
      {
        break;
      }
      default:
      {
        throw new NoViableAltException(LT(1), getFilename());
      }
      }
      }
      typeListZeroOrMore_AST = (AST)currentAST.root;
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_53, _tokenSet_44);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_44);
      } else {
        throw ex;
      }
    }
    returnAST = typeListZeroOrMore_AST;
  }
  
  public final void recordType(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST recordType_AST = null;
    Token  openBraceNode = null;
    AST openBraceNode_AST = null;
    Token  closeBraceNode = null;
    AST closeBraceNode_AST = null;
    
    try {      // for error handling
      openBraceNode = LT(1);
      openBraceNode_AST = astFactory.create(openBraceNode);
      astFactory.makeASTRoot(currentAST, openBraceNode_AST);
      match(OPEN_BRACE);
      if ( inputState.guessing==0 ) {
        openBraceNode_AST.initialize (RECORD_TYPE_CONSTRUCTOR, "Record");
      }
      recordVar(LT(1), "a base-record type variable");
      astFactory.addASTChild(currentAST, returnAST);
      fieldTypeAssignmentList(LT(1), "a comma-separated list of field type assignments");
      astFactory.addASTChild(currentAST, returnAST);
      closeBraceNode = LT(1);
      closeBraceNode_AST = astFactory.create(closeBraceNode);
      match(CLOSE_BRACE);
      if ( inputState.guessing==0 ) {
        ((ParseTreeNode)openBraceNode_AST).addOmittedDelimiter(closeBraceNode_AST);
      }
      recordType_AST = (AST)currentAST.root;
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_54, _tokenSet_52);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_52);
      } else {
        throw ex;
      }
    }
    returnAST = recordType_AST;
  }
  
  public final void recordVar(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST recordVar_AST = null;
    
    try {      // for error handling
      boolean synPredMatched79 = false;
      if (((LA(1)==VAR_ID) && (LA(2)==BAR))) {
        int _m79 = mark();
        synPredMatched79 = true;
        inputState.guessing++;
        try {
          {
          var();
          match(BAR);
          }
        }
        catch (RecognitionException pe) {
          synPredMatched79 = false;
        }
        rewind(_m79);
inputState.guessing--;
      }
      if ( synPredMatched79 ) {
        {
        var();
        astFactory.addASTChild(currentAST, returnAST);
        match(BAR);
        }
        if ( inputState.guessing==0 ) {
          recordVar_AST = (AST)currentAST.root;
          recordVar_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(RECORD_VAR,"RECORD_VAR")).add(recordVar_AST));
          currentAST.root = recordVar_AST;
          currentAST.child = recordVar_AST!=null &&recordVar_AST.getFirstChild()!=null ?
            recordVar_AST.getFirstChild() : recordVar_AST;
          currentAST.advanceChildToEnd();
        }
        recordVar_AST = (AST)currentAST.root;
      }
      else {
        boolean synPredMatched82 = false;
        if (((LA(1)==VAR_ID) && (_tokenSet_55.member(LA(2))))) {
          int _m82 = mark();
          synPredMatched82 = true;
          inputState.guessing++;
          try {
            {
            var();
            match(CLOSE_BRACE);
            }
          }
          catch (RecognitionException pe) {
            synPredMatched82 = false;
          }
          rewind(_m82);
inputState.guessing--;
        }
        if ( synPredMatched82 ) {
          {
          var();
          astFactory.addASTChild(currentAST, returnAST);
          }
          if ( inputState.guessing==0 ) {
            recordVar_AST = (AST)currentAST.root;
            recordVar_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(RECORD_VAR,"RECORD_VAR")).add(recordVar_AST));
            currentAST.root = recordVar_AST;
            currentAST.child = recordVar_AST!=null &&recordVar_AST.getFirstChild()!=null ?
              recordVar_AST.getFirstChild() : recordVar_AST;
            currentAST.advanceChildToEnd();
          }
          recordVar_AST = (AST)currentAST.root;
        }
        else if ((_tokenSet_55.member(LA(1))) && (_tokenSet_56.member(LA(2)))) {
          if ( inputState.guessing==0 ) {
            recordVar_AST = (AST)currentAST.root;
            recordVar_AST = (AST)astFactory.make( (new ASTArray(1)).add(astFactory.create(RECORD_VAR,"RECORD_VAR")));
            currentAST.root = recordVar_AST;
            currentAST.child = recordVar_AST!=null &&recordVar_AST.getFirstChild()!=null ?
              recordVar_AST.getFirstChild() : recordVar_AST;
            currentAST.advanceChildToEnd();
          }
          recordVar_AST = (AST)currentAST.root;
        }
        else {
          throw new NoViableAltException(LT(1), getFilename());
        }
        }
      }
      catch (NoViableAltException ex) {
        if (inputState.guessing==0) {
          reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_55, _tokenSet_55);
        } else {
          throw ex;
        }
      }
      catch (RecognitionException ex) {
        if (inputState.guessing==0) {
          reportError(ex, _tokenSet_55);
        } else {
          throw ex;
        }
      }
      returnAST = recordVar_AST;
    }
    
  public final void fieldTypeAssignmentList(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST fieldTypeAssignmentList_AST = null;
    
    try {      // for error handling
      {
      switch ( LA(1)) {
      case VAR_ID:
      case ORDINAL_FIELD_NAME:
      {
        fieldTypeAssignment(LT(1), "a field type assignment");
        astFactory.addASTChild(currentAST, returnAST);
        {
        _loop87:
        do {
          if ((LA(1)==COMMA)) {
            match(COMMA);
            fieldTypeAssignment(LT(1), "a field type assignment");
            astFactory.addASTChild(currentAST, returnAST);
          }
          else {
            break _loop87;
          }
          
        } while (true);
        }
        break;
      }
      case CLOSE_BRACE:
      {
        break;
      }
      default:
      {
        throw new NoViableAltException(LT(1), getFilename());
      }
      }
      }
      if ( inputState.guessing==0 ) {
        fieldTypeAssignmentList_AST = (AST)currentAST.root;
        fieldTypeAssignmentList_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(FIELD_TYPE_ASSIGNMENT_LIST,"FIELD_TYPE_ASSIGNMENT_LIST")).add(fieldTypeAssignmentList_AST));
        currentAST.root = fieldTypeAssignmentList_AST;
        currentAST.child = fieldTypeAssignmentList_AST!=null &&fieldTypeAssignmentList_AST.getFirstChild()!=null ?
          fieldTypeAssignmentList_AST.getFirstChild() : fieldTypeAssignmentList_AST;
        currentAST.advanceChildToEnd();
      }
      fieldTypeAssignmentList_AST = (AST)currentAST.root;
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_55, _tokenSet_57);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_57);
      } else {
        throw ex;
      }
    }
    returnAST = fieldTypeAssignmentList_AST;
  }
  
  public final void fieldTypeAssignment(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST fieldTypeAssignment_AST = null;
    Token  node = null;
    AST node_AST = null;
    
    try {      // for error handling
      fieldName(LT(1), "a valid record-field name");
      astFactory.addASTChild(currentAST, returnAST);
      node = LT(1);
      node_AST = astFactory.create(node);
      astFactory.makeASTRoot(currentAST, node_AST);
      match(COLONCOLON);
      if ( inputState.guessing==0 ) {
        node_AST.initialize (FIELD_TYPE_ASSIGNMENT, "FIELD_TYPE_ASSIGNMENT");
      }
      type(LT(1), "a field type");
      astFactory.addASTChild(currentAST, returnAST);
      fieldTypeAssignment_AST = (AST)currentAST.root;
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_49, _tokenSet_58);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_58);
      } else {
        throw ex;
      }
    }
    returnAST = fieldTypeAssignment_AST;
  }
  
  public final void foreignDataDeclaration(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST foreignDataDeclaration_AST = null;
    AST doc_AST = null;
    
    try {      // for error handling
      optionalDocComment();
      doc_AST = (AST)returnAST;
      foreignDataDeclarationWithOptionalDocComment(doc_AST, contextToken, paraphrase);
      astFactory.addASTChild(currentAST, returnAST);
      foreignDataDeclaration_AST = (AST)currentAST.root;
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_59, _tokenSet_0);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_0);
      } else {
        throw ex;
      }
    }
    returnAST = foreignDataDeclaration_AST;
  }
  
  public final void externalName() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST externalName_AST = null;
    
    try {      // for error handling
      AST tmp62_AST = null;
      tmp62_AST = astFactory.create(LT(1));
      astFactory.addASTChild(currentAST, tmp62_AST);
      match(STRING_LITERAL);
      externalName_AST = (AST)currentAST.root;
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        recover(ex,_tokenSet_60);
      } else {
        throw ex;
      }
    }
    returnAST = externalName_AST;
  }
  
  public final void maybeDerivingClause(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST maybeDerivingClause_AST = null;
    
    try {      // for error handling
      {
      switch ( LA(1)) {
      case LITERAL_deriving:
      {
        derivingClause(LT(1), "a deriving clause");
        astFactory.addASTChild(currentAST, returnAST);
        break;
      }
      case SEMICOLON:
      {
        break;
      }
      default:
      {
        throw new NoViableAltException(LT(1), getFilename());
      }
      }
      }
      maybeDerivingClause_AST = (AST)currentAST.root;
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_61, _tokenSet_21);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_21);
      } else {
        throw ex;
      }
    }
    returnAST = maybeDerivingClause_AST;
  }
  
  public final void dataDeclaration(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST dataDeclaration_AST = null;
    AST doc_AST = null;
    
    try {      // for error handling
      optionalDocComment();
      doc_AST = (AST)returnAST;
      dataDeclarationWithOptionalDocComment(doc_AST, contextToken, paraphrase);
      astFactory.addASTChild(currentAST, returnAST);
      dataDeclaration_AST = (AST)currentAST.root;
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_59, _tokenSet_0);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_0);
      } else {
        throw ex;
      }
    }
    returnAST = dataDeclaration_AST;
  }
  
  public final void simpleType(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST simpleType_AST = null;
    
    try {      // for error handling
      accessModifier(LT(1), "an access modifier");
      astFactory.addASTChild(currentAST, returnAST);
      typeConsName(LT(1), "a type constructor name");
      astFactory.addASTChild(currentAST, returnAST);
      typeConsParamList(LT(1), "a list of type constructor parameters");
      astFactory.addASTChild(currentAST, returnAST);
      simpleType_AST = (AST)currentAST.root;
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_28, _tokenSet_62);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_62);
      } else {
        throw ex;
      }
    }
    returnAST = simpleType_AST;
  }
  
  public final void dataDeclarationBody(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST dataDeclarationBody_AST = null;
    
    try {      // for error handling
      dataConstructorDefnList(LT(1), "a bar-separated list of data constructor definitions");
      astFactory.addASTChild(currentAST, returnAST);
      maybeDerivingClause(LT(1), "a bar, a deriving clause, or a semicolon");
      astFactory.addASTChild(currentAST, returnAST);
      dataDeclarationBody_AST = (AST)currentAST.root;
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_63, _tokenSet_21);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_21);
      } else {
        throw ex;
      }
    }
    returnAST = dataDeclarationBody_AST;
  }
  
  public final void dataConstructorDefnList(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST dataConstructorDefnList_AST = null;
    
    try {      // for error handling
      dataConstructorDefn(LT(1), "a data constructor definition");
      astFactory.addASTChild(currentAST, returnAST);
      {
      _loop107:
      do {
        if ((LA(1)==BAR)) {
          match(BAR);
          dataConstructorDefn(LT(1), "a data constructor definition");
          astFactory.addASTChild(currentAST, returnAST);
        }
        else {
          break _loop107;
        }
        
      } while (true);
      }
      if ( inputState.guessing==0 ) {
        dataConstructorDefnList_AST = (AST)currentAST.root;
        dataConstructorDefnList_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(DATA_CONSTRUCTOR_DEFN_LIST,"DATA_CONSTRUCTOR_DEFN_LIST")).add(dataConstructorDefnList_AST));
        currentAST.root = dataConstructorDefnList_AST;
        currentAST.child = dataConstructorDefnList_AST!=null &&dataConstructorDefnList_AST.getFirstChild()!=null ?
          dataConstructorDefnList_AST.getFirstChild() : dataConstructorDefnList_AST;
        currentAST.advanceChildToEnd();
      }
      dataConstructorDefnList_AST = (AST)currentAST.root;
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_63, _tokenSet_61);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_61);
      } else {
        throw ex;
      }
    }
    returnAST = dataConstructorDefnList_AST;
  }
  
  public final void derivingClause(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST derivingClause_AST = null;
    
    try {      // for error handling
      {
      AST tmp64_AST = null;
      tmp64_AST = astFactory.create(LT(1));
      astFactory.makeASTRoot(currentAST, tmp64_AST);
      match(LITERAL_deriving);
      qualifiedCons(LT(1), "a type class name");
      astFactory.addASTChild(currentAST, returnAST);
      {
      _loop118:
      do {
        if ((LA(1)==COMMA)) {
          match(COMMA);
          qualifiedCons(LT(1), "a type class name");
          astFactory.addASTChild(currentAST, returnAST);
        }
        else {
          break _loop118;
        }
        
      } while (true);
      }
      }
      derivingClause_AST = (AST)currentAST.root;
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_64, _tokenSet_21);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_21);
      } else {
        throw ex;
      }
    }
    returnAST = derivingClause_AST;
  }
  
  public final void typeConsName(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST typeConsName_AST = null;
    
    try {      // for error handling
      cons();
      astFactory.addASTChild(currentAST, returnAST);
      typeConsName_AST = (AST)currentAST.root;
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_17, _tokenSet_65);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_65);
      } else {
        throw ex;
      }
    }
    returnAST = typeConsName_AST;
  }
  
  public final void typeConsParamList(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST typeConsParamList_AST = null;
    
    try {      // for error handling
      {
      _loop104:
      do {
        if ((LA(1)==VAR_ID)) {
          var();
          astFactory.addASTChild(currentAST, returnAST);
        }
        else {
          break _loop104;
        }
        
      } while (true);
      }
      if ( inputState.guessing==0 ) {
        typeConsParamList_AST = (AST)currentAST.root;
        typeConsParamList_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(TYPE_CONS_PARAM_LIST,"TYPE_CONS_PARAM_LIST")).add(typeConsParamList_AST));
        currentAST.root = typeConsParamList_AST;
        currentAST.child = typeConsParamList_AST!=null &&typeConsParamList_AST.getFirstChild()!=null ?
          typeConsParamList_AST.getFirstChild() : typeConsParamList_AST;
        currentAST.advanceChildToEnd();
      }
      typeConsParamList_AST = (AST)currentAST.root;
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_65, _tokenSet_62);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_62);
      } else {
        throw ex;
      }
    }
    returnAST = typeConsParamList_AST;
  }
  
  public final void dataConstructorDefn(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST dataConstructorDefn_AST = null;
    
    try {      // for error handling
      optionalDocComment();
      astFactory.addASTChild(currentAST, returnAST);
      accessModifier(LT(1), "an access modifier");
      astFactory.addASTChild(currentAST, returnAST);
      cons();
      astFactory.addASTChild(currentAST, returnAST);
      dataConstructorArgList(LT(1), "a list of data constructor arguments");
      astFactory.addASTChild(currentAST, returnAST);
      if ( inputState.guessing==0 ) {
        dataConstructorDefn_AST = (AST)currentAST.root;
        dataConstructorDefn_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(DATA_CONSTRUCTOR_DEFN,"DATA_CONSTRUCTOR_DEFN")).add(dataConstructorDefn_AST));
        currentAST.root = dataConstructorDefn_AST;
        currentAST.child = dataConstructorDefn_AST!=null &&dataConstructorDefn_AST.getFirstChild()!=null ?
          dataConstructorDefn_AST.getFirstChild() : dataConstructorDefn_AST;
        currentAST.advanceChildToEnd();
      }
      dataConstructorDefn_AST = (AST)currentAST.root;
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_63, _tokenSet_66);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_66);
      } else {
        throw ex;
      }
    }
    returnAST = dataConstructorDefn_AST;
  }
  
  public final void dataConstructorArgList(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST dataConstructorArgList_AST = null;
    
    try {      // for error handling
      {
      _loop111:
      do {
        if ((LA(1)==VAR_ID||LA(1)==ORDINAL_FIELD_NAME)) {
          dataConstructorArg(LT(1), "a data constructor argument");
          astFactory.addASTChild(currentAST, returnAST);
        }
        else {
          break _loop111;
        }
        
      } while (true);
      }
      if ( inputState.guessing==0 ) {
        dataConstructorArgList_AST = (AST)currentAST.root;
        dataConstructorArgList_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(DATA_CONSTRUCTOR_ARG_LIST,"DATA_CONSTRUCTOR_ARG_LIST")).add(dataConstructorArgList_AST));
        currentAST.root = dataConstructorArgList_AST;
        currentAST.child = dataConstructorArgList_AST!=null &&dataConstructorArgList_AST.getFirstChild()!=null ?
          dataConstructorArgList_AST.getFirstChild() : dataConstructorArgList_AST;
        currentAST.advanceChildToEnd();
      }
      dataConstructorArgList_AST = (AST)currentAST.root;
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_67, _tokenSet_66);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_66);
      } else {
        throw ex;
      }
    }
    returnAST = dataConstructorArgList_AST;
  }
  
  public final void dataConstructorArg(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST dataConstructorArg_AST = null;
    Token  node = null;
    AST node_AST = null;
    
    try {      // for error handling
      fieldName(LT(1), "a valid argument name");
      astFactory.addASTChild(currentAST, returnAST);
      node = LT(1);
      node_AST = astFactory.create(node);
      astFactory.makeASTRoot(currentAST, node_AST);
      match(COLONCOLON);
      if ( inputState.guessing==0 ) {
        node_AST.setType (DATA_CONSTRUCTOR_NAMED_ARG);
      }
      dataConstructorArgType(LT(1), "a type for the data constructor argument");
      astFactory.addASTChild(currentAST, returnAST);
      dataConstructorArg_AST = (AST)currentAST.root;
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_49, _tokenSet_67);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_67);
      } else {
        throw ex;
      }
    }
    returnAST = dataConstructorArg_AST;
  }
  
  public final void dataConstructorArgType(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST dataConstructorArgType_AST = null;
    Token  node = null;
    AST node_AST = null;
    
    try {      // for error handling
      switch ( LA(1)) {
      case PLING:
      {
        {
        node = LT(1);
        node_AST = astFactory.create(node);
        astFactory.makeASTRoot(currentAST, node_AST);
        match(PLING);
        if ( inputState.guessing==0 ) {
          {node_AST.initialize (STRICT_ARG, "!");}
        }
        atomicType(contextToken, paraphrase);
        astFactory.addASTChild(currentAST, returnAST);
        }
        dataConstructorArgType_AST = (AST)currentAST.root;
        break;
      }
      case CONS_ID:
      case VAR_ID:
      case OPEN_PAREN:
      case OPEN_BRACKET:
      case OPEN_BRACE:
      {
        atomicType(contextToken, paraphrase);
        astFactory.addASTChild(currentAST, returnAST);
        dataConstructorArgType_AST = (AST)currentAST.root;
        break;
      }
      default:
      {
        throw new NoViableAltException(LT(1), getFilename());
      }
      }
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_68, _tokenSet_67);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_67);
      } else {
        throw ex;
      }
    }
    returnAST = dataConstructorArgType_AST;
  }
  
  public final void typeClassDefn(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST typeClassDefn_AST = null;
    AST doc_AST = null;
    
    try {      // for error handling
      optionalDocComment();
      doc_AST = (AST)returnAST;
      typeClassDefnWithOptionalDocComment(doc_AST, contextToken, paraphrase);
      astFactory.addASTChild(currentAST, returnAST);
      typeClassDefn_AST = (AST)currentAST.root;
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_69, _tokenSet_0);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_0);
      } else {
        throw ex;
      }
    }
    returnAST = typeClassDefn_AST;
  }
  
  public final void typeClassName(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST typeClassName_AST = null;
    
    try {      // for error handling
      cons();
      astFactory.addASTChild(currentAST, returnAST);
      typeClassName_AST = (AST)currentAST.root;
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_17, _tokenSet_15);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_15);
      } else {
        throw ex;
      }
    }
    returnAST = typeClassName_AST;
  }
  
  public final void typeClassParam(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST typeClassParam_AST = null;
    
    try {      // for error handling
      var();
      astFactory.addASTChild(currentAST, returnAST);
      typeClassParam_AST = (AST)currentAST.root;
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_15, _tokenSet_70);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_70);
      } else {
        throw ex;
      }
    }
    returnAST = typeClassParam_AST;
  }
  
  public final void classMethodList(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST classMethodList_AST = null;
    
    try {      // for error handling
      {
      _loop125:
      do {
        if ((_tokenSet_71.member(LA(1)))) {
          classMethod(LT(1), "a class method definition");
          astFactory.addASTChild(currentAST, returnAST);
        }
        else {
          break _loop125;
        }
        
      } while (true);
      }
      if ( inputState.guessing==0 ) {
        classMethodList_AST = (AST)currentAST.root;
        classMethodList_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(CLASS_METHOD_LIST,"CLASS_METHOD_LIST")).add(classMethodList_AST));
        currentAST.root = classMethodList_AST;
        currentAST.child = classMethodList_AST!=null &&classMethodList_AST.getFirstChild()!=null ?
          classMethodList_AST.getFirstChild() : classMethodList_AST;
        currentAST.advanceChildToEnd();
      }
      classMethodList_AST = (AST)currentAST.root;
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_72, _tokenSet_21);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_21);
      } else {
        throw ex;
      }
    }
    returnAST = classMethodList_AST;
  }
  
  public final void classMethod(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST classMethod_AST = null;
    
    try {      // for error handling
      optionalDocComment();
      astFactory.addASTChild(currentAST, returnAST);
      accessModifier(LT(1), "an access modifier");
      astFactory.addASTChild(currentAST, returnAST);
      classMethodName(LT(1), "a class method name");
      astFactory.addASTChild(currentAST, returnAST);
      match(COLONCOLON);
      typeSignature(LT(1), "a type signature for a method");
      astFactory.addASTChild(currentAST, returnAST);
      {
      switch ( LA(1)) {
      case LITERAL_default:
      {
        match(LITERAL_default);
        defaultClassMethodName(LT(1), "a default class method name");
        astFactory.addASTChild(currentAST, returnAST);
        break;
      }
      case SEMICOLON:
      {
        break;
      }
      default:
      {
        throw new NoViableAltException(LT(1), getFilename());
      }
      }
      }
      match(SEMICOLON);
      if ( inputState.guessing==0 ) {
        classMethod_AST = (AST)currentAST.root;
        classMethod_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(CLASS_METHOD,"CLASS_METHOD")).add(classMethod_AST));
        currentAST.root = classMethod_AST;
        currentAST.child = classMethod_AST!=null &&classMethod_AST.getFirstChild()!=null ?
          classMethod_AST.getFirstChild() : classMethod_AST;
        currentAST.advanceChildToEnd();
      }
      classMethod_AST = (AST)currentAST.root;
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_71, _tokenSet_72);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_72);
      } else {
        throw ex;
      }
    }
    returnAST = classMethod_AST;
  }
  
  public final void classMethodName(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST classMethodName_AST = null;
    
    try {      // for error handling
      var();
      astFactory.addASTChild(currentAST, returnAST);
      classMethodName_AST = (AST)currentAST.root;
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_15, _tokenSet_73);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_73);
      } else {
        throw ex;
      }
    }
    returnAST = classMethodName_AST;
  }
  
  public final void defaultClassMethodName(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST defaultClassMethodName_AST = null;
    
    try {      // for error handling
      qualifiedVar(contextToken, paraphrase);
      astFactory.addASTChild(currentAST, returnAST);
      defaultClassMethodName_AST = (AST)currentAST.root;
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_42, _tokenSet_21);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_21);
      } else {
        throw ex;
      }
    }
    returnAST = defaultClassMethodName_AST;
  }
  
  public final void qualifiedVar(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST qualifiedVar_AST = null;
    Token  qualifiedVarNode = null;
    AST qualifiedVarNode_AST = null;
    
    try {      // for error handling
      switch ( LA(1)) {
      case VAR_ID:
      {
        var();
        astFactory.addASTChild(currentAST, returnAST);
        if ( inputState.guessing==0 ) {
          qualifiedVar_AST = (AST)currentAST.root;
          qualifiedVar_AST = (AST)astFactory.make( (new ASTArray(3)).add(astFactory.create(QUALIFIED_VAR,"QUALIFIED_VAR")).add(astFactory.create(HIERARCHICAL_MODULE_NAME_EMPTY_QUALIFIER,"HIERARCHICAL_MODULE_NAME_EMPTY_QUALIFIER")).add(qualifiedVar_AST));
          currentAST.root = qualifiedVar_AST;
          currentAST.child = qualifiedVar_AST!=null &&qualifiedVar_AST.getFirstChild()!=null ?
            qualifiedVar_AST.getFirstChild() : qualifiedVar_AST;
          currentAST.advanceChildToEnd();
        }
        qualifiedVar_AST = (AST)currentAST.root;
        break;
      }
      case CONS_ID:
      {
        moduleName(LT(1), "a valid module name");
        astFactory.addASTChild(currentAST, returnAST);
        qualifiedVarNode = LT(1);
        qualifiedVarNode_AST = astFactory.create(qualifiedVarNode);
        astFactory.makeASTRoot(currentAST, qualifiedVarNode_AST);
        match(DOT);
        if ( inputState.guessing==0 ) {
          qualifiedVarNode_AST.initialize (QUALIFIED_VAR, "QUALIFIED_VAR");
        }
        var();
        astFactory.addASTChild(currentAST, returnAST);
        qualifiedVar_AST = (AST)currentAST.root;
        break;
      }
      default:
      {
        throw new NoViableAltException(LT(1), getFilename());
      }
      }
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_42, _tokenSet_74);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_74);
      } else {
        throw ex;
      }
    }
    returnAST = qualifiedVar_AST;
  }
  
  public final void instanceDefn(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST instanceDefn_AST = null;
    AST doc_AST = null;
    
    try {      // for error handling
      optionalDocComment();
      doc_AST = (AST)returnAST;
      instanceDefnWithOptionalDocComment(doc_AST, contextToken, paraphrase);
      astFactory.addASTChild(currentAST, returnAST);
      instanceDefn_AST = (AST)currentAST.root;
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_75, _tokenSet_0);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_0);
      } else {
        throw ex;
      }
    }
    returnAST = instanceDefn_AST;
  }
  
  public final void instanceName(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST instanceName_AST = null;
    
    try {      // for error handling
      classContextList(LT(1), "a class context");
      astFactory.addASTChild(currentAST, returnAST);
      qualifiedCons(LT(1), "a class name");
      astFactory.addASTChild(currentAST, returnAST);
      instanceTypeConsName(LT(1), "a type constructor name");
      astFactory.addASTChild(currentAST, returnAST);
      if ( inputState.guessing==0 ) {
        instanceName_AST = (AST)currentAST.root;
        instanceName_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(INSTANCE_NAME,"INSTANCE_NAME")).add(instanceName_AST));
        currentAST.root = instanceName_AST;
        currentAST.child = instanceName_AST!=null &&instanceName_AST.getFirstChild()!=null ?
          instanceName_AST.getFirstChild() : instanceName_AST;
        currentAST.advanceChildToEnd();
      }
      instanceName_AST = (AST)currentAST.root;
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_46, _tokenSet_70);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_70);
      } else {
        throw ex;
      }
    }
    returnAST = instanceName_AST;
  }
  
  public final void instanceMethodList(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST instanceMethodList_AST = null;
    
    try {      // for error handling
      {
      _loop142:
      do {
        if ((LA(1)==CALDOC_OPEN||LA(1)==VAR_ID)) {
          instanceMethod(LT(1), "an instance method definition");
          astFactory.addASTChild(currentAST, returnAST);
        }
        else {
          break _loop142;
        }
        
      } while (true);
      }
      if ( inputState.guessing==0 ) {
        instanceMethodList_AST = (AST)currentAST.root;
        instanceMethodList_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(INSTANCE_METHOD_LIST,"INSTANCE_METHOD_LIST")).add(instanceMethodList_AST));
        currentAST.root = instanceMethodList_AST;
        currentAST.child = instanceMethodList_AST!=null &&instanceMethodList_AST.getFirstChild()!=null ?
          instanceMethodList_AST.getFirstChild() : instanceMethodList_AST;
        currentAST.advanceChildToEnd();
      }
      instanceMethodList_AST = (AST)currentAST.root;
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_76, _tokenSet_21);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_21);
      } else {
        throw ex;
      }
    }
    returnAST = instanceMethodList_AST;
  }
  
  public final void instanceTypeConsName(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST instanceTypeConsName_AST = null;
    Token  openParenNode = null;
    AST openParenNode_AST = null;
    Token  closeParenNode = null;
    AST closeParenNode_AST = null;
    Token  node = null;
    AST node_AST = null;
    Token  openParenNode2 = null;
    AST openParenNode2_AST = null;
    Token  closeParenNode2 = null;
    AST closeParenNode2_AST = null;
    Token  openBracketNode = null;
    AST openBracketNode_AST = null;
    Token  closeBracketNode = null;
    AST closeBracketNode_AST = null;
    Token  openBraceNode = null;
    AST openBraceNode_AST = null;
    Token  closeBraceNode = null;
    AST closeBraceNode_AST = null;
    
    try {      // for error handling
      switch ( LA(1)) {
      case CONS_ID:
      {
        qualifiedCons(contextToken, paraphrase);
        astFactory.addASTChild(currentAST, returnAST);
        if ( inputState.guessing==0 ) {
          instanceTypeConsName_AST = (AST)currentAST.root;
          instanceTypeConsName_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(UNPARENTHESIZED_TYPE_CONSTRUCTOR,"UNPARENTHESIZED_TYPE_CONSTRUCTOR")).add(instanceTypeConsName_AST));
          currentAST.root = instanceTypeConsName_AST;
          currentAST.child = instanceTypeConsName_AST!=null &&instanceTypeConsName_AST.getFirstChild()!=null ?
            instanceTypeConsName_AST.getFirstChild() : instanceTypeConsName_AST;
          currentAST.advanceChildToEnd();
        }
        instanceTypeConsName_AST = (AST)currentAST.root;
        break;
      }
      case OPEN_BRACKET:
      {
        openBracketNode = LT(1);
        openBracketNode_AST = astFactory.create(openBracketNode);
        astFactory.makeASTRoot(currentAST, openBracketNode_AST);
        match(OPEN_BRACKET);
        if ( inputState.guessing==0 ) {
          openBracketNode_AST.initialize (LIST_TYPE_CONSTRUCTOR, "List");
        }
        var();
        astFactory.addASTChild(currentAST, returnAST);
        closeBracketNode = LT(1);
        closeBracketNode_AST = astFactory.create(closeBracketNode);
        match(CLOSE_BRACKET);
        if ( inputState.guessing==0 ) {
          ((ParseTreeNode)openBracketNode_AST).addOmittedDelimiter(closeBracketNode_AST);
        }
        instanceTypeConsName_AST = (AST)currentAST.root;
        break;
      }
      case OPEN_BRACE:
      {
        openBraceNode = LT(1);
        openBraceNode_AST = astFactory.create(openBraceNode);
        astFactory.makeASTRoot(currentAST, openBraceNode_AST);
        match(OPEN_BRACE);
        if ( inputState.guessing==0 ) {
          openBraceNode_AST.initialize (RECORD_TYPE_CONSTRUCTOR, "Record");
        }
        var();
        astFactory.addASTChild(currentAST, returnAST);
        closeBraceNode = LT(1);
        closeBraceNode_AST = astFactory.create(closeBraceNode);
        match(CLOSE_BRACE);
        if ( inputState.guessing==0 ) {
          ((ParseTreeNode)openBraceNode_AST).addOmittedDelimiter(closeBraceNode_AST);
        }
        instanceTypeConsName_AST = (AST)currentAST.root;
        break;
      }
      default:
        boolean synPredMatched135 = false;
        if (((LA(1)==OPEN_PAREN) && (LA(2)==CONS_ID))) {
          int _m135 = mark();
          synPredMatched135 = true;
          inputState.guessing++;
          try {
            {
            match(OPEN_PAREN);
            qualifiedCons(null,null);
            }
          }
          catch (RecognitionException pe) {
            synPredMatched135 = false;
          }
          rewind(_m135);
inputState.guessing--;
        }
        if ( synPredMatched135 ) {
          openParenNode = LT(1);
          openParenNode_AST = astFactory.create(openParenNode);
          astFactory.makeASTRoot(currentAST, openParenNode_AST);
          match(OPEN_PAREN);
          if ( inputState.guessing==0 ) {
            openParenNode_AST.initialize (GENERAL_TYPE_CONSTRUCTOR, "GENERAL_TYPE_CONSTRUCTOR");
          }
          qualifiedCons(contextToken, paraphrase);
          astFactory.addASTChild(currentAST, returnAST);
          {
          _loop137:
          do {
            if ((LA(1)==VAR_ID)) {
              var();
              astFactory.addASTChild(currentAST, returnAST);
            }
            else {
              break _loop137;
            }
            
          } while (true);
          }
          closeParenNode = LT(1);
          closeParenNode_AST = astFactory.create(closeParenNode);
          match(CLOSE_PAREN);
          if ( inputState.guessing==0 ) {
            ((ParseTreeNode)openParenNode_AST).addOmittedDelimiter(closeParenNode_AST);
          }
          instanceTypeConsName_AST = (AST)currentAST.root;
        }
        else {
          boolean synPredMatched139 = false;
          if (((LA(1)==OPEN_PAREN) && (LA(2)==VAR_ID))) {
            int _m139 = mark();
            synPredMatched139 = true;
            inputState.guessing++;
            try {
              {
              match(OPEN_PAREN);
              var();
              match(RARROW);
              }
            }
            catch (RecognitionException pe) {
              synPredMatched139 = false;
            }
            rewind(_m139);
inputState.guessing--;
          }
          if ( synPredMatched139 ) {
            match(OPEN_PAREN);
            var();
            astFactory.addASTChild(currentAST, returnAST);
            node = LT(1);
            node_AST = astFactory.create(node);
            astFactory.makeASTRoot(currentAST, node_AST);
            match(RARROW);
            if ( inputState.guessing==0 ) {
              node_AST.initialize (FUNCTION_TYPE_CONSTRUCTOR, "->");
            }
            var();
            astFactory.addASTChild(currentAST, returnAST);
            match(CLOSE_PAREN);
            instanceTypeConsName_AST = (AST)currentAST.root;
          }
          else if ((LA(1)==OPEN_PAREN) && (LA(2)==CLOSE_PAREN)) {
            openParenNode2 = LT(1);
            openParenNode2_AST = astFactory.create(openParenNode2);
            astFactory.makeASTRoot(currentAST, openParenNode2_AST);
            match(OPEN_PAREN);
            if ( inputState.guessing==0 ) {
              openParenNode2_AST.initialize (UNIT_TYPE_CONSTRUCTOR, "Unit");
            }
            closeParenNode2 = LT(1);
            closeParenNode2_AST = astFactory.create(closeParenNode2);
            match(CLOSE_PAREN);
            if ( inputState.guessing==0 ) {
              ((ParseTreeNode)openParenNode2_AST).addOmittedDelimiter(closeParenNode2_AST);
            }
            instanceTypeConsName_AST = (AST)currentAST.root;
          }
        else {
          throw new NoViableAltException(LT(1), getFilename());
        }
        }}
      }
      catch (NoViableAltException ex) {
        if (inputState.guessing==0) {
          reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_77, _tokenSet_70);
        } else {
          throw ex;
        }
      }
      catch (RecognitionException ex) {
        if (inputState.guessing==0) {
          reportError(ex, _tokenSet_70);
        } else {
          throw ex;
        }
      }
      returnAST = instanceTypeConsName_AST;
    }
    
  public final void instanceMethod(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST instanceMethod_AST = null;
    AST doc_AST = null;
    Token  node = null;
    AST node_AST = null;
    
    try {      // for error handling
      optionalDocComment();
      doc_AST = (AST)returnAST;
      astFactory.addASTChild(currentAST, returnAST);
      instanceMethodName(LT(1), "a method name");
      astFactory.addASTChild(currentAST, returnAST);
      node = LT(1);
      node_AST = astFactory.create(node);
      astFactory.makeASTRoot(currentAST, node_AST);
      match(EQUALS);
      if ( inputState.guessing==0 ) {
        node_AST.initialize (INSTANCE_METHOD, "INSTANCE_METHOD");
      }
      instanceMethodDefn(LT(1), "a function or method name");
      astFactory.addASTChild(currentAST, returnAST);
      match(SEMICOLON);
      instanceMethod_AST = (AST)currentAST.root;
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_36, _tokenSet_76);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_76);
      } else {
        throw ex;
      }
    }
    returnAST = instanceMethod_AST;
  }
  
  public final void instanceMethodName(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST instanceMethodName_AST = null;
    
    try {      // for error handling
      var();
      astFactory.addASTChild(currentAST, returnAST);
      instanceMethodName_AST = (AST)currentAST.root;
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_15, _tokenSet_62);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_62);
      } else {
        throw ex;
      }
    }
    returnAST = instanceMethodName_AST;
  }
  
  public final void instanceMethodDefn(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST instanceMethodDefn_AST = null;
    
    try {      // for error handling
      qualifiedVar(contextToken, paraphrase);
      astFactory.addASTChild(currentAST, returnAST);
      instanceMethodDefn_AST = (AST)currentAST.root;
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_42, _tokenSet_21);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_21);
      } else {
        throw ex;
      }
    }
    returnAST = instanceMethodDefn_AST;
  }
  
  public final void foreignFunctionDeclaration(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST foreignFunctionDeclaration_AST = null;
    AST doc_AST = null;
    
    try {      // for error handling
      optionalDocComment();
      doc_AST = (AST)returnAST;
      foreignFunctionDeclarationWithOptionalDocComment(doc_AST, contextToken, paraphrase);
      astFactory.addASTChild(currentAST, returnAST);
      foreignFunctionDeclaration_AST = (AST)currentAST.root;
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_78, _tokenSet_0);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_0);
      } else {
        throw ex;
      }
    }
    returnAST = foreignFunctionDeclaration_AST;
  }
  
  public final void primitiveFunctionDeclaration(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST primitiveFunctionDeclaration_AST = null;
    AST doc_AST = null;
    
    try {      // for error handling
      optionalDocComment();
      doc_AST = (AST)returnAST;
      primitiveFunctionDeclarationWithOptionalDocComment(doc_AST, contextToken, paraphrase);
      astFactory.addASTChild(currentAST, returnAST);
      primitiveFunctionDeclaration_AST = (AST)currentAST.root;
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_79, _tokenSet_0);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_0);
      } else {
        throw ex;
      }
    }
    returnAST = primitiveFunctionDeclaration_AST;
  }
  
  public final void topLevelFunction(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST topLevelFunction_AST = null;
    AST doc_AST = null;
    
    try {      // for error handling
      optionalDocComment();
      doc_AST = (AST)returnAST;
      topLevelFunctionWithOptionalDocComment(doc_AST, contextToken, paraphrase);
      astFactory.addASTChild(currentAST, returnAST);
      topLevelFunction_AST = (AST)currentAST.root;
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_71, _tokenSet_0);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_0);
      } else {
        throw ex;
      }
    }
    returnAST = topLevelFunction_AST;
  }
  
  public final void functionName(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST functionName_AST = null;
    
    try {      // for error handling
      var();
      astFactory.addASTChild(currentAST, returnAST);
      functionName_AST = (AST)currentAST.root;
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_15, _tokenSet_14);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_14);
      } else {
        throw ex;
      }
    }
    returnAST = functionName_AST;
  }
  
  public final void functionParamList(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST functionParamList_AST = null;
    
    try {      // for error handling
      {
      _loop158:
      do {
        if ((LA(1)==VAR_ID||LA(1)==PLING)) {
          functionParam(LT(1), "a function parameter name");
          astFactory.addASTChild(currentAST, returnAST);
        }
        else {
          break _loop158;
        }
        
      } while (true);
      }
      if ( inputState.guessing==0 ) {
        functionParamList_AST = (AST)currentAST.root;
        functionParamList_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(FUNCTION_PARAM_LIST,"FUNCTION_PARAM_LIST")).add(functionParamList_AST));
        currentAST.root = functionParamList_AST;
        currentAST.child = functionParamList_AST!=null &&functionParamList_AST.getFirstChild()!=null ?
          functionParamList_AST.getFirstChild() : functionParamList_AST;
        currentAST.advanceChildToEnd();
      }
      functionParamList_AST = (AST)currentAST.root;
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_14, _tokenSet_62);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_62);
      } else {
        throw ex;
      }
    }
    returnAST = functionParamList_AST;
  }
  
  public final void functionParam(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST functionParam_AST = null;
    Token  node1 = null;
    AST node1_AST = null;
    Token  node2 = null;
    AST node2_AST = null;
    
    try {      // for error handling
      switch ( LA(1)) {
      case VAR_ID:
      {
        node1 = LT(1);
        node1_AST = astFactory.create(node1);
        astFactory.addASTChild(currentAST, node1_AST);
        match(VAR_ID);
        if ( inputState.guessing==0 ) {
          node1_AST.setType (LAZY_PARAM);
        }
        functionParam_AST = (AST)currentAST.root;
        break;
      }
      case PLING:
      {
        match(PLING);
        node2 = LT(1);
        node2_AST = astFactory.create(node2);
        astFactory.addASTChild(currentAST, node2_AST);
        match(VAR_ID);
        if ( inputState.guessing==0 ) {
          node2_AST.setType (STRICT_PARAM);
        }
        functionParam_AST = (AST)currentAST.root;
        break;
      }
      default:
      {
        throw new NoViableAltException(LT(1), getFilename());
      }
      }
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_80, _tokenSet_81);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_81);
      } else {
        throw ex;
      }
    }
    returnAST = functionParam_AST;
  }
  
  public final void lambdaParamList(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST lambdaParamList_AST = null;
    
    try {      // for error handling
      {
      int _cnt162=0;
      _loop162:
      do {
        if ((LA(1)==VAR_ID||LA(1)==PLING)) {
          functionParam(LT(1), "a lambda parameter name");
          astFactory.addASTChild(currentAST, returnAST);
        }
        else {
          if ( _cnt162>=1 ) { break _loop162; } else {throw new NoViableAltException(LT(1), getFilename());}
        }
        
        _cnt162++;
      } while (true);
      }
      if ( inputState.guessing==0 ) {
        lambdaParamList_AST = (AST)currentAST.root;
        lambdaParamList_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(FUNCTION_PARAM_LIST,"FUNCTION_PARAM_LIST")).add(lambdaParamList_AST));
        currentAST.root = lambdaParamList_AST;
        currentAST.child = lambdaParamList_AST!=null &&lambdaParamList_AST.getFirstChild()!=null ?
          lambdaParamList_AST.getFirstChild() : lambdaParamList_AST;
        currentAST.advanceChildToEnd();
      }
      lambdaParamList_AST = (AST)currentAST.root;
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_80, _tokenSet_82);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_82);
      } else {
        throw ex;
      }
    }
    returnAST = lambdaParamList_AST;
  }
  
  public final void letDefnList(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST letDefnList_AST = null;
    
    try {      // for error handling
      {
      int _cnt238=0;
      _loop238:
      do {
        if ((_tokenSet_83.member(LA(1)))) {
          letDefnOrTypeDeclarationOrPatternMatchDecl(contextToken, paraphrase);
          astFactory.addASTChild(currentAST, returnAST);
        }
        else {
          if ( _cnt238>=1 ) { break _loop238; } else {throw new NoViableAltException(LT(1), getFilename());}
        }
        
        _cnt238++;
      } while (true);
      }
      if ( inputState.guessing==0 ) {
        letDefnList_AST = (AST)currentAST.root;
        letDefnList_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(LET_DEFN_LIST,"LET_DEFN_LIST")).add(letDefnList_AST));
        currentAST.root = letDefnList_AST;
        currentAST.child = letDefnList_AST!=null &&letDefnList_AST.getFirstChild()!=null ?
          letDefnList_AST.getFirstChild() : letDefnList_AST;
        currentAST.advanceChildToEnd();
      }
      letDefnList_AST = (AST)currentAST.root;
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_83, _tokenSet_84);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_84);
      } else {
        throw ex;
      }
    }
    returnAST = letDefnList_AST;
  }
  
  public final void altList(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST altList_AST = null;
    
    try {      // for error handling
      {
      int _cnt252=0;
      _loop252:
      do {
        if ((_tokenSet_85.member(LA(1)))) {
          alt(LT(1), "a case alternative");
          astFactory.addASTChild(currentAST, returnAST);
        }
        else {
          if ( _cnt252>=1 ) { break _loop252; } else {throw new NoViableAltException(LT(1), getFilename());}
        }
        
        _cnt252++;
      } while (true);
      }
      if ( inputState.guessing==0 ) {
        altList_AST = (AST)currentAST.root;
        altList_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(ALT_LIST,"ALT_LIST")).add(altList_AST));
        currentAST.root = altList_AST;
        currentAST.child = altList_AST!=null &&altList_AST.getFirstChild()!=null ?
          altList_AST.getFirstChild() : altList_AST;
        currentAST.advanceChildToEnd();
      }
      altList_AST = (AST)currentAST.root;
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_85, _tokenSet_2);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_2);
      } else {
        throw ex;
      }
    }
    returnAST = altList_AST;
  }
  
  public final void typeSignatureExpr(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST typeSignatureExpr_AST = null;
    Token  node = null;
    AST node_AST = null;
    
    try {      // for error handling
      applyOpExpr(contextToken, paraphrase);
      astFactory.addASTChild(currentAST, returnAST);
      {
      switch ( LA(1)) {
      case COLONCOLON:
      {
        node = LT(1);
        node_AST = astFactory.create(node);
        astFactory.makeASTRoot(currentAST, node_AST);
        match(COLONCOLON);
        if ( inputState.guessing==0 ) {
          node_AST.setType (EXPRESSION_TYPE_SIGNATURE);
        }
        typeSignature(LT(1), "a valid type signature");
        astFactory.addASTChild(currentAST, returnAST);
        break;
      }
      case EOF:
      case COMMA:
      case SEMICOLON:
      case CLOSE_PAREN:
      case CLOSE_BRACKET:
      case CLOSE_BRACE:
      case BAR:
      case LITERAL_then:
      case LITERAL_else:
      case LITERAL_of:
      {
        break;
      }
      default:
      {
        throw new NoViableAltException(LT(1), getFilename());
      }
      }
      }
      typeSignatureExpr_AST = (AST)currentAST.root;
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_86, _tokenSet_2);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_2);
      } else {
        throw ex;
      }
    }
    returnAST = typeSignatureExpr_AST;
  }
  
  public final void applyOpExpr(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST applyOpExpr_AST = null;
    
    try {      // for error handling
      orExpr(contextToken, paraphrase);
      astFactory.addASTChild(currentAST, returnAST);
      {
      switch ( LA(1)) {
      case DOLLAR:
      {
        AST tmp73_AST = null;
        tmp73_AST = astFactory.create(LT(1));
        astFactory.makeASTRoot(currentAST, tmp73_AST);
        match(DOLLAR);
        applyOpExpr(contextToken, paraphrase);
        astFactory.addASTChild(currentAST, returnAST);
        break;
      }
      case EOF:
      case COMMA:
      case SEMICOLON:
      case COLONCOLON:
      case CLOSE_PAREN:
      case CLOSE_BRACKET:
      case CLOSE_BRACE:
      case BAR:
      case LITERAL_then:
      case LITERAL_else:
      case LITERAL_of:
      {
        break;
      }
      default:
      {
        throw new NoViableAltException(LT(1), getFilename());
      }
      }
      }
      applyOpExpr_AST = (AST)currentAST.root;
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_86, _tokenSet_87);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_87);
      } else {
        throw ex;
      }
    }
    returnAST = applyOpExpr_AST;
  }
  
  public final void orExpr(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST orExpr_AST = null;
    
    try {      // for error handling
      andExpr(contextToken, paraphrase);
      astFactory.addASTChild(currentAST, returnAST);
      {
      switch ( LA(1)) {
      case BARBAR:
      {
        AST tmp74_AST = null;
        tmp74_AST = astFactory.create(LT(1));
        astFactory.makeASTRoot(currentAST, tmp74_AST);
        match(BARBAR);
        orExpr(contextToken, paraphrase);
        astFactory.addASTChild(currentAST, returnAST);
        break;
      }
      case EOF:
      case COMMA:
      case SEMICOLON:
      case COLONCOLON:
      case CLOSE_PAREN:
      case CLOSE_BRACKET:
      case CLOSE_BRACE:
      case BAR:
      case LITERAL_then:
      case LITERAL_else:
      case LITERAL_of:
      case DOLLAR:
      {
        break;
      }
      default:
      {
        throw new NoViableAltException(LT(1), getFilename());
      }
      }
      }
      orExpr_AST = (AST)currentAST.root;
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_86, _tokenSet_88);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_88);
      } else {
        throw ex;
      }
    }
    returnAST = orExpr_AST;
  }
  
  public final void andExpr(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST andExpr_AST = null;
    
    try {      // for error handling
      relationalExpr(contextToken, paraphrase);
      astFactory.addASTChild(currentAST, returnAST);
      {
      switch ( LA(1)) {
      case AMPERSANDAMPERSAND:
      {
        AST tmp75_AST = null;
        tmp75_AST = astFactory.create(LT(1));
        astFactory.makeASTRoot(currentAST, tmp75_AST);
        match(AMPERSANDAMPERSAND);
        andExpr(contextToken, paraphrase);
        astFactory.addASTChild(currentAST, returnAST);
        break;
      }
      case EOF:
      case COMMA:
      case SEMICOLON:
      case COLONCOLON:
      case CLOSE_PAREN:
      case CLOSE_BRACKET:
      case CLOSE_BRACE:
      case BAR:
      case LITERAL_then:
      case LITERAL_else:
      case LITERAL_of:
      case DOLLAR:
      case BARBAR:
      {
        break;
      }
      default:
      {
        throw new NoViableAltException(LT(1), getFilename());
      }
      }
      }
      andExpr_AST = (AST)currentAST.root;
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_86, _tokenSet_89);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_89);
      } else {
        throw ex;
      }
    }
    returnAST = andExpr_AST;
  }
  
  public final void relationalExpr(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST relationalExpr_AST = null;
    
    try {      // for error handling
      listOpExpr(contextToken, paraphrase);
      astFactory.addASTChild(currentAST, returnAST);
      {
      switch ( LA(1)) {
      case EQUALS:
      case LESS_THAN:
      case LESS_THAN_OR_EQUALS:
      case EQUALSEQUALS:
      case NOT_EQUALS:
      case GREATER_THAN_OR_EQUALS:
      case GREATER_THAN:
      {
        {
        switch ( LA(1)) {
        case LESS_THAN:
        {
          AST tmp76_AST = null;
          tmp76_AST = astFactory.create(LT(1));
          astFactory.makeASTRoot(currentAST, tmp76_AST);
          match(LESS_THAN);
          break;
        }
        case LESS_THAN_OR_EQUALS:
        {
          AST tmp77_AST = null;
          tmp77_AST = astFactory.create(LT(1));
          astFactory.makeASTRoot(currentAST, tmp77_AST);
          match(LESS_THAN_OR_EQUALS);
          break;
        }
        case EQUALSEQUALS:
        {
          AST tmp78_AST = null;
          tmp78_AST = astFactory.create(LT(1));
          astFactory.makeASTRoot(currentAST, tmp78_AST);
          match(EQUALSEQUALS);
          break;
        }
        case EQUALS:
        {
          AST tmp79_AST = null;
          tmp79_AST = astFactory.create(LT(1));
          astFactory.makeASTRoot(currentAST, tmp79_AST);
          match(EQUALS);
          if ( inputState.guessing==0 ) {
            reportWithSuggestion(LT(0), "the equality operator ('==')");
          }
          break;
        }
        case NOT_EQUALS:
        {
          AST tmp80_AST = null;
          tmp80_AST = astFactory.create(LT(1));
          astFactory.makeASTRoot(currentAST, tmp80_AST);
          match(NOT_EQUALS);
          break;
        }
        case GREATER_THAN_OR_EQUALS:
        {
          AST tmp81_AST = null;
          tmp81_AST = astFactory.create(LT(1));
          astFactory.makeASTRoot(currentAST, tmp81_AST);
          match(GREATER_THAN_OR_EQUALS);
          break;
        }
        case GREATER_THAN:
        {
          AST tmp82_AST = null;
          tmp82_AST = astFactory.create(LT(1));
          astFactory.makeASTRoot(currentAST, tmp82_AST);
          match(GREATER_THAN);
          break;
        }
        default:
        {
          throw new NoViableAltException(LT(1), getFilename());
        }
        }
        }
        listOpExpr(contextToken, paraphrase);
        astFactory.addASTChild(currentAST, returnAST);
        break;
      }
      case EOF:
      case COMMA:
      case SEMICOLON:
      case COLONCOLON:
      case CLOSE_PAREN:
      case CLOSE_BRACKET:
      case CLOSE_BRACE:
      case BAR:
      case LITERAL_then:
      case LITERAL_else:
      case LITERAL_of:
      case DOLLAR:
      case BARBAR:
      case AMPERSANDAMPERSAND:
      {
        break;
      }
      default:
      {
        throw new NoViableAltException(LT(1), getFilename());
      }
      }
      }
      relationalExpr_AST = (AST)currentAST.root;
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_86, _tokenSet_90);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_90);
      } else {
        throw ex;
      }
    }
    returnAST = relationalExpr_AST;
  }
  
  public final void listOpExpr(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST listOpExpr_AST = null;
    
    try {      // for error handling
      addExpr(contextToken, paraphrase);
      astFactory.addASTChild(currentAST, returnAST);
      {
      switch ( LA(1)) {
      case COLON:
      case PLUSPLUS:
      {
        {
        switch ( LA(1)) {
        case COLON:
        {
          AST tmp83_AST = null;
          tmp83_AST = astFactory.create(LT(1));
          astFactory.makeASTRoot(currentAST, tmp83_AST);
          match(COLON);
          break;
        }
        case PLUSPLUS:
        {
          AST tmp84_AST = null;
          tmp84_AST = astFactory.create(LT(1));
          astFactory.makeASTRoot(currentAST, tmp84_AST);
          match(PLUSPLUS);
          break;
        }
        default:
        {
          throw new NoViableAltException(LT(1), getFilename());
        }
        }
        }
        listOpExpr(contextToken, paraphrase);
        astFactory.addASTChild(currentAST, returnAST);
        break;
      }
      case EOF:
      case EQUALS:
      case COMMA:
      case SEMICOLON:
      case COLONCOLON:
      case CLOSE_PAREN:
      case CLOSE_BRACKET:
      case CLOSE_BRACE:
      case BAR:
      case LITERAL_then:
      case LITERAL_else:
      case LITERAL_of:
      case DOLLAR:
      case BARBAR:
      case AMPERSANDAMPERSAND:
      case LESS_THAN:
      case LESS_THAN_OR_EQUALS:
      case EQUALSEQUALS:
      case NOT_EQUALS:
      case GREATER_THAN_OR_EQUALS:
      case GREATER_THAN:
      {
        break;
      }
      default:
      {
        throw new NoViableAltException(LT(1), getFilename());
      }
      }
      }
      listOpExpr_AST = (AST)currentAST.root;
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_86, _tokenSet_91);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_91);
      } else {
        throw ex;
      }
    }
    returnAST = listOpExpr_AST;
  }
  
  public final void addExpr(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST addExpr_AST = null;
    
    try {      // for error handling
      multiplyExpr(contextToken, paraphrase);
      astFactory.addASTChild(currentAST, returnAST);
      {
      _loop181:
      do {
        if ((LA(1)==PLUS||LA(1)==MINUS)) {
          {
          switch ( LA(1)) {
          case PLUS:
          {
            AST tmp85_AST = null;
            tmp85_AST = astFactory.create(LT(1));
            astFactory.makeASTRoot(currentAST, tmp85_AST);
            match(PLUS);
            break;
          }
          case MINUS:
          {
            AST tmp86_AST = null;
            tmp86_AST = astFactory.create(LT(1));
            astFactory.makeASTRoot(currentAST, tmp86_AST);
            match(MINUS);
            break;
          }
          default:
          {
            throw new NoViableAltException(LT(1), getFilename());
          }
          }
          }
          multiplyExpr(contextToken, paraphrase);
          astFactory.addASTChild(currentAST, returnAST);
        }
        else {
          break _loop181;
        }
        
      } while (true);
      }
      addExpr_AST = (AST)currentAST.root;
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_86, _tokenSet_92);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_92);
      } else {
        throw ex;
      }
    }
    returnAST = addExpr_AST;
  }
  
  public final void multiplyExpr(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST multiplyExpr_AST = null;
    
    try {      // for error handling
      unaryExpr(contextToken, paraphrase);
      astFactory.addASTChild(currentAST, returnAST);
      {
      _loop185:
      do {
        if (((LA(1) >= ASTERISK && LA(1) <= PERCENT))) {
          {
          switch ( LA(1)) {
          case ASTERISK:
          {
            AST tmp87_AST = null;
            tmp87_AST = astFactory.create(LT(1));
            astFactory.makeASTRoot(currentAST, tmp87_AST);
            match(ASTERISK);
            break;
          }
          case SOLIDUS:
          {
            AST tmp88_AST = null;
            tmp88_AST = astFactory.create(LT(1));
            astFactory.makeASTRoot(currentAST, tmp88_AST);
            match(SOLIDUS);
            break;
          }
          case PERCENT:
          {
            AST tmp89_AST = null;
            tmp89_AST = astFactory.create(LT(1));
            astFactory.makeASTRoot(currentAST, tmp89_AST);
            match(PERCENT);
            break;
          }
          default:
          {
            throw new NoViableAltException(LT(1), getFilename());
          }
          }
          }
          unaryExpr(contextToken, paraphrase);
          astFactory.addASTChild(currentAST, returnAST);
        }
        else {
          break _loop185;
        }
        
      } while (true);
      }
      multiplyExpr_AST = (AST)currentAST.root;
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_86, _tokenSet_93);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_93);
      } else {
        throw ex;
      }
    }
    returnAST = multiplyExpr_AST;
  }
  
  public final void unaryExpr(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST unaryExpr_AST = null;
    Token  minusNode = null;
    AST minusNode_AST = null;
    
    try {      // for error handling
      switch ( LA(1)) {
      case MINUS:
      {
        minusNode = LT(1);
        minusNode_AST = astFactory.create(minusNode);
        astFactory.makeASTRoot(currentAST, minusNode_AST);
        match(MINUS);
        if ( inputState.guessing==0 ) {
          minusNode_AST.setType(UNARY_MINUS);
        }
        unaryExpr(contextToken, paraphrase);
        astFactory.addASTChild(currentAST, returnAST);
        unaryExpr_AST = (AST)currentAST.root;
        break;
      }
      case CONS_ID:
      case VAR_ID:
      case OPEN_PAREN:
      case OPEN_BRACKET:
      case OPEN_BRACE:
      case STRING_LITERAL:
      case CHAR_LITERAL:
      case INTEGER_LITERAL:
      case FLOAT_LITERAL:
      {
        userOpExpr(contextToken, paraphrase);
        astFactory.addASTChild(currentAST, returnAST);
        unaryExpr_AST = (AST)currentAST.root;
        break;
      }
      default:
      {
        throw new NoViableAltException(LT(1), getFilename());
      }
      }
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_86, _tokenSet_94);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_94);
      } else {
        throw ex;
      }
    }
    returnAST = unaryExpr_AST;
  }
  
  public final void userOpExpr(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST userOpExpr_AST = null;
    AST arg1_AST = null;
    AST opA_AST = null;
    AST arg2A_AST = null;
    Token  opB = null;
    AST opB_AST = null;
    AST arg2B_AST = null;
    AST result = null;
    
    try {      // for error handling
      applicationExpr(contextToken, paraphrase);
      arg1_AST = (AST)returnAST;
      if ( inputState.guessing==0 ) {
        result = arg1_AST;
      }
      {
      switch ( LA(1)) {
      case EOF:
      case EQUALS:
      case COMMA:
      case SEMICOLON:
      case COLONCOLON:
      case CLOSE_PAREN:
      case CLOSE_BRACKET:
      case CLOSE_BRACE:
      case BAR:
      case LITERAL_then:
      case LITERAL_else:
      case LITERAL_of:
      case DOLLAR:
      case BARBAR:
      case AMPERSANDAMPERSAND:
      case LESS_THAN:
      case LESS_THAN_OR_EQUALS:
      case EQUALSEQUALS:
      case NOT_EQUALS:
      case GREATER_THAN_OR_EQUALS:
      case GREATER_THAN:
      case COLON:
      case PLUSPLUS:
      case PLUS:
      case MINUS:
      case ASTERISK:
      case SOLIDUS:
      case PERCENT:
      case BACKQUOTE:
      {
        {
        _loop190:
        do {
          if ((LA(1)==BACKQUOTE)) {
            backquotedOperator(contextToken, paraphrase);
            opA_AST = (AST)returnAST;
            applicationExpr(contextToken, paraphrase);
            arg2A_AST = (AST)returnAST;
            if ( inputState.guessing==0 ) {
              result = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(BACKQUOTE,"`")).add((AST)astFactory.make( (new ASTArray(4)).add(astFactory.create(APPLICATION,"@")).add(opA_AST).add(result).add(arg2A_AST))));
            }
          }
          else {
            break _loop190;
          }
          
        } while (true);
        }
        break;
      }
      case POUND:
      {
        {
        opB = LT(1);
        opB_AST = astFactory.create(opB);
        match(POUND);
        composeOpExpr(contextToken, paraphrase);
        arg2B_AST = (AST)returnAST;
        if ( inputState.guessing==0 ) {
          result = (AST)astFactory.make( (new ASTArray(3)).add(opB_AST).add(result).add(arg2B_AST));
        }
        }
        break;
      }
      default:
      {
        throw new NoViableAltException(LT(1), getFilename());
      }
      }
      }
      if ( inputState.guessing==0 ) {
        userOpExpr_AST = (AST)currentAST.root;
        userOpExpr_AST = result;
        currentAST.root = userOpExpr_AST;
        currentAST.child = userOpExpr_AST!=null &&userOpExpr_AST.getFirstChild()!=null ?
          userOpExpr_AST.getFirstChild() : userOpExpr_AST;
        currentAST.advanceChildToEnd();
      }
      userOpExpr_AST = (AST)currentAST.root;
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_95, _tokenSet_94);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_94);
      } else {
        throw ex;
      }
    }
    returnAST = userOpExpr_AST;
  }
  
  public final void applicationExpr(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST applicationExpr_AST = null;
    
    try {      // for error handling
      {
      int _cnt200=0;
      _loop200:
      do {
        if ((_tokenSet_95.member(LA(1)))) {
          selectFieldExpr(contextToken, paraphrase);
          astFactory.addASTChild(currentAST, returnAST);
        }
        else {
          if ( _cnt200>=1 ) { break _loop200; } else {throw new NoViableAltException(LT(1), getFilename());}
        }
        
        _cnt200++;
      } while (true);
      }
      if ( inputState.guessing==0 ) {
        applicationExpr_AST = (AST)currentAST.root;
        applicationExpr_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(APPLICATION,"@")).add(applicationExpr_AST));
        currentAST.root = applicationExpr_AST;
        currentAST.child = applicationExpr_AST!=null &&applicationExpr_AST.getFirstChild()!=null ?
          applicationExpr_AST.getFirstChild() : applicationExpr_AST;
        currentAST.advanceChildToEnd();
      }
      applicationExpr_AST = (AST)currentAST.root;
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_95, _tokenSet_96);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_96);
      } else {
        throw ex;
      }
    }
    returnAST = applicationExpr_AST;
  }
  
  public final void backquotedOperator(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST backquotedOperator_AST = null;
    
    try {      // for error handling
      match(BACKQUOTE);
      {
      boolean synPredMatched195 = false;
      if (((LA(1)==CONS_ID||LA(1)==VAR_ID) && (LA(2)==DOT||LA(2)==BACKQUOTE))) {
        int _m195 = mark();
        synPredMatched195 = true;
        inputState.guessing++;
        try {
          {
          switch ( LA(1)) {
          case VAR_ID:
          {
            var();
            break;
          }
          case CONS_ID:
          {
            moduleName(null,null);
            match(DOT);
            var();
            break;
          }
          default:
          {
            throw new NoViableAltException(LT(1), getFilename());
          }
          }
          }
        }
        catch (RecognitionException pe) {
          synPredMatched195 = false;
        }
        rewind(_m195);
inputState.guessing--;
      }
      if ( synPredMatched195 ) {
        qualifiedVar(LT(1), "a function or method name");
        astFactory.addASTChild(currentAST, returnAST);
      }
      else if ((LA(1)==CONS_ID) && (LA(2)==DOT||LA(2)==BACKQUOTE)) {
        qualifiedCons(LT(1), "a data constructor name");
        astFactory.addASTChild(currentAST, returnAST);
      }
      else {
        throw new NoViableAltException(LT(1), getFilename());
      }
      
      }
      match(BACKQUOTE);
      backquotedOperator_AST = (AST)currentAST.root;
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_97, _tokenSet_95);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_95);
      } else {
        throw ex;
      }
    }
    returnAST = backquotedOperator_AST;
  }
  
  public final void composeOpExpr(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST composeOpExpr_AST = null;
    
    try {      // for error handling
      applicationExpr(contextToken, paraphrase);
      astFactory.addASTChild(currentAST, returnAST);
      {
      switch ( LA(1)) {
      case POUND:
      {
        AST tmp92_AST = null;
        tmp92_AST = astFactory.create(LT(1));
        astFactory.makeASTRoot(currentAST, tmp92_AST);
        match(POUND);
        composeOpExpr(contextToken, paraphrase);
        astFactory.addASTChild(currentAST, returnAST);
        break;
      }
      case EOF:
      case EQUALS:
      case COMMA:
      case SEMICOLON:
      case COLONCOLON:
      case CLOSE_PAREN:
      case CLOSE_BRACKET:
      case CLOSE_BRACE:
      case BAR:
      case LITERAL_then:
      case LITERAL_else:
      case LITERAL_of:
      case DOLLAR:
      case BARBAR:
      case AMPERSANDAMPERSAND:
      case LESS_THAN:
      case LESS_THAN_OR_EQUALS:
      case EQUALSEQUALS:
      case NOT_EQUALS:
      case GREATER_THAN_OR_EQUALS:
      case GREATER_THAN:
      case COLON:
      case PLUSPLUS:
      case PLUS:
      case MINUS:
      case ASTERISK:
      case SOLIDUS:
      case PERCENT:
      {
        break;
      }
      default:
      {
        throw new NoViableAltException(LT(1), getFilename());
      }
      }
      }
      composeOpExpr_AST = (AST)currentAST.root;
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_95, _tokenSet_94);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_94);
      } else {
        throw ex;
      }
    }
    returnAST = composeOpExpr_AST;
  }
  
  public final void selectFieldExpr(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST selectFieldExpr_AST = null;
    Token  selectRecordFieldNode = null;
    AST selectRecordFieldNode_AST = null;
    Token  selectDCFieldNode = null;
    AST selectDCFieldNode_AST = null;
    
    try {      // for error handling
      atomicExpr(contextToken, paraphrase);
      astFactory.addASTChild(currentAST, returnAST);
      {
      _loop208:
      do {
        if ((LA(1)==DOT) && (LA(2)==VAR_ID||LA(2)==ORDINAL_FIELD_NAME)) {
          {
          selectRecordFieldNode = LT(1);
          selectRecordFieldNode_AST = astFactory.create(selectRecordFieldNode);
          astFactory.makeASTRoot(currentAST, selectRecordFieldNode_AST);
          match(DOT);
          if ( inputState.guessing==0 ) {
            selectRecordFieldNode_AST.initialize (SELECT_RECORD_FIELD, "SELECT_RECORD_FIELD");
          }
          fieldName(LT(1), "a valid record-field name");
          astFactory.addASTChild(currentAST, returnAST);
          }
        }
        else if ((LA(1)==DOT) && (LA(2)==CONS_ID)) {
          {
          selectDCFieldNode = LT(1);
          selectDCFieldNode_AST = astFactory.create(selectDCFieldNode);
          astFactory.makeASTRoot(currentAST, selectDCFieldNode_AST);
          match(DOT);
          if ( inputState.guessing==0 ) {
            selectDCFieldNode_AST.initialize (SELECT_DATA_CONSTRUCTOR_FIELD, "SELECT_DATA_CONSTRUCTOR_FIELD");
          }
          {
          boolean synPredMatched207 = false;
          if (((LA(1)==CONS_ID) && (LA(2)==DOT))) {
            int _m207 = mark();
            synPredMatched207 = true;
            inputState.guessing++;
            try {
              {
              cons();
              match(DOT);
              cons();
              }
            }
            catch (RecognitionException pe) {
              synPredMatched207 = false;
            }
            rewind(_m207);
inputState.guessing--;
          }
          if ( synPredMatched207 ) {
            qualifiedCons_qualified(LT(1), "a qualified data constructor name");
            astFactory.addASTChild(currentAST, returnAST);
          }
          else if ((LA(1)==CONS_ID) && (LA(2)==DOT)) {
            qualifiedCons_unqualified(LT(1), "a constructor name");
            astFactory.addASTChild(currentAST, returnAST);
          }
          else {
            throw new NoViableAltException(LT(1), getFilename());
          }
          
          }
          match(DOT);
          fieldName(LT(1), "a valid field name");
          astFactory.addASTChild(currentAST, returnAST);
          }
        }
        else {
          break _loop208;
        }
        
      } while (true);
      }
      selectFieldExpr_AST = (AST)currentAST.root;
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_95, _tokenSet_98);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_98);
      } else {
        throw ex;
      }
    }
    returnAST = selectFieldExpr_AST;
  }
  
  public final void atomicExpr(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST atomicExpr_AST = null;
    Token  openParenNode = null;
    AST openParenNode_AST = null;
    Token  closeParenNode = null;
    AST closeParenNode_AST = null;
    Token  openBracketNode = null;
    AST openBracketNode_AST = null;
    Token  closeBracketNode = null;
    AST closeBracketNode_AST = null;
    
    try {      // for error handling
      switch ( LA(1)) {
      case STRING_LITERAL:
      case CHAR_LITERAL:
      case INTEGER_LITERAL:
      case FLOAT_LITERAL:
      {
        literal(contextToken, paraphrase);
        astFactory.addASTChild(currentAST, returnAST);
        atomicExpr_AST = (AST)currentAST.root;
        break;
      }
      case OPEN_PAREN:
      {
        openParenNode = LT(1);
        openParenNode_AST = astFactory.create(openParenNode);
        astFactory.makeASTRoot(currentAST, openParenNode_AST);
        match(OPEN_PAREN);
        if ( inputState.guessing==0 ) {
          openParenNode_AST.initialize (TUPLE_CONSTRUCTOR, "Tuple");
        }
        exprListZeroOrMore(LT(1), "a comma-separated list of expressions");
        astFactory.addASTChild(currentAST, returnAST);
        closeParenNode = LT(1);
        closeParenNode_AST = astFactory.create(closeParenNode);
        match(CLOSE_PAREN);
        if ( inputState.guessing==0 ) {
          ((ParseTreeNode)openParenNode_AST).addOmittedDelimiter(closeParenNode_AST);
        }
        atomicExpr_AST = (AST)currentAST.root;
        break;
      }
      case OPEN_BRACKET:
      {
        openBracketNode = LT(1);
        openBracketNode_AST = astFactory.create(openBracketNode);
        astFactory.makeASTRoot(currentAST, openBracketNode_AST);
        match(OPEN_BRACKET);
        if ( inputState.guessing==0 ) {
          openBracketNode_AST.initialize (LIST_CONSTRUCTOR, "List");
        }
        exprListZeroOrMore(LT(1), "a comma-separated list of expressions");
        astFactory.addASTChild(currentAST, returnAST);
        closeBracketNode = LT(1);
        closeBracketNode_AST = astFactory.create(closeBracketNode);
        match(CLOSE_BRACKET);
        if ( inputState.guessing==0 ) {
          ((ParseTreeNode)openBracketNode_AST).addOmittedDelimiter(closeBracketNode_AST);
        }
        atomicExpr_AST = (AST)currentAST.root;
        break;
      }
      case OPEN_BRACE:
      {
        recordValue(contextToken, paraphrase);
        astFactory.addASTChild(currentAST, returnAST);
        atomicExpr_AST = (AST)currentAST.root;
        break;
      }
      default:
        boolean synPredMatched211 = false;
        if (((LA(1)==CONS_ID||LA(1)==VAR_ID) && (_tokenSet_99.member(LA(2))))) {
          int _m211 = mark();
          synPredMatched211 = true;
          inputState.guessing++;
          try {
            {
            switch ( LA(1)) {
            case VAR_ID:
            {
              var();
              break;
            }
            case CONS_ID:
            {
              moduleName(null, null);
              match(DOT);
              var();
              break;
            }
            default:
            {
              throw new NoViableAltException(LT(1), getFilename());
            }
            }
            }
          }
          catch (RecognitionException pe) {
            synPredMatched211 = false;
          }
          rewind(_m211);
inputState.guessing--;
        }
        if ( synPredMatched211 ) {
          qualifiedVar(contextToken, paraphrase);
          astFactory.addASTChild(currentAST, returnAST);
          atomicExpr_AST = (AST)currentAST.root;
        }
        else if ((LA(1)==CONS_ID) && (_tokenSet_99.member(LA(2)))) {
          qualifiedCons(contextToken, paraphrase);
          astFactory.addASTChild(currentAST, returnAST);
          atomicExpr_AST = (AST)currentAST.root;
        }
      else {
        throw new NoViableAltException(LT(1), getFilename());
      }
      }
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_95, _tokenSet_99);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_99);
      } else {
        throw ex;
      }
    }
    returnAST = atomicExpr_AST;
  }
  
  public final void qualifiedCons_qualified(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST qualifiedCons_qualified_AST = null;
    AST bareCons_AST = null;
    Token  dot = null;
    AST dot_AST = null;
    
    try {      // for error handling
      cons();
      bareCons_AST = (AST)returnAST;
      astFactory.addASTChild(currentAST, returnAST);
      if ( inputState.guessing==0 ) {
        qualifiedCons_qualified_AST = (AST)currentAST.root;
        qualifiedCons_qualified_AST = (AST)astFactory.make( (new ASTArray(3)).add(astFactory.create(HIERARCHICAL_MODULE_NAME,"HIERARCHICAL_MODULE_NAME")).add(astFactory.create(HIERARCHICAL_MODULE_NAME_EMPTY_QUALIFIER,"HIERARCHICAL_MODULE_NAME_EMPTY_QUALIFIER")).add(bareCons_AST));
        currentAST.root = qualifiedCons_qualified_AST;
        currentAST.child = qualifiedCons_qualified_AST!=null &&qualifiedCons_qualified_AST.getFirstChild()!=null ?
          qualifiedCons_qualified_AST.getFirstChild() : qualifiedCons_qualified_AST;
        currentAST.advanceChildToEnd();
      }
      {
      int _cnt234=0;
      _loop234:
      do {
        if ((LA(1)==DOT) && (LA(2)==CONS_ID)) {
          dot = LT(1);
          dot_AST = astFactory.create(dot);
          astFactory.makeASTRoot(currentAST, dot_AST);
          match(DOT);
          if ( inputState.guessing==0 ) {
            dot_AST.initialize(HIERARCHICAL_MODULE_NAME, "HIERARCHICAL_MODULE_NAME");
          }
          cons();
          astFactory.addASTChild(currentAST, returnAST);
        }
        else {
          if ( _cnt234>=1 ) { break _loop234; } else {throw new NoViableAltException(LT(1), getFilename());}
        }
        
        _cnt234++;
      } while (true);
      }
      if ( inputState.guessing==0 ) {
        qualifiedCons_qualified_AST = (AST)currentAST.root;
        qualifiedCons_qualified_AST.initialize(QUALIFIED_CONS, "QUALIFIED_CONS");
      }
      qualifiedCons_qualified_AST = (AST)currentAST.root;
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_17, _tokenSet_48);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_48);
      } else {
        throw ex;
      }
    }
    returnAST = qualifiedCons_qualified_AST;
  }
  
  public final void qualifiedCons_unqualified(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST qualifiedCons_unqualified_AST = null;
    
    try {      // for error handling
      cons();
      astFactory.addASTChild(currentAST, returnAST);
      if ( inputState.guessing==0 ) {
        qualifiedCons_unqualified_AST = (AST)currentAST.root;
        qualifiedCons_unqualified_AST = (AST)astFactory.make( (new ASTArray(3)).add(astFactory.create(QUALIFIED_CONS,"QUALIFIED_CONS")).add(astFactory.create(HIERARCHICAL_MODULE_NAME_EMPTY_QUALIFIER,"HIERARCHICAL_MODULE_NAME_EMPTY_QUALIFIER")).add(qualifiedCons_unqualified_AST));
        currentAST.root = qualifiedCons_unqualified_AST;
        currentAST.child = qualifiedCons_unqualified_AST!=null &&qualifiedCons_unqualified_AST.getFirstChild()!=null ?
          qualifiedCons_unqualified_AST.getFirstChild() : qualifiedCons_unqualified_AST;
        currentAST.advanceChildToEnd();
      }
      qualifiedCons_unqualified_AST = (AST)currentAST.root;
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_17, _tokenSet_48);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_48);
      } else {
        throw ex;
      }
    }
    returnAST = qualifiedCons_unqualified_AST;
  }
  
  public final void literal(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST literal_AST = null;
    
    try {      // for error handling
      switch ( LA(1)) {
      case INTEGER_LITERAL:
      {
        AST tmp94_AST = null;
        tmp94_AST = astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp94_AST);
        match(INTEGER_LITERAL);
        literal_AST = (AST)currentAST.root;
        break;
      }
      case FLOAT_LITERAL:
      {
        AST tmp95_AST = null;
        tmp95_AST = astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp95_AST);
        match(FLOAT_LITERAL);
        literal_AST = (AST)currentAST.root;
        break;
      }
      case CHAR_LITERAL:
      {
        AST tmp96_AST = null;
        tmp96_AST = astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp96_AST);
        match(CHAR_LITERAL);
        literal_AST = (AST)currentAST.root;
        break;
      }
      case STRING_LITERAL:
      {
        AST tmp97_AST = null;
        tmp97_AST = astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp97_AST);
        match(STRING_LITERAL);
        literal_AST = (AST)currentAST.root;
        break;
      }
      default:
      {
        throw new NoViableAltException(LT(1), getFilename());
      }
      }
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_100, _tokenSet_99);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_99);
      } else {
        throw ex;
      }
    }
    returnAST = literal_AST;
  }
  
  public final void exprListZeroOrMore(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST exprListZeroOrMore_AST = null;
    
    try {      // for error handling
      {
      switch ( LA(1)) {
      case CONS_ID:
      case VAR_ID:
      case OPEN_PAREN:
      case BACKSLASH:
      case OPEN_BRACKET:
      case OPEN_BRACE:
      case STRING_LITERAL:
      case LITERAL_let:
      case LITERAL_if:
      case LITERAL_case:
      case MINUS:
      case CHAR_LITERAL:
      case INTEGER_LITERAL:
      case FLOAT_LITERAL:
      {
        expr(contextToken, paraphrase);
        astFactory.addASTChild(currentAST, returnAST);
        {
        _loop227:
        do {
          if ((LA(1)==COMMA)) {
            match(COMMA);
            expr(contextToken, paraphrase);
            astFactory.addASTChild(currentAST, returnAST);
          }
          else {
            break _loop227;
          }
          
        } while (true);
        }
        break;
      }
      case CLOSE_PAREN:
      case CLOSE_BRACKET:
      {
        break;
      }
      default:
      {
        throw new NoViableAltException(LT(1), getFilename());
      }
      }
      }
      exprListZeroOrMore_AST = (AST)currentAST.root;
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_101, _tokenSet_102);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_102);
      } else {
        throw ex;
      }
    }
    returnAST = exprListZeroOrMore_AST;
  }
  
  public final void recordValue(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST recordValue_AST = null;
    Token  openBraceNode = null;
    AST openBraceNode_AST = null;
    Token  closeBraceNode = null;
    AST closeBraceNode_AST = null;
    
    try {      // for error handling
      openBraceNode = LT(1);
      openBraceNode_AST = astFactory.create(openBraceNode);
      astFactory.makeASTRoot(currentAST, openBraceNode_AST);
      match(OPEN_BRACE);
      if ( inputState.guessing==0 ) {
        openBraceNode_AST.initialize (RECORD_CONSTRUCTOR, "Record");
      }
      baseRecord(LT(1), "a base-record expression");
      astFactory.addASTChild(currentAST, returnAST);
      fieldModificationList(LT(1), "a list of field extensions or field value updates");
      astFactory.addASTChild(currentAST, returnAST);
      closeBraceNode = LT(1);
      closeBraceNode_AST = astFactory.create(closeBraceNode);
      match(CLOSE_BRACE);
      if ( inputState.guessing==0 ) {
        ((ParseTreeNode)openBraceNode_AST).addOmittedDelimiter(closeBraceNode_AST);
      }
      recordValue_AST = (AST)currentAST.root;
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_54, _tokenSet_99);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_99);
      } else {
        throw ex;
      }
    }
    returnAST = recordValue_AST;
  }
  
  public final void baseRecord(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST baseRecord_AST = null;
    
    try {      // for error handling
      boolean synPredMatched215 = false;
      if (((_tokenSet_1.member(LA(1))) && (_tokenSet_103.member(LA(2))))) {
        int _m215 = mark();
        synPredMatched215 = true;
        inputState.guessing++;
        try {
          {
          expr(null,null);
          match(BAR);
          }
        }
        catch (RecognitionException pe) {
          synPredMatched215 = false;
        }
        rewind(_m215);
inputState.guessing--;
      }
      if ( synPredMatched215 ) {
        {
        expr(LT(1), "a base-record expression");
        astFactory.addASTChild(currentAST, returnAST);
        match(BAR);
        }
        if ( inputState.guessing==0 ) {
          baseRecord_AST = (AST)currentAST.root;
          baseRecord_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(BASE_RECORD,"BASE_RECORD")).add(baseRecord_AST));
          currentAST.root = baseRecord_AST;
          currentAST.child = baseRecord_AST!=null &&baseRecord_AST.getFirstChild()!=null ?
            baseRecord_AST.getFirstChild() : baseRecord_AST;
          currentAST.advanceChildToEnd();
        }
        baseRecord_AST = (AST)currentAST.root;
      }
      else if ((_tokenSet_55.member(LA(1))) && (_tokenSet_104.member(LA(2)))) {
        if ( inputState.guessing==0 ) {
          baseRecord_AST = (AST)currentAST.root;
          baseRecord_AST = (AST)astFactory.make( (new ASTArray(1)).add(astFactory.create(BASE_RECORD,"BASE_RECORD")));
          currentAST.root = baseRecord_AST;
          currentAST.child = baseRecord_AST!=null &&baseRecord_AST.getFirstChild()!=null ?
            baseRecord_AST.getFirstChild() : baseRecord_AST;
          currentAST.advanceChildToEnd();
        }
        baseRecord_AST = (AST)currentAST.root;
      }
      else {
        throw new NoViableAltException(LT(1), getFilename());
      }
      
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_105, _tokenSet_55);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_55);
      } else {
        throw ex;
      }
    }
    returnAST = baseRecord_AST;
  }
  
  public final void fieldModificationList(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST fieldModificationList_AST = null;
    
    try {      // for error handling
      {
      switch ( LA(1)) {
      case VAR_ID:
      case ORDINAL_FIELD_NAME:
      {
        fieldModification(LT(1), "a field extension or field value update");
        astFactory.addASTChild(currentAST, returnAST);
        {
        _loop220:
        do {
          if ((LA(1)==COMMA)) {
            match(COMMA);
            fieldModification(LT(1), "a field extension or field value update");
            astFactory.addASTChild(currentAST, returnAST);
          }
          else {
            break _loop220;
          }
          
        } while (true);
        }
        break;
      }
      case CLOSE_BRACE:
      {
        break;
      }
      default:
      {
        throw new NoViableAltException(LT(1), getFilename());
      }
      }
      }
      if ( inputState.guessing==0 ) {
        fieldModificationList_AST = (AST)currentAST.root;
        fieldModificationList_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(FIELD_MODIFICATION_LIST,"FIELD_MODIFICATION_LIST")).add(fieldModificationList_AST));
        currentAST.root = fieldModificationList_AST;
        currentAST.child = fieldModificationList_AST!=null &&fieldModificationList_AST.getFirstChild()!=null ?
          fieldModificationList_AST.getFirstChild() : fieldModificationList_AST;
        currentAST.advanceChildToEnd();
      }
      fieldModificationList_AST = (AST)currentAST.root;
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_55, _tokenSet_57);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_57);
      } else {
        throw ex;
      }
    }
    returnAST = fieldModificationList_AST;
  }
  
  public final void fieldModification(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST fieldModification_AST = null;
    Token  node = null;
    AST node_AST = null;
    Token  node2 = null;
    AST node2_AST = null;
    
    try {      // for error handling
      fieldName(LT(1), "a valid record-field name");
      astFactory.addASTChild(currentAST, returnAST);
      {
      switch ( LA(1)) {
      case EQUALS:
      {
        node = LT(1);
        node_AST = astFactory.create(node);
        astFactory.makeASTRoot(currentAST, node_AST);
        match(EQUALS);
        if ( inputState.guessing==0 ) {
          node_AST.initialize (FIELD_EXTENSION, "FIELD_EXTENSION");
        }
        break;
      }
      case COLONEQUALS:
      {
        node2 = LT(1);
        node2_AST = astFactory.create(node2);
        astFactory.makeASTRoot(currentAST, node2_AST);
        match(COLONEQUALS);
        if ( inputState.guessing==0 ) {
          node2_AST.initialize (FIELD_VALUE_UPDATE, "FIELD_VALUE_UPDATE");
        }
        break;
      }
      default:
      {
        throw new NoViableAltException(LT(1), getFilename());
      }
      }
      }
      expr(LT(1), "an expression");
      astFactory.addASTChild(currentAST, returnAST);
      fieldModification_AST = (AST)currentAST.root;
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_49, _tokenSet_58);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_58);
      } else {
        throw ex;
      }
    }
    returnAST = fieldModification_AST;
  }
  
  public final void letDefnOrTypeDeclarationOrPatternMatchDecl(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST letDefnOrTypeDeclarationOrPatternMatchDecl_AST = null;
    AST doc_AST = null;
    
    try {      // for error handling
      optionalDocComment();
      doc_AST = (AST)returnAST;
      {
      boolean synPredMatched243 = false;
      if (((_tokenSet_85.member(LA(1))) && (_tokenSet_106.member(LA(2))))) {
        int _m243 = mark();
        synPredMatched243 = true;
        inputState.guessing++;
        try {
          {
          switch ( LA(1)) {
          case CONS_ID:
          {
            match(CONS_ID);
            break;
          }
          case OPEN_PAREN:
          {
            match(OPEN_PAREN);
            break;
          }
          case OPEN_BRACE:
          {
            match(OPEN_BRACE);
            break;
          }
          case OPEN_BRACKET:
          {
            match(OPEN_BRACKET);
            break;
          }
          case CHAR_LITERAL:
          {
            match(CHAR_LITERAL);
            break;
          }
          case INTEGER_LITERAL:
          {
            match(INTEGER_LITERAL);
            break;
          }
          case MINUS:
          {
            match(MINUS);
            break;
          }
          default:
            if ((LA(1)==VAR_ID||LA(1)==UNDERSCORE) && (LA(2)==COLON)) {
              {
              switch ( LA(1)) {
              case VAR_ID:
              {
                match(VAR_ID);
                break;
              }
              case UNDERSCORE:
              {
                match(UNDERSCORE);
                break;
              }
              default:
              {
                throw new NoViableAltException(LT(1), getFilename());
              }
              }
              }
              match(COLON);
            }
            else if ((LA(1)==UNDERSCORE) && (true)) {
              match(UNDERSCORE);
            }
          else {
            throw new NoViableAltException(LT(1), getFilename());
          }
          }
          }
        }
        catch (RecognitionException pe) {
          synPredMatched243 = false;
        }
        rewind(_m243);
inputState.guessing--;
      }
      if ( synPredMatched243 ) {
        letPatternMatchDecl(doc_AST, LT(1), "a local pattern match declaration");
        astFactory.addASTChild(currentAST, returnAST);
      }
      else if ((LA(1)==VAR_ID) && (_tokenSet_14.member(LA(2)))) {
        letDefnWithOptionalDocComment(doc_AST, LT(1), "a let definition");
        astFactory.addASTChild(currentAST, returnAST);
      }
      else if ((LA(1)==VAR_ID) && (LA(2)==COLONCOLON)) {
        letDefnTypeDeclarationWithOptionalDocComment(doc_AST, LT(1), "a type declaration for a let definition");
        astFactory.addASTChild(currentAST, returnAST);
      }
      else {
        throw new NoViableAltException(LT(1), getFilename());
      }
      
      }
      letDefnOrTypeDeclarationOrPatternMatchDecl_AST = (AST)currentAST.root;
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_83, _tokenSet_38);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_38);
      } else {
        throw ex;
      }
    }
    returnAST = letDefnOrTypeDeclarationOrPatternMatchDecl_AST;
  }
  
  public final void letPatternMatchDecl(
    AST doc, Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST letPatternMatchDecl_AST = null;
    Token  node = null;
    AST node_AST = null;
    
    try {      // for error handling
      letPatternMatchPattern(LT(1), "a pattern for a local pattern match declaration");
      astFactory.addASTChild(currentAST, returnAST);
      node = LT(1);
      node_AST = astFactory.create(node);
      astFactory.makeASTRoot(currentAST, node_AST);
      match(EQUALS);
      if ( inputState.guessing==0 ) {
        node_AST.initialize (LET_PATTERN_MATCH_DECL, "LET_PATTERN_MATCH_DECL");
      }
      expr(LT(1), "valid defining expression for a local pattern match declaration");
      astFactory.addASTChild(currentAST, returnAST);
      match(SEMICOLON);
      if ( inputState.guessing==0 ) {
        
          if (doc != null && doc.getFirstChild() != null) {
        // a CALDoc comment is not allowed for a pattern match decl
        reportLocalPatternMatchDeclCannotHaveCALDocComment((ParseTreeNode)doc.getFirstChild());
          }
        
      }
      letPatternMatchDecl_AST = (AST)currentAST.root;
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_85, _tokenSet_38);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_38);
      } else {
        throw ex;
      }
    }
    returnAST = letPatternMatchDecl_AST;
  }
  
  public final void letDefnWithOptionalDocComment(
    AST doc, Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST letDefnWithOptionalDocComment_AST = null;
    Token  node = null;
    AST node_AST = null;
    Token  semicolonNode = null;
    AST semicolonNode_AST = null;
    
    try {      // for error handling
      functionName(LT(1), "a function name for a let definition");
      astFactory.addASTChild(currentAST, returnAST);
      functionParamList(LT(1), "a list of function parameters for a let definition");
      astFactory.addASTChild(currentAST, returnAST);
      node = LT(1);
      node_AST = astFactory.create(node);
      astFactory.makeASTRoot(currentAST, node_AST);
      match(EQUALS);
      if ( inputState.guessing==0 ) {
        node_AST.initialize (LET_DEFN, "LET_DEFN");
      }
      expr(LT(1), "valid defining expression for a let definition");
      astFactory.addASTChild(currentAST, returnAST);
      semicolonNode = LT(1);
      semicolonNode_AST = astFactory.create(semicolonNode);
      match(SEMICOLON);
      if ( inputState.guessing==0 ) {
        letDefnWithOptionalDocComment_AST = (AST)currentAST.root;
        ((ParseTreeNode)letDefnWithOptionalDocComment_AST).addOmittedDelimiter(semicolonNode_AST);
      }
      if ( inputState.guessing==0 ) {
        letDefnWithOptionalDocComment_AST = (AST)currentAST.root;
        
        AST firstChild = letDefnWithOptionalDocComment_AST.getFirstChild();
        doc.setNextSibling(firstChild);
        letDefnWithOptionalDocComment_AST.setFirstChild(doc);
        
      }
      letDefnWithOptionalDocComment_AST = (AST)currentAST.root;
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_15, _tokenSet_38);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_38);
      } else {
        throw ex;
      }
    }
    returnAST = letDefnWithOptionalDocComment_AST;
  }
  
  public final void letPatternMatchPattern(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST letPatternMatchPattern_AST = null;
    Token  openParenNode = null;
    AST openParenNode_AST = null;
    Token  closeParenNode = null;
    AST closeParenNode_AST = null;
    AST dataConstructorNameListOneOrMore_AST = null;
    Token  openBracketNode = null;
    AST openBracketNode_AST = null;
    AST maybeMinusIntSingleton_AST = null;
    AST maybeMinusIntListOneOrMore_AST = null;
    AST charSingleton_AST = null;
    AST charListOneOrMore_AST = null;
    AST wildcard_AST = null;
    
    try {      // for error handling
      switch ( LA(1)) {
      case CONS_ID:
      {
        dataConstructorSingleton(contextToken, paraphrase);
        astFactory.addASTChild(currentAST, returnAST);
        dataConstructorArgumentBindings(contextToken, paraphrase);
        astFactory.addASTChild(currentAST, returnAST);
        if ( inputState.guessing==0 ) {
          letPatternMatchPattern_AST = (AST)currentAST.root;
          letPatternMatchPattern_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(PATTERN_CONSTRUCTOR,"PATTERN_CONSTRUCTOR")).add(letPatternMatchPattern_AST));
          currentAST.root = letPatternMatchPattern_AST;
          currentAST.child = letPatternMatchPattern_AST!=null &&letPatternMatchPattern_AST.getFirstChild()!=null ?
            letPatternMatchPattern_AST.getFirstChild() : letPatternMatchPattern_AST;
          currentAST.advanceChildToEnd();
        }
        letPatternMatchPattern_AST = (AST)currentAST.root;
        break;
      }
      case OPEN_BRACE:
      {
        recordPattern(contextToken, paraphrase);
        astFactory.addASTChild(currentAST, returnAST);
        letPatternMatchPattern_AST = (AST)currentAST.root;
        break;
      }
      case OPEN_BRACKET:
      {
        openBracketNode = LT(1);
        openBracketNode_AST = astFactory.create(openBracketNode);
        astFactory.makeASTRoot(currentAST, openBracketNode_AST);
        match(OPEN_BRACKET);
        match(CLOSE_BRACKET);
        if ( inputState.guessing==0 ) {
          reportInvalidLocalPatternMatchNilPatternError((ParseTreeNode)openBracketNode_AST);
        }
        letPatternMatchPattern_AST = (AST)currentAST.root;
        break;
      }
      case MINUS:
      case INTEGER_LITERAL:
      {
        maybeMinusIntSingleton(contextToken, paraphrase);
        maybeMinusIntSingleton_AST = (AST)returnAST;
        astFactory.addASTChild(currentAST, returnAST);
        if ( inputState.guessing==0 ) {
          reportInvalidLocalPatternMatchIntPatternError((ParseTreeNode)maybeMinusIntSingleton_AST);
        }
        letPatternMatchPattern_AST = (AST)currentAST.root;
        break;
      }
      case CHAR_LITERAL:
      {
        charSingleton();
        charSingleton_AST = (AST)returnAST;
        astFactory.addASTChild(currentAST, returnAST);
        if ( inputState.guessing==0 ) {
          reportInvalidLocalPatternMatchCharPatternError((ParseTreeNode)charSingleton_AST);
        }
        letPatternMatchPattern_AST = (AST)currentAST.root;
        break;
      }
      default:
        if ((LA(1)==OPEN_PAREN) && (_tokenSet_107.member(LA(2)))) {
          openParenNode = LT(1);
          openParenNode_AST = astFactory.create(openParenNode);
          astFactory.makeASTRoot(currentAST, openParenNode_AST);
          match(OPEN_PAREN);
          if ( inputState.guessing==0 ) {
            openParenNode_AST.initialize (TUPLE_CONSTRUCTOR, "Tuple");
          }
          {
          switch ( LA(1)) {
          case VAR_ID:
          case UNDERSCORE:
          {
            patternVar(contextToken, paraphrase);
            astFactory.addASTChild(currentAST, returnAST);
            {
            _loop249:
            do {
              if ((LA(1)==COMMA)) {
                match(COMMA);
                patternVar(contextToken, paraphrase);
                astFactory.addASTChild(currentAST, returnAST);
              }
              else {
                break _loop249;
              }
              
            } while (true);
            }
            break;
          }
          case CLOSE_PAREN:
          {
            break;
          }
          default:
          {
            throw new NoViableAltException(LT(1), getFilename());
          }
          }
          }
          closeParenNode = LT(1);
          closeParenNode_AST = astFactory.create(closeParenNode);
          match(CLOSE_PAREN);
          if ( inputState.guessing==0 ) {
            ((ParseTreeNode)openParenNode_AST).addOmittedDelimiter(closeParenNode_AST);
          }
          letPatternMatchPattern_AST = (AST)currentAST.root;
        }
        else if ((LA(1)==VAR_ID||LA(1)==UNDERSCORE) && (LA(2)==COLON)) {
          patternVar(contextToken, paraphrase);
          astFactory.addASTChild(currentAST, returnAST);
          AST tmp104_AST = null;
          tmp104_AST = astFactory.create(LT(1));
          astFactory.makeASTRoot(currentAST, tmp104_AST);
          match(COLON);
          patternVar(contextToken, paraphrase);
          astFactory.addASTChild(currentAST, returnAST);
          letPatternMatchPattern_AST = (AST)currentAST.root;
        }
        else if ((LA(1)==OPEN_PAREN) && (LA(2)==CONS_ID)) {
          dataConstructorNameListOneOrMore(contextToken, paraphrase);
          dataConstructorNameListOneOrMore_AST = (AST)returnAST;
          astFactory.addASTChild(currentAST, returnAST);
          dataConstructorArgumentBindings(contextToken, paraphrase);
          astFactory.addASTChild(currentAST, returnAST);
          if ( inputState.guessing==0 ) {
            reportInvalidLocalPatternMatchMultipleDataConsPatternError((ParseTreeNode)dataConstructorNameListOneOrMore_AST);
          }
          letPatternMatchPattern_AST = (AST)currentAST.root;
        }
        else if ((LA(1)==OPEN_PAREN) && (LA(2)==MINUS||LA(2)==INTEGER_LITERAL)) {
          maybeMinusIntListOneOrMore(contextToken, paraphrase);
          maybeMinusIntListOneOrMore_AST = (AST)returnAST;
          astFactory.addASTChild(currentAST, returnAST);
          if ( inputState.guessing==0 ) {
            reportInvalidLocalPatternMatchIntPatternError((ParseTreeNode)maybeMinusIntListOneOrMore_AST);
          }
          letPatternMatchPattern_AST = (AST)currentAST.root;
        }
        else if ((LA(1)==OPEN_PAREN) && (LA(2)==CHAR_LITERAL)) {
          charListOneOrMore();
          charListOneOrMore_AST = (AST)returnAST;
          astFactory.addASTChild(currentAST, returnAST);
          if ( inputState.guessing==0 ) {
            reportInvalidLocalPatternMatchCharPatternError((ParseTreeNode)charListOneOrMore_AST);
          }
          letPatternMatchPattern_AST = (AST)currentAST.root;
        }
        else if ((LA(1)==UNDERSCORE) && (LA(2)==EQUALS)) {
          wildcard();
          wildcard_AST = (AST)returnAST;
          astFactory.addASTChild(currentAST, returnAST);
          if ( inputState.guessing==0 ) {
            reportInvalidLocalPatternMatchWildcardPatternError((ParseTreeNode)wildcard_AST);
          }
          letPatternMatchPattern_AST = (AST)currentAST.root;
        }
      else {
        throw new NoViableAltException(LT(1), getFilename());
      }
      }
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_85, _tokenSet_62);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_62);
      } else {
        throw ex;
      }
    }
    returnAST = letPatternMatchPattern_AST;
  }
  
  public final void dataConstructorSingleton(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST dataConstructorSingleton_AST = null;
    
    try {      // for error handling
      qualifiedCons(contextToken, paraphrase);
      astFactory.addASTChild(currentAST, returnAST);
      if ( inputState.guessing==0 ) {
        dataConstructorSingleton_AST = (AST)currentAST.root;
        dataConstructorSingleton_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(DATA_CONSTRUCTOR_NAME_SINGLETON,"DATA_CONSTRUCTOR_NAME_SINGLETON")).add(dataConstructorSingleton_AST));
        currentAST.root = dataConstructorSingleton_AST;
        currentAST.child = dataConstructorSingleton_AST!=null &&dataConstructorSingleton_AST.getFirstChild()!=null ?
          dataConstructorSingleton_AST.getFirstChild() : dataConstructorSingleton_AST;
        currentAST.advanceChildToEnd();
      }
      dataConstructorSingleton_AST = (AST)currentAST.root;
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_17, _tokenSet_108);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_108);
      } else {
        throw ex;
      }
    }
    returnAST = dataConstructorSingleton_AST;
  }
  
  public final void dataConstructorArgumentBindings(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST dataConstructorArgumentBindings_AST = null;
    
    try {      // for error handling
      switch ( LA(1)) {
      case VAR_ID:
      case EQUALS:
      case RARROW:
      case UNDERSCORE:
      {
        patternVarListZeroOrMore(LT(1), "a list of field names");
        astFactory.addASTChild(currentAST, returnAST);
        dataConstructorArgumentBindings_AST = (AST)currentAST.root;
        break;
      }
      case OPEN_BRACE:
      {
        match(OPEN_BRACE);
        fieldBindingVarAssignmentList(LT(1), "a list of comma-separated field bindings");
        astFactory.addASTChild(currentAST, returnAST);
        match(CLOSE_BRACE);
        dataConstructorArgumentBindings_AST = (AST)currentAST.root;
        break;
      }
      default:
      {
        throw new NoViableAltException(LT(1), getFilename());
      }
      }
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_108, _tokenSet_109);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_109);
      } else {
        throw ex;
      }
    }
    returnAST = dataConstructorArgumentBindings_AST;
  }
  
  public final void patternVar(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST patternVar_AST = null;
    
    try {      // for error handling
      switch ( LA(1)) {
      case VAR_ID:
      {
        var();
        astFactory.addASTChild(currentAST, returnAST);
        patternVar_AST = (AST)currentAST.root;
        break;
      }
      case UNDERSCORE:
      {
        wildcard();
        astFactory.addASTChild(currentAST, returnAST);
        patternVar_AST = (AST)currentAST.root;
        break;
      }
      default:
      {
        throw new NoViableAltException(LT(1), getFilename());
      }
      }
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_110, _tokenSet_111);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_111);
      } else {
        throw ex;
      }
    }
    returnAST = patternVar_AST;
  }
  
  public final void recordPattern(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST recordPattern_AST = null;
    Token  openBraceNode = null;
    AST openBraceNode_AST = null;
    Token  closeBraceNode = null;
    AST closeBraceNode_AST = null;
    
    try {      // for error handling
      openBraceNode = LT(1);
      openBraceNode_AST = astFactory.create(openBraceNode);
      astFactory.makeASTRoot(currentAST, openBraceNode_AST);
      match(OPEN_BRACE);
      if ( inputState.guessing==0 ) {
        openBraceNode_AST.initialize (RECORD_PATTERN, "RECORD_PATTERN");
      }
      baseRecordPattern(LT(1), "a valid base record pattern");
      astFactory.addASTChild(currentAST, returnAST);
      fieldBindingVarAssignmentList(LT(1), "a list of comma-separated field bindings");
      astFactory.addASTChild(currentAST, returnAST);
      closeBraceNode = LT(1);
      closeBraceNode_AST = astFactory.create(closeBraceNode);
      match(CLOSE_BRACE);
      if ( inputState.guessing==0 ) {
        ((ParseTreeNode)openBraceNode_AST).addOmittedDelimiter(closeBraceNode_AST);
      }
      recordPattern_AST = (AST)currentAST.root;
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_54, _tokenSet_109);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_109);
      } else {
        throw ex;
      }
    }
    returnAST = recordPattern_AST;
  }
  
  public final void dataConstructorNameListOneOrMore(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST dataConstructorNameListOneOrMore_AST = null;
    Token  openParenNode = null;
    AST openParenNode_AST = null;
    
    try {      // for error handling
      openParenNode = LT(1);
      openParenNode_AST = astFactory.create(openParenNode);
      match(OPEN_PAREN);
      qualifiedCons(contextToken, paraphrase);
      astFactory.addASTChild(currentAST, returnAST);
      {
      _loop261:
      do {
        if ((LA(1)==BAR)) {
          match(BAR);
          qualifiedCons(contextToken, paraphrase);
          astFactory.addASTChild(currentAST, returnAST);
        }
        else {
          break _loop261;
        }
        
      } while (true);
      }
      match(CLOSE_PAREN);
      if ( inputState.guessing==0 ) {
        dataConstructorNameListOneOrMore_AST = (AST)currentAST.root;
        dataConstructorNameListOneOrMore_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(DATA_CONSTRUCTOR_NAME_LIST,"DATA_CONSTRUCTOR_NAME_LIST")).add(dataConstructorNameListOneOrMore_AST));
        currentAST.root = dataConstructorNameListOneOrMore_AST;
        currentAST.child = dataConstructorNameListOneOrMore_AST!=null &&dataConstructorNameListOneOrMore_AST.getFirstChild()!=null ?
          dataConstructorNameListOneOrMore_AST.getFirstChild() : dataConstructorNameListOneOrMore_AST;
        currentAST.advanceChildToEnd();
      }
      dataConstructorNameListOneOrMore_AST = (AST)currentAST.root;
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_112, _tokenSet_108);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_108);
      } else {
        throw ex;
      }
    }
    returnAST = dataConstructorNameListOneOrMore_AST;
  }
  
  public final void maybeMinusIntSingleton(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST maybeMinusIntSingleton_AST = null;
    
    try {      // for error handling
      maybeMinusInt(contextToken, paraphrase);
      astFactory.addASTChild(currentAST, returnAST);
      if ( inputState.guessing==0 ) {
        maybeMinusIntSingleton_AST = (AST)currentAST.root;
        maybeMinusIntSingleton_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(MAYBE_MINUS_INT_LIST,"MAYBE_MINUS_INT_LIST")).add(maybeMinusIntSingleton_AST));
        currentAST.root = maybeMinusIntSingleton_AST;
        currentAST.child = maybeMinusIntSingleton_AST!=null &&maybeMinusIntSingleton_AST.getFirstChild()!=null ?
          maybeMinusIntSingleton_AST.getFirstChild() : maybeMinusIntSingleton_AST;
        currentAST.advanceChildToEnd();
      }
      maybeMinusIntSingleton_AST = (AST)currentAST.root;
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_113, _tokenSet_109);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_109);
      } else {
        throw ex;
      }
    }
    returnAST = maybeMinusIntSingleton_AST;
  }
  
  public final void maybeMinusIntListOneOrMore(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST maybeMinusIntListOneOrMore_AST = null;
    Token  openParenNode = null;
    AST openParenNode_AST = null;
    
    try {      // for error handling
      openParenNode = LT(1);
      openParenNode_AST = astFactory.create(openParenNode);
      match(OPEN_PAREN);
      maybeMinusInt(LT(1), "an integer literal");
      astFactory.addASTChild(currentAST, returnAST);
      {
      _loop269:
      do {
        if ((LA(1)==BAR)) {
          match(BAR);
          maybeMinusInt(LT(1), "an integer literal");
          astFactory.addASTChild(currentAST, returnAST);
        }
        else {
          break _loop269;
        }
        
      } while (true);
      }
      match(CLOSE_PAREN);
      if ( inputState.guessing==0 ) {
        maybeMinusIntListOneOrMore_AST = (AST)currentAST.root;
        maybeMinusIntListOneOrMore_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(MAYBE_MINUS_INT_LIST,"MAYBE_MINUS_INT_LIST")).add(maybeMinusIntListOneOrMore_AST));
        currentAST.root = maybeMinusIntListOneOrMore_AST;
        currentAST.child = maybeMinusIntListOneOrMore_AST!=null &&maybeMinusIntListOneOrMore_AST.getFirstChild()!=null ?
          maybeMinusIntListOneOrMore_AST.getFirstChild() : maybeMinusIntListOneOrMore_AST;
        currentAST.advanceChildToEnd();
      }
      maybeMinusIntListOneOrMore_AST = (AST)currentAST.root;
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_112, _tokenSet_109);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_109);
      } else {
        throw ex;
      }
    }
    returnAST = maybeMinusIntListOneOrMore_AST;
  }
  
  public final void charSingleton() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST charSingleton_AST = null;
    
    try {      // for error handling
      AST tmp111_AST = null;
      tmp111_AST = astFactory.create(LT(1));
      astFactory.addASTChild(currentAST, tmp111_AST);
      match(CHAR_LITERAL);
      if ( inputState.guessing==0 ) {
        charSingleton_AST = (AST)currentAST.root;
        charSingleton_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(CHAR_LIST,"CHAR_LIST")).add(charSingleton_AST));
        currentAST.root = charSingleton_AST;
        currentAST.child = charSingleton_AST!=null &&charSingleton_AST.getFirstChild()!=null ?
          charSingleton_AST.getFirstChild() : charSingleton_AST;
        currentAST.advanceChildToEnd();
      }
      charSingleton_AST = (AST)currentAST.root;
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        recover(ex,_tokenSet_109);
      } else {
        throw ex;
      }
    }
    returnAST = charSingleton_AST;
  }
  
  public final void charListOneOrMore() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST charListOneOrMore_AST = null;
    Token  openParenNode = null;
    AST openParenNode_AST = null;
    
    try {      // for error handling
      openParenNode = LT(1);
      openParenNode_AST = astFactory.create(openParenNode);
      match(OPEN_PAREN);
      AST tmp112_AST = null;
      tmp112_AST = astFactory.create(LT(1));
      astFactory.addASTChild(currentAST, tmp112_AST);
      match(CHAR_LITERAL);
      {
      _loop275:
      do {
        if ((LA(1)==BAR)) {
          match(BAR);
          AST tmp114_AST = null;
          tmp114_AST = astFactory.create(LT(1));
          astFactory.addASTChild(currentAST, tmp114_AST);
          match(CHAR_LITERAL);
        }
        else {
          break _loop275;
        }
        
      } while (true);
      }
      match(CLOSE_PAREN);
      if ( inputState.guessing==0 ) {
        charListOneOrMore_AST = (AST)currentAST.root;
        charListOneOrMore_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(CHAR_LIST,"CHAR_LIST")).add(charListOneOrMore_AST));
        currentAST.root = charListOneOrMore_AST;
        currentAST.child = charListOneOrMore_AST!=null &&charListOneOrMore_AST.getFirstChild()!=null ?
          charListOneOrMore_AST.getFirstChild() : charListOneOrMore_AST;
        currentAST.advanceChildToEnd();
      }
      charListOneOrMore_AST = (AST)currentAST.root;
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        recover(ex,_tokenSet_109);
      } else {
        throw ex;
      }
    }
    returnAST = charListOneOrMore_AST;
  }
  
  public final void wildcard() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST wildcard_AST = null;
    
    try {      // for error handling
      AST tmp116_AST = null;
      tmp116_AST = astFactory.create(LT(1));
      astFactory.addASTChild(currentAST, tmp116_AST);
      match(UNDERSCORE);
      wildcard_AST = (AST)currentAST.root;
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        recover(ex,_tokenSet_111);
      } else {
        throw ex;
      }
    }
    returnAST = wildcard_AST;
  }
  
  public final void alt(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST alt_AST = null;
    
    try {      // for error handling
      pat(contextToken, paraphrase);
      astFactory.addASTChild(currentAST, returnAST);
      match(RARROW);
      expr(LT(1), "a semicolon-terminated expression");
      astFactory.addASTChild(currentAST, returnAST);
      match(SEMICOLON);
      if ( inputState.guessing==0 ) {
        alt_AST = (AST)currentAST.root;
        alt_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(ALT,"ALT")).add(alt_AST));
        currentAST.root = alt_AST;
        currentAST.child = alt_AST!=null &&alt_AST.getFirstChild()!=null ?
          alt_AST.getFirstChild() : alt_AST;
        currentAST.advanceChildToEnd();
      }
      alt_AST = (AST)currentAST.root;
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_85, _tokenSet_114);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_114);
      } else {
        throw ex;
      }
    }
    returnAST = alt_AST;
  }
  
  public final void pat(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST pat_AST = null;
    Token  openParenNode = null;
    AST openParenNode_AST = null;
    Token  closeParenNode = null;
    AST closeParenNode_AST = null;
    Token  openBracketNode = null;
    AST openBracketNode_AST = null;
    Token  closeBracketNode = null;
    AST closeBracketNode_AST = null;
    
    try {      // for error handling
      switch ( LA(1)) {
      case CONS_ID:
      {
        dataConstructorSingleton(contextToken, paraphrase);
        astFactory.addASTChild(currentAST, returnAST);
        dataConstructorArgumentBindings(contextToken, paraphrase);
        astFactory.addASTChild(currentAST, returnAST);
        if ( inputState.guessing==0 ) {
          pat_AST = (AST)currentAST.root;
          pat_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(PATTERN_CONSTRUCTOR,"PATTERN_CONSTRUCTOR")).add(pat_AST));
          currentAST.root = pat_AST;
          currentAST.child = pat_AST!=null &&pat_AST.getFirstChild()!=null ?
            pat_AST.getFirstChild() : pat_AST;
          currentAST.advanceChildToEnd();
        }
        pat_AST = (AST)currentAST.root;
        break;
      }
      case OPEN_BRACKET:
      {
        openBracketNode = LT(1);
        openBracketNode_AST = astFactory.create(openBracketNode);
        astFactory.makeASTRoot(currentAST, openBracketNode_AST);
        match(OPEN_BRACKET);
        if ( inputState.guessing==0 ) {
          openBracketNode_AST.initialize (LIST_CONSTRUCTOR, "List");
        }
        closeBracketNode = LT(1);
        closeBracketNode_AST = astFactory.create(closeBracketNode);
        match(CLOSE_BRACKET);
        if ( inputState.guessing==0 ) {
          ((ParseTreeNode)openBracketNode_AST).addOmittedDelimiter(closeBracketNode_AST);
        }
        pat_AST = (AST)currentAST.root;
        break;
      }
      case MINUS:
      case INTEGER_LITERAL:
      {
        maybeMinusIntSingleton(contextToken, paraphrase);
        astFactory.addASTChild(currentAST, returnAST);
        if ( inputState.guessing==0 ) {
          pat_AST = (AST)currentAST.root;
          pat_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(INT_PATTERN,"INT_PATTERN")).add(pat_AST));
          currentAST.root = pat_AST;
          currentAST.child = pat_AST!=null &&pat_AST.getFirstChild()!=null ?
            pat_AST.getFirstChild() : pat_AST;
          currentAST.advanceChildToEnd();
        }
        pat_AST = (AST)currentAST.root;
        break;
      }
      case CHAR_LITERAL:
      {
        charSingleton();
        astFactory.addASTChild(currentAST, returnAST);
        if ( inputState.guessing==0 ) {
          pat_AST = (AST)currentAST.root;
          pat_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(CHAR_PATTERN,"CHAR_PATTERN")).add(pat_AST));
          currentAST.root = pat_AST;
          currentAST.child = pat_AST!=null &&pat_AST.getFirstChild()!=null ?
            pat_AST.getFirstChild() : pat_AST;
          currentAST.advanceChildToEnd();
        }
        pat_AST = (AST)currentAST.root;
        break;
      }
      case OPEN_BRACE:
      {
        recordPattern(contextToken, paraphrase);
        astFactory.addASTChild(currentAST, returnAST);
        pat_AST = (AST)currentAST.root;
        break;
      }
      default:
        if ((LA(1)==OPEN_PAREN) && (LA(2)==CONS_ID)) {
          dataConstructorNameListOneOrMore(contextToken, paraphrase);
          astFactory.addASTChild(currentAST, returnAST);
          dataConstructorArgumentBindings(contextToken, paraphrase);
          astFactory.addASTChild(currentAST, returnAST);
          if ( inputState.guessing==0 ) {
            pat_AST = (AST)currentAST.root;
            pat_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(PATTERN_CONSTRUCTOR,"PATTERN_CONSTRUCTOR")).add(pat_AST));
            currentAST.root = pat_AST;
            currentAST.child = pat_AST!=null &&pat_AST.getFirstChild()!=null ?
              pat_AST.getFirstChild() : pat_AST;
            currentAST.advanceChildToEnd();
          }
          pat_AST = (AST)currentAST.root;
        }
        else if ((LA(1)==OPEN_PAREN) && (_tokenSet_107.member(LA(2)))) {
          openParenNode = LT(1);
          openParenNode_AST = astFactory.create(openParenNode);
          astFactory.makeASTRoot(currentAST, openParenNode_AST);
          match(OPEN_PAREN);
          if ( inputState.guessing==0 ) {
            openParenNode_AST.initialize (TUPLE_CONSTRUCTOR, "Tuple");
          }
          {
          switch ( LA(1)) {
          case VAR_ID:
          case UNDERSCORE:
          {
            patternVar(contextToken, paraphrase);
            astFactory.addASTChild(currentAST, returnAST);
            {
            _loop257:
            do {
              if ((LA(1)==COMMA)) {
                match(COMMA);
                patternVar(contextToken, paraphrase);
                astFactory.addASTChild(currentAST, returnAST);
              }
              else {
                break _loop257;
              }
              
            } while (true);
            }
            break;
          }
          case CLOSE_PAREN:
          {
            break;
          }
          default:
          {
            throw new NoViableAltException(LT(1), getFilename());
          }
          }
          }
          closeParenNode = LT(1);
          closeParenNode_AST = astFactory.create(closeParenNode);
          match(CLOSE_PAREN);
          if ( inputState.guessing==0 ) {
            ((ParseTreeNode)openParenNode_AST).addOmittedDelimiter(closeParenNode_AST);
          }
          pat_AST = (AST)currentAST.root;
        }
        else if ((LA(1)==OPEN_PAREN) && (LA(2)==MINUS||LA(2)==INTEGER_LITERAL)) {
          maybeMinusIntListOneOrMore(contextToken, paraphrase);
          astFactory.addASTChild(currentAST, returnAST);
          if ( inputState.guessing==0 ) {
            pat_AST = (AST)currentAST.root;
            pat_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(INT_PATTERN,"INT_PATTERN")).add(pat_AST));
            currentAST.root = pat_AST;
            currentAST.child = pat_AST!=null &&pat_AST.getFirstChild()!=null ?
              pat_AST.getFirstChild() : pat_AST;
            currentAST.advanceChildToEnd();
          }
          pat_AST = (AST)currentAST.root;
        }
        else if ((LA(1)==OPEN_PAREN) && (LA(2)==CHAR_LITERAL)) {
          charListOneOrMore();
          astFactory.addASTChild(currentAST, returnAST);
          if ( inputState.guessing==0 ) {
            pat_AST = (AST)currentAST.root;
            pat_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(CHAR_PATTERN,"CHAR_PATTERN")).add(pat_AST));
            currentAST.root = pat_AST;
            currentAST.child = pat_AST!=null &&pat_AST.getFirstChild()!=null ?
              pat_AST.getFirstChild() : pat_AST;
            currentAST.advanceChildToEnd();
          }
          pat_AST = (AST)currentAST.root;
        }
        else if ((LA(1)==VAR_ID||LA(1)==UNDERSCORE) && (LA(2)==COLON)) {
          patternVar(contextToken, paraphrase);
          astFactory.addASTChild(currentAST, returnAST);
          AST tmp120_AST = null;
          tmp120_AST = astFactory.create(LT(1));
          astFactory.makeASTRoot(currentAST, tmp120_AST);
          match(COLON);
          patternVar(contextToken, paraphrase);
          astFactory.addASTChild(currentAST, returnAST);
          pat_AST = (AST)currentAST.root;
        }
        else if ((LA(1)==UNDERSCORE) && (LA(2)==RARROW)) {
          wildcard();
          astFactory.addASTChild(currentAST, returnAST);
          pat_AST = (AST)currentAST.root;
        }
      else {
        throw new NoViableAltException(LT(1), getFilename());
      }
      }
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_85, _tokenSet_82);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_82);
      } else {
        throw ex;
      }
    }
    returnAST = pat_AST;
  }
  
  public final void patternVarListZeroOrMore(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST patternVarListZeroOrMore_AST = null;
    
    try {      // for error handling
      {
      _loop265:
      do {
        if ((LA(1)==VAR_ID||LA(1)==UNDERSCORE)) {
          patternVar(contextToken, paraphrase);
          astFactory.addASTChild(currentAST, returnAST);
        }
        else {
          break _loop265;
        }
        
      } while (true);
      }
      if ( inputState.guessing==0 ) {
        patternVarListZeroOrMore_AST = (AST)currentAST.root;
        patternVarListZeroOrMore_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(PATTERN_VAR_LIST,"PATTERN_VAR_LIST")).add(patternVarListZeroOrMore_AST));
        currentAST.root = patternVarListZeroOrMore_AST;
        currentAST.child = patternVarListZeroOrMore_AST!=null &&patternVarListZeroOrMore_AST.getFirstChild()!=null ?
          patternVarListZeroOrMore_AST.getFirstChild() : patternVarListZeroOrMore_AST;
        currentAST.advanceChildToEnd();
      }
      patternVarListZeroOrMore_AST = (AST)currentAST.root;
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_115, _tokenSet_109);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_109);
      } else {
        throw ex;
      }
    }
    returnAST = patternVarListZeroOrMore_AST;
  }
  
  public final void fieldBindingVarAssignmentList(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST fieldBindingVarAssignmentList_AST = null;
    
    try {      // for error handling
      {
      switch ( LA(1)) {
      case VAR_ID:
      case ORDINAL_FIELD_NAME:
      {
        fieldBindingVarAssignment(LT(1), "a valid field-binding");
        astFactory.addASTChild(currentAST, returnAST);
        {
        _loop286:
        do {
          if ((LA(1)==COMMA)) {
            match(COMMA);
            fieldBindingVarAssignment(LT(1), "a valid field-binding");
            astFactory.addASTChild(currentAST, returnAST);
          }
          else {
            break _loop286;
          }
          
        } while (true);
        }
        break;
      }
      case CLOSE_BRACE:
      {
        break;
      }
      default:
      {
        throw new NoViableAltException(LT(1), getFilename());
      }
      }
      }
      if ( inputState.guessing==0 ) {
        fieldBindingVarAssignmentList_AST = (AST)currentAST.root;
        fieldBindingVarAssignmentList_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(FIELD_BINDING_VAR_ASSIGNMENT_LIST,"FIELD_BINDING_VAR_ASSIGNMENT_LIST")).add(fieldBindingVarAssignmentList_AST));
        currentAST.root = fieldBindingVarAssignmentList_AST;
        currentAST.child = fieldBindingVarAssignmentList_AST!=null &&fieldBindingVarAssignmentList_AST.getFirstChild()!=null ?
          fieldBindingVarAssignmentList_AST.getFirstChild() : fieldBindingVarAssignmentList_AST;
        currentAST.advanceChildToEnd();
      }
      fieldBindingVarAssignmentList_AST = (AST)currentAST.root;
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_55, _tokenSet_57);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_57);
      } else {
        throw ex;
      }
    }
    returnAST = fieldBindingVarAssignmentList_AST;
  }
  
  public final void maybeMinusInt(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST maybeMinusInt_AST = null;
    Token  node = null;
    AST node_AST = null;
    
    try {      // for error handling
      switch ( LA(1)) {
      case MINUS:
      {
        {
        node = LT(1);
        node_AST = astFactory.create(node);
        astFactory.makeASTRoot(currentAST, node_AST);
        match(MINUS);
        if ( inputState.guessing==0 ) {
          node_AST.initialize (MINUS, "-");
        }
        AST tmp122_AST = null;
        tmp122_AST = astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp122_AST);
        match(INTEGER_LITERAL);
        }
        maybeMinusInt_AST = (AST)currentAST.root;
        break;
      }
      case INTEGER_LITERAL:
      {
        AST tmp123_AST = null;
        tmp123_AST = astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp123_AST);
        match(INTEGER_LITERAL);
        maybeMinusInt_AST = (AST)currentAST.root;
        break;
      }
      default:
      {
        throw new NoViableAltException(LT(1), getFilename());
      }
      }
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_113, _tokenSet_116);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_116);
      } else {
        throw ex;
      }
    }
    returnAST = maybeMinusInt_AST;
  }
  
  public final void baseRecordPattern(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST baseRecordPattern_AST = null;
    
    try {      // for error handling
      boolean synPredMatched281 = false;
      if (((LA(1)==VAR_ID||LA(1)==UNDERSCORE) && (LA(2)==BAR))) {
        int _m281 = mark();
        synPredMatched281 = true;
        inputState.guessing++;
        try {
          {
          patternVar(null, null);
          match(BAR);
          }
        }
        catch (RecognitionException pe) {
          synPredMatched281 = false;
        }
        rewind(_m281);
inputState.guessing--;
      }
      if ( synPredMatched281 ) {
        {
        patternVar(contextToken, paraphrase);
        astFactory.addASTChild(currentAST, returnAST);
        match(BAR);
        }
        if ( inputState.guessing==0 ) {
          baseRecordPattern_AST = (AST)currentAST.root;
          baseRecordPattern_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(BASE_RECORD_PATTERN,"BASE_RECORD_PATTERN")).add(baseRecordPattern_AST));
          currentAST.root = baseRecordPattern_AST;
          currentAST.child = baseRecordPattern_AST!=null &&baseRecordPattern_AST.getFirstChild()!=null ?
            baseRecordPattern_AST.getFirstChild() : baseRecordPattern_AST;
          currentAST.advanceChildToEnd();
        }
        baseRecordPattern_AST = (AST)currentAST.root;
      }
      else if ((_tokenSet_55.member(LA(1))) && (_tokenSet_117.member(LA(2)))) {
        if ( inputState.guessing==0 ) {
          baseRecordPattern_AST = (AST)currentAST.root;
          baseRecordPattern_AST = (AST)astFactory.make( (new ASTArray(1)).add(astFactory.create(BASE_RECORD_PATTERN,"BASE_RECORD_PATTERN")));
          currentAST.root = baseRecordPattern_AST;
          currentAST.child = baseRecordPattern_AST!=null &&baseRecordPattern_AST.getFirstChild()!=null ?
            baseRecordPattern_AST.getFirstChild() : baseRecordPattern_AST;
          currentAST.advanceChildToEnd();
        }
        baseRecordPattern_AST = (AST)currentAST.root;
      }
      else {
        throw new NoViableAltException(LT(1), getFilename());
      }
      
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_118, _tokenSet_55);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_55);
      } else {
        throw ex;
      }
    }
    returnAST = baseRecordPattern_AST;
  }
  
  public final void fieldBindingVarAssignment(
    Token contextToken, String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST fieldBindingVarAssignment_AST = null;
    Token  node = null;
    AST node_AST = null;
    
    try {      // for error handling
      boolean synPredMatched289 = false;
      if (((LA(1)==VAR_ID||LA(1)==ORDINAL_FIELD_NAME) && (LA(2)==EQUALS))) {
        int _m289 = mark();
        synPredMatched289 = true;
        inputState.guessing++;
        try {
          {
          fieldName(null, null);
          match(EQUALS);
          }
        }
        catch (RecognitionException pe) {
          synPredMatched289 = false;
        }
        rewind(_m289);
inputState.guessing--;
      }
      if ( synPredMatched289 ) {
        fieldName(LT(1), "a valid record-field name");
        astFactory.addASTChild(currentAST, returnAST);
        node = LT(1);
        node_AST = astFactory.create(node);
        astFactory.makeASTRoot(currentAST, node_AST);
        match(EQUALS);
        if ( inputState.guessing==0 ) {
          node_AST.initialize (FIELD_BINDING_VAR_ASSIGNMENT, "FIELD_BINDING_VAR_ASSIGNMENT");
        }
        patternVar(LT(1), "a valid variable name");
        astFactory.addASTChild(currentAST, returnAST);
        fieldBindingVarAssignment_AST = (AST)currentAST.root;
      }
      else if ((LA(1)==VAR_ID||LA(1)==ORDINAL_FIELD_NAME) && (LA(2)==COMMA||LA(2)==CLOSE_BRACE)) {
        fieldName(LT(1), "a valid record-field name");
        astFactory.addASTChild(currentAST, returnAST);
        if ( inputState.guessing==0 ) {
          fieldBindingVarAssignment_AST = (AST)currentAST.root;
          fieldBindingVarAssignment_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(FIELD_BINDING_VAR_ASSIGNMENT,"FIELD_BINDING_VAR_ASSIGNMENT")).add(fieldBindingVarAssignment_AST));
          currentAST.root = fieldBindingVarAssignment_AST;
          currentAST.child = fieldBindingVarAssignment_AST!=null &&fieldBindingVarAssignment_AST.getFirstChild()!=null ?
            fieldBindingVarAssignment_AST.getFirstChild() : fieldBindingVarAssignment_AST;
          currentAST.advanceChildToEnd();
        }
        fieldBindingVarAssignment_AST = (AST)currentAST.root;
      }
      else {
        throw new NoViableAltException(LT(1), getFilename());
      }
      
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        reportWithParaphrase(ex, contextToken, paraphrase, _tokenSet_49, _tokenSet_58);
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex, _tokenSet_58);
      } else {
        throw ex;
      }
    }
    returnAST = fieldBindingVarAssignment_AST;
  }
  
  public final void literal_index() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST literal_index_AST = null;
    
    try {      // for error handling
      AST tmp125_AST = null;
      tmp125_AST = astFactory.create(LT(1));
      astFactory.addASTChild(currentAST, tmp125_AST);
      match(INTEGER_LITERAL);
      literal_index_AST = (AST)currentAST.root;
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        recover(ex,_tokenSet_0);
      } else {
        throw ex;
      }
    }
    returnAST = literal_index_AST;
  }
  
  public final void docComment() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST docComment_AST = null;
    Token  node = null;
    AST node_AST = null;
    Token  caldocCloseNode = null;
    AST caldocCloseNode_AST = null;
    
    try {      // for error handling
      node = LT(1);
      node_AST = astFactory.create(node);
      astFactory.makeASTRoot(currentAST, node_AST);
      match(CALDOC_OPEN);
      if ( inputState.guessing==0 ) {
        node_AST.initialize(CALDOC_COMMENT, "CALDOC_COMMENT");
      }
      docCommentDescriptionBlock();
      astFactory.addASTChild(currentAST, returnAST);
      docCommentTaggedBlocks();
      astFactory.addASTChild(currentAST, returnAST);
      caldocCloseNode = LT(1);
      caldocCloseNode_AST = astFactory.create(caldocCloseNode);
      match(CALDOC_CLOSE);
      if ( inputState.guessing==0 ) {
        ((ParseTreeNode)node_AST).addOmittedDelimiter(caldocCloseNode_AST);
      }
      docComment_AST = (AST)currentAST.root;
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        recover(ex,_tokenSet_119);
      } else {
        throw ex;
      }
    }
    returnAST = docComment_AST;
  }
  
  public final void moreDocComments() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST moreDocComments_AST = null;
    AST comment_AST = null;
    AST moreComments_AST = null;
    
    try {      // for error handling
      docComment();
      comment_AST = (AST)returnAST;
      {
      switch ( LA(1)) {
      case CONS_ID:
      case VAR_ID:
      case LITERAL_module:
      case LITERAL_class:
      case OPEN_PAREN:
      case OPEN_BRACKET:
      case OPEN_BRACE:
      case LITERAL_data:
      case LITERAL_foreign:
      case LITERAL_instance:
      case LITERAL_primitive:
      case LITERAL_public:
      case LITERAL_private:
      case LITERAL_protected:
      case MINUS:
      case UNDERSCORE:
      case CHAR_LITERAL:
      case INTEGER_LITERAL:
      {
        if ( inputState.guessing==0 ) {
          moreDocComments_AST = (AST)currentAST.root;
          moreDocComments_AST = comment_AST;
          currentAST.root = moreDocComments_AST;
          currentAST.child = moreDocComments_AST!=null &&moreDocComments_AST.getFirstChild()!=null ?
            moreDocComments_AST.getFirstChild() : moreDocComments_AST;
          currentAST.advanceChildToEnd();
        }
        break;
      }
      case CALDOC_OPEN:
      {
        if ( inputState.guessing==0 ) {
          reportUnassociatedCALDocCommentError((ParseTreeNode)comment_AST);
        }
        moreDocComments();
        moreComments_AST = (AST)returnAST;
        if ( inputState.guessing==0 ) {
          moreDocComments_AST = (AST)currentAST.root;
          moreDocComments_AST = moreComments_AST;
          currentAST.root = moreDocComments_AST;
          currentAST.child = moreDocComments_AST!=null &&moreDocComments_AST.getFirstChild()!=null ?
            moreDocComments_AST.getFirstChild() : moreDocComments_AST;
          currentAST.advanceChildToEnd();
        }
        break;
      }
      default:
      {
        throw new NoViableAltException(LT(1), getFilename());
      }
      }
      }
      moreDocComments_AST = (AST)currentAST.root;
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        recover(ex,_tokenSet_5);
      } else {
        throw ex;
      }
    }
    returnAST = moreDocComments_AST;
  }
  
  public final void docCommentDescriptionBlock() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST docCommentDescriptionBlock_AST = null;
    AST text_AST = null;
    
    try {      // for error handling
      docCommentTextualContent();
      text_AST = (AST)returnAST;
      if ( inputState.guessing==0 ) {
        docCommentDescriptionBlock_AST = (AST)currentAST.root;
        docCommentDescriptionBlock_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(CALDOC_DESCRIPTION_BLOCK,"CALDOC_DESCRIPTION_BLOCK")).add(text_AST));
        currentAST.root = docCommentDescriptionBlock_AST;
        currentAST.child = docCommentDescriptionBlock_AST!=null &&docCommentDescriptionBlock_AST.getFirstChild()!=null ?
          docCommentDescriptionBlock_AST.getFirstChild() : docCommentDescriptionBlock_AST;
        currentAST.advanceChildToEnd();
      }
      docCommentDescriptionBlock_AST = (AST)currentAST.root;
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        recover(ex,_tokenSet_120);
      } else {
        throw ex;
      }
    }
    returnAST = docCommentDescriptionBlock_AST;
  }
  
  public final void docCommentTaggedBlocks() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST docCommentTaggedBlocks_AST = null;
    
    try {      // for error handling
      {
      _loop356:
      do {
        switch ( LA(1)) {
        case CALDOC_AUTHOR_TAG:
        {
          docCommentAuthorBlock();
          astFactory.addASTChild(currentAST, returnAST);
          break;
        }
        case CALDOC_DEPRECATED_TAG:
        {
          docCommentDeprecatedBlock();
          astFactory.addASTChild(currentAST, returnAST);
          break;
        }
        case CALDOC_RETURN_TAG:
        {
          docCommentReturnBlock();
          astFactory.addASTChild(currentAST, returnAST);
          break;
        }
        case CALDOC_VERSION_TAG:
        {
          docCommentVersionBlock();
          astFactory.addASTChild(currentAST, returnAST);
          break;
        }
        case CALDOC_ARG_TAG:
        {
          docCommentArgBlock();
          astFactory.addASTChild(currentAST, returnAST);
          break;
        }
        case CALDOC_SEE_TAG:
        {
          docCommentSeeBlock();
          astFactory.addASTChild(currentAST, returnAST);
          break;
        }
        case CALDOC_UNKNOWN_TAG:
        {
          docCommentUnknownTagBlock();
          break;
        }
        default:
        {
          break _loop356;
        }
        }
      } while (true);
      }
      if ( inputState.guessing==0 ) {
        docCommentTaggedBlocks_AST = (AST)currentAST.root;
        docCommentTaggedBlocks_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(CALDOC_TAGGED_BLOCKS,"CALDOC_TAGGED_BLOCKS")).add(docCommentTaggedBlocks_AST));
        currentAST.root = docCommentTaggedBlocks_AST;
        currentAST.child = docCommentTaggedBlocks_AST!=null &&docCommentTaggedBlocks_AST.getFirstChild()!=null ?
          docCommentTaggedBlocks_AST.getFirstChild() : docCommentTaggedBlocks_AST;
        currentAST.advanceChildToEnd();
      }
      docCommentTaggedBlocks_AST = (AST)currentAST.root;
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        recover(ex,_tokenSet_121);
      } else {
        throw ex;
      }
    }
    returnAST = docCommentTaggedBlocks_AST;
  }
  
  public final void docCommentTextualContent() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST docCommentTextualContent_AST = null;
    
    try {      // for error handling
      {
      _loop302:
      do {
        switch ( LA(1)) {
        case CALDOC_OPEN_INLINE_TAG:
        case CALDOC_BLANK_TEXT_LINE:
        case CALDOC_TEXT_LINE:
        {
          docCommentTextSpan();
          astFactory.addASTChild(currentAST, returnAST);
          break;
        }
        case CALDOC_NEWLINE:
        case CALDOC_NEWLINE_WITH_LEADING_ASTERISK:
        {
          docCommentLineBreak();
          astFactory.addASTChild(currentAST, returnAST);
          break;
        }
        default:
        {
          break _loop302;
        }
        }
      } while (true);
      }
      if ( inputState.guessing==0 ) {
        docCommentTextualContent_AST = (AST)currentAST.root;
        docCommentTextualContent_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(CALDOC_TEXT,"CALDOC_TEXT")).add(docCommentTextualContent_AST));
        currentAST.root = docCommentTextualContent_AST;
        currentAST.child = docCommentTextualContent_AST!=null &&docCommentTextualContent_AST.getFirstChild()!=null ?
          docCommentTextualContent_AST.getFirstChild() : docCommentTextualContent_AST;
        currentAST.advanceChildToEnd();
      }
      docCommentTextualContent_AST = (AST)currentAST.root;
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        recover(ex,_tokenSet_122);
      } else {
        throw ex;
      }
    }
    returnAST = docCommentTextualContent_AST;
  }
  
  public final void docCommentTextSpan() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST docCommentTextSpan_AST = null;
    
    try {      // for error handling
      switch ( LA(1)) {
      case CALDOC_TEXT_LINE:
      {
        AST tmp126_AST = null;
        tmp126_AST = astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp126_AST);
        match(CALDOC_TEXT_LINE);
        docCommentTextSpan_AST = (AST)currentAST.root;
        break;
      }
      case CALDOC_BLANK_TEXT_LINE:
      {
        AST tmp127_AST = null;
        tmp127_AST = astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp127_AST);
        match(CALDOC_BLANK_TEXT_LINE);
        docCommentTextSpan_AST = (AST)currentAST.root;
        break;
      }
      case CALDOC_OPEN_INLINE_TAG:
      {
        docCommentInlineBlock();
        astFactory.addASTChild(currentAST, returnAST);
        docCommentTextSpan_AST = (AST)currentAST.root;
        break;
      }
      default:
      {
        throw new NoViableAltException(LT(1), getFilename());
      }
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        recover(ex,_tokenSet_123);
      } else {
        throw ex;
      }
    }
    returnAST = docCommentTextSpan_AST;
  }
  
  public final void docCommentLineBreak() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST docCommentLineBreak_AST = null;
    AST node_AST = null;
    
    try {      // for error handling
      docCommentNewline();
      node_AST = (AST)returnAST;
      astFactory.addASTChild(currentAST, returnAST);
      if ( inputState.guessing==0 ) {
        node_AST.initialize(CALDOC_TEXT_LINE_BREAK, "CALDOC_TEXT_LINE_BREAK");
      }
      docCommentLineBreak_AST = (AST)currentAST.root;
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        recover(ex,_tokenSet_123);
      } else {
        throw ex;
      }
    }
    returnAST = docCommentLineBreak_AST;
  }
  
  public final void docCommentInlineBlock() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST docCommentInlineBlock_AST = null;
    Token  openInlineTag = null;
    AST openInlineTag_AST = null;
    AST content_AST = null;
    AST closeInlineTag_AST = null;
    
    try {      // for error handling
      openInlineTag = LT(1);
      openInlineTag_AST = astFactory.create(openInlineTag);
      match(CALDOC_OPEN_INLINE_TAG);
      docCommentInlineBlockContent();
      content_AST = (AST)returnAST;
      astFactory.addASTChild(currentAST, returnAST);
      docCommentCloseInlineTag(openInlineTag);
      closeInlineTag_AST = (AST)returnAST;
      if ( inputState.guessing==0 ) {
        docCommentInlineBlock_AST = (AST)currentAST.root;
        
           if (openInlineTag_AST == null || content_AST == null || closeInlineTag_AST == null) {// we did not match a proper inline block, and we reported a custom error for it, so the subtree for the close tag is null
               docCommentInlineBlock_AST = null;
           } else {
        docCommentInlineBlock_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(CALDOC_TEXT_INLINE_BLOCK,"CALDOC_TEXT_INLINE_BLOCK")).add(docCommentInlineBlock_AST));
        ((ParseTreeNode)content_AST).addOmittedDelimiter(openInlineTag_AST);
        ((ParseTreeNode)content_AST).addOmittedDelimiter(closeInlineTag_AST);
           }
        
        currentAST.root = docCommentInlineBlock_AST;
        currentAST.child = docCommentInlineBlock_AST!=null &&docCommentInlineBlock_AST.getFirstChild()!=null ?
          docCommentInlineBlock_AST.getFirstChild() : docCommentInlineBlock_AST;
        currentAST.advanceChildToEnd();
      }
      docCommentInlineBlock_AST = (AST)currentAST.root;
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        recover(ex,_tokenSet_123);
      } else {
        throw ex;
      }
    }
    returnAST = docCommentInlineBlock_AST;
  }
  
  public final void docCommentNewline() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST docCommentNewline_AST = null;
    
    try {      // for error handling
      switch ( LA(1)) {
      case CALDOC_NEWLINE:
      {
        AST tmp128_AST = null;
        tmp128_AST = astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp128_AST);
        match(CALDOC_NEWLINE);
        docCommentNewline_AST = (AST)currentAST.root;
        break;
      }
      case CALDOC_NEWLINE_WITH_LEADING_ASTERISK:
      {
        AST tmp129_AST = null;
        tmp129_AST = astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp129_AST);
        match(CALDOC_NEWLINE_WITH_LEADING_ASTERISK);
        docCommentNewline_AST = (AST)currentAST.root;
        break;
      }
      default:
      {
        throw new NoViableAltException(LT(1), getFilename());
      }
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        recover(ex,_tokenSet_123);
      } else {
        throw ex;
      }
    }
    returnAST = docCommentNewline_AST;
  }
  
  public final void docCommentPreformattedBlock() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST docCommentPreformattedBlock_AST = null;
    
    try {      // for error handling
      {
      _loop308:
      do {
        switch ( LA(1)) {
        case CALDOC_OPEN_INLINE_TAG:
        case CALDOC_BLANK_TEXT_LINE:
        case CALDOC_TEXT_LINE:
        {
          docCommentTextSpan();
          astFactory.addASTChild(currentAST, returnAST);
          break;
        }
        case CALDOC_NEWLINE:
        case CALDOC_NEWLINE_WITH_LEADING_ASTERISK:
        {
          docCommentLineBreak();
          astFactory.addASTChild(currentAST, returnAST);
          break;
        }
        default:
        {
          break _loop308;
        }
        }
      } while (true);
      }
      if ( inputState.guessing==0 ) {
        docCommentPreformattedBlock_AST = (AST)currentAST.root;
        docCommentPreformattedBlock_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(CALDOC_TEXT_PREFORMATTED_BLOCK,"CALDOC_TEXT_PREFORMATTED_BLOCK")).add(docCommentPreformattedBlock_AST));
        currentAST.root = docCommentPreformattedBlock_AST;
        currentAST.child = docCommentPreformattedBlock_AST!=null &&docCommentPreformattedBlock_AST.getFirstChild()!=null ?
          docCommentPreformattedBlock_AST.getFirstChild() : docCommentPreformattedBlock_AST;
        currentAST.advanceChildToEnd();
      }
      docCommentPreformattedBlock_AST = (AST)currentAST.root;
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        recover(ex,_tokenSet_124);
      } else {
        throw ex;
      }
    }
    returnAST = docCommentPreformattedBlock_AST;
  }
  
  public final void docCommentTextBlockWithoutInlineTags(
    Token surroundingInlineTag
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST docCommentTextBlockWithoutInlineTags_AST = null;
    
    try {      // for error handling
      {
      _loop311:
      do {
        if ((_tokenSet_125.member(LA(1)))) {
          docCommentContentForTextBlockWithoutInlineTags(surroundingInlineTag);
          astFactory.addASTChild(currentAST, returnAST);
        }
        else {
          break _loop311;
        }
        
      } while (true);
      }
      if ( inputState.guessing==0 ) {
        docCommentTextBlockWithoutInlineTags_AST = (AST)currentAST.root;
        docCommentTextBlockWithoutInlineTags_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(CALDOC_TEXT_BLOCK_WITHOUT_INLINE_TAGS,"CALDOC_TEXT_BLOCK_WITHOUT_INLINE_TAGS")).add(docCommentTextBlockWithoutInlineTags_AST));
        currentAST.root = docCommentTextBlockWithoutInlineTags_AST;
        currentAST.child = docCommentTextBlockWithoutInlineTags_AST!=null &&docCommentTextBlockWithoutInlineTags_AST.getFirstChild()!=null ?
          docCommentTextBlockWithoutInlineTags_AST.getFirstChild() : docCommentTextBlockWithoutInlineTags_AST;
        currentAST.advanceChildToEnd();
      }
      docCommentTextBlockWithoutInlineTags_AST = (AST)currentAST.root;
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        recover(ex,_tokenSet_124);
      } else {
        throw ex;
      }
    }
    returnAST = docCommentTextBlockWithoutInlineTags_AST;
  }
  
  public final void docCommentContentForTextBlockWithoutInlineTags(
    Token surroundingInlineTag
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST docCommentContentForTextBlockWithoutInlineTags_AST = null;
    Token  openInlineTag = null;
    AST openInlineTag_AST = null;
    AST tag_AST = null;
    
    try {      // for error handling
      switch ( LA(1)) {
      case CALDOC_OPEN_INLINE_TAG:
      {
        openInlineTag = LT(1);
        openInlineTag_AST = astFactory.create(openInlineTag);
        match(CALDOC_OPEN_INLINE_TAG);
        docCommentInlineBlockContent();
        tag_AST = (AST)returnAST;
        match(CALDOC_CLOSE_INLINE_TAG);
        if ( inputState.guessing==0 ) {
          reportCALDocInlineTagAppearingInInadmissibleLocationError(openInlineTag, surroundingInlineTag);
        }
        docCommentContentForTextBlockWithoutInlineTags_AST = (AST)currentAST.root;
        break;
      }
      case CALDOC_NEWLINE:
      case CALDOC_NEWLINE_WITH_LEADING_ASTERISK:
      case CALDOC_BLANK_TEXT_LINE:
      case CALDOC_TEXT_LINE:
      {
        {
        switch ( LA(1)) {
        case CALDOC_TEXT_LINE:
        {
          AST tmp131_AST = null;
          tmp131_AST = astFactory.create(LT(1));
          astFactory.addASTChild(currentAST, tmp131_AST);
          match(CALDOC_TEXT_LINE);
          break;
        }
        case CALDOC_BLANK_TEXT_LINE:
        {
          AST tmp132_AST = null;
          tmp132_AST = astFactory.create(LT(1));
          astFactory.addASTChild(currentAST, tmp132_AST);
          match(CALDOC_BLANK_TEXT_LINE);
          break;
        }
        case CALDOC_NEWLINE:
        case CALDOC_NEWLINE_WITH_LEADING_ASTERISK:
        {
          docCommentLineBreak();
          astFactory.addASTChild(currentAST, returnAST);
          break;
        }
        default:
        {
          throw new NoViableAltException(LT(1), getFilename());
        }
        }
        }
        docCommentContentForTextBlockWithoutInlineTags_AST = (AST)currentAST.root;
        break;
      }
      default:
      {
        throw new NoViableAltException(LT(1), getFilename());
      }
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        recover(ex,_tokenSet_126);
      } else {
        throw ex;
      }
    }
    returnAST = docCommentContentForTextBlockWithoutInlineTags_AST;
  }
  
  public final void docCommentInlineBlockContent() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST docCommentInlineBlockContent_AST = null;
    
    try {      // for error handling
      switch ( LA(1)) {
      case CALDOC_INLINE_URL_TAG:
      {
        docCommentInlineBlockContentUrlTagAndContent();
        astFactory.addASTChild(currentAST, returnAST);
        docCommentInlineBlockContent_AST = (AST)currentAST.root;
        break;
      }
      case CALDOC_INLINE_LINK_TAG:
      {
        docCommentInlineBlockContentLinkTagAndContent();
        astFactory.addASTChild(currentAST, returnAST);
        docCommentInlineBlockContent_AST = (AST)currentAST.root;
        break;
      }
      case CALDOC_INLINE_EM_TAG:
      {
        docCommentInlineBlockContentEmTagAndContent();
        astFactory.addASTChild(currentAST, returnAST);
        docCommentInlineBlockContent_AST = (AST)currentAST.root;
        break;
      }
      case CALDOC_INLINE_STRONG_TAG:
      {
        docCommentInlineBlockContentStrongTagAndContent();
        astFactory.addASTChild(currentAST, returnAST);
        docCommentInlineBlockContent_AST = (AST)currentAST.root;
        break;
      }
      case CALDOC_INLINE_SUP_TAG:
      {
        docCommentInlineBlockContentSupTagAndContent();
        astFactory.addASTChild(currentAST, returnAST);
        docCommentInlineBlockContent_AST = (AST)currentAST.root;
        break;
      }
      case CALDOC_INLINE_SUB_TAG:
      {
        docCommentInlineBlockContentSubTagAndContent();
        astFactory.addASTChild(currentAST, returnAST);
        docCommentInlineBlockContent_AST = (AST)currentAST.root;
        break;
      }
      case CALDOC_INLINE_SUMMARY_TAG:
      {
        docCommentInlineBlockContentSummaryTagAndContent();
        astFactory.addASTChild(currentAST, returnAST);
        docCommentInlineBlockContent_AST = (AST)currentAST.root;
        break;
      }
      case CALDOC_INLINE_CODE_TAG:
      {
        docCommentInlineBlockContentCodeTagAndContent();
        astFactory.addASTChild(currentAST, returnAST);
        docCommentInlineBlockContent_AST = (AST)currentAST.root;
        break;
      }
      case CALDOC_INLINE_ORDERED_LIST_TAG:
      {
        docCommentInlineBlockContentOrderedListTagAndContent();
        astFactory.addASTChild(currentAST, returnAST);
        docCommentInlineBlockContent_AST = (AST)currentAST.root;
        break;
      }
      case CALDOC_INLINE_UNORDERED_LIST_TAG:
      {
        docCommentInlineBlockContentUnorderedListTagAndContent();
        astFactory.addASTChild(currentAST, returnAST);
        docCommentInlineBlockContent_AST = (AST)currentAST.root;
        break;
      }
      case CALDOC_INLINE_UNKNOWN_TAG:
      {
        docCommentInlineBlockContentUnknownTagAndContent();
        astFactory.addASTChild(currentAST, returnAST);
        docCommentInlineBlockContent_AST = (AST)currentAST.root;
        break;
      }
      default:
      {
        throw new NoViableAltException(LT(1), getFilename());
      }
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        recover(ex,_tokenSet_124);
      } else {
        throw ex;
      }
    }
    returnAST = docCommentInlineBlockContent_AST;
  }
  
  public final void docCommentCloseInlineTag(
    Token openInlineTag
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST docCommentCloseInlineTag_AST = null;
    
    try {      // for error handling
      AST tmp133_AST = null;
      tmp133_AST = astFactory.create(LT(1));
      astFactory.addASTChild(currentAST, tmp133_AST);
      match(CALDOC_CLOSE_INLINE_TAG);
      docCommentCloseInlineTag_AST = (AST)currentAST.root;
    }
    catch (MismatchedTokenException ex) {
      if (inputState.guessing==0) {
        
        reportMaybeCALDocInlineBlockNotClosedBeforeEndOfTextBlockError(openInlineTag, ex);
        // no consumption of the invalid token... it may well be the close of the comment.
        
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        
        reportError(ex);
        consume();
        consumeUntil(_tokenSet_123);
        
      } else {
        throw ex;
      }
    }
    returnAST = docCommentCloseInlineTag_AST;
  }
  
  public final void docCommentInlineBlockContentUrlTagAndContent() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST docCommentInlineBlockContentUrlTagAndContent_AST = null;
    Token  node = null;
    AST node_AST = null;
    
    try {      // for error handling
      node = LT(1);
      node_AST = astFactory.create(node);
      astFactory.makeASTRoot(currentAST, node_AST);
      match(CALDOC_INLINE_URL_TAG);
      if ( inputState.guessing==0 ) {
        node_AST.initialize(CALDOC_TEXT_URL, "CALDOC_TEXT_URL");
      }
      docCommentTextBlockWithoutInlineTags(node);
      astFactory.addASTChild(currentAST, returnAST);
      docCommentInlineBlockContentUrlTagAndContent_AST = (AST)currentAST.root;
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        recover(ex,_tokenSet_124);
      } else {
        throw ex;
      }
    }
    returnAST = docCommentInlineBlockContentUrlTagAndContent_AST;
  }
  
  public final void docCommentInlineBlockContentLinkTagAndContent() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST docCommentInlineBlockContentLinkTagAndContent_AST = null;
    Token  node = null;
    AST node_AST = null;
    
    try {      // for error handling
      node = LT(1);
      node_AST = astFactory.create(node);
      astFactory.makeASTRoot(currentAST, node_AST);
      match(CALDOC_INLINE_LINK_TAG);
      if ( inputState.guessing==0 ) {
        node_AST.initialize(CALDOC_TEXT_LINK, "CALDOC_TEXT_LINK");
      }
      {
      switch ( LA(1)) {
      case CALDOC_SEE_TAG_FUNCTION_CONTEXT:
      {
        docCommentLinkFunction();
        astFactory.addASTChild(currentAST, returnAST);
        break;
      }
      case CALDOC_SEE_TAG_MODULE_CONTEXT:
      {
        docCommentLinkModule();
        astFactory.addASTChild(currentAST, returnAST);
        break;
      }
      case CALDOC_SEE_TAG_DATACONS_CONTEXT:
      {
        docCommentLinkDataCons();
        astFactory.addASTChild(currentAST, returnAST);
        break;
      }
      case CALDOC_SEE_TAG_TYPECONS_CONTEXT:
      {
        docCommentLinkTypeCons();
        astFactory.addASTChild(currentAST, returnAST);
        break;
      }
      case CALDOC_SEE_TAG_TYPECLASS_CONTEXT:
      {
        docCommentLinkTypeClass();
        astFactory.addASTChild(currentAST, returnAST);
        break;
      }
      case CALDOC_SEE_TAG_UNKNOWN_CONTEXT:
      {
        docCommentLinkUnknown();
        break;
      }
      default:
        boolean synPredMatched323 = false;
        if (((LA(1)==CONS_ID||LA(1)==VAR_ID) && (LA(2)==EQUALS))) {
          int _m323 = mark();
          synPredMatched323 = true;
          inputState.guessing++;
          try {
            {
            {
            switch ( LA(1)) {
            case VAR_ID:
            {
              match(VAR_ID);
              break;
            }
            case CONS_ID:
            {
              match(CONS_ID);
              break;
            }
            default:
            {
              throw new NoViableAltException(LT(1), getFilename());
            }
            }
            }
            match(EQUALS);
            }
          }
          catch (RecognitionException pe) {
            synPredMatched323 = false;
          }
          rewind(_m323);
inputState.guessing--;
        }
        if ( synPredMatched323 ) {
          docCommentLinkUnknownIdentifierLike();
        }
        else if ((_tokenSet_127.member(LA(1))) && (_tokenSet_128.member(LA(2)))) {
          docCommentLinkWithoutContext();
          astFactory.addASTChild(currentAST, returnAST);
        }
      else {
        throw new NoViableAltException(LT(1), getFilename());
      }
      }
      }
      docCommentInlineBlockContentLinkTagAndContent_AST = (AST)currentAST.root;
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        
        reportMaybeMissingSeeOrLinkBlockContextInCALDocCommentError(ex);
        consume();
        consumeUntil(_tokenSet_124);
        
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        
        reportError(ex);
        consume();
        consumeUntil(_tokenSet_124);
        
      } else {
        throw ex;
      }
    }
    returnAST = docCommentInlineBlockContentLinkTagAndContent_AST;
  }
  
  public final void docCommentInlineBlockContentEmTagAndContent() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST docCommentInlineBlockContentEmTagAndContent_AST = null;
    Token  node = null;
    AST node_AST = null;
    
    try {      // for error handling
      node = LT(1);
      node_AST = astFactory.create(node);
      astFactory.makeASTRoot(currentAST, node_AST);
      match(CALDOC_INLINE_EM_TAG);
      if ( inputState.guessing==0 ) {
        node_AST.initialize(CALDOC_TEXT_EMPHASIZED_TEXT, "CALDOC_TEXT_EMPHASIZED_TEXT");
      }
      docCommentTextualContent();
      astFactory.addASTChild(currentAST, returnAST);
      docCommentInlineBlockContentEmTagAndContent_AST = (AST)currentAST.root;
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        recover(ex,_tokenSet_124);
      } else {
        throw ex;
      }
    }
    returnAST = docCommentInlineBlockContentEmTagAndContent_AST;
  }
  
  public final void docCommentInlineBlockContentStrongTagAndContent() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST docCommentInlineBlockContentStrongTagAndContent_AST = null;
    Token  node = null;
    AST node_AST = null;
    
    try {      // for error handling
      node = LT(1);
      node_AST = astFactory.create(node);
      astFactory.makeASTRoot(currentAST, node_AST);
      match(CALDOC_INLINE_STRONG_TAG);
      if ( inputState.guessing==0 ) {
        node_AST.initialize(CALDOC_TEXT_STRONGLY_EMPHASIZED_TEXT, "CALDOC_TEXT_STRONGLY_EMPHASIZED_TEXT");
      }
      docCommentTextualContent();
      astFactory.addASTChild(currentAST, returnAST);
      docCommentInlineBlockContentStrongTagAndContent_AST = (AST)currentAST.root;
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        recover(ex,_tokenSet_124);
      } else {
        throw ex;
      }
    }
    returnAST = docCommentInlineBlockContentStrongTagAndContent_AST;
  }
  
  public final void docCommentInlineBlockContentSupTagAndContent() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST docCommentInlineBlockContentSupTagAndContent_AST = null;
    Token  node = null;
    AST node_AST = null;
    
    try {      // for error handling
      node = LT(1);
      node_AST = astFactory.create(node);
      astFactory.makeASTRoot(currentAST, node_AST);
      match(CALDOC_INLINE_SUP_TAG);
      if ( inputState.guessing==0 ) {
        node_AST.initialize(CALDOC_TEXT_SUPERSCRIPT_TEXT, "CALDOC_TEXT_SUPERSCRIPT_TEXT");
      }
      docCommentTextualContent();
      astFactory.addASTChild(currentAST, returnAST);
      docCommentInlineBlockContentSupTagAndContent_AST = (AST)currentAST.root;
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        recover(ex,_tokenSet_124);
      } else {
        throw ex;
      }
    }
    returnAST = docCommentInlineBlockContentSupTagAndContent_AST;
  }
  
  public final void docCommentInlineBlockContentSubTagAndContent() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST docCommentInlineBlockContentSubTagAndContent_AST = null;
    Token  node = null;
    AST node_AST = null;
    
    try {      // for error handling
      node = LT(1);
      node_AST = astFactory.create(node);
      astFactory.makeASTRoot(currentAST, node_AST);
      match(CALDOC_INLINE_SUB_TAG);
      if ( inputState.guessing==0 ) {
        node_AST.initialize(CALDOC_TEXT_SUBSCRIPT_TEXT, "CALDOC_TEXT_SUBSCRIPT_TEXT");
      }
      docCommentTextualContent();
      astFactory.addASTChild(currentAST, returnAST);
      docCommentInlineBlockContentSubTagAndContent_AST = (AST)currentAST.root;
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        recover(ex,_tokenSet_124);
      } else {
        throw ex;
      }
    }
    returnAST = docCommentInlineBlockContentSubTagAndContent_AST;
  }
  
  public final void docCommentInlineBlockContentSummaryTagAndContent() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST docCommentInlineBlockContentSummaryTagAndContent_AST = null;
    Token  node = null;
    AST node_AST = null;
    
    try {      // for error handling
      node = LT(1);
      node_AST = astFactory.create(node);
      astFactory.makeASTRoot(currentAST, node_AST);
      match(CALDOC_INLINE_SUMMARY_TAG);
      if ( inputState.guessing==0 ) {
        node_AST.initialize(CALDOC_TEXT_SUMMARY, "CALDOC_TEXT_SUMMARY");
      }
      docCommentTextualContent();
      astFactory.addASTChild(currentAST, returnAST);
      docCommentInlineBlockContentSummaryTagAndContent_AST = (AST)currentAST.root;
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        recover(ex,_tokenSet_124);
      } else {
        throw ex;
      }
    }
    returnAST = docCommentInlineBlockContentSummaryTagAndContent_AST;
  }
  
  public final void docCommentInlineBlockContentCodeTagAndContent() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST docCommentInlineBlockContentCodeTagAndContent_AST = null;
    Token  node = null;
    AST node_AST = null;
    
    try {      // for error handling
      node = LT(1);
      node_AST = astFactory.create(node);
      astFactory.makeASTRoot(currentAST, node_AST);
      match(CALDOC_INLINE_CODE_TAG);
      if ( inputState.guessing==0 ) {
        node_AST.initialize(CALDOC_TEXT_CODE_BLOCK, "CALDOC_TEXT_CODE_BLOCK");
      }
      docCommentPreformattedBlock();
      astFactory.addASTChild(currentAST, returnAST);
      docCommentInlineBlockContentCodeTagAndContent_AST = (AST)currentAST.root;
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        recover(ex,_tokenSet_124);
      } else {
        throw ex;
      }
    }
    returnAST = docCommentInlineBlockContentCodeTagAndContent_AST;
  }
  
  public final void docCommentInlineBlockContentOrderedListTagAndContent() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST docCommentInlineBlockContentOrderedListTagAndContent_AST = null;
    Token  node = null;
    AST node_AST = null;
    
    try {      // for error handling
      node = LT(1);
      node_AST = astFactory.create(node);
      astFactory.makeASTRoot(currentAST, node_AST);
      match(CALDOC_INLINE_ORDERED_LIST_TAG);
      if ( inputState.guessing==0 ) {
        node_AST.initialize(CALDOC_TEXT_ORDERED_LIST, "CALDOC_TEXT_ORDERED_LIST");
      }
      {
      _loop332:
      do {
        if ((_tokenSet_129.member(LA(1)))) {
          docCommentListItem();
          astFactory.addASTChild(currentAST, returnAST);
        }
        else {
          break _loop332;
        }
        
      } while (true);
      }
      docCommentInlineBlockContentOrderedListTagAndContent_AST = (AST)currentAST.root;
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        recover(ex,_tokenSet_124);
      } else {
        throw ex;
      }
    }
    returnAST = docCommentInlineBlockContentOrderedListTagAndContent_AST;
  }
  
  public final void docCommentInlineBlockContentUnorderedListTagAndContent() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST docCommentInlineBlockContentUnorderedListTagAndContent_AST = null;
    Token  node = null;
    AST node_AST = null;
    
    try {      // for error handling
      node = LT(1);
      node_AST = astFactory.create(node);
      astFactory.makeASTRoot(currentAST, node_AST);
      match(CALDOC_INLINE_UNORDERED_LIST_TAG);
      if ( inputState.guessing==0 ) {
        node_AST.initialize(CALDOC_TEXT_UNORDERED_LIST, "CALDOC_TEXT_UNORDERED_LIST");
      }
      {
      _loop335:
      do {
        if ((_tokenSet_129.member(LA(1)))) {
          docCommentListItem();
          astFactory.addASTChild(currentAST, returnAST);
        }
        else {
          break _loop335;
        }
        
      } while (true);
      }
      docCommentInlineBlockContentUnorderedListTagAndContent_AST = (AST)currentAST.root;
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        recover(ex,_tokenSet_124);
      } else {
        throw ex;
      }
    }
    returnAST = docCommentInlineBlockContentUnorderedListTagAndContent_AST;
  }
  
  public final void docCommentInlineBlockContentUnknownTagAndContent() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST docCommentInlineBlockContentUnknownTagAndContent_AST = null;
    Token  unknownTag = null;
    AST unknownTag_AST = null;
    AST text_AST = null;
    
    try {      // for error handling
      unknownTag = LT(1);
      unknownTag_AST = astFactory.create(unknownTag);
      match(CALDOC_INLINE_UNKNOWN_TAG);
      docCommentTextualContent();
      text_AST = (AST)returnAST;
      if ( inputState.guessing==0 ) {
        reportUnrecognizedInlineTagInCALDocCommentError(unknownTag);
      }
      docCommentInlineBlockContentUnknownTagAndContent_AST = (AST)currentAST.root;
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        recover(ex,_tokenSet_124);
      } else {
        throw ex;
      }
    }
    returnAST = docCommentInlineBlockContentUnknownTagAndContent_AST;
  }
  
  public final void docCommentLinkFunction() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST docCommentLinkFunction_AST = null;
    
    try {      // for error handling
      match(CALDOC_SEE_TAG_FUNCTION_CONTEXT);
      match(EQUALS);
      docCommentMaybeUncheckedQualifiedVar();
      astFactory.addASTChild(currentAST, returnAST);
      if ( inputState.guessing==0 ) {
        docCommentLinkFunction_AST = (AST)currentAST.root;
        docCommentLinkFunction_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(CALDOC_TEXT_LINK_FUNCTION,"CALDOC_TEXT_LINK_FUNCTION")).add(docCommentLinkFunction_AST));
        currentAST.root = docCommentLinkFunction_AST;
        currentAST.child = docCommentLinkFunction_AST!=null &&docCommentLinkFunction_AST.getFirstChild()!=null ?
          docCommentLinkFunction_AST.getFirstChild() : docCommentLinkFunction_AST;
        currentAST.advanceChildToEnd();
      }
      docCommentLinkFunction_AST = (AST)currentAST.root;
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        recover(ex,_tokenSet_124);
      } else {
        throw ex;
      }
    }
    returnAST = docCommentLinkFunction_AST;
  }
  
  public final void docCommentLinkModule() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST docCommentLinkModule_AST = null;
    
    try {      // for error handling
      match(CALDOC_SEE_TAG_MODULE_CONTEXT);
      match(EQUALS);
      docCommentMaybeUncheckedModuleName();
      astFactory.addASTChild(currentAST, returnAST);
      if ( inputState.guessing==0 ) {
        docCommentLinkModule_AST = (AST)currentAST.root;
        docCommentLinkModule_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(CALDOC_TEXT_LINK_MODULE,"CALDOC_TEXT_LINK_MODULE")).add(docCommentLinkModule_AST));
        currentAST.root = docCommentLinkModule_AST;
        currentAST.child = docCommentLinkModule_AST!=null &&docCommentLinkModule_AST.getFirstChild()!=null ?
          docCommentLinkModule_AST.getFirstChild() : docCommentLinkModule_AST;
        currentAST.advanceChildToEnd();
      }
      docCommentLinkModule_AST = (AST)currentAST.root;
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        recover(ex,_tokenSet_124);
      } else {
        throw ex;
      }
    }
    returnAST = docCommentLinkModule_AST;
  }
  
  public final void docCommentLinkDataCons() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST docCommentLinkDataCons_AST = null;
    
    try {      // for error handling
      match(CALDOC_SEE_TAG_DATACONS_CONTEXT);
      match(EQUALS);
      docCommentMaybeUncheckedQualifiedCons();
      astFactory.addASTChild(currentAST, returnAST);
      if ( inputState.guessing==0 ) {
        docCommentLinkDataCons_AST = (AST)currentAST.root;
        docCommentLinkDataCons_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(CALDOC_TEXT_LINK_DATACONS,"CALDOC_TEXT_LINK_DATACONS")).add(docCommentLinkDataCons_AST));
        currentAST.root = docCommentLinkDataCons_AST;
        currentAST.child = docCommentLinkDataCons_AST!=null &&docCommentLinkDataCons_AST.getFirstChild()!=null ?
          docCommentLinkDataCons_AST.getFirstChild() : docCommentLinkDataCons_AST;
        currentAST.advanceChildToEnd();
      }
      docCommentLinkDataCons_AST = (AST)currentAST.root;
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        recover(ex,_tokenSet_124);
      } else {
        throw ex;
      }
    }
    returnAST = docCommentLinkDataCons_AST;
  }
  
  public final void docCommentLinkTypeCons() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST docCommentLinkTypeCons_AST = null;
    
    try {      // for error handling
      match(CALDOC_SEE_TAG_TYPECONS_CONTEXT);
      match(EQUALS);
      docCommentMaybeUncheckedQualifiedCons();
      astFactory.addASTChild(currentAST, returnAST);
      if ( inputState.guessing==0 ) {
        docCommentLinkTypeCons_AST = (AST)currentAST.root;
        docCommentLinkTypeCons_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(CALDOC_TEXT_LINK_TYPECONS,"CALDOC_TEXT_LINK_TYPECONS")).add(docCommentLinkTypeCons_AST));
        currentAST.root = docCommentLinkTypeCons_AST;
        currentAST.child = docCommentLinkTypeCons_AST!=null &&docCommentLinkTypeCons_AST.getFirstChild()!=null ?
          docCommentLinkTypeCons_AST.getFirstChild() : docCommentLinkTypeCons_AST;
        currentAST.advanceChildToEnd();
      }
      docCommentLinkTypeCons_AST = (AST)currentAST.root;
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        recover(ex,_tokenSet_124);
      } else {
        throw ex;
      }
    }
    returnAST = docCommentLinkTypeCons_AST;
  }
  
  public final void docCommentLinkTypeClass() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST docCommentLinkTypeClass_AST = null;
    
    try {      // for error handling
      match(CALDOC_SEE_TAG_TYPECLASS_CONTEXT);
      match(EQUALS);
      docCommentMaybeUncheckedQualifiedCons();
      astFactory.addASTChild(currentAST, returnAST);
      if ( inputState.guessing==0 ) {
        docCommentLinkTypeClass_AST = (AST)currentAST.root;
        docCommentLinkTypeClass_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(CALDOC_TEXT_LINK_TYPECLASS,"CALDOC_TEXT_LINK_TYPECLASS")).add(docCommentLinkTypeClass_AST));
        currentAST.root = docCommentLinkTypeClass_AST;
        currentAST.child = docCommentLinkTypeClass_AST!=null &&docCommentLinkTypeClass_AST.getFirstChild()!=null ?
          docCommentLinkTypeClass_AST.getFirstChild() : docCommentLinkTypeClass_AST;
        currentAST.advanceChildToEnd();
      }
      docCommentLinkTypeClass_AST = (AST)currentAST.root;
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        recover(ex,_tokenSet_124);
      } else {
        throw ex;
      }
    }
    returnAST = docCommentLinkTypeClass_AST;
  }
  
  public final void docCommentLinkUnknownIdentifierLike() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST docCommentLinkUnknownIdentifierLike_AST = null;
    AST unknownContext_AST = null;
    
    try {      // for error handling
      docCommentLinkUnknownIdentifierLikeContext();
      unknownContext_AST = (AST)returnAST;
      docCommentLinkUnknownRemainder();
      if ( inputState.guessing==0 ) {
        reportUnrecognizedSeeOrLinkBlockContextInCALDocCommentError((ParseTreeNode)unknownContext_AST);
      }
      docCommentLinkUnknownIdentifierLike_AST = (AST)currentAST.root;
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        recover(ex,_tokenSet_124);
      } else {
        throw ex;
      }
    }
    returnAST = docCommentLinkUnknownIdentifierLike_AST;
  }
  
  public final void docCommentLinkWithoutContext() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST docCommentLinkWithoutContext_AST = null;
    
    try {      // for error handling
      docCommentMaybeUncheckedReferenceWithoutContext();
      astFactory.addASTChild(currentAST, returnAST);
      if ( inputState.guessing==0 ) {
        docCommentLinkWithoutContext_AST = (AST)currentAST.root;
        docCommentLinkWithoutContext_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(CALDOC_TEXT_LINK_WITHOUT_CONTEXT,"CALDOC_TEXT_LINK_WITHOUT_CONTEXT")).add(docCommentLinkWithoutContext_AST));
        currentAST.root = docCommentLinkWithoutContext_AST;
        currentAST.child = docCommentLinkWithoutContext_AST!=null &&docCommentLinkWithoutContext_AST.getFirstChild()!=null ?
          docCommentLinkWithoutContext_AST.getFirstChild() : docCommentLinkWithoutContext_AST;
        currentAST.advanceChildToEnd();
      }
      docCommentLinkWithoutContext_AST = (AST)currentAST.root;
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        recover(ex,_tokenSet_124);
      } else {
        throw ex;
      }
    }
    returnAST = docCommentLinkWithoutContext_AST;
  }
  
  public final void docCommentLinkUnknown() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST docCommentLinkUnknown_AST = null;
    Token  unknownContext = null;
    AST unknownContext_AST = null;
    
    try {      // for error handling
      unknownContext = LT(1);
      unknownContext_AST = astFactory.create(unknownContext);
      match(CALDOC_SEE_TAG_UNKNOWN_CONTEXT);
      docCommentLinkUnknownRemainder();
      if ( inputState.guessing==0 ) {
        reportUnrecognizedSeeOrLinkBlockContextInCALDocCommentError((ParseTreeNode)unknownContext_AST);
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        recover(ex,_tokenSet_124);
      } else {
        throw ex;
      }
    }
    returnAST = docCommentLinkUnknown_AST;
  }
  
  public final void docCommentListItem() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST docCommentListItem_AST = null;
    Token  node = null;
    AST node_AST = null;
    
    try {      // for error handling
      switch ( LA(1)) {
      case CALDOC_BLANK_TEXT_LINE:
      {
        match(CALDOC_BLANK_TEXT_LINE);
        docCommentListItem_AST = (AST)currentAST.root;
        break;
      }
      case CALDOC_NEWLINE:
      case CALDOC_NEWLINE_WITH_LEADING_ASTERISK:
      {
        docCommentNewline();
        docCommentListItem_AST = (AST)currentAST.root;
        break;
      }
      case CALDOC_OPEN_INLINE_TAG:
      {
        match(CALDOC_OPEN_INLINE_TAG);
        node = LT(1);
        node_AST = astFactory.create(node);
        astFactory.makeASTRoot(currentAST, node_AST);
        match(CALDOC_INLINE_ITEM_TAG);
        if ( inputState.guessing==0 ) {
          node_AST.initialize(CALDOC_TEXT_LIST_ITEM, "CALDOC_TEXT_LIST_ITEM");
        }
        docCommentTextualContent();
        astFactory.addASTChild(currentAST, returnAST);
        match(CALDOC_CLOSE_INLINE_TAG);
        docCommentListItem_AST = (AST)currentAST.root;
        break;
      }
      default:
      {
        throw new NoViableAltException(LT(1), getFilename());
      }
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        recover(ex,_tokenSet_130);
      } else {
        throw ex;
      }
    }
    returnAST = docCommentListItem_AST;
  }
  
  public final void docCommentLinkUnknownRemainder() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST docCommentLinkUnknownRemainder_AST = null;
    
    try {      // for error handling
      {
      _loop343:
      do {
        switch ( LA(1)) {
        case CALDOC_SEE_TAG_FUNCTION_CONTEXT:
        {
          match(CALDOC_SEE_TAG_FUNCTION_CONTEXT);
          break;
        }
        case CALDOC_SEE_TAG_MODULE_CONTEXT:
        {
          match(CALDOC_SEE_TAG_MODULE_CONTEXT);
          break;
        }
        case CALDOC_SEE_TAG_DATACONS_CONTEXT:
        {
          match(CALDOC_SEE_TAG_DATACONS_CONTEXT);
          break;
        }
        case CALDOC_SEE_TAG_TYPECONS_CONTEXT:
        {
          match(CALDOC_SEE_TAG_TYPECONS_CONTEXT);
          break;
        }
        case CALDOC_SEE_TAG_TYPECLASS_CONTEXT:
        {
          match(CALDOC_SEE_TAG_TYPECLASS_CONTEXT);
          break;
        }
        case EQUALS:
        {
          match(EQUALS);
          break;
        }
        case DOT:
        {
          match(DOT);
          break;
        }
        case COMMA:
        {
          match(COMMA);
          break;
        }
        case CALDOC_SEE_TAG_QUOTE:
        {
          match(CALDOC_SEE_TAG_QUOTE);
          break;
        }
        case CONS_ID:
        {
          match(CONS_ID);
          break;
        }
        case VAR_ID:
        {
          match(VAR_ID);
          break;
        }
        case CALDOC_TEXT_LINE:
        {
          match(CALDOC_TEXT_LINE);
          break;
        }
        case CALDOC_BLANK_TEXT_LINE:
        {
          match(CALDOC_BLANK_TEXT_LINE);
          break;
        }
        case CALDOC_INLINE_SUMMARY_TAG:
        {
          match(CALDOC_INLINE_SUMMARY_TAG);
          break;
        }
        case CALDOC_INLINE_EM_TAG:
        {
          match(CALDOC_INLINE_EM_TAG);
          break;
        }
        case CALDOC_INLINE_STRONG_TAG:
        {
          match(CALDOC_INLINE_STRONG_TAG);
          break;
        }
        case CALDOC_INLINE_SUP_TAG:
        {
          match(CALDOC_INLINE_SUP_TAG);
          break;
        }
        case CALDOC_INLINE_SUB_TAG:
        {
          match(CALDOC_INLINE_SUB_TAG);
          break;
        }
        case CALDOC_INLINE_UNORDERED_LIST_TAG:
        {
          match(CALDOC_INLINE_UNORDERED_LIST_TAG);
          break;
        }
        case CALDOC_INLINE_ORDERED_LIST_TAG:
        {
          match(CALDOC_INLINE_ORDERED_LIST_TAG);
          break;
        }
        case CALDOC_INLINE_ITEM_TAG:
        {
          match(CALDOC_INLINE_ITEM_TAG);
          break;
        }
        case CALDOC_INLINE_CODE_TAG:
        {
          match(CALDOC_INLINE_CODE_TAG);
          break;
        }
        case CALDOC_INLINE_URL_TAG:
        {
          match(CALDOC_INLINE_URL_TAG);
          break;
        }
        case CALDOC_INLINE_LINK_TAG:
        {
          match(CALDOC_INLINE_LINK_TAG);
          break;
        }
        case CALDOC_NEWLINE:
        {
          match(CALDOC_NEWLINE);
          break;
        }
        case CALDOC_NEWLINE_WITH_LEADING_ASTERISK:
        {
          match(CALDOC_NEWLINE_WITH_LEADING_ASTERISK);
          break;
        }
        default:
        {
          break _loop343;
        }
        }
      } while (true);
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        recover(ex,_tokenSet_124);
      } else {
        throw ex;
      }
    }
    returnAST = docCommentLinkUnknownRemainder_AST;
  }
  
  public final void docCommentLinkUnknownIdentifierLikeContext() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST docCommentLinkUnknownIdentifierLikeContext_AST = null;
    
    try {      // for error handling
      {
      switch ( LA(1)) {
      case VAR_ID:
      {
        AST tmp173_AST = null;
        tmp173_AST = astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp173_AST);
        match(VAR_ID);
        break;
      }
      case CONS_ID:
      {
        AST tmp174_AST = null;
        tmp174_AST = astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp174_AST);
        match(CONS_ID);
        break;
      }
      default:
      {
        throw new NoViableAltException(LT(1), getFilename());
      }
      }
      }
      AST tmp175_AST = null;
      tmp175_AST = astFactory.create(LT(1));
      astFactory.addASTChild(currentAST, tmp175_AST);
      match(EQUALS);
      docCommentLinkUnknownIdentifierLikeContext_AST = (AST)currentAST.root;
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        recover(ex,_tokenSet_131);
      } else {
        throw ex;
      }
    }
    returnAST = docCommentLinkUnknownIdentifierLikeContext_AST;
  }
  
  public final void docCommentMaybeUncheckedQualifiedVar() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST docCommentMaybeUncheckedQualifiedVar_AST = null;
    Token  node = null;
    AST node_AST = null;
    
    try {      // for error handling
      switch ( LA(1)) {
      case CONS_ID:
      case VAR_ID:
      {
        qualifiedVar(LT(1), "a qualified variable name");
        astFactory.addASTChild(currentAST, returnAST);
        if ( inputState.guessing==0 ) {
          docCommentMaybeUncheckedQualifiedVar_AST = (AST)currentAST.root;
          docCommentMaybeUncheckedQualifiedVar_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(CALDOC_CHECKED_QUALIFIED_VAR,"CALDOC_CHECKED_QUALIFIED_VAR")).add(docCommentMaybeUncheckedQualifiedVar_AST));
          currentAST.root = docCommentMaybeUncheckedQualifiedVar_AST;
          currentAST.child = docCommentMaybeUncheckedQualifiedVar_AST!=null &&docCommentMaybeUncheckedQualifiedVar_AST.getFirstChild()!=null ?
            docCommentMaybeUncheckedQualifiedVar_AST.getFirstChild() : docCommentMaybeUncheckedQualifiedVar_AST;
          currentAST.advanceChildToEnd();
        }
        docCommentMaybeUncheckedQualifiedVar_AST = (AST)currentAST.root;
        break;
      }
      case CALDOC_SEE_TAG_QUOTE:
      {
        node = LT(1);
        node_AST = astFactory.create(node);
        astFactory.makeASTRoot(currentAST, node_AST);
        match(CALDOC_SEE_TAG_QUOTE);
        if ( inputState.guessing==0 ) {
          node_AST.initialize(CALDOC_UNCHECKED_QUALIFIED_VAR, "CALDOC_UNCHECKED_QUALIFIED_VAR");
        }
        qualifiedVar(LT(1), "a qualified variable name");
        astFactory.addASTChild(currentAST, returnAST);
        match(CALDOC_SEE_TAG_QUOTE);
        docCommentMaybeUncheckedQualifiedVar_AST = (AST)currentAST.root;
        break;
      }
      default:
      {
        throw new NoViableAltException(LT(1), getFilename());
      }
      }
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        
        reportMaybeUnrecognizedSeeOrLinkBlockReferenceInCALDocCommentError(ex);
        consume();
        consumeUntil(_tokenSet_132);
        
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        
        reportError(ex);
        consume();
        consumeUntil(_tokenSet_132);
        
      } else {
        throw ex;
      }
    }
    returnAST = docCommentMaybeUncheckedQualifiedVar_AST;
  }
  
  public final void docCommentMaybeUncheckedModuleName() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST docCommentMaybeUncheckedModuleName_AST = null;
    
    try {      // for error handling
      switch ( LA(1)) {
      case CONS_ID:
      {
        moduleName(LT(1), "a valid module name");
        astFactory.addASTChild(currentAST, returnAST);
        if ( inputState.guessing==0 ) {
          docCommentMaybeUncheckedModuleName_AST = (AST)currentAST.root;
          docCommentMaybeUncheckedModuleName_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(CALDOC_CHECKED_MODULE_NAME,"CALDOC_CHECKED_MODULE_NAME")).add(docCommentMaybeUncheckedModuleName_AST));
          currentAST.root = docCommentMaybeUncheckedModuleName_AST;
          currentAST.child = docCommentMaybeUncheckedModuleName_AST!=null &&docCommentMaybeUncheckedModuleName_AST.getFirstChild()!=null ?
            docCommentMaybeUncheckedModuleName_AST.getFirstChild() : docCommentMaybeUncheckedModuleName_AST;
          currentAST.advanceChildToEnd();
        }
        docCommentMaybeUncheckedModuleName_AST = (AST)currentAST.root;
        break;
      }
      case CALDOC_SEE_TAG_QUOTE:
      {
        match(CALDOC_SEE_TAG_QUOTE);
        moduleName(LT(1), "a valid module name");
        astFactory.addASTChild(currentAST, returnAST);
        match(CALDOC_SEE_TAG_QUOTE);
        if ( inputState.guessing==0 ) {
          docCommentMaybeUncheckedModuleName_AST = (AST)currentAST.root;
          docCommentMaybeUncheckedModuleName_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(CALDOC_UNCHECKED_MODULE_NAME,"CALDOC_UNCHECKED_MODULE_NAME")).add(docCommentMaybeUncheckedModuleName_AST));
          currentAST.root = docCommentMaybeUncheckedModuleName_AST;
          currentAST.child = docCommentMaybeUncheckedModuleName_AST!=null &&docCommentMaybeUncheckedModuleName_AST.getFirstChild()!=null ?
            docCommentMaybeUncheckedModuleName_AST.getFirstChild() : docCommentMaybeUncheckedModuleName_AST;
          currentAST.advanceChildToEnd();
        }
        docCommentMaybeUncheckedModuleName_AST = (AST)currentAST.root;
        break;
      }
      default:
      {
        throw new NoViableAltException(LT(1), getFilename());
      }
      }
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        
        reportMaybeUnrecognizedSeeOrLinkBlockReferenceInCALDocCommentError(ex);
        consume();
        consumeUntil(_tokenSet_132);
        
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        
        reportError(ex);
        consume();
        consumeUntil(_tokenSet_132);
        
      } else {
        throw ex;
      }
    }
    returnAST = docCommentMaybeUncheckedModuleName_AST;
  }
  
  public final void docCommentMaybeUncheckedQualifiedCons() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST docCommentMaybeUncheckedQualifiedCons_AST = null;
    
    try {      // for error handling
      docCommentMaybeUncheckedQualifiedConsWithParaphrase("a qualified constructor name");
      astFactory.addASTChild(currentAST, returnAST);
      docCommentMaybeUncheckedQualifiedCons_AST = (AST)currentAST.root;
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        recover(ex,_tokenSet_132);
      } else {
        throw ex;
      }
    }
    returnAST = docCommentMaybeUncheckedQualifiedCons_AST;
  }
  
  public final void docCommentMaybeUncheckedReferenceWithoutContext() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST docCommentMaybeUncheckedReferenceWithoutContext_AST = null;
    
    try {      // for error handling
      {
      boolean synPredMatched353 = false;
      if (((_tokenSet_127.member(LA(1))) && (_tokenSet_133.member(LA(2))))) {
        int _m353 = mark();
        synPredMatched353 = true;
        inputState.guessing++;
        try {
          {
          docCommentMaybeUncheckedQualifiedVar();
          }
        }
        catch (RecognitionException pe) {
          synPredMatched353 = false;
        }
        rewind(_m353);
inputState.guessing--;
      }
      if ( synPredMatched353 ) {
        docCommentMaybeUncheckedQualifiedVar();
        astFactory.addASTChild(currentAST, returnAST);
      }
      else if ((LA(1)==CONS_ID||LA(1)==CALDOC_SEE_TAG_QUOTE) && (_tokenSet_134.member(LA(2)))) {
        docCommentMaybeUncheckedQualifiedConsWithParaphrase("a qualified variable name or a qualified constructor name");
        astFactory.addASTChild(currentAST, returnAST);
      }
      else {
        throw new NoViableAltException(LT(1), getFilename());
      }
      
      }
      docCommentMaybeUncheckedReferenceWithoutContext_AST = (AST)currentAST.root;
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        recover(ex,_tokenSet_132);
      } else {
        throw ex;
      }
    }
    returnAST = docCommentMaybeUncheckedReferenceWithoutContext_AST;
  }
  
  public final void docCommentMaybeUncheckedQualifiedConsWithParaphrase(
    String paraphrase
  ) throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST docCommentMaybeUncheckedQualifiedConsWithParaphrase_AST = null;
    Token  node = null;
    AST node_AST = null;
    
    try {      // for error handling
      switch ( LA(1)) {
      case CONS_ID:
      {
        qualifiedCons(LT(1), paraphrase);
        astFactory.addASTChild(currentAST, returnAST);
        if ( inputState.guessing==0 ) {
          docCommentMaybeUncheckedQualifiedConsWithParaphrase_AST = (AST)currentAST.root;
          docCommentMaybeUncheckedQualifiedConsWithParaphrase_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(CALDOC_CHECKED_QUALIFIED_CONS,"CALDOC_CHECKED_QUALIFIED_CONS")).add(docCommentMaybeUncheckedQualifiedConsWithParaphrase_AST));
          currentAST.root = docCommentMaybeUncheckedQualifiedConsWithParaphrase_AST;
          currentAST.child = docCommentMaybeUncheckedQualifiedConsWithParaphrase_AST!=null &&docCommentMaybeUncheckedQualifiedConsWithParaphrase_AST.getFirstChild()!=null ?
            docCommentMaybeUncheckedQualifiedConsWithParaphrase_AST.getFirstChild() : docCommentMaybeUncheckedQualifiedConsWithParaphrase_AST;
          currentAST.advanceChildToEnd();
        }
        docCommentMaybeUncheckedQualifiedConsWithParaphrase_AST = (AST)currentAST.root;
        break;
      }
      case CALDOC_SEE_TAG_QUOTE:
      {
        node = LT(1);
        node_AST = astFactory.create(node);
        astFactory.makeASTRoot(currentAST, node_AST);
        match(CALDOC_SEE_TAG_QUOTE);
        if ( inputState.guessing==0 ) {
          node_AST.initialize(CALDOC_UNCHECKED_QUALIFIED_CONS, "CALDOC_UNCHECKED_QUALIFIED_CONS");
        }
        qualifiedCons(LT(1), paraphrase);
        astFactory.addASTChild(currentAST, returnAST);
        match(CALDOC_SEE_TAG_QUOTE);
        docCommentMaybeUncheckedQualifiedConsWithParaphrase_AST = (AST)currentAST.root;
        break;
      }
      default:
      {
        throw new NoViableAltException(LT(1), getFilename());
      }
      }
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        
        reportMaybeUnrecognizedSeeOrLinkBlockReferenceInCALDocCommentError(ex);
        consume();
        consumeUntil(_tokenSet_132);
        
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        
        reportError(ex);
        consume();
        consumeUntil(_tokenSet_132);
        
      } else {
        throw ex;
      }
    }
    returnAST = docCommentMaybeUncheckedQualifiedConsWithParaphrase_AST;
  }
  
  public final void docCommentAuthorBlock() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST docCommentAuthorBlock_AST = null;
    Token  node = null;
    AST node_AST = null;
    
    try {      // for error handling
      node = LT(1);
      node_AST = astFactory.create(node);
      astFactory.makeASTRoot(currentAST, node_AST);
      match(CALDOC_AUTHOR_TAG);
      if ( inputState.guessing==0 ) {
        node_AST.initialize(CALDOC_AUTHOR_BLOCK, "CALDOC_AUTHOR_BLOCK");
      }
      docCommentTextualContent();
      astFactory.addASTChild(currentAST, returnAST);
      docCommentAuthorBlock_AST = (AST)currentAST.root;
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        recover(ex,_tokenSet_120);
      } else {
        throw ex;
      }
    }
    returnAST = docCommentAuthorBlock_AST;
  }
  
  public final void docCommentDeprecatedBlock() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST docCommentDeprecatedBlock_AST = null;
    Token  node = null;
    AST node_AST = null;
    
    try {      // for error handling
      node = LT(1);
      node_AST = astFactory.create(node);
      astFactory.makeASTRoot(currentAST, node_AST);
      match(CALDOC_DEPRECATED_TAG);
      if ( inputState.guessing==0 ) {
        node_AST.initialize(CALDOC_DEPRECATED_BLOCK, "CALDOC_DEPRECATED_BLOCK");
      }
      docCommentTextualContent();
      astFactory.addASTChild(currentAST, returnAST);
      docCommentDeprecatedBlock_AST = (AST)currentAST.root;
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        recover(ex,_tokenSet_120);
      } else {
        throw ex;
      }
    }
    returnAST = docCommentDeprecatedBlock_AST;
  }
  
  public final void docCommentReturnBlock() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST docCommentReturnBlock_AST = null;
    Token  node = null;
    AST node_AST = null;
    
    try {      // for error handling
      node = LT(1);
      node_AST = astFactory.create(node);
      astFactory.makeASTRoot(currentAST, node_AST);
      match(CALDOC_RETURN_TAG);
      if ( inputState.guessing==0 ) {
        node_AST.initialize(CALDOC_RETURN_BLOCK, "CALDOC_RETURN_BLOCK");
      }
      docCommentTextualContent();
      astFactory.addASTChild(currentAST, returnAST);
      docCommentReturnBlock_AST = (AST)currentAST.root;
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        recover(ex,_tokenSet_120);
      } else {
        throw ex;
      }
    }
    returnAST = docCommentReturnBlock_AST;
  }
  
  public final void docCommentVersionBlock() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST docCommentVersionBlock_AST = null;
    Token  node = null;
    AST node_AST = null;
    
    try {      // for error handling
      node = LT(1);
      node_AST = astFactory.create(node);
      astFactory.makeASTRoot(currentAST, node_AST);
      match(CALDOC_VERSION_TAG);
      if ( inputState.guessing==0 ) {
        node_AST.initialize(CALDOC_VERSION_BLOCK, "CALDOC_VERSION_BLOCK");
      }
      docCommentTextualContent();
      astFactory.addASTChild(currentAST, returnAST);
      docCommentVersionBlock_AST = (AST)currentAST.root;
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        recover(ex,_tokenSet_120);
      } else {
        throw ex;
      }
    }
    returnAST = docCommentVersionBlock_AST;
  }
  
  public final void docCommentArgBlock() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST docCommentArgBlock_AST = null;
    Token  node = null;
    AST node_AST = null;
    
    try {      // for error handling
      node = LT(1);
      node_AST = astFactory.create(node);
      astFactory.makeASTRoot(currentAST, node_AST);
      match(CALDOC_ARG_TAG);
      if ( inputState.guessing==0 ) {
        node_AST.initialize(CALDOC_ARG_BLOCK, "CALDOC_ARG_BLOCK");
      }
      fieldName(LT(1), "a valid argument name");
      astFactory.addASTChild(currentAST, returnAST);
      docCommentTextualContent();
      astFactory.addASTChild(currentAST, returnAST);
      docCommentArgBlock_AST = (AST)currentAST.root;
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        recover(ex,_tokenSet_120);
      } else {
        throw ex;
      }
    }
    returnAST = docCommentArgBlock_AST;
  }
  
  public final void docCommentSeeBlock() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST docCommentSeeBlock_AST = null;
    Token  seeTag = null;
    AST seeTag_AST = null;
    
    try {      // for error handling
      seeTag = LT(1);
      seeTag_AST = astFactory.create(seeTag);
      match(CALDOC_SEE_TAG);
      {
      switch ( LA(1)) {
      case CALDOC_SEE_TAG_FUNCTION_CONTEXT:
      {
        docCommentSeeFunctionBlock();
        astFactory.addASTChild(currentAST, returnAST);
        break;
      }
      case CALDOC_SEE_TAG_MODULE_CONTEXT:
      {
        docCommentSeeModuleBlock();
        astFactory.addASTChild(currentAST, returnAST);
        break;
      }
      case CALDOC_SEE_TAG_DATACONS_CONTEXT:
      {
        docCommentSeeDataConsBlock();
        astFactory.addASTChild(currentAST, returnAST);
        break;
      }
      case CALDOC_SEE_TAG_TYPECONS_CONTEXT:
      {
        docCommentSeeTypeConsBlock();
        astFactory.addASTChild(currentAST, returnAST);
        break;
      }
      case CALDOC_SEE_TAG_TYPECLASS_CONTEXT:
      {
        docCommentSeeTypeClassBlock();
        astFactory.addASTChild(currentAST, returnAST);
        break;
      }
      case CALDOC_SEE_TAG_UNKNOWN_CONTEXT:
      {
        docCommentSeeUnknownBlock();
        break;
      }
      default:
        boolean synPredMatched367 = false;
        if (((LA(1)==CONS_ID||LA(1)==VAR_ID) && (LA(2)==EQUALS))) {
          int _m367 = mark();
          synPredMatched367 = true;
          inputState.guessing++;
          try {
            {
            {
            switch ( LA(1)) {
            case VAR_ID:
            {
              match(VAR_ID);
              break;
            }
            case CONS_ID:
            {
              match(CONS_ID);
              break;
            }
            default:
            {
              throw new NoViableAltException(LT(1), getFilename());
            }
            }
            }
            match(EQUALS);
            }
          }
          catch (RecognitionException pe) {
            synPredMatched367 = false;
          }
          rewind(_m367);
inputState.guessing--;
        }
        if ( synPredMatched367 ) {
          docCommentSeeUnknownBlockIdentifierLike();
        }
        else if ((_tokenSet_127.member(LA(1))) && (_tokenSet_135.member(LA(2)))) {
          docCommentSeeBlockWithoutContext();
          astFactory.addASTChild(currentAST, returnAST);
        }
      else {
        throw new NoViableAltException(LT(1), getFilename());
      }
      }
      }
      if ( inputState.guessing==0 ) {
        docCommentSeeBlock_AST = (AST)currentAST.root;
        
        docCommentSeeBlock_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(CALDOC_SEE_BLOCK,"CALDOC_SEE_BLOCK")).add(docCommentSeeBlock_AST));
        ((ParseTreeNode)docCommentSeeBlock_AST).addOmittedDelimiter(seeTag_AST);
        
        currentAST.root = docCommentSeeBlock_AST;
        currentAST.child = docCommentSeeBlock_AST!=null &&docCommentSeeBlock_AST.getFirstChild()!=null ?
          docCommentSeeBlock_AST.getFirstChild() : docCommentSeeBlock_AST;
        currentAST.advanceChildToEnd();
      }
      docCommentSeeBlock_AST = (AST)currentAST.root;
    }
    catch (NoViableAltException ex) {
      if (inputState.guessing==0) {
        
        reportMaybeMissingSeeOrLinkBlockContextInCALDocCommentError(ex);
        consume();
        consumeUntil(_tokenSet_120);
        
      } else {
        throw ex;
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        
        reportError(ex);
        consume();
        consumeUntil(_tokenSet_120);
        
      } else {
        throw ex;
      }
    }
    returnAST = docCommentSeeBlock_AST;
  }
  
  public final void docCommentUnknownTagBlock() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST docCommentUnknownTagBlock_AST = null;
    Token  unknownTag = null;
    AST unknownTag_AST = null;
    AST text_AST = null;
    
    try {      // for error handling
      unknownTag = LT(1);
      unknownTag_AST = astFactory.create(unknownTag);
      match(CALDOC_UNKNOWN_TAG);
      docCommentTextualContent();
      text_AST = (AST)returnAST;
      if ( inputState.guessing==0 ) {
        reportUnrecognizedTagInCALDocCommentError(unknownTag);
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        recover(ex,_tokenSet_120);
      } else {
        throw ex;
      }
    }
    returnAST = docCommentUnknownTagBlock_AST;
  }
  
  public final void docCommentSeeFunctionBlock() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST docCommentSeeFunctionBlock_AST = null;
    
    try {      // for error handling
      match(CALDOC_SEE_TAG_FUNCTION_CONTEXT);
      match(EQUALS);
      docCommentMaybeUncheckedQualifiedVar();
      astFactory.addASTChild(currentAST, returnAST);
      {
      _loop377:
      do {
        if ((LA(1)==COMMA)) {
          match(COMMA);
          docCommentMaybeUncheckedQualifiedVar();
          astFactory.addASTChild(currentAST, returnAST);
        }
        else {
          break _loop377;
        }
        
      } while (true);
      }
      if ( inputState.guessing==0 ) {
        docCommentSeeFunctionBlock_AST = (AST)currentAST.root;
        docCommentSeeFunctionBlock_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(CALDOC_SEE_FUNCTION_BLOCK,"CALDOC_SEE_FUNCTION_BLOCK")).add(docCommentSeeFunctionBlock_AST));
        currentAST.root = docCommentSeeFunctionBlock_AST;
        currentAST.child = docCommentSeeFunctionBlock_AST!=null &&docCommentSeeFunctionBlock_AST.getFirstChild()!=null ?
          docCommentSeeFunctionBlock_AST.getFirstChild() : docCommentSeeFunctionBlock_AST;
        currentAST.advanceChildToEnd();
      }
      docCommentSeeFunctionBlock_AST = (AST)currentAST.root;
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        recover(ex,_tokenSet_120);
      } else {
        throw ex;
      }
    }
    returnAST = docCommentSeeFunctionBlock_AST;
  }
  
  public final void docCommentSeeModuleBlock() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST docCommentSeeModuleBlock_AST = null;
    
    try {      // for error handling
      match(CALDOC_SEE_TAG_MODULE_CONTEXT);
      match(EQUALS);
      docCommentMaybeUncheckedModuleName();
      astFactory.addASTChild(currentAST, returnAST);
      {
      _loop380:
      do {
        if ((LA(1)==COMMA)) {
          match(COMMA);
          docCommentMaybeUncheckedModuleName();
          astFactory.addASTChild(currentAST, returnAST);
        }
        else {
          break _loop380;
        }
        
      } while (true);
      }
      if ( inputState.guessing==0 ) {
        docCommentSeeModuleBlock_AST = (AST)currentAST.root;
        docCommentSeeModuleBlock_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(CALDOC_SEE_MODULE_BLOCK,"CALDOC_SEE_MODULE_BLOCK")).add(docCommentSeeModuleBlock_AST));
        currentAST.root = docCommentSeeModuleBlock_AST;
        currentAST.child = docCommentSeeModuleBlock_AST!=null &&docCommentSeeModuleBlock_AST.getFirstChild()!=null ?
          docCommentSeeModuleBlock_AST.getFirstChild() : docCommentSeeModuleBlock_AST;
        currentAST.advanceChildToEnd();
      }
      docCommentSeeModuleBlock_AST = (AST)currentAST.root;
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        recover(ex,_tokenSet_120);
      } else {
        throw ex;
      }
    }
    returnAST = docCommentSeeModuleBlock_AST;
  }
  
  public final void docCommentSeeDataConsBlock() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST docCommentSeeDataConsBlock_AST = null;
    
    try {      // for error handling
      match(CALDOC_SEE_TAG_DATACONS_CONTEXT);
      match(EQUALS);
      docCommentMaybeUncheckedQualifiedCons();
      astFactory.addASTChild(currentAST, returnAST);
      {
      _loop383:
      do {
        if ((LA(1)==COMMA)) {
          match(COMMA);
          docCommentMaybeUncheckedQualifiedCons();
          astFactory.addASTChild(currentAST, returnAST);
        }
        else {
          break _loop383;
        }
        
      } while (true);
      }
      if ( inputState.guessing==0 ) {
        docCommentSeeDataConsBlock_AST = (AST)currentAST.root;
        docCommentSeeDataConsBlock_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(CALDOC_SEE_DATACONS_BLOCK,"CALDOC_SEE_DATACONS_BLOCK")).add(docCommentSeeDataConsBlock_AST));
        currentAST.root = docCommentSeeDataConsBlock_AST;
        currentAST.child = docCommentSeeDataConsBlock_AST!=null &&docCommentSeeDataConsBlock_AST.getFirstChild()!=null ?
          docCommentSeeDataConsBlock_AST.getFirstChild() : docCommentSeeDataConsBlock_AST;
        currentAST.advanceChildToEnd();
      }
      docCommentSeeDataConsBlock_AST = (AST)currentAST.root;
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        recover(ex,_tokenSet_120);
      } else {
        throw ex;
      }
    }
    returnAST = docCommentSeeDataConsBlock_AST;
  }
  
  public final void docCommentSeeTypeConsBlock() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST docCommentSeeTypeConsBlock_AST = null;
    
    try {      // for error handling
      match(CALDOC_SEE_TAG_TYPECONS_CONTEXT);
      match(EQUALS);
      docCommentMaybeUncheckedQualifiedCons();
      astFactory.addASTChild(currentAST, returnAST);
      {
      _loop386:
      do {
        if ((LA(1)==COMMA)) {
          match(COMMA);
          docCommentMaybeUncheckedQualifiedCons();
          astFactory.addASTChild(currentAST, returnAST);
        }
        else {
          break _loop386;
        }
        
      } while (true);
      }
      if ( inputState.guessing==0 ) {
        docCommentSeeTypeConsBlock_AST = (AST)currentAST.root;
        docCommentSeeTypeConsBlock_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(CALDOC_SEE_TYPECONS_BLOCK,"CALDOC_SEE_TYPECONS_BLOCK")).add(docCommentSeeTypeConsBlock_AST));
        currentAST.root = docCommentSeeTypeConsBlock_AST;
        currentAST.child = docCommentSeeTypeConsBlock_AST!=null &&docCommentSeeTypeConsBlock_AST.getFirstChild()!=null ?
          docCommentSeeTypeConsBlock_AST.getFirstChild() : docCommentSeeTypeConsBlock_AST;
        currentAST.advanceChildToEnd();
      }
      docCommentSeeTypeConsBlock_AST = (AST)currentAST.root;
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        recover(ex,_tokenSet_120);
      } else {
        throw ex;
      }
    }
    returnAST = docCommentSeeTypeConsBlock_AST;
  }
  
  public final void docCommentSeeTypeClassBlock() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST docCommentSeeTypeClassBlock_AST = null;
    
    try {      // for error handling
      match(CALDOC_SEE_TAG_TYPECLASS_CONTEXT);
      match(EQUALS);
      docCommentMaybeUncheckedQualifiedCons();
      astFactory.addASTChild(currentAST, returnAST);
      {
      _loop389:
      do {
        if ((LA(1)==COMMA)) {
          match(COMMA);
          docCommentMaybeUncheckedQualifiedCons();
          astFactory.addASTChild(currentAST, returnAST);
        }
        else {
          break _loop389;
        }
        
      } while (true);
      }
      if ( inputState.guessing==0 ) {
        docCommentSeeTypeClassBlock_AST = (AST)currentAST.root;
        docCommentSeeTypeClassBlock_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(CALDOC_SEE_TYPECLASS_BLOCK,"CALDOC_SEE_TYPECLASS_BLOCK")).add(docCommentSeeTypeClassBlock_AST));
        currentAST.root = docCommentSeeTypeClassBlock_AST;
        currentAST.child = docCommentSeeTypeClassBlock_AST!=null &&docCommentSeeTypeClassBlock_AST.getFirstChild()!=null ?
          docCommentSeeTypeClassBlock_AST.getFirstChild() : docCommentSeeTypeClassBlock_AST;
        currentAST.advanceChildToEnd();
      }
      docCommentSeeTypeClassBlock_AST = (AST)currentAST.root;
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        recover(ex,_tokenSet_120);
      } else {
        throw ex;
      }
    }
    returnAST = docCommentSeeTypeClassBlock_AST;
  }
  
  public final void docCommentSeeUnknownBlockIdentifierLike() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST docCommentSeeUnknownBlockIdentifierLike_AST = null;
    AST unknownContext_AST = null;
    
    try {      // for error handling
      docCommentSeeUnknownBlockIdentifierLikeContext();
      unknownContext_AST = (AST)returnAST;
      docCommentSeeUnknownBlockRemainder();
      if ( inputState.guessing==0 ) {
        reportUnrecognizedSeeOrLinkBlockContextInCALDocCommentError((ParseTreeNode)unknownContext_AST);
      }
      docCommentSeeUnknownBlockIdentifierLike_AST = (AST)currentAST.root;
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        recover(ex,_tokenSet_120);
      } else {
        throw ex;
      }
    }
    returnAST = docCommentSeeUnknownBlockIdentifierLike_AST;
  }
  
  public final void docCommentSeeBlockWithoutContext() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST docCommentSeeBlockWithoutContext_AST = null;
    
    try {      // for error handling
      docCommentMaybeUncheckedReferenceWithoutContext();
      astFactory.addASTChild(currentAST, returnAST);
      {
      _loop392:
      do {
        if ((LA(1)==COMMA)) {
          match(COMMA);
          docCommentMaybeUncheckedReferenceWithoutContext();
          astFactory.addASTChild(currentAST, returnAST);
        }
        else {
          break _loop392;
        }
        
      } while (true);
      }
      if ( inputState.guessing==0 ) {
        docCommentSeeBlockWithoutContext_AST = (AST)currentAST.root;
        docCommentSeeBlockWithoutContext_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(CALDOC_SEE_BLOCK_WITHOUT_CONTEXT,"CALDOC_SEE_BLOCK_WITHOUT_CONTEXT")).add(docCommentSeeBlockWithoutContext_AST));
        currentAST.root = docCommentSeeBlockWithoutContext_AST;
        currentAST.child = docCommentSeeBlockWithoutContext_AST!=null &&docCommentSeeBlockWithoutContext_AST.getFirstChild()!=null ?
          docCommentSeeBlockWithoutContext_AST.getFirstChild() : docCommentSeeBlockWithoutContext_AST;
        currentAST.advanceChildToEnd();
      }
      docCommentSeeBlockWithoutContext_AST = (AST)currentAST.root;
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        recover(ex,_tokenSet_120);
      } else {
        throw ex;
      }
    }
    returnAST = docCommentSeeBlockWithoutContext_AST;
  }
  
  public final void docCommentSeeUnknownBlock() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST docCommentSeeUnknownBlock_AST = null;
    Token  unknownContext = null;
    AST unknownContext_AST = null;
    
    try {      // for error handling
      unknownContext = LT(1);
      unknownContext_AST = astFactory.create(unknownContext);
      match(CALDOC_SEE_TAG_UNKNOWN_CONTEXT);
      docCommentSeeUnknownBlockRemainder();
      if ( inputState.guessing==0 ) {
        reportUnrecognizedSeeOrLinkBlockContextInCALDocCommentError((ParseTreeNode)unknownContext_AST);
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        recover(ex,_tokenSet_120);
      } else {
        throw ex;
      }
    }
    returnAST = docCommentSeeUnknownBlock_AST;
  }
  
  public final void docCommentSeeUnknownBlockRemainder() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST docCommentSeeUnknownBlockRemainder_AST = null;
    
    try {      // for error handling
      {
      _loop374:
      do {
        switch ( LA(1)) {
        case CALDOC_SEE_TAG_FUNCTION_CONTEXT:
        {
          match(CALDOC_SEE_TAG_FUNCTION_CONTEXT);
          break;
        }
        case CALDOC_SEE_TAG_MODULE_CONTEXT:
        {
          match(CALDOC_SEE_TAG_MODULE_CONTEXT);
          break;
        }
        case CALDOC_SEE_TAG_DATACONS_CONTEXT:
        {
          match(CALDOC_SEE_TAG_DATACONS_CONTEXT);
          break;
        }
        case CALDOC_SEE_TAG_TYPECONS_CONTEXT:
        {
          match(CALDOC_SEE_TAG_TYPECONS_CONTEXT);
          break;
        }
        case CALDOC_SEE_TAG_TYPECLASS_CONTEXT:
        {
          match(CALDOC_SEE_TAG_TYPECLASS_CONTEXT);
          break;
        }
        case EQUALS:
        {
          match(EQUALS);
          break;
        }
        case DOT:
        {
          match(DOT);
          break;
        }
        case COMMA:
        {
          match(COMMA);
          break;
        }
        case CALDOC_SEE_TAG_QUOTE:
        {
          match(CALDOC_SEE_TAG_QUOTE);
          break;
        }
        case CONS_ID:
        {
          match(CONS_ID);
          break;
        }
        case VAR_ID:
        {
          match(VAR_ID);
          break;
        }
        case CALDOC_TEXT_LINE:
        {
          match(CALDOC_TEXT_LINE);
          break;
        }
        case CALDOC_BLANK_TEXT_LINE:
        {
          match(CALDOC_BLANK_TEXT_LINE);
          break;
        }
        case CALDOC_OPEN_INLINE_TAG:
        {
          match(CALDOC_OPEN_INLINE_TAG);
          break;
        }
        case CALDOC_CLOSE_INLINE_TAG:
        {
          match(CALDOC_CLOSE_INLINE_TAG);
          break;
        }
        case CALDOC_INLINE_SUMMARY_TAG:
        {
          match(CALDOC_INLINE_SUMMARY_TAG);
          break;
        }
        case CALDOC_INLINE_EM_TAG:
        {
          match(CALDOC_INLINE_EM_TAG);
          break;
        }
        case CALDOC_INLINE_STRONG_TAG:
        {
          match(CALDOC_INLINE_STRONG_TAG);
          break;
        }
        case CALDOC_INLINE_SUP_TAG:
        {
          match(CALDOC_INLINE_SUP_TAG);
          break;
        }
        case CALDOC_INLINE_SUB_TAG:
        {
          match(CALDOC_INLINE_SUB_TAG);
          break;
        }
        case CALDOC_INLINE_UNORDERED_LIST_TAG:
        {
          match(CALDOC_INLINE_UNORDERED_LIST_TAG);
          break;
        }
        case CALDOC_INLINE_ORDERED_LIST_TAG:
        {
          match(CALDOC_INLINE_ORDERED_LIST_TAG);
          break;
        }
        case CALDOC_INLINE_ITEM_TAG:
        {
          match(CALDOC_INLINE_ITEM_TAG);
          break;
        }
        case CALDOC_INLINE_CODE_TAG:
        {
          match(CALDOC_INLINE_CODE_TAG);
          break;
        }
        case CALDOC_INLINE_URL_TAG:
        {
          match(CALDOC_INLINE_URL_TAG);
          break;
        }
        case CALDOC_INLINE_LINK_TAG:
        {
          match(CALDOC_INLINE_LINK_TAG);
          break;
        }
        case CALDOC_INLINE_UNKNOWN_TAG:
        {
          match(CALDOC_INLINE_UNKNOWN_TAG);
          break;
        }
        case CALDOC_NEWLINE:
        {
          match(CALDOC_NEWLINE);
          break;
        }
        case CALDOC_NEWLINE_WITH_LEADING_ASTERISK:
        {
          match(CALDOC_NEWLINE_WITH_LEADING_ASTERISK);
          break;
        }
        default:
        {
          break _loop374;
        }
        }
      } while (true);
      }
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        recover(ex,_tokenSet_120);
      } else {
        throw ex;
      }
    }
    returnAST = docCommentSeeUnknownBlockRemainder_AST;
  }
  
  public final void docCommentSeeUnknownBlockIdentifierLikeContext() throws RecognitionException, TokenStreamException {
    
    returnAST = null;
    ASTPair currentAST = new ASTPair();
    AST docCommentSeeUnknownBlockIdentifierLikeContext_AST = null;
    
    try {      // for error handling
      {
      switch ( LA(1)) {
      case VAR_ID:
      {
        AST tmp225_AST = null;
        tmp225_AST = astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp225_AST);
        match(VAR_ID);
        break;
      }
      case CONS_ID:
      {
        AST tmp226_AST = null;
        tmp226_AST = astFactory.create(LT(1));
        astFactory.addASTChild(currentAST, tmp226_AST);
        match(CONS_ID);
        break;
      }
      default:
      {
        throw new NoViableAltException(LT(1), getFilename());
      }
      }
      }
      AST tmp227_AST = null;
      tmp227_AST = astFactory.create(LT(1));
      astFactory.addASTChild(currentAST, tmp227_AST);
      match(EQUALS);
      docCommentSeeUnknownBlockIdentifierLikeContext_AST = (AST)currentAST.root;
    }
    catch (RecognitionException ex) {
      if (inputState.guessing==0) {
        reportError(ex);
        recover(ex,_tokenSet_136);
      } else {
        throw ex;
      }
    }
    returnAST = docCommentSeeUnknownBlockIdentifierLikeContext_AST;
  }
  
  
  public static final String[] _tokenNames = {
    "<0>",
    "EOF",
    "<2>",
    "NULL_TREE_LOOKAHEAD",
    "the start of a CALDoc comment '/**'",
    "the end of a CALDoc comment '*/'",
    "an identifier starting with a capital letter",
    "an identifier starting with a lowercase letter",
    "ORDINAL_FIELD_NAME",
    "'='",
    "','",
    "DOT",
    "CALDOC_NEWLINE",
    "CALDOC_WS",
    "CALDOC_NEWLINE_WITH_LEADING_ASTERISK",
    "CALDOC_NEWLINE_WITH_OPTIONAL_LEADING_ASTERISK_SPEC",
    "CALDOC_NEWLINE_WITH_OPTIONAL_LEADING_ASTERISK",
    "whitespace",
    "CALDOC_SEE_TAG_FUNCTION_CONTEXT",
    "CALDOC_SEE_TAG_MODULE_CONTEXT",
    "CALDOC_SEE_TAG_DATACONS_CONTEXT",
    "CALDOC_SEE_TAG_TYPECONS_CONTEXT",
    "CALDOC_SEE_TAG_TYPECLASS_CONTEXT",
    "CALDOC_SEE_TAG_CONTEXT",
    "CALDOC_SEE_TAG_CONS_ID",
    "CALDOC_SEE_TAG_VAR_ID",
    "'\\\"'",
    "'='",
    "','",
    "'.'",
    "CALDOC_AUTHOR_TAG",
    "CALDOC_DEPRECATED_TAG",
    "CALDOC_RETURN_TAG",
    "CALDOC_VERSION_TAG",
    "CALDOC_ARG_TAG",
    "CALDOC_ARG_TAG_VAR_ID",
    "CALDOC_ARG_TAG_ORDINAL_FIELD_NAME",
    "CALDOC_SEE_TAG",
    "CALDOC_OPEN_INLINE_TAG",
    "CALDOC_CLOSE_INLINE_TAG",
    "CALDOC_INLINE_SUMMARY_TAG",
    "CALDOC_INLINE_EM_TAG",
    "CALDOC_INLINE_STRONG_TAG",
    "CALDOC_INLINE_SUP_TAG",
    "CALDOC_INLINE_SUB_TAG",
    "CALDOC_INLINE_UNORDERED_LIST_TAG",
    "CALDOC_INLINE_ORDERED_LIST_TAG",
    "CALDOC_INLINE_ITEM_TAG",
    "CALDOC_INLINE_CODE_TAG",
    "CALDOC_INLINE_URL_TAG",
    "CALDOC_INLINE_LINK_TAG",
    "CALDOC_INLINE_TAG",
    "CALDOC_INLINE_UNKNOWN_TAG",
    "CALDOC_UNKNOWN_TAG",
    "CALDOC_SEE_TAG_UNKNOWN_CONTEXT",
    "CALDOC_SEE_TAG_UNKNOWN_REFERENCE",
    "CALDOC_REGULAR_TEXT_LINE",
    "CALDOC_BLANK_TEXT_LINE",
    "CALDOC_TEXT_LINE",
    "TOP_LEVEL_FUNCTION_DEFN",
    "FUNCTION_PARAM_LIST",
    "STRICT_PARAM",
    "LAZY_PARAM",
    "LAMBDA_DEFN",
    "APPLICATION",
    "ALT_LIST",
    "ALT",
    "LET_DEFN_LIST",
    "LET_DEFN",
    "LET_PATTERN_MATCH_DECL",
    "TOP_LEVEL_TYPE_DECLARATION",
    "LET_DEFN_TYPE_DECLARATION",
    "TYPE_DECLARATION",
    "FUNCTION_TYPE_CONSTRUCTOR",
    "TYPE_APPLICATION",
    "TUPLE_CONSTRUCTOR",
    "LIST_CONSTRUCTOR",
    "DATA_DECLARATION",
    "TYPE_CONS_PARAM_LIST",
    "DATA_CONSTRUCTOR_DEFN_LIST",
    "DATA_CONSTRUCTOR_DEFN",
    "DATA_CONSTRUCTOR_ARG_LIST",
    "DATA_CONSTRUCTOR_NAMED_ARG",
    "TYPE_CONTEXT_LIST",
    "TYPE_CONTEXT_SINGLETON",
    "TYPE_CONTEXT_NOTHING",
    "CLASS_CONTEXT_LIST",
    "CLASS_CONTEXT_SINGLETON",
    "CLASS_CONTEXT_NOTHING",
    "CLASS_CONTEXT",
    "LACKS_FIELD_CONTEXT",
    "FRIEND_DECLARATION_LIST",
    "IMPORT_DECLARATION_LIST",
    "OUTER_DEFN_LIST",
    "ACCESS_MODIFIER",
    "QUALIFIED_VAR",
    "QUALIFIED_CONS",
    "HIERARCHICAL_MODULE_NAME",
    "HIERARCHICAL_MODULE_NAME_EMPTY_QUALIFIER",
    "COMPILATION_UNIT",
    "MODULE_DEFN",
    "PATTERN_CONSTRUCTOR",
    "UNIT_TYPE_CONSTRUCTOR",
    "LIST_TYPE_CONSTRUCTOR",
    "TUPLE_TYPE_CONSTRUCTOR",
    "INT_PATTERN",
    "CHAR_PATTERN",
    "FOREIGN_FUNCTION_DECLARATION",
    "PRIMITIVE_FUNCTION_DECLARATION",
    "FOREIGN_DATA_DECLARATION",
    "TYPE_CLASS_DEFN",
    "CLASS_METHOD_LIST",
    "CLASS_METHOD",
    "INSTANCE_DEFN",
    "INSTANCE_NAME",
    "INSTANCE_METHOD_LIST",
    "INSTANCE_METHOD",
    "UNPARENTHESIZED_TYPE_CONSTRUCTOR",
    "GENERAL_TYPE_CONSTRUCTOR",
    "PATTERN_VAR_LIST",
    "DATA_CONSTRUCTOR_NAME_LIST",
    "DATA_CONSTRUCTOR_NAME_SINGLETON",
    "MAYBE_MINUS_INT_LIST",
    "CHAR_LIST",
    "RECORD_CONSTRUCTOR",
    "BASE_RECORD",
    "FIELD_MODIFICATION_LIST",
    "FIELD_EXTENSION",
    "FIELD_VALUE_UPDATE",
    "RECORD_TYPE_CONSTRUCTOR",
    "RECORD_VAR",
    "FIELD_TYPE_ASSIGNMENT_LIST",
    "FIELD_TYPE_ASSIGNMENT",
    "SELECT_RECORD_FIELD",
    "SELECT_DATA_CONSTRUCTOR_FIELD",
    "RECORD_PATTERN",
    "BASE_RECORD_PATTERN",
    "FIELD_BINDING_VAR_ASSIGNMENT_LIST",
    "FIELD_BINDING_VAR_ASSIGNMENT",
    "TYPE_SIGNATURE",
    "STRICT_ARG",
    "EXPRESSION_TYPE_SIGNATURE",
    "UNARY_MINUS",
    "OPTIONAL_CALDOC_COMMENT",
    "CALDOC_COMMENT",
    "CALDOC_TEXT",
    "CALDOC_DESCRIPTION_BLOCK",
    "CALDOC_TAGGED_BLOCKS",
    "CALDOC_AUTHOR_BLOCK",
    "CALDOC_DEPRECATED_BLOCK",
    "CALDOC_RETURN_BLOCK",
    "CALDOC_VERSION_BLOCK",
    "CALDOC_ARG_BLOCK",
    "CALDOC_SEE_BLOCK",
    "CALDOC_SEE_FUNCTION_BLOCK",
    "CALDOC_SEE_MODULE_BLOCK",
    "CALDOC_SEE_DATACONS_BLOCK",
    "CALDOC_SEE_TYPECONS_BLOCK",
    "CALDOC_SEE_TYPECLASS_BLOCK",
    "CALDOC_SEE_BLOCK_WITHOUT_CONTEXT",
    "CALDOC_CHECKED_MODULE_NAME",
    "CALDOC_UNCHECKED_MODULE_NAME",
    "CALDOC_CHECKED_QUALIFIED_VAR",
    "CALDOC_UNCHECKED_QUALIFIED_VAR",
    "CALDOC_CHECKED_QUALIFIED_CONS",
    "CALDOC_UNCHECKED_QUALIFIED_CONS",
    "CALDOC_TEXT_PREFORMATTED_BLOCK",
    "CALDOC_TEXT_BLOCK_WITHOUT_INLINE_TAGS",
    "CALDOC_TEXT_LINE_BREAK",
    "CALDOC_TEXT_INLINE_BLOCK",
    "CALDOC_TEXT_URL",
    "CALDOC_TEXT_LINK",
    "CALDOC_TEXT_EMPHASIZED_TEXT",
    "CALDOC_TEXT_STRONGLY_EMPHASIZED_TEXT",
    "CALDOC_TEXT_SUPERSCRIPT_TEXT",
    "CALDOC_TEXT_SUBSCRIPT_TEXT",
    "CALDOC_TEXT_SUMMARY",
    "CALDOC_TEXT_CODE_BLOCK",
    "CALDOC_TEXT_ORDERED_LIST",
    "CALDOC_TEXT_UNORDERED_LIST",
    "CALDOC_TEXT_LIST_ITEM",
    "CALDOC_TEXT_LINK_FUNCTION",
    "CALDOC_TEXT_LINK_MODULE",
    "CALDOC_TEXT_LINK_DATACONS",
    "CALDOC_TEXT_LINK_TYPECONS",
    "CALDOC_TEXT_LINK_TYPECLASS",
    "CALDOC_TEXT_LINK_WITHOUT_CONTEXT",
    "VIRTUAL_LET_NONREC",
    "VIRTUAL_LET_REC",
    "VIRTUAL_DATA_CONSTRUCTOR_CASE",
    "VIRTUAL_RECORD_CASE",
    "VIRTUAL_TUPLE_CASE",
    "VIRTUAL_UNIT_DATA_CONSTRUCTOR",
    "\"module\"",
    "';'",
    "\"import\"",
    "\"using\"",
    "\"function\"",
    "\"typeConstructor\"",
    "\"dataConstructor\"",
    "\"typeClass\"",
    "\"friend\"",
    "\"class\"",
    "'::'",
    "'=>'",
    "'('",
    "')'",
    "'\\'",
    "'->'",
    "'['",
    "']'",
    "'{'",
    "'}'",
    "'|'",
    "\"data\"",
    "\"foreign\"",
    "\"unsafe\"",
    "\"jvm\"",
    "'!'",
    "\"deriving\"",
    "\"where\"",
    "\"default\"",
    "\"instance\"",
    "a string literal",
    "\"primitive\"",
    "\"public\"",
    "\"private\"",
    "\"protected\"",
    "\"let\"",
    "\"in\"",
    "\"if\"",
    "\"then\"",
    "\"else\"",
    "\"case\"",
    "\"of\"",
    "'$'",
    "'||'",
    "'&&'",
    "'<'",
    "'<='",
    "'=='",
    "'!='",
    "'>='",
    "'>'",
    "':'",
    "'++'",
    "'+'",
    "'-'",
    "'*'",
    "'/'",
    "'%'",
    "'#'",
    "'`'",
    "':='",
    "'_'",
    "a character literal",
    "an integer value",
    "FLOAT_LITERAL",
    "whitespace",
    "a comment",
    "a comment",
    "ESC",
    "HEX_DIGIT",
    "EXPONENT"
  };
  
  protected void buildTokenTypeASTClassMap() {
    tokenTypeToASTClassMap=null;
  };
  
  private static final long[] mk_tokenSet_0() {
    long[] data = { 2L, 0L, 0L, 0L, 0L};
    return data;
  }
  public static final BitSet _tokenSet_0 = new BitSet(mk_tokenSet_0());
  private static final long[] mk_tokenSet_1() {
    long[] data = new long[10];
    data[0]=192L;
    data[3]=-9187340695066992640L;
    data[4]=3L;
    return data;
  }
  public static final BitSet _tokenSet_1 = new BitSet(mk_tokenSet_1());
  private static final long[] mk_tokenSet_2() {
    long[] data = new long[8];
    data[0]=1026L;
    data[3]=6047317377028L;
    return data;
  }
  public static final BitSet _tokenSet_2 = new BitSet(mk_tokenSet_2());
  private static final long[] mk_tokenSet_3() {
    long[] data = new long[8];
    data[0]=192L;
    data[3]=663552L;
    return data;
  }
  public static final BitSet _tokenSet_3 = new BitSet(mk_tokenSet_3());
  private static final long[] mk_tokenSet_4() {
    long[] data = new long[8];
    data[0]=1026L;
    data[3]=6047854247940L;
    return data;
  }
  public static final BitSet _tokenSet_4 = new BitSet(mk_tokenSet_4());
  private static final long[] mk_tokenSet_5() {
    long[] data = new long[10];
    data[0]=192L;
    data[3]=-4575657155896925182L;
    data[4]=1L;
    return data;
  }
  public static final BitSet _tokenSet_5 = new BitSet(mk_tokenSet_5());
  private static final long[] mk_tokenSet_6() {
    long[] data = new long[8];
    data[3]=2L;
    return data;
  }
  public static final BitSet _tokenSet_6 = new BitSet(mk_tokenSet_6());
  private static final long[] mk_tokenSet_7() {
    long[] data = new long[8];
    data[0]=146L;
    data[3]=65510835720L;
    return data;
  }
  public static final BitSet _tokenSet_7 = new BitSet(mk_tokenSet_7());
  private static final long[] mk_tokenSet_8() {
    long[] data = new long[8];
    data[0]=146L;
    data[3]=65510835712L;
    return data;
  }
  public static final BitSet _tokenSet_8 = new BitSet(mk_tokenSet_8());
  private static final long[] mk_tokenSet_9() {
    long[] data = new long[8];
    data[0]=146L;
    data[3]=65510835200L;
    return data;
  }
  public static final BitSet _tokenSet_9 = new BitSet(mk_tokenSet_9());
  private static final long[] mk_tokenSet_10() {
    long[] data = new long[8];
    data[0]=144L;
    data[3]=65510835200L;
    return data;
  }
  public static final BitSet _tokenSet_10 = new BitSet(mk_tokenSet_10());
  private static final long[] mk_tokenSet_11() {
    long[] data = new long[8];
    data[0]=144L;
    data[3]=61203283968L;
    return data;
  }
  public static final BitSet _tokenSet_11 = new BitSet(mk_tokenSet_11());
  private static final long[] mk_tokenSet_12() {
    long[] data = new long[8];
    data[0]=146L;
    data[3]=61203283968L;
    return data;
  }
  public static final BitSet _tokenSet_12 = new BitSet(mk_tokenSet_12());
  private static final long[] mk_tokenSet_13() {
    long[] data = new long[8];
    data[0]=128L;
    data[3]=60129542144L;
    return data;
  }
  public static final BitSet _tokenSet_13 = new BitSet(mk_tokenSet_13());
  private static final long[] mk_tokenSet_14() {
    long[] data = new long[8];
    data[0]=640L;
    data[3]=67108864L;
    return data;
  }
  public static final BitSet _tokenSet_14 = new BitSet(mk_tokenSet_14());
  private static final long[] mk_tokenSet_15() {
    long[] data = { 128L, 0L, 0L, 0L, 0L};
    return data;
  }
  public static final BitSet _tokenSet_15 = new BitSet(mk_tokenSet_15());
  private static final long[] mk_tokenSet_16() {
    long[] data = new long[8];
    data[3]=1073741824L;
    return data;
  }
  public static final BitSet _tokenSet_16 = new BitSet(mk_tokenSet_16());
  private static final long[] mk_tokenSet_17() {
    long[] data = { 64L, 0L, 0L, 0L, 0L};
    return data;
  }
  public static final BitSet _tokenSet_17 = new BitSet(mk_tokenSet_17());
  private static final long[] mk_tokenSet_18() {
    long[] data = new long[8];
    data[0]=9007919802616864L;
    data[3]=20L;
    return data;
  }
  public static final BitSet _tokenSet_18 = new BitSet(mk_tokenSet_18());
  private static final long[] mk_tokenSet_19() {
    long[] data = new long[8];
    data[3]=8L;
    return data;
  }
  public static final BitSet _tokenSet_19 = new BitSet(mk_tokenSet_19());
  private static final long[] mk_tokenSet_20() {
    long[] data = new long[8];
    data[3]=20L;
    return data;
  }
  public static final BitSet _tokenSet_20 = new BitSet(mk_tokenSet_20());
  private static final long[] mk_tokenSet_21() {
    long[] data = new long[8];
    data[3]=4L;
    return data;
  }
  public static final BitSet _tokenSet_21 = new BitSet(mk_tokenSet_21());
  private static final long[] mk_tokenSet_22() {
    long[] data = new long[8];
    data[3]=16L;
    return data;
  }
  public static final BitSet _tokenSet_22 = new BitSet(mk_tokenSet_22());
  private static final long[] mk_tokenSet_23() {
    long[] data = new long[8];
    data[3]=480L;
    return data;
  }
  public static final BitSet _tokenSet_23 = new BitSet(mk_tokenSet_23());
  private static final long[] mk_tokenSet_24() {
    long[] data = new long[8];
    data[3]=484L;
    return data;
  }
  public static final BitSet _tokenSet_24 = new BitSet(mk_tokenSet_24());
  private static final long[] mk_tokenSet_25() {
    long[] data = new long[10];
    data[0]=9007919802617826L;
    data[3]=-2305845754901600236L;
    data[4]=3L;
    return data;
  }
  public static final BitSet _tokenSet_25 = new BitSet(mk_tokenSet_25());
  private static final long[] mk_tokenSet_26() {
    long[] data = new long[10];
    data[0]=441353758908112866L;
    data[3]=-2745620760572L;
    data[4]=3L;
    return data;
  }
  public static final BitSet _tokenSet_26 = new BitSet(mk_tokenSet_26());
  private static final long[] mk_tokenSet_27() {
    long[] data = new long[8];
    data[3]=512L;
    return data;
  }
  public static final BitSet _tokenSet_27 = new BitSet(mk_tokenSet_27());
  private static final long[] mk_tokenSet_28() {
    long[] data = new long[8];
    data[0]=64L;
    data[3]=60129542144L;
    return data;
  }
  public static final BitSet _tokenSet_28 = new BitSet(mk_tokenSet_28());
  private static final long[] mk_tokenSet_29() {
    long[] data = new long[8];
    data[3]=60129543168L;
    return data;
  }
  public static final BitSet _tokenSet_29 = new BitSet(mk_tokenSet_29());
  private static final long[] mk_tokenSet_30() {
    long[] data = new long[8];
    data[0]=64L;
    data[3]=9216L;
    return data;
  }
  public static final BitSet _tokenSet_30 = new BitSet(mk_tokenSet_30());
  private static final long[] mk_tokenSet_31() {
    long[] data = new long[8];
    data[3]=4194304L;
    return data;
  }
  public static final BitSet _tokenSet_31 = new BitSet(mk_tokenSet_31());
  private static final long[] mk_tokenSet_32() {
    long[] data = new long[8];
    data[0]=192L;
    data[3]=62277026816L;
    return data;
  }
  public static final BitSet _tokenSet_32 = new BitSet(mk_tokenSet_32());
  private static final long[] mk_tokenSet_33() {
    long[] data = new long[8];
    data[0]=192L;
    data[3]=2147484672L;
    return data;
  }
  public static final BitSet _tokenSet_33 = new BitSet(mk_tokenSet_33());
  private static final long[] mk_tokenSet_34() {
    long[] data = new long[8];
    data[3]=4294967296L;
    return data;
  }
  public static final BitSet _tokenSet_34 = new BitSet(mk_tokenSet_34());
  private static final long[] mk_tokenSet_35() {
    long[] data = new long[8];
    data[3]=8388608L;
    return data;
  }
  public static final BitSet _tokenSet_35 = new BitSet(mk_tokenSet_35());
  private static final long[] mk_tokenSet_36() {
    long[] data = { 144L, 0L, 0L, 0L, 0L};
    return data;
  }
  public static final BitSet _tokenSet_36 = new BitSet(mk_tokenSet_36());
  private static final long[] mk_tokenSet_37() {
    long[] data = new long[10];
    data[0]=210L;
    data[3]=-4575657018457971712L;
    data[4]=1L;
    return data;
  }
  public static final BitSet _tokenSet_37 = new BitSet(mk_tokenSet_37());
  private static final long[] mk_tokenSet_38() {
    long[] data = new long[10];
    data[0]=208L;
    data[3]=-4575657083968806912L;
    data[4]=1L;
    return data;
  }
  public static final BitSet _tokenSet_38 = new BitSet(mk_tokenSet_38());
  private static final long[] mk_tokenSet_39() {
    long[] data = new long[8];
    data[0]=2176L;
    data[3]=32768L;
    return data;
  }
  public static final BitSet _tokenSet_39 = new BitSet(mk_tokenSet_39());
  private static final long[] mk_tokenSet_40() {
    long[] data = new long[8];
    data[0]=192L;
    data[3]=16384L;
    return data;
  }
  public static final BitSet _tokenSet_40 = new BitSet(mk_tokenSet_40());
  private static final long[] mk_tokenSet_41() {
    long[] data = new long[8];
    data[0]=3522L;
    data[3]=6047854977028L;
    return data;
  }
  public static final BitSet _tokenSet_41 = new BitSet(mk_tokenSet_41());
  private static final long[] mk_tokenSet_42() {
    long[] data = { 192L, 0L, 0L, 0L, 0L};
    return data;
  }
  public static final BitSet _tokenSet_42 = new BitSet(mk_tokenSet_42());
  private static final long[] mk_tokenSet_43() {
    long[] data = new long[8];
    data[0]=1024L;
    data[3]=20480L;
    return data;
  }
  public static final BitSet _tokenSet_43 = new BitSet(mk_tokenSet_43());
  private static final long[] mk_tokenSet_44() {
    long[] data = new long[8];
    data[3]=16384L;
    return data;
  }
  public static final BitSet _tokenSet_44 = new BitSet(mk_tokenSet_44());
  private static final long[] mk_tokenSet_45() {
    long[] data = new long[8];
    data[0]=2240L;
    data[3]=663552L;
    return data;
  }
  public static final BitSet _tokenSet_45 = new BitSet(mk_tokenSet_45());
  private static final long[] mk_tokenSet_46() {
    long[] data = new long[8];
    data[0]=64L;
    data[3]=8192L;
    return data;
  }
  public static final BitSet _tokenSet_46 = new BitSet(mk_tokenSet_46());
  private static final long[] mk_tokenSet_47() {
    long[] data = new long[8];
    data[0]=64L;
    data[3]=16384L;
    return data;
  }
  public static final BitSet _tokenSet_47 = new BitSet(mk_tokenSet_47());
  private static final long[] mk_tokenSet_48() {
    long[] data = new long[10];
    data[0]=9007919802617826L;
    data[3]=-2305845754901600252L;
    data[4]=3L;
    return data;
  }
  public static final BitSet _tokenSet_48 = new BitSet(mk_tokenSet_48());
  private static final long[] mk_tokenSet_49() {
    long[] data = { 384L, 0L, 0L, 0L, 0L};
    return data;
  }
  public static final BitSet _tokenSet_49 = new BitSet(mk_tokenSet_49());
  private static final long[] mk_tokenSet_50() {
    long[] data = new long[10];
    data[0]=441353209085189858L;
    data[3]=-4611688765054879740L;
    data[4]=3L;
    return data;
  }
  public static final BitSet _tokenSet_50 = new BitSet(mk_tokenSet_50());
  private static final long[] mk_tokenSet_51() {
    long[] data = new long[8];
    data[0]=1026L;
    data[3]=6047854313476L;
    return data;
  }
  public static final BitSet _tokenSet_51 = new BitSet(mk_tokenSet_51());
  private static final long[] mk_tokenSet_52() {
    long[] data = new long[8];
    data[0]=1474L;
    data[3]=6047989194756L;
    return data;
  }
  public static final BitSet _tokenSet_52 = new BitSet(mk_tokenSet_52());
  private static final long[] mk_tokenSet_53() {
    long[] data = new long[8];
    data[0]=192L;
    data[3]=679936L;
    return data;
  }
  public static final BitSet _tokenSet_53 = new BitSet(mk_tokenSet_53());
  private static final long[] mk_tokenSet_54() {
    long[] data = new long[8];
    data[3]=524288L;
    return data;
  }
  public static final BitSet _tokenSet_54 = new BitSet(mk_tokenSet_54());
  private static final long[] mk_tokenSet_55() {
    long[] data = new long[8];
    data[0]=384L;
    data[3]=1048576L;
    return data;
  }
  public static final BitSet _tokenSet_55 = new BitSet(mk_tokenSet_55());
  private static final long[] mk_tokenSet_56() {
    long[] data = new long[8];
    data[0]=1474L;
    data[3]=6047989196804L;
    return data;
  }
  public static final BitSet _tokenSet_56 = new BitSet(mk_tokenSet_56());
  private static final long[] mk_tokenSet_57() {
    long[] data = new long[8];
    data[3]=1048576L;
    return data;
  }
  public static final BitSet _tokenSet_57 = new BitSet(mk_tokenSet_57());
  private static final long[] mk_tokenSet_58() {
    long[] data = new long[8];
    data[0]=1024L;
    data[3]=1048576L;
    return data;
  }
  public static final BitSet _tokenSet_58 = new BitSet(mk_tokenSet_58());
  private static final long[] mk_tokenSet_59() {
    long[] data = new long[8];
    data[0]=16L;
    data[3]=4194304L;
    return data;
  }
  public static final BitSet _tokenSet_59 = new BitSet(mk_tokenSet_59());
  private static final long[] mk_tokenSet_60() {
    long[] data = new long[8];
    data[0]=192L;
    data[3]=60129542144L;
    return data;
  }
  public static final BitSet _tokenSet_60 = new BitSet(mk_tokenSet_60());
  private static final long[] mk_tokenSet_61() {
    long[] data = new long[8];
    data[3]=134217732L;
    return data;
  }
  public static final BitSet _tokenSet_61 = new BitSet(mk_tokenSet_61());
  private static final long[] mk_tokenSet_62() {
    long[] data = { 512L, 0L, 0L, 0L, 0L};
    return data;
  }
  public static final BitSet _tokenSet_62 = new BitSet(mk_tokenSet_62());
  private static final long[] mk_tokenSet_63() {
    long[] data = new long[8];
    data[0]=80L;
    data[3]=60129542144L;
    return data;
  }
  public static final BitSet _tokenSet_63 = new BitSet(mk_tokenSet_63());
  private static final long[] mk_tokenSet_64() {
    long[] data = new long[8];
    data[3]=134217728L;
    return data;
  }
  public static final BitSet _tokenSet_64 = new BitSet(mk_tokenSet_64());
  private static final long[] mk_tokenSet_65() {
    long[] data = { 640L, 0L, 0L, 0L, 0L};
    return data;
  }
  public static final BitSet _tokenSet_65 = new BitSet(mk_tokenSet_65());
  private static final long[] mk_tokenSet_66() {
    long[] data = new long[8];
    data[3]=136314884L;
    return data;
  }
  public static final BitSet _tokenSet_66 = new BitSet(mk_tokenSet_66());
  private static final long[] mk_tokenSet_67() {
    long[] data = new long[8];
    data[0]=384L;
    data[3]=136314884L;
    return data;
  }
  public static final BitSet _tokenSet_67 = new BitSet(mk_tokenSet_67());
  private static final long[] mk_tokenSet_68() {
    long[] data = new long[8];
    data[0]=192L;
    data[3]=67772416L;
    return data;
  }
  public static final BitSet _tokenSet_68 = new BitSet(mk_tokenSet_68());
  private static final long[] mk_tokenSet_69() {
    long[] data = new long[8];
    data[0]=16L;
    data[3]=60129543168L;
    return data;
  }
  public static final BitSet _tokenSet_69 = new BitSet(mk_tokenSet_69());
  private static final long[] mk_tokenSet_70() {
    long[] data = new long[8];
    data[3]=268435456L;
    return data;
  }
  public static final BitSet _tokenSet_70 = new BitSet(mk_tokenSet_70());
  private static final long[] mk_tokenSet_71() {
    long[] data = new long[8];
    data[0]=144L;
    data[3]=60129542144L;
    return data;
  }
  public static final BitSet _tokenSet_71 = new BitSet(mk_tokenSet_71());
  private static final long[] mk_tokenSet_72() {
    long[] data = new long[8];
    data[0]=144L;
    data[3]=60129542148L;
    return data;
  }
  public static final BitSet _tokenSet_72 = new BitSet(mk_tokenSet_72());
  private static final long[] mk_tokenSet_73() {
    long[] data = new long[8];
    data[3]=2048L;
    return data;
  }
  public static final BitSet _tokenSet_73 = new BitSet(mk_tokenSet_73());
  private static final long[] mk_tokenSet_74() {
    long[] data = new long[10];
    data[0]=9007919802617570L;
    data[3]=-6917531774268577788L;
    data[4]=3L;
    return data;
  }
  public static final BitSet _tokenSet_74 = new BitSet(mk_tokenSet_74());
  private static final long[] mk_tokenSet_75() {
    long[] data = new long[8];
    data[0]=16L;
    data[3]=1073741824L;
    return data;
  }
  public static final BitSet _tokenSet_75 = new BitSet(mk_tokenSet_75());
  private static final long[] mk_tokenSet_76() {
    long[] data = new long[8];
    data[0]=144L;
    data[3]=4L;
    return data;
  }
  public static final BitSet _tokenSet_76 = new BitSet(mk_tokenSet_76());
  private static final long[] mk_tokenSet_77() {
    long[] data = new long[8];
    data[0]=64L;
    data[3]=663552L;
    return data;
  }
  public static final BitSet _tokenSet_77 = new BitSet(mk_tokenSet_77());
  private static final long[] mk_tokenSet_78() {
    long[] data = new long[8];
    data[0]=16L;
    data[3]=8388608L;
    return data;
  }
  public static final BitSet _tokenSet_78 = new BitSet(mk_tokenSet_78());
  private static final long[] mk_tokenSet_79() {
    long[] data = new long[8];
    data[0]=16L;
    data[3]=4294967296L;
    return data;
  }
  public static final BitSet _tokenSet_79 = new BitSet(mk_tokenSet_79());
  private static final long[] mk_tokenSet_80() {
    long[] data = new long[8];
    data[0]=128L;
    data[3]=67108864L;
    return data;
  }
  public static final BitSet _tokenSet_80 = new BitSet(mk_tokenSet_80());
  private static final long[] mk_tokenSet_81() {
    long[] data = new long[8];
    data[0]=640L;
    data[3]=67174400L;
    return data;
  }
  public static final BitSet _tokenSet_81 = new BitSet(mk_tokenSet_81());
  private static final long[] mk_tokenSet_82() {
    long[] data = new long[8];
    data[3]=65536L;
    return data;
  }
  public static final BitSet _tokenSet_82 = new BitSet(mk_tokenSet_82());
  private static final long[] mk_tokenSet_83() {
    long[] data = new long[10];
    data[0]=208L;
    data[3]=-4575657221407760384L;
    data[4]=1L;
    return data;
  }
  public static final BitSet _tokenSet_83 = new BitSet(mk_tokenSet_83());
  private static final long[] mk_tokenSet_84() {
    long[] data = new long[8];
    data[3]=137438953472L;
    return data;
  }
  public static final BitSet _tokenSet_84 = new BitSet(mk_tokenSet_84());
  private static final long[] mk_tokenSet_85() {
    long[] data = new long[10];
    data[0]=192L;
    data[3]=-4575657221407760384L;
    data[4]=1L;
    return data;
  }
  public static final BitSet _tokenSet_85 = new BitSet(mk_tokenSet_85());
  private static final long[] mk_tokenSet_86() {
    long[] data = new long[10];
    data[0]=192L;
    data[3]=-9187343237687664640L;
    data[4]=3L;
    return data;
  }
  public static final BitSet _tokenSet_86 = new BitSet(mk_tokenSet_86());
  private static final long[] mk_tokenSet_87() {
    long[] data = new long[8];
    data[0]=1026L;
    data[3]=6047317379076L;
    return data;
  }
  public static final BitSet _tokenSet_87 = new BitSet(mk_tokenSet_87());
  private static final long[] mk_tokenSet_88() {
    long[] data = new long[8];
    data[0]=1026L;
    data[3]=14843410401284L;
    return data;
  }
  public static final BitSet _tokenSet_88 = new BitSet(mk_tokenSet_88());
  private static final long[] mk_tokenSet_89() {
    long[] data = new long[8];
    data[0]=1026L;
    data[3]=32435596445700L;
    return data;
  }
  public static final BitSet _tokenSet_89 = new BitSet(mk_tokenSet_89());
  private static final long[] mk_tokenSet_90() {
    long[] data = new long[8];
    data[0]=1026L;
    data[3]=67619968534532L;
    return data;
  }
  public static final BitSet _tokenSet_90 = new BitSet(mk_tokenSet_90());
  private static final long[] mk_tokenSet_91() {
    long[] data = new long[8];
    data[0]=1538L;
    data[3]=4500850851727364L;
    return data;
  }
  public static final BitSet _tokenSet_91 = new BitSet(mk_tokenSet_91());
  private static final long[] mk_tokenSet_92() {
    long[] data = new long[8];
    data[0]=1538L;
    data[3]=18011649733838852L;
    return data;
  }
  public static final BitSet _tokenSet_92 = new BitSet(mk_tokenSet_92());
  private static final long[] mk_tokenSet_93() {
    long[] data = new long[8];
    data[0]=1538L;
    data[3]=72054845262284804L;
    return data;
  }
  public static final BitSet _tokenSet_93 = new BitSet(mk_tokenSet_93());
  private static final long[] mk_tokenSet_94() {
    long[] data = new long[8];
    data[0]=1538L;
    data[3]=576458003527780356L;
    return data;
  }
  public static final BitSet _tokenSet_94 = new BitSet(mk_tokenSet_94());
  private static final long[] mk_tokenSet_95() {
    long[] data = new long[10];
    data[0]=192L;
    data[3]=-9223372034706628608L;
    data[4]=3L;
    return data;
  }
  public static final BitSet _tokenSet_95 = new BitSet(mk_tokenSet_95());
  private static final long[] mk_tokenSet_96() {
    long[] data = new long[8];
    data[0]=1538L;
    data[3]=2305840260438050820L;
    return data;
  }
  public static final BitSet _tokenSet_96 = new BitSet(mk_tokenSet_96());
  private static final long[] mk_tokenSet_97() {
    long[] data = new long[8];
    data[3]=1152921504606846976L;
    return data;
  }
  public static final BitSet _tokenSet_97 = new BitSet(mk_tokenSet_97());
  private static final long[] mk_tokenSet_98() {
    long[] data = new long[10];
    data[0]=1730L;
    data[3]=-6917531774268577788L;
    data[4]=3L;
    return data;
  }
  public static final BitSet _tokenSet_98 = new BitSet(mk_tokenSet_98());
  private static final long[] mk_tokenSet_99() {
    long[] data = new long[10];
    data[0]=3778L;
    data[3]=-6917531774268577788L;
    data[4]=3L;
    return data;
  }
  public static final BitSet _tokenSet_99 = new BitSet(mk_tokenSet_99());
  private static final long[] mk_tokenSet_100() {
    long[] data = new long[10];
    data[3]=-9223372034707292160L;
    data[4]=3L;
    return data;
  }
  public static final BitSet _tokenSet_100 = new BitSet(mk_tokenSet_100());
  private static final long[] mk_tokenSet_101() {
    long[] data = new long[10];
    data[0]=192L;
    data[3]=-9187340695066714112L;
    data[4]=3L;
    return data;
  }
  public static final BitSet _tokenSet_101 = new BitSet(mk_tokenSet_101());
  private static final long[] mk_tokenSet_102() {
    long[] data = new long[8];
    data[3]=278528L;
    return data;
  }
  public static final BitSet _tokenSet_102 = new BitSet(mk_tokenSet_102());
  private static final long[] mk_tokenSet_103() {
    long[] data = new long[10];
    data[0]=3024L;
    data[3]=-2305849260467361792L;
    data[4]=3L;
    return data;
  }
  public static final BitSet _tokenSet_103 = new BitSet(mk_tokenSet_103());
  private static final long[] mk_tokenSet_104() {
    long[] data = new long[10];
    data[0]=3778L;
    data[3]=-4611688765054883836L;
    data[4]=3L;
    return data;
  }
  public static final BitSet _tokenSet_104 = new BitSet(mk_tokenSet_104());
  private static final long[] mk_tokenSet_105() {
    long[] data = new long[10];
    data[0]=448L;
    data[3]=-9187340695065944064L;
    data[4]=3L;
    return data;
  }
  public static final BitSet _tokenSet_105 = new BitSet(mk_tokenSet_105());
  private static final long[] mk_tokenSet_106() {
    long[] data = new long[10];
    data[0]=3008L;
    data[3]=-4571153621779202048L;
    data[4]=1L;
    return data;
  }
  public static final BitSet _tokenSet_106 = new BitSet(mk_tokenSet_106());
  private static final long[] mk_tokenSet_107() {
    long[] data = new long[8];
    data[0]=128L;
    data[3]=4611686018427404288L;
    return data;
  }
  public static final BitSet _tokenSet_107 = new BitSet(mk_tokenSet_107());
  private static final long[] mk_tokenSet_108() {
    long[] data = new long[8];
    data[0]=640L;
    data[3]=4611686018427977728L;
    return data;
  }
  public static final BitSet _tokenSet_108 = new BitSet(mk_tokenSet_108());
  private static final long[] mk_tokenSet_109() {
    long[] data = new long[8];
    data[0]=512L;
    data[3]=65536L;
    return data;
  }
  public static final BitSet _tokenSet_109 = new BitSet(mk_tokenSet_109());
  private static final long[] mk_tokenSet_110() {
    long[] data = new long[8];
    data[0]=128L;
    data[3]=4611686018427387904L;
    return data;
  }
  public static final BitSet _tokenSet_110 = new BitSet(mk_tokenSet_110());
  private static final long[] mk_tokenSet_111() {
    long[] data = new long[8];
    data[0]=1664L;
    data[3]=4616189618057986048L;
    return data;
  }
  public static final BitSet _tokenSet_111 = new BitSet(mk_tokenSet_111());
  private static final long[] mk_tokenSet_112() {
    long[] data = new long[8];
    data[3]=8192L;
    return data;
  }
  public static final BitSet _tokenSet_112 = new BitSet(mk_tokenSet_112());
  private static final long[] mk_tokenSet_113() {
    long[] data = new long[10];
    data[3]=36028797018963968L;
    data[4]=1L;
    return data;
  }
  public static final BitSet _tokenSet_113 = new BitSet(mk_tokenSet_113());
  private static final long[] mk_tokenSet_114() {
    long[] data = new long[10];
    data[0]=1218L;
    data[3]=-4575651174090383356L;
    data[4]=1L;
    return data;
  }
  public static final BitSet _tokenSet_114 = new BitSet(mk_tokenSet_114());
  private static final long[] mk_tokenSet_115() {
    long[] data = new long[8];
    data[0]=640L;
    data[3]=4611686018427453440L;
    return data;
  }
  public static final BitSet _tokenSet_115 = new BitSet(mk_tokenSet_115());
  private static final long[] mk_tokenSet_116() {
    long[] data = new long[8];
    data[0]=512L;
    data[3]=2179072L;
    return data;
  }
  public static final BitSet _tokenSet_116 = new BitSet(mk_tokenSet_116());
  private static final long[] mk_tokenSet_117() {
    long[] data = new long[8];
    data[0]=1536L;
    data[3]=1114112L;
    return data;
  }
  public static final BitSet _tokenSet_117 = new BitSet(mk_tokenSet_117());
  private static final long[] mk_tokenSet_118() {
    long[] data = new long[8];
    data[0]=384L;
    data[3]=4611686018428436480L;
    return data;
  }
  public static final BitSet _tokenSet_118 = new BitSet(mk_tokenSet_118());
  private static final long[] mk_tokenSet_119() {
    long[] data = new long[10];
    data[0]=208L;
    data[3]=-4575657155896925182L;
    data[4]=1L;
    return data;
  }
  public static final BitSet _tokenSet_119 = new BitSet(mk_tokenSet_119());
  private static final long[] mk_tokenSet_120() {
    long[] data = { 9007369979691040L, 0L, 0L, 0L, 0L};
    return data;
  }
  public static final BitSet _tokenSet_120 = new BitSet(mk_tokenSet_120());
  private static final long[] mk_tokenSet_121() {
    long[] data = { 32L, 0L, 0L, 0L, 0L};
    return data;
  }
  public static final BitSet _tokenSet_121 = new BitSet(mk_tokenSet_121());
  private static final long[] mk_tokenSet_122() {
    long[] data = { 9007919735504928L, 0L, 0L, 0L, 0L};
    return data;
  }
  public static final BitSet _tokenSet_122 = new BitSet(mk_tokenSet_122());
  private static final long[] mk_tokenSet_123() {
    long[] data = { 441353758840999968L, 0L, 0L, 0L, 0L};
    return data;
  }
  public static final BitSet _tokenSet_123 = new BitSet(mk_tokenSet_123());
  private static final long[] mk_tokenSet_124() {
    long[] data = { 549755813888L, 0L, 0L, 0L, 0L};
    return data;
  }
  public static final BitSet _tokenSet_124 = new BitSet(mk_tokenSet_124());
  private static final long[] mk_tokenSet_125() {
    long[] data = { 432345839105495040L, 0L, 0L, 0L, 0L};
    return data;
  }
  public static final BitSet _tokenSet_125 = new BitSet(mk_tokenSet_125());
  private static final long[] mk_tokenSet_126() {
    long[] data = { 432346388861308928L, 0L, 0L, 0L, 0L};
    return data;
  }
  public static final BitSet _tokenSet_126 = new BitSet(mk_tokenSet_126());
  private static final long[] mk_tokenSet_127() {
    long[] data = { 67109056L, 0L, 0L, 0L, 0L};
    return data;
  }
  public static final BitSet _tokenSet_127 = new BitSet(mk_tokenSet_127());
  private static final long[] mk_tokenSet_128() {
    long[] data = { 549755816128L, 0L, 0L, 0L, 0L};
    return data;
  }
  public static final BitSet _tokenSet_128 = new BitSet(mk_tokenSet_128());
  private static final long[] mk_tokenSet_129() {
    long[] data = { 144115462953783296L, 0L, 0L, 0L, 0L};
    return data;
  }
  public static final BitSet _tokenSet_129 = new BitSet(mk_tokenSet_129());
  private static final long[] mk_tokenSet_130() {
    long[] data = { 144116012709597184L, 0L, 0L, 0L, 0L};
    return data;
  }
  public static final BitSet _tokenSet_130 = new BitSet(mk_tokenSet_130());
  private static final long[] mk_tokenSet_131() {
    long[] data = { 434596814360698560L, 0L, 0L, 0L, 0L};
    return data;
  }
  public static final BitSet _tokenSet_131 = new BitSet(mk_tokenSet_131());
  private static final long[] mk_tokenSet_132() {
    long[] data = { 9007919735505952L, 0L, 0L, 0L, 0L};
    return data;
  }
  public static final BitSet _tokenSet_132 = new BitSet(mk_tokenSet_132());
  private static final long[] mk_tokenSet_133() {
    long[] data = { 9007919735508192L, 0L, 0L, 0L, 0L};
    return data;
  }
  public static final BitSet _tokenSet_133 = new BitSet(mk_tokenSet_133());
  private static final long[] mk_tokenSet_134() {
    long[] data = { 9007919735508064L, 0L, 0L, 0L, 0L};
    return data;
  }
  public static final BitSet _tokenSet_134 = new BitSet(mk_tokenSet_134());
  private static final long[] mk_tokenSet_135() {
    long[] data = { 9007369979694304L, 0L, 0L, 0L, 0L};
    return data;
  }
  public static final BitSet _tokenSet_135 = new BitSet(mk_tokenSet_135());
  private static final long[] mk_tokenSet_136() {
    long[] data = { 448108058845667040L, 0L, 0L, 0L, 0L};
    return data;
  }
  public static final BitSet _tokenSet_136 = new BitSet(mk_tokenSet_136());
  
  }
Source Code of org.openquark.cal.compiler.CALParser

Related Classes of org.openquark.cal.compiler.CALParser
