DartParser.java

// This is a generated file. Not intended for manual editing.
package com.jetbrains.lang.dart;

import com.intellij.lang.PsiBuilder;
import com.intellij.lang.PsiBuilder.Marker;
import static com.jetbrains.lang.dart.DartTokenTypes.*;
import static com.jetbrains.lang.dart.DartGeneratedParserUtilBase.*;
import com.intellij.psi.tree.IElementType;
import com.intellij.lang.ASTNode;
import com.intellij.psi.tree.TokenSet;
import com.intellij.lang.PsiParser;
import com.intellij.lang.LightPsiParser;

@SuppressWarnings({"SimplifiableIfStatement", "UnusedAssignment"})
public class DartParser implements PsiParser, LightPsiParser {

  public ASTNode parse(IElementType t, PsiBuilder b) {
    parseLight(t, b);
    return b.getTreeBuilt();
  }

  public void parseLight(IElementType t, PsiBuilder b) {
    boolean r;
    b = adapt_builder_(t, b, this, EXTENDS_SETS_);
    Marker m = enter_section_(b, 0, _COLLAPSE_, null);
    if (t == ADDITIVE_EXPRESSION) {
      r = additiveExpression(b, 0);
    }
    else if (t == ADDITIVE_OPERATOR) {
      r = additiveOperator(b, 0);
    }
    else if (t == ARGUMENT_LIST) {
      r = argumentList(b, 0);
    }
    else if (t == ARGUMENTS) {
      r = arguments(b, 0);
    }
    else if (t == ARRAY_ACCESS_EXPRESSION) {
      r = arrayAccessExpression(b, 0);
    }
    else if (t == AS_EXPRESSION) {
      r = asExpression(b, 0);
    }
    else if (t == ASSERT_STATEMENT) {
      r = assertStatement(b, 0);
    }
    else if (t == ASSIGN_EXPRESSION) {
      r = assignExpression(b, 0);
    }
    else if (t == ASSIGNMENT_OPERATOR) {
      r = assignmentOperator(b, 0);
    }
    else if (t == AWAIT_EXPRESSION) {
      r = awaitExpression(b, 0);
    }
    else if (t == BITWISE_EXPRESSION) {
      r = bitwiseExpression(b, 0);
    }
    else if (t == BITWISE_OPERATOR) {
      r = bitwiseOperator(b, 0);
    }
    else if (t == BLOCK) {
      r = block(b, 0);
    }
    else if (t == BREAK_STATEMENT) {
      r = breakStatement(b, 0);
    }
    else if (t == CALL_EXPRESSION) {
      r = callExpression(b, 0);
    }
    else if (t == CASCADE_REFERENCE_EXPRESSION) {
      r = cascadeReferenceExpression(b, 0);
    }
    else if (t == CATCH_PART) {
      r = catchPart(b, 0);
    }
    else if (t == CLASS_BODY) {
      r = classBody(b, 0);
    }
    else if (t == CLASS_DEFINITION) {
      r = classDefinition(b, 0);
    }
    else if (t == CLASS_MEMBERS) {
      r = classMembers(b, 0);
    }
    else if (t == COMPARE_EXPRESSION) {
      r = compareExpression(b, 0);
    }
    else if (t == COMPONENT_NAME) {
      r = componentName(b, 0);
    }
    else if (t == CONTINUE_STATEMENT) {
      r = continueStatement(b, 0);
    }
    else if (t == DEFAULT_CASE) {
      r = defaultCase(b, 0);
    }
    else if (t == DEFAULT_FORMAL_NAMED_PARAMETER) {
      r = defaultFormalNamedParameter(b, 0);
    }
    else if (t == DO_WHILE_STATEMENT) {
      r = doWhileStatement(b, 0);
    }
    else if (t == ENUM_CONSTANT_DECLARATION) {
      r = enumConstantDeclaration(b, 0);
    }
    else if (t == ENUM_DEFINITION) {
      r = enumDefinition(b, 0);
    }
    else if (t == EQUALITY_OPERATOR) {
      r = equalityOperator(b, 0);
    }
    else if (t == EXPORT_STATEMENT) {
      r = exportStatement(b, 0);
    }
    else if (t == EXPRESSION) {
      r = expression(b, 0);
    }
    else if (t == EXPRESSION_LIST) {
      r = expressionList(b, 0);
    }
    else if (t == FACTORY_CONSTRUCTOR_DECLARATION) {
      r = factoryConstructorDeclaration(b, 0);
    }
    else if (t == FIELD_FORMAL_PARAMETER) {
      r = fieldFormalParameter(b, 0);
    }
    else if (t == FIELD_INITIALIZER) {
      r = fieldInitializer(b, 0);
    }
    else if (t == FINALLY_PART) {
      r = finallyPart(b, 0);
    }
    else if (t == FOR_IN_PART) {
      r = forInPart(b, 0);
    }
    else if (t == FOR_LOOP_PARTS) {
      r = forLoopParts(b, 0);
    }
    else if (t == FOR_LOOP_PARTS_IN_BRACES) {
      r = forLoopPartsInBraces(b, 0);
    }
    else if (t == FOR_STATEMENT) {
      r = forStatement(b, 0);
    }
    else if (t == FORMAL_PARAMETER_LIST) {
      r = formalParameterList(b, 0);
    }
    else if (t == FUNCTION_BODY) {
      r = functionBody(b, 0);
    }
    else if (t == FUNCTION_DECLARATION_WITH_BODY) {
      r = functionDeclarationWithBody(b, 0);
    }
    else if (t == FUNCTION_DECLARATION_WITH_BODY_OR_NATIVE) {
      r = functionDeclarationWithBodyOrNative(b, 0);
    }
    else if (t == FUNCTION_EXPRESSION) {
      r = functionExpression(b, 0);
    }
    else if (t == FUNCTION_EXPRESSION_BODY) {
      r = functionExpressionBody(b, 0);
    }
    else if (t == FUNCTION_FORMAL_PARAMETER) {
      r = functionFormalParameter(b, 0);
    }
    else if (t == FUNCTION_TYPE_ALIAS) {
      r = functionTypeAlias(b, 0);
    }
    else if (t == GETTER_DECLARATION) {
      r = getterDeclaration(b, 0);
    }
    else if (t == HIDE_COMBINATOR) {
      r = hideCombinator(b, 0);
    }
    else if (t == ID) {
      r = id(b, 0);
    }
    else if (t == IF_NULL_EXPRESSION) {
      r = ifNullExpression(b, 0);
    }
    else if (t == IF_STATEMENT) {
      r = ifStatement(b, 0);
    }
    else if (t == IMPORT_STATEMENT) {
      r = importStatement(b, 0);
    }
    else if (t == INCOMPLETE_DECLARATION) {
      r = incompleteDeclaration(b, 0);
    }
    else if (t == INITIALIZERS) {
      r = initializers(b, 0);
    }
    else if (t == INTERFACES) {
      r = interfaces(b, 0);
    }
    else if (t == IS_EXPRESSION) {
      r = isExpression(b, 0);
    }
    else if (t == LABEL) {
      r = label(b, 0);
    }
    else if (t == LIBRARY_COMPONENT_REFERENCE_EXPRESSION) {
      r = libraryComponentReferenceExpression(b, 0);
    }
    else if (t == LIBRARY_ID) {
      r = libraryId(b, 0);
    }
    else if (t == LIBRARY_NAME_ELEMENT) {
      r = libraryNameElement(b, 0);
    }
    else if (t == LIBRARY_REFERENCE_LIST) {
      r = libraryReferenceList(b, 0);
    }
    else if (t == LIBRARY_STATEMENT) {
      r = libraryStatement(b, 0);
    }
    else if (t == LIST_LITERAL_EXPRESSION) {
      r = listLiteralExpression(b, 0);
    }
    else if (t == LITERAL_EXPRESSION) {
      r = literalExpression(b, 0);
    }
    else if (t == LOGIC_AND_EXPRESSION) {
      r = logicAndExpression(b, 0);
    }
    else if (t == LOGIC_OR_EXPRESSION) {
      r = logicOrExpression(b, 0);
    }
    else if (t == LONG_TEMPLATE_ENTRY) {
      r = longTemplateEntry(b, 0);
    }
    else if (t == MAP_LITERAL_ENTRY) {
      r = mapLiteralEntry(b, 0);
    }
    else if (t == MAP_LITERAL_EXPRESSION) {
      r = mapLiteralExpression(b, 0);
    }
    else if (t == METADATA) {
      r = metadata(b, 0);
    }
    else if (t == METHOD_DECLARATION) {
      r = methodDeclaration(b, 0);
    }
    else if (t == MIXIN_APPLICATION) {
      r = mixinApplication(b, 0);
    }
    else if (t == MIXINS) {
      r = mixins(b, 0);
    }
    else if (t == MULTIPLICATIVE_EXPRESSION) {
      r = multiplicativeExpression(b, 0);
    }
    else if (t == MULTIPLICATIVE_OPERATOR) {
      r = multiplicativeOperator(b, 0);
    }
    else if (t == NAMED_ARGUMENT) {
      r = namedArgument(b, 0);
    }
    else if (t == NAMED_CONSTRUCTOR_DECLARATION) {
      r = namedConstructorDeclaration(b, 0);
    }
    else if (t == NEW_EXPRESSION) {
      r = newExpression(b, 0);
    }
    else if (t == NORMAL_FORMAL_PARAMETER) {
      r = normalFormalParameter(b, 0);
    }
    else if (t == NORMAL_PARAMETER_TYPE) {
      r = normalParameterType(b, 0);
    }
    else if (t == ON_PART) {
      r = onPart(b, 0);
    }
    else if (t == OPTIONAL_FORMAL_PARAMETERS) {
      r = optionalFormalParameters(b, 0);
    }
    else if (t == OPTIONAL_PARAMETER_TYPES) {
      r = optionalParameterTypes(b, 0);
    }
    else if (t == PARAMETER_NAME_REFERENCE_EXPRESSION) {
      r = parameterNameReferenceExpression(b, 0);
    }
    else if (t == PARAMETER_TYPE_LIST) {
      r = parameterTypeList(b, 0);
    }
    else if (t == PARENTHESIZED_EXPRESSION) {
      r = parenthesizedExpression(b, 0);
    }
    else if (t == PART_OF_STATEMENT) {
      r = partOfStatement(b, 0);
    }
    else if (t == PART_STATEMENT) {
      r = partStatement(b, 0);
    }
    else if (t == PREFIX_EXPRESSION) {
      r = prefixExpression(b, 0);
    }
    else if (t == PREFIX_OPERATOR) {
      r = prefixOperator(b, 0);
    }
    else if (t == REDIRECTION) {
      r = redirection(b, 0);
    }
    else if (t == REFERENCE_EXPRESSION) {
      r = referenceExpression(b, 0);
    }
    else if (t == RELATIONAL_OPERATOR) {
      r = relationalOperator(b, 0);
    }
    else if (t == RETHROW_STATEMENT) {
      r = rethrowStatement(b, 0);
    }
    else if (t == RETURN_STATEMENT) {
      r = returnStatement(b, 0);
    }
    else if (t == RETURN_TYPE) {
      r = returnType(b, 0);
    }
    else if (t == SETTER_DECLARATION) {
      r = setterDeclaration(b, 0);
    }
    else if (t == SHIFT_EXPRESSION) {
      r = shiftExpression(b, 0);
    }
    else if (t == SHIFT_OPERATOR) {
      r = shiftOperator(b, 0);
    }
    else if (t == SHORT_TEMPLATE_ENTRY) {
      r = shortTemplateEntry(b, 0);
    }
    else if (t == SHOW_COMBINATOR) {
      r = showCombinator(b, 0);
    }
    else if (t == SIMPLE_FORMAL_PARAMETER) {
      r = simpleFormalParameter(b, 0);
    }
    else if (t == SIMPLE_TYPE) {
      r = simpleType(b, 0);
    }
    else if (t == STATEMENTS) {
      r = statements(b, 0);
    }
    else if (t == STRING_LITERAL_EXPRESSION) {
      r = stringLiteralExpression(b, 0);
    }
    else if (t == SUFFIX_EXPRESSION) {
      r = suffixExpression(b, 0);
    }
    else if (t == SUPER_CALL_OR_FIELD_INITIALIZER) {
      r = superCallOrFieldInitializer(b, 0);
    }
    else if (t == SUPER_EXPRESSION) {
      r = superExpression(b, 0);
    }
    else if (t == SUPERCLASS) {
      r = superclass(b, 0);
    }
    else if (t == SWITCH_CASE) {
      r = switchCase(b, 0);
    }
    else if (t == SWITCH_STATEMENT) {
      r = switchStatement(b, 0);
    }
    else if (t == SYMBOL_LITERAL_EXPRESSION) {
      r = symbolLiteralExpression(b, 0);
    }
    else if (t == TERNARY_EXPRESSION) {
      r = ternaryExpression(b, 0);
    }
    else if (t == THIS_EXPRESSION) {
      r = thisExpression(b, 0);
    }
    else if (t == THROW_EXPRESSION) {
      r = throwExpression(b, 0);
    }
    else if (t == TRY_STATEMENT) {
      r = tryStatement(b, 0);
    }
    else if (t == TYPE) {
      r = type(b, 0);
    }
    else if (t == TYPE_ARGUMENTS) {
      r = typeArguments(b, 0);
    }
    else if (t == TYPE_LIST) {
      r = typeList(b, 0);
    }
    else if (t == TYPE_PARAMETER) {
      r = typeParameter(b, 0);
    }
    else if (t == TYPE_PARAMETERS) {
      r = typeParameters(b, 0);
    }
    else if (t == TYPED_FUNCTION_TYPE) {
      r = typedFunctionType(b, 0);
    }
    else if (t == UNTYPED_FUNCTION_TYPE) {
      r = untypedFunctionType(b, 0);
    }
    else if (t == URI_ELEMENT) {
      r = uriElement(b, 0);
    }
    else if (t == USER_DEFINABLE_OPERATOR) {
      r = userDefinableOperator(b, 0);
    }
    else if (t == VALUE_EXPRESSION) {
      r = valueExpression(b, 0);
    }
    else if (t == VAR_ACCESS_DECLARATION) {
      r = varAccessDeclaration(b, 0);
    }
    else if (t == VAR_DECLARATION_LIST) {
      r = varDeclarationList(b, 0);
    }
    else if (t == VAR_DECLARATION_LIST_PART) {
      r = varDeclarationListPart(b, 0);
    }
    else if (t == VAR_INIT) {
      r = varInit(b, 0);
    }
    else if (t == VOID_TYPE_FUNCTION_TYPE) {
      r = voidTypeFunctionType(b, 0);
    }
    else if (t == WHILE_STATEMENT) {
      r = whileStatement(b, 0);
    }
    else if (t == YIELD_EACH_STATEMENT) {
      r = yieldEachStatement(b, 0);
    }
    else if (t == YIELD_STATEMENT) {
      r = yieldStatement(b, 0);
    }
    else {
      r = parse_root_(t, b, 0);
    }
    exit_section_(b, 0, m, t, r, true, TRUE_CONDITION);
  }

  protected boolean parse_root_(IElementType t, PsiBuilder b, int l) {
    return dartUnit(b, l + 1);
  }

  public static final TokenSet[] EXTENDS_SETS_ = new TokenSet[] {
    create_token_set_(ADDITIVE_EXPRESSION, ARRAY_ACCESS_EXPRESSION, ASSIGN_EXPRESSION, AS_EXPRESSION,
      AWAIT_EXPRESSION, BITWISE_EXPRESSION, CALL_EXPRESSION, CASCADE_REFERENCE_EXPRESSION,
      COMPARE_EXPRESSION, EXPRESSION, FUNCTION_EXPRESSION, IF_NULL_EXPRESSION,
      IS_EXPRESSION, LIBRARY_COMPONENT_REFERENCE_EXPRESSION, LIST_LITERAL_EXPRESSION, LITERAL_EXPRESSION,
      LOGIC_AND_EXPRESSION, LOGIC_OR_EXPRESSION, MAP_LITERAL_EXPRESSION, MULTIPLICATIVE_EXPRESSION,
      NEW_EXPRESSION, PARAMETER_NAME_REFERENCE_EXPRESSION, PARENTHESIZED_EXPRESSION, PREFIX_EXPRESSION,
      REFERENCE_EXPRESSION, SHIFT_EXPRESSION, STRING_LITERAL_EXPRESSION, SUFFIX_EXPRESSION,
      SUPER_EXPRESSION, SYMBOL_LITERAL_EXPRESSION, TERNARY_EXPRESSION, THIS_EXPRESSION,
      THROW_EXPRESSION, VALUE_EXPRESSION),
  };

