import com.intellij.lang.PsiBuilder.Marker; //导入依赖的package包/类
private static boolean nakedTerm_0_1(PsiBuilder b, int l) {
  if (!recursion_guard_(b, l, "nakedTerm_0_1")) return false;
  boolean r;
  Marker m = enter_section_(b);
  r = nakedTerm_0_1_0(b, l + 1);
  int c = current_position_(b);
  while (r) {
    if (!nakedTerm_0_1_0(b, l + 1)) break;
    if (!empty_element_parsed_guard_(b, "nakedTerm_0_1", c)) break;
    c = current_position_(b);
  }
  exit_section_(b, m, null, r);
  return r;
}
 

import com.intellij.lang.PsiBuilder.Marker; //导入依赖的package包/类
private static boolean handlerLabeledParametersCallExpression_0_2_0_1_0_0_3_0_0(PsiBuilder b, int l) {
  if (!recursion_guard_(b, l, "handlerLabeledParametersCallExpression_0_2_0_1_0_0_3_0_0")) return false;
  boolean r;
  Marker m = enter_section_(b);
  r = consumeTokenFast(b, LAND);
  if (!r) r = consumeTokenFast(b, LOR);
  if (!r) r = consumeTokenFast(b, COMMA);
  exit_section_(b, m, null, r);
  return r;
}
 

import com.intellij.lang.PsiBuilder.Marker; //导入依赖的package包/类
static boolean root(PsiBuilder b, int l) {
  if (!recursion_guard_(b, l, "root")) return false;
  boolean r;
  Marker m = enter_section_(b, l, _NONE_);
  r = consumeToken(b, CRLF);
  if (!r) r = root_1(b, l + 1);
  exit_section_(b, l, m, r, false, recover_root_parser_);
  return r;
}
 

import com.intellij.lang.PsiBuilder.Marker; //导入依赖的package包/类
public static boolean string(PsiBuilder b, int l) {
  if (!recursion_guard_(b, l, "string")) return false;
  if (!nextTokenIs(b, "<string>", DQSTRING, SQSTRING)) return false;
  boolean r;
  Marker m = enter_section_(b, l, _NONE_, STRING, "<string>");
  r = consumeToken(b, DQSTRING);
  if (!r) r = consumeToken(b, SQSTRING);
  exit_section_(b, l, m, r, false, null);
  return r;
}
 

import com.intellij.lang.PsiBuilder.Marker; //导入依赖的package包/类
public static boolean activateCommandExpression(PsiBuilder b, int l) {
  if (!recursion_guard_(b, l, "activateCommandExpression")) return false;
  if (!nextTokenIsFast(b, ACTIVATE)) return false;
  boolean r;
  Marker m = enter_section_(b);
  r = consumeTokenFast(b, ACTIVATE);
  r = r && activateCommandExpression_1(b, l + 1);
  exit_section_(b, m, ACTIVATE_COMMAND_EXPRESSION, r);
  return r;
}
 

import com.intellij.lang.PsiBuilder.Marker; //导入依赖的package包/类
private static boolean parameter_0(PsiBuilder b, int l) {
  if (!recursion_guard_(b, l, "parameter_0")) return false;
  boolean r;
  Marker m = enter_section_(b);
  r = consumeToken(b, HEADER_PARAMETER_NAME);
  if (!r) r = macro_usage_dec(b, l + 1);
  if (!r) r = consumeToken(b, DOCUMENT_ID);
  exit_section_(b, m, null, r);
  return r;
}
 

import com.intellij.lang.PsiBuilder.Marker; //导入依赖的package包/类
private static boolean referenceIdBeforeParamLabel_1(PsiBuilder b, int l) {
  if (!recursion_guard_(b, l, "referenceIdBeforeParamLabel_1")) return false;
  boolean r;
  Marker m = enter_section_(b, l, _AND_);
  r = handlerParameterLabel(b, l + 1);
  exit_section_(b, l, m, r, false, null);
  return r;
}
 

import com.intellij.lang.PsiBuilder.Marker; //导入依赖的package包/类
private static boolean templateVariable_2_0(PsiBuilder b, int l) {
  if (!recursion_guard_(b, l, "templateVariable_2_0")) return false;
  boolean r;
  Marker m = enter_section_(b);
  r = consumeToken(b, TEMPLATE_VARIABLE_SEPARATOR);
  r = r && templateVariableExpressionG(b, l + 1);
  r = r && templateVariable_2_0_2(b, l + 1);
  exit_section_(b, m, null, r);
  return r;
}
 

import com.intellij.lang.PsiBuilder.Marker; //导入依赖的package包/类
private static boolean identifier_chain_1_0_0(PsiBuilder b, int l) {
  if (!recursion_guard_(b, l, "identifier_chain_1_0_0")) return false;
  boolean r;
  Marker m = enter_section_(b);
  r = identifier_chain_1_0_0_0(b, l + 1);
  r = r && identifier_chain_1_0_0_1(b, l + 1);
  exit_section_(b, m, null, r);
  return r;
}
 

import com.intellij.lang.PsiBuilder.Marker; //导入依赖的package包/类
private static boolean handlerLabeledParametersCallExpression_1_1_0_1(PsiBuilder b, int l) {
  if (!recursion_guard_(b, l, "handlerLabeledParametersCallExpression_1_1_0_1")) return false;
  boolean r;
  Marker m = enter_section_(b);
  r = consumeTokenFast(b, WITHOUT);
  r = r && labelForFalseParam(b, l + 1);
  r = r && handlerLabeledParametersCallExpression_1_1_0_1_2(b, l + 1);
  r = r && handlerLabeledParametersCallExpression_1_1_0_1_3(b, l + 1);
  exit_section_(b, m, null, r);
  return r;
}
 

