public static Rule_classImplements parse(ParserContext context) {
    context.push("classImplements");

    boolean parsed = true;
    int s0 = context.index;
    ArrayList<Rule> e0 = new ArrayList<Rule>();
    Rule rule;

    parsed = false;
    if (!parsed) {
      {
        ArrayList<Rule> e1 = new ArrayList<Rule>();
        int s1 = context.index;
        parsed = true;
        if (parsed) {
          boolean f1 = true;
          int c1 = 0;
          for (int i1 = 0; i1 < 1 && f1; i1++) {
            rule = Rule_optPadding.parse(context);
            if ((f1 = rule != null)) {
              e1.add(rule);
              c1++;
            }
          }
          parsed = c1 == 1;
        }
        if (parsed) {
          boolean f1 = true;
          int c1 = 0;
          for (int i1 = 0; i1 < 1 && f1; i1++) {
            rule = Rule_dirImplements.parse(context);
            if ((f1 = rule != null)) {
              e1.add(rule);
              c1++;
            }
          }
          parsed = c1 == 1;
        }
        if (parsed) {
          boolean f1 = true;
          int c1 = 0;
          for (int i1 = 0; i1 < 1 && f1; i1++) {
            rule = Rule_padding.parse(context);
            if ((f1 = rule != null)) {
              e1.add(rule);
              c1++;
            }
          }
          parsed = c1 == 1;
        }
        if (parsed) {
          boolean f1 = true;
          int c1 = 0;
          for (int i1 = 0; i1 < 1 && f1; i1++) {
            rule = Rule_className.parse(context);
            if ((f1 = rule != null)) {
              e1.add(rule);
              c1++;
            }
          }
          parsed = c1 == 1;
        }
        if (parsed) {
          boolean f1 = true;
          int c1 = 0;
          for (int i1 = 0; i1 < 1 && f1; i1++) {
            rule = Rule_optPadding.parse(context);
            if ((f1 = rule != null)) {
              e1.add(rule);
              c1++;
            }
          }
          parsed = c1 == 1;
        }
        if (parsed) {
          boolean f1 = true;
          int c1 = 0;
          for (int i1 = 0; i1 < 1 && f1; i1++) {
            rule = Rule_CRLF.parse(context);
            if ((f1 = rule != null)) {
              e1.add(rule);
              c1++;
            }
          }
          parsed = c1 == 1;
        }
        if (parsed) e0.addAll(e1);
        else context.index = s1;
      }
    }

    rule = null;
    if (parsed) rule = new Rule_classImplements(context.text.substring(s0, context.index), e0);
    else context.index = s0;

    context.pop("classImplements", parsed);

    return (Rule_classImplements) rule;
  }
  public static Rule_methodLine parse(ParserContext context) {
    context.push("methodLine");

    boolean parsed = true;
    int s0 = context.index;
    ArrayList<Rule> e0 = new ArrayList<Rule>();
    Rule rule;

    parsed = false;
    if (!parsed) {
      {
        ArrayList<Rule> e1 = new ArrayList<Rule>();
        int s1 = context.index;
        parsed = true;
        if (parsed) {
          boolean f1 = true;
          int c1 = 0;
          for (int i1 = 0; i1 < 1 && f1; i1++) {
            rule = Rule_optPadding.parse(context);
            if ((f1 = rule != null)) {
              e1.add(rule);
              c1++;
            }
          }
          parsed = c1 == 1;
        }
        if (parsed) {
          boolean f1 = true;
          int c1 = 0;
          for (int i1 = 0; i1 < 1 && f1; i1++) {
            rule = Terminal_StringValue.parse(context, ".line");
            if ((f1 = rule != null)) {
              e1.add(rule);
              c1++;
            }
          }
          parsed = c1 == 1;
        }
        if (parsed) {
          boolean f1 = true;
          int c1 = 0;
          for (int i1 = 0; i1 < 1 && f1; i1++) {
            rule = Rule_padding.parse(context);
            if ((f1 = rule != null)) {
              e1.add(rule);
              c1++;
            }
          }
          parsed = c1 == 1;
        }
        if (parsed) {
          boolean f1 = true;
          int c1 = 0;
          for (int i1 = 0; i1 < 1 && f1; i1++) {
            rule = Rule_intValue.parse(context);
            if ((f1 = rule != null)) {
              e1.add(rule);
              c1++;
            }
          }
          parsed = c1 == 1;
        }
        if (parsed) {
          boolean f1 = true;
          int c1 = 0;
          for (int i1 = 0; i1 < 1 && f1; i1++) {
            rule = Rule_optPadding.parse(context);
            if ((f1 = rule != null)) {
              e1.add(rule);
              c1++;
            }
          }
          parsed = c1 == 1;
        }
        if (parsed) {
          boolean f1 = true;
          int c1 = 0;
          for (int i1 = 0; i1 < 1 && f1; i1++) {
            rule = Rule_CRLF.parse(context);
            if ((f1 = rule != null)) {
              e1.add(rule);
              c1++;
            }
          }
          parsed = c1 == 1;
        }
        if (parsed) e0.addAll(e1);
        else context.index = s1;
      }
    }

    rule = null;
    if (parsed) rule = new Rule_methodLine(context.text.substring(s0, context.index), e0);
    else context.index = s0;

    context.pop("methodLine", parsed);

    return (Rule_methodLine) rule;
  }
  public static Rule_cmdMoveResultWide parse(ParserContext context) {
    context.push("cmdMoveResultWide");

    boolean parsed = true;
    int s0 = context.index;
    ArrayList<Rule> e0 = new ArrayList<Rule>();
    Rule rule;

    parsed = false;
    if (!parsed) {
      {
        ArrayList<Rule> e1 = new ArrayList<Rule>();
        int s1 = context.index;
        parsed = true;
        if (parsed) {
          boolean f1 = true;
          int c1 = 0;
          for (int i1 = 0; i1 < 1 && f1; i1++) {
            rule = Rule_optPadding.parse(context);
            if ((f1 = rule != null)) {
              e1.add(rule);
              c1++;
            }
          }
          parsed = c1 == 1;
        }
        if (parsed) {
          boolean f1 = true;
          int c1 = 0;
          for (int i1 = 0; i1 < 1 && f1; i1++) {
            rule = Terminal_StringValue.parse(context, "move-result-wide");
            if ((f1 = rule != null)) {
              e1.add(rule);
              c1++;
            }
          }
          parsed = c1 == 1;
        }
        if (parsed) {
          boolean f1 = true;
          int c1 = 0;
          for (int i1 = 0; i1 < 1 && f1; i1++) {
            rule = Rule_padding.parse(context);
            if ((f1 = rule != null)) {
              e1.add(rule);
              c1++;
            }
          }
          parsed = c1 == 1;
        }
        if (parsed) {
          boolean f1 = true;
          int c1 = 0;
          for (int i1 = 0; i1 < 1 && f1; i1++) {
            rule = Rule_codeRegisterV64Dst.parse(context);
            if ((f1 = rule != null)) {
              e1.add(rule);
              c1++;
            }
          }
          parsed = c1 == 1;
        }
        if (parsed) {
          boolean f1 = true;
          int c1 = 0;
          for (int i1 = 0; i1 < 1 && f1; i1++) {
            rule = Rule_optPadding.parse(context);
            if ((f1 = rule != null)) {
              e1.add(rule);
              c1++;
            }
          }
          parsed = c1 == 1;
        }
        if (parsed) {
          boolean f1 = true;
          @SuppressWarnings("unused")
          int c1 = 0;
          for (int i1 = 0; i1 < 1 && f1; i1++) {
            int g1 = context.index;
            parsed = false;
            if (!parsed) {
              {
                ArrayList<Rule> e2 = new ArrayList<Rule>();
                int s2 = context.index;
                parsed = true;
                if (parsed) {
                  boolean f2 = true;
                  int c2 = 0;
                  for (int i2 = 0; i2 < 1 && f2; i2++) {
                    rule = Rule_padding.parse(context);
                    if ((f2 = rule != null)) {
                      e2.add(rule);
                      c2++;
                    }
                  }
                  parsed = c2 == 1;
                }
                if (parsed) {
                  boolean f2 = true;
                  int c2 = 0;
                  for (int i2 = 0; i2 < 1 && f2; i2++) {
                    rule = Rule_commentSequence.parse(context);
                    if ((f2 = rule != null)) {
                      e2.add(rule);
                      c2++;
                    }
                  }
                  parsed = c2 == 1;
                }
                if (parsed) e1.addAll(e2);
                else context.index = s2;
              }
            }
            f1 = context.index > g1;
            if (parsed) c1++;
          }
          parsed = true;
        }
        if (parsed) {
          boolean f1 = true;
          int c1 = 0;
          for (int i1 = 0; i1 < 1 && f1; i1++) {
            rule = Rule_CRLF.parse(context);
            if ((f1 = rule != null)) {
              e1.add(rule);
              c1++;
            }
          }
          parsed = c1 == 1;
        }
        if (parsed) e0.addAll(e1);
        else context.index = s1;
      }
    }

    rule = null;
    if (parsed) rule = new Rule_cmdMoveResultWide(context.text.substring(s0, context.index), e0);
    else context.index = s0;

    context.pop("cmdMoveResultWide", parsed);

    return (Rule_cmdMoveResultWide) rule;
  }
  public static Rule_codeRegisterGroup parse(ParserContext context) {
    context.push("codeRegisterGroup");

    boolean parsed = true;
    int s0 = context.index;
    ArrayList<Rule> e0 = new ArrayList<Rule>();
    Rule rule;

    parsed = false;
    if (!parsed) {
      {
        ArrayList<Rule> e1 = new ArrayList<Rule>();
        int s1 = context.index;
        parsed = true;
        if (parsed) {
          boolean f1 = true;
          int c1 = 0;
          for (int i1 = 0; i1 < 1 && f1; i1++) {
            rule = Terminal_StringValue.parse(context, "{");
            if ((f1 = rule != null)) {
              e1.add(rule);
              c1++;
            }
          }
          parsed = c1 == 1;
        }
        if (parsed) {
          boolean f1 = true;
          int c1 = 0;
          for (int i1 = 0; i1 < 1 && f1; i1++) {
            rule = Rule_optPadding.parse(context);
            if ((f1 = rule != null)) {
              e1.add(rule);
              c1++;
            }
          }
          parsed = c1 == 1;
        }
        if (parsed) {
          boolean f1 = true;
          @SuppressWarnings("unused")
          int c1 = 0;
          while (f1) {
            int g1 = context.index;
            parsed = false;
            if (!parsed) {
              {
                ArrayList<Rule> e2 = new ArrayList<Rule>();
                int s2 = context.index;
                parsed = true;
                if (parsed) {
                  boolean f2 = true;
                  int c2 = 0;
                  for (int i2 = 0; i2 < 1 && f2; i2++) {
                    rule = Rule_codeRegisterP.parse(context);
                    if ((f2 = rule != null)) {
                      e2.add(rule);
                      c2++;
                    }
                  }
                  parsed = c2 == 1;
                }
                if (parsed) e1.addAll(e2);
                else context.index = s2;
              }
            }
            if (!parsed) {
              {
                ArrayList<Rule> e2 = new ArrayList<Rule>();
                int s2 = context.index;
                parsed = true;
                if (parsed) {
                  boolean f2 = true;
                  int c2 = 0;
                  for (int i2 = 0; i2 < 1 && f2; i2++) {
                    rule = Rule_codeRegisterV.parse(context);
                    if ((f2 = rule != null)) {
                      e2.add(rule);
                      c2++;
                    }
                  }
                  parsed = c2 == 1;
                }
                if (parsed) e1.addAll(e2);
                else context.index = s2;
              }
            }
            f1 = context.index > g1;
            if (parsed) c1++;
          }
          parsed = true;
        }
        if (parsed) {
          boolean f1 = true;
          int c1 = 0;
          for (int i1 = 0; i1 < 1 && f1; i1++) {
            rule = Rule_optPadding.parse(context);
            if ((f1 = rule != null)) {
              e1.add(rule);
              c1++;
            }
          }
          parsed = c1 == 1;
        }
        if (parsed) {
          boolean f1 = true;
          @SuppressWarnings("unused")
          int c1 = 0;
          while (f1) {
            int g1 = context.index;
            parsed = false;
            if (!parsed) {
              {
                ArrayList<Rule> e2 = new ArrayList<Rule>();
                int s2 = context.index;
                parsed = true;
                if (parsed) {
                  boolean f2 = true;
                  int c2 = 0;
                  for (int i2 = 0; i2 < 1 && f2; i2++) {
                    rule = Rule_COMMA.parse(context);
                    if ((f2 = rule != null)) {
                      e2.add(rule);
                      c2++;
                    }
                  }
                  parsed = c2 == 1;
                }
                if (parsed) {
                  boolean f2 = true;
                  int c2 = 0;
                  for (int i2 = 0; i2 < 1 && f2; i2++) {
                    rule = Rule_optPadding.parse(context);
                    if ((f2 = rule != null)) {
                      e2.add(rule);
                      c2++;
                    }
                  }
                  parsed = c2 == 1;
                }
                if (parsed) {
                  boolean f2 = true;
                  int c2 = 0;
                  for (int i2 = 0; i2 < 1 && f2; i2++) {
                    int g2 = context.index;
                    parsed = false;
                    if (!parsed) {
                      {
                        ArrayList<Rule> e3 = new ArrayList<Rule>();
                        int s3 = context.index;
                        parsed = true;
                        if (parsed) {
                          boolean f3 = true;
                          int c3 = 0;
                          for (int i3 = 0; i3 < 1 && f3; i3++) {
                            rule = Rule_codeRegisterP.parse(context);
                            if ((f3 = rule != null)) {
                              e3.add(rule);
                              c3++;
                            }
                          }
                          parsed = c3 == 1;
                        }
                        if (parsed) e2.addAll(e3);
                        else context.index = s3;
                      }
                    }
                    if (!parsed) {
                      {
                        ArrayList<Rule> e3 = new ArrayList<Rule>();
                        int s3 = context.index;
                        parsed = true;
                        if (parsed) {
                          boolean f3 = true;
                          int c3 = 0;
                          for (int i3 = 0; i3 < 1 && f3; i3++) {
                            rule = Rule_codeRegisterV.parse(context);
                            if ((f3 = rule != null)) {
                              e3.add(rule);
                              c3++;
                            }
                          }
                          parsed = c3 == 1;
                        }
                        if (parsed) e2.addAll(e3);
                        else context.index = s3;
                      }
                    }
                    f2 = context.index > g2;
                    if (parsed) c2++;
                  }
                  parsed = c2 == 1;
                }
                if (parsed) {
                  boolean f2 = true;
                  int c2 = 0;
                  for (int i2 = 0; i2 < 1 && f2; i2++) {
                    rule = Rule_optPadding.parse(context);
                    if ((f2 = rule != null)) {
                      e2.add(rule);
                      c2++;
                    }
                  }
                  parsed = c2 == 1;
                }
                if (parsed) e1.addAll(e2);
                else context.index = s2;
              }
            }
            f1 = context.index > g1;
            if (parsed) c1++;
          }
          parsed = true;
        }
        if (parsed) {
          boolean f1 = true;
          int c1 = 0;
          for (int i1 = 0; i1 < 1 && f1; i1++) {
            rule = Terminal_StringValue.parse(context, "}");
            if ((f1 = rule != null)) {
              e1.add(rule);
              c1++;
            }
          }
          parsed = c1 == 1;
        }
        if (parsed) e0.addAll(e1);
        else context.index = s1;
      }
    }

    rule = null;
    if (parsed) rule = new Rule_codeRegisterGroup(context.text.substring(s0, context.index), e0);
    else context.index = s0;

    context.pop("codeRegisterGroup", parsed);

    return (Rule_codeRegisterGroup) rule;
  }