// This is a generated file. Not intended for manual editing.
package dev.hgh.jai.parser;

import com.intellij.lang.PsiBuilder;
import com.intellij.lang.PsiBuilder.Marker;
import static dev.hgh.jai.psi.JaiTypes.*;
import static dev.hgh.jai.parser.JaiParserUtil.*;
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 JaiParser implements PsiParser, LightPsiParser {

  public ASTNode parse(IElementType root_, PsiBuilder builder_) {
    parseLight(root_, builder_);
    return builder_.getTreeBuilt();
  }

  public void parseLight(IElementType root_, PsiBuilder builder_) {
    boolean result_;
    builder_ = adapt_builder_(root_, builder_, this, EXTENDS_SETS_);
    Marker marker_ = enter_section_(builder_, 0, _COLLAPSE_, null);
    result_ = parse_root_(root_, builder_);
    exit_section_(builder_, 0, marker_, root_, result_, true, TRUE_CONDITION);
  }

  protected boolean parse_root_(IElementType root_, PsiBuilder builder_) {
    return parse_root_(root_, builder_, 0);
  }

  static boolean parse_root_(IElementType root_, PsiBuilder builder_, int level_) {
    return jaiFile(builder_, level_ + 1);
  }

  public static final TokenSet[] EXTENDS_SETS_ = new TokenSet[] {
    create_token_set_(ADD_EXPR, AND_EXPR, ARRAY_LITERAL_EXPR, ARRAY_TYPE_EXPR,
      ASSIGN_EXPR, AUTO_CAST_EXPR, BACKTICK_EXPR, BIT_AND_EXPR,
      BIT_OR_EXPR, BIT_XOR_EXPR, BUILTIN_CALL_EXPR, CALL_EXPR,
      CAST_EXPR, DEREF_EXPR, DIRECTIVE_EXPR, ENUM_EXPR,
      EQUALITY_EXPR, EXPR, IFX_EXPR, INDEX_EXPR,
      INLINE_EXPR, INTERFACE_EXPR, LAMBDA_EXPR, LITERAL_EXPR,
      MEMBER_EXPR, MUL_EXPR, OR_EXPR, PAREN_EXPR,
      PREFIX_EXPR, PRIMARY_EXPR, PROC_LITERAL_EXPR, RANGE_EXPR,
      REF_EXPR, RELATIONAL_EXPR, SHIFT_EXPR, STRUCT_EXPR,
      STRUCT_LITERAL_EXPR, TYPED_ARRAY_LITERAL_EXPR, TYPED_STRUCT_LITERAL_EXPR, UNARY_DOT_EXPR,
      UNINITIALIZED_EXPR, UNION_EXPR),
  };

  /* ********************************************************** */
  // argument ((',' | ',,') argument)* [',']
  static boolean argList(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "argList")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = argument(builder_, level_ + 1);
    result_ = result_ && argList_1(builder_, level_ + 1);
    result_ = result_ && argList_2(builder_, level_ + 1);
    exit_section_(builder_, marker_, null, result_);
    return result_;
  }

  // ((',' | ',,') argument)*
  private static boolean argList_1(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "argList_1")) return false;
    while (true) {
      int pos_ = current_position_(builder_);
      if (!argList_1_0(builder_, level_ + 1)) break;
      if (!empty_element_parsed_guard_(builder_, "argList_1", pos_)) break;
    }
    return true;
  }

  // (',' | ',,') argument
  private static boolean argList_1_0(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "argList_1_0")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = argList_1_0_0(builder_, level_ + 1);
    result_ = result_ && argument(builder_, level_ + 1);
    exit_section_(builder_, marker_, null, result_);
    return result_;
  }

  // ',' | ',,'
  private static boolean argList_1_0_0(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "argList_1_0_0")) return false;
    boolean result_;
    result_ = consumeToken(builder_, COMMA);
    if (!result_) result_ = consumeToken(builder_, DOUBLE_COMMA);
    return result_;
  }

  // [',']
  private static boolean argList_2(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "argList_2")) return false;
    consumeToken(builder_, COMMA);
    return true;
  }

  /* ********************************************************** */
  // '---' | expr
  public static boolean argument(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "argument")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_, level_, _NONE_, ARGUMENT, "<argument>");
    result_ = consumeToken(builder_, TRIPLE_MINUS);
    if (!result_) result_ = expr(builder_, level_ + 1, -1);
    exit_section_(builder_, level_, marker_, result_, false, null);
    return result_;
  }

  /* ********************************************************** */
  // '.[' [argList] ']'
  public static boolean arrayLiteralExpr(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "arrayLiteralExpr")) return false;
    if (!nextTokenIs(builder_, BEGIN_ARRAY_LITERAL)) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = consumeToken(builder_, BEGIN_ARRAY_LITERAL);
    result_ = result_ && arrayLiteralExpr_1(builder_, level_ + 1);
    result_ = result_ && consumeToken(builder_, RBRACKET);
    exit_section_(builder_, marker_, ARRAY_LITERAL_EXPR, result_);
    return result_;
  }

  // [argList]
  private static boolean arrayLiteralExpr_1(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "arrayLiteralExpr_1")) return false;
    argList(builder_, level_ + 1);
    return true;
  }

  /* ********************************************************** */
  // '=' | '+=' | '-=' | '*=' | '/=' | '%=' | '&=' | '|=' | '^='
  //                     | '<<=' | '>>=' | '<<<=' | '>>>=' | '&&=' | '||='
  static boolean assignOp_(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "assignOp_")) return false;
    boolean result_;
    result_ = consumeToken(builder_, EQ);
    if (!result_) result_ = consumeToken(builder_, PLUS_EQ);
    if (!result_) result_ = consumeToken(builder_, MINUS_EQ);
    if (!result_) result_ = consumeToken(builder_, STAR_EQ);
    if (!result_) result_ = consumeToken(builder_, SLASH_EQ);
    if (!result_) result_ = consumeToken(builder_, PERCENT_EQ);
    if (!result_) result_ = consumeToken(builder_, AND_EQ);
    if (!result_) result_ = consumeToken(builder_, OR_EQ);
    if (!result_) result_ = consumeToken(builder_, XOR_EQ);
    if (!result_) result_ = consumeToken(builder_, SHL_EQ);
    if (!result_) result_ = consumeToken(builder_, SHR_EQ);
    if (!result_) result_ = consumeToken(builder_, ROL_EQ);
    if (!result_) result_ = consumeToken(builder_, ROR_EQ);
    if (!result_) result_ = consumeToken(builder_, AND_AND_EQ);
    if (!result_) result_ = consumeToken(builder_, OR_OR_EQ);
    return result_;
  }

  /* ********************************************************** */
  // '`' (IDENT | 'defer' | 'return' | 'push_context' | 'operator')
  public static boolean backtickExpr(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "backtickExpr")) return false;
    if (!nextTokenIs(builder_, BACKTICK)) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = consumeToken(builder_, BACKTICK);
    result_ = result_ && backtickExpr_1(builder_, level_ + 1);
    exit_section_(builder_, marker_, BACKTICK_EXPR, result_);
    return result_;
  }

  // IDENT | 'defer' | 'return' | 'push_context' | 'operator'
  private static boolean backtickExpr_1(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "backtickExpr_1")) return false;
    boolean result_;
    result_ = consumeToken(builder_, IDENT);
    if (!result_) result_ = consumeToken(builder_, KW_DEFER);
    if (!result_) result_ = consumeToken(builder_, KW_RETURN);
    if (!result_) result_ = consumeToken(builder_, KW_PUSH_CONTEXT);
    if (!result_) result_ = consumeToken(builder_, KW_OPERATOR);
    return result_;
  }

  /* ********************************************************** */
  // '{' statement* '}'
  public static boolean block(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "block")) return false;
    if (!nextTokenIs(builder_, LBRACE)) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = consumeToken(builder_, LBRACE);
    result_ = result_ && block_1(builder_, level_ + 1);
    result_ = result_ && consumeToken(builder_, RBRACE);
    exit_section_(builder_, marker_, BLOCK, result_);
    return result_;
  }

  // statement*
  private static boolean block_1(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "block_1")) return false;
    while (true) {
      int pos_ = current_position_(builder_);
      if (!statement(builder_, level_ + 1)) break;
      if (!empty_element_parsed_guard_(builder_, "block_1", pos_)) break;
    }
    return true;
  }

  /* ********************************************************** */
  // 'break' [IDENT] semi
  public static boolean breakStatement(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "breakStatement")) return false;
    if (!nextTokenIs(builder_, KW_BREAK)) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = consumeToken(builder_, KW_BREAK);
    result_ = result_ && breakStatement_1(builder_, level_ + 1);
    result_ = result_ && semi(builder_, level_ + 1);
    exit_section_(builder_, marker_, BREAK_STATEMENT, result_);
    return result_;
  }

  // [IDENT]
  private static boolean breakStatement_1(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "breakStatement_1")) return false;
    consumeToken(builder_, IDENT);
    return true;
  }

  /* ********************************************************** */
  // builtinName_ '(' [argList] ')'
  public static boolean builtinCallExpr(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "builtinCallExpr")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_, level_, _NONE_, BUILTIN_CALL_EXPR, "<builtin call expr>");
    result_ = builtinName_(builder_, level_ + 1);
    result_ = result_ && consumeToken(builder_, LPAREN);
    result_ = result_ && builtinCallExpr_2(builder_, level_ + 1);
    result_ = result_ && consumeToken(builder_, RPAREN);
    exit_section_(builder_, level_, marker_, result_, false, null);
    return result_;
  }

  // [argList]
  private static boolean builtinCallExpr_2(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "builtinCallExpr_2")) return false;
    argList(builder_, level_ + 1);
    return true;
  }

  /* ********************************************************** */
  // 'size_of' | 'type_of' | 'type_info' | 'code_of'
  //                        | 'initializer_of' | 'is_constant'
  static boolean builtinName_(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "builtinName_")) return false;
    boolean result_;
    result_ = consumeToken(builder_, KW_SIZE_OF);
    if (!result_) result_ = consumeToken(builder_, KW_TYPE_OF);
    if (!result_) result_ = consumeToken(builder_, KW_TYPE_INFO);
    if (!result_) result_ = consumeToken(builder_, KW_CODE_OF);
    if (!result_) result_ = consumeToken(builder_, KW_INITIALIZER_OF);
    if (!result_) result_ = consumeToken(builder_, KW_IS_CONSTANT);
    return result_;
  }

  /* ********************************************************** */
  // 'case' [expr] [';'] statement*
  public static boolean caseClause(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "caseClause")) return false;
    if (!nextTokenIs(builder_, KW_CASE)) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = consumeToken(builder_, KW_CASE);
    result_ = result_ && caseClause_1(builder_, level_ + 1);
    result_ = result_ && caseClause_2(builder_, level_ + 1);
    result_ = result_ && caseClause_3(builder_, level_ + 1);
    exit_section_(builder_, marker_, CASE_CLAUSE, result_);
    return result_;
  }

  // [expr]
  private static boolean caseClause_1(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "caseClause_1")) return false;
    expr(builder_, level_ + 1, -1);
    return true;
  }

  // [';']
  private static boolean caseClause_2(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "caseClause_2")) return false;
    consumeToken(builder_, SEMICOLON);
    return true;
  }

  // statement*
  private static boolean caseClause_3(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "caseClause_3")) return false;
    while (true) {
      int pos_ = current_position_(builder_);
      if (!statement(builder_, level_ + 1)) break;
      if (!empty_element_parsed_guard_(builder_, "caseClause_3", pos_)) break;
    }
    return true;
  }

  /* ********************************************************** */
  // 'continue' [IDENT] semi
  public static boolean continueStatement(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "continueStatement")) return false;
    if (!nextTokenIs(builder_, KW_CONTINUE)) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = consumeToken(builder_, KW_CONTINUE);
    result_ = result_ && continueStatement_1(builder_, level_ + 1);
    result_ = result_ && semi(builder_, level_ + 1);
    exit_section_(builder_, marker_, CONTINUE_STATEMENT, result_);
    return result_;
  }

  // [IDENT]
  private static boolean continueStatement_1(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "continueStatement_1")) return false;
    consumeToken(builder_, IDENT);
    return true;
  }

  /* ********************************************************** */
  // <<dirPlain>> | 'using'
  static boolean declModifier_(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "declModifier_")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = dirPlain(builder_, level_ + 1);
    if (!result_) result_ = consumeToken(builder_, KW_USING);
    exit_section_(builder_, marker_, null, result_);
    return result_;
  }

  /* ********************************************************** */
  // IDENT (',' IDENT)*
  public static boolean declNames(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "declNames")) return false;
    if (!nextTokenIs(builder_, IDENT)) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = consumeToken(builder_, IDENT);
    result_ = result_ && declNames_1(builder_, level_ + 1);
    exit_section_(builder_, marker_, DECL_NAMES, result_);
    return result_;
  }

  // (',' IDENT)*
  private static boolean declNames_1(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "declNames_1")) return false;
    while (true) {
      int pos_ = current_position_(builder_);
      if (!declNames_1_0(builder_, level_ + 1)) break;
      if (!empty_element_parsed_guard_(builder_, "declNames_1", pos_)) break;
    }
    return true;
  }

  // ',' IDENT
  private static boolean declNames_1_0(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "declNames_1_0")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = consumeTokens(builder_, 0, COMMA, IDENT);
    exit_section_(builder_, marker_, null, result_);
    return result_;
  }

  /* ********************************************************** */
  // ':' [<<exprNoAssign>>] [('=' | ':') initializer]
  //                     | ':=' initializer
  //                     | '::' initializer
  static boolean declTail_(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "declTail_")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = declTail__0(builder_, level_ + 1);
    if (!result_) result_ = declTail__1(builder_, level_ + 1);
    if (!result_) result_ = declTail__2(builder_, level_ + 1);
    exit_section_(builder_, marker_, null, result_);
    return result_;
  }

  // ':' [<<exprNoAssign>>] [('=' | ':') initializer]
  private static boolean declTail__0(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "declTail__0")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = consumeToken(builder_, COLON);
    result_ = result_ && declTail__0_1(builder_, level_ + 1);
    result_ = result_ && declTail__0_2(builder_, level_ + 1);
    exit_section_(builder_, marker_, null, result_);
    return result_;
  }

  // [<<exprNoAssign>>]
  private static boolean declTail__0_1(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "declTail__0_1")) return false;
    exprNoAssign(builder_, level_ + 1);
    return true;
  }

  // [('=' | ':') initializer]
  private static boolean declTail__0_2(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "declTail__0_2")) return false;
    declTail__0_2_0(builder_, level_ + 1);
    return true;
  }

  // ('=' | ':') initializer
  private static boolean declTail__0_2_0(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "declTail__0_2_0")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = declTail__0_2_0_0(builder_, level_ + 1);
    result_ = result_ && initializer(builder_, level_ + 1);
    exit_section_(builder_, marker_, null, result_);
    return result_;
  }

  // '=' | ':'
  private static boolean declTail__0_2_0_0(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "declTail__0_2_0_0")) return false;
    boolean result_;
    result_ = consumeToken(builder_, EQ);
    if (!result_) result_ = consumeToken(builder_, COLON);
    return result_;
  }

  // ':=' initializer
  private static boolean declTail__1(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "declTail__1")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = consumeToken(builder_, COLON_EQ);
    result_ = result_ && initializer(builder_, level_ + 1);
    exit_section_(builder_, marker_, null, result_);
    return result_;
  }

  // '::' initializer
  private static boolean declTail__2(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "declTail__2")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = consumeToken(builder_, COLON_COLON);
    result_ = result_ && initializer(builder_, level_ + 1);
    exit_section_(builder_, marker_, null, result_);
    return result_;
  }

  /* ********************************************************** */
  // <<isDeclarationAhead>> declModifier_* declNames declTail_ NOTE* semi
  public static boolean declaration(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "declaration")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_, level_, _NONE_, DECLARATION, "<declaration>");
    result_ = isDeclarationAhead(builder_, level_ + 1);
    result_ = result_ && declaration_1(builder_, level_ + 1);
    result_ = result_ && declNames(builder_, level_ + 1);
    result_ = result_ && declTail_(builder_, level_ + 1);
    result_ = result_ && declaration_4(builder_, level_ + 1);
    result_ = result_ && semi(builder_, level_ + 1);
    exit_section_(builder_, level_, marker_, result_, false, null);
    return result_;
  }

  // declModifier_*
  private static boolean declaration_1(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "declaration_1")) return false;
    while (true) {
      int pos_ = current_position_(builder_);
      if (!declModifier_(builder_, level_ + 1)) break;
      if (!empty_element_parsed_guard_(builder_, "declaration_1", pos_)) break;
    }
    return true;
  }

  // NOTE*
  private static boolean declaration_4(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "declaration_4")) return false;
    while (true) {
      int pos_ = current_position_(builder_);
      if (!consumeToken(builder_, NOTE)) break;
      if (!empty_element_parsed_guard_(builder_, "declaration_4", pos_)) break;
    }
    return true;
  }

  /* ********************************************************** */
  // ['`'] 'defer' statement
  public static boolean deferStatement(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "deferStatement")) return false;
    if (!nextTokenIs(builder_, "<defer statement>", BACKTICK, KW_DEFER)) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_, level_, _NONE_, DEFER_STATEMENT, "<defer statement>");
    result_ = deferStatement_0(builder_, level_ + 1);
    result_ = result_ && consumeToken(builder_, KW_DEFER);
    result_ = result_ && statement(builder_, level_ + 1);
    exit_section_(builder_, level_, marker_, result_, false, null);
    return result_;
  }

  // ['`']
  private static boolean deferStatement_0(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "deferStatement_0")) return false;
    consumeToken(builder_, BACKTICK);
    return true;
  }

  /* ********************************************************** */
  // <<dir "#assert">> expr [expr]
  //                 | <<dirWithBlock>> [',' IDENT] block
  //                 | <<dirWithOperand>> [',' IDENT] [expr]
  //                 | <<dirPlain>> [',' IDENT]
  public static boolean directiveExpr(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "directiveExpr")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_, level_, _COLLAPSE_, DIRECTIVE_EXPR, "<directive expr>");
    result_ = directiveExpr_0(builder_, level_ + 1);
    if (!result_) result_ = directiveExpr_1(builder_, level_ + 1);
    if (!result_) result_ = directiveExpr_2(builder_, level_ + 1);
    if (!result_) result_ = directiveExpr_3(builder_, level_ + 1);
    exit_section_(builder_, level_, marker_, result_, false, null);
    return result_;
  }

  // <<dir "#assert">> expr [expr]
  private static boolean directiveExpr_0(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "directiveExpr_0")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = dir(builder_, level_ + 1, "#assert");
    result_ = result_ && expr(builder_, level_ + 1, -1);
    result_ = result_ && directiveExpr_0_2(builder_, level_ + 1);
    exit_section_(builder_, marker_, null, result_);
    return result_;
  }

  // [expr]
  private static boolean directiveExpr_0_2(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "directiveExpr_0_2")) return false;
    expr(builder_, level_ + 1, -1);
    return true;
  }

  // <<dirWithBlock>> [',' IDENT] block
  private static boolean directiveExpr_1(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "directiveExpr_1")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = dirWithBlock(builder_, level_ + 1);
    result_ = result_ && directiveExpr_1_1(builder_, level_ + 1);
    result_ = result_ && block(builder_, level_ + 1);
    exit_section_(builder_, marker_, null, result_);
    return result_;
  }

  // [',' IDENT]
  private static boolean directiveExpr_1_1(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "directiveExpr_1_1")) return false;
    parseTokens(builder_, 0, COMMA, IDENT);
    return true;
  }

  // <<dirWithOperand>> [',' IDENT] [expr]
  private static boolean directiveExpr_2(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "directiveExpr_2")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = dirWithOperand(builder_, level_ + 1);
    result_ = result_ && directiveExpr_2_1(builder_, level_ + 1);
    result_ = result_ && directiveExpr_2_2(builder_, level_ + 1);
    exit_section_(builder_, marker_, null, result_);
    return result_;
  }

  // [',' IDENT]
  private static boolean directiveExpr_2_1(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "directiveExpr_2_1")) return false;
    parseTokens(builder_, 0, COMMA, IDENT);
    return true;
  }

  // [expr]
  private static boolean directiveExpr_2_2(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "directiveExpr_2_2")) return false;
    expr(builder_, level_ + 1, -1);
    return true;
  }

  // <<dirPlain>> [',' IDENT]
  private static boolean directiveExpr_3(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "directiveExpr_3")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = dirPlain(builder_, level_ + 1);
    result_ = result_ && directiveExpr_3_1(builder_, level_ + 1);
    exit_section_(builder_, marker_, null, result_);
    return result_;
  }

  // [',' IDENT]
  private static boolean directiveExpr_3_1(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "directiveExpr_3_1")) return false;
    parseTokens(builder_, 0, COMMA, IDENT);
    return true;
  }

  /* ********************************************************** */
  // <<dirBare>> [',' IDENT] [';']
  public static boolean directiveStatement(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "directiveStatement")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_, level_, _NONE_, DIRECTIVE_STATEMENT, "<directive statement>");
    result_ = dirBare(builder_, level_ + 1);
    result_ = result_ && directiveStatement_1(builder_, level_ + 1);
    result_ = result_ && directiveStatement_2(builder_, level_ + 1);
    exit_section_(builder_, level_, marker_, result_, false, null);
    return result_;
  }

  // [',' IDENT]
  private static boolean directiveStatement_1(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "directiveStatement_1")) return false;
    parseTokens(builder_, 0, COMMA, IDENT);
    return true;
  }

  // [';']
  private static boolean directiveStatement_2(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "directiveStatement_2")) return false;
    consumeToken(builder_, SEMICOLON);
    return true;
  }

  /* ********************************************************** */
  // 'else' statement
  public static boolean elseClause(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "elseClause")) return false;
    if (!nextTokenIs(builder_, KW_ELSE)) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = consumeToken(builder_, KW_ELSE);
    result_ = result_ && statement(builder_, level_ + 1);
    exit_section_(builder_, marker_, ELSE_CLAUSE, result_);
    return result_;
  }

  /* ********************************************************** */
  // ('enum' | 'enum_flags') [!'{' expr] structModifier_* block
  public static boolean enumExpr(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "enumExpr")) return false;
    if (!nextTokenIs(builder_, "<enum expr>", KW_ENUM, KW_ENUM_FLAGS)) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_, level_, _NONE_, ENUM_EXPR, "<enum expr>");
    result_ = enumExpr_0(builder_, level_ + 1);
    result_ = result_ && enumExpr_1(builder_, level_ + 1);
    result_ = result_ && enumExpr_2(builder_, level_ + 1);
    result_ = result_ && block(builder_, level_ + 1);
    exit_section_(builder_, level_, marker_, result_, false, null);
    return result_;
  }

  // 'enum' | 'enum_flags'
  private static boolean enumExpr_0(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "enumExpr_0")) return false;
    boolean result_;
    result_ = consumeToken(builder_, KW_ENUM);
    if (!result_) result_ = consumeToken(builder_, KW_ENUM_FLAGS);
    return result_;
  }

  // [!'{' expr]
  private static boolean enumExpr_1(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "enumExpr_1")) return false;
    enumExpr_1_0(builder_, level_ + 1);
    return true;
  }

  // !'{' expr
  private static boolean enumExpr_1_0(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "enumExpr_1_0")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = enumExpr_1_0_0(builder_, level_ + 1);
    result_ = result_ && expr(builder_, level_ + 1, -1);
    exit_section_(builder_, marker_, null, result_);
    return result_;
  }

  // !'{'
  private static boolean enumExpr_1_0_0(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "enumExpr_1_0_0")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_, level_, _NOT_);
    result_ = !consumeToken(builder_, LBRACE);
    exit_section_(builder_, level_, marker_, result_, false, null);
    return result_;
  }

  // structModifier_*
  private static boolean enumExpr_2(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "enumExpr_2")) return false;
    while (true) {
      int pos_ = current_position_(builder_);
      if (!structModifier_(builder_, level_ + 1)) break;
      if (!empty_element_parsed_guard_(builder_, "enumExpr_2", pos_)) break;
    }
    return true;
  }

  /* ********************************************************** */
  // expr (',' expr)* NOTE* semi
  public static boolean expressionStatement(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "expressionStatement")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_, level_, _NONE_, EXPRESSION_STATEMENT, "<expression statement>");
    result_ = expr(builder_, level_ + 1, -1);
    result_ = result_ && expressionStatement_1(builder_, level_ + 1);
    result_ = result_ && expressionStatement_2(builder_, level_ + 1);
    result_ = result_ && semi(builder_, level_ + 1);
    exit_section_(builder_, level_, marker_, result_, false, null);
    return result_;
  }

  // (',' expr)*
  private static boolean expressionStatement_1(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "expressionStatement_1")) return false;
    while (true) {
      int pos_ = current_position_(builder_);
      if (!expressionStatement_1_0(builder_, level_ + 1)) break;
      if (!empty_element_parsed_guard_(builder_, "expressionStatement_1", pos_)) break;
    }
    return true;
  }

  // ',' expr
  private static boolean expressionStatement_1_0(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "expressionStatement_1_0")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = consumeToken(builder_, COMMA);
    result_ = result_ && expr(builder_, level_ + 1, -1);
    exit_section_(builder_, marker_, null, result_);
    return result_;
  }

  // NOTE*
  private static boolean expressionStatement_2(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "expressionStatement_2")) return false;
    while (true) {
      int pos_ = current_position_(builder_);
      if (!consumeToken(builder_, NOTE)) break;
      if (!empty_element_parsed_guard_(builder_, "expressionStatement_2", pos_)) break;
    }
    return true;
  }

  /* ********************************************************** */
  // '<' | '*'
  static boolean forModifier_(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "forModifier_")) return false;
    if (!nextTokenIs(builder_, "", LT, STAR)) return false;
    boolean result_;
    result_ = consumeToken(builder_, LT);
    if (!result_) result_ = consumeToken(builder_, STAR);
    return result_;
  }

  /* ********************************************************** */
  // IDENT (',' IDENT)*
  public static boolean forNames(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "forNames")) return false;
    if (!nextTokenIs(builder_, IDENT)) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = consumeToken(builder_, IDENT);
    result_ = result_ && forNames_1(builder_, level_ + 1);
    exit_section_(builder_, marker_, FOR_NAMES, result_);
    return result_;
  }

  // (',' IDENT)*
  private static boolean forNames_1(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "forNames_1")) return false;
    while (true) {
      int pos_ = current_position_(builder_);
      if (!forNames_1_0(builder_, level_ + 1)) break;
      if (!empty_element_parsed_guard_(builder_, "forNames_1", pos_)) break;
    }
    return true;
  }

  // ',' IDENT
  private static boolean forNames_1_0(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "forNames_1_0")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = consumeTokens(builder_, 0, COMMA, IDENT);
    exit_section_(builder_, marker_, null, result_);
    return result_;
  }

  /* ********************************************************** */
  // 'for' [':' expr] forModifier_* [<<isForNamesAhead>> forNames ':'] expr statement
  public static boolean forStatement(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "forStatement")) return false;
    if (!nextTokenIs(builder_, KW_FOR)) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = consumeToken(builder_, KW_FOR);
    result_ = result_ && forStatement_1(builder_, level_ + 1);
    result_ = result_ && forStatement_2(builder_, level_ + 1);
    result_ = result_ && forStatement_3(builder_, level_ + 1);
    result_ = result_ && expr(builder_, level_ + 1, -1);
    result_ = result_ && statement(builder_, level_ + 1);
    exit_section_(builder_, marker_, FOR_STATEMENT, result_);
    return result_;
  }

  // [':' expr]
  private static boolean forStatement_1(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "forStatement_1")) return false;
    forStatement_1_0(builder_, level_ + 1);
    return true;
  }

  // ':' expr
  private static boolean forStatement_1_0(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "forStatement_1_0")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = consumeToken(builder_, COLON);
    result_ = result_ && expr(builder_, level_ + 1, -1);
    exit_section_(builder_, marker_, null, result_);
    return result_;
  }

  // forModifier_*
  private static boolean forStatement_2(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "forStatement_2")) return false;
    while (true) {
      int pos_ = current_position_(builder_);
      if (!forModifier_(builder_, level_ + 1)) break;
      if (!empty_element_parsed_guard_(builder_, "forStatement_2", pos_)) break;
    }
    return true;
  }

  // [<<isForNamesAhead>> forNames ':']
  private static boolean forStatement_3(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "forStatement_3")) return false;
    forStatement_3_0(builder_, level_ + 1);
    return true;
  }

  // <<isForNamesAhead>> forNames ':'
  private static boolean forStatement_3_0(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "forStatement_3_0")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = isForNamesAhead(builder_, level_ + 1);
    result_ = result_ && forNames(builder_, level_ + 1);
    result_ = result_ && consumeToken(builder_, COLON);
    exit_section_(builder_, marker_, null, result_);
    return result_;
  }

  /* ********************************************************** */
  // 'if' | <<dir "#if">>
  static boolean ifKeyword_(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "ifKeyword_")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = consumeToken(builder_, KW_IF);
    if (!result_) result_ = dir(builder_, level_ + 1, "#if");
    exit_section_(builder_, marker_, null, result_);
    return result_;
  }

  /* ********************************************************** */
  // ifKeyword_ [<<dir "#complete">>] expr (switchBody | ['then'] statement [elseClause])
  public static boolean ifStatement(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "ifStatement")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_, level_, _NONE_, IF_STATEMENT, "<if statement>");
    result_ = ifKeyword_(builder_, level_ + 1);
    result_ = result_ && ifStatement_1(builder_, level_ + 1);
    result_ = result_ && expr(builder_, level_ + 1, -1);
    result_ = result_ && ifStatement_3(builder_, level_ + 1);
    exit_section_(builder_, level_, marker_, result_, false, null);
    return result_;
  }

  // [<<dir "#complete">>]
  private static boolean ifStatement_1(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "ifStatement_1")) return false;
    dir(builder_, level_ + 1, "#complete");
    return true;
  }

  // switchBody | ['then'] statement [elseClause]
  private static boolean ifStatement_3(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "ifStatement_3")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = switchBody(builder_, level_ + 1);
    if (!result_) result_ = ifStatement_3_1(builder_, level_ + 1);
    exit_section_(builder_, marker_, null, result_);
    return result_;
  }

  // ['then'] statement [elseClause]
  private static boolean ifStatement_3_1(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "ifStatement_3_1")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = ifStatement_3_1_0(builder_, level_ + 1);
    result_ = result_ && statement(builder_, level_ + 1);
    result_ = result_ && ifStatement_3_1_2(builder_, level_ + 1);
    exit_section_(builder_, marker_, null, result_);
    return result_;
  }

  // ['then']
  private static boolean ifStatement_3_1_0(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "ifStatement_3_1_0")) return false;
    consumeToken(builder_, KW_THEN);
    return true;
  }

  // [elseClause]
  private static boolean ifStatement_3_1_2(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "ifStatement_3_1_2")) return false;
    elseClause(builder_, level_ + 1);
    return true;
  }

  /* ********************************************************** */
  // '---' | expr
  public static boolean initializer(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "initializer")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_, level_, _NONE_, INITIALIZER, "<initializer>");
    result_ = consumeToken(builder_, TRIPLE_MINUS);
    if (!result_) result_ = expr(builder_, level_ + 1, -1);
    exit_section_(builder_, level_, marker_, result_, false, null);
    return result_;
  }

  /* ********************************************************** */
  // 'interface' [expr]
  public static boolean interfaceExpr(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "interfaceExpr")) return false;
    if (!nextTokenIs(builder_, KW_INTERFACE)) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = consumeToken(builder_, KW_INTERFACE);
    result_ = result_ && interfaceExpr_1(builder_, level_ + 1);
    exit_section_(builder_, marker_, INTERFACE_EXPR, result_);
    return result_;
  }

  // [expr]
  private static boolean interfaceExpr_1(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "interfaceExpr_1")) return false;
    expr(builder_, level_ + 1, -1);
    return true;
  }

  /* ********************************************************** */
  // statement*
  static boolean jaiFile(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "jaiFile")) return false;
    while (true) {
      int pos_ = current_position_(builder_);
      if (!statement(builder_, level_ + 1)) break;
      if (!empty_element_parsed_guard_(builder_, "jaiFile", pos_)) break;
    }
    return true;
  }

  /* ********************************************************** */
  // 'if' | 'for' | 'case' | 'enum' | 'cast' | 'union' | 'struct'
  //                          | 'remove' | 'inline' | 'context' | 'operator' | 'interface'
  //                          | 'type_info' | 'using' | 'defer' | 'return' | 'break'
  //                          | 'continue' | 'then' | 'else' | 'while' | 'null' | 'true' | 'false'
  static boolean keywordAsName_(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "keywordAsName_")) return false;
    boolean result_;
    result_ = consumeToken(builder_, KW_IF);
    if (!result_) result_ = consumeToken(builder_, KW_FOR);
    if (!result_) result_ = consumeToken(builder_, KW_CASE);
    if (!result_) result_ = consumeToken(builder_, KW_ENUM);
    if (!result_) result_ = consumeToken(builder_, KW_CAST);
    if (!result_) result_ = consumeToken(builder_, KW_UNION);
    if (!result_) result_ = consumeToken(builder_, KW_STRUCT);
    if (!result_) result_ = consumeToken(builder_, KW_REMOVE);
    if (!result_) result_ = consumeToken(builder_, KW_INLINE);
    if (!result_) result_ = consumeToken(builder_, KW_CONTEXT);
    if (!result_) result_ = consumeToken(builder_, KW_OPERATOR);
    if (!result_) result_ = consumeToken(builder_, KW_INTERFACE);
    if (!result_) result_ = consumeToken(builder_, KW_TYPE_INFO);
    if (!result_) result_ = consumeToken(builder_, KW_USING);
    if (!result_) result_ = consumeToken(builder_, KW_DEFER);
    if (!result_) result_ = consumeToken(builder_, KW_RETURN);
    if (!result_) result_ = consumeToken(builder_, KW_BREAK);
    if (!result_) result_ = consumeToken(builder_, KW_CONTINUE);
    if (!result_) result_ = consumeToken(builder_, KW_THEN);
    if (!result_) result_ = consumeToken(builder_, KW_ELSE);
    if (!result_) result_ = consumeToken(builder_, KW_WHILE);
    if (!result_) result_ = consumeToken(builder_, KW_NULL);
    if (!result_) result_ = consumeToken(builder_, KW_TRUE);
    if (!result_) result_ = consumeToken(builder_, KW_FALSE);
    return result_;
  }

  /* ********************************************************** */
  // NUMBER | STRING | HERE_STRING | 'true' | 'false' | 'null' | 'context'
  public static boolean literalExpr(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "literalExpr")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_, level_, _NONE_, LITERAL_EXPR, "<literal expr>");
    result_ = consumeToken(builder_, NUMBER);
    if (!result_) result_ = consumeToken(builder_, STRING);
    if (!result_) result_ = consumeToken(builder_, HERE_STRING);
    if (!result_) result_ = consumeToken(builder_, KW_TRUE);
    if (!result_) result_ = consumeToken(builder_, KW_FALSE);
    if (!result_) result_ = consumeToken(builder_, KW_NULL);
    if (!result_) result_ = consumeToken(builder_, KW_CONTEXT);
    exit_section_(builder_, level_, marker_, result_, false, null);
    return result_;
  }

  /* ********************************************************** */
  // IDENT | NUMBER | keywordAsName_
  public static boolean memberName(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "memberName")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_, level_, _NONE_, MEMBER_NAME, "<member name>");
    result_ = consumeToken(builder_, IDENT);
    if (!result_) result_ = consumeToken(builder_, NUMBER);
    if (!result_) result_ = keywordAsName_(builder_, level_ + 1);
    exit_section_(builder_, level_, marker_, result_, false, null);
    return result_;
  }

  /* ********************************************************** */
  // NOTE+
  public static boolean noteStatement(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "noteStatement")) return false;
    if (!nextTokenIs(builder_, NOTE)) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = consumeToken(builder_, NOTE);
    while (result_) {
      int pos_ = current_position_(builder_);
      if (!consumeToken(builder_, NOTE)) break;
      if (!empty_element_parsed_guard_(builder_, "noteStatement", pos_)) break;
    }
    exit_section_(builder_, marker_, NOTE_STATEMENT, result_);
    return result_;
  }

  /* ********************************************************** */
  // 'operator' operatorSymbol '::' expr NOTE* semi
  public static boolean operatorDeclaration(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "operatorDeclaration")) return false;
    if (!nextTokenIs(builder_, KW_OPERATOR)) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = consumeToken(builder_, KW_OPERATOR);
    result_ = result_ && operatorSymbol(builder_, level_ + 1);
    result_ = result_ && consumeToken(builder_, COLON_COLON);
    result_ = result_ && expr(builder_, level_ + 1, -1);
    result_ = result_ && operatorDeclaration_4(builder_, level_ + 1);
    result_ = result_ && semi(builder_, level_ + 1);
    exit_section_(builder_, marker_, OPERATOR_DECLARATION, result_);
    return result_;
  }

  // NOTE*
  private static boolean operatorDeclaration_4(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "operatorDeclaration_4")) return false;
    while (true) {
      int pos_ = current_position_(builder_);
      if (!consumeToken(builder_, NOTE)) break;
      if (!empty_element_parsed_guard_(builder_, "operatorDeclaration_4", pos_)) break;
    }
    return true;
  }

  /* ********************************************************** */
  // '+' | '-' | '*' | '/' | '%' | '==' | '!=' | '<' | '>' | '<=' | '>='
  //                  | '&' | '|' | '^' | '~' | '<<' | '>>' | '<<<' | '>>>'
  //                  | '[' ']' | '[' ']' '='
  public static boolean operatorSymbol(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "operatorSymbol")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_, level_, _NONE_, OPERATOR_SYMBOL, "<operator symbol>");
    result_ = consumeToken(builder_, PLUS);
    if (!result_) result_ = consumeToken(builder_, MINUS);
    if (!result_) result_ = consumeToken(builder_, STAR);
    if (!result_) result_ = consumeToken(builder_, SLASH);
    if (!result_) result_ = consumeToken(builder_, PERCENT);
    if (!result_) result_ = consumeToken(builder_, EQ_EQ);
    if (!result_) result_ = consumeToken(builder_, NOT_EQ);
    if (!result_) result_ = consumeToken(builder_, LT);
    if (!result_) result_ = consumeToken(builder_, GT);
    if (!result_) result_ = consumeToken(builder_, LT_EQ);
    if (!result_) result_ = consumeToken(builder_, GT_EQ);
    if (!result_) result_ = consumeToken(builder_, AND);
    if (!result_) result_ = consumeToken(builder_, OR);
    if (!result_) result_ = consumeToken(builder_, XOR);
    if (!result_) result_ = consumeToken(builder_, TILDE);
    if (!result_) result_ = consumeToken(builder_, SHL);
    if (!result_) result_ = consumeToken(builder_, SHR);
    if (!result_) result_ = consumeToken(builder_, ROL);
    if (!result_) result_ = consumeToken(builder_, ROR);
    if (!result_) result_ = parseTokens(builder_, 0, LBRACKET, RBRACKET);
    if (!result_) result_ = parseTokens(builder_, 0, LBRACKET, RBRACKET, EQ);
    exit_section_(builder_, level_, marker_, result_, false, null);
    return result_;
  }

  /* ********************************************************** */
  // parameter (',' parameter)* [',']
  static boolean paramList(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "paramList")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = parameter(builder_, level_ + 1);
    result_ = result_ && paramList_1(builder_, level_ + 1);
    result_ = result_ && paramList_2(builder_, level_ + 1);
    exit_section_(builder_, marker_, null, result_);
    return result_;
  }

  // (',' parameter)*
  private static boolean paramList_1(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "paramList_1")) return false;
    while (true) {
      int pos_ = current_position_(builder_);
      if (!paramList_1_0(builder_, level_ + 1)) break;
      if (!empty_element_parsed_guard_(builder_, "paramList_1", pos_)) break;
    }
    return true;
  }

  // ',' parameter
  private static boolean paramList_1_0(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "paramList_1_0")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = consumeToken(builder_, COMMA);
    result_ = result_ && parameter(builder_, level_ + 1);
    exit_section_(builder_, marker_, null, result_);
    return result_;
  }

  // [',']
  private static boolean paramList_2(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "paramList_2")) return false;
    consumeToken(builder_, COMMA);
    return true;
  }

  /* ********************************************************** */
  // ['$' | '$$'] IDENT
  public static boolean paramName(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "paramName")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_, level_, _NONE_, PARAM_NAME, "<param name>");
    result_ = paramName_0(builder_, level_ + 1);
    result_ = result_ && consumeToken(builder_, IDENT);
    exit_section_(builder_, level_, marker_, result_, false, null);
    return result_;
  }

  // ['$' | '$$']
  private static boolean paramName_0(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "paramName_0")) return false;
    paramName_0_0(builder_, level_ + 1);
    return true;
  }

  // '$' | '$$'
  private static boolean paramName_0_0(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "paramName_0_0")) return false;
    boolean result_;
    result_ = consumeToken(builder_, DOLLAR);
    if (!result_) result_ = consumeToken(builder_, DOUBLE_DOLLAR);
    return result_;
  }

  /* ********************************************************** */
  // paramName (',' paramName)*
  public static boolean paramNames(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "paramNames")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_, level_, _NONE_, PARAM_NAMES, "<param names>");
    result_ = paramName(builder_, level_ + 1);
    result_ = result_ && paramNames_1(builder_, level_ + 1);
    exit_section_(builder_, level_, marker_, result_, false, null);
    return result_;
  }

  // (',' paramName)*
  private static boolean paramNames_1(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "paramNames_1")) return false;
    while (true) {
      int pos_ = current_position_(builder_);
      if (!paramNames_1_0(builder_, level_ + 1)) break;
      if (!empty_element_parsed_guard_(builder_, "paramNames_1", pos_)) break;
    }
    return true;
  }

  // ',' paramName
  private static boolean paramNames_1_0(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "paramNames_1_0")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = consumeToken(builder_, COMMA);
    result_ = result_ && paramName(builder_, level_ + 1);
    exit_section_(builder_, marker_, null, result_);
    return result_;
  }

  /* ********************************************************** */
  // ':' [<<exprNoAssign>>] ['=' initializer]
  //                          | ':=' initializer
  //                          | '::' initializer
  static boolean paramTypeTail_(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "paramTypeTail_")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = paramTypeTail__0(builder_, level_ + 1);
    if (!result_) result_ = paramTypeTail__1(builder_, level_ + 1);
    if (!result_) result_ = paramTypeTail__2(builder_, level_ + 1);
    exit_section_(builder_, marker_, null, result_);
    return result_;
  }

  // ':' [<<exprNoAssign>>] ['=' initializer]
  private static boolean paramTypeTail__0(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "paramTypeTail__0")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = consumeToken(builder_, COLON);
    result_ = result_ && paramTypeTail__0_1(builder_, level_ + 1);
    result_ = result_ && paramTypeTail__0_2(builder_, level_ + 1);
    exit_section_(builder_, marker_, null, result_);
    return result_;
  }

  // [<<exprNoAssign>>]
  private static boolean paramTypeTail__0_1(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "paramTypeTail__0_1")) return false;
    exprNoAssign(builder_, level_ + 1);
    return true;
  }

  // ['=' initializer]
  private static boolean paramTypeTail__0_2(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "paramTypeTail__0_2")) return false;
    paramTypeTail__0_2_0(builder_, level_ + 1);
    return true;
  }

  // '=' initializer
  private static boolean paramTypeTail__0_2_0(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "paramTypeTail__0_2_0")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = consumeToken(builder_, EQ);
    result_ = result_ && initializer(builder_, level_ + 1);
    exit_section_(builder_, marker_, null, result_);
    return result_;
  }

  // ':=' initializer
  private static boolean paramTypeTail__1(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "paramTypeTail__1")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = consumeToken(builder_, COLON_EQ);
    result_ = result_ && initializer(builder_, level_ + 1);
    exit_section_(builder_, marker_, null, result_);
    return result_;
  }

  // '::' initializer
  private static boolean paramTypeTail__2(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "paramTypeTail__2")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = consumeToken(builder_, COLON_COLON);
    result_ = result_ && initializer(builder_, level_ + 1);
    exit_section_(builder_, marker_, null, result_);
    return result_;
  }

  /* ********************************************************** */
  // ['using'] parameterTail_
  public static boolean parameter(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "parameter")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_, level_, _NONE_, PARAMETER, "<parameter>");
    result_ = parameter_0(builder_, level_ + 1);
    result_ = result_ && parameterTail_(builder_, level_ + 1);
    exit_section_(builder_, level_, marker_, result_, false, null);
    return result_;
  }

  // ['using']
  private static boolean parameter_0(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "parameter_0")) return false;
    consumeToken(builder_, KW_USING);
    return true;
  }

  /* ********************************************************** */
  // <<isParamNameAhead>> paramNames paramTypeTail_ | '..' | expr
  static boolean parameterTail_(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "parameterTail_")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = parameterTail__0(builder_, level_ + 1);
    if (!result_) result_ = consumeToken(builder_, DOUBLE_DOT);
    if (!result_) result_ = expr(builder_, level_ + 1, -1);
    exit_section_(builder_, marker_, null, result_);
    return result_;
  }

  // <<isParamNameAhead>> paramNames paramTypeTail_
  private static boolean parameterTail__0(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "parameterTail__0")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = isParamNameAhead(builder_, level_ + 1);
    result_ = result_ && paramNames(builder_, level_ + 1);
    result_ = result_ && paramTypeTail_(builder_, level_ + 1);
    exit_section_(builder_, marker_, null, result_);
    return result_;
  }

  /* ********************************************************** */
  // '(' [expr (',' expr)*] ')'
  public static boolean parenExpr(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "parenExpr")) return false;
    if (!nextTokenIs(builder_, LPAREN)) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = consumeToken(builder_, LPAREN);
    result_ = result_ && parenExpr_1(builder_, level_ + 1);
    result_ = result_ && consumeToken(builder_, RPAREN);
    exit_section_(builder_, marker_, PAREN_EXPR, result_);
    return result_;
  }

  // [expr (',' expr)*]
  private static boolean parenExpr_1(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "parenExpr_1")) return false;
    parenExpr_1_0(builder_, level_ + 1);
    return true;
  }

  // expr (',' expr)*
  private static boolean parenExpr_1_0(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "parenExpr_1_0")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = expr(builder_, level_ + 1, -1);
    result_ = result_ && parenExpr_1_0_1(builder_, level_ + 1);
    exit_section_(builder_, marker_, null, result_);
    return result_;
  }

  // (',' expr)*
  private static boolean parenExpr_1_0_1(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "parenExpr_1_0_1")) return false;
    while (true) {
      int pos_ = current_position_(builder_);
      if (!parenExpr_1_0_1_0(builder_, level_ + 1)) break;
      if (!empty_element_parsed_guard_(builder_, "parenExpr_1_0_1", pos_)) break;
    }
    return true;
  }

  // ',' expr
  private static boolean parenExpr_1_0_1_0(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "parenExpr_1_0_1_0")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = consumeToken(builder_, COMMA);
    result_ = result_ && expr(builder_, level_ + 1, -1);
    exit_section_(builder_, marker_, null, result_);
    return result_;
  }

  /* ********************************************************** */
  // '-' | '+' | '!' | '~' | '*' | '..' | '$' | '$$' | '<<' | '>>'
  static boolean prefixOp_(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "prefixOp_")) return false;
    boolean result_;
    result_ = consumeToken(builder_, MINUS);
    if (!result_) result_ = consumeToken(builder_, PLUS);
    if (!result_) result_ = consumeToken(builder_, NOT);
    if (!result_) result_ = consumeToken(builder_, TILDE);
    if (!result_) result_ = consumeToken(builder_, STAR);
    if (!result_) result_ = consumeToken(builder_, DOUBLE_DOT);
    if (!result_) result_ = consumeToken(builder_, DOLLAR);
    if (!result_) result_ = consumeToken(builder_, DOUBLE_DOLLAR);
    if (!result_) result_ = consumeToken(builder_, SHL);
    if (!result_) result_ = consumeToken(builder_, SHR);
    return result_;
  }

  /* ********************************************************** */
  // <<isProcHeaderAhead>> '(' [paramList] ')' ['->' returnTypes_] procModifier* [block]
  //                  | '->' returnTypes_ procModifier* [block]
  public static boolean procLiteralExpr(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "procLiteralExpr")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_, level_, _NONE_, PROC_LITERAL_EXPR, "<proc literal expr>");
    result_ = procLiteralExpr_0(builder_, level_ + 1);
    if (!result_) result_ = procLiteralExpr_1(builder_, level_ + 1);
    exit_section_(builder_, level_, marker_, result_, false, null);
    return result_;
  }

  // <<isProcHeaderAhead>> '(' [paramList] ')' ['->' returnTypes_] procModifier* [block]
  private static boolean procLiteralExpr_0(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "procLiteralExpr_0")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = isProcHeaderAhead(builder_, level_ + 1);
    result_ = result_ && consumeToken(builder_, LPAREN);
    result_ = result_ && procLiteralExpr_0_2(builder_, level_ + 1);
    result_ = result_ && consumeToken(builder_, RPAREN);
    result_ = result_ && procLiteralExpr_0_4(builder_, level_ + 1);
    result_ = result_ && procLiteralExpr_0_5(builder_, level_ + 1);
    result_ = result_ && procLiteralExpr_0_6(builder_, level_ + 1);
    exit_section_(builder_, marker_, null, result_);
    return result_;
  }

  // [paramList]
  private static boolean procLiteralExpr_0_2(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "procLiteralExpr_0_2")) return false;
    paramList(builder_, level_ + 1);
    return true;
  }

  // ['->' returnTypes_]
  private static boolean procLiteralExpr_0_4(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "procLiteralExpr_0_4")) return false;
    procLiteralExpr_0_4_0(builder_, level_ + 1);
    return true;
  }

  // '->' returnTypes_
  private static boolean procLiteralExpr_0_4_0(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "procLiteralExpr_0_4_0")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = consumeToken(builder_, RIGHT_ARROW);
    result_ = result_ && returnTypes_(builder_, level_ + 1);
    exit_section_(builder_, marker_, null, result_);
    return result_;
  }

  // procModifier*
  private static boolean procLiteralExpr_0_5(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "procLiteralExpr_0_5")) return false;
    while (true) {
      int pos_ = current_position_(builder_);
      if (!procModifier(builder_, level_ + 1)) break;
      if (!empty_element_parsed_guard_(builder_, "procLiteralExpr_0_5", pos_)) break;
    }
    return true;
  }

  // [block]
  private static boolean procLiteralExpr_0_6(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "procLiteralExpr_0_6")) return false;
    block(builder_, level_ + 1);
    return true;
  }

  // '->' returnTypes_ procModifier* [block]
  private static boolean procLiteralExpr_1(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "procLiteralExpr_1")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = consumeToken(builder_, RIGHT_ARROW);
    result_ = result_ && returnTypes_(builder_, level_ + 1);
    result_ = result_ && procLiteralExpr_1_2(builder_, level_ + 1);
    result_ = result_ && procLiteralExpr_1_3(builder_, level_ + 1);
    exit_section_(builder_, marker_, null, result_);
    return result_;
  }

  // procModifier*
  private static boolean procLiteralExpr_1_2(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "procLiteralExpr_1_2")) return false;
    while (true) {
      int pos_ = current_position_(builder_);
      if (!procModifier(builder_, level_ + 1)) break;
      if (!empty_element_parsed_guard_(builder_, "procLiteralExpr_1_2", pos_)) break;
    }
    return true;
  }

  // [block]
  private static boolean procLiteralExpr_1_3(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "procLiteralExpr_1_3")) return false;
    block(builder_, level_ + 1);
    return true;
  }

  /* ********************************************************** */
  // <<dirWithBlock>> block
  //                | <<dirWithOperand>> [',' IDENT] [expr]
  //                | <<dirPlain>> [',' IDENT]
  public static boolean procModifier(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "procModifier")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_, level_, _NONE_, PROC_MODIFIER, "<proc modifier>");
    result_ = procModifier_0(builder_, level_ + 1);
    if (!result_) result_ = procModifier_1(builder_, level_ + 1);
    if (!result_) result_ = procModifier_2(builder_, level_ + 1);
    exit_section_(builder_, level_, marker_, result_, false, null);
    return result_;
  }

  // <<dirWithBlock>> block
  private static boolean procModifier_0(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "procModifier_0")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = dirWithBlock(builder_, level_ + 1);
    result_ = result_ && block(builder_, level_ + 1);
    exit_section_(builder_, marker_, null, result_);
    return result_;
  }

  // <<dirWithOperand>> [',' IDENT] [expr]
  private static boolean procModifier_1(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "procModifier_1")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = dirWithOperand(builder_, level_ + 1);
    result_ = result_ && procModifier_1_1(builder_, level_ + 1);
    result_ = result_ && procModifier_1_2(builder_, level_ + 1);
    exit_section_(builder_, marker_, null, result_);
    return result_;
  }

  // [',' IDENT]
  private static boolean procModifier_1_1(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "procModifier_1_1")) return false;
    parseTokens(builder_, 0, COMMA, IDENT);
    return true;
  }

  // [expr]
  private static boolean procModifier_1_2(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "procModifier_1_2")) return false;
    expr(builder_, level_ + 1, -1);
    return true;
  }

  // <<dirPlain>> [',' IDENT]
  private static boolean procModifier_2(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "procModifier_2")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = dirPlain(builder_, level_ + 1);
    result_ = result_ && procModifier_2_1(builder_, level_ + 1);
    exit_section_(builder_, marker_, null, result_);
    return result_;
  }

  // [',' IDENT]
  private static boolean procModifier_2_1(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "procModifier_2_1")) return false;
    parseTokens(builder_, 0, COMMA, IDENT);
    return true;
  }

  /* ********************************************************** */
  // ['`'] 'push_context' expr block
  public static boolean pushContextStatement(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "pushContextStatement")) return false;
    if (!nextTokenIs(builder_, "<push context statement>", BACKTICK, KW_PUSH_CONTEXT)) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_, level_, _NONE_, PUSH_CONTEXT_STATEMENT, "<push context statement>");
    result_ = pushContextStatement_0(builder_, level_ + 1);
    result_ = result_ && consumeToken(builder_, KW_PUSH_CONTEXT);
    result_ = result_ && expr(builder_, level_ + 1, -1);
    result_ = result_ && block(builder_, level_ + 1);
    exit_section_(builder_, level_, marker_, result_, false, null);
    return result_;
  }

  // ['`']
  private static boolean pushContextStatement_0(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "pushContextStatement_0")) return false;
    consumeToken(builder_, BACKTICK);
    return true;
  }

  /* ********************************************************** */
  // IDENT
  public static boolean refExpr(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "refExpr")) return false;
    if (!nextTokenIs(builder_, IDENT)) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = consumeToken(builder_, IDENT);
    exit_section_(builder_, marker_, REF_EXPR, result_);
    return result_;
  }

  /* ********************************************************** */
  // 'remove' [expr] semi
  public static boolean removeStatement(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "removeStatement")) return false;
    if (!nextTokenIs(builder_, KW_REMOVE)) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = consumeToken(builder_, KW_REMOVE);
    result_ = result_ && removeStatement_1(builder_, level_ + 1);
    result_ = result_ && semi(builder_, level_ + 1);
    exit_section_(builder_, marker_, REMOVE_STATEMENT, result_);
    return result_;
  }

  // [expr]
  private static boolean removeStatement_1(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "removeStatement_1")) return false;
    expr(builder_, level_ + 1, -1);
    return true;
  }

  /* ********************************************************** */
  // '(' [returnItem (',' returnItem)*] ')'
  public static boolean returnGroup(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "returnGroup")) return false;
    if (!nextTokenIs(builder_, LPAREN)) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = consumeToken(builder_, LPAREN);
    result_ = result_ && returnGroup_1(builder_, level_ + 1);
    result_ = result_ && consumeToken(builder_, RPAREN);
    exit_section_(builder_, marker_, RETURN_GROUP, result_);
    return result_;
  }

  // [returnItem (',' returnItem)*]
  private static boolean returnGroup_1(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "returnGroup_1")) return false;
    returnGroup_1_0(builder_, level_ + 1);
    return true;
  }

  // returnItem (',' returnItem)*
  private static boolean returnGroup_1_0(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "returnGroup_1_0")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = returnItem(builder_, level_ + 1);
    result_ = result_ && returnGroup_1_0_1(builder_, level_ + 1);
    exit_section_(builder_, marker_, null, result_);
    return result_;
  }

  // (',' returnItem)*
  private static boolean returnGroup_1_0_1(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "returnGroup_1_0_1")) return false;
    while (true) {
      int pos_ = current_position_(builder_);
      if (!returnGroup_1_0_1_0(builder_, level_ + 1)) break;
      if (!empty_element_parsed_guard_(builder_, "returnGroup_1_0_1", pos_)) break;
    }
    return true;
  }

  // ',' returnItem
  private static boolean returnGroup_1_0_1_0(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "returnGroup_1_0_1_0")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = consumeToken(builder_, COMMA);
    result_ = result_ && returnItem(builder_, level_ + 1);
    exit_section_(builder_, marker_, null, result_);
    return result_;
  }

  /* ********************************************************** */
  // [<<isParamNameAhead>> IDENT ':'] <<exprNoAssign>> ['=' initializer]
  public static boolean returnItem(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "returnItem")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_, level_, _NONE_, RETURN_ITEM, "<return item>");
    result_ = returnItem_0(builder_, level_ + 1);
    result_ = result_ && exprNoAssign(builder_, level_ + 1);
    result_ = result_ && returnItem_2(builder_, level_ + 1);
    exit_section_(builder_, level_, marker_, result_, false, null);
    return result_;
  }

  // [<<isParamNameAhead>> IDENT ':']
  private static boolean returnItem_0(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "returnItem_0")) return false;
    returnItem_0_0(builder_, level_ + 1);
    return true;
  }

  // <<isParamNameAhead>> IDENT ':'
  private static boolean returnItem_0_0(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "returnItem_0_0")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = isParamNameAhead(builder_, level_ + 1);
    result_ = result_ && consumeTokens(builder_, 0, IDENT, COLON);
    exit_section_(builder_, marker_, null, result_);
    return result_;
  }

  // ['=' initializer]
  private static boolean returnItem_2(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "returnItem_2")) return false;
    returnItem_2_0(builder_, level_ + 1);
    return true;
  }

  // '=' initializer
  private static boolean returnItem_2_0(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "returnItem_2_0")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = consumeToken(builder_, EQ);
    result_ = result_ && initializer(builder_, level_ + 1);
    exit_section_(builder_, marker_, null, result_);
    return result_;
  }

  /* ********************************************************** */
  // 'return' [expr (',' expr)*] NOTE* semi
  public static boolean returnStatement(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "returnStatement")) return false;
    if (!nextTokenIs(builder_, KW_RETURN)) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = consumeToken(builder_, KW_RETURN);
    result_ = result_ && returnStatement_1(builder_, level_ + 1);
    result_ = result_ && returnStatement_2(builder_, level_ + 1);
    result_ = result_ && semi(builder_, level_ + 1);
    exit_section_(builder_, marker_, RETURN_STATEMENT, result_);
    return result_;
  }

  // [expr (',' expr)*]
  private static boolean returnStatement_1(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "returnStatement_1")) return false;
    returnStatement_1_0(builder_, level_ + 1);
    return true;
  }

  // expr (',' expr)*
  private static boolean returnStatement_1_0(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "returnStatement_1_0")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = expr(builder_, level_ + 1, -1);
    result_ = result_ && returnStatement_1_0_1(builder_, level_ + 1);
    exit_section_(builder_, marker_, null, result_);
    return result_;
  }

  // (',' expr)*
  private static boolean returnStatement_1_0_1(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "returnStatement_1_0_1")) return false;
    while (true) {
      int pos_ = current_position_(builder_);
      if (!returnStatement_1_0_1_0(builder_, level_ + 1)) break;
      if (!empty_element_parsed_guard_(builder_, "returnStatement_1_0_1", pos_)) break;
    }
    return true;
  }

  // ',' expr
  private static boolean returnStatement_1_0_1_0(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "returnStatement_1_0_1_0")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = consumeToken(builder_, COMMA);
    result_ = result_ && expr(builder_, level_ + 1, -1);
    exit_section_(builder_, marker_, null, result_);
    return result_;
  }

  // NOTE*
  private static boolean returnStatement_2(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "returnStatement_2")) return false;
    while (true) {
      int pos_ = current_position_(builder_);
      if (!consumeToken(builder_, NOTE)) break;
      if (!empty_element_parsed_guard_(builder_, "returnStatement_2", pos_)) break;
    }
    return true;
  }

  /* ********************************************************** */
  // <<isReturnGroupAhead>> returnGroup | returnItem (',' returnItem)*
  static boolean returnTypes_(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "returnTypes_")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = returnTypes__0(builder_, level_ + 1);
    if (!result_) result_ = returnTypes__1(builder_, level_ + 1);
    exit_section_(builder_, marker_, null, result_);
    return result_;
  }

  // <<isReturnGroupAhead>> returnGroup
  private static boolean returnTypes__0(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "returnTypes__0")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = isReturnGroupAhead(builder_, level_ + 1);
    result_ = result_ && returnGroup(builder_, level_ + 1);
    exit_section_(builder_, marker_, null, result_);
    return result_;
  }

  // returnItem (',' returnItem)*
  private static boolean returnTypes__1(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "returnTypes__1")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = returnItem(builder_, level_ + 1);
    result_ = result_ && returnTypes__1_1(builder_, level_ + 1);
    exit_section_(builder_, marker_, null, result_);
    return result_;
  }

  // (',' returnItem)*
  private static boolean returnTypes__1_1(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "returnTypes__1_1")) return false;
    while (true) {
      int pos_ = current_position_(builder_);
      if (!returnTypes__1_1_0(builder_, level_ + 1)) break;
      if (!empty_element_parsed_guard_(builder_, "returnTypes__1_1", pos_)) break;
    }
    return true;
  }

  // ',' returnItem
  private static boolean returnTypes__1_1_0(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "returnTypes__1_1_0")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = consumeToken(builder_, COMMA);
    result_ = result_ && returnItem(builder_, level_ + 1);
    exit_section_(builder_, marker_, null, result_);
    return result_;
  }

  /* ********************************************************** */
  // ';' | <<prevEndsConstruct>>
  static boolean semi(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "semi")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = consumeToken(builder_, SEMICOLON);
    if (!result_) result_ = prevEndsConstruct(builder_, level_ + 1);
    exit_section_(builder_, marker_, null, result_);
    return result_;
  }

  /* ********************************************************** */
  // ';'
  //             | block
  //             | ifStatement
  //             | whileStatement
  //             | forStatement
  //             | returnStatement
  //             | breakStatement
  //             | continueStatement
  //             | removeStatement
  //             | deferStatement
  //             | pushContextStatement
  //             | operatorDeclaration
  //             | usingStatement
  //             | noteStatement
  //             | directiveStatement
  //             | declaration
  //             | expressionStatement
  public static boolean statement(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "statement")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_, level_, _NONE_, STATEMENT, "<statement>");
    result_ = consumeToken(builder_, SEMICOLON);
    if (!result_) result_ = block(builder_, level_ + 1);
    if (!result_) result_ = ifStatement(builder_, level_ + 1);
    if (!result_) result_ = whileStatement(builder_, level_ + 1);
    if (!result_) result_ = forStatement(builder_, level_ + 1);
    if (!result_) result_ = returnStatement(builder_, level_ + 1);
    if (!result_) result_ = breakStatement(builder_, level_ + 1);
    if (!result_) result_ = continueStatement(builder_, level_ + 1);
    if (!result_) result_ = removeStatement(builder_, level_ + 1);
    if (!result_) result_ = deferStatement(builder_, level_ + 1);
    if (!result_) result_ = pushContextStatement(builder_, level_ + 1);
    if (!result_) result_ = operatorDeclaration(builder_, level_ + 1);
    if (!result_) result_ = usingStatement(builder_, level_ + 1);
    if (!result_) result_ = noteStatement(builder_, level_ + 1);
    if (!result_) result_ = directiveStatement(builder_, level_ + 1);
    if (!result_) result_ = declaration(builder_, level_ + 1);
    if (!result_) result_ = expressionStatement(builder_, level_ + 1);
    exit_section_(builder_, level_, marker_, result_, false, null);
    return result_;
  }

  /* ********************************************************** */
  // 'struct' ['(' [paramList] ')'] structModifier_* block
  public static boolean structExpr(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "structExpr")) return false;
    if (!nextTokenIs(builder_, KW_STRUCT)) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = consumeToken(builder_, KW_STRUCT);
    result_ = result_ && structExpr_1(builder_, level_ + 1);
    result_ = result_ && structExpr_2(builder_, level_ + 1);
    result_ = result_ && block(builder_, level_ + 1);
    exit_section_(builder_, marker_, STRUCT_EXPR, result_);
    return result_;
  }

  // ['(' [paramList] ')']
  private static boolean structExpr_1(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "structExpr_1")) return false;
    structExpr_1_0(builder_, level_ + 1);
    return true;
  }

  // '(' [paramList] ')'
  private static boolean structExpr_1_0(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "structExpr_1_0")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = consumeToken(builder_, LPAREN);
    result_ = result_ && structExpr_1_0_1(builder_, level_ + 1);
    result_ = result_ && consumeToken(builder_, RPAREN);
    exit_section_(builder_, marker_, null, result_);
    return result_;
  }

  // [paramList]
  private static boolean structExpr_1_0_1(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "structExpr_1_0_1")) return false;
    paramList(builder_, level_ + 1);
    return true;
  }

  // structModifier_*
  private static boolean structExpr_2(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "structExpr_2")) return false;
    while (true) {
      int pos_ = current_position_(builder_);
      if (!structModifier_(builder_, level_ + 1)) break;
      if (!empty_element_parsed_guard_(builder_, "structExpr_2", pos_)) break;
    }
    return true;
  }

  /* ********************************************************** */
  // '.{' [argList] '}'
  public static boolean structLiteralExpr(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "structLiteralExpr")) return false;
    if (!nextTokenIs(builder_, BEGIN_STRUCT_LITERAL)) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = consumeToken(builder_, BEGIN_STRUCT_LITERAL);
    result_ = result_ && structLiteralExpr_1(builder_, level_ + 1);
    result_ = result_ && consumeToken(builder_, RBRACE);
    exit_section_(builder_, marker_, STRUCT_LITERAL_EXPR, result_);
    return result_;
  }

  // [argList]
  private static boolean structLiteralExpr_1(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "structLiteralExpr_1")) return false;
    argList(builder_, level_ + 1);
    return true;
  }

  /* ********************************************************** */
  // procModifier
  static boolean structModifier_(PsiBuilder builder_, int level_) {
    return procModifier(builder_, level_ + 1);
  }

  /* ********************************************************** */
  // '==' '{' caseClause* '}'
  public static boolean switchBody(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "switchBody")) return false;
    if (!nextTokenIs(builder_, EQ_EQ)) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = consumeTokens(builder_, 0, EQ_EQ, LBRACE);
    result_ = result_ && switchBody_2(builder_, level_ + 1);
    result_ = result_ && consumeToken(builder_, RBRACE);
    exit_section_(builder_, marker_, SWITCH_BODY, result_);
    return result_;
  }

  // caseClause*
  private static boolean switchBody_2(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "switchBody_2")) return false;
    while (true) {
      int pos_ = current_position_(builder_);
      if (!caseClause(builder_, level_ + 1)) break;
      if (!empty_element_parsed_guard_(builder_, "switchBody_2", pos_)) break;
    }
    return true;
  }

  /* ********************************************************** */
  // '.' memberName
  public static boolean unaryDotExpr(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "unaryDotExpr")) return false;
    if (!nextTokenIs(builder_, DOT)) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = consumeToken(builder_, DOT);
    result_ = result_ && memberName(builder_, level_ + 1);
    exit_section_(builder_, marker_, UNARY_DOT_EXPR, result_);
    return result_;
  }

  /* ********************************************************** */
  // '---' | '--'
  public static boolean uninitializedExpr(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "uninitializedExpr")) return false;
    if (!nextTokenIs(builder_, "<uninitialized expr>", DOUBLE_MINUS, TRIPLE_MINUS)) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_, level_, _NONE_, UNINITIALIZED_EXPR, "<uninitialized expr>");
    result_ = consumeToken(builder_, TRIPLE_MINUS);
    if (!result_) result_ = consumeToken(builder_, DOUBLE_MINUS);
    exit_section_(builder_, level_, marker_, result_, false, null);
    return result_;
  }

  /* ********************************************************** */
  // 'union' structModifier_* block
  public static boolean unionExpr(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "unionExpr")) return false;
    if (!nextTokenIs(builder_, KW_UNION)) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = consumeToken(builder_, KW_UNION);
    result_ = result_ && unionExpr_1(builder_, level_ + 1);
    result_ = result_ && block(builder_, level_ + 1);
    exit_section_(builder_, marker_, UNION_EXPR, result_);
    return result_;
  }

  // structModifier_*
  private static boolean unionExpr_1(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "unionExpr_1")) return false;
    while (true) {
      int pos_ = current_position_(builder_);
      if (!structModifier_(builder_, level_ + 1)) break;
      if (!empty_element_parsed_guard_(builder_, "unionExpr_1", pos_)) break;
    }
    return true;
  }

  /* ********************************************************** */
  // 'using' [',' expr] expr semi
  public static boolean usingStatement(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "usingStatement")) return false;
    if (!nextTokenIs(builder_, KW_USING)) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = consumeToken(builder_, KW_USING);
    result_ = result_ && usingStatement_1(builder_, level_ + 1);
    result_ = result_ && expr(builder_, level_ + 1, -1);
    result_ = result_ && semi(builder_, level_ + 1);
    exit_section_(builder_, marker_, USING_STATEMENT, result_);
    return result_;
  }

  // [',' expr]
  private static boolean usingStatement_1(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "usingStatement_1")) return false;
    usingStatement_1_0(builder_, level_ + 1);
    return true;
  }

  // ',' expr
  private static boolean usingStatement_1_0(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "usingStatement_1_0")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = consumeToken(builder_, COMMA);
    result_ = result_ && expr(builder_, level_ + 1, -1);
    exit_section_(builder_, marker_, null, result_);
    return result_;
  }

  /* ********************************************************** */
  // 'while' [<<isLabelAhead>> IDENT ':'] expr statement
  public static boolean whileStatement(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "whileStatement")) return false;
    if (!nextTokenIs(builder_, KW_WHILE)) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = consumeToken(builder_, KW_WHILE);
    result_ = result_ && whileStatement_1(builder_, level_ + 1);
    result_ = result_ && expr(builder_, level_ + 1, -1);
    result_ = result_ && statement(builder_, level_ + 1);
    exit_section_(builder_, marker_, WHILE_STATEMENT, result_);
    return result_;
  }

  // [<<isLabelAhead>> IDENT ':']
  private static boolean whileStatement_1(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "whileStatement_1")) return false;
    whileStatement_1_0(builder_, level_ + 1);
    return true;
  }

  // <<isLabelAhead>> IDENT ':'
  private static boolean whileStatement_1_0(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "whileStatement_1_0")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = isLabelAhead(builder_, level_ + 1);
    result_ = result_ && consumeTokens(builder_, 0, IDENT, COLON);
    exit_section_(builder_, marker_, null, result_);
    return result_;
  }

  /* ********************************************************** */
  // Expression root: expr
  // Operator priority table:
  // 0: BINARY(assignExpr)
  // 1: BINARY(lambdaExpr)
  // 2: BINARY(orExpr)
  // 3: BINARY(andExpr)
  // 4: BINARY(equalityExpr)
  // 5: BINARY(relationalExpr)
  // 6: BINARY(bitOrExpr)
  // 7: BINARY(bitXorExpr)
  // 8: BINARY(bitAndExpr)
  // 9: BINARY(shiftExpr)
  // 10: BINARY(rangeExpr)
  // 11: BINARY(addExpr)
  // 12: BINARY(mulExpr)
  // 13: PREFIX(prefixExpr)
  // 14: ATOM(arrayTypeExpr)
  // 15: ATOM(castExpr)
  // 16: PREFIX(autoCastExpr)
  // 17: PREFIX(inlineExpr)
  // 18: ATOM(ifxExpr)
  // 19: POSTFIX(callExpr)
  // 20: POSTFIX(indexExpr)
  // 21: POSTFIX(memberExpr)
  // 22: POSTFIX(derefExpr)
  // 23: POSTFIX(typedStructLiteralExpr)
  // 24: POSTFIX(typedArrayLiteralExpr)
  // 25: ATOM(primaryExpr)
  public static boolean expr(PsiBuilder builder_, int level_, int priority_) {
    if (!recursion_guard_(builder_, level_, "expr")) return false;
    addVariant(builder_, "<expr>");
    boolean result_, pinned_;
    Marker marker_ = enter_section_(builder_, level_, _NONE_, "<expr>");
    result_ = prefixExpr(builder_, level_ + 1);
    if (!result_) result_ = arrayTypeExpr(builder_, level_ + 1);
    if (!result_) result_ = castExpr(builder_, level_ + 1);
    if (!result_) result_ = autoCastExpr(builder_, level_ + 1);
    if (!result_) result_ = inlineExpr(builder_, level_ + 1);
    if (!result_) result_ = ifxExpr(builder_, level_ + 1);
    if (!result_) result_ = primaryExpr(builder_, level_ + 1);
    pinned_ = result_;
    result_ = result_ && expr_0(builder_, level_ + 1, priority_);
    exit_section_(builder_, level_, marker_, null, result_, pinned_, null);
    return result_ || pinned_;
  }

  public static boolean expr_0(PsiBuilder builder_, int level_, int priority_) {
    if (!recursion_guard_(builder_, level_, "expr_0")) return false;
    boolean result_ = true;
    while (true) {
      Marker marker_ = enter_section_(builder_, level_, _LEFT_, null);
      if (priority_ < 0 && assignOp_(builder_, level_ + 1)) {
        result_ = expr(builder_, level_, -1);
        exit_section_(builder_, level_, marker_, ASSIGN_EXPR, result_, true, null);
      }
      else if (priority_ < 1 && consumeTokenSmart(builder_, QUICK_LAMBDA)) {
        result_ = expr(builder_, level_, 0);
        exit_section_(builder_, level_, marker_, LAMBDA_EXPR, result_, true, null);
      }
      else if (priority_ < 2 && consumeTokenSmart(builder_, OR_OR)) {
        result_ = expr(builder_, level_, 2);
        exit_section_(builder_, level_, marker_, OR_EXPR, result_, true, null);
      }
      else if (priority_ < 3 && consumeTokenSmart(builder_, AND_AND)) {
        result_ = expr(builder_, level_, 3);
        exit_section_(builder_, level_, marker_, AND_EXPR, result_, true, null);
      }
      else if (priority_ < 4 && equalityExpr_0(builder_, level_ + 1)) {
        result_ = expr(builder_, level_, 4);
        exit_section_(builder_, level_, marker_, EQUALITY_EXPR, result_, true, null);
      }
      else if (priority_ < 5 && relationalExpr_0(builder_, level_ + 1)) {
        result_ = expr(builder_, level_, 5);
        exit_section_(builder_, level_, marker_, RELATIONAL_EXPR, result_, true, null);
      }
      else if (priority_ < 6 && consumeTokenSmart(builder_, OR)) {
        result_ = expr(builder_, level_, 6);
        exit_section_(builder_, level_, marker_, BIT_OR_EXPR, result_, true, null);
      }
      else if (priority_ < 7 && consumeTokenSmart(builder_, XOR)) {
        result_ = expr(builder_, level_, 7);
        exit_section_(builder_, level_, marker_, BIT_XOR_EXPR, result_, true, null);
      }
      else if (priority_ < 8 && consumeTokenSmart(builder_, AND)) {
        result_ = expr(builder_, level_, 8);
        exit_section_(builder_, level_, marker_, BIT_AND_EXPR, result_, true, null);
      }
      else if (priority_ < 9 && shiftExpr_0(builder_, level_ + 1)) {
        result_ = expr(builder_, level_, 9);
        exit_section_(builder_, level_, marker_, SHIFT_EXPR, result_, true, null);
      }
      else if (priority_ < 10 && consumeTokenSmart(builder_, DOUBLE_DOT)) {
        result_ = expr(builder_, level_, 10);
        exit_section_(builder_, level_, marker_, RANGE_EXPR, result_, true, null);
      }
      else if (priority_ < 11 && addExpr_0(builder_, level_ + 1)) {
        result_ = expr(builder_, level_, 11);
        exit_section_(builder_, level_, marker_, ADD_EXPR, result_, true, null);
      }
      else if (priority_ < 12 && mulExpr_0(builder_, level_ + 1)) {
        result_ = expr(builder_, level_, 12);
        exit_section_(builder_, level_, marker_, MUL_EXPR, result_, true, null);
      }
      else if (priority_ < 19 && callExpr_0(builder_, level_ + 1)) {
        result_ = true;
        exit_section_(builder_, level_, marker_, CALL_EXPR, result_, true, null);
      }
      else if (priority_ < 20 && indexExpr_0(builder_, level_ + 1)) {
        result_ = true;
        exit_section_(builder_, level_, marker_, INDEX_EXPR, result_, true, null);
      }
      else if (priority_ < 21 && memberExpr_0(builder_, level_ + 1)) {
        result_ = true;
        exit_section_(builder_, level_, marker_, MEMBER_EXPR, result_, true, null);
      }
      else if (priority_ < 22 && consumeTokenSmart(builder_, POSTFIX_DEREFERENCE)) {
        result_ = true;
        exit_section_(builder_, level_, marker_, DEREF_EXPR, result_, true, null);
      }
      else if (priority_ < 23 && typedStructLiteralExpr_0(builder_, level_ + 1)) {
        result_ = true;
        exit_section_(builder_, level_, marker_, TYPED_STRUCT_LITERAL_EXPR, result_, true, null);
      }
      else if (priority_ < 24 && typedArrayLiteralExpr_0(builder_, level_ + 1)) {
        result_ = true;
        exit_section_(builder_, level_, marker_, TYPED_ARRAY_LITERAL_EXPR, result_, true, null);
      }
      else {
        exit_section_(builder_, level_, marker_, null, false, false, null);
        break;
      }
    }
    return result_;
  }

  // <<eqEqNotSwitch>> | '!=' | '==='
  private static boolean equalityExpr_0(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "equalityExpr_0")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = eqEqNotSwitch(builder_, level_ + 1);
    if (!result_) result_ = consumeTokenSmart(builder_, NOT_EQ);
    if (!result_) result_ = consumeTokenSmart(builder_, EQ_EQ_EQ);
    exit_section_(builder_, marker_, null, result_);
    return result_;
  }

  // '<' | '>' | '<=' | '>='
  private static boolean relationalExpr_0(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "relationalExpr_0")) return false;
    boolean result_;
    result_ = consumeTokenSmart(builder_, LT);
    if (!result_) result_ = consumeTokenSmart(builder_, GT);
    if (!result_) result_ = consumeTokenSmart(builder_, LT_EQ);
    if (!result_) result_ = consumeTokenSmart(builder_, GT_EQ);
    return result_;
  }

  // '<<' | '>>' | '<<<' | '>>>'
  private static boolean shiftExpr_0(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "shiftExpr_0")) return false;
    boolean result_;
    result_ = consumeTokenSmart(builder_, SHL);
    if (!result_) result_ = consumeTokenSmart(builder_, SHR);
    if (!result_) result_ = consumeTokenSmart(builder_, ROL);
    if (!result_) result_ = consumeTokenSmart(builder_, ROR);
    return result_;
  }

  // '+' | '-'
  private static boolean addExpr_0(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "addExpr_0")) return false;
    boolean result_;
    result_ = consumeTokenSmart(builder_, PLUS);
    if (!result_) result_ = consumeTokenSmart(builder_, MINUS);
    return result_;
  }

  // '*' | '/' | '%'
  private static boolean mulExpr_0(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "mulExpr_0")) return false;
    boolean result_;
    result_ = consumeTokenSmart(builder_, STAR);
    if (!result_) result_ = consumeTokenSmart(builder_, SLASH);
    if (!result_) result_ = consumeTokenSmart(builder_, PERCENT);
    return result_;
  }

  public static boolean prefixExpr(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "prefixExpr")) return false;
    boolean result_, pinned_;
    Marker marker_ = enter_section_(builder_, level_, _NONE_, null);
    result_ = prefixOp_(builder_, level_ + 1);
    pinned_ = result_;
    result_ = pinned_ && expr(builder_, level_, 13);
    exit_section_(builder_, level_, marker_, PREFIX_EXPR, result_, pinned_, null);
    return result_ || pinned_;
  }

  // '[' ['..' | expr] ']' expr
  public static boolean arrayTypeExpr(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "arrayTypeExpr")) return false;
    if (!nextTokenIsSmart(builder_, LBRACKET)) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = consumeTokenSmart(builder_, LBRACKET);
    result_ = result_ && arrayTypeExpr_1(builder_, level_ + 1);
    result_ = result_ && consumeToken(builder_, RBRACKET);
    result_ = result_ && expr(builder_, level_ + 1, -1);
    exit_section_(builder_, marker_, ARRAY_TYPE_EXPR, result_);
    return result_;
  }

  // ['..' | expr]
  private static boolean arrayTypeExpr_1(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "arrayTypeExpr_1")) return false;
    arrayTypeExpr_1_0(builder_, level_ + 1);
    return true;
  }

  // '..' | expr
  private static boolean arrayTypeExpr_1_0(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "arrayTypeExpr_1_0")) return false;
    boolean result_;
    result_ = consumeTokenSmart(builder_, DOUBLE_DOT);
    if (!result_) result_ = expr(builder_, level_ + 1, -1);
    return result_;
  }

  // 'cast' [',' IDENT] '(' [expr] ')' expr
  public static boolean castExpr(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "castExpr")) return false;
    if (!nextTokenIsSmart(builder_, KW_CAST)) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = consumeTokenSmart(builder_, KW_CAST);
    result_ = result_ && castExpr_1(builder_, level_ + 1);
    result_ = result_ && consumeToken(builder_, LPAREN);
    result_ = result_ && castExpr_3(builder_, level_ + 1);
    result_ = result_ && consumeToken(builder_, RPAREN);
    result_ = result_ && expr(builder_, level_ + 1, -1);
    exit_section_(builder_, marker_, CAST_EXPR, result_);
    return result_;
  }

  // [',' IDENT]
  private static boolean castExpr_1(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "castExpr_1")) return false;
    parseTokensSmart(builder_, 0, COMMA, IDENT);
    return true;
  }

  // [expr]
  private static boolean castExpr_3(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "castExpr_3")) return false;
    expr(builder_, level_ + 1, -1);
    return true;
  }

  public static boolean autoCastExpr(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "autoCastExpr")) return false;
    if (!nextTokenIsSmart(builder_, KW_XX)) return false;
    boolean result_, pinned_;
    Marker marker_ = enter_section_(builder_, level_, _NONE_, null);
    result_ = autoCastExpr_0(builder_, level_ + 1);
    pinned_ = result_;
    result_ = pinned_ && expr(builder_, level_, 16);
    exit_section_(builder_, level_, marker_, AUTO_CAST_EXPR, result_, pinned_, null);
    return result_ || pinned_;
  }

  // 'xx' [',' IDENT]
  private static boolean autoCastExpr_0(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "autoCastExpr_0")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = consumeTokenSmart(builder_, KW_XX);
    result_ = result_ && autoCastExpr_0_1(builder_, level_ + 1);
    exit_section_(builder_, marker_, null, result_);
    return result_;
  }

  // [',' IDENT]
  private static boolean autoCastExpr_0_1(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "autoCastExpr_0_1")) return false;
    parseTokensSmart(builder_, 0, COMMA, IDENT);
    return true;
  }

  public static boolean inlineExpr(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "inlineExpr")) return false;
    if (!nextTokenIsSmart(builder_, KW_INLINE, KW_NO_INLINE)) return false;
    boolean result_, pinned_;
    Marker marker_ = enter_section_(builder_, level_, _NONE_, null);
    result_ = inlineExpr_0(builder_, level_ + 1);
    pinned_ = result_;
    result_ = pinned_ && expr(builder_, level_, 17);
    exit_section_(builder_, level_, marker_, INLINE_EXPR, result_, pinned_, null);
    return result_ || pinned_;
  }

  // 'inline' | 'no_inline'
  private static boolean inlineExpr_0(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "inlineExpr_0")) return false;
    boolean result_;
    result_ = consumeTokenSmart(builder_, KW_INLINE);
    if (!result_) result_ = consumeTokenSmart(builder_, KW_NO_INLINE);
    return result_;
  }

  // 'ifx' expr ['then'] expr ['else' expr]
  public static boolean ifxExpr(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "ifxExpr")) return false;
    if (!nextTokenIsSmart(builder_, KW_IFX)) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = consumeTokenSmart(builder_, KW_IFX);
    result_ = result_ && expr(builder_, level_ + 1, -1);
    result_ = result_ && ifxExpr_2(builder_, level_ + 1);
    result_ = result_ && expr(builder_, level_ + 1, -1);
    result_ = result_ && ifxExpr_4(builder_, level_ + 1);
    exit_section_(builder_, marker_, IFX_EXPR, result_);
    return result_;
  }

  // ['then']
  private static boolean ifxExpr_2(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "ifxExpr_2")) return false;
    consumeTokenSmart(builder_, KW_THEN);
    return true;
  }

  // ['else' expr]
  private static boolean ifxExpr_4(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "ifxExpr_4")) return false;
    ifxExpr_4_0(builder_, level_ + 1);
    return true;
  }

  // 'else' expr
  private static boolean ifxExpr_4_0(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "ifxExpr_4_0")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = consumeTokenSmart(builder_, KW_ELSE);
    result_ = result_ && expr(builder_, level_ + 1, -1);
    exit_section_(builder_, marker_, null, result_);
    return result_;
  }

  // '(' [argList] ')'
  private static boolean callExpr_0(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "callExpr_0")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = consumeTokenSmart(builder_, LPAREN);
    result_ = result_ && callExpr_0_1(builder_, level_ + 1);
    result_ = result_ && consumeToken(builder_, RPAREN);
    exit_section_(builder_, marker_, null, result_);
    return result_;
  }

  // [argList]
  private static boolean callExpr_0_1(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "callExpr_0_1")) return false;
    argList(builder_, level_ + 1);
    return true;
  }

  // '[' [expr] ']'
  private static boolean indexExpr_0(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "indexExpr_0")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = consumeTokenSmart(builder_, LBRACKET);
    result_ = result_ && indexExpr_0_1(builder_, level_ + 1);
    result_ = result_ && consumeToken(builder_, RBRACKET);
    exit_section_(builder_, marker_, null, result_);
    return result_;
  }

  // [expr]
  private static boolean indexExpr_0_1(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "indexExpr_0_1")) return false;
    expr(builder_, level_ + 1, -1);
    return true;
  }

  // '.' memberName
  private static boolean memberExpr_0(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "memberExpr_0")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = consumeTokenSmart(builder_, DOT);
    result_ = result_ && memberName(builder_, level_ + 1);
    exit_section_(builder_, marker_, null, result_);
    return result_;
  }

  // '.{' [argList] '}'
  private static boolean typedStructLiteralExpr_0(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "typedStructLiteralExpr_0")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = consumeTokenSmart(builder_, BEGIN_STRUCT_LITERAL);
    result_ = result_ && typedStructLiteralExpr_0_1(builder_, level_ + 1);
    result_ = result_ && consumeToken(builder_, RBRACE);
    exit_section_(builder_, marker_, null, result_);
    return result_;
  }

  // [argList]
  private static boolean typedStructLiteralExpr_0_1(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "typedStructLiteralExpr_0_1")) return false;
    argList(builder_, level_ + 1);
    return true;
  }

  // '.[' [argList] ']'
  private static boolean typedArrayLiteralExpr_0(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "typedArrayLiteralExpr_0")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = consumeTokenSmart(builder_, BEGIN_ARRAY_LITERAL);
    result_ = result_ && typedArrayLiteralExpr_0_1(builder_, level_ + 1);
    result_ = result_ && consumeToken(builder_, RBRACKET);
    exit_section_(builder_, marker_, null, result_);
    return result_;
  }

  // [argList]
  private static boolean typedArrayLiteralExpr_0_1(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "typedArrayLiteralExpr_0_1")) return false;
    argList(builder_, level_ + 1);
    return true;
  }

  // procLiteralExpr
  //               | structExpr
  //               | enumExpr
  //               | unionExpr
  //               | directiveExpr
  //               | parenExpr
  //               | structLiteralExpr
  //               | arrayLiteralExpr
  //               | unaryDotExpr
  //               | backtickExpr
  //               | builtinCallExpr
  //               | interfaceExpr
  //               | literalExpr
  //               | refExpr
  //               | uninitializedExpr
  public static boolean primaryExpr(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "primaryExpr")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_, level_, _COLLAPSE_, PRIMARY_EXPR, "<primary expr>");
    result_ = procLiteralExpr(builder_, level_ + 1);
    if (!result_) result_ = structExpr(builder_, level_ + 1);
    if (!result_) result_ = enumExpr(builder_, level_ + 1);
    if (!result_) result_ = unionExpr(builder_, level_ + 1);
    if (!result_) result_ = directiveExpr(builder_, level_ + 1);
    if (!result_) result_ = parenExpr(builder_, level_ + 1);
    if (!result_) result_ = structLiteralExpr(builder_, level_ + 1);
    if (!result_) result_ = arrayLiteralExpr(builder_, level_ + 1);
    if (!result_) result_ = unaryDotExpr(builder_, level_ + 1);
    if (!result_) result_ = backtickExpr(builder_, level_ + 1);
    if (!result_) result_ = builtinCallExpr(builder_, level_ + 1);
    if (!result_) result_ = interfaceExpr(builder_, level_ + 1);
    if (!result_) result_ = literalExpr(builder_, level_ + 1);
    if (!result_) result_ = refExpr(builder_, level_ + 1);
    if (!result_) result_ = uninitializedExpr(builder_, level_ + 1);
    exit_section_(builder_, level_, marker_, result_, false, null);
    return result_;
  }

}