import com.intellij.lang.PsiBuilder.Marker; //导入依赖的package包/类
public static boolean textItemDelimitersProperty(PsiBuilder b, int l) {
  if (!recursion_guard_(b, l, "textItemDelimitersProperty")) return false;
  if (!nextTokenIs(b, TEXT_ITEM_DELIMETERS)) return false;
  boolean r;
  Marker m = enter_section_(b);
  r = consumeToken(b, TEXT_ITEM_DELIMETERS);
  exit_section_(b, m, TEXT_ITEM_DELIMITERS_PROPERTY, r);
  return r;
}
 

import com.intellij.lang.PsiBuilder.Marker; //导入依赖的package包/类
private static boolean value_line_0(PsiBuilder b, int l) {
  if (!recursion_guard_(b, l, "value_line_0")) return false;
  boolean r;
  Marker m = enter_section_(b);
  r = consumeToken(b, VALUE_SUBTYPE);
  r = r && value_line_0_1(b, l + 1);
  exit_section_(b, m, null, r);
  return r;
}
 

import com.intellij.lang.PsiBuilder.Marker; //导入依赖的package包/类
private static boolean useScriptingAdditionsStatement_2_0_0_0(PsiBuilder b, int l) {
  if (!recursion_guard_(b, l, "useScriptingAdditionsStatement_2_0_0_0")) return false;
  boolean r;
  Marker m = enter_section_(b);
  r = consumeTokens(b, 0, WITH, IMPORTING);
  exit_section_(b, m, null, r);
  return r;
}
 

import com.intellij.lang.PsiBuilder.Marker; //导入依赖的package包/类
private static boolean root_0(PsiBuilder b, int l) {
  if (!recursion_guard_(b, l, "root_0")) return false;
  boolean r;
  Marker m = enter_section_(b);
  r = useClause(b, l + 1);
  int c = current_position_(b);
  while (r) {
    if (!useClause(b, l + 1)) break;
    if (!empty_element_parsed_guard_(b, "root_0", c)) break;
    c = current_position_(b);
  }
  exit_section_(b, m, null, r);
  return r;
}
 

import com.intellij.lang.PsiBuilder.Marker; //导入依赖的package包/类
public static boolean CONST_DECLARATION(PsiBuilder b, int l) {
  if (!recursion_guard_(b, l, "CONST_DECLARATION")) return false;
  if (!nextTokenIs(b, CONST)) return false;
  boolean r;
  Marker m = enter_section_(b);
  r = consumeTokens(b, 0, CONST, IDENT, COLON);
  r = r && TYPE_DECLARATION(b, l + 1);
  r = r && CONST_DECLARATION_4(b, l + 1);
  exit_section_(b, m, CONST_DECLARATION, r);
  return r;
}
 

import com.intellij.lang.PsiBuilder.Marker; //导入依赖的package包/类
public static boolean variableList(PsiBuilder b, int l) {
  if (!recursion_guard_(b, l, "variableList")) return false;
  if (!nextTokenIs(b, VARIABLE)) return false;
  boolean r;
  Marker m = enter_section_(b);
  r = consumeToken(b, VARIABLE);
  r = r && variableList_1(b, l + 1);
  exit_section_(b, m, VARIABLE_LIST, r);
  return r;
}
 

import com.intellij.lang.PsiBuilder.Marker; //导入依赖的package包/类
static boolean equalityOperator(PsiBuilder b, int l) {
  if (!recursion_guard_(b, l, "equalityOperator")) return false;
  if (!nextTokenIs(b, "", EQ, NE)) return false;
  boolean r;
  Marker m = enter_section_(b);
  r = consumeToken(b, NE);
  if (!r) r = consumeToken(b, EQ);
  exit_section_(b, m, null, r);
  return r;
}
 

import com.intellij.lang.PsiBuilder.Marker; //导入依赖的package包/类
public static boolean table_expression(PsiBuilder b, int l) {
  if (!recursion_guard_(b, l, "table_expression")) return false;
  if (!nextTokenIs(b, FROM)) return false;
  boolean r;
  Marker m = enter_section_(b);
  r = from_clause(b, l + 1);
  r = r && table_expression_1(b, l + 1);
  r = r && table_expression_2(b, l + 1);
  r = r && table_expression_3(b, l + 1);
  exit_section_(b, m, TABLE_EXPRESSION, r);
  return r;
}
 

import com.intellij.lang.PsiBuilder.Marker; //导入依赖的package包/类
public static boolean rawDictionaryCommandHandlerCallExpression(PsiBuilder b, int l) {
  if (!recursion_guard_(b, l, "rawDictionaryCommandHandlerCallExpression")) return false;
  if (!nextTokenIsFast(b, RAW_LBR)) return false;
  boolean r;
  Marker m = enter_section_(b);
  r = consumeTokens(b, 0, RAW_LBR, EVENT);
  r = r && identifier(b, l + 1);
  r = r && consumeToken(b, RAW_RBR);
  r = r && rawDictionaryCommandHandlerCallExpression_4(b, l + 1);
  exit_section_(b, m, RAW_DICTIONARY_COMMAND_HANDLER_CALL_EXPRESSION, r);
  return r;
}
 

import com.intellij.lang.PsiBuilder.Marker; //导入依赖的package包/类
public static boolean arbitraryReference(PsiBuilder b, int l) {
  if (!recursion_guard_(b, l, "arbitraryReference")) return false;
  if (!nextTokenIs(b, SOME)) return false;
  boolean r, p;
  Marker m = enter_section_(b, l, _NONE_, ARBITRARY_REFERENCE, null);
  r = consumeToken(b, SOME);
  p = r; // pin = 1
  r = r && typeSpecifier(b, l + 1);
  exit_section_(b, l, m, r, p, null);
  return r || p;
}