  /* ********************************************************** */
  // additiveOperator multiplicativeExpressionWrapper
  public static boolean additiveExpression(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "additiveExpression")) return false;
    if (!nextTokenIs(b, "<additive expression>", PLUS, MINUS)) return false;
    boolean r;
    Marker m = enter_section_(b, l, _LEFT_, ADDITIVE_EXPRESSION, "<additive expression>");
    r = additiveOperator(b, l + 1);
    r = r && multiplicativeExpressionWrapper(b, l + 1);
    exit_section_(b, l, m, r, false, null);
    return r;
  }

  /* ********************************************************** */
  // multiplicativeExpressionWrapper additiveExpression*
  static boolean additiveExpressionWrapper(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "additiveExpressionWrapper")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = multiplicativeExpressionWrapper(b, l + 1);
    r = r && additiveExpressionWrapper_1(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  // additiveExpression*
  private static boolean additiveExpressionWrapper_1(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "additiveExpressionWrapper_1")) return false;
    int c = current_position_(b);
    while (true) {
      if (!additiveExpression(b, l + 1)) break;
      if (!empty_element_parsed_guard_(b, "additiveExpressionWrapper_1", c)) break;
      c = current_position_(b);
    }
    return true;
  }

  /* ********************************************************** */
  // '+' | '-'
  public static boolean additiveOperator(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "additiveOperator")) return false;
    if (!nextTokenIs(b, "<additive operator>", PLUS, MINUS)) return false;
    boolean r;
    Marker m = enter_section_(b, l, _NONE_, ADDITIVE_OPERATOR, "<additive operator>");
    r = consumeToken(b, PLUS);
    if (!r) r = consumeToken(b, MINUS);
    exit_section_(b, l, m, r, false, null);
    return r;
  }

  /* ********************************************************** */
  // argumentListPart (',' argumentListPart)* ','?
  public static boolean argumentList(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "argumentList")) return false;
    boolean r;
    Marker m = enter_section_(b, l, _NONE_, ARGUMENT_LIST, "<argument list>");
    r = argumentListPart(b, l + 1);
    r = r && argumentList_1(b, l + 1);
    r = r && argumentList_2(b, l + 1);
    exit_section_(b, l, m, r, false, argument_list_recover_parser_);
    return r;
  }

  // (',' argumentListPart)*
  private static boolean argumentList_1(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "argumentList_1")) return false;
    int c = current_position_(b);
    while (true) {
      if (!argumentList_1_0(b, l + 1)) break;
      if (!empty_element_parsed_guard_(b, "argumentList_1", c)) break;
      c = current_position_(b);
    }
    return true;
  }

  // ',' argumentListPart
  private static boolean argumentList_1_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "argumentList_1_0")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = consumeToken(b, COMMA);
    r = r && argumentListPart(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  // ','?
  private static boolean argumentList_2(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "argumentList_2")) return false;
    consumeToken(b, COMMA);
    return true;
  }

  /* ********************************************************** */
  // namedArgument | expression
  static boolean argumentListPart(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "argumentListPart")) return false;
    boolean r;
    Marker m = enter_section_(b, l, _NONE_);
    r = namedArgument(b, l + 1);
    if (!r) r = expression(b, l + 1);
    exit_section_(b, l, m, r, false, argument_list_part_recover_parser_);
    return r;
  }

  /* ********************************************************** */
  // !(')' | ',')
  static boolean argument_list_part_recover(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "argument_list_part_recover")) return false;
    boolean r;
    Marker m = enter_section_(b, l, _NOT_);
    r = !argument_list_part_recover_0(b, l + 1);
    exit_section_(b, l, m, r, false, null);
    return r;
  }

  // ')' | ','
  private static boolean argument_list_part_recover_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "argument_list_part_recover_0")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = consumeToken(b, RPAREN);
    if (!r) r = consumeToken(b, COMMA);
    exit_section_(b, m, null, r);
    return r;
  }

  /* ********************************************************** */
  // !(')')
  static boolean argument_list_recover(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "argument_list_recover")) return false;
    boolean r;
    Marker m = enter_section_(b, l, _NOT_);
    r = !consumeToken(b, RPAREN);
    exit_section_(b, l, m, r, false, null);
    return r;
  }

  /* ********************************************************** */
  // '(' argumentList? ')'
  public static boolean arguments(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "arguments")) return false;
    if (!nextTokenIs(b, LPAREN)) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = consumeToken(b, LPAREN);
    r = r && arguments_1(b, l + 1);
    r = r && consumeToken(b, RPAREN);
    exit_section_(b, m, ARGUMENTS, r);
    return r;
  }

  // argumentList?
  private static boolean arguments_1(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "arguments_1")) return false;
    argumentList(b, l + 1);
    return true;
  }

  /* ********************************************************** */
  // '[' expression? ']'
  static boolean arrayAccess(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "arrayAccess")) return false;
    if (!nextTokenIs(b, LBRACKET)) return false;
    boolean r, p;
    Marker m = enter_section_(b, l, _NONE_);
    r = consumeToken(b, LBRACKET);
    p = r; // pin = 1
    r = r && report_error_(b, arrayAccess_1(b, l + 1));
    r = p && consumeToken(b, RBRACKET) && r;
    exit_section_(b, l, m, r, p, null);
    return r || p;
  }

  // expression?
  private static boolean arrayAccess_1(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "arrayAccess_1")) return false;
    expression(b, l + 1);
    return true;
  }

  /* ********************************************************** */
  // arrayAccess
  public static boolean arrayAccessExpression(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "arrayAccessExpression")) return false;
    if (!nextTokenIs(b, LBRACKET)) return false;
    boolean r;
    Marker m = enter_section_(b, l, _LEFT_, ARRAY_ACCESS_EXPRESSION, null);
    r = arrayAccess(b, l + 1);
    exit_section_(b, l, m, r, false, null);
    return r;
  }

  /* ********************************************************** */
  // ('async' '*'? | 'sync' '*'?)? '=>' expression
  static boolean arrowBody(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "arrowBody")) return false;
    if (!nextTokenIs(b, "", EXPRESSION_BODY_DEF, ASYNC, SYNC)) return false;
    boolean r, p;
    Marker m = enter_section_(b, l, _NONE_);
    r = arrowBody_0(b, l + 1);
    r = r && consumeToken(b, EXPRESSION_BODY_DEF);
    p = r; // pin = 2
    r = r && expression(b, l + 1);
    exit_section_(b, l, m, r, p, null);
    return r || p;
  }

  // ('async' '*'? | 'sync' '*'?)?
  private static boolean arrowBody_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "arrowBody_0")) return false;
    arrowBody_0_0(b, l + 1);
    return true;
  }

  // 'async' '*'? | 'sync' '*'?
  private static boolean arrowBody_0_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "arrowBody_0_0")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = arrowBody_0_0_0(b, l + 1);
    if (!r) r = arrowBody_0_0_1(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  // 'async' '*'?
  private static boolean arrowBody_0_0_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "arrowBody_0_0_0")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = consumeToken(b, ASYNC);
    r = r && arrowBody_0_0_0_1(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  // '*'?
  private static boolean arrowBody_0_0_0_1(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "arrowBody_0_0_0_1")) return false;
    consumeToken(b, MUL);
    return true;
  }

  // 'sync' '*'?
  private static boolean arrowBody_0_0_1(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "arrowBody_0_0_1")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = consumeToken(b, SYNC);
    r = r && arrowBody_0_0_1_1(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  // '*'?
  private static boolean arrowBody_0_0_1_1(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "arrowBody_0_0_1_1")) return false;
    consumeToken(b, MUL);
    return true;
  }

  /* ********************************************************** */
  // <<arrowBodyWrapper>> ';'
  static boolean arrowBodyWithSemi(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "arrowBodyWithSemi")) return false;
    boolean r, p;
    Marker m = enter_section_(b, l, _NONE_);
    r = arrowBodyWrapper(b, l + 1);
    p = r; // pin = 1
    r = r && consumeToken(b, SEMICOLON);
    exit_section_(b, l, m, r, p, null);
    return r || p;
  }

  /* ********************************************************** */
  // 'as' type
  public static boolean asExpression(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "asExpression")) return false;
    if (!nextTokenIs(b, AS)) return false;
    boolean r;
    Marker m = enter_section_(b, l, _LEFT_, AS_EXPRESSION, null);
    r = consumeToken(b, AS);
    r = r && type(b, l + 1);
    exit_section_(b, l, m, r, false, null);
    return r;
  }

  /* ********************************************************** */
  // 'assert' '(' expressionWithRecoverUntilParenOrComma (',' stringLiteralExpression)? ')'
  public static boolean assertStatement(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "assertStatement")) return false;
    if (!nextTokenIs(b, ASSERT)) return false;
    boolean r, p;
    Marker m = enter_section_(b, l, _NONE_, ASSERT_STATEMENT, null);
    r = consumeTokens(b, 1, ASSERT, LPAREN);
    p = r; // pin = 1
    r = r && report_error_(b, expressionWithRecoverUntilParenOrComma(b, l + 1));
    r = p && report_error_(b, assertStatement_3(b, l + 1)) && r;
    r = p && consumeToken(b, RPAREN) && r;
    exit_section_(b, l, m, r, p, null);
    return r || p;
  }

  // (',' stringLiteralExpression)?
  private static boolean assertStatement_3(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "assertStatement_3")) return false;
    assertStatement_3_0(b, l + 1);
    return true;
  }

  // ',' stringLiteralExpression
  private static boolean assertStatement_3_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "assertStatement_3_0")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = consumeToken(b, COMMA);
    r = r && stringLiteralExpression(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  /* ********************************************************** */
  // assertStatement ';'
  static boolean assertStatementWithSemicolon(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "assertStatementWithSemicolon")) return false;
    if (!nextTokenIs(b, ASSERT)) return false;
    boolean r, p;
    Marker m = enter_section_(b, l, _NONE_);
    r = assertStatement(b, l + 1);
    p = r; // pin = 1
    r = r && consumeToken(b, SEMICOLON);
    exit_section_(b, l, m, r, p, null);
    return r || p;
  }

  /* ********************************************************** */
  // assignmentOperator ternaryExpressionWrapper
  public static boolean assignExpression(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "assignExpression")) return false;
    boolean r, p;
    Marker m = enter_section_(b, l, _LEFT_, ASSIGN_EXPRESSION, "<assign expression>");
    r = assignmentOperator(b, l + 1);
    p = r; // pin = 1
    r = r && ternaryExpressionWrapper(b, l + 1);
    exit_section_(b, l, m, r, p, null);
    return r || p;
  }

  /* ********************************************************** */
  // ternaryExpressionWrapper assignExpression*
  static boolean assignExpressionWrapper(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "assignExpressionWrapper")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = ternaryExpressionWrapper(b, l + 1);
    r = r && assignExpressionWrapper_1(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  // assignExpression*
  private static boolean assignExpressionWrapper_1(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "assignExpressionWrapper_1")) return false;
    int c = current_position_(b);
    while (true) {
      if (!assignExpression(b, l + 1)) break;
      if (!empty_element_parsed_guard_(b, "assignExpressionWrapper_1", c)) break;
      c = current_position_(b);
    }
    return true;
  }

  /* ********************************************************** */
  // '=' | '*=' | '/=' | '~/=' | '%=' | '+=' | '-=' | '<<=' | <<gtGtEq>> | '&=' | '&&=' | '^=' | '|=' | '||=' | '??='
  public static boolean assignmentOperator(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "assignmentOperator")) return false;
    boolean r;
    Marker m = enter_section_(b, l, _NONE_, ASSIGNMENT_OPERATOR, "<assignment operator>");
    r = consumeToken(b, EQ);
    if (!r) r = consumeToken(b, MUL_EQ);
    if (!r) r = consumeToken(b, DIV_EQ);
    if (!r) r = consumeToken(b, INT_DIV_EQ);
    if (!r) r = consumeToken(b, REM_EQ);
    if (!r) r = consumeToken(b, PLUS_EQ);
    if (!r) r = consumeToken(b, MINUS_EQ);
    if (!r) r = consumeToken(b, LT_LT_EQ);
    if (!r) r = gtGtEq(b, l + 1);
    if (!r) r = consumeToken(b, AND_EQ);
    if (!r) r = consumeToken(b, AND_AND_EQ);
    if (!r) r = consumeToken(b, XOR_EQ);
    if (!r) r = consumeToken(b, OR_EQ);
    if (!r) r = consumeToken(b, OR_OR_EQ);
    if (!r) r = consumeToken(b, QUEST_QUEST_EQ);
    exit_section_(b, l, m, r, false, null);
    return r;
  }

  /* ********************************************************** */
  // <<isInsideSyncOrAsyncFunction>> 'await' prefixExpression
  public static boolean awaitExpression(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "awaitExpression")) return false;
    boolean r;
    Marker m = enter_section_(b, l, _NONE_, AWAIT_EXPRESSION, "<await expression>");
    r = isInsideSyncOrAsyncFunction(b, l + 1);
    r = r && consumeToken(b, AWAIT);
    r = r && prefixExpression(b, l + 1);
    exit_section_(b, l, m, r, false, null);
    return r;
  }

  /* ********************************************************** */
  // multiplicativeOperator |
  //                            additiveOperator |
  //                            shiftOperator|
  //                            relationalOperator|
  //                            '==' |
  //                            bitwiseOperator
  static boolean binaryOperator(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "binaryOperator")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = multiplicativeOperator(b, l + 1);
    if (!r) r = additiveOperator(b, l + 1);
    if (!r) r = shiftOperator(b, l + 1);
    if (!r) r = relationalOperator(b, l + 1);
    if (!r) r = consumeToken(b, EQ_EQ);
    if (!r) r = bitwiseOperator(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  /* ********************************************************** */
  // bitwiseOperator shiftExpressionWrapper
  public static boolean bitwiseExpression(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "bitwiseExpression")) return false;
    if (!nextTokenIs(b, "<bitwise expression>", AND, XOR, OR)) return false;
    boolean r;
    Marker m = enter_section_(b, l, _LEFT_, BITWISE_EXPRESSION, "<bitwise expression>");
    r = bitwiseOperator(b, l + 1);
    r = r && shiftExpressionWrapper(b, l + 1);
    exit_section_(b, l, m, r, false, null);
    return r;
  }

  /* ********************************************************** */
  // shiftExpressionWrapper bitwiseExpression*
  static boolean bitwiseExpressionWrapper(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "bitwiseExpressionWrapper")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = shiftExpressionWrapper(b, l + 1);
    r = r && bitwiseExpressionWrapper_1(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  // bitwiseExpression*
  private static boolean bitwiseExpressionWrapper_1(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "bitwiseExpressionWrapper_1")) return false;
    int c = current_position_(b);
    while (true) {
      if (!bitwiseExpression(b, l + 1)) break;
      if (!empty_element_parsed_guard_(b, "bitwiseExpressionWrapper_1", c)) break;
      c = current_position_(b);
    }
    return true;
  }

  /* ********************************************************** */
  // '&' | '^' | '|'
  public static boolean bitwiseOperator(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "bitwiseOperator")) return false;
    if (!nextTokenIs(b, "<bitwise operator>", AND, XOR, OR)) return false;
    boolean r;
    Marker m = enter_section_(b, l, _NONE_, BITWISE_OPERATOR, "<bitwise operator>");
    r = consumeToken(b, AND);
    if (!r) r = consumeToken(b, XOR);
    if (!r) r = consumeToken(b, OR);
    exit_section_(b, l, m, r, false, null);
    return r;
  }

  /* ********************************************************** */
  // '{' statements '}'
  public static boolean block(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "block")) return false;
    if (!nextTokenIs(b, LBRACE)) return false;
    boolean r, p;
    Marker m = enter_section_(b, l, _NONE_, BLOCK, null);
    r = consumeToken(b, LBRACE);
    p = r; // pin = 1
    r = r && report_error_(b, statements(b, l + 1));
    r = p && consumeToken(b, RBRACE) && r;
    exit_section_(b, l, m, r, p, null);
    return r || p;
  }

  /* ********************************************************** */
  // ('async' '*'? | 'sync' '*'?)? lazyParseableBlock
  static boolean blockBody(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "blockBody")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = blockBody_0(b, l + 1);
    r = r && lazyParseableBlock(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  // ('async' '*'? | 'sync' '*'?)?
  private static boolean blockBody_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "blockBody_0")) return false;
    blockBody_0_0(b, l + 1);
    return true;
  }

  // 'async' '*'? | 'sync' '*'?
  private static boolean blockBody_0_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "blockBody_0_0")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = blockBody_0_0_0(b, l + 1);
    if (!r) r = blockBody_0_0_1(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  // 'async' '*'?
  private static boolean blockBody_0_0_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "blockBody_0_0_0")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = consumeToken(b, ASYNC);
    r = r && blockBody_0_0_0_1(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  // '*'?
  private static boolean blockBody_0_0_0_1(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "blockBody_0_0_0_1")) return false;
    consumeToken(b, MUL);
    return true;
  }

  // 'sync' '*'?
  private static boolean blockBody_0_0_1(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "blockBody_0_0_1")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = consumeToken(b, SYNC);
    r = r && blockBody_0_0_1_1(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  // '*'?
  private static boolean blockBody_0_0_1_1(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "blockBody_0_0_1_1")) return false;
    consumeToken(b, MUL);
    return true;
  }

  /* ********************************************************** */
  // 'break' referenceExpression? ';'
  public static boolean breakStatement(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "breakStatement")) return false;
    if (!nextTokenIs(b, BREAK)) return false;
    boolean r, p;
    Marker m = enter_section_(b, l, _NONE_, BREAK_STATEMENT, null);
    r = consumeToken(b, BREAK);
    p = r; // pin = 1
    r = r && report_error_(b, breakStatement_1(b, l + 1));
    r = p && consumeToken(b, SEMICOLON) && r;
    exit_section_(b, l, m, r, p, null);
    return r || p;
  }

  // referenceExpression?
  private static boolean breakStatement_1(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "breakStatement_1")) return false;
    referenceExpression(b, l + 1);
    return true;
  }

  /* ********************************************************** */
  // typeArguments? <<argumentsWrapper>>
  public static boolean callExpression(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "callExpression")) return false;
    boolean r;
    Marker m = enter_section_(b, l, _LEFT_, CALL_EXPRESSION, "<call expression>");
    r = callExpression_0(b, l + 1);
    r = r && argumentsWrapper(b, l + 1);
    exit_section_(b, l, m, r, false, null);
    return r;
  }

  // typeArguments?
  private static boolean callExpression_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "callExpression_0")) return false;
    typeArguments(b, l + 1);
    return true;
  }

  /* ********************************************************** */
  // (callExpression | arrayAccessExpression | qualifiedReferenceExpression)*
  static boolean callOrArrayAccessOrQualifiedRefExpression(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "callOrArrayAccessOrQualifiedRefExpression")) return false;
    int c = current_position_(b);
    while (true) {
      if (!callOrArrayAccessOrQualifiedRefExpression_0(b, l + 1)) break;
      if (!empty_element_parsed_guard_(b, "callOrArrayAccessOrQualifiedRefExpression", c)) break;
      c = current_position_(b);
    }
    return true;
  }

  // callExpression | arrayAccessExpression | qualifiedReferenceExpression
  private static boolean callOrArrayAccessOrQualifiedRefExpression_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "callOrArrayAccessOrQualifiedRefExpression_0")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = callExpression(b, l + 1);
    if (!r) r = arrayAccessExpression(b, l + 1);
    if (!r) r = qualifiedReferenceExpression(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  /* ********************************************************** */
  // '..' << cascadeStopper >> (arrayAccess | refOrThisOrSuperOrParenExpression callOrArrayAccessOrQualifiedRefExpression) << varInitWrapper >>
  public static boolean cascadeReferenceExpression(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "cascadeReferenceExpression")) return false;
    if (!nextTokenIs(b, DOT_DOT)) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = consumeToken(b, DOT_DOT);
    r = r && cascadeStopper(b, l + 1);
    r = r && cascadeReferenceExpression_2(b, l + 1);
    r = r && varInitWrapper(b, l + 1);
    exit_section_(b, m, CASCADE_REFERENCE_EXPRESSION, r);
    return r;
  }

  // arrayAccess | refOrThisOrSuperOrParenExpression callOrArrayAccessOrQualifiedRefExpression
  private static boolean cascadeReferenceExpression_2(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "cascadeReferenceExpression_2")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = arrayAccess(b, l + 1);
    if (!r) r = cascadeReferenceExpression_2_1(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  // refOrThisOrSuperOrParenExpression callOrArrayAccessOrQualifiedRefExpression
  private static boolean cascadeReferenceExpression_2_1(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "cascadeReferenceExpression_2_1")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = refOrThisOrSuperOrParenExpression(b, l + 1);
    r = r && callOrArrayAccessOrQualifiedRefExpression(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  /* ********************************************************** */
  // 'catch' '(' componentName (',' componentName)? ')'
  public static boolean catchPart(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "catchPart")) return false;
    if (!nextTokenIs(b, CATCH)) return false;
    boolean r, p;
    Marker m = enter_section_(b, l, _NONE_, CATCH_PART, null);
    r = consumeTokens(b, 1, CATCH, LPAREN);
    p = r; // pin = 1
    r = r && report_error_(b, componentName(b, l + 1));
    r = p && report_error_(b, catchPart_3(b, l + 1)) && r;
    r = p && consumeToken(b, RPAREN) && r;
    exit_section_(b, l, m, r, p, null);
    return r || p;
  }

  // (',' componentName)?
  private static boolean catchPart_3(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "catchPart_3")) return false;
    catchPart_3_0(b, l + 1);
    return true;
  }

  // ',' componentName
  private static boolean catchPart_3_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "catchPart_3_0")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = consumeToken(b, COMMA);
    r = r && componentName(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  /* ********************************************************** */
  // '{' classMembers '}'
  public static boolean classBody(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "classBody")) return false;
    if (!nextTokenIs(b, LBRACE)) return false;
    boolean r, p;
    Marker m = enter_section_(b, l, _NONE_, CLASS_BODY, null);
    r = consumeToken(b, LBRACE);
    p = r; // pin = 1
    r = r && report_error_(b, classMembers(b, l + 1));
    r = p && consumeToken(b, RBRACE) && r;
    exit_section_(b, l, m, r, p, null);
    return r || p;
  }

  /* ********************************************************** */
  // metadata* 'abstract'? 'class' componentName typeParameters? (mixinApplication | standardClassDeclarationTail)
  public static boolean classDefinition(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "classDefinition")) return false;
    if (!nextTokenIs(b, "<class definition>", AT, ABSTRACT, CLASS)) return false;
    boolean r, p;
    Marker m = enter_section_(b, l, _NONE_, CLASS_DEFINITION, "<class definition>");
    r = classDefinition_0(b, l + 1);
    r = r && classDefinition_1(b, l + 1);
    r = r && consumeToken(b, CLASS);
    r = r && componentName(b, l + 1);
    p = r; // pin = 4
    r = r && report_error_(b, classDefinition_4(b, l + 1));
    r = p && classDefinition_5(b, l + 1) && r;
    exit_section_(b, l, m, r, p, null);
    return r || p;
  }

  // metadata*
  private static boolean classDefinition_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "classDefinition_0")) return false;
    int c = current_position_(b);
    while (true) {
      if (!metadata(b, l + 1)) break;
      if (!empty_element_parsed_guard_(b, "classDefinition_0", c)) break;
      c = current_position_(b);
    }
    return true;
  }

  // 'abstract'?
  private static boolean classDefinition_1(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "classDefinition_1")) return false;
    consumeToken(b, ABSTRACT);
    return true;
  }

  // typeParameters?
  private static boolean classDefinition_4(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "classDefinition_4")) return false;
    typeParameters(b, l + 1);
    return true;
  }

  // mixinApplication | standardClassDeclarationTail
  private static boolean classDefinition_5(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "classDefinition_5")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = mixinApplication(b, l + 1);
    if (!r) r = standardClassDeclarationTail(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  /* ********************************************************** */
  // factoryConstructorDeclaration
  //                                 | namedConstructorDeclaration
  //                                 | getterOrSetterDeclaration
  //                                 | methodDeclaration
  //                                 | varDeclarationListWithSemicolon
  //                                 | incompleteDeclaration
  static boolean classMemberDefinition(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "classMemberDefinition")) return false;
    boolean r;
    Marker m = enter_section_(b, l, _NONE_);
    r = factoryConstructorDeclaration(b, l + 1);
    if (!r) r = namedConstructorDeclaration(b, l + 1);
    if (!r) r = getterOrSetterDeclaration(b, l + 1);
    if (!r) r = methodDeclaration(b, l + 1);
    if (!r) r = varDeclarationListWithSemicolon(b, l + 1);
    if (!r) r = incompleteDeclaration(b, l + 1);
    exit_section_(b, l, m, r, false, class_member_recover_parser_);
    return r;
  }

  /* ********************************************************** */
  // classMemberDefinition*
  public static boolean classMembers(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "classMembers")) return false;
    Marker m = enter_section_(b, l, _NONE_, CLASS_MEMBERS, "<class members>");
    int c = current_position_(b);
    while (true) {
      if (!classMemberDefinition(b, l + 1)) break;
      if (!empty_element_parsed_guard_(b, "classMembers", c)) break;
      c = current_position_(b);
    }
    exit_section_(b, l, m, true, false, simple_scope_recover_parser_);
    return true;
  }

  /* ********************************************************** */
  // !(<<nonStrictID>> | '@' | 'abstract' | 'class' | 'const' | 'export' | 'external' | 'factory' | 'final' | 'get' | 'import' | 'library' | 'operator' | 'part' | 'set' | 'static' | 'typedef' | 'var' | 'void' | '}' )
  static boolean class_member_recover(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "class_member_recover")) return false;
    boolean r;
    Marker m = enter_section_(b, l, _NOT_);
    r = !class_member_recover_0(b, l + 1);
    exit_section_(b, l, m, r, false, null);
    return r;
  }

  // <<nonStrictID>> | '@' | 'abstract' | 'class' | 'const' | 'export' | 'external' | 'factory' | 'final' | 'get' | 'import' | 'library' | 'operator' | 'part' | 'set' | 'static' | 'typedef' | 'var' | 'void' | '}'
  private static boolean class_member_recover_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "class_member_recover_0")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = nonStrictID(b, l + 1);
    if (!r) r = consumeToken(b, AT);
    if (!r) r = consumeToken(b, ABSTRACT);
    if (!r) r = consumeToken(b, CLASS);
    if (!r) r = consumeToken(b, CONST);
    if (!r) r = consumeToken(b, EXPORT);
    if (!r) r = consumeToken(b, EXTERNAL);
    if (!r) r = consumeToken(b, FACTORY);
    if (!r) r = consumeToken(b, FINAL);
    if (!r) r = consumeToken(b, GET);
    if (!r) r = consumeToken(b, IMPORT);
    if (!r) r = consumeToken(b, LIBRARY);
    if (!r) r = consumeToken(b, OPERATOR);
    if (!r) r = consumeToken(b, PART);
    if (!r) r = consumeToken(b, SET);
    if (!r) r = consumeToken(b, STATIC);
    if (!r) r = consumeToken(b, TYPEDEF);
    if (!r) r = consumeToken(b, VAR);
    if (!r) r = consumeToken(b, VOID);
    if (!r) r = consumeToken(b, RBRACE);
    exit_section_(b, m, null, r);
    return r;
  }

  /* ********************************************************** */
  // showCombinator | hideCombinator
  static boolean combinator(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "combinator")) return false;
    if (!nextTokenIs(b, "", HIDE, SHOW)) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = showCombinator(b, l + 1);
    if (!r) r = hideCombinator(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  /* ********************************************************** */
  // (relationalOperator | equalityOperator) bitwiseExpressionWrapper
  public static boolean compareExpression(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "compareExpression")) return false;
    boolean r;
    Marker m = enter_section_(b, l, _LEFT_, COMPARE_EXPRESSION, "<compare expression>");
    r = compareExpression_0(b, l + 1);
    r = r && bitwiseExpressionWrapper(b, l + 1);
    exit_section_(b, l, m, r, false, null);
    return r;
  }

  // relationalOperator | equalityOperator
  private static boolean compareExpression_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "compareExpression_0")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = relationalOperator(b, l + 1);
    if (!r) r = equalityOperator(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  /* ********************************************************** */
  // bitwiseExpressionWrapper compareExpression*
  static boolean compareExpressionWrapper(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "compareExpressionWrapper")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = bitwiseExpressionWrapper(b, l + 1);
    r = r && compareExpressionWrapper_1(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  // compareExpression*
  private static boolean compareExpressionWrapper_1(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "compareExpressionWrapper_1")) return false;
    int c = current_position_(b);
    while (true) {
      if (!compareExpression(b, l + 1)) break;
      if (!empty_element_parsed_guard_(b, "compareExpressionWrapper_1", c)) break;
      c = current_position_(b);
    }
    return true;
  }

  /* ********************************************************** */
  // << nonStrictID >>
  public static boolean componentName(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "componentName")) return false;
    boolean r;
    Marker m = enter_section_(b, l, _NONE_, COMPONENT_NAME, "<component name>");
    r = nonStrictID(b, l + 1);
    exit_section_(b, l, m, r, false, null);
    return r;
  }

  /* ********************************************************** */
  // 'continue' referenceExpression? ';'
  public static boolean continueStatement(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "continueStatement")) return false;
    if (!nextTokenIs(b, CONTINUE)) return false;
    boolean r, p;
    Marker m = enter_section_(b, l, _NONE_, CONTINUE_STATEMENT, null);
    r = consumeToken(b, CONTINUE);
    p = r; // pin = 1
    r = r && report_error_(b, continueStatement_1(b, l + 1));
    r = p && consumeToken(b, SEMICOLON) && r;
    exit_section_(b, l, m, r, p, null);
    return r || p;
  }

  // referenceExpression?
  private static boolean continueStatement_1(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "continueStatement_1")) return false;
    referenceExpression(b, l + 1);
    return true;
  }

  /* ********************************************************** */
  // topLevelDefinition*
  static boolean dartUnit(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "dartUnit")) return false;
    int c = current_position_(b);
    while (true) {
      if (!topLevelDefinition(b, l + 1)) break;
      if (!empty_element_parsed_guard_(b, "dartUnit", c)) break;
      c = current_position_(b);
    }
    return true;
  }

  /* ********************************************************** */
  // metadata* finalConstVarOrTypeAndComponentName
  static boolean declaredIdentifier(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "declaredIdentifier")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = declaredIdentifier_0(b, l + 1);
    r = r && finalConstVarOrTypeAndComponentName(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  // metadata*
  private static boolean declaredIdentifier_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "declaredIdentifier_0")) return false;
    int c = current_position_(b);
    while (true) {
      if (!metadata(b, l + 1)) break;
      if (!empty_element_parsed_guard_(b, "declaredIdentifier_0", c)) break;
      c = current_position_(b);
    }
    return true;
  }

  /* ********************************************************** */
  // label* 'default' ':' statements
  public static boolean defaultCase(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "defaultCase")) return false;
    boolean r, p;
    Marker m = enter_section_(b, l, _NONE_, DEFAULT_CASE, "<default case>");
    r = defaultCase_0(b, l + 1);
    r = r && consumeTokens(b, 1, DEFAULT, COLON);
    p = r; // pin = 2
    r = r && statements(b, l + 1);
    exit_section_(b, l, m, r, p, null);
    return r || p;
  }

  // label*
  private static boolean defaultCase_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "defaultCase_0")) return false;
    int c = current_position_(b);
    while (true) {
      if (!label(b, l + 1)) break;
      if (!empty_element_parsed_guard_(b, "defaultCase_0", c)) break;
      c = current_position_(b);
    }
    return true;
  }

  /* ********************************************************** */
  // normalFormalParameter (('=' | ':') expression)?
  public static boolean defaultFormalNamedParameter(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "defaultFormalNamedParameter")) return false;
    boolean r;
    Marker m = enter_section_(b, l, _NONE_, DEFAULT_FORMAL_NAMED_PARAMETER, "<default formal named parameter>");
    r = normalFormalParameter(b, l + 1);
    r = r && defaultFormalNamedParameter_1(b, l + 1);
    exit_section_(b, l, m, r, false, default_formal_parameter_recover_parser_);
    return r;
  }

  // (('=' | ':') expression)?
  private static boolean defaultFormalNamedParameter_1(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "defaultFormalNamedParameter_1")) return false;
    defaultFormalNamedParameter_1_0(b, l + 1);
    return true;
  }

  // ('=' | ':') expression
  private static boolean defaultFormalNamedParameter_1_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "defaultFormalNamedParameter_1_0")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = defaultFormalNamedParameter_1_0_0(b, l + 1);
    r = r && expression(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  // '=' | ':'
  private static boolean defaultFormalNamedParameter_1_0_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "defaultFormalNamedParameter_1_0_0")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = consumeToken(b, EQ);
    if (!r) r = consumeToken(b, COLON);
    exit_section_(b, m, null, r);
    return r;
  }

  /* ********************************************************** */
  // !(')' | ',' | ']' | '}')
  static boolean default_formal_parameter_recover(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "default_formal_parameter_recover")) return false;
    boolean r;
    Marker m = enter_section_(b, l, _NOT_);
    r = !default_formal_parameter_recover_0(b, l + 1);
    exit_section_(b, l, m, r, false, null);
    return r;
  }

  // ')' | ',' | ']' | '}'
  private static boolean default_formal_parameter_recover_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "default_formal_parameter_recover_0")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = consumeToken(b, RPAREN);
    if (!r) r = consumeToken(b, COMMA);
    if (!r) r = consumeToken(b, RBRACKET);
    if (!r) r = consumeToken(b, RBRACE);
    exit_section_(b, m, null, r);
    return r;
  }

  /* ********************************************************** */
  // 'do' statement 'while' '(' expressionWithRecoverUntilParen ')' ';'
  public static boolean doWhileStatement(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "doWhileStatement")) return false;
    if (!nextTokenIs(b, DO)) return false;
    boolean r, p;
    Marker m = enter_section_(b, l, _NONE_, DO_WHILE_STATEMENT, null);
    r = consumeToken(b, DO);
    p = r; // pin = 1
    r = r && report_error_(b, statement(b, l + 1));
    r = p && report_error_(b, consumeTokens(b, -1, WHILE, LPAREN)) && r;
    r = p && report_error_(b, expressionWithRecoverUntilParen(b, l + 1)) && r;
    r = p && report_error_(b, consumeTokens(b, -1, RPAREN, SEMICOLON)) && r;
    exit_section_(b, l, m, r, p, null);
    return r || p;
  }

  /* ********************************************************** */
  // <<nonStrictID>> ('.' <<nonStrictID>>)*
  static boolean dottedName(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "dottedName")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = nonStrictID(b, l + 1);
    r = r && dottedName_1(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  // ('.' <<nonStrictID>>)*
  private static boolean dottedName_1(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "dottedName_1")) return false;
    int c = current_position_(b);
    while (true) {
      if (!dottedName_1_0(b, l + 1)) break;
      if (!empty_element_parsed_guard_(b, "dottedName_1", c)) break;
      c = current_position_(b);
    }
    return true;
  }

  // '.' <<nonStrictID>>
  private static boolean dottedName_1_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "dottedName_1_0")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = consumeToken(b, DOT);
    r = r && nonStrictID(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  /* ********************************************************** */
  // componentName
  public static boolean enumConstantDeclaration(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "enumConstantDeclaration")) return false;
    boolean r;
    Marker m = enter_section_(b, l, _NONE_, ENUM_CONSTANT_DECLARATION, "<enum constant declaration>");
    r = componentName(b, l + 1);
    exit_section_(b, l, m, r, false, null);
    return r;
  }

  /* ********************************************************** */
  // metadata* 'enum' componentName '{' enumConstantDeclaration (',' enumConstantDeclaration)* ','? '}'
  public static boolean enumDefinition(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "enumDefinition")) return false;
    if (!nextTokenIs(b, "<enum definition>", AT, ENUM)) return false;
    boolean r, p;
    Marker m = enter_section_(b, l, _NONE_, ENUM_DEFINITION, "<enum definition>");
    r = enumDefinition_0(b, l + 1);
    r = r && consumeToken(b, ENUM);
    r = r && componentName(b, l + 1);
    p = r; // pin = 3
    r = r && report_error_(b, consumeToken(b, LBRACE));
    r = p && report_error_(b, enumConstantDeclaration(b, l + 1)) && r;
    r = p && report_error_(b, enumDefinition_5(b, l + 1)) && r;
    r = p && report_error_(b, enumDefinition_6(b, l + 1)) && r;
    r = p && consumeToken(b, RBRACE) && r;
    exit_section_(b, l, m, r, p, null);
    return r || p;
  }

  // metadata*
  private static boolean enumDefinition_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "enumDefinition_0")) return false;
    int c = current_position_(b);
    while (true) {
      if (!metadata(b, l + 1)) break;
      if (!empty_element_parsed_guard_(b, "enumDefinition_0", c)) break;
      c = current_position_(b);
    }
    return true;
  }

  // (',' enumConstantDeclaration)*
  private static boolean enumDefinition_5(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "enumDefinition_5")) return false;
    int c = current_position_(b);
    while (true) {
      if (!enumDefinition_5_0(b, l + 1)) break;
      if (!empty_element_parsed_guard_(b, "enumDefinition_5", c)) break;
      c = current_position_(b);
    }
    return true;
  }

  // ',' enumConstantDeclaration
  private static boolean enumDefinition_5_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "enumDefinition_5_0")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = consumeToken(b, COMMA);
    r = r && enumConstantDeclaration(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  // ','?
  private static boolean enumDefinition_6(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "enumDefinition_6")) return false;
    consumeToken(b, COMMA);
    return true;
  }

  /* ********************************************************** */
  // '==' | '!='
  public static boolean equalityOperator(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "equalityOperator")) return false;
    if (!nextTokenIs(b, "<equality operator>", NEQ, EQ_EQ)) return false;
    boolean r;
    Marker m = enter_section_(b, l, _NONE_, EQUALITY_OPERATOR, "<equality operator>");
    r = consumeToken(b, EQ_EQ);
    if (!r) r = consumeToken(b, NEQ);
    exit_section_(b, l, m, r, false, null);
    return r;
  }

  /* ********************************************************** */
  // metadata* 'export' uriElement importConfig* combinator* ';'
  public static boolean exportStatement(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "exportStatement")) return false;
    if (!nextTokenIs(b, "<export statement>", AT, EXPORT)) return false;
    boolean r, p;
    Marker m = enter_section_(b, l, _NONE_, EXPORT_STATEMENT, "<export statement>");
    r = exportStatement_0(b, l + 1);
    r = r && consumeToken(b, EXPORT);
    r = r && uriElement(b, l + 1);
    p = r; // pin = 3
    r = r && report_error_(b, exportStatement_3(b, l + 1));
    r = p && report_error_(b, exportStatement_4(b, l + 1)) && r;
    r = p && consumeToken(b, SEMICOLON) && r;
    exit_section_(b, l, m, r, p, null);
    return r || p;
  }

  // metadata*
  private static boolean exportStatement_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "exportStatement_0")) return false;
    int c = current_position_(b);
    while (true) {
      if (!metadata(b, l + 1)) break;
      if (!empty_element_parsed_guard_(b, "exportStatement_0", c)) break;
      c = current_position_(b);
    }
    return true;
  }

  // importConfig*
  private static boolean exportStatement_3(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "exportStatement_3")) return false;
    int c = current_position_(b);
    while (true) {
      if (!importConfig(b, l + 1)) break;
      if (!empty_element_parsed_guard_(b, "exportStatement_3", c)) break;
      c = current_position_(b);
    }
    return true;
  }

  // combinator*
  private static boolean exportStatement_4(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "exportStatement_4")) return false;
    int c = current_position_(b);
    while (true) {
      if (!combinator(b, l + 1)) break;
      if (!empty_element_parsed_guard_(b, "exportStatement_4", c)) break;
      c = current_position_(b);
    }
    return true;
  }

  /* ********************************************************** */
  // assignExpressionWrapper
  public static boolean expression(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "expression")) return false;
    boolean r;
    Marker m = enter_section_(b, l, _COLLAPSE_, EXPRESSION, "<expression>");
    r = assignExpressionWrapper(b, l + 1);
    exit_section_(b, l, m, r, false, expression_recover_parser_);
    return r;
  }

  /* ********************************************************** */
  // expression | statement
  static boolean expressionInParentheses(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "expressionInParentheses")) return false;
    boolean r;
    Marker m = enter_section_(b, l, _NONE_);
    r = expression(b, l + 1);
    if (!r) r = statement(b, l + 1);
    exit_section_(b, l, m, r, false, parenthesesRecovery_parser_);
    return r;
  }

  /* ********************************************************** */
  // expression (',' expression)*
  public static boolean expressionList(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "expressionList")) return false;
    boolean r;
    Marker m = enter_section_(b, l, _NONE_, EXPRESSION_LIST, "<expression list>");
    r = expression(b, l + 1);
    r = r && expressionList_1(b, l + 1);
    exit_section_(b, l, m, r, false, null);
    return r;
  }

  // (',' expression)*
  private static boolean expressionList_1(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "expressionList_1")) return false;
    int c = current_position_(b);
    while (true) {
      if (!expressionList_1_0(b, l + 1)) break;
      if (!empty_element_parsed_guard_(b, "expressionList_1", c)) break;
      c = current_position_(b);
    }
    return true;
  }

  // ',' expression
  private static boolean expressionList_1_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "expressionList_1_0")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = consumeToken(b, COMMA);
    r = r && expression(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  /* ********************************************************** */
  // expression
  static boolean expressionWithRecoverUntilParen(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "expressionWithRecoverUntilParen")) return false;
    boolean r;
    Marker m = enter_section_(b, l, _NONE_);
    r = expression(b, l + 1);
    exit_section_(b, l, m, r, false, not_paren_recover_parser_);
    return r;
  }

  /* ********************************************************** */
  // expression
  static boolean expressionWithRecoverUntilParenOrComma(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "expressionWithRecoverUntilParenOrComma")) return false;
    boolean r;
    Marker m = enter_section_(b, l, _NONE_);
    r = expression(b, l + 1);
    exit_section_(b, l, m, r, false, not_paren_or_comma_recover_parser_);
    return r;
  }

  /* ********************************************************** */
  // !(<<nonStrictID>> | <<parenthesizedExpressionWrapper>> | '!' | '!=' | '%' | '%=' |
  //                                  '&&' | '&&=' | '&' | '&=' | '(' | ')' | '*' | '*=' | '+' | '++' | '+=' | ',' | '-' | '--' | '-=' | '.' | '..' | '/' |
  //                                  '/=' | ':' | ';' | '<' | '<<' | '<<=' | '<=' | '=' | '==' | '=>' | '>' | <<gtGt>> | <<gtEq>> | <<gtGtEq>> |
  //                                  '@' | '[' | ']' | '^' | '^=' | '?.' | '??=' | '??' | '?' |
  //                                  'abstract' | 'as' | 'assert' | 'async' | 'break' | 'case' | 'catch' | 'class' | 'const' |
  //                                  'continue' | 'default' | 'deferred' | 'do' | 'else' | 'export' | 'external' | 'factory' | 'final' | 'finally' | 'for' |
  //                                  'get' | 'hide' | 'if' | 'import' | 'is' | 'library' | 'native' | 'new' | 'on' | 'operator' | 'part' |
  //                                  'rethrow' | 'return' | 'set' | 'show' | 'static' | 'super' | 'switch' | 'sync' | 'this' | 'throw' | 'try' |
  //                                  'typedef' | 'var' | 'void' | 'while' | '{' | '|' | '|=' | '||' | '||=' | '}' | '~' | '~/' | '~/=' | CLOSING_QUOTE |
  //                                   FALSE | HEX_NUMBER | LONG_TEMPLATE_ENTRY_END | LONG_TEMPLATE_ENTRY_START | NULL | NUMBER |
  //                                   OPEN_QUOTE | RAW_SINGLE_QUOTED_STRING | RAW_TRIPLE_QUOTED_STRING | REGULAR_STRING_PART |
  //                                   SHORT_TEMPLATE_ENTRY_START | TRUE)
  static boolean expression_recover(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "expression_recover")) return false;
    boolean r;
    Marker m = enter_section_(b, l, _NOT_);
    r = !expression_recover_0(b, l + 1);
    exit_section_(b, l, m, r, false, null);
    return r;
  }

  // <<nonStrictID>> | <<parenthesizedExpressionWrapper>> | '!' | '!=' | '%' | '%=' |
  //                                  '&&' | '&&=' | '&' | '&=' | '(' | ')' | '*' | '*=' | '+' | '++' | '+=' | ',' | '-' | '--' | '-=' | '.' | '..' | '/' |
  //                                  '/=' | ':' | ';' | '<' | '<<' | '<<=' | '<=' | '=' | '==' | '=>' | '>' | <<gtGt>> | <<gtEq>> | <<gtGtEq>> |
  //                                  '@' | '[' | ']' | '^' | '^=' | '?.' | '??=' | '??' | '?' |
  //                                  'abstract' | 'as' | 'assert' | 'async' | 'break' | 'case' | 'catch' | 'class' | 'const' |
  //                                  'continue' | 'default' | 'deferred' | 'do' | 'else' | 'export' | 'external' | 'factory' | 'final' | 'finally' | 'for' |
  //                                  'get' | 'hide' | 'if' | 'import' | 'is' | 'library' | 'native' | 'new' | 'on' | 'operator' | 'part' |
  //                                  'rethrow' | 'return' | 'set' | 'show' | 'static' | 'super' | 'switch' | 'sync' | 'this' | 'throw' | 'try' |
  //                                  'typedef' | 'var' | 'void' | 'while' | '{' | '|' | '|=' | '||' | '||=' | '}' | '~' | '~/' | '~/=' | CLOSING_QUOTE |
  //                                   FALSE | HEX_NUMBER | LONG_TEMPLATE_ENTRY_END | LONG_TEMPLATE_ENTRY_START | NULL | NUMBER |
  //                                   OPEN_QUOTE | RAW_SINGLE_QUOTED_STRING | RAW_TRIPLE_QUOTED_STRING | REGULAR_STRING_PART |
  //                                   SHORT_TEMPLATE_ENTRY_START | TRUE
  private static boolean expression_recover_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "expression_recover_0")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = nonStrictID(b, l + 1);
    if (!r) r = parenthesizedExpressionWrapper(b, l + 1);
    if (!r) r = consumeToken(b, NOT);
    if (!r) r = consumeToken(b, NEQ);
    if (!r) r = consumeToken(b, REM);
    if (!r) r = consumeToken(b, REM_EQ);
    if (!r) r = consumeToken(b, AND_AND);
    if (!r) r = consumeToken(b, AND_AND_EQ);
    if (!r) r = consumeToken(b, AND);
    if (!r) r = consumeToken(b, AND_EQ);
    if (!r) r = consumeToken(b, LPAREN);
    if (!r) r = consumeToken(b, RPAREN);
    if (!r) r = consumeToken(b, MUL);
    if (!r) r = consumeToken(b, MUL_EQ);
    if (!r) r = consumeToken(b, PLUS);
    if (!r) r = consumeToken(b, PLUS_PLUS);
    if (!r) r = consumeToken(b, PLUS_EQ);
    if (!r) r = consumeToken(b, COMMA);
    if (!r) r = consumeToken(b, MINUS);
    if (!r) r = consumeToken(b, MINUS_MINUS);
    if (!r) r = consumeToken(b, MINUS_EQ);
    if (!r) r = consumeToken(b, DOT);
    if (!r) r = consumeToken(b, DOT_DOT);
    if (!r) r = consumeToken(b, DIV);
    if (!r) r = consumeToken(b, DIV_EQ);
    if (!r) r = consumeToken(b, COLON);
    if (!r) r = consumeToken(b, SEMICOLON);
    if (!r) r = consumeToken(b, LT);
    if (!r) r = consumeToken(b, LT_LT);
    if (!r) r = consumeToken(b, LT_LT_EQ);
    if (!r) r = consumeToken(b, LT_EQ);
    if (!r) r = consumeToken(b, EQ);
    if (!r) r = consumeToken(b, EQ_EQ);
    if (!r) r = consumeToken(b, EXPRESSION_BODY_DEF);
    if (!r) r = consumeToken(b, GT);
    if (!r) r = gtGt(b, l + 1);
    if (!r) r = gtEq(b, l + 1);
    if (!r) r = gtGtEq(b, l + 1);
    if (!r) r = consumeToken(b, AT);
    if (!r) r = consumeToken(b, LBRACKET);
    if (!r) r = consumeToken(b, RBRACKET);
    if (!r) r = consumeToken(b, XOR);
    if (!r) r = consumeToken(b, XOR_EQ);
    if (!r) r = consumeToken(b, QUEST_DOT);
    if (!r) r = consumeToken(b, QUEST_QUEST_EQ);
    if (!r) r = consumeToken(b, QUEST_QUEST);
    if (!r) r = consumeToken(b, QUEST);
    if (!r) r = consumeToken(b, ABSTRACT);
    if (!r) r = consumeToken(b, AS);
    if (!r) r = consumeToken(b, ASSERT);
    if (!r) r = consumeToken(b, ASYNC);
    if (!r) r = consumeToken(b, BREAK);
    if (!r) r = consumeToken(b, CASE);
    if (!r) r = consumeToken(b, CATCH);
    if (!r) r = consumeToken(b, CLASS);
    if (!r) r = consumeToken(b, CONST);
    if (!r) r = consumeToken(b, CONTINUE);
    if (!r) r = consumeToken(b, DEFAULT);
    if (!r) r = consumeToken(b, DEFERRED);
    if (!r) r = consumeToken(b, DO);
    if (!r) r = consumeToken(b, ELSE);
    if (!r) r = consumeToken(b, EXPORT);
    if (!r) r = consumeToken(b, EXTERNAL);
    if (!r) r = consumeToken(b, FACTORY);
    if (!r) r = consumeToken(b, FINAL);
    if (!r) r = consumeToken(b, FINALLY);
    if (!r) r = consumeToken(b, FOR);
    if (!r) r = consumeToken(b, GET);
    if (!r) r = consumeToken(b, HIDE);
    if (!r) r = consumeToken(b, IF);
    if (!r) r = consumeToken(b, IMPORT);
    if (!r) r = consumeToken(b, IS);
    if (!r) r = consumeToken(b, LIBRARY);
    if (!r) r = consumeToken(b, NATIVE);
    if (!r) r = consumeToken(b, NEW);
    if (!r) r = consumeToken(b, ON);
    if (!r) r = consumeToken(b, OPERATOR);
    if (!r) r = consumeToken(b, PART);
    if (!r) r = consumeToken(b, RETHROW);
    if (!r) r = consumeToken(b, RETURN);
    if (!r) r = consumeToken(b, SET);
    if (!r) r = consumeToken(b, SHOW);
    if (!r) r = consumeToken(b, STATIC);
    if (!r) r = consumeToken(b, SUPER);
    if (!r) r = consumeToken(b, SWITCH);
    if (!r) r = consumeToken(b, SYNC);
    if (!r) r = consumeToken(b, THIS);
    if (!r) r = consumeToken(b, THROW);
    if (!r) r = consumeToken(b, TRY);
    if (!r) r = consumeToken(b, TYPEDEF);
    if (!r) r = consumeToken(b, VAR);
    if (!r) r = consumeToken(b, VOID);
    if (!r) r = consumeToken(b, WHILE);
    if (!r) r = consumeToken(b, LBRACE);
    if (!r) r = consumeToken(b, OR);
    if (!r) r = consumeToken(b, OR_EQ);
    if (!r) r = consumeToken(b, OR_OR);
    if (!r) r = consumeToken(b, OR_OR_EQ);
    if (!r) r = consumeToken(b, RBRACE);
    if (!r) r = consumeToken(b, BIN_NOT);
    if (!r) r = consumeToken(b, INT_DIV);
    if (!r) r = consumeToken(b, INT_DIV_EQ);
    if (!r) r = consumeToken(b, CLOSING_QUOTE);
    if (!r) r = consumeToken(b, FALSE);
    if (!r) r = consumeToken(b, HEX_NUMBER);
    if (!r) r = consumeToken(b, LONG_TEMPLATE_ENTRY_END);
    if (!r) r = consumeToken(b, LONG_TEMPLATE_ENTRY_START);
    if (!r) r = consumeToken(b, NULL);
    if (!r) r = consumeToken(b, NUMBER);
    if (!r) r = consumeToken(b, OPEN_QUOTE);
    if (!r) r = consumeToken(b, RAW_SINGLE_QUOTED_STRING);
    if (!r) r = consumeToken(b, RAW_TRIPLE_QUOTED_STRING);
    if (!r) r = consumeToken(b, REGULAR_STRING_PART);
    if (!r) r = consumeToken(b, SHORT_TEMPLATE_ENTRY_START);
    if (!r) r = consumeToken(b, TRUE);
    exit_section_(b, m, null, r);
    return r;
  }

  /* ********************************************************** */
  // metadata* ('external' | 'const')* 'factory' componentName ('.' componentName)? formalParameterList factoryTail?
  public static boolean factoryConstructorDeclaration(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "factoryConstructorDeclaration")) return false;
    if (!nextTokenIs(b, "<factory constructor declaration>", AT, CONST, EXTERNAL, FACTORY)) return false;
    boolean r, p;
    Marker m = enter_section_(b, l, _NONE_, FACTORY_CONSTRUCTOR_DECLARATION, "<factory constructor declaration>");
    r = factoryConstructorDeclaration_0(b, l + 1);
    r = r && factoryConstructorDeclaration_1(b, l + 1);
    r = r && consumeToken(b, FACTORY);
    p = r; // pin = 3
    r = r && report_error_(b, componentName(b, l + 1));
    r = p && report_error_(b, factoryConstructorDeclaration_4(b, l + 1)) && r;
    r = p && report_error_(b, formalParameterList(b, l + 1)) && r;
    r = p && factoryConstructorDeclaration_6(b, l + 1) && r;
    exit_section_(b, l, m, r, p, null);
    return r || p;
  }

  // metadata*
  private static boolean factoryConstructorDeclaration_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "factoryConstructorDeclaration_0")) return false;
    int c = current_position_(b);
    while (true) {
      if (!metadata(b, l + 1)) break;
      if (!empty_element_parsed_guard_(b, "factoryConstructorDeclaration_0", c)) break;
      c = current_position_(b);
    }
    return true;
  }

  // ('external' | 'const')*
  private static boolean factoryConstructorDeclaration_1(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "factoryConstructorDeclaration_1")) return false;
    int c = current_position_(b);
    while (true) {
      if (!factoryConstructorDeclaration_1_0(b, l + 1)) break;
      if (!empty_element_parsed_guard_(b, "factoryConstructorDeclaration_1", c)) break;
      c = current_position_(b);
    }
    return true;
  }

  // 'external' | 'const'
  private static boolean factoryConstructorDeclaration_1_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "factoryConstructorDeclaration_1_0")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = consumeToken(b, EXTERNAL);
    if (!r) r = consumeToken(b, CONST);
    exit_section_(b, m, null, r);
    return r;
  }

  // ('.' componentName)?
  private static boolean factoryConstructorDeclaration_4(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "factoryConstructorDeclaration_4")) return false;
    factoryConstructorDeclaration_4_0(b, l + 1);
    return true;
  }

  // '.' componentName
  private static boolean factoryConstructorDeclaration_4_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "factoryConstructorDeclaration_4_0")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = consumeToken(b, DOT);
    r = r && componentName(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  // factoryTail?
  private static boolean factoryConstructorDeclaration_6(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "factoryConstructorDeclaration_6")) return false;
    factoryTail(b, l + 1);
    return true;
  }

  /* ********************************************************** */
  // varFactoryDeclaration ';' | functionBodyOrNative | ';'
  static boolean factoryTail(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "factoryTail")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = factoryTail_0(b, l + 1);
    if (!r) r = functionBodyOrNative(b, l + 1);
    if (!r) r = consumeToken(b, SEMICOLON);
    exit_section_(b, m, null, r);
    return r;
  }

  // varFactoryDeclaration ';'
  private static boolean factoryTail_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "factoryTail_0")) return false;
    boolean r, p;
    Marker m = enter_section_(b, l, _NONE_);
    r = varFactoryDeclaration(b, l + 1);
    p = r; // pin = 1
    r = r && consumeToken(b, SEMICOLON);
    exit_section_(b, l, m, r, p, null);
    return r || p;
  }

  /* ********************************************************** */
  // metadata* finalConstVarVoidOrType? 'this' '.' referenceExpression typeParameters? formalParameterList?
  public static boolean fieldFormalParameter(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "fieldFormalParameter")) return false;
    boolean r;
    Marker m = enter_section_(b, l, _NONE_, FIELD_FORMAL_PARAMETER, "<field formal parameter>");
    r = fieldFormalParameter_0(b, l + 1);
    r = r && fieldFormalParameter_1(b, l + 1);
    r = r && consumeTokens(b, 0, THIS, DOT);
    r = r && referenceExpression(b, l + 1);
    r = r && fieldFormalParameter_5(b, l + 1);
    r = r && fieldFormalParameter_6(b, l + 1);
    exit_section_(b, l, m, r, false, null);
    return r;
  }

  // metadata*
  private static boolean fieldFormalParameter_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "fieldFormalParameter_0")) return false;
    int c = current_position_(b);
    while (true) {
      if (!metadata(b, l + 1)) break;
      if (!empty_element_parsed_guard_(b, "fieldFormalParameter_0", c)) break;
      c = current_position_(b);
    }
    return true;
  }

  // finalConstVarVoidOrType?
  private static boolean fieldFormalParameter_1(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "fieldFormalParameter_1")) return false;
    finalConstVarVoidOrType(b, l + 1);
    return true;
  }

  // typeParameters?
  private static boolean fieldFormalParameter_5(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "fieldFormalParameter_5")) return false;
    typeParameters(b, l + 1);
    return true;
  }

  // formalParameterList?
  private static boolean fieldFormalParameter_6(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "fieldFormalParameter_6")) return false;
    formalParameterList(b, l + 1);
    return true;
  }

  /* ********************************************************** */
  // ('this' '.')? referenceExpression '=' expression
  public static boolean fieldInitializer(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "fieldInitializer")) return false;
    boolean r, p;
    Marker m = enter_section_(b, l, _NONE_, FIELD_INITIALIZER, "<field initializer>");
    r = fieldInitializer_0(b, l + 1);
    r = r && referenceExpression(b, l + 1);
    p = r; // pin = 2
    r = r && report_error_(b, consumeToken(b, EQ));
    r = p && expression(b, l + 1) && r;
    exit_section_(b, l, m, r, p, null);
    return r || p;
  }

  // ('this' '.')?
  private static boolean fieldInitializer_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "fieldInitializer_0")) return false;
    fieldInitializer_0_0(b, l + 1);
    return true;
  }

  // 'this' '.'
  private static boolean fieldInitializer_0_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "fieldInitializer_0_0")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = consumeTokens(b, 0, THIS, DOT);
    exit_section_(b, m, null, r);
    return r;
  }

  /* ********************************************************** */
  // 'covariant'? 'final' type componentName |
  //                                                 'covariant'? 'final'      componentName |
  //                                                 'covariant'? 'const' type componentName |
  //                                                 'covariant'? 'const'      componentName |
  //                                                 'covariant'? 'var'        componentName |
  //                                                 'covariant'          type componentName |
  //                                                                      type componentName
  static boolean finalConstVarOrTypeAndComponentName(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "finalConstVarOrTypeAndComponentName")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = finalConstVarOrTypeAndComponentName_0(b, l + 1);
    if (!r) r = finalConstVarOrTypeAndComponentName_1(b, l + 1);
    if (!r) r = finalConstVarOrTypeAndComponentName_2(b, l + 1);
    if (!r) r = finalConstVarOrTypeAndComponentName_3(b, l + 1);
    if (!r) r = finalConstVarOrTypeAndComponentName_4(b, l + 1);
    if (!r) r = finalConstVarOrTypeAndComponentName_5(b, l + 1);
    if (!r) r = finalConstVarOrTypeAndComponentName_6(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  // 'covariant'? 'final' type componentName
  private static boolean finalConstVarOrTypeAndComponentName_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "finalConstVarOrTypeAndComponentName_0")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = finalConstVarOrTypeAndComponentName_0_0(b, l + 1);
    r = r && consumeToken(b, FINAL);
    r = r && type(b, l + 1);
    r = r && componentName(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  // 'covariant'?
  private static boolean finalConstVarOrTypeAndComponentName_0_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "finalConstVarOrTypeAndComponentName_0_0")) return false;
    consumeToken(b, COVARIANT);
    return true;
  }

  // 'covariant'? 'final'      componentName
  private static boolean finalConstVarOrTypeAndComponentName_1(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "finalConstVarOrTypeAndComponentName_1")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = finalConstVarOrTypeAndComponentName_1_0(b, l + 1);
    r = r && consumeToken(b, FINAL);
    r = r && componentName(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  // 'covariant'?
  private static boolean finalConstVarOrTypeAndComponentName_1_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "finalConstVarOrTypeAndComponentName_1_0")) return false;
    consumeToken(b, COVARIANT);
    return true;
  }

  // 'covariant'? 'const' type componentName
  private static boolean finalConstVarOrTypeAndComponentName_2(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "finalConstVarOrTypeAndComponentName_2")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = finalConstVarOrTypeAndComponentName_2_0(b, l + 1);
    r = r && consumeToken(b, CONST);
    r = r && type(b, l + 1);
    r = r && componentName(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  // 'covariant'?
  private static boolean finalConstVarOrTypeAndComponentName_2_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "finalConstVarOrTypeAndComponentName_2_0")) return false;
    consumeToken(b, COVARIANT);
    return true;
  }

  // 'covariant'? 'const'      componentName
  private static boolean finalConstVarOrTypeAndComponentName_3(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "finalConstVarOrTypeAndComponentName_3")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = finalConstVarOrTypeAndComponentName_3_0(b, l + 1);
    r = r && consumeToken(b, CONST);
    r = r && componentName(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  // 'covariant'?
  private static boolean finalConstVarOrTypeAndComponentName_3_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "finalConstVarOrTypeAndComponentName_3_0")) return false;
    consumeToken(b, COVARIANT);
    return true;
  }

  // 'covariant'? 'var'        componentName
  private static boolean finalConstVarOrTypeAndComponentName_4(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "finalConstVarOrTypeAndComponentName_4")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = finalConstVarOrTypeAndComponentName_4_0(b, l + 1);
    r = r && consumeToken(b, VAR);
    r = r && componentName(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  // 'covariant'?
  private static boolean finalConstVarOrTypeAndComponentName_4_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "finalConstVarOrTypeAndComponentName_4_0")) return false;
    consumeToken(b, COVARIANT);
    return true;
  }

  // 'covariant'          type componentName
  private static boolean finalConstVarOrTypeAndComponentName_5(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "finalConstVarOrTypeAndComponentName_5")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = consumeToken(b, COVARIANT);
    r = r && type(b, l + 1);
    r = r && componentName(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  // type componentName
  private static boolean finalConstVarOrTypeAndComponentName_6(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "finalConstVarOrTypeAndComponentName_6")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = type(b, l + 1);
    r = r && componentName(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  /* ********************************************************** */
  // 'final' type? | 'const' type? | 'var' | 'void' | type
  static boolean finalConstVarVoidOrType(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "finalConstVarVoidOrType")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = finalConstVarVoidOrType_0(b, l + 1);
    if (!r) r = finalConstVarVoidOrType_1(b, l + 1);
    if (!r) r = consumeToken(b, VAR);
    if (!r) r = consumeToken(b, VOID);
    if (!r) r = type(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  // 'final' type?
  private static boolean finalConstVarVoidOrType_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "finalConstVarVoidOrType_0")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = consumeToken(b, FINAL);
    r = r && finalConstVarVoidOrType_0_1(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  // type?
  private static boolean finalConstVarVoidOrType_0_1(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "finalConstVarVoidOrType_0_1")) return false;
    type(b, l + 1);
    return true;
  }

  // 'const' type?
  private static boolean finalConstVarVoidOrType_1(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "finalConstVarVoidOrType_1")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = consumeToken(b, CONST);
    r = r && finalConstVarVoidOrType_1_1(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  // type?
  private static boolean finalConstVarVoidOrType_1_1(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "finalConstVarVoidOrType_1_1")) return false;
    type(b, l + 1);
    return true;
  }

  /* ********************************************************** */
  // 'final' | 'const'
  static boolean finalOrConst(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "finalOrConst")) return false;
    if (!nextTokenIs(b, "", CONST, FINAL)) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = consumeToken(b, FINAL);
    if (!r) r = consumeToken(b, CONST);
    exit_section_(b, m, null, r);
    return r;
  }

  /* ********************************************************** */
  // 'finally' block
  public static boolean finallyPart(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "finallyPart")) return false;
    if (!nextTokenIs(b, FINALLY)) return false;
    boolean r, p;
    Marker m = enter_section_(b, l, _NONE_, FINALLY_PART, null);
    r = consumeToken(b, FINALLY);
    p = r; // pin = 1
    r = r && block(b, l + 1);
    exit_section_(b, l, m, r, p, null);
    return r || p;
  }

  /* ********************************************************** */
  // (varAccessDeclaration | componentName) 'in' expression
  public static boolean forInPart(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "forInPart")) return false;
    boolean r;
    Marker m = enter_section_(b, l, _NONE_, FOR_IN_PART, "<for in part>");
    r = forInPart_0(b, l + 1);
    r = r && consumeToken(b, IN);
    r = r && expression(b, l + 1);
    exit_section_(b, l, m, r, false, null);
    return r;
  }

  // varAccessDeclaration | componentName
  private static boolean forInPart_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "forInPart_0")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = varAccessDeclaration(b, l + 1);
    if (!r) r = componentName(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  /* ********************************************************** */
  // forInPart
  //               | varDeclarationList (';' expression? (';' expressionList?)?)?
  //               | expressionList? (';' expression? (';' expressionList?)?)?
  public static boolean forLoopParts(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "forLoopParts")) return false;
    boolean r;
    Marker m = enter_section_(b, l, _NONE_, FOR_LOOP_PARTS, "<for loop parts>");
    r = forInPart(b, l + 1);
    if (!r) r = forLoopParts_1(b, l + 1);
    if (!r) r = forLoopParts_2(b, l + 1);
    exit_section_(b, l, m, r, false, for_loops_parts_recover_parser_);
    return r;
  }

  // varDeclarationList (';' expression? (';' expressionList?)?)?
  private static boolean forLoopParts_1(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "forLoopParts_1")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = varDeclarationList(b, l + 1);
    r = r && forLoopParts_1_1(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  // (';' expression? (';' expressionList?)?)?
  private static boolean forLoopParts_1_1(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "forLoopParts_1_1")) return false;
    forLoopParts_1_1_0(b, l + 1);
    return true;
  }

  // ';' expression? (';' expressionList?)?
  private static boolean forLoopParts_1_1_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "forLoopParts_1_1_0")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = consumeToken(b, SEMICOLON);
    r = r && forLoopParts_1_1_0_1(b, l + 1);
    r = r && forLoopParts_1_1_0_2(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  // expression?
  private static boolean forLoopParts_1_1_0_1(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "forLoopParts_1_1_0_1")) return false;
    expression(b, l + 1);
    return true;
  }

  // (';' expressionList?)?
  private static boolean forLoopParts_1_1_0_2(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "forLoopParts_1_1_0_2")) return false;
    forLoopParts_1_1_0_2_0(b, l + 1);
    return true;
  }

  // ';' expressionList?
  private static boolean forLoopParts_1_1_0_2_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "forLoopParts_1_1_0_2_0")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = consumeToken(b, SEMICOLON);
    r = r && forLoopParts_1_1_0_2_0_1(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  // expressionList?
  private static boolean forLoopParts_1_1_0_2_0_1(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "forLoopParts_1_1_0_2_0_1")) return false;
    expressionList(b, l + 1);
    return true;
  }

  // expressionList? (';' expression? (';' expressionList?)?)?
  private static boolean forLoopParts_2(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "forLoopParts_2")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = forLoopParts_2_0(b, l + 1);
    r = r && forLoopParts_2_1(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  // expressionList?
  private static boolean forLoopParts_2_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "forLoopParts_2_0")) return false;
    expressionList(b, l + 1);
    return true;
  }

  // (';' expression? (';' expressionList?)?)?
  private static boolean forLoopParts_2_1(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "forLoopParts_2_1")) return false;
    forLoopParts_2_1_0(b, l + 1);
    return true;
  }

  // ';' expression? (';' expressionList?)?
  private static boolean forLoopParts_2_1_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "forLoopParts_2_1_0")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = consumeToken(b, SEMICOLON);
    r = r && forLoopParts_2_1_0_1(b, l + 1);
    r = r && forLoopParts_2_1_0_2(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  // expression?
  private static boolean forLoopParts_2_1_0_1(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "forLoopParts_2_1_0_1")) return false;
    expression(b, l + 1);
    return true;
  }

  // (';' expressionList?)?
  private static boolean forLoopParts_2_1_0_2(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "forLoopParts_2_1_0_2")) return false;
    forLoopParts_2_1_0_2_0(b, l + 1);
    return true;
  }

  // ';' expressionList?
  private static boolean forLoopParts_2_1_0_2_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "forLoopParts_2_1_0_2_0")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = consumeToken(b, SEMICOLON);
    r = r && forLoopParts_2_1_0_2_0_1(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  // expressionList?
  private static boolean forLoopParts_2_1_0_2_0_1(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "forLoopParts_2_1_0_2_0_1")) return false;
    expressionList(b, l + 1);
    return true;
  }

  /* ********************************************************** */
  // '(' forLoopParts ')'
  public static boolean forLoopPartsInBraces(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "forLoopPartsInBraces")) return false;
    if (!nextTokenIs(b, LPAREN)) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = consumeToken(b, LPAREN);
    r = r && forLoopParts(b, l + 1);
    r = r && consumeToken(b, RPAREN);
    exit_section_(b, m, FOR_LOOP_PARTS_IN_BRACES, r);
    return r;
  }

  /* ********************************************************** */
  // 'await'? 'for' forLoopPartsInBraces statement
  public static boolean forStatement(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "forStatement")) return false;
    if (!nextTokenIs(b, "<for statement>", AWAIT, FOR)) return false;
    boolean r, p;
    Marker m = enter_section_(b, l, _NONE_, FOR_STATEMENT, "<for statement>");
    r = forStatement_0(b, l + 1);
    r = r && consumeToken(b, FOR);
    p = r; // pin = 2
    r = r && report_error_(b, forLoopPartsInBraces(b, l + 1));
    r = p && statement(b, l + 1) && r;
    exit_section_(b, l, m, r, p, null);
    return r || p;
  }

  // 'await'?
  private static boolean forStatement_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "forStatement_0")) return false;
    consumeToken(b, AWAIT);
    return true;
  }

  /* ********************************************************** */
  // !')'
  static boolean for_loops_parts_recover(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "for_loops_parts_recover")) return false;
    boolean r;
    Marker m = enter_section_(b, l, _NOT_);
    r = !consumeToken(b, RPAREN);
    exit_section_(b, l, m, r, false, null);
    return r;
  }

  /* ********************************************************** */
  // '(' ')' |
  //                         '(' normalFormalParameters (',' optionalFormalParameters)? ','? ')' |
  //                         '(' optionalFormalParameters ')'
  public static boolean formalParameterList(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "formalParameterList")) return false;
    if (!nextTokenIs(b, LPAREN)) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = parseTokens(b, 0, LPAREN, RPAREN);
    if (!r) r = formalParameterList_1(b, l + 1);
    if (!r) r = formalParameterList_2(b, l + 1);
    exit_section_(b, m, FORMAL_PARAMETER_LIST, r);
    return r;
  }

  // '(' normalFormalParameters (',' optionalFormalParameters)? ','? ')'
  private static boolean formalParameterList_1(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "formalParameterList_1")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = consumeToken(b, LPAREN);
    r = r && normalFormalParameters(b, l + 1);
    r = r && formalParameterList_1_2(b, l + 1);
    r = r && formalParameterList_1_3(b, l + 1);
    r = r && consumeToken(b, RPAREN);
    exit_section_(b, m, null, r);
    return r;
  }

  // (',' optionalFormalParameters)?
  private static boolean formalParameterList_1_2(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "formalParameterList_1_2")) return false;
    formalParameterList_1_2_0(b, l + 1);
    return true;
  }

  // ',' optionalFormalParameters
  private static boolean formalParameterList_1_2_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "formalParameterList_1_2_0")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = consumeToken(b, COMMA);
    r = r && optionalFormalParameters(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  // ','?
  private static boolean formalParameterList_1_3(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "formalParameterList_1_3")) return false;
    consumeToken(b, COMMA);
    return true;
  }

  // '(' optionalFormalParameters ')'
  private static boolean formalParameterList_2(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "formalParameterList_2")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = consumeToken(b, LPAREN);
    r = r && optionalFormalParameters(b, l + 1);
    r = r && consumeToken(b, RPAREN);
    exit_section_(b, m, null, r);
    return r;
  }

  /* ********************************************************** */
  // arrowBodyWithSemi | <<blockBodyWrapper>>
  public static boolean functionBody(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "functionBody")) return false;
    boolean r;
    Marker m = enter_section_(b, l, _NONE_, FUNCTION_BODY, "<function body>");
    r = arrowBodyWithSemi(b, l + 1);
    if (!r) r = blockBodyWrapper(b, l + 1);
    exit_section_(b, l, m, r, false, null);
    return r;
  }

  /* ********************************************************** */
  // 'native' functionBody
  //                                | functionNative
  //                                | functionBody
  static boolean functionBodyOrNative(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "functionBodyOrNative")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = functionBodyOrNative_0(b, l + 1);
    if (!r) r = functionNative(b, l + 1);
    if (!r) r = functionBody(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  // 'native' functionBody
  private static boolean functionBodyOrNative_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "functionBodyOrNative_0")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = consumeToken(b, NATIVE);
    r = r && functionBody(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  /* ********************************************************** */
  // metadata*  (returnType componentName typeParameters? formalParameterList | componentName typeParameters? formalParameterList) functionBody
  public static boolean functionDeclarationWithBody(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "functionDeclarationWithBody")) return false;
    boolean r;
    Marker m = enter_section_(b, l, _NONE_, FUNCTION_DECLARATION_WITH_BODY, "<function declaration with body>");
    r = functionDeclarationWithBody_0(b, l + 1);
    r = r && functionDeclarationWithBody_1(b, l + 1);
    r = r && functionBody(b, l + 1);
    exit_section_(b, l, m, r, false, null);
    return r;
  }

  // metadata*
  private static boolean functionDeclarationWithBody_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "functionDeclarationWithBody_0")) return false;
    int c = current_position_(b);
    while (true) {
      if (!metadata(b, l + 1)) break;
      if (!empty_element_parsed_guard_(b, "functionDeclarationWithBody_0", c)) break;
      c = current_position_(b);
    }
    return true;
  }

  // returnType componentName typeParameters? formalParameterList | componentName typeParameters? formalParameterList
  private static boolean functionDeclarationWithBody_1(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "functionDeclarationWithBody_1")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = functionDeclarationWithBody_1_0(b, l + 1);
    if (!r) r = functionDeclarationWithBody_1_1(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  // returnType componentName typeParameters? formalParameterList
  private static boolean functionDeclarationWithBody_1_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "functionDeclarationWithBody_1_0")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = returnType(b, l + 1);
    r = r && componentName(b, l + 1);
    r = r && functionDeclarationWithBody_1_0_2(b, l + 1);
    r = r && formalParameterList(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  // typeParameters?
  private static boolean functionDeclarationWithBody_1_0_2(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "functionDeclarationWithBody_1_0_2")) return false;
    typeParameters(b, l + 1);
    return true;
  }

  // componentName typeParameters? formalParameterList
  private static boolean functionDeclarationWithBody_1_1(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "functionDeclarationWithBody_1_1")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = componentName(b, l + 1);
    r = r && functionDeclarationWithBody_1_1_1(b, l + 1);
    r = r && formalParameterList(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  // typeParameters?
  private static boolean functionDeclarationWithBody_1_1_1(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "functionDeclarationWithBody_1_1_1")) return false;
    typeParameters(b, l + 1);
    return true;
  }

  /* ********************************************************** */
  // metadata* 'external'? (returnType componentName typeParameters? formalParameterList | componentName typeParameters? formalParameterList) ( ';' | functionBodyOrNative)
  public static boolean functionDeclarationWithBodyOrNative(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "functionDeclarationWithBodyOrNative")) return false;
    boolean r;
    Marker m = enter_section_(b, l, _NONE_, FUNCTION_DECLARATION_WITH_BODY_OR_NATIVE, "<function declaration with body or native>");
    r = functionDeclarationWithBodyOrNative_0(b, l + 1);
    r = r && functionDeclarationWithBodyOrNative_1(b, l + 1);
    r = r && functionDeclarationWithBodyOrNative_2(b, l + 1);
    r = r && functionDeclarationWithBodyOrNative_3(b, l + 1);
    exit_section_(b, l, m, r, false, null);
    return r;
  }

  // metadata*
  private static boolean functionDeclarationWithBodyOrNative_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "functionDeclarationWithBodyOrNative_0")) return false;
    int c = current_position_(b);
    while (true) {
      if (!metadata(b, l + 1)) break;
      if (!empty_element_parsed_guard_(b, "functionDeclarationWithBodyOrNative_0", c)) break;
      c = current_position_(b);
    }
    return true;
  }

  // 'external'?
  private static boolean functionDeclarationWithBodyOrNative_1(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "functionDeclarationWithBodyOrNative_1")) return false;
    consumeToken(b, EXTERNAL);
    return true;
  }

  // returnType componentName typeParameters? formalParameterList | componentName typeParameters? formalParameterList
  private static boolean functionDeclarationWithBodyOrNative_2(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "functionDeclarationWithBodyOrNative_2")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = functionDeclarationWithBodyOrNative_2_0(b, l + 1);
    if (!r) r = functionDeclarationWithBodyOrNative_2_1(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  // returnType componentName typeParameters? formalParameterList
  private static boolean functionDeclarationWithBodyOrNative_2_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "functionDeclarationWithBodyOrNative_2_0")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = returnType(b, l + 1);
    r = r && componentName(b, l + 1);
    r = r && functionDeclarationWithBodyOrNative_2_0_2(b, l + 1);
    r = r && formalParameterList(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  // typeParameters?
  private static boolean functionDeclarationWithBodyOrNative_2_0_2(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "functionDeclarationWithBodyOrNative_2_0_2")) return false;
    typeParameters(b, l + 1);
    return true;
  }

  // componentName typeParameters? formalParameterList
  private static boolean functionDeclarationWithBodyOrNative_2_1(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "functionDeclarationWithBodyOrNative_2_1")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = componentName(b, l + 1);
    r = r && functionDeclarationWithBodyOrNative_2_1_1(b, l + 1);
    r = r && formalParameterList(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  // typeParameters?
  private static boolean functionDeclarationWithBodyOrNative_2_1_1(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "functionDeclarationWithBodyOrNative_2_1_1")) return false;
    typeParameters(b, l + 1);
    return true;
  }

  // ';' | functionBodyOrNative
  private static boolean functionDeclarationWithBodyOrNative_3(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "functionDeclarationWithBodyOrNative_3")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = consumeToken(b, SEMICOLON);
    if (!r) r = functionBodyOrNative(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  /* ********************************************************** */
  // typeParameters? formalParameterList functionExpressionBody
  public static boolean functionExpression(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "functionExpression")) return false;
    if (!nextTokenIs(b, "<function expression>", LPAREN, LT)) return false;
    boolean r;
    Marker m = enter_section_(b, l, _NONE_, FUNCTION_EXPRESSION, "<function expression>");
    r = functionExpression_0(b, l + 1);
    r = r && formalParameterList(b, l + 1);
    r = r && functionExpressionBody(b, l + 1);
    exit_section_(b, l, m, r, false, null);
    return r;
  }

  // typeParameters?
  private static boolean functionExpression_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "functionExpression_0")) return false;
    typeParameters(b, l + 1);
    return true;
  }

  /* ********************************************************** */
  // <<arrowBodyWrapper>> | <<blockBodyWrapper>>
  public static boolean functionExpressionBody(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "functionExpressionBody")) return false;
    boolean r;
    Marker m = enter_section_(b, l, _NONE_, FUNCTION_EXPRESSION_BODY, "<function expression body>");
    r = arrowBodyWrapper(b, l + 1);
    if (!r) r = blockBodyWrapper(b, l + 1);
    exit_section_(b, l, m, r, false, null);
    return r;
  }

  /* ********************************************************** */
  // !functionTypeWrapper (metadata*                         componentName typeParameters? formalParameterList |
  //                                                   metadata* 'covariant'? returnType componentName typeParameters? formalParameterList |
  //                                                   metadata* 'covariant'             componentName typeParameters? formalParameterList)
  public static boolean functionFormalParameter(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "functionFormalParameter")) return false;
    boolean r;
    Marker m = enter_section_(b, l, _NONE_, FUNCTION_FORMAL_PARAMETER, "<function formal parameter>");
    r = functionFormalParameter_0(b, l + 1);
    r = r && functionFormalParameter_1(b, l + 1);
    exit_section_(b, l, m, r, false, null);
    return r;
  }

  // !functionTypeWrapper
  private static boolean functionFormalParameter_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "functionFormalParameter_0")) return false;
    boolean r;
    Marker m = enter_section_(b, l, _NOT_);
    r = !functionTypeWrapper(b, l + 1);
    exit_section_(b, l, m, r, false, null);
    return r;
  }

  // metadata*                         componentName typeParameters? formalParameterList |
  //                                                   metadata* 'covariant'? returnType componentName typeParameters? formalParameterList |
  //                                                   metadata* 'covariant'             componentName typeParameters? formalParameterList
  private static boolean functionFormalParameter_1(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "functionFormalParameter_1")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = functionFormalParameter_1_0(b, l + 1);
    if (!r) r = functionFormalParameter_1_1(b, l + 1);
    if (!r) r = functionFormalParameter_1_2(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  // metadata*                         componentName typeParameters? formalParameterList
  private static boolean functionFormalParameter_1_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "functionFormalParameter_1_0")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = functionFormalParameter_1_0_0(b, l + 1);
    r = r && componentName(b, l + 1);
    r = r && functionFormalParameter_1_0_2(b, l + 1);
    r = r && formalParameterList(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  // metadata*
  private static boolean functionFormalParameter_1_0_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "functionFormalParameter_1_0_0")) return false;
    int c = current_position_(b);
    while (true) {
      if (!metadata(b, l + 1)) break;
      if (!empty_element_parsed_guard_(b, "functionFormalParameter_1_0_0", c)) break;
      c = current_position_(b);
    }
    return true;
  }

  // typeParameters?
  private static boolean functionFormalParameter_1_0_2(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "functionFormalParameter_1_0_2")) return false;
    typeParameters(b, l + 1);
    return true;
  }

  // metadata* 'covariant'? returnType componentName typeParameters? formalParameterList
  private static boolean functionFormalParameter_1_1(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "functionFormalParameter_1_1")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = functionFormalParameter_1_1_0(b, l + 1);
    r = r && functionFormalParameter_1_1_1(b, l + 1);
    r = r && returnType(b, l + 1);
    r = r && componentName(b, l + 1);
    r = r && functionFormalParameter_1_1_4(b, l + 1);
    r = r && formalParameterList(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  // metadata*
  private static boolean functionFormalParameter_1_1_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "functionFormalParameter_1_1_0")) return false;
    int c = current_position_(b);
    while (true) {
      if (!metadata(b, l + 1)) break;
      if (!empty_element_parsed_guard_(b, "functionFormalParameter_1_1_0", c)) break;
      c = current_position_(b);
    }
    return true;
  }

  // 'covariant'?
  private static boolean functionFormalParameter_1_1_1(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "functionFormalParameter_1_1_1")) return false;
    consumeToken(b, COVARIANT);
    return true;
  }

  // typeParameters?
  private static boolean functionFormalParameter_1_1_4(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "functionFormalParameter_1_1_4")) return false;
    typeParameters(b, l + 1);
    return true;
  }

  // metadata* 'covariant'             componentName typeParameters? formalParameterList
  private static boolean functionFormalParameter_1_2(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "functionFormalParameter_1_2")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = functionFormalParameter_1_2_0(b, l + 1);
    r = r && consumeToken(b, COVARIANT);
    r = r && componentName(b, l + 1);
    r = r && functionFormalParameter_1_2_3(b, l + 1);
    r = r && formalParameterList(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  // metadata*
  private static boolean functionFormalParameter_1_2_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "functionFormalParameter_1_2_0")) return false;
    int c = current_position_(b);
    while (true) {
      if (!metadata(b, l + 1)) break;
      if (!empty_element_parsed_guard_(b, "functionFormalParameter_1_2_0", c)) break;
      c = current_position_(b);
    }
    return true;
  }

  // typeParameters?
  private static boolean functionFormalParameter_1_2_3(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "functionFormalParameter_1_2_3")) return false;
    typeParameters(b, l + 1);
    return true;
  }

  /* ********************************************************** */
  // 'native' (stringLiteralExpression ';' | ';' | stringLiteralExpression functionBody)
  static boolean functionNative(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "functionNative")) return false;
    if (!nextTokenIs(b, NATIVE)) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = consumeToken(b, NATIVE);
    r = r && functionNative_1(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  // stringLiteralExpression ';' | ';' | stringLiteralExpression functionBody
  private static boolean functionNative_1(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "functionNative_1")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = functionNative_1_0(b, l + 1);
    if (!r) r = consumeToken(b, SEMICOLON);
    if (!r) r = functionNative_1_2(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  // stringLiteralExpression ';'
  private static boolean functionNative_1_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "functionNative_1_0")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = stringLiteralExpression(b, l + 1);
    r = r && consumeToken(b, SEMICOLON);
    exit_section_(b, m, null, r);
    return r;
  }

  // stringLiteralExpression functionBody
  private static boolean functionNative_1_2(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "functionNative_1_2")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = stringLiteralExpression(b, l + 1);
    r = r && functionBody(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  /* ********************************************************** */
  // returnType componentName | componentName
  static boolean functionPrefix(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "functionPrefix")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = functionPrefix_0(b, l + 1);
    if (!r) r = componentName(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  // returnType componentName
  private static boolean functionPrefix_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "functionPrefix_0")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = returnType(b, l + 1);
    r = r && componentName(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  /* ********************************************************** */
  // metadata* 'typedef' functionPrefix typeParameters? formalParameterList ';'?
  //                     | metadata* 'typedef' componentName typeParameters? '=' functionTypeWrapper ';'?
  public static boolean functionTypeAlias(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "functionTypeAlias")) return false;
    if (!nextTokenIs(b, "<function type alias>", AT, TYPEDEF)) return false;
    boolean r;
    Marker m = enter_section_(b, l, _NONE_, FUNCTION_TYPE_ALIAS, "<function type alias>");
    r = functionTypeAlias_0(b, l + 1);
    if (!r) r = functionTypeAlias_1(b, l + 1);
    exit_section_(b, l, m, r, false, null);
    return r;
  }

  // metadata* 'typedef' functionPrefix typeParameters? formalParameterList ';'?
  private static boolean functionTypeAlias_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "functionTypeAlias_0")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = functionTypeAlias_0_0(b, l + 1);
    r = r && consumeToken(b, TYPEDEF);
    r = r && functionPrefix(b, l + 1);
    r = r && functionTypeAlias_0_3(b, l + 1);
    r = r && formalParameterList(b, l + 1);
    r = r && functionTypeAlias_0_5(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  // metadata*
  private static boolean functionTypeAlias_0_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "functionTypeAlias_0_0")) return false;
    int c = current_position_(b);
    while (true) {
      if (!metadata(b, l + 1)) break;
      if (!empty_element_parsed_guard_(b, "functionTypeAlias_0_0", c)) break;
      c = current_position_(b);
    }
    return true;
  }

  // typeParameters?
  private static boolean functionTypeAlias_0_3(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "functionTypeAlias_0_3")) return false;
    typeParameters(b, l + 1);
    return true;
  }

  // ';'?
  private static boolean functionTypeAlias_0_5(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "functionTypeAlias_0_5")) return false;
    consumeToken(b, SEMICOLON);
    return true;
  }

  // metadata* 'typedef' componentName typeParameters? '=' functionTypeWrapper ';'?
  private static boolean functionTypeAlias_1(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "functionTypeAlias_1")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = functionTypeAlias_1_0(b, l + 1);
    r = r && consumeToken(b, TYPEDEF);
    r = r && componentName(b, l + 1);
    r = r && functionTypeAlias_1_3(b, l + 1);
    r = r && consumeToken(b, EQ);
    r = r && functionTypeWrapper(b, l + 1);
    r = r && functionTypeAlias_1_6(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  // metadata*
  private static boolean functionTypeAlias_1_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "functionTypeAlias_1_0")) return false;
    int c = current_position_(b);
    while (true) {
      if (!metadata(b, l + 1)) break;
      if (!empty_element_parsed_guard_(b, "functionTypeAlias_1_0", c)) break;
      c = current_position_(b);
    }
    return true;
  }

  // typeParameters?
  private static boolean functionTypeAlias_1_3(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "functionTypeAlias_1_3")) return false;
    typeParameters(b, l + 1);
    return true;
  }

  // ';'?
  private static boolean functionTypeAlias_1_6(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "functionTypeAlias_1_6")) return false;
    consumeToken(b, SEMICOLON);
    return true;
  }

  /* ********************************************************** */
  // (voidTypeFunctionType | untypedFunctionType | simpleType) typedFunctionType+ | untypedFunctionType
  static boolean functionTypeWrapper(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "functionTypeWrapper")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = functionTypeWrapper_0(b, l + 1);
    if (!r) r = untypedFunctionType(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  // (voidTypeFunctionType | untypedFunctionType | simpleType) typedFunctionType+
  private static boolean functionTypeWrapper_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "functionTypeWrapper_0")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = functionTypeWrapper_0_0(b, l + 1);
    r = r && functionTypeWrapper_0_1(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  // voidTypeFunctionType | untypedFunctionType | simpleType
  private static boolean functionTypeWrapper_0_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "functionTypeWrapper_0_0")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = voidTypeFunctionType(b, l + 1);
    if (!r) r = untypedFunctionType(b, l + 1);
    if (!r) r = simpleType(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  // typedFunctionType+
  private static boolean functionTypeWrapper_0_1(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "functionTypeWrapper_0_1")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = typedFunctionType(b, l + 1);
    int c = current_position_(b);
    while (r) {
      if (!typedFunctionType(b, l + 1)) break;
      if (!empty_element_parsed_guard_(b, "functionTypeWrapper_0_1", c)) break;
      c = current_position_(b);
    }
    exit_section_(b, m, null, r);
    return r;
  }

  /* ********************************************************** */
  // getterDeclarationWithReturnType | getterDeclarationWithoutReturnType
  public static boolean getterDeclaration(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "getterDeclaration")) return false;
    boolean r;
    Marker m = enter_section_(b, l, _NONE_, GETTER_DECLARATION, "<getter declaration>");
    r = getterDeclarationWithReturnType(b, l + 1);
    if (!r) r = getterDeclarationWithoutReturnType(b, l + 1);
    exit_section_(b, l, m, r, false, null);
    return r;
  }

  /* ********************************************************** */
  // metadata* ('external' | 'static')* returnType 'get' componentName formalParameterList? (';' | functionBodyOrNative)
  static boolean getterDeclarationWithReturnType(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "getterDeclarationWithReturnType")) return false;
    boolean r, p;
    Marker m = enter_section_(b, l, _NONE_);
    r = getterDeclarationWithReturnType_0(b, l + 1);
    r = r && getterDeclarationWithReturnType_1(b, l + 1);
    r = r && returnType(b, l + 1);
    r = r && consumeToken(b, GET);
    r = r && componentName(b, l + 1);
    p = r; // pin = 5
    r = r && report_error_(b, getterDeclarationWithReturnType_5(b, l + 1));
    r = p && getterDeclarationWithReturnType_6(b, l + 1) && r;
    exit_section_(b, l, m, r, p, null);
    return r || p;
  }

  // metadata*
  private static boolean getterDeclarationWithReturnType_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "getterDeclarationWithReturnType_0")) return false;
    int c = current_position_(b);
    while (true) {
      if (!metadata(b, l + 1)) break;
      if (!empty_element_parsed_guard_(b, "getterDeclarationWithReturnType_0", c)) break;
      c = current_position_(b);
    }
    return true;
  }

  // ('external' | 'static')*
  private static boolean getterDeclarationWithReturnType_1(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "getterDeclarationWithReturnType_1")) return false;
    int c = current_position_(b);
    while (true) {
      if (!getterDeclarationWithReturnType_1_0(b, l + 1)) break;
      if (!empty_element_parsed_guard_(b, "getterDeclarationWithReturnType_1", c)) break;
      c = current_position_(b);
    }
    return true;
  }

  // 'external' | 'static'
  private static boolean getterDeclarationWithReturnType_1_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "getterDeclarationWithReturnType_1_0")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = consumeToken(b, EXTERNAL);
    if (!r) r = consumeToken(b, STATIC);
    exit_section_(b, m, null, r);
    return r;
  }

  // formalParameterList?
  private static boolean getterDeclarationWithReturnType_5(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "getterDeclarationWithReturnType_5")) return false;
    formalParameterList(b, l + 1);
    return true;
  }

  // ';' | functionBodyOrNative
  private static boolean getterDeclarationWithReturnType_6(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "getterDeclarationWithReturnType_6")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = consumeToken(b, SEMICOLON);
    if (!r) r = functionBodyOrNative(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  /* ********************************************************** */
  // metadata* ('external' | 'static')*            'get' componentName formalParameterList? (';' | functionBodyOrNative)
  static boolean getterDeclarationWithoutReturnType(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "getterDeclarationWithoutReturnType")) return false;
    if (!nextTokenIs(b, "", AT, EXTERNAL, GET, STATIC)) return false;
    boolean r, p;
    Marker m = enter_section_(b, l, _NONE_);
    r = getterDeclarationWithoutReturnType_0(b, l + 1);
    r = r && getterDeclarationWithoutReturnType_1(b, l + 1);
    r = r && consumeToken(b, GET);
    r = r && componentName(b, l + 1);
    p = r; // pin = 4
    r = r && report_error_(b, getterDeclarationWithoutReturnType_4(b, l + 1));
    r = p && getterDeclarationWithoutReturnType_5(b, l + 1) && r;
    exit_section_(b, l, m, r, p, null);
    return r || p;
  }

  // metadata*
  private static boolean getterDeclarationWithoutReturnType_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "getterDeclarationWithoutReturnType_0")) return false;
    int c = current_position_(b);
    while (true) {
      if (!metadata(b, l + 1)) break;
      if (!empty_element_parsed_guard_(b, "getterDeclarationWithoutReturnType_0", c)) break;
      c = current_position_(b);
    }
    return true;
  }

  // ('external' | 'static')*
  private static boolean getterDeclarationWithoutReturnType_1(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "getterDeclarationWithoutReturnType_1")) return false;
    int c = current_position_(b);
    while (true) {
      if (!getterDeclarationWithoutReturnType_1_0(b, l + 1)) break;
      if (!empty_element_parsed_guard_(b, "getterDeclarationWithoutReturnType_1", c)) break;
      c = current_position_(b);
    }
    return true;
  }

  // 'external' | 'static'
  private static boolean getterDeclarationWithoutReturnType_1_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "getterDeclarationWithoutReturnType_1_0")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = consumeToken(b, EXTERNAL);
    if (!r) r = consumeToken(b, STATIC);
    exit_section_(b, m, null, r);
    return r;
  }

  // formalParameterList?
  private static boolean getterDeclarationWithoutReturnType_4(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "getterDeclarationWithoutReturnType_4")) return false;
    formalParameterList(b, l + 1);
    return true;
  }

  // ';' | functionBodyOrNative
  private static boolean getterDeclarationWithoutReturnType_5(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "getterDeclarationWithoutReturnType_5")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = consumeToken(b, SEMICOLON);
    if (!r) r = functionBodyOrNative(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  /* ********************************************************** */
  // getterDeclaration | setterDeclaration
  static boolean getterOrSetterDeclaration(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "getterOrSetterDeclaration")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = getterDeclaration(b, l + 1);
    if (!r) r = setterDeclaration(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  /* ********************************************************** */
  // 'hide' libraryReferenceList
  public static boolean hideCombinator(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "hideCombinator")) return false;
    if (!nextTokenIs(b, HIDE)) return false;
    boolean r, p;
    Marker m = enter_section_(b, l, _NONE_, HIDE_COMBINATOR, null);
    r = consumeToken(b, HIDE);
    p = r; // pin = 1
    r = r && libraryReferenceList(b, l + 1);
    exit_section_(b, l, m, r, p, null);
    return r || p;
  }

  /* ********************************************************** */
  // IDENTIFIER
  public static boolean id(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "id")) return false;
    if (!nextTokenIs(b, IDENTIFIER)) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = consumeToken(b, IDENTIFIER);
    exit_section_(b, m, ID, r);
    return r;
  }

  /* ********************************************************** */
  // '??' logicOrExpressionWrapper
  public static boolean ifNullExpression(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "ifNullExpression")) return false;
    if (!nextTokenIs(b, QUEST_QUEST)) return false;
    boolean r;
    Marker m = enter_section_(b, l, _LEFT_, IF_NULL_EXPRESSION, null);
    r = consumeToken(b, QUEST_QUEST);
    r = r && logicOrExpressionWrapper(b, l + 1);
    exit_section_(b, l, m, r, false, null);
    return r;
  }

  /* ********************************************************** */
  // logicOrExpressionWrapper ifNullExpression*
  static boolean ifNullExpressionWrapper(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "ifNullExpressionWrapper")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = logicOrExpressionWrapper(b, l + 1);
    r = r && ifNullExpressionWrapper_1(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  // ifNullExpression*
  private static boolean ifNullExpressionWrapper_1(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "ifNullExpressionWrapper_1")) return false;
    int c = current_position_(b);
    while (true) {
      if (!ifNullExpression(b, l + 1)) break;
      if (!empty_element_parsed_guard_(b, "ifNullExpressionWrapper_1", c)) break;
      c = current_position_(b);
    }
    return true;
  }

  /* ********************************************************** */
  // 'if' '(' expressionWithRecoverUntilParen ')' statement ('else' statement)?
  public static boolean ifStatement(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "ifStatement")) return false;
    if (!nextTokenIs(b, IF)) return false;
    boolean r, p;
    Marker m = enter_section_(b, l, _NONE_, IF_STATEMENT, null);
    r = consumeTokens(b, 1, IF, LPAREN);
    p = r; // pin = 1
    r = r && report_error_(b, expressionWithRecoverUntilParen(b, l + 1));
    r = p && report_error_(b, consumeToken(b, RPAREN)) && r;
    r = p && report_error_(b, statement(b, l + 1)) && r;
    r = p && ifStatement_5(b, l + 1) && r;
    exit_section_(b, l, m, r, p, null);
    return r || p;
  }

  // ('else' statement)?
  private static boolean ifStatement_5(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "ifStatement_5")) return false;
    ifStatement_5_0(b, l + 1);
    return true;
  }

  // 'else' statement
  private static boolean ifStatement_5_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "ifStatement_5_0")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = consumeToken(b, ELSE);
    r = r && statement(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  /* ********************************************************** */
  // 'if' '(' dottedName ('==' stringLiteralExpression)? ')' stringLiteralExpression
  static boolean importConfig(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "importConfig")) return false;
    if (!nextTokenIs(b, IF)) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = consumeTokens(b, 0, IF, LPAREN);
    r = r && dottedName(b, l + 1);
    r = r && importConfig_3(b, l + 1);
    r = r && consumeToken(b, RPAREN);
    r = r && stringLiteralExpression(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  // ('==' stringLiteralExpression)?
  private static boolean importConfig_3(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "importConfig_3")) return false;
    importConfig_3_0(b, l + 1);
    return true;
  }

  // '==' stringLiteralExpression
  private static boolean importConfig_3_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "importConfig_3_0")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = consumeToken(b, EQ_EQ);
    r = r && stringLiteralExpression(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  /* ********************************************************** */
  // metadata* 'import' uriElement importConfig* ('deferred'? 'as' componentName )? combinator* ';'
  public static boolean importStatement(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "importStatement")) return false;
    if (!nextTokenIs(b, "<import statement>", AT, IMPORT)) return false;
    boolean r, p;
    Marker m = enter_section_(b, l, _NONE_, IMPORT_STATEMENT, "<import statement>");
    r = importStatement_0(b, l + 1);
    r = r && consumeToken(b, IMPORT);
    r = r && uriElement(b, l + 1);
    p = r; // pin = 3
    r = r && report_error_(b, importStatement_3(b, l + 1));
    r = p && report_error_(b, importStatement_4(b, l + 1)) && r;
    r = p && report_error_(b, importStatement_5(b, l + 1)) && r;
    r = p && consumeToken(b, SEMICOLON) && r;
    exit_section_(b, l, m, r, p, null);
    return r || p;
  }

  // metadata*
  private static boolean importStatement_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "importStatement_0")) return false;
    int c = current_position_(b);
    while (true) {
      if (!metadata(b, l + 1)) break;
      if (!empty_element_parsed_guard_(b, "importStatement_0", c)) break;
      c = current_position_(b);
    }
    return true;
  }

  // importConfig*
  private static boolean importStatement_3(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "importStatement_3")) return false;
    int c = current_position_(b);
    while (true) {
      if (!importConfig(b, l + 1)) break;
      if (!empty_element_parsed_guard_(b, "importStatement_3", c)) break;
      c = current_position_(b);
    }
    return true;
  }

  // ('deferred'? 'as' componentName )?
  private static boolean importStatement_4(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "importStatement_4")) return false;
    importStatement_4_0(b, l + 1);
    return true;
  }

  // 'deferred'? 'as' componentName
  private static boolean importStatement_4_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "importStatement_4_0")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = importStatement_4_0_0(b, l + 1);
    r = r && consumeToken(b, AS);
    r = r && componentName(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  // 'deferred'?
  private static boolean importStatement_4_0_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "importStatement_4_0_0")) return false;
    consumeToken(b, DEFERRED);
    return true;
  }

  // combinator*
  private static boolean importStatement_5(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "importStatement_5")) return false;
    int c = current_position_(b);
    while (true) {
      if (!combinator(b, l + 1)) break;
      if (!empty_element_parsed_guard_(b, "importStatement_5", c)) break;
      c = current_position_(b);
    }
    return true;
  }

  /* ********************************************************** */
  // metadata* ('external' | 'static' | 'final' | 'const' | 'covariant')* type | metadata+
  public static boolean incompleteDeclaration(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "incompleteDeclaration")) return false;
    boolean r;
    Marker m = enter_section_(b, l, _NONE_, INCOMPLETE_DECLARATION, "<incomplete declaration>");
    r = incompleteDeclaration_0(b, l + 1);
    if (!r) r = incompleteDeclaration_1(b, l + 1);
    exit_section_(b, l, m, r, false, null);
    return r;
  }

  // metadata* ('external' | 'static' | 'final' | 'const' | 'covariant')* type
  private static boolean incompleteDeclaration_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "incompleteDeclaration_0")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = incompleteDeclaration_0_0(b, l + 1);
    r = r && incompleteDeclaration_0_1(b, l + 1);
    r = r && type(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  // metadata*
  private static boolean incompleteDeclaration_0_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "incompleteDeclaration_0_0")) return false;
    int c = current_position_(b);
    while (true) {
      if (!metadata(b, l + 1)) break;
      if (!empty_element_parsed_guard_(b, "incompleteDeclaration_0_0", c)) break;
      c = current_position_(b);
    }
    return true;
  }

  // ('external' | 'static' | 'final' | 'const' | 'covariant')*
  private static boolean incompleteDeclaration_0_1(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "incompleteDeclaration_0_1")) return false;
    int c = current_position_(b);
    while (true) {
      if (!incompleteDeclaration_0_1_0(b, l + 1)) break;
      if (!empty_element_parsed_guard_(b, "incompleteDeclaration_0_1", c)) break;
      c = current_position_(b);
    }
    return true;
  }

  // 'external' | 'static' | 'final' | 'const' | 'covariant'
  private static boolean incompleteDeclaration_0_1_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "incompleteDeclaration_0_1_0")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = consumeToken(b, EXTERNAL);
    if (!r) r = consumeToken(b, STATIC);
    if (!r) r = consumeToken(b, FINAL);
    if (!r) r = consumeToken(b, CONST);
    if (!r) r = consumeToken(b, COVARIANT);
    exit_section_(b, m, null, r);
    return r;
  }

  // metadata+
  private static boolean incompleteDeclaration_1(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "incompleteDeclaration_1")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = metadata(b, l + 1);
    int c = current_position_(b);
    while (r) {
      if (!metadata(b, l + 1)) break;
      if (!empty_element_parsed_guard_(b, "incompleteDeclaration_1", c)) break;
      c = current_position_(b);
    }
    exit_section_(b, m, null, r);
    return r;
  }

  /* ********************************************************** */
  // '<' + <<nonStrictID>> + '>' <<nonStrictID>>
  static boolean incorrectNormalFormalParameter(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "incorrectNormalFormalParameter")) return false;
    if (!nextTokenIs(b, LT)) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = incorrectNormalFormalParameter_0(b, l + 1);
    r = r && incorrectNormalFormalParameter_1(b, l + 1);
    r = r && consumeToken(b, GT);
    r = r && nonStrictID(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  // '<' +
  private static boolean incorrectNormalFormalParameter_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "incorrectNormalFormalParameter_0")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = consumeToken(b, LT);
    int c = current_position_(b);
    while (r) {
      if (!consumeToken(b, LT)) break;
      if (!empty_element_parsed_guard_(b, "incorrectNormalFormalParameter_0", c)) break;
      c = current_position_(b);
    }
    exit_section_(b, m, null, r);
    return r;
  }

  // <<nonStrictID>> +
  private static boolean incorrectNormalFormalParameter_1(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "incorrectNormalFormalParameter_1")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = nonStrictID(b, l + 1);
    int c = current_position_(b);
    while (r) {
      if (!nonStrictID(b, l + 1)) break;
      if (!empty_element_parsed_guard_(b, "incorrectNormalFormalParameter_1", c)) break;
      c = current_position_(b);
    }
    exit_section_(b, m, null, r);
    return r;
  }

  /* ********************************************************** */
  // ':' superCallOrFieldInitializer (',' superCallOrFieldInitializer)*
  public static boolean initializers(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "initializers")) return false;
    if (!nextTokenIs(b, COLON)) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = consumeToken(b, COLON);
    r = r && superCallOrFieldInitializer(b, l + 1);
    r = r && initializers_2(b, l + 1);
    exit_section_(b, m, INITIALIZERS, r);
    return r;
  }

  // (',' superCallOrFieldInitializer)*
  private static boolean initializers_2(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "initializers_2")) return false;
    int c = current_position_(b);
    while (true) {
      if (!initializers_2_0(b, l + 1)) break;
      if (!empty_element_parsed_guard_(b, "initializers_2", c)) break;
      c = current_position_(b);
    }
    return true;
  }

  // ',' superCallOrFieldInitializer
  private static boolean initializers_2_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "initializers_2_0")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = consumeToken(b, COMMA);
    r = r && superCallOrFieldInitializer(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  /* ********************************************************** */
  // 'implements' typeList
  public static boolean interfaces(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "interfaces")) return false;
    if (!nextTokenIs(b, IMPLEMENTS)) return false;
    boolean r, p;
    Marker m = enter_section_(b, l, _NONE_, INTERFACES, null);
    r = consumeToken(b, IMPLEMENTS);
    p = r; // pin = 1
    r = r && typeList(b, l + 1);
    exit_section_(b, l, m, r, p, null);
    return r || p;
  }

  /* ********************************************************** */
  // 'is' '!'? type
  public static boolean isExpression(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "isExpression")) return false;
    if (!nextTokenIs(b, IS)) return false;
    boolean r;
    Marker m = enter_section_(b, l, _LEFT_, IS_EXPRESSION, null);
    r = consumeToken(b, IS);
    r = r && isExpression_1(b, l + 1);
    r = r && type(b, l + 1);
    exit_section_(b, l, m, r, false, null);
    return r;
  }

  // '!'?
  private static boolean isExpression_1(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "isExpression_1")) return false;
    consumeToken(b, NOT);
    return true;
  }

  /* ********************************************************** */
  // componentName ':'
  public static boolean label(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "label")) return false;
    boolean r;
    Marker m = enter_section_(b, l, _NONE_, LABEL, "<label>");
    r = componentName(b, l + 1);
    r = r && consumeToken(b, COLON);
    exit_section_(b, l, m, r, false, null);
    return r;
  }

  /* ********************************************************** */
  // <<lazyParseableBlockImpl>>
  static boolean lazyParseableBlock(PsiBuilder b, int l) {
    return lazyParseableBlockImpl(b, l + 1);
  }

  /* ********************************************************** */
  // << nonStrictID >>
  public static boolean libraryComponentReferenceExpression(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "libraryComponentReferenceExpression")) return false;
    boolean r;
    Marker m = enter_section_(b, l, _COLLAPSE_, LIBRARY_COMPONENT_REFERENCE_EXPRESSION, "<library component reference expression>");
    r = nonStrictID(b, l + 1);
    exit_section_(b, l, m, r, false, null);
    return r;
  }

  /* ********************************************************** */
  // <<nonStrictID>> ('.' <<nonStrictID>>)*
  public static boolean libraryId(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "libraryId")) return false;
    boolean r;
    Marker m = enter_section_(b, l, _NONE_, LIBRARY_ID, "<library id>");
    r = nonStrictID(b, l + 1);
    r = r && libraryId_1(b, l + 1);
    exit_section_(b, l, m, r, false, null);
    return r;
  }

  // ('.' <<nonStrictID>>)*
  private static boolean libraryId_1(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "libraryId_1")) return false;
    int c = current_position_(b);
    while (true) {
      if (!libraryId_1_0(b, l + 1)) break;
      if (!empty_element_parsed_guard_(b, "libraryId_1", c)) break;
      c = current_position_(b);
    }
    return true;
  }

  // '.' <<nonStrictID>>
  private static boolean libraryId_1_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "libraryId_1_0")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = consumeToken(b, DOT);
    r = r && nonStrictID(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  /* ********************************************************** */
  // <<nonStrictID>> ('.' <<nonStrictID>>)*
  public static boolean libraryNameElement(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "libraryNameElement")) return false;
    boolean r;
    Marker m = enter_section_(b, l, _NONE_, LIBRARY_NAME_ELEMENT, "<library name element>");
    r = nonStrictID(b, l + 1);
    r = r && libraryNameElement_1(b, l + 1);
    exit_section_(b, l, m, r, false, null);
    return r;
  }

  // ('.' <<nonStrictID>>)*
  private static boolean libraryNameElement_1(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "libraryNameElement_1")) return false;
    int c = current_position_(b);
    while (true) {
      if (!libraryNameElement_1_0(b, l + 1)) break;
      if (!empty_element_parsed_guard_(b, "libraryNameElement_1", c)) break;
      c = current_position_(b);
    }
    return true;
  }

  // '.' <<nonStrictID>>
  private static boolean libraryNameElement_1_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "libraryNameElement_1_0")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = consumeToken(b, DOT);
    r = r && nonStrictID(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  /* ********************************************************** */
  // libraryComponentReferenceExpression (',' libraryComponentReferenceExpression)*
  public static boolean libraryReferenceList(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "libraryReferenceList")) return false;
    boolean r;
    Marker m = enter_section_(b, l, _NONE_, LIBRARY_REFERENCE_LIST, "<library reference list>");
    r = libraryComponentReferenceExpression(b, l + 1);
    r = r && libraryReferenceList_1(b, l + 1);
    exit_section_(b, l, m, r, false, null);
    return r;
  }

  // (',' libraryComponentReferenceExpression)*
  private static boolean libraryReferenceList_1(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "libraryReferenceList_1")) return false;
    int c = current_position_(b);
    while (true) {
      if (!libraryReferenceList_1_0(b, l + 1)) break;
      if (!empty_element_parsed_guard_(b, "libraryReferenceList_1", c)) break;
      c = current_position_(b);
    }
    return true;
  }

  // ',' libraryComponentReferenceExpression
  private static boolean libraryReferenceList_1_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "libraryReferenceList_1_0")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = consumeToken(b, COMMA);
    r = r && libraryComponentReferenceExpression(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  /* ********************************************************** */
  // metadata* 'library' libraryNameElement ';'
  public static boolean libraryStatement(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "libraryStatement")) return false;
    if (!nextTokenIs(b, "<library statement>", AT, LIBRARY)) return false;
    boolean r, p;
    Marker m = enter_section_(b, l, _NONE_, LIBRARY_STATEMENT, "<library statement>");
    r = libraryStatement_0(b, l + 1);
    r = r && consumeToken(b, LIBRARY);
    r = r && libraryNameElement(b, l + 1);
    p = r; // pin = 3
    r = r && consumeToken(b, SEMICOLON);
    exit_section_(b, l, m, r, p, null);
    return r || p;
  }

  // metadata*
  private static boolean libraryStatement_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "libraryStatement_0")) return false;
    int c = current_position_(b);
    while (true) {
      if (!metadata(b, l + 1)) break;
      if (!empty_element_parsed_guard_(b, "libraryStatement_0", c)) break;
      c = current_position_(b);
    }
    return true;
  }

  /* ********************************************************** */
  // 'const'? typeArguments? '[' (expressionList ','?)? ']'
  public static boolean listLiteralExpression(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "listLiteralExpression")) return false;
    if (!nextTokenIs(b, "<list literal expression>", LT, LBRACKET, CONST)) return false;
    boolean r;
    Marker m = enter_section_(b, l, _NONE_, LIST_LITERAL_EXPRESSION, "<list literal expression>");
    r = listLiteralExpression_0(b, l + 1);
    r = r && listLiteralExpression_1(b, l + 1);
    r = r && consumeToken(b, LBRACKET);
    r = r && listLiteralExpression_3(b, l + 1);
    r = r && consumeToken(b, RBRACKET);
    exit_section_(b, l, m, r, false, null);
    return r;
  }

  // 'const'?
  private static boolean listLiteralExpression_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "listLiteralExpression_0")) return false;
    consumeToken(b, CONST);
    return true;
  }

  // typeArguments?
  private static boolean listLiteralExpression_1(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "listLiteralExpression_1")) return false;
    typeArguments(b, l + 1);
    return true;
  }

  // (expressionList ','?)?
  private static boolean listLiteralExpression_3(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "listLiteralExpression_3")) return false;
    listLiteralExpression_3_0(b, l + 1);
    return true;
  }

  // expressionList ','?
  private static boolean listLiteralExpression_3_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "listLiteralExpression_3_0")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = expressionList(b, l + 1);
    r = r && listLiteralExpression_3_0_1(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  // ','?
  private static boolean listLiteralExpression_3_0_1(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "listLiteralExpression_3_0_1")) return false;
    consumeToken(b, COMMA);
    return true;
  }

  /* ********************************************************** */
  // NULL | TRUE | FALSE | NUMBER | HEX_NUMBER | stringLiteralExpression | symbolLiteralExpression | <<mapLiteralExpressionWrapper>> | <<listLiteralExpressionWrapper>>
  public static boolean literalExpression(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "literalExpression")) return false;
    boolean r;
    Marker m = enter_section_(b, l, _COLLAPSE_, LITERAL_EXPRESSION, "<literal expression>");
    r = consumeToken(b, NULL);
    if (!r) r = consumeToken(b, TRUE);
    if (!r) r = consumeToken(b, FALSE);
    if (!r) r = consumeToken(b, NUMBER);
    if (!r) r = consumeToken(b, HEX_NUMBER);
    if (!r) r = stringLiteralExpression(b, l + 1);
    if (!r) r = symbolLiteralExpression(b, l + 1);
    if (!r) r = mapLiteralExpressionWrapper(b, l + 1);
    if (!r) r = listLiteralExpressionWrapper(b, l + 1);
    exit_section_(b, l, m, r, false, null);
    return r;
  }

  /* ********************************************************** */
  // '&&' compareExpressionWrapper
  public static boolean logicAndExpression(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "logicAndExpression")) return false;
    if (!nextTokenIs(b, AND_AND)) return false;
    boolean r;
    Marker m = enter_section_(b, l, _LEFT_, LOGIC_AND_EXPRESSION, null);
    r = consumeToken(b, AND_AND);
    r = r && compareExpressionWrapper(b, l + 1);
    exit_section_(b, l, m, r, false, null);
    return r;
  }

  /* ********************************************************** */
  // compareExpressionWrapper logicAndExpression*
  static boolean logicAndExpressionWrapper(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "logicAndExpressionWrapper")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = compareExpressionWrapper(b, l + 1);
    r = r && logicAndExpressionWrapper_1(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  // logicAndExpression*
  private static boolean logicAndExpressionWrapper_1(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "logicAndExpressionWrapper_1")) return false;
    int c = current_position_(b);
    while (true) {
      if (!logicAndExpression(b, l + 1)) break;
      if (!empty_element_parsed_guard_(b, "logicAndExpressionWrapper_1", c)) break;
      c = current_position_(b);
    }
    return true;
  }

  /* ********************************************************** */
  // '||' logicAndExpressionWrapper
  public static boolean logicOrExpression(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "logicOrExpression")) return false;
    if (!nextTokenIs(b, OR_OR)) return false;
    boolean r;
    Marker m = enter_section_(b, l, _LEFT_, LOGIC_OR_EXPRESSION, null);
    r = consumeToken(b, OR_OR);
    r = r && logicAndExpressionWrapper(b, l + 1);
    exit_section_(b, l, m, r, false, null);
    return r;
  }

  /* ********************************************************** */
  // logicAndExpressionWrapper logicOrExpression*
  static boolean logicOrExpressionWrapper(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "logicOrExpressionWrapper")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = logicAndExpressionWrapper(b, l + 1);
    r = r && logicOrExpressionWrapper_1(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  // logicOrExpression*
  private static boolean logicOrExpressionWrapper_1(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "logicOrExpressionWrapper_1")) return false;
    int c = current_position_(b);
    while (true) {
      if (!logicOrExpression(b, l + 1)) break;
      if (!empty_element_parsed_guard_(b, "logicOrExpressionWrapper_1", c)) break;
      c = current_position_(b);
    }
    return true;
  }

  /* ********************************************************** */
  // LONG_TEMPLATE_ENTRY_START expression LONG_TEMPLATE_ENTRY_END
  public static boolean longTemplateEntry(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "longTemplateEntry")) return false;
    if (!nextTokenIs(b, LONG_TEMPLATE_ENTRY_START)) return false;
    boolean r, p;
    Marker m = enter_section_(b, l, _NONE_, LONG_TEMPLATE_ENTRY, null);
    r = consumeToken(b, LONG_TEMPLATE_ENTRY_START);
    p = r; // pin = 1
    r = r && report_error_(b, expression(b, l + 1));
    r = p && consumeToken(b, LONG_TEMPLATE_ENTRY_END) && r;
    exit_section_(b, l, m, r, p, null);
    return r || p;
  }

  /* ********************************************************** */
  // expression ':' expression
  public static boolean mapLiteralEntry(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "mapLiteralEntry")) return false;
    boolean r;
    Marker m = enter_section_(b, l, _NONE_, MAP_LITERAL_ENTRY, "<map literal entry>");
    r = expression(b, l + 1);
    r = r && consumeToken(b, COLON);
    r = r && expression(b, l + 1);
    exit_section_(b, l, m, r, false, map_literal_entry_recover_parser_);
    return r;
  }

  /* ********************************************************** */
  // 'const'? typeArguments? '{' (mapLiteralEntry (',' mapLiteralEntry)* ','? )? '}'
  public static boolean mapLiteralExpression(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "mapLiteralExpression")) return false;
    if (!nextTokenIs(b, "<map literal expression>", LT, CONST, LBRACE)) return false;
    boolean r;
    Marker m = enter_section_(b, l, _NONE_, MAP_LITERAL_EXPRESSION, "<map literal expression>");
    r = mapLiteralExpression_0(b, l + 1);
    r = r && mapLiteralExpression_1(b, l + 1);
    r = r && consumeToken(b, LBRACE);
    r = r && mapLiteralExpression_3(b, l + 1);
    r = r && consumeToken(b, RBRACE);
    exit_section_(b, l, m, r, false, null);
    return r;
  }

  // 'const'?
  private static boolean mapLiteralExpression_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "mapLiteralExpression_0")) return false;
    consumeToken(b, CONST);
    return true;
  }

  // typeArguments?
  private static boolean mapLiteralExpression_1(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "mapLiteralExpression_1")) return false;
    typeArguments(b, l + 1);
    return true;
  }

  // (mapLiteralEntry (',' mapLiteralEntry)* ','? )?
  private static boolean mapLiteralExpression_3(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "mapLiteralExpression_3")) return false;
    mapLiteralExpression_3_0(b, l + 1);
    return true;
  }

  // mapLiteralEntry (',' mapLiteralEntry)* ','?
  private static boolean mapLiteralExpression_3_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "mapLiteralExpression_3_0")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = mapLiteralEntry(b, l + 1);
    r = r && mapLiteralExpression_3_0_1(b, l + 1);
    r = r && mapLiteralExpression_3_0_2(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  // (',' mapLiteralEntry)*
  private static boolean mapLiteralExpression_3_0_1(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "mapLiteralExpression_3_0_1")) return false;
    int c = current_position_(b);
    while (true) {
      if (!mapLiteralExpression_3_0_1_0(b, l + 1)) break;
      if (!empty_element_parsed_guard_(b, "mapLiteralExpression_3_0_1", c)) break;
      c = current_position_(b);
    }
    return true;
  }

  // ',' mapLiteralEntry
  private static boolean mapLiteralExpression_3_0_1_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "mapLiteralExpression_3_0_1_0")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = consumeToken(b, COMMA);
    r = r && mapLiteralEntry(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  // ','?
  private static boolean mapLiteralExpression_3_0_2(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "mapLiteralExpression_3_0_2")) return false;
    consumeToken(b, COMMA);
    return true;
  }

  /* ********************************************************** */
  // !(',' | '}')
  static boolean map_literal_entry_recover(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "map_literal_entry_recover")) return false;
    boolean r;
    Marker m = enter_section_(b, l, _NOT_);
    r = !map_literal_entry_recover_0(b, l + 1);
    exit_section_(b, l, m, r, false, null);
    return r;
  }

  // ',' | '}'
  private static boolean map_literal_entry_recover_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "map_literal_entry_recover_0")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = consumeToken(b, COMMA);
    if (!r) r = consumeToken(b, RBRACE);
    exit_section_(b, m, null, r);
    return r;
  }

  /* ********************************************************** */
  // '@' simpleQualifiedReferenceExpression <<argumentsWrapper>>?
  public static boolean metadata(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "metadata")) return false;
    if (!nextTokenIs(b, AT)) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = consumeToken(b, AT);
    r = r && simpleQualifiedReferenceExpression(b, l + 1);
    r = r && metadata_2(b, l + 1);
    exit_section_(b, m, METADATA, r);
    return r;
  }

  // <<argumentsWrapper>>?
  private static boolean metadata_2(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "metadata_2")) return false;
    argumentsWrapper(b, l + 1);
    return true;
  }

  /* ********************************************************** */
  // metadata* ('external' | 'static' | 'const')* methodDeclarationPrivate initializers? (';' | functionBodyOrNative | redirection)?
  public static boolean methodDeclaration(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "methodDeclaration")) return false;
    boolean r, p;
    Marker m = enter_section_(b, l, _NONE_, METHOD_DECLARATION, "<method declaration>");
    r = methodDeclaration_0(b, l + 1);
    r = r && methodDeclaration_1(b, l + 1);
    r = r && methodDeclarationPrivate(b, l + 1);
    p = r; // pin = 3
    r = r && report_error_(b, methodDeclaration_3(b, l + 1));
    r = p && methodDeclaration_4(b, l + 1) && r;
    exit_section_(b, l, m, r, p, null);
    return r || p;
  }

  // metadata*
  private static boolean methodDeclaration_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "methodDeclaration_0")) return false;
    int c = current_position_(b);
    while (true) {
      if (!metadata(b, l + 1)) break;
      if (!empty_element_parsed_guard_(b, "methodDeclaration_0", c)) break;
      c = current_position_(b);
    }
    return true;
  }

  // ('external' | 'static' | 'const')*
  private static boolean methodDeclaration_1(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "methodDeclaration_1")) return false;
    int c = current_position_(b);
    while (true) {
      if (!methodDeclaration_1_0(b, l + 1)) break;
      if (!empty_element_parsed_guard_(b, "methodDeclaration_1", c)) break;
      c = current_position_(b);
    }
    return true;
  }

  // 'external' | 'static' | 'const'
  private static boolean methodDeclaration_1_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "methodDeclaration_1_0")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = consumeToken(b, EXTERNAL);
    if (!r) r = consumeToken(b, STATIC);
    if (!r) r = consumeToken(b, CONST);
    exit_section_(b, m, null, r);
    return r;
  }

  // initializers?
  private static boolean methodDeclaration_3(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "methodDeclaration_3")) return false;
    initializers(b, l + 1);
    return true;
  }

  // (';' | functionBodyOrNative | redirection)?
  private static boolean methodDeclaration_4(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "methodDeclaration_4")) return false;
    methodDeclaration_4_0(b, l + 1);
    return true;
  }

  // ';' | functionBodyOrNative | redirection
  private static boolean methodDeclaration_4_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "methodDeclaration_4_0")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = consumeToken(b, SEMICOLON);
    if (!r) r = functionBodyOrNative(b, l + 1);
    if (!r) r = redirection(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  /* ********************************************************** */
  // returnType <<methodNameWrapper>> typeParameters? formalParameterList | !untypedFunctionType <<methodNameWrapper>> typeParameters? formalParameterList
  static boolean methodDeclarationPrivate(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "methodDeclarationPrivate")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = methodDeclarationPrivate_0(b, l + 1);
    if (!r) r = methodDeclarationPrivate_1(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  // returnType <<methodNameWrapper>> typeParameters? formalParameterList
  private static boolean methodDeclarationPrivate_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "methodDeclarationPrivate_0")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = returnType(b, l + 1);
    r = r && methodNameWrapper(b, l + 1);
    r = r && methodDeclarationPrivate_0_2(b, l + 1);
    r = r && formalParameterList(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  // typeParameters?
  private static boolean methodDeclarationPrivate_0_2(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "methodDeclarationPrivate_0_2")) return false;
    typeParameters(b, l + 1);
    return true;
  }

  // !untypedFunctionType <<methodNameWrapper>> typeParameters? formalParameterList
  private static boolean methodDeclarationPrivate_1(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "methodDeclarationPrivate_1")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = methodDeclarationPrivate_1_0(b, l + 1);
    r = r && methodNameWrapper(b, l + 1);
    r = r && methodDeclarationPrivate_1_2(b, l + 1);
    r = r && formalParameterList(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  // !untypedFunctionType
  private static boolean methodDeclarationPrivate_1_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "methodDeclarationPrivate_1_0")) return false;
    boolean r;
    Marker m = enter_section_(b, l, _NOT_);
    r = !untypedFunctionType(b, l + 1);
    exit_section_(b, l, m, r, false, null);
    return r;
  }

  // typeParameters?
  private static boolean methodDeclarationPrivate_1_2(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "methodDeclarationPrivate_1_2")) return false;
    typeParameters(b, l + 1);
    return true;
  }

  /* ********************************************************** */
  // '=' type mixins? interfaces? ';'
  public static boolean mixinApplication(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "mixinApplication")) return false;
    if (!nextTokenIs(b, EQ)) return false;
    boolean r, p;
    Marker m = enter_section_(b, l, _NONE_, MIXIN_APPLICATION, null);
    r = consumeToken(b, EQ);
    p = r; // pin = 1
    r = r && report_error_(b, type(b, l + 1));
    r = p && report_error_(b, mixinApplication_2(b, l + 1)) && r;
    r = p && report_error_(b, mixinApplication_3(b, l + 1)) && r;
    r = p && consumeToken(b, SEMICOLON) && r;
    exit_section_(b, l, m, r, p, null);
    return r || p;
  }

  // mixins?
  private static boolean mixinApplication_2(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "mixinApplication_2")) return false;
    mixins(b, l + 1);
    return true;
  }

  // interfaces?
  private static boolean mixinApplication_3(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "mixinApplication_3")) return false;
    interfaces(b, l + 1);
    return true;
  }

  /* ********************************************************** */
  // 'with' typeList
  public static boolean mixins(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "mixins")) return false;
    if (!nextTokenIs(b, WITH)) return false;
    boolean r, p;
    Marker m = enter_section_(b, l, _NONE_, MIXINS, null);
    r = consumeToken(b, WITH);
    p = r; // pin = 1
    r = r && typeList(b, l + 1);
    exit_section_(b, l, m, r, p, null);
    return r || p;
  }

  /* ********************************************************** */
  // multiplicativeOperator prefixExpression
  public static boolean multiplicativeExpression(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "multiplicativeExpression")) return false;
    if (!nextTokenIs(b, "<multiplicative expression>", REM, MUL, DIV, INT_DIV)) return false;
    boolean r;
    Marker m = enter_section_(b, l, _LEFT_, MULTIPLICATIVE_EXPRESSION, "<multiplicative expression>");
    r = multiplicativeOperator(b, l + 1);
    r = r && prefixExpression(b, l + 1);
    exit_section_(b, l, m, r, false, null);
    return r;
  }

  /* ********************************************************** */
  // prefixExpression multiplicativeExpression*
  static boolean multiplicativeExpressionWrapper(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "multiplicativeExpressionWrapper")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = prefixExpression(b, l + 1);
    r = r && multiplicativeExpressionWrapper_1(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  // multiplicativeExpression*
  private static boolean multiplicativeExpressionWrapper_1(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "multiplicativeExpressionWrapper_1")) return false;
    int c = current_position_(b);
    while (true) {
      if (!multiplicativeExpression(b, l + 1)) break;
      if (!empty_element_parsed_guard_(b, "multiplicativeExpressionWrapper_1", c)) break;
      c = current_position_(b);
    }
    return true;
  }

  /* ********************************************************** */
  // '*' | '/' | '%' | '~/'
  public static boolean multiplicativeOperator(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "multiplicativeOperator")) return false;
    if (!nextTokenIs(b, "<multiplicative operator>", REM, MUL, DIV, INT_DIV)) return false;
    boolean r;
    Marker m = enter_section_(b, l, _NONE_, MULTIPLICATIVE_OPERATOR, "<multiplicative operator>");
    r = consumeToken(b, MUL);
    if (!r) r = consumeToken(b, DIV);
    if (!r) r = consumeToken(b, REM);
    if (!r) r = consumeToken(b, INT_DIV);
    exit_section_(b, l, m, r, false, null);
    return r;
  }

  /* ********************************************************** */
  // parameterNameReferenceExpression ':' expression
  public static boolean namedArgument(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "namedArgument")) return false;
    boolean r;
    Marker m = enter_section_(b, l, _NONE_, NAMED_ARGUMENT, "<named argument>");
    r = parameterNameReferenceExpression(b, l + 1);
    r = r && consumeToken(b, COLON);
    r = r && expression(b, l + 1);
    exit_section_(b, l, m, r, false, null);
    return r;
  }

  /* ********************************************************** */
  // metadata* ('external' | 'const')* componentName '.' componentName formalParameterList initializers? (';' | functionBodyOrNative | redirection)?
  public static boolean namedConstructorDeclaration(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "namedConstructorDeclaration")) return false;
    boolean r, p;
    Marker m = enter_section_(b, l, _NONE_, NAMED_CONSTRUCTOR_DECLARATION, "<named constructor declaration>");
    r = namedConstructorDeclaration_0(b, l + 1);
    r = r && namedConstructorDeclaration_1(b, l + 1);
    r = r && componentName(b, l + 1);
    r = r && consumeToken(b, DOT);
    r = r && componentName(b, l + 1);
    r = r && formalParameterList(b, l + 1);
    p = r; // pin = 6
    r = r && report_error_(b, namedConstructorDeclaration_6(b, l + 1));
    r = p && namedConstructorDeclaration_7(b, l + 1) && r;
    exit_section_(b, l, m, r, p, null);
    return r || p;
  }

  // metadata*
  private static boolean namedConstructorDeclaration_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "namedConstructorDeclaration_0")) return false;
    int c = current_position_(b);
    while (true) {
      if (!metadata(b, l + 1)) break;
      if (!empty_element_parsed_guard_(b, "namedConstructorDeclaration_0", c)) break;
      c = current_position_(b);
    }
    return true;
  }

  // ('external' | 'const')*
  private static boolean namedConstructorDeclaration_1(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "namedConstructorDeclaration_1")) return false;
    int c = current_position_(b);
    while (true) {
      if (!namedConstructorDeclaration_1_0(b, l + 1)) break;
      if (!empty_element_parsed_guard_(b, "namedConstructorDeclaration_1", c)) break;
      c = current_position_(b);
    }
    return true;
  }

  // 'external' | 'const'
  private static boolean namedConstructorDeclaration_1_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "namedConstructorDeclaration_1_0")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = consumeToken(b, EXTERNAL);
    if (!r) r = consumeToken(b, CONST);
    exit_section_(b, m, null, r);
    return r;
  }

  // initializers?
  private static boolean namedConstructorDeclaration_6(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "namedConstructorDeclaration_6")) return false;
    initializers(b, l + 1);
    return true;
  }

  // (';' | functionBodyOrNative | redirection)?
  private static boolean namedConstructorDeclaration_7(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "namedConstructorDeclaration_7")) return false;
    namedConstructorDeclaration_7_0(b, l + 1);
    return true;
  }

  // ';' | functionBodyOrNative | redirection
  private static boolean namedConstructorDeclaration_7_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "namedConstructorDeclaration_7_0")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = consumeToken(b, SEMICOLON);
    if (!r) r = functionBodyOrNative(b, l + 1);
    if (!r) r = redirection(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  /* ********************************************************** */
  // '{' defaultFormalNamedParameter (',' defaultFormalNamedParameter)* ','? '}'
  static boolean namedFormalParameters(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "namedFormalParameters")) return false;
    if (!nextTokenIs(b, LBRACE)) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = consumeToken(b, LBRACE);
    r = r && defaultFormalNamedParameter(b, l + 1);
    r = r && namedFormalParameters_2(b, l + 1);
    r = r && namedFormalParameters_3(b, l + 1);
    r = r && consumeToken(b, RBRACE);
    exit_section_(b, m, null, r);
    return r;
  }

  // (',' defaultFormalNamedParameter)*
  private static boolean namedFormalParameters_2(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "namedFormalParameters_2")) return false;
    int c = current_position_(b);
    while (true) {
      if (!namedFormalParameters_2_0(b, l + 1)) break;
      if (!empty_element_parsed_guard_(b, "namedFormalParameters_2", c)) break;
      c = current_position_(b);
    }
    return true;
  }

  // ',' defaultFormalNamedParameter
  private static boolean namedFormalParameters_2_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "namedFormalParameters_2_0")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = consumeToken(b, COMMA);
    r = r && defaultFormalNamedParameter(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  // ','?
  private static boolean namedFormalParameters_3(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "namedFormalParameters_3")) return false;
    consumeToken(b, COMMA);
    return true;
  }

  /* ********************************************************** */
  // '{' typedIdentifier (',' typedIdentifier)* ','? '}'
  static boolean namedParameterTypes(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "namedParameterTypes")) return false;
    if (!nextTokenIs(b, LBRACE)) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = consumeToken(b, LBRACE);
    r = r && typedIdentifier(b, l + 1);
    r = r && namedParameterTypes_2(b, l + 1);
    r = r && namedParameterTypes_3(b, l + 1);
    r = r && consumeToken(b, RBRACE);
    exit_section_(b, m, null, r);
    return r;
  }

  // (',' typedIdentifier)*
  private static boolean namedParameterTypes_2(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "namedParameterTypes_2")) return false;
    int c = current_position_(b);
    while (true) {
      if (!namedParameterTypes_2_0(b, l + 1)) break;
      if (!empty_element_parsed_guard_(b, "namedParameterTypes_2", c)) break;
      c = current_position_(b);
    }
    return true;
  }

  // ',' typedIdentifier
  private static boolean namedParameterTypes_2_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "namedParameterTypes_2_0")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = consumeToken(b, COMMA);
    r = r && typedIdentifier(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  // ','?
  private static boolean namedParameterTypes_3(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "namedParameterTypes_3")) return false;
    consumeToken(b, COMMA);
    return true;
  }

  /* ********************************************************** */
  // ('new' | 'const') type ('.' referenceExpression)? <<argumentsWrapper>>
  public static boolean newExpression(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "newExpression")) return false;
    if (!nextTokenIs(b, "<new expression>", CONST, NEW)) return false;
    boolean r, p;
    Marker m = enter_section_(b, l, _COLLAPSE_, NEW_EXPRESSION, "<new expression>");
    r = newExpression_0(b, l + 1);
    p = r; // pin = 1
    r = r && report_error_(b, type(b, l + 1));
    r = p && report_error_(b, newExpression_2(b, l + 1)) && r;
    r = p && argumentsWrapper(b, l + 1) && r;
    exit_section_(b, l, m, r, p, null);
    return r || p;
  }

  // 'new' | 'const'
  private static boolean newExpression_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "newExpression_0")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = consumeToken(b, NEW);
    if (!r) r = consumeToken(b, CONST);
    exit_section_(b, m, null, r);
    return r;
  }

  // ('.' referenceExpression)?
  private static boolean newExpression_2(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "newExpression_2")) return false;
    newExpression_2_0(b, l + 1);
    return true;
  }

  // '.' referenceExpression
  private static boolean newExpression_2_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "newExpression_2_0")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = consumeToken(b, DOT);
    r = r && referenceExpression(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  /* ********************************************************** */
  // block // Guard to break tie with map literal.
  //                                | functionDeclarationWithBody
  //                                | forStatement
  //                                | whileStatement
  //                                | doWhileStatement
  //                                | switchStatement
  //                                | ifStatement
  //                                | rethrowStatement
  //                                | tryStatement
  //                                | breakStatement
  //                                | continueStatement
  //                                | returnStatement
  //                                | assertStatementWithSemicolon
  //                                | statementFollowedBySemiColon
  //                                | yieldEachStatement
  //                                | yieldStatement
  //                                | ';'
  //                                | '=>'
  static boolean nonLabelledStatement(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "nonLabelledStatement")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = block(b, l + 1);
    if (!r) r = functionDeclarationWithBody(b, l + 1);
    if (!r) r = forStatement(b, l + 1);
    if (!r) r = whileStatement(b, l + 1);
    if (!r) r = doWhileStatement(b, l + 1);
    if (!r) r = switchStatement(b, l + 1);
    if (!r) r = ifStatement(b, l + 1);
    if (!r) r = rethrowStatement(b, l + 1);
    if (!r) r = tryStatement(b, l + 1);
    if (!r) r = breakStatement(b, l + 1);
    if (!r) r = continueStatement(b, l + 1);
    if (!r) r = returnStatement(b, l + 1);
    if (!r) r = assertStatementWithSemicolon(b, l + 1);
    if (!r) r = statementFollowedBySemiColon(b, l + 1);
    if (!r) r = yieldEachStatement(b, l + 1);
    if (!r) r = yieldStatement(b, l + 1);
    if (!r) r = consumeToken(b, SEMICOLON);
    if (!r) r = consumeToken(b, EXPRESSION_BODY_DEF);
    exit_section_(b, m, null, r);
    return r;
  }

  /* ********************************************************** */
  // functionFormalParameter
  //                         | fieldFormalParameter
  //                         | simpleFormalParameter
  //                         | incorrectNormalFormalParameter
  public static boolean normalFormalParameter(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "normalFormalParameter")) return false;
    boolean r;
    Marker m = enter_section_(b, l, _NONE_, NORMAL_FORMAL_PARAMETER, "<normal formal parameter>");
    r = functionFormalParameter(b, l + 1);
    if (!r) r = fieldFormalParameter(b, l + 1);
    if (!r) r = simpleFormalParameter(b, l + 1);
    if (!r) r = incorrectNormalFormalParameter(b, l + 1);
    exit_section_(b, l, m, r, false, null);
    return r;
  }

  /* ********************************************************** */
  // normalFormalParameter (',' normalFormalParameter)*
  static boolean normalFormalParameters(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "normalFormalParameters")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = normalFormalParameter(b, l + 1);
    r = r && normalFormalParameters_1(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  // (',' normalFormalParameter)*
  private static boolean normalFormalParameters_1(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "normalFormalParameters_1")) return false;
    int c = current_position_(b);
    while (true) {
      if (!normalFormalParameters_1_0(b, l + 1)) break;
      if (!empty_element_parsed_guard_(b, "normalFormalParameters_1", c)) break;
      c = current_position_(b);
    }
    return true;
  }

  // ',' normalFormalParameter
  private static boolean normalFormalParameters_1_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "normalFormalParameters_1_0")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = consumeToken(b, COMMA);
    r = r && normalFormalParameter(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  /* ********************************************************** */
  // typedIdentifier | type
  public static boolean normalParameterType(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "normalParameterType")) return false;
    boolean r;
    Marker m = enter_section_(b, l, _NONE_, NORMAL_PARAMETER_TYPE, "<normal parameter type>");
    r = typedIdentifier(b, l + 1);
    if (!r) r = type(b, l + 1);
    exit_section_(b, l, m, r, false, null);
    return r;
  }

  /* ********************************************************** */
  // normalParameterType (',' normalParameterType)*
  static boolean normalParameterTypes(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "normalParameterTypes")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = normalParameterType(b, l + 1);
    r = r && normalParameterTypes_1(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  // (',' normalParameterType)*
  private static boolean normalParameterTypes_1(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "normalParameterTypes_1")) return false;
    int c = current_position_(b);
    while (true) {
      if (!normalParameterTypes_1_0(b, l + 1)) break;
      if (!empty_element_parsed_guard_(b, "normalParameterTypes_1", c)) break;
      c = current_position_(b);
    }
    return true;
  }

  // ',' normalParameterType
  private static boolean normalParameterTypes_1_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "normalParameterTypes_1_0")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = consumeToken(b, COMMA);
    r = r && normalParameterType(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  /* ********************************************************** */
  // !(')' | ',')
  static boolean not_paren_or_comma_recover(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "not_paren_or_comma_recover")) return false;
    boolean r;
    Marker m = enter_section_(b, l, _NOT_);
    r = !not_paren_or_comma_recover_0(b, l + 1);
    exit_section_(b, l, m, r, false, null);
    return r;
  }

  // ')' | ','
  private static boolean not_paren_or_comma_recover_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "not_paren_or_comma_recover_0")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = consumeToken(b, RPAREN);
    if (!r) r = consumeToken(b, COMMA);
    exit_section_(b, m, null, r);
    return r;
  }

  /* ********************************************************** */
  // !')'
  static boolean not_paren_recover(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "not_paren_recover")) return false;
    boolean r;
    Marker m = enter_section_(b, l, _NOT_);
    r = !consumeToken(b, RPAREN);
    exit_section_(b, l, m, r, false, null);
    return r;
  }

  /* ********************************************************** */
  // catchPart block | 'on' type catchPart? block
  public static boolean onPart(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "onPart")) return false;
    if (!nextTokenIs(b, "<on part>", CATCH, ON)) return false;
    boolean r;
    Marker m = enter_section_(b, l, _NONE_, ON_PART, "<on part>");
    r = onPart_0(b, l + 1);
    if (!r) r = onPart_1(b, l + 1);
    exit_section_(b, l, m, r, false, null);
    return r;
  }

  // catchPart block
  private static boolean onPart_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "onPart_0")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = catchPart(b, l + 1);
    r = r && block(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  // 'on' type catchPart? block
  private static boolean onPart_1(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "onPart_1")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = consumeToken(b, ON);
    r = r && type(b, l + 1);
    r = r && onPart_1_2(b, l + 1);
    r = r && block(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  // catchPart?
  private static boolean onPart_1_2(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "onPart_1_2")) return false;
    catchPart(b, l + 1);
    return true;
  }

  /* ********************************************************** */
  // optionalPositionalFormalParameters (',' namedFormalParameters)? | namedFormalParameters
  public static boolean optionalFormalParameters(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "optionalFormalParameters")) return false;
    if (!nextTokenIs(b, "<optional formal parameters>", LBRACKET, LBRACE)) return false;
    boolean r;
    Marker m = enter_section_(b, l, _NONE_, OPTIONAL_FORMAL_PARAMETERS, "<optional formal parameters>");
    r = optionalFormalParameters_0(b, l + 1);
    if (!r) r = namedFormalParameters(b, l + 1);
    exit_section_(b, l, m, r, false, null);
    return r;
  }

  // optionalPositionalFormalParameters (',' namedFormalParameters)?
  private static boolean optionalFormalParameters_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "optionalFormalParameters_0")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = optionalPositionalFormalParameters(b, l + 1);
    r = r && optionalFormalParameters_0_1(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  // (',' namedFormalParameters)?
  private static boolean optionalFormalParameters_0_1(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "optionalFormalParameters_0_1")) return false;
    optionalFormalParameters_0_1_0(b, l + 1);
    return true;
  }

  // ',' namedFormalParameters
  private static boolean optionalFormalParameters_0_1_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "optionalFormalParameters_0_1_0")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = consumeToken(b, COMMA);
    r = r && namedFormalParameters(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  /* ********************************************************** */
  // optionalPositionalParameterTypes | namedParameterTypes
  public static boolean optionalParameterTypes(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "optionalParameterTypes")) return false;
    if (!nextTokenIs(b, "<optional parameter types>", LBRACKET, LBRACE)) return false;
    boolean r;
    Marker m = enter_section_(b, l, _NONE_, OPTIONAL_PARAMETER_TYPES, "<optional parameter types>");
    r = optionalPositionalParameterTypes(b, l + 1);
    if (!r) r = namedParameterTypes(b, l + 1);
    exit_section_(b, l, m, r, false, null);
    return r;
  }

  /* ********************************************************** */
  // '[' defaultFormalNamedParameter (',' defaultFormalNamedParameter)* ','? ']'
  static boolean optionalPositionalFormalParameters(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "optionalPositionalFormalParameters")) return false;
    if (!nextTokenIs(b, LBRACKET)) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = consumeToken(b, LBRACKET);
    r = r && defaultFormalNamedParameter(b, l + 1);
    r = r && optionalPositionalFormalParameters_2(b, l + 1);
    r = r && optionalPositionalFormalParameters_3(b, l + 1);
    r = r && consumeToken(b, RBRACKET);
    exit_section_(b, m, null, r);
    return r;
  }

  // (',' defaultFormalNamedParameter)*
  private static boolean optionalPositionalFormalParameters_2(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "optionalPositionalFormalParameters_2")) return false;
    int c = current_position_(b);
    while (true) {
      if (!optionalPositionalFormalParameters_2_0(b, l + 1)) break;
      if (!empty_element_parsed_guard_(b, "optionalPositionalFormalParameters_2", c)) break;
      c = current_position_(b);
    }
    return true;
  }

  // ',' defaultFormalNamedParameter
  private static boolean optionalPositionalFormalParameters_2_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "optionalPositionalFormalParameters_2_0")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = consumeToken(b, COMMA);
    r = r && defaultFormalNamedParameter(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  // ','?
  private static boolean optionalPositionalFormalParameters_3(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "optionalPositionalFormalParameters_3")) return false;
    consumeToken(b, COMMA);
    return true;
  }

  /* ********************************************************** */
  // '[' normalParameterTypes ','? ']'
  static boolean optionalPositionalParameterTypes(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "optionalPositionalParameterTypes")) return false;
    if (!nextTokenIs(b, LBRACKET)) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = consumeToken(b, LBRACKET);
    r = r && normalParameterTypes(b, l + 1);
    r = r && optionalPositionalParameterTypes_2(b, l + 1);
    r = r && consumeToken(b, RBRACKET);
    exit_section_(b, m, null, r);
    return r;
  }

  // ','?
  private static boolean optionalPositionalParameterTypes_2(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "optionalPositionalParameterTypes_2")) return false;
    consumeToken(b, COMMA);
    return true;
  }

  /* ********************************************************** */
  // << nonStrictID >>
  public static boolean parameterNameReferenceExpression(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "parameterNameReferenceExpression")) return false;
    boolean r;
    Marker m = enter_section_(b, l, _COLLAPSE_, PARAMETER_NAME_REFERENCE_EXPRESSION, "<parameter name reference expression>");
    r = nonStrictID(b, l + 1);
    exit_section_(b, l, m, r, false, null);
    return r;
  }

  /* ********************************************************** */
  // '(' ')'
  //                     | '(' normalParameterTypes ','? ')'
  //                     | '(' normalParameterTypes ',' optionalParameterTypes ')'
  //                     | '(' optionalParameterTypes ')'
  public static boolean parameterTypeList(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "parameterTypeList")) return false;
    if (!nextTokenIs(b, LPAREN)) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = parseTokens(b, 0, LPAREN, RPAREN);
    if (!r) r = parameterTypeList_1(b, l + 1);
    if (!r) r = parameterTypeList_2(b, l + 1);
    if (!r) r = parameterTypeList_3(b, l + 1);
    exit_section_(b, m, PARAMETER_TYPE_LIST, r);
    return r;
  }

  // '(' normalParameterTypes ','? ')'
  private static boolean parameterTypeList_1(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "parameterTypeList_1")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = consumeToken(b, LPAREN);
    r = r && normalParameterTypes(b, l + 1);
    r = r && parameterTypeList_1_2(b, l + 1);
    r = r && consumeToken(b, RPAREN);
    exit_section_(b, m, null, r);
    return r;
  }

  // ','?
  private static boolean parameterTypeList_1_2(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "parameterTypeList_1_2")) return false;
    consumeToken(b, COMMA);
    return true;
  }

  // '(' normalParameterTypes ',' optionalParameterTypes ')'
  private static boolean parameterTypeList_2(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "parameterTypeList_2")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = consumeToken(b, LPAREN);
    r = r && normalParameterTypes(b, l + 1);
    r = r && consumeToken(b, COMMA);
    r = r && optionalParameterTypes(b, l + 1);
    r = r && consumeToken(b, RPAREN);
    exit_section_(b, m, null, r);
    return r;
  }

  // '(' optionalParameterTypes ')'
  private static boolean parameterTypeList_3(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "parameterTypeList_3")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = consumeToken(b, LPAREN);
    r = r && optionalParameterTypes(b, l + 1);
    r = r && consumeToken(b, RPAREN);
    exit_section_(b, m, null, r);
    return r;
  }

  /* ********************************************************** */
  // !')'
  static boolean parenthesesRecovery(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "parenthesesRecovery")) return false;
    boolean r;
    Marker m = enter_section_(b, l, _NOT_);
    r = !consumeToken(b, RPAREN);
    exit_section_(b, l, m, r, false, null);
    return r;
  }

  /* ********************************************************** */
  // '(' expressionInParentheses ')'
  public static boolean parenthesizedExpression(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "parenthesizedExpression")) return false;
    if (!nextTokenIs(b, LPAREN)) return false;
    boolean r, p;
    Marker m = enter_section_(b, l, _NONE_, PARENTHESIZED_EXPRESSION, null);
    r = consumeToken(b, LPAREN);
    p = r; // pin = 1
    r = r && report_error_(b, expressionInParentheses(b, l + 1));
    r = p && consumeToken(b, RPAREN) && r;
    exit_section_(b, l, m, r, p, null);
    return r || p;
  }

  /* ********************************************************** */
  // metadata* 'part' 'of' (libraryId | uriElement)';'
  public static boolean partOfStatement(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "partOfStatement")) return false;
    if (!nextTokenIs(b, "<part of statement>", AT, PART)) return false;
    boolean r, p;
    Marker m = enter_section_(b, l, _NONE_, PART_OF_STATEMENT, "<part of statement>");
    r = partOfStatement_0(b, l + 1);
    r = r && consumeTokens(b, 0, PART, OF);
    r = r && partOfStatement_3(b, l + 1);
    p = r; // pin = 4
    r = r && consumeToken(b, SEMICOLON);
    exit_section_(b, l, m, r, p, null);
    return r || p;
  }

  // metadata*
  private static boolean partOfStatement_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "partOfStatement_0")) return false;
    int c = current_position_(b);
    while (true) {
      if (!metadata(b, l + 1)) break;
      if (!empty_element_parsed_guard_(b, "partOfStatement_0", c)) break;
      c = current_position_(b);
    }
    return true;
  }

  // libraryId | uriElement
  private static boolean partOfStatement_3(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "partOfStatement_3")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = libraryId(b, l + 1);
    if (!r) r = uriElement(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  /* ********************************************************** */
  // metadata* 'part' uriElement ';'
  public static boolean partStatement(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "partStatement")) return false;
    if (!nextTokenIs(b, "<part statement>", AT, PART)) return false;
    boolean r, p;
    Marker m = enter_section_(b, l, _NONE_, PART_STATEMENT, "<part statement>");
    r = partStatement_0(b, l + 1);
    r = r && consumeToken(b, PART);
    r = r && uriElement(b, l + 1);
    p = r; // pin = 3
    r = r && consumeToken(b, SEMICOLON);
    exit_section_(b, l, m, r, p, null);
    return r || p;
  }

  // metadata*
  private static boolean partStatement_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "partStatement_0")) return false;
    int c = current_position_(b);
    while (true) {
      if (!metadata(b, l + 1)) break;
      if (!empty_element_parsed_guard_(b, "partStatement_0", c)) break;
      c = current_position_(b);
    }
    return true;
  }

  /* ********************************************************** */
  // (prefixOperator prefixExpression) | awaitExpression | suffixExpressionWrapper
  public static boolean prefixExpression(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "prefixExpression")) return false;
    boolean r;
    Marker m = enter_section_(b, l, _COLLAPSE_, PREFIX_EXPRESSION, "<prefix expression>");
    r = prefixExpression_0(b, l + 1);
    if (!r) r = awaitExpression(b, l + 1);
    if (!r) r = suffixExpressionWrapper(b, l + 1);
    exit_section_(b, l, m, r, false, null);
    return r;
  }

  // prefixOperator prefixExpression
  private static boolean prefixExpression_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "prefixExpression_0")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = prefixOperator(b, l + 1);
    r = r && prefixExpression(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  /* ********************************************************** */
  // '-' | '+' | '--' | '++' | '!' | '~'
  public static boolean prefixOperator(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "prefixOperator")) return false;
    if (!nextTokenIs(b, "<prefix operator>", NOT, PLUS,
      PLUS_PLUS, MINUS, MINUS_MINUS, BIN_NOT)) return false;
    boolean r;
    Marker m = enter_section_(b, l, _NONE_, PREFIX_OPERATOR, "<prefix operator>");
    r = consumeToken(b, MINUS);
    if (!r) r = consumeToken(b, PLUS);
    if (!r) r = consumeToken(b, MINUS_MINUS);
    if (!r) r = consumeToken(b, PLUS_PLUS);
    if (!r) r = consumeToken(b, NOT);
    if (!r) r = consumeToken(b, BIN_NOT);
    exit_section_(b, l, m, r, false, null);
    return r;
  }

  /* ********************************************************** */
  // literalExpression |
  //                      functionExpression |
  //                      newExpression | // constant object expression is also parsed as newExpression
  //                      refOrThisOrSuperOrParenExpression |
  //                      throwExpression
  static boolean primary(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "primary")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = literalExpression(b, l + 1);
    if (!r) r = functionExpression(b, l + 1);
    if (!r) r = newExpression(b, l + 1);
    if (!r) r = refOrThisOrSuperOrParenExpression(b, l + 1);
    if (!r) r = throwExpression(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  /* ********************************************************** */
  // '.' referenceExpression | '?.' referenceExpression
  public static boolean qualifiedReferenceExpression(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "qualifiedReferenceExpression")) return false;
    if (!nextTokenIs(b, "<qualified reference expression>", DOT, QUEST_DOT)) return false;
    boolean r;
    Marker m = enter_section_(b, l, _LEFT_, REFERENCE_EXPRESSION, "<qualified reference expression>");
    r = qualifiedReferenceExpression_0(b, l + 1);
    if (!r) r = qualifiedReferenceExpression_1(b, l + 1);
    exit_section_(b, l, m, r, false, null);
    return r;
  }

  // '.' referenceExpression
  private static boolean qualifiedReferenceExpression_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "qualifiedReferenceExpression_0")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = consumeToken(b, DOT);
    r = r && referenceExpression(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  // '?.' referenceExpression
  private static boolean qualifiedReferenceExpression_1(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "qualifiedReferenceExpression_1")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = consumeToken(b, QUEST_DOT);
    r = r && referenceExpression(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  /* ********************************************************** */
  // ':' 'this' ('.' referenceExpression)? <<argumentsWrapper>>
  public static boolean redirection(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "redirection")) return false;
    if (!nextTokenIs(b, COLON)) return false;
    boolean r, p;
    Marker m = enter_section_(b, l, _NONE_, REDIRECTION, null);
    r = consumeTokens(b, 2, COLON, THIS);
    p = r; // pin = 2
    r = r && report_error_(b, redirection_2(b, l + 1));
    r = p && argumentsWrapper(b, l + 1) && r;
    exit_section_(b, l, m, r, p, null);
    return r || p;
  }

  // ('.' referenceExpression)?
  private static boolean redirection_2(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "redirection_2")) return false;
    redirection_2_0(b, l + 1);
    return true;
  }

  // '.' referenceExpression
  private static boolean redirection_2_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "redirection_2_0")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = consumeToken(b, DOT);
    r = r && referenceExpression(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  /* ********************************************************** */
  // referenceExpression | thisExpression | superExpression | << parenthesizedExpressionWrapper >>
  static boolean refOrThisOrSuperOrParenExpression(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "refOrThisOrSuperOrParenExpression")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = referenceExpression(b, l + 1);
    if (!r) r = thisExpression(b, l + 1);
    if (!r) r = superExpression(b, l + 1);
    if (!r) r = parenthesizedExpressionWrapper(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  /* ********************************************************** */
  // << nonStrictID >>
  public static boolean referenceExpression(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "referenceExpression")) return false;
    boolean r;
    Marker m = enter_section_(b, l, _COLLAPSE_, REFERENCE_EXPRESSION, "<reference expression>");
    r = nonStrictID(b, l + 1);
    exit_section_(b, l, m, r, false, null);
    return r;
  }

  /* ********************************************************** */
  // <<gtEq>> | '>' | '<=' | '<'
  public static boolean relationalOperator(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "relationalOperator")) return false;
    boolean r;
    Marker m = enter_section_(b, l, _NONE_, RELATIONAL_OPERATOR, "<relational operator>");
    r = gtEq(b, l + 1);
    if (!r) r = consumeToken(b, GT);
    if (!r) r = consumeToken(b, LT_EQ);
    if (!r) r = consumeToken(b, LT);
    exit_section_(b, l, m, r, false, null);
    return r;
  }

  /* ********************************************************** */
  // 'rethrow' ';'
  public static boolean rethrowStatement(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "rethrowStatement")) return false;
    if (!nextTokenIs(b, RETHROW)) return false;
    boolean r, p;
    Marker m = enter_section_(b, l, _NONE_, RETHROW_STATEMENT, null);
    r = consumeTokens(b, 1, RETHROW, SEMICOLON);
    p = r; // pin = 1
    exit_section_(b, l, m, r, p, null);
    return r || p;
  }

  /* ********************************************************** */
  // 'return' expression? ';'
  public static boolean returnStatement(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "returnStatement")) return false;
    if (!nextTokenIs(b, RETURN)) return false;
    boolean r, p;
    Marker m = enter_section_(b, l, _NONE_, RETURN_STATEMENT, null);
    r = consumeToken(b, RETURN);
    p = r; // pin = 1
    r = r && report_error_(b, returnStatement_1(b, l + 1));
    r = p && consumeToken(b, SEMICOLON) && r;
    exit_section_(b, l, m, r, p, null);
    return r || p;
  }

  // expression?
  private static boolean returnStatement_1(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "returnStatement_1")) return false;
    expression(b, l + 1);
    return true;
  }

  /* ********************************************************** */
  // 'void' !untypedFunctionType | type
  public static boolean returnType(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "returnType")) return false;
    boolean r;
    Marker m = enter_section_(b, l, _NONE_, RETURN_TYPE, "<return type>");
    r = returnType_0(b, l + 1);
    if (!r) r = type(b, l + 1);
    exit_section_(b, l, m, r, false, null);
    return r;
  }

  // 'void' !untypedFunctionType
  private static boolean returnType_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "returnType_0")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = consumeToken(b, VOID);
    r = r && returnType_0_1(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  // !untypedFunctionType
  private static boolean returnType_0_1(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "returnType_0_1")) return false;
    boolean r;
    Marker m = enter_section_(b, l, _NOT_);
    r = !untypedFunctionType(b, l + 1);
    exit_section_(b, l, m, r, false, null);
    return r;
  }

  /* ********************************************************** */
  // setterDeclarationWithReturnType | setterDeclarationWithoutReturnType
  public static boolean setterDeclaration(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "setterDeclaration")) return false;
    boolean r;
    Marker m = enter_section_(b, l, _NONE_, SETTER_DECLARATION, "<setter declaration>");
    r = setterDeclarationWithReturnType(b, l + 1);
    if (!r) r = setterDeclarationWithoutReturnType(b, l + 1);
    exit_section_(b, l, m, r, false, null);
    return r;
  }

  /* ********************************************************** */
  // metadata* ('external' | 'static')* returnType 'set' componentName formalParameterList (';' | functionBodyOrNative)
  static boolean setterDeclarationWithReturnType(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "setterDeclarationWithReturnType")) return false;
    boolean r, p;
    Marker m = enter_section_(b, l, _NONE_);
    r = setterDeclarationWithReturnType_0(b, l + 1);
    r = r && setterDeclarationWithReturnType_1(b, l + 1);
    r = r && returnType(b, l + 1);
    r = r && consumeToken(b, SET);
    r = r && componentName(b, l + 1);
    p = r; // pin = 5
    r = r && report_error_(b, formalParameterList(b, l + 1));
    r = p && setterDeclarationWithReturnType_6(b, l + 1) && r;
    exit_section_(b, l, m, r, p, null);
    return r || p;
  }

  // metadata*
  private static boolean setterDeclarationWithReturnType_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "setterDeclarationWithReturnType_0")) return false;
    int c = current_position_(b);
    while (true) {
      if (!metadata(b, l + 1)) break;
      if (!empty_element_parsed_guard_(b, "setterDeclarationWithReturnType_0", c)) break;
      c = current_position_(b);
    }
    return true;
  }

  // ('external' | 'static')*
  private static boolean setterDeclarationWithReturnType_1(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "setterDeclarationWithReturnType_1")) return false;
    int c = current_position_(b);
    while (true) {
      if (!setterDeclarationWithReturnType_1_0(b, l + 1)) break;
      if (!empty_element_parsed_guard_(b, "setterDeclarationWithReturnType_1", c)) break;
      c = current_position_(b);
    }
    return true;
  }

  // 'external' | 'static'
  private static boolean setterDeclarationWithReturnType_1_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "setterDeclarationWithReturnType_1_0")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = consumeToken(b, EXTERNAL);
    if (!r) r = consumeToken(b, STATIC);
    exit_section_(b, m, null, r);
    return r;
  }

  // ';' | functionBodyOrNative
  private static boolean setterDeclarationWithReturnType_6(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "setterDeclarationWithReturnType_6")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = consumeToken(b, SEMICOLON);
    if (!r) r = functionBodyOrNative(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  /* ********************************************************** */
  // metadata* ('external' | 'static')*            'set' componentName formalParameterList (';' | functionBodyOrNative)
  static boolean setterDeclarationWithoutReturnType(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "setterDeclarationWithoutReturnType")) return false;
    if (!nextTokenIs(b, "", AT, EXTERNAL, SET, STATIC)) return false;
    boolean r, p;
    Marker m = enter_section_(b, l, _NONE_);
    r = setterDeclarationWithoutReturnType_0(b, l + 1);
    r = r && setterDeclarationWithoutReturnType_1(b, l + 1);
    r = r && consumeToken(b, SET);
    r = r && componentName(b, l + 1);
    p = r; // pin = 4
    r = r && report_error_(b, formalParameterList(b, l + 1));
    r = p && setterDeclarationWithoutReturnType_5(b, l + 1) && r;
    exit_section_(b, l, m, r, p, null);
    return r || p;
  }

  // metadata*
  private static boolean setterDeclarationWithoutReturnType_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "setterDeclarationWithoutReturnType_0")) return false;
    int c = current_position_(b);
    while (true) {
      if (!metadata(b, l + 1)) break;
      if (!empty_element_parsed_guard_(b, "setterDeclarationWithoutReturnType_0", c)) break;
      c = current_position_(b);
    }
    return true;
  }

  // ('external' | 'static')*
  private static boolean setterDeclarationWithoutReturnType_1(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "setterDeclarationWithoutReturnType_1")) return false;
    int c = current_position_(b);
    while (true) {
      if (!setterDeclarationWithoutReturnType_1_0(b, l + 1)) break;
      if (!empty_element_parsed_guard_(b, "setterDeclarationWithoutReturnType_1", c)) break;
      c = current_position_(b);
    }
    return true;
  }

  // 'external' | 'static'
  private static boolean setterDeclarationWithoutReturnType_1_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "setterDeclarationWithoutReturnType_1_0")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = consumeToken(b, EXTERNAL);
    if (!r) r = consumeToken(b, STATIC);
    exit_section_(b, m, null, r);
    return r;
  }

  // ';' | functionBodyOrNative
  private static boolean setterDeclarationWithoutReturnType_5(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "setterDeclarationWithoutReturnType_5")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = consumeToken(b, SEMICOLON);
    if (!r) r = functionBodyOrNative(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  /* ********************************************************** */
  // shiftOperator additiveExpressionWrapper
  public static boolean shiftExpression(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "shiftExpression")) return false;
    boolean r;
    Marker m = enter_section_(b, l, _LEFT_, SHIFT_EXPRESSION, "<shift expression>");
    r = shiftOperator(b, l + 1);
    r = r && additiveExpressionWrapper(b, l + 1);
    exit_section_(b, l, m, r, false, null);
    return r;
  }

  /* ********************************************************** */
  // additiveExpressionWrapper shiftExpression*
  static boolean shiftExpressionWrapper(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "shiftExpressionWrapper")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = additiveExpressionWrapper(b, l + 1);
    r = r && shiftExpressionWrapper_1(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  // shiftExpression*
  private static boolean shiftExpressionWrapper_1(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "shiftExpressionWrapper_1")) return false;
    int c = current_position_(b);
    while (true) {
      if (!shiftExpression(b, l + 1)) break;
      if (!empty_element_parsed_guard_(b, "shiftExpressionWrapper_1", c)) break;
      c = current_position_(b);
    }
    return true;
  }

  /* ********************************************************** */
  // '<<' | <<gtGt>>
  public static boolean shiftOperator(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "shiftOperator")) return false;
    boolean r;
    Marker m = enter_section_(b, l, _NONE_, SHIFT_OPERATOR, "<shift operator>");
    r = consumeToken(b, LT_LT);
    if (!r) r = gtGt(b, l + 1);
    exit_section_(b, l, m, r, false, null);
    return r;
  }

  /* ********************************************************** */
  // SHORT_TEMPLATE_ENTRY_START (thisExpression | referenceExpression)
  public static boolean shortTemplateEntry(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "shortTemplateEntry")) return false;
    if (!nextTokenIs(b, SHORT_TEMPLATE_ENTRY_START)) return false;
    boolean r, p;
    Marker m = enter_section_(b, l, _NONE_, SHORT_TEMPLATE_ENTRY, null);
    r = consumeToken(b, SHORT_TEMPLATE_ENTRY_START);
    p = r; // pin = 1
    r = r && shortTemplateEntry_1(b, l + 1);
    exit_section_(b, l, m, r, p, null);
    return r || p;
  }

  // thisExpression | referenceExpression
  private static boolean shortTemplateEntry_1(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "shortTemplateEntry_1")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = thisExpression(b, l + 1);
    if (!r) r = referenceExpression(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  /* ********************************************************** */
  // 'show' libraryReferenceList
  public static boolean showCombinator(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "showCombinator")) return false;
    if (!nextTokenIs(b, SHOW)) return false;
    boolean r, p;
    Marker m = enter_section_(b, l, _NONE_, SHOW_COMBINATOR, null);
    r = consumeToken(b, SHOW);
    p = r; // pin = 1
    r = r && libraryReferenceList(b, l + 1);
    exit_section_(b, l, m, r, p, null);
    return r || p;
  }

  /* ********************************************************** */
  // declaredIdentifier | metadata* componentName | metadata* 'covariant' componentName
  public static boolean simpleFormalParameter(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "simpleFormalParameter")) return false;
    boolean r;
    Marker m = enter_section_(b, l, _NONE_, SIMPLE_FORMAL_PARAMETER, "<simple formal parameter>");
    r = declaredIdentifier(b, l + 1);
    if (!r) r = simpleFormalParameter_1(b, l + 1);
    if (!r) r = simpleFormalParameter_2(b, l + 1);
    exit_section_(b, l, m, r, false, null);
    return r;
  }

  // metadata* componentName
  private static boolean simpleFormalParameter_1(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "simpleFormalParameter_1")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = simpleFormalParameter_1_0(b, l + 1);
    r = r && componentName(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  // metadata*
  private static boolean simpleFormalParameter_1_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "simpleFormalParameter_1_0")) return false;
    int c = current_position_(b);
    while (true) {
      if (!metadata(b, l + 1)) break;
      if (!empty_element_parsed_guard_(b, "simpleFormalParameter_1_0", c)) break;
      c = current_position_(b);
    }
    return true;
  }

  // metadata* 'covariant' componentName
  private static boolean simpleFormalParameter_2(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "simpleFormalParameter_2")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = simpleFormalParameter_2_0(b, l + 1);
    r = r && consumeToken(b, COVARIANT);
    r = r && componentName(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  // metadata*
  private static boolean simpleFormalParameter_2_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "simpleFormalParameter_2_0")) return false;
    int c = current_position_(b);
    while (true) {
      if (!metadata(b, l + 1)) break;
      if (!empty_element_parsed_guard_(b, "simpleFormalParameter_2_0", c)) break;
      c = current_position_(b);
    }
    return true;
  }

  /* ********************************************************** */
  // referenceExpression qualifiedReferenceExpression*
  public static boolean simpleQualifiedReferenceExpression(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "simpleQualifiedReferenceExpression")) return false;
    boolean r;
    Marker m = enter_section_(b, l, _COLLAPSE_, REFERENCE_EXPRESSION, "<simple qualified reference expression>");
    r = referenceExpression(b, l + 1);
    r = r && simpleQualifiedReferenceExpression_1(b, l + 1);
    exit_section_(b, l, m, r, false, null);
    return r;
  }

  // qualifiedReferenceExpression*
  private static boolean simpleQualifiedReferenceExpression_1(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "simpleQualifiedReferenceExpression_1")) return false;
    int c = current_position_(b);
    while (true) {
      if (!qualifiedReferenceExpression(b, l + 1)) break;
      if (!empty_element_parsed_guard_(b, "simpleQualifiedReferenceExpression_1", c)) break;
      c = current_position_(b);
    }
    return true;
  }

  /* ********************************************************** */
  // simpleQualifiedReferenceExpression typeArguments?
  public static boolean simpleType(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "simpleType")) return false;
    boolean r;
    Marker m = enter_section_(b, l, _NONE_, SIMPLE_TYPE, "<simple type>");
    r = simpleQualifiedReferenceExpression(b, l + 1);
    r = r && simpleType_1(b, l + 1);
    exit_section_(b, l, m, r, false, null);
    return r;
  }

  // typeArguments?
  private static boolean simpleType_1(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "simpleType_1")) return false;
    typeArguments(b, l + 1);
    return true;
  }

  /* ********************************************************** */
  // !'}'
  static boolean simple_scope_recover(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "simple_scope_recover")) return false;
    boolean r;
    Marker m = enter_section_(b, l, _NOT_);
    r = !consumeToken(b, RBRACE);
    exit_section_(b, l, m, r, false, null);
    return r;
  }

  /* ********************************************************** */
  // (superclass mixins?)? interfaces? ('native' stringLiteralExpression?)? classBody?
  static boolean standardClassDeclarationTail(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "standardClassDeclarationTail")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = standardClassDeclarationTail_0(b, l + 1);
    r = r && standardClassDeclarationTail_1(b, l + 1);
    r = r && standardClassDeclarationTail_2(b, l + 1);
    r = r && standardClassDeclarationTail_3(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  // (superclass mixins?)?
  private static boolean standardClassDeclarationTail_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "standardClassDeclarationTail_0")) return false;
    standardClassDeclarationTail_0_0(b, l + 1);
    return true;
  }

  // superclass mixins?
  private static boolean standardClassDeclarationTail_0_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "standardClassDeclarationTail_0_0")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = superclass(b, l + 1);
    r = r && standardClassDeclarationTail_0_0_1(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  // mixins?
  private static boolean standardClassDeclarationTail_0_0_1(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "standardClassDeclarationTail_0_0_1")) return false;
    mixins(b, l + 1);
    return true;
  }

  // interfaces?
  private static boolean standardClassDeclarationTail_1(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "standardClassDeclarationTail_1")) return false;
    interfaces(b, l + 1);
    return true;
  }

  // ('native' stringLiteralExpression?)?
  private static boolean standardClassDeclarationTail_2(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "standardClassDeclarationTail_2")) return false;
    standardClassDeclarationTail_2_0(b, l + 1);
    return true;
  }

  // 'native' stringLiteralExpression?
  private static boolean standardClassDeclarationTail_2_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "standardClassDeclarationTail_2_0")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = consumeToken(b, NATIVE);
    r = r && standardClassDeclarationTail_2_0_1(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  // stringLiteralExpression?
  private static boolean standardClassDeclarationTail_2_0_1(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "standardClassDeclarationTail_2_0_1")) return false;
    stringLiteralExpression(b, l + 1);
    return true;
  }

  // classBody?
  private static boolean standardClassDeclarationTail_3(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "standardClassDeclarationTail_3")) return false;
    classBody(b, l + 1);
    return true;
  }

  /* ********************************************************** */
  // label* nonLabelledStatement
  static boolean statement(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "statement")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = statement_0(b, l + 1);
    r = r && nonLabelledStatement(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  // label*
  private static boolean statement_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "statement_0")) return false;
    int c = current_position_(b);
    while (true) {
      if (!label(b, l + 1)) break;
      if (!empty_element_parsed_guard_(b, "statement_0", c)) break;
      c = current_position_(b);
    }
    return true;
  }

  /* ********************************************************** */
  // (varDeclarationList | expression) ';'
  static boolean statementFollowedBySemiColon(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "statementFollowedBySemiColon")) return false;
    boolean r, p;
    Marker m = enter_section_(b, l, _NONE_);
    r = statementFollowedBySemiColon_0(b, l + 1);
    p = r; // pin = 1
    r = r && consumeToken(b, SEMICOLON);
    exit_section_(b, l, m, r, p, null);
    return r || p;
  }

  // varDeclarationList | expression
  private static boolean statementFollowedBySemiColon_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "statementFollowedBySemiColon_0")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = varDeclarationList(b, l + 1);
    if (!r) r = expression(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  /* ********************************************************** */
  // statement*
  public static boolean statements(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "statements")) return false;
    Marker m = enter_section_(b, l, _NONE_, STATEMENTS, "<statements>");
    int c = current_position_(b);
    while (true) {
      if (!statement(b, l + 1)) break;
      if (!empty_element_parsed_guard_(b, "statements", c)) break;
      c = current_position_(b);
    }
    exit_section_(b, l, m, true, false, null);
    return true;
  }

  /* ********************************************************** */
  // (RAW_SINGLE_QUOTED_STRING | RAW_TRIPLE_QUOTED_STRING | stringTemplate)+
  public static boolean stringLiteralExpression(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "stringLiteralExpression")) return false;
    if (!nextTokenIs(b, "<string literal expression>", OPEN_QUOTE, RAW_SINGLE_QUOTED_STRING, RAW_TRIPLE_QUOTED_STRING)) return false;
    boolean r;
    Marker m = enter_section_(b, l, _NONE_, STRING_LITERAL_EXPRESSION, "<string literal expression>");
    r = stringLiteralExpression_0(b, l + 1);
    int c = current_position_(b);
    while (r) {
      if (!stringLiteralExpression_0(b, l + 1)) break;
      if (!empty_element_parsed_guard_(b, "stringLiteralExpression", c)) break;
      c = current_position_(b);
    }
    exit_section_(b, l, m, r, false, null);
    return r;
  }

  // RAW_SINGLE_QUOTED_STRING | RAW_TRIPLE_QUOTED_STRING | stringTemplate
  private static boolean stringLiteralExpression_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "stringLiteralExpression_0")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = consumeToken(b, RAW_SINGLE_QUOTED_STRING);
    if (!r) r = consumeToken(b, RAW_TRIPLE_QUOTED_STRING);
    if (!r) r = stringTemplate(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  /* ********************************************************** */
  // OPEN_QUOTE (REGULAR_STRING_PART | shortTemplateEntry | longTemplateEntry)* CLOSING_QUOTE
  static boolean stringTemplate(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "stringTemplate")) return false;
    if (!nextTokenIs(b, OPEN_QUOTE)) return false;
    boolean r, p;
    Marker m = enter_section_(b, l, _NONE_);
    r = consumeToken(b, OPEN_QUOTE);
    p = r; // pin = 1
    r = r && report_error_(b, stringTemplate_1(b, l + 1));
    r = p && consumeToken(b, CLOSING_QUOTE) && r;
    exit_section_(b, l, m, r, p, null);
    return r || p;
  }

  // (REGULAR_STRING_PART | shortTemplateEntry | longTemplateEntry)*
  private static boolean stringTemplate_1(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "stringTemplate_1")) return false;
    int c = current_position_(b);
    while (true) {
      if (!stringTemplate_1_0(b, l + 1)) break;
      if (!empty_element_parsed_guard_(b, "stringTemplate_1", c)) break;
      c = current_position_(b);
    }
    return true;
  }

  // REGULAR_STRING_PART | shortTemplateEntry | longTemplateEntry
  private static boolean stringTemplate_1_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "stringTemplate_1_0")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = consumeToken(b, REGULAR_STRING_PART);
    if (!r) r = shortTemplateEntry(b, l + 1);
    if (!r) r = longTemplateEntry(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  /* ********************************************************** */
  // '--' | '++'
  public static boolean suffixExpression(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "suffixExpression")) return false;
    if (!nextTokenIs(b, "<suffix expression>", PLUS_PLUS, MINUS_MINUS)) return false;
    boolean r;
    Marker m = enter_section_(b, l, _LEFT_, SUFFIX_EXPRESSION, "<suffix expression>");
    r = consumeToken(b, MINUS_MINUS);
    if (!r) r = consumeToken(b, PLUS_PLUS);
    exit_section_(b, l, m, r, false, null);
    return r;
  }

  /* ********************************************************** */
  // valueExpression suffixExpression*
  static boolean suffixExpressionWrapper(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "suffixExpressionWrapper")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = valueExpression(b, l + 1);
    r = r && suffixExpressionWrapper_1(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  // suffixExpression*
  private static boolean suffixExpressionWrapper_1(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "suffixExpressionWrapper_1")) return false;
    int c = current_position_(b);
    while (true) {
      if (!suffixExpression(b, l + 1)) break;
      if (!empty_element_parsed_guard_(b, "suffixExpressionWrapper_1", c)) break;
      c = current_position_(b);
    }
    return true;
  }

  /* ********************************************************** */
  // (superExpression | thisExpression) ('.' referenceExpression)? <<argumentsWrapper>>
  //                               | fieldInitializer
  //                               | assertStatement
  public static boolean superCallOrFieldInitializer(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "superCallOrFieldInitializer")) return false;
    boolean r;
    Marker m = enter_section_(b, l, _NONE_, SUPER_CALL_OR_FIELD_INITIALIZER, "<super call or field initializer>");
    r = superCallOrFieldInitializer_0(b, l + 1);
    if (!r) r = fieldInitializer(b, l + 1);
    if (!r) r = assertStatement(b, l + 1);
    exit_section_(b, l, m, r, false, super_call_or_field_initializer_recover_parser_);
    return r;
  }

  // (superExpression | thisExpression) ('.' referenceExpression)? <<argumentsWrapper>>
  private static boolean superCallOrFieldInitializer_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "superCallOrFieldInitializer_0")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = superCallOrFieldInitializer_0_0(b, l + 1);
    r = r && superCallOrFieldInitializer_0_1(b, l + 1);
    r = r && argumentsWrapper(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  // superExpression | thisExpression
  private static boolean superCallOrFieldInitializer_0_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "superCallOrFieldInitializer_0_0")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = superExpression(b, l + 1);
    if (!r) r = thisExpression(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  // ('.' referenceExpression)?
  private static boolean superCallOrFieldInitializer_0_1(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "superCallOrFieldInitializer_0_1")) return false;
    superCallOrFieldInitializer_0_1_0(b, l + 1);
    return true;
  }

  // '.' referenceExpression
  private static boolean superCallOrFieldInitializer_0_1_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "superCallOrFieldInitializer_0_1_0")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = consumeToken(b, DOT);
    r = r && referenceExpression(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  /* ********************************************************** */
  // 'super'
  public static boolean superExpression(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "superExpression")) return false;
    if (!nextTokenIs(b, SUPER)) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = consumeToken(b, SUPER);
    exit_section_(b, m, SUPER_EXPRESSION, r);
    return r;
  }

  /* ********************************************************** */
  // !(<<nonStrictID>> | ',' | ':' | ';' | '=>' | '@' | 'abstract' | 'async' | 'class' | 'const' |
  //                                                       'export' | 'external' | 'factory' | 'final' | 'get' | 'import' | 'library' |
  //                                                       'native' | 'operator' | 'part' | 'set' | 'static' | 'sync' | 'typedef' | 'var' | 'void' | '{' |
  //                                                       '}' )
  static boolean super_call_or_field_initializer_recover(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "super_call_or_field_initializer_recover")) return false;
    boolean r;
    Marker m = enter_section_(b, l, _NOT_);
    r = !super_call_or_field_initializer_recover_0(b, l + 1);
    exit_section_(b, l, m, r, false, null);
    return r;
  }

  // <<nonStrictID>> | ',' | ':' | ';' | '=>' | '@' | 'abstract' | 'async' | 'class' | 'const' |
  //                                                       'export' | 'external' | 'factory' | 'final' | 'get' | 'import' | 'library' |
  //                                                       'native' | 'operator' | 'part' | 'set' | 'static' | 'sync' | 'typedef' | 'var' | 'void' | '{' |
  //                                                       '}'
  private static boolean super_call_or_field_initializer_recover_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "super_call_or_field_initializer_recover_0")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = nonStrictID(b, l + 1);
    if (!r) r = consumeToken(b, COMMA);
    if (!r) r = consumeToken(b, COLON);
    if (!r) r = consumeToken(b, SEMICOLON);
    if (!r) r = consumeToken(b, EXPRESSION_BODY_DEF);
    if (!r) r = consumeToken(b, AT);
    if (!r) r = consumeToken(b, ABSTRACT);
    if (!r) r = consumeToken(b, ASYNC);
    if (!r) r = consumeToken(b, CLASS);
    if (!r) r = consumeToken(b, CONST);
    if (!r) r = consumeToken(b, EXPORT);
    if (!r) r = consumeToken(b, EXTERNAL);
    if (!r) r = consumeToken(b, FACTORY);
    if (!r) r = consumeToken(b, FINAL);
    if (!r) r = consumeToken(b, GET);
    if (!r) r = consumeToken(b, IMPORT);
    if (!r) r = consumeToken(b, LIBRARY);
    if (!r) r = consumeToken(b, NATIVE);
    if (!r) r = consumeToken(b, OPERATOR);
    if (!r) r = consumeToken(b, PART);
    if (!r) r = consumeToken(b, SET);
    if (!r) r = consumeToken(b, STATIC);
    if (!r) r = consumeToken(b, SYNC);
    if (!r) r = consumeToken(b, TYPEDEF);
    if (!r) r = consumeToken(b, VAR);
    if (!r) r = consumeToken(b, VOID);
    if (!r) r = consumeToken(b, LBRACE);
    if (!r) r = consumeToken(b, RBRACE);
    exit_section_(b, m, null, r);
    return r;
  }

  /* ********************************************************** */
  // 'extends' type
  public static boolean superclass(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "superclass")) return false;
    if (!nextTokenIs(b, EXTENDS)) return false;
    boolean r, p;
    Marker m = enter_section_(b, l, _NONE_, SUPERCLASS, null);
    r = consumeToken(b, EXTENDS);
    p = r; // pin = 1
    r = r && type(b, l + 1);
    exit_section_(b, l, m, r, p, null);
    return r || p;
  }

  /* ********************************************************** */
  // label* 'case' expression ':' statements
  public static boolean switchCase(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "switchCase")) return false;
    boolean r, p;
    Marker m = enter_section_(b, l, _NONE_, SWITCH_CASE, "<switch case>");
    r = switchCase_0(b, l + 1);
    r = r && consumeToken(b, CASE);
    p = r; // pin = 2
    r = r && report_error_(b, expression(b, l + 1));
    r = p && report_error_(b, consumeToken(b, COLON)) && r;
    r = p && statements(b, l + 1) && r;
    exit_section_(b, l, m, r, p, null);
    return r || p;
  }

  // label*
  private static boolean switchCase_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "switchCase_0")) return false;
    int c = current_position_(b);
    while (true) {
      if (!label(b, l + 1)) break;
      if (!empty_element_parsed_guard_(b, "switchCase_0", c)) break;
      c = current_position_(b);
    }
    return true;
  }

  /* ********************************************************** */
  // 'switch' '(' expressionWithRecoverUntilParen ')' '{' switchCase* defaultCase? '}'
  public static boolean switchStatement(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "switchStatement")) return false;
    if (!nextTokenIs(b, SWITCH)) return false;
    boolean r, p;
    Marker m = enter_section_(b, l, _NONE_, SWITCH_STATEMENT, null);
    r = consumeTokens(b, 1, SWITCH, LPAREN);
    p = r; // pin = 1
    r = r && report_error_(b, expressionWithRecoverUntilParen(b, l + 1));
    r = p && report_error_(b, consumeTokens(b, -1, RPAREN, LBRACE)) && r;
    r = p && report_error_(b, switchStatement_5(b, l + 1)) && r;
    r = p && report_error_(b, switchStatement_6(b, l + 1)) && r;
    r = p && consumeToken(b, RBRACE) && r;
    exit_section_(b, l, m, r, p, null);
    return r || p;
  }

  // switchCase*
  private static boolean switchStatement_5(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "switchStatement_5")) return false;
    int c = current_position_(b);
    while (true) {
      if (!switchCase(b, l + 1)) break;
      if (!empty_element_parsed_guard_(b, "switchStatement_5", c)) break;
      c = current_position_(b);
    }
    return true;
  }

  // defaultCase?
  private static boolean switchStatement_6(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "switchStatement_6")) return false;
    defaultCase(b, l + 1);
    return true;
  }

  /* ********************************************************** */
  // '#' ('void' | userDefinableOperator | simpleQualifiedReferenceExpression)
  public static boolean symbolLiteralExpression(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "symbolLiteralExpression")) return false;
    if (!nextTokenIs(b, HASH)) return false;
    boolean r, p;
    Marker m = enter_section_(b, l, _NONE_, SYMBOL_LITERAL_EXPRESSION, null);
    r = consumeToken(b, HASH);
    p = r; // pin = 1
    r = r && symbolLiteralExpression_1(b, l + 1);
    exit_section_(b, l, m, r, p, null);
    return r || p;
  }

  // 'void' | userDefinableOperator | simpleQualifiedReferenceExpression
  private static boolean symbolLiteralExpression_1(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "symbolLiteralExpression_1")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = consumeToken(b, VOID);
    if (!r) r = userDefinableOperator(b, l + 1);
    if (!r) r = simpleQualifiedReferenceExpression(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  /* ********************************************************** */
  // '?' expression ':' ternaryExpressionWrapper
  public static boolean ternaryExpression(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "ternaryExpression")) return false;
    if (!nextTokenIs(b, QUEST)) return false;
    boolean r;
    Marker m = enter_section_(b, l, _LEFT_, TERNARY_EXPRESSION, null);
    r = consumeToken(b, QUEST);
    r = r && expression(b, l + 1);
    r = r && consumeToken(b, COLON);
    r = r && ternaryExpressionWrapper(b, l + 1);
    exit_section_(b, l, m, r, false, null);
    return r;
  }

  /* ********************************************************** */
  // ifNullExpressionWrapper ternaryExpression?
  static boolean ternaryExpressionWrapper(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "ternaryExpressionWrapper")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = ifNullExpressionWrapper(b, l + 1);
    r = r && ternaryExpressionWrapper_1(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  // ternaryExpression?
  private static boolean ternaryExpressionWrapper_1(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "ternaryExpressionWrapper_1")) return false;
    ternaryExpression(b, l + 1);
    return true;
  }

  /* ********************************************************** */
  // 'this'
  public static boolean thisExpression(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "thisExpression")) return false;
    if (!nextTokenIs(b, THIS)) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = consumeToken(b, THIS);
    exit_section_(b, m, THIS_EXPRESSION, r);
    return r;
  }

  /* ********************************************************** */
  // 'throw' expression
  public static boolean throwExpression(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "throwExpression")) return false;
    if (!nextTokenIs(b, THROW)) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = consumeToken(b, THROW);
    r = r && expression(b, l + 1);
    exit_section_(b, m, THROW_EXPRESSION, r);
    return r;
  }

  /* ********************************************************** */
  // libraryStatement
  //                              | partOfStatement
  //                              | importStatement
  //                              | exportStatement
  //                              | partStatement
  //                              | classDefinition
  //                              | enumDefinition
  //                              | functionTypeAlias
  //                              | getterOrSetterDeclaration
  //                              | functionDeclarationWithBodyOrNative
  //                              | varDeclarationListWithSemicolon
  //                              | incompleteDeclaration
  static boolean topLevelDefinition(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "topLevelDefinition")) return false;
    boolean r;
    Marker m = enter_section_(b, l, _NONE_);
    r = libraryStatement(b, l + 1);
    if (!r) r = partOfStatement(b, l + 1);
    if (!r) r = importStatement(b, l + 1);
    if (!r) r = exportStatement(b, l + 1);
    if (!r) r = partStatement(b, l + 1);
    if (!r) r = classDefinition(b, l + 1);
    if (!r) r = enumDefinition(b, l + 1);
    if (!r) r = functionTypeAlias(b, l + 1);
    if (!r) r = getterOrSetterDeclaration(b, l + 1);
    if (!r) r = functionDeclarationWithBodyOrNative(b, l + 1);
    if (!r) r = varDeclarationListWithSemicolon(b, l + 1);
    if (!r) r = incompleteDeclaration(b, l + 1);
    exit_section_(b, l, m, r, false, top_level_recover_parser_);
    return r;
  }

  /* ********************************************************** */
  // !(<<nonStrictID>> | '@' | 'abstract' | 'class' | 'const' | 'enum' | 'export' | 'external' | 'final' | 'get' | 'import' | 'library' | 'part' | 'set' | 'static' | 'typedef' | 'var' | 'void')
  static boolean top_level_recover(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "top_level_recover")) return false;
    boolean r;
    Marker m = enter_section_(b, l, _NOT_);
    r = !top_level_recover_0(b, l + 1);
    exit_section_(b, l, m, r, false, null);
    return r;
  }

  // <<nonStrictID>> | '@' | 'abstract' | 'class' | 'const' | 'enum' | 'export' | 'external' | 'final' | 'get' | 'import' | 'library' | 'part' | 'set' | 'static' | 'typedef' | 'var' | 'void'
  private static boolean top_level_recover_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "top_level_recover_0")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = nonStrictID(b, l + 1);
    if (!r) r = consumeToken(b, AT);
    if (!r) r = consumeToken(b, ABSTRACT);
    if (!r) r = consumeToken(b, CLASS);
    if (!r) r = consumeToken(b, CONST);
    if (!r) r = consumeToken(b, ENUM);
    if (!r) r = consumeToken(b, EXPORT);
    if (!r) r = consumeToken(b, EXTERNAL);
    if (!r) r = consumeToken(b, FINAL);
    if (!r) r = consumeToken(b, GET);
    if (!r) r = consumeToken(b, IMPORT);
    if (!r) r = consumeToken(b, LIBRARY);
    if (!r) r = consumeToken(b, PART);
    if (!r) r = consumeToken(b, SET);
    if (!r) r = consumeToken(b, STATIC);
    if (!r) r = consumeToken(b, TYPEDEF);
    if (!r) r = consumeToken(b, VAR);
    if (!r) r = consumeToken(b, VOID);
    exit_section_(b, m, null, r);
    return r;
  }

  /* ********************************************************** */
  // 'try' block (onPart+ finallyPart? | finallyPart)
  public static boolean tryStatement(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "tryStatement")) return false;
    if (!nextTokenIs(b, TRY)) return false;
    boolean r, p;
    Marker m = enter_section_(b, l, _NONE_, TRY_STATEMENT, null);
    r = consumeToken(b, TRY);
    p = r; // pin = 1
    r = r && report_error_(b, block(b, l + 1));
    r = p && tryStatement_2(b, l + 1) && r;
    exit_section_(b, l, m, r, p, null);
    return r || p;
  }

  // onPart+ finallyPart? | finallyPart
  private static boolean tryStatement_2(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "tryStatement_2")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = tryStatement_2_0(b, l + 1);
    if (!r) r = finallyPart(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  // onPart+ finallyPart?
  private static boolean tryStatement_2_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "tryStatement_2_0")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = tryStatement_2_0_0(b, l + 1);
    r = r && tryStatement_2_0_1(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  // onPart+
  private static boolean tryStatement_2_0_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "tryStatement_2_0_0")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = onPart(b, l + 1);
    int c = current_position_(b);
    while (r) {
      if (!onPart(b, l + 1)) break;
      if (!empty_element_parsed_guard_(b, "tryStatement_2_0_0", c)) break;
      c = current_position_(b);
    }
    exit_section_(b, m, null, r);
    return r;
  }

  // finallyPart?
  private static boolean tryStatement_2_0_1(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "tryStatement_2_0_1")) return false;
    finallyPart(b, l + 1);
    return true;
  }

  /* ********************************************************** */
  // functionTypeWrapper | simpleType
  public static boolean type(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "type")) return false;
    boolean r;
    Marker m = enter_section_(b, l, _NONE_, TYPE, "<type>");
    r = functionTypeWrapper(b, l + 1);
    if (!r) r = simpleType(b, l + 1);
    exit_section_(b, l, m, r, false, null);
    return r;
  }

  /* ********************************************************** */
  // '<' typeList '>'
  public static boolean typeArguments(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "typeArguments")) return false;
    if (!nextTokenIs(b, LT)) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = consumeToken(b, LT);
    r = r && typeList(b, l + 1);
    r = r && consumeToken(b, GT);
    exit_section_(b, m, TYPE_ARGUMENTS, r);
    return r;
  }

  /* ********************************************************** */
  // type? (',' type)*
  public static boolean typeList(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "typeList")) return false;
    boolean r;
    Marker m = enter_section_(b, l, _NONE_, TYPE_LIST, "<type list>");
    r = typeList_0(b, l + 1);
    r = r && typeList_1(b, l + 1);
    exit_section_(b, l, m, r, false, null);
    return r;
  }

  // type?
  private static boolean typeList_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "typeList_0")) return false;
    type(b, l + 1);
    return true;
  }

  // (',' type)*
  private static boolean typeList_1(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "typeList_1")) return false;
    int c = current_position_(b);
    while (true) {
      if (!typeList_1_0(b, l + 1)) break;
      if (!empty_element_parsed_guard_(b, "typeList_1", c)) break;
      c = current_position_(b);
    }
    return true;
  }

  // ',' type
  private static boolean typeList_1_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "typeList_1_0")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = consumeToken(b, COMMA);
    r = r && type(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  /* ********************************************************** */
  // metadata* componentName ('extends' type)?
  public static boolean typeParameter(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "typeParameter")) return false;
    boolean r;
    Marker m = enter_section_(b, l, _NONE_, TYPE_PARAMETER, "<type parameter>");
    r = typeParameter_0(b, l + 1);
    r = r && componentName(b, l + 1);
    r = r && typeParameter_2(b, l + 1);
    exit_section_(b, l, m, r, false, type_parameter_recover_parser_);
    return r;
  }

  // metadata*
  private static boolean typeParameter_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "typeParameter_0")) return false;
    int c = current_position_(b);
    while (true) {
      if (!metadata(b, l + 1)) break;
      if (!empty_element_parsed_guard_(b, "typeParameter_0", c)) break;
      c = current_position_(b);
    }
    return true;
  }

  // ('extends' type)?
  private static boolean typeParameter_2(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "typeParameter_2")) return false;
    typeParameter_2_0(b, l + 1);
    return true;
  }

  // 'extends' type
  private static boolean typeParameter_2_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "typeParameter_2_0")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = consumeToken(b, EXTENDS);
    r = r && type(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  /* ********************************************************** */
  // '<' typeParameter? (',' typeParameter)* '>'
  public static boolean typeParameters(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "typeParameters")) return false;
    if (!nextTokenIs(b, LT)) return false;
    boolean r, p;
    Marker m = enter_section_(b, l, _NONE_, TYPE_PARAMETERS, null);
    r = consumeToken(b, LT);
    p = r; // pin = 1
    r = r && report_error_(b, typeParameters_1(b, l + 1));
    r = p && report_error_(b, typeParameters_2(b, l + 1)) && r;
    r = p && consumeToken(b, GT) && r;
    exit_section_(b, l, m, r, p, null);
    return r || p;
  }

  // typeParameter?
  private static boolean typeParameters_1(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "typeParameters_1")) return false;
    typeParameter(b, l + 1);
    return true;
  }

  // (',' typeParameter)*
  private static boolean typeParameters_2(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "typeParameters_2")) return false;
    int c = current_position_(b);
    while (true) {
      if (!typeParameters_2_0(b, l + 1)) break;
      if (!empty_element_parsed_guard_(b, "typeParameters_2", c)) break;
      c = current_position_(b);
    }
    return true;
  }

  // ',' typeParameter
  private static boolean typeParameters_2_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "typeParameters_2_0")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = consumeToken(b, COMMA);
    r = r && typeParameter(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  /* ********************************************************** */
  // !(<<nonStrictID>> | '(' | ',' | '=' | '>' | '@' | 'abstract' | 'class' | 'const' | 'export' | 'extends' |
  //                                      'external' | 'final' | 'get' | 'implements' | 'import' | 'library' | 'native' | 'part' | 'set' |
  //                                      'static' | 'typedef' | 'var' | 'void' | '{')
  static boolean type_parameter_recover(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "type_parameter_recover")) return false;
    boolean r;
    Marker m = enter_section_(b, l, _NOT_);
    r = !type_parameter_recover_0(b, l + 1);
    exit_section_(b, l, m, r, false, null);
    return r;
  }

  // <<nonStrictID>> | '(' | ',' | '=' | '>' | '@' | 'abstract' | 'class' | 'const' | 'export' | 'extends' |
  //                                      'external' | 'final' | 'get' | 'implements' | 'import' | 'library' | 'native' | 'part' | 'set' |
  //                                      'static' | 'typedef' | 'var' | 'void' | '{'
  private static boolean type_parameter_recover_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "type_parameter_recover_0")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = nonStrictID(b, l + 1);
    if (!r) r = consumeToken(b, LPAREN);
    if (!r) r = consumeToken(b, COMMA);
    if (!r) r = consumeToken(b, EQ);
    if (!r) r = consumeToken(b, GT);
    if (!r) r = consumeToken(b, AT);
    if (!r) r = consumeToken(b, ABSTRACT);
    if (!r) r = consumeToken(b, CLASS);
    if (!r) r = consumeToken(b, CONST);
    if (!r) r = consumeToken(b, EXPORT);
    if (!r) r = consumeToken(b, EXTENDS);
    if (!r) r = consumeToken(b, EXTERNAL);
    if (!r) r = consumeToken(b, FINAL);
    if (!r) r = consumeToken(b, GET);
    if (!r) r = consumeToken(b, IMPLEMENTS);
    if (!r) r = consumeToken(b, IMPORT);
    if (!r) r = consumeToken(b, LIBRARY);
    if (!r) r = consumeToken(b, NATIVE);
    if (!r) r = consumeToken(b, PART);
    if (!r) r = consumeToken(b, SET);
    if (!r) r = consumeToken(b, STATIC);
    if (!r) r = consumeToken(b, TYPEDEF);
    if (!r) r = consumeToken(b, VAR);
    if (!r) r = consumeToken(b, VOID);
    if (!r) r = consumeToken(b, LBRACE);
    exit_section_(b, m, null, r);
    return r;
  }

  /* ********************************************************** */
  // <<functionId>> typeParameters? parameterTypeList
  public static boolean typedFunctionType(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "typedFunctionType")) return false;
    boolean r;
    Marker m = enter_section_(b, l, _LEFT_, TYPED_FUNCTION_TYPE, "<typed function type>");
    r = functionId(b, l + 1);
    r = r && typedFunctionType_1(b, l + 1);
    r = r && parameterTypeList(b, l + 1);
    exit_section_(b, l, m, r, false, null);
    return r;
  }

  // typeParameters?
  private static boolean typedFunctionType_1(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "typedFunctionType_1")) return false;
    typeParameters(b, l + 1);
    return true;
  }

  /* ********************************************************** */
  // type <<nonStrictID>>
  static boolean typedIdentifier(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "typedIdentifier")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = type(b, l + 1);
    r = r && nonStrictID(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  /* ********************************************************** */
  // <<functionId>> typeParameters? parameterTypeList
  public static boolean untypedFunctionType(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "untypedFunctionType")) return false;
    boolean r;
    Marker m = enter_section_(b, l, _NONE_, UNTYPED_FUNCTION_TYPE, "<untyped function type>");
    r = functionId(b, l + 1);
    r = r && untypedFunctionType_1(b, l + 1);
    r = r && parameterTypeList(b, l + 1);
    exit_section_(b, l, m, r, false, null);
    return r;
  }

  // typeParameters?
  private static boolean untypedFunctionType_1(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "untypedFunctionType_1")) return false;
    typeParameters(b, l + 1);
    return true;
  }

  /* ********************************************************** */
  // stringLiteralExpression
  public static boolean uriElement(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "uriElement")) return false;
    if (!nextTokenIs(b, "<uri element>", OPEN_QUOTE, RAW_SINGLE_QUOTED_STRING, RAW_TRIPLE_QUOTED_STRING)) return false;
    boolean r;
    Marker m = enter_section_(b, l, _NONE_, URI_ELEMENT, "<uri element>");
    r = stringLiteralExpression(b, l + 1);
    exit_section_(b, l, m, r, false, null);
    return r;
  }

  /* ********************************************************** */
  // binaryOperator |
  //                           '~' |
  //                           '[' ']' '='?
  public static boolean userDefinableOperator(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "userDefinableOperator")) return false;
    boolean r;
    Marker m = enter_section_(b, l, _NONE_, USER_DEFINABLE_OPERATOR, "<user definable operator>");
    r = binaryOperator(b, l + 1);
    if (!r) r = consumeToken(b, BIN_NOT);
    if (!r) r = userDefinableOperator_2(b, l + 1);
    exit_section_(b, l, m, r, false, null);
    return r;
  }

  // '[' ']' '='?
  private static boolean userDefinableOperator_2(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "userDefinableOperator_2")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = consumeTokens(b, 0, LBRACKET, RBRACKET);
    r = r && userDefinableOperator_2_2(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  // '='?
  private static boolean userDefinableOperator_2_2(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "userDefinableOperator_2_2")) return false;
    consumeToken(b, EQ);
    return true;
  }

  /* ********************************************************** */
  // primary callOrArrayAccessOrQualifiedRefExpression (isExpression | asExpression)? cascadeReferenceExpression*
  public static boolean valueExpression(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "valueExpression")) return false;
    boolean r;
    Marker m = enter_section_(b, l, _COLLAPSE_, VALUE_EXPRESSION, "<value expression>");
    r = primary(b, l + 1);
    r = r && callOrArrayAccessOrQualifiedRefExpression(b, l + 1);
    r = r && valueExpression_2(b, l + 1);
    r = r && valueExpression_3(b, l + 1);
    exit_section_(b, l, m, r, false, null);
    return r;
  }

  // (isExpression | asExpression)?
  private static boolean valueExpression_2(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "valueExpression_2")) return false;
    valueExpression_2_0(b, l + 1);
    return true;
  }

  // isExpression | asExpression
  private static boolean valueExpression_2_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "valueExpression_2_0")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = isExpression(b, l + 1);
    if (!r) r = asExpression(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  // cascadeReferenceExpression*
  private static boolean valueExpression_3(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "valueExpression_3")) return false;
    int c = current_position_(b);
    while (true) {
      if (!cascadeReferenceExpression(b, l + 1)) break;
      if (!empty_element_parsed_guard_(b, "valueExpression_3", c)) break;
      c = current_position_(b);
    }
    return true;
  }

  /* ********************************************************** */
  // metadata* 'static'? ('covariant'? finalOrConst type               componentName |
  //                                               'covariant'? finalOrConst                    componentName <<failIfItLooksLikeConstantObjectExpression>> |
  //                                               'covariant'               type !asExpression componentName |
  //                                                                         type !asExpression componentName |
  //                                               'covariant'? 'var'                           componentName)
  public static boolean varAccessDeclaration(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "varAccessDeclaration")) return false;
    boolean r;
    Marker m = enter_section_(b, l, _NONE_, VAR_ACCESS_DECLARATION, "<var access declaration>");
    r = varAccessDeclaration_0(b, l + 1);
    r = r && varAccessDeclaration_1(b, l + 1);
    r = r && varAccessDeclaration_2(b, l + 1);
    exit_section_(b, l, m, r, false, null);
    return r;
  }

  // metadata*
  private static boolean varAccessDeclaration_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "varAccessDeclaration_0")) return false;
    int c = current_position_(b);
    while (true) {
      if (!metadata(b, l + 1)) break;
      if (!empty_element_parsed_guard_(b, "varAccessDeclaration_0", c)) break;
      c = current_position_(b);
    }
    return true;
  }

  // 'static'?
  private static boolean varAccessDeclaration_1(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "varAccessDeclaration_1")) return false;
    consumeToken(b, STATIC);
    return true;
  }

  // 'covariant'? finalOrConst type               componentName |
  //                                               'covariant'? finalOrConst                    componentName <<failIfItLooksLikeConstantObjectExpression>> |
  //                                               'covariant'               type !asExpression componentName |
  //                                                                         type !asExpression componentName |
  //                                               'covariant'? 'var'                           componentName
  private static boolean varAccessDeclaration_2(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "varAccessDeclaration_2")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = varAccessDeclaration_2_0(b, l + 1);
    if (!r) r = varAccessDeclaration_2_1(b, l + 1);
    if (!r) r = varAccessDeclaration_2_2(b, l + 1);
    if (!r) r = varAccessDeclaration_2_3(b, l + 1);
    if (!r) r = varAccessDeclaration_2_4(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  // 'covariant'? finalOrConst type               componentName
  private static boolean varAccessDeclaration_2_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "varAccessDeclaration_2_0")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = varAccessDeclaration_2_0_0(b, l + 1);
    r = r && finalOrConst(b, l + 1);
    r = r && type(b, l + 1);
    r = r && componentName(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  // 'covariant'?
  private static boolean varAccessDeclaration_2_0_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "varAccessDeclaration_2_0_0")) return false;
    consumeToken(b, COVARIANT);
    return true;
  }

  // 'covariant'? finalOrConst                    componentName <<failIfItLooksLikeConstantObjectExpression>>
  private static boolean varAccessDeclaration_2_1(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "varAccessDeclaration_2_1")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = varAccessDeclaration_2_1_0(b, l + 1);
    r = r && finalOrConst(b, l + 1);
    r = r && componentName(b, l + 1);
    r = r && failIfItLooksLikeConstantObjectExpression(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  // 'covariant'?
  private static boolean varAccessDeclaration_2_1_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "varAccessDeclaration_2_1_0")) return false;
    consumeToken(b, COVARIANT);
    return true;
  }

  // 'covariant'               type !asExpression componentName
  private static boolean varAccessDeclaration_2_2(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "varAccessDeclaration_2_2")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = consumeToken(b, COVARIANT);
    r = r && type(b, l + 1);
    r = r && varAccessDeclaration_2_2_2(b, l + 1);
    r = r && componentName(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  // !asExpression
  private static boolean varAccessDeclaration_2_2_2(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "varAccessDeclaration_2_2_2")) return false;
    boolean r;
    Marker m = enter_section_(b, l, _NOT_);
    r = !asExpression(b, l + 1);
    exit_section_(b, l, m, r, false, null);
    return r;
  }

  // type !asExpression componentName
  private static boolean varAccessDeclaration_2_3(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "varAccessDeclaration_2_3")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = type(b, l + 1);
    r = r && varAccessDeclaration_2_3_1(b, l + 1);
    r = r && componentName(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  // !asExpression
  private static boolean varAccessDeclaration_2_3_1(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "varAccessDeclaration_2_3_1")) return false;
    boolean r;
    Marker m = enter_section_(b, l, _NOT_);
    r = !asExpression(b, l + 1);
    exit_section_(b, l, m, r, false, null);
    return r;
  }

  // 'covariant'? 'var'                           componentName
  private static boolean varAccessDeclaration_2_4(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "varAccessDeclaration_2_4")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = varAccessDeclaration_2_4_0(b, l + 1);
    r = r && consumeToken(b, VAR);
    r = r && componentName(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  // 'covariant'?
  private static boolean varAccessDeclaration_2_4_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "varAccessDeclaration_2_4_0")) return false;
    consumeToken(b, COVARIANT);
    return true;
  }

  /* ********************************************************** */
  // varAccessDeclaration varInit? (',' varDeclarationListPart)*
  public static boolean varDeclarationList(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "varDeclarationList")) return false;
    boolean r;
    Marker m = enter_section_(b, l, _NONE_, VAR_DECLARATION_LIST, "<var declaration list>");
    r = varAccessDeclaration(b, l + 1);
    r = r && varDeclarationList_1(b, l + 1);
    r = r && varDeclarationList_2(b, l + 1);
    exit_section_(b, l, m, r, false, null);
    return r;
  }

  // varInit?
  private static boolean varDeclarationList_1(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "varDeclarationList_1")) return false;
    varInit(b, l + 1);
    return true;
  }

  // (',' varDeclarationListPart)*
  private static boolean varDeclarationList_2(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "varDeclarationList_2")) return false;
    int c = current_position_(b);
    while (true) {
      if (!varDeclarationList_2_0(b, l + 1)) break;
      if (!empty_element_parsed_guard_(b, "varDeclarationList_2", c)) break;
      c = current_position_(b);
    }
    return true;
  }

  // ',' varDeclarationListPart
  private static boolean varDeclarationList_2_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "varDeclarationList_2_0")) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = consumeToken(b, COMMA);
    r = r && varDeclarationListPart(b, l + 1);
    exit_section_(b, m, null, r);
    return r;
  }

  /* ********************************************************** */
  // componentName varInit?
  public static boolean varDeclarationListPart(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "varDeclarationListPart")) return false;
    boolean r;
    Marker m = enter_section_(b, l, _NONE_, VAR_DECLARATION_LIST_PART, "<var declaration list part>");
    r = componentName(b, l + 1);
    r = r && varDeclarationListPart_1(b, l + 1);
    exit_section_(b, l, m, r, false, null);
    return r;
  }

  // varInit?
  private static boolean varDeclarationListPart_1(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "varDeclarationListPart_1")) return false;
    varInit(b, l + 1);
    return true;
  }

  /* ********************************************************** */
  // varDeclarationList ';'
  static boolean varDeclarationListWithSemicolon(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "varDeclarationListWithSemicolon")) return false;
    boolean r, p;
    Marker m = enter_section_(b, l, _NONE_);
    r = varDeclarationList(b, l + 1);
    p = r; // pin = 1
    r = r && consumeToken(b, SEMICOLON);
    exit_section_(b, l, m, r, p, null);
    return r || p;
  }

  /* ********************************************************** */
  // '=' type ['.' referenceExpression]
  static boolean varFactoryDeclaration(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "varFactoryDeclaration")) return false;
    if (!nextTokenIs(b, EQ)) return false;
    boolean r, p;
    Marker m = enter_section_(b, l, _NONE_);
    r = consumeToken(b, EQ);
    p = r; // pin = 1
    r = r && report_error_(b, type(b, l + 1));
    r = p && varFactoryDeclaration_2(b, l + 1) && r;
    exit_section_(b, l, m, r, p, null);
    return r || p;
  }

  // ['.' referenceExpression]
  private static boolean varFactoryDeclaration_2(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "varFactoryDeclaration_2")) return false;
    varFactoryDeclaration_2_0(b, l + 1);
    return true;
  }

  // '.' referenceExpression
  private static boolean varFactoryDeclaration_2_0(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "varFactoryDeclaration_2_0")) return false;
    boolean r, p;
    Marker m = enter_section_(b, l, _NONE_);
    r = consumeToken(b, DOT);
    p = r; // pin = 1
    r = r && referenceExpression(b, l + 1);
    exit_section_(b, l, m, r, p, null);
    return r || p;
  }

  /* ********************************************************** */
  // '=' expression
  public static boolean varInit(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "varInit")) return false;
    if (!nextTokenIs(b, EQ)) return false;
    boolean r, p;
    Marker m = enter_section_(b, l, _NONE_, VAR_INIT, null);
    r = consumeToken(b, EQ);
    p = r; // pin = 1
    r = r && expression(b, l + 1);
    exit_section_(b, l, m, r, p, null);
    return r || p;
  }

  /* ********************************************************** */
  // 'void'
  public static boolean voidTypeFunctionType(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "voidTypeFunctionType")) return false;
    if (!nextTokenIs(b, VOID)) return false;
    boolean r;
    Marker m = enter_section_(b);
    r = consumeToken(b, VOID);
    exit_section_(b, m, VOID_TYPE_FUNCTION_TYPE, r);
    return r;
  }

  /* ********************************************************** */
  // 'while' '(' expressionWithRecoverUntilParen ')' statement
  public static boolean whileStatement(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "whileStatement")) return false;
    if (!nextTokenIs(b, WHILE)) return false;
    boolean r, p;
    Marker m = enter_section_(b, l, _NONE_, WHILE_STATEMENT, null);
    r = consumeTokens(b, 1, WHILE, LPAREN);
    p = r; // pin = 1
    r = r && report_error_(b, expressionWithRecoverUntilParen(b, l + 1));
    r = p && report_error_(b, consumeToken(b, RPAREN)) && r;
    r = p && statement(b, l + 1) && r;
    exit_section_(b, l, m, r, p, null);
    return r || p;
  }

  /* ********************************************************** */
  // 'yield' '*' expression ';'
  public static boolean yieldEachStatement(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "yieldEachStatement")) return false;
    if (!nextTokenIs(b, YIELD)) return false;
    boolean r, p;
    Marker m = enter_section_(b, l, _NONE_, YIELD_EACH_STATEMENT, null);
    r = consumeTokens(b, 2, YIELD, MUL);
    p = r; // pin = 2
    r = r && report_error_(b, expression(b, l + 1));
    r = p && consumeToken(b, SEMICOLON) && r;
    exit_section_(b, l, m, r, p, null);
    return r || p;
  }

  /* ********************************************************** */
  // 'yield' expression ';'
  public static boolean yieldStatement(PsiBuilder b, int l) {
    if (!recursion_guard_(b, l, "yieldStatement")) return false;
    if (!nextTokenIs(b, YIELD)) return false;
    boolean r, p;
    Marker m = enter_section_(b, l, _NONE_, YIELD_STATEMENT, null);
    r = consumeToken(b, YIELD);
    p = r; // pin = 1
    r = r && report_error_(b, expression(b, l + 1));
    r = p && consumeToken(b, SEMICOLON) && r;
    exit_section_(b, l, m, r, p, null);
    return r || p;
  }

  final static Parser argument_list_part_recover_parser_ = new Parser() {
    public boolean parse(PsiBuilder b, int l) {
      return argument_list_part_recover(b, l + 1);
    }
  };
  final static Parser argument_list_recover_parser_ = new Parser() {
    public boolean parse(PsiBuilder b, int l) {
      return argument_list_recover(b, l + 1);
    }
  };
  final static Parser class_member_recover_parser_ = new Parser() {
    public boolean parse(PsiBuilder b, int l) {
      return class_member_recover(b, l + 1);
    }
  };
  final static Parser default_formal_parameter_recover_parser_ = new Parser() {
    public boolean parse(PsiBuilder b, int l) {
      return default_formal_parameter_recover(b, l + 1);
    }
  };
  final static Parser expression_recover_parser_ = new Parser() {
    public boolean parse(PsiBuilder b, int l) {
      return expression_recover(b, l + 1);
    }
  };
  final static Parser for_loops_parts_recover_parser_ = new Parser() {
    public boolean parse(PsiBuilder b, int l) {
      return for_loops_parts_recover(b, l + 1);
    }
  };
  final static Parser map_literal_entry_recover_parser_ = new Parser() {
    public boolean parse(PsiBuilder b, int l) {
      return map_literal_entry_recover(b, l + 1);
    }
  };
  final static Parser not_paren_or_comma_recover_parser_ = new Parser() {
    public boolean parse(PsiBuilder b, int l) {
      return not_paren_or_comma_recover(b, l + 1);
    }
  };
  final static Parser not_paren_recover_parser_ = new Parser() {
    public boolean parse(PsiBuilder b, int l) {
      return not_paren_recover(b, l + 1);
    }
  };
  final static Parser parenthesesRecovery_parser_ = new Parser() {
    public boolean parse(PsiBuilder b, int l) {
      return parenthesesRecovery(b, l + 1);
    }
  };
  final static Parser simple_scope_recover_parser_ = new Parser() {
    public boolean parse(PsiBuilder b, int l) {
      return simple_scope_recover(b, l + 1);
    }
  };
  final static Parser super_call_or_field_initializer_recover_parser_ = new Parser() {
    public boolean parse(PsiBuilder b, int l) {
      return super_call_or_field_initializer_recover(b, l + 1);
    }
  };
  final static Parser top_level_recover_parser_ = new Parser() {
    public boolean parse(PsiBuilder b, int l) {
      return top_level_recover(b, l + 1);
    }
  };
  final static Parser type_parameter_recover_parser_ = new Parser() {
    public boolean parse(PsiBuilder b, int l) {
      return type_parameter_recover(b, l + 1);
    }
  };
}