//\\ B<char> = 0;
//\\ B<identifier> = 1;
//\\ B<integer-constant> = 2;
//\\ B<character-constant> = 3;
//\\ B<floating-constant> = 4;
//\\ B<string> = 5;
//\\ B<EOF> = 6;

 
//\\ P<primary-expression> = 
//\\    <identifier>,
//\\    <constant>,
//\\    <string>,
//\\    <?sp> '(' <expression> <?sp> ')';

case P_primary_expression:
  if (alt == 0)        {
    T[1] = identifier(ap+0);
    T[0] = mktuple(phrase /*P_primary_expression*/, alt /*1*/, /*phrases*/ 1, T /*T[1]*/);
  } else if (alt == 1) {
    T[1] = build_ast(A[ap+0], depth+1); // <constant>
    T[0] = mktuple(phrase /*P_primary_expression*/, alt /*2*/, /*phrases*/ 1, T /*T[1]*/);
  } else if (alt == 2) {
    T[1] = string(ap+0);
    T[0] = mktuple(phrase /*P_primary_expression*/, alt /*3*/, /*phrases*/ 1, T /*T[1]*/);
  } else               {
    T[1] = -1; // <?sp>
    T[2] = lit('(');
    T[3] = build_ast(A[ap+1], depth+1); // <expression>
    T[4] = -1; // <?sp>
    T[5] = lit(')');
    T[0] = mktuple(phrase /*P_primary_expression*/, alt /*4*/, /*phrases*/ 5, T /*T[1], T[2], T[3], T[4], T[5]*/);
  }
  return T[0];



 
//\\ P<post-increment-op> = 
//\\    <?sp> '+' '+',
//\\    <?sp> '-' '-';

case P_post_increment_op:
  if (alt == 0)        {
    T[1] = -1; // <?sp>
    T[2] = lit('+');
    T[3] = lit('+');
    T[0] = mktuple(phrase /*P_post_increment_op*/, alt /*1*/, /*phrases*/ 3, T /*T[1], T[2], T[3]*/);
  } else               {
    T[1] = -1; // <?sp>
    T[2] = lit('-');
    T[3] = lit('-');
    T[0] = mktuple(phrase /*P_post_increment_op*/, alt /*2*/, /*phrases*/ 3, T /*T[1], T[2], T[3]*/);
  }
  return T[0];



 
//\\ P<postfix-lvalue-expression> = 
//\\    <primary-expression> <rest-of-postfix-expression>;

case P_postfix_lvalue_expression:
  T[1] = build_ast(A[ap+0], depth+1); // <primary-expression>
  T[2] = build_ast(A[ap+1], depth+1); // <rest-of-postfix-expression>
  return mktuple(phrase /*P_postfix_lvalue_expression*/, alt /*1*/, /*phrases*/ 2, T /*T[1], T[2]*/);


 
//\\ P<rest-of-postfix-expression> = 
//\\    <?sp> '[' <expression> <?sp> ']' <rest-of-postfix-expression>,
//\\    <?sp> '(' <param-list> <?sp> ')' <non-empty-rest-of-postfix-expression>,
//\\    <?sp> '.' <identifier> <rest-of-postfix-expression>,
//\\    <?sp> '-' '>' <identifier> <rest-of-postfix-expression>,
//\\    <post-increment-op> <rest-of-postfix-expression>,
//\\   ;

case P_rest_of_postfix_expression:
  if (alt == 0)        {
    T[1] = -1; // <?sp>
    T[2] = lit('[');
    T[3] = build_ast(A[ap+1], depth+1); // <expression>
    T[4] = -1; // <?sp>
    T[5] = lit(']');
    T[6] = build_ast(A[ap+3], depth+1); // <rest-of-postfix-expression>
    T[0] = mktuple(phrase /*P_rest_of_postfix_expression*/, alt /*1*/, /*phrases*/ 6, T /*T[1], T[2], T[3], T[4], T[5], T[6]*/);
  } else if (alt == 1) {
    T[1] = -1; // <?sp>
    T[2] = lit('(');
    T[3] = build_ast(A[ap+1], depth+1); // <param-list>
    T[4] = -1; // <?sp>
    T[5] = lit(')');
    T[6] = build_ast(A[ap+3], depth+1); // <non-empty-rest-of-postfix-expression>
    T[0] = mktuple(phrase /*P_rest_of_postfix_expression*/, alt /*2*/, /*phrases*/ 6, T /*T[1], T[2], T[3], T[4], T[5], T[6]*/);
  } else if (alt == 2) {
    T[1] = -1; // <?sp>
    T[2] = lit('.');
    T[3] = identifier(ap+1);
    T[4] = build_ast(A[ap+2], depth+1); // <rest-of-postfix-expression>
    T[0] = mktuple(phrase /*P_rest_of_postfix_expression*/, alt /*3*/, /*phrases*/ 4, T /*T[1], T[2], T[3], T[4]*/);
  } else if (alt == 3) {
    T[1] = -1; // <?sp>
    T[2] = lit('-');
    T[3] = lit('>');
    T[4] = identifier(ap+1);
    T[5] = build_ast(A[ap+2], depth+1); // <rest-of-postfix-expression>
    T[0] = mktuple(phrase /*P_rest_of_postfix_expression*/, alt /*4*/, /*phrases*/ 5, T /*T[1], T[2], T[3], T[4], T[5]*/);
  } else if (alt == 4) {
    T[1] = build_ast(A[ap+0], depth+1); // <post-increment-op>
    T[2] = build_ast(A[ap+1], depth+1); // <rest-of-postfix-expression>
    T[0] = mktuple(phrase /*P_rest_of_postfix_expression*/, alt /*5*/, /*phrases*/ 2, T /*T[1], T[2]*/);
  } else               {
    T[0] = mktuple(phrase /*P_rest_of_postfix_expression*/, alt /*6*/, /*phrases*/ 0, T /**/);
  }
  return T[0];



 
//\\ P<non-empty-rest-of-postfix-expression> = 
//\\    <?sp> '[' <expression> <?sp> ']' <rest-of-postfix-expression>,
//\\    <?sp> '(' <param-list> <?sp> ')' <non-empty-rest-of-postfix-expression>,
//\\    <?sp> '.' <identifier> <rest-of-postfix-expression>,
//\\    <?sp> '-' '>' <identifier> <rest-of-postfix-expression>,
//\\    <post-increment-op> <rest-of-postfix-expression>;

case P_non_empty_rest_of_postfix_expression:
  if (alt == 0)        {
    T[1] = -1; // <?sp>
    T[2] = lit('[');
    T[3] = build_ast(A[ap+1], depth+1); // <expression>
    T[4] = -1; // <?sp>
    T[5] = lit(']');
    T[6] = build_ast(A[ap+3], depth+1); // <rest-of-postfix-expression>
    T[0] = mktuple(phrase /*P_non_empty_rest_of_postfix_expression*/, alt /*1*/, /*phrases*/ 6, T /*T[1], T[2], T[3], T[4], T[5], T[6]*/);
  } else if (alt == 1) {
    T[1] = -1; // <?sp>
    T[2] = lit('(');
    T[3] = build_ast(A[ap+1], depth+1); // <param-list>
    T[4] = -1; // <?sp>
    T[5] = lit(')');
    T[6] = build_ast(A[ap+3], depth+1); // <non-empty-rest-of-postfix-expression>
    T[0] = mktuple(phrase /*P_non_empty_rest_of_postfix_expression*/, alt /*2*/, /*phrases*/ 6, T /*T[1], T[2], T[3], T[4], T[5], T[6]*/);
  } else if (alt == 2) {
    T[1] = -1; // <?sp>
    T[2] = lit('.');
    T[3] = identifier(ap+1);
    T[4] = build_ast(A[ap+2], depth+1); // <rest-of-postfix-expression>
    T[0] = mktuple(phrase /*P_non_empty_rest_of_postfix_expression*/, alt /*3*/, /*phrases*/ 4, T /*T[1], T[2], T[3], T[4]*/);
  } else if (alt == 3) {
    T[1] = -1; // <?sp>
    T[2] = lit('-');
    T[3] = lit('>');
    T[4] = identifier(ap+1);
    T[5] = build_ast(A[ap+2], depth+1); // <rest-of-postfix-expression>
    T[0] = mktuple(phrase /*P_non_empty_rest_of_postfix_expression*/, alt /*4*/, /*phrases*/ 5, T /*T[1], T[2], T[3], T[4], T[5]*/);
  } else               {
    T[1] = build_ast(A[ap+0], depth+1); // <post-increment-op>
    T[2] = build_ast(A[ap+1], depth+1); // <rest-of-postfix-expression>
    T[0] = mktuple(phrase /*P_non_empty_rest_of_postfix_expression*/, alt /*5*/, /*phrases*/ 2, T /*T[1], T[2]*/);
  }
  return T[0];



 
//\\ P<postfix-rvalue-expression> = 
//\\    <primary-expression> <rest-of-postfix-rvalue-expression>;

case P_postfix_rvalue_expression:
  T[1] = build_ast(A[ap+0], depth+1); // <primary-expression>
  T[2] = build_ast(A[ap+1], depth+1); // <rest-of-postfix-rvalue-expression>
  return mktuple(phrase /*P_postfix_rvalue_expression*/, alt /*1*/, /*phrases*/ 2, T /*T[1], T[2]*/);


 
//\\ P<rest-of-postfix-rvalue-expression> = 
//\\    <?sp> '[' <expression> <?sp> ']' <rest-of-postfix-rvalue-expression>,
//\\    <?sp> '(' <param-list> <?sp> ')' <rest-of-postfix-rvalue-expression>,
//\\    <?sp> '.' <identifier> <rest-of-postfix-rvalue-expression>,
//\\    <?sp> '-' '>' <identifier> <rest-of-postfix-rvalue-expression>,
//\\    <post-increment-op> <rest-of-postfix-rvalue-expression>,
//\\   ;

case P_rest_of_postfix_rvalue_expression:
  if (alt == 0)        {
    T[1] = -1; // <?sp>
    T[2] = lit('[');
    T[3] = build_ast(A[ap+1], depth+1); // <expression>
    T[4] = -1; // <?sp>
    T[5] = lit(']');
    T[6] = build_ast(A[ap+3], depth+1); // <rest-of-postfix-rvalue-expression>
    T[0] = mktuple(phrase /*P_rest_of_postfix_rvalue_expression*/, alt /*1*/, /*phrases*/ 6, T /*T[1], T[2], T[3], T[4], T[5], T[6]*/);
  } else if (alt == 1) {
    T[1] = -1; // <?sp>
    T[2] = lit('(');
    T[3] = build_ast(A[ap+1], depth+1); // <param-list>
    T[4] = -1; // <?sp>
    T[5] = lit(')');
    T[6] = build_ast(A[ap+3], depth+1); // <rest-of-postfix-rvalue-expression>
    T[0] = mktuple(phrase /*P_rest_of_postfix_rvalue_expression*/, alt /*2*/, /*phrases*/ 6, T /*T[1], T[2], T[3], T[4], T[5], T[6]*/);
  } else if (alt == 2) {
    T[1] = -1; // <?sp>
    T[2] = lit('.');
    T[3] = identifier(ap+1);
    T[4] = build_ast(A[ap+2], depth+1); // <rest-of-postfix-rvalue-expression>
    T[0] = mktuple(phrase /*P_rest_of_postfix_rvalue_expression*/, alt /*3*/, /*phrases*/ 4, T /*T[1], T[2], T[3], T[4]*/);
  } else if (alt == 3) {
    T[1] = -1; // <?sp>
    T[2] = lit('-');
    T[3] = lit('>');
    T[4] = identifier(ap+1);
    T[5] = build_ast(A[ap+2], depth+1); // <rest-of-postfix-rvalue-expression>
    T[0] = mktuple(phrase /*P_rest_of_postfix_rvalue_expression*/, alt /*4*/, /*phrases*/ 5, T /*T[1], T[2], T[3], T[4], T[5]*/);
  } else if (alt == 4) {
    T[1] = build_ast(A[ap+0], depth+1); // <post-increment-op>
    T[2] = build_ast(A[ap+1], depth+1); // <rest-of-postfix-rvalue-expression>
    T[0] = mktuple(phrase /*P_rest_of_postfix_rvalue_expression*/, alt /*5*/, /*phrases*/ 2, T /*T[1], T[2]*/);
  } else               {
    T[0] = mktuple(phrase /*P_rest_of_postfix_rvalue_expression*/, alt /*6*/, /*phrases*/ 0, T /**/);
  }
  return T[0];



 
//\\ P<signed> = 
//\\    <?sp> "signed",
//\\    <?sp> "unsigned",
//\\   ;

case P_signed:
  if (alt == 0)        {
    T[1] = -1; // <?sp>
    T[2] = kw(/*"signed"*/ 0);
    T[0] = mktuple(phrase /*P_signed*/, alt /*1*/, /*phrases*/ 2, T /*T[1], T[2]*/);
  } else if (alt == 1) {
    T[1] = -1; // <?sp>
    T[2] = kw(/*"unsigned"*/ 1);
    T[0] = mktuple(phrase /*P_signed*/, alt /*2*/, /*phrases*/ 2, T /*T[1], T[2]*/);
  } else               {
    T[0] = mktuple(phrase /*P_signed*/, alt /*3*/, /*phrases*/ 0, T /**/);
  }
  return T[0];



 
//\\ P<inttype> = 
//\\    <?sp> "short" <int>,
//\\    <?sp> "long" <?sp> "long" <int>,
//\\    <?sp> "long" <int>;

case P_inttype:
  if (alt == 0)        {
    T[1] = -1; // <?sp>
    T[2] = kw(/*"short"*/ 2);
    T[3] = build_ast(A[ap+1], depth+1); // <int>
    T[0] = mktuple(phrase /*P_inttype*/, alt /*1*/, /*phrases*/ 3, T /*T[1], T[2], T[3]*/);
  } else if (alt == 1) {
    T[1] = -1; // <?sp>
    T[2] = kw(/*"long"*/ 3);
    T[3] = -1; // <?sp>
    T[4] = kw(/*"long"*/ 3);
    T[5] = build_ast(A[ap+2], depth+1); // <int>
    T[0] = mktuple(phrase /*P_inttype*/, alt /*2*/, /*phrases*/ 5, T /*T[1], T[2], T[3], T[4], T[5]*/);
  } else               {
    T[1] = -1; // <?sp>
    T[2] = kw(/*"long"*/ 3);
    T[3] = build_ast(A[ap+1], depth+1); // <int>
    T[0] = mktuple(phrase /*P_inttype*/, alt /*3*/, /*phrases*/ 3, T /*T[1], T[2], T[3]*/);
  }
  return T[0];



 
//\\ P<int> = 
//\\    <?sp> "int",
//\\   ;

case P_int:
  if (alt == 0)        {
    T[1] = -1; // <?sp>
    T[2] = kw(/*"int"*/ 4);
    T[0] = mktuple(phrase /*P_int*/, alt /*1*/, /*phrases*/ 2, T /*T[1], T[2]*/);
  } else               {
    T[0] = mktuple(phrase /*P_int*/, alt /*2*/, /*phrases*/ 0, T /**/);
  }
  return T[0];



 
//\\ P<type-specifier> = 
//\\    <?sp> "void",
//\\    <signed> <?sp> "char",
//\\    <signed> <inttype>,
//\\    <?sp> "float",
//\\    <?sp> "double",
//\\    <typedef-name>;

case P_type_specifier:
  if (alt == 0)        {
    T[1] = -1; // <?sp>
    T[2] = kw(/*"void"*/ 5);
    T[0] = mktuple(phrase /*P_type_specifier*/, alt /*1*/, /*phrases*/ 2, T /*T[1], T[2]*/);
  } else if (alt == 1) {
    T[1] = build_ast(A[ap+0], depth+1); // <signed>
    T[2] = -1; // <?sp>
    T[3] = kw(/*"char"*/ 6);
    T[0] = mktuple(phrase /*P_type_specifier*/, alt /*2*/, /*phrases*/ 3, T /*T[1], T[2], T[3]*/);
  } else if (alt == 2) {
    T[1] = build_ast(A[ap+0], depth+1); // <signed>
    T[2] = build_ast(A[ap+1], depth+1); // <inttype>
    T[0] = mktuple(phrase /*P_type_specifier*/, alt /*3*/, /*phrases*/ 2, T /*T[1], T[2]*/);
  } else if (alt == 3) {
    T[1] = -1; // <?sp>
    T[2] = kw(/*"float"*/ 7);
    T[0] = mktuple(phrase /*P_type_specifier*/, alt /*4*/, /*phrases*/ 2, T /*T[1], T[2]*/);
  } else if (alt == 4) {
    T[1] = -1; // <?sp>
    T[2] = kw(/*"double"*/ 8);
    T[0] = mktuple(phrase /*P_type_specifier*/, alt /*5*/, /*phrases*/ 2, T /*T[1], T[2]*/);
  } else               {
    T[1] = build_ast(A[ap+0], depth+1); // <typedef-name>
    T[0] = mktuple(phrase /*P_type_specifier*/, alt /*6*/, /*phrases*/ 1, T /*T[1]*/);
  }
  return T[0];



 
//\\ P<indirection-unary-ops> = 
//\\    <?sp> '*' <rest-of-indirection-unary-ops>;

case P_indirection_unary_ops:
  T[1] = -1; // <?sp>
  T[2] = lit('*');
  T[3] = build_ast(A[ap+1], depth+1); // <rest-of-indirection-unary-ops>
  return mktuple(phrase /*P_indirection_unary_ops*/, alt /*1*/, /*phrases*/ 3, T /*T[1], T[2], T[3]*/);


 
//\\ P<rest-of-indirection-unary-ops> = 
//\\    <?sp> '*' <rest-of-indirection-unary-ops>,
//\\   ;

case P_rest_of_indirection_unary_ops:
  if (alt == 0)        {
    T[1] = -1; // <?sp>
    T[2] = lit('*');
    T[3] = build_ast(A[ap+1], depth+1); // <rest-of-indirection-unary-ops>
    T[0] = mktuple(phrase /*P_rest_of_indirection_unary_ops*/, alt /*1*/, /*phrases*/ 3, T /*T[1], T[2], T[3]*/);
  } else               {
    T[0] = mktuple(phrase /*P_rest_of_indirection_unary_ops*/, alt /*2*/, /*phrases*/ 0, T /**/);
  }
  return T[0];



 
//\\ P<arithmetic-unary-op> = 
//\\    <?sp> '+',
//\\    <?sp> '-';

case P_arithmetic_unary_op:
  if (alt == 0)        {
    T[1] = -1; // <?sp>
    T[2] = lit('+');
    T[0] = mktuple(phrase /*P_arithmetic_unary_op*/, alt /*1*/, /*phrases*/ 2, T /*T[1], T[2]*/);
  } else               {
    T[1] = -1; // <?sp>
    T[2] = lit('-');
    T[0] = mktuple(phrase /*P_arithmetic_unary_op*/, alt /*2*/, /*phrases*/ 2, T /*T[1], T[2]*/);
  }
  return T[0];



 
//\\ P<boolean-unary-ops> = 
//\\    <?sp> '!' <rest-of-boolean-unary-ops>;

case P_boolean_unary_ops:
  T[1] = -1; // <?sp>
  T[2] = lit('!');
  T[3] = build_ast(A[ap+1], depth+1); // <rest-of-boolean-unary-ops>
  return mktuple(phrase /*P_boolean_unary_ops*/, alt /*1*/, /*phrases*/ 3, T /*T[1], T[2], T[3]*/);


 
//\\ P<rest-of-boolean-unary-ops> = 
//\\    <?sp> '!' <rest-of-boolean-unary-ops>,
//\\   ;

case P_rest_of_boolean_unary_ops:
  if (alt == 0)        {
    T[1] = -1; // <?sp>
    T[2] = lit('!');
    T[3] = build_ast(A[ap+1], depth+1); // <rest-of-boolean-unary-ops>
    T[0] = mktuple(phrase /*P_rest_of_boolean_unary_ops*/, alt /*1*/, /*phrases*/ 3, T /*T[1], T[2], T[3]*/);
  } else               {
    T[0] = mktuple(phrase /*P_rest_of_boolean_unary_ops*/, alt /*2*/, /*phrases*/ 0, T /**/);
  }
  return T[0];



 
//\\ P<bitwise-unary-ops> = 
//\\    <?sp> '~' <rest-of-bitwise-unary-ops>;

case P_bitwise_unary_ops:
  T[1] = -1; // <?sp>
  T[2] = lit('~');
  T[3] = build_ast(A[ap+1], depth+1); // <rest-of-bitwise-unary-ops>
  return mktuple(phrase /*P_bitwise_unary_ops*/, alt /*1*/, /*phrases*/ 3, T /*T[1], T[2], T[3]*/);


 
//\\ P<rest-of-bitwise-unary-ops> = 
//\\    <?sp> '~' <rest-of-bitwise-unary-ops>,
//\\   ;

case P_rest_of_bitwise_unary_ops:
  if (alt == 0)        {
    T[1] = -1; // <?sp>
    T[2] = lit('~');
    T[3] = build_ast(A[ap+1], depth+1); // <rest-of-bitwise-unary-ops>
    T[0] = mktuple(phrase /*P_rest_of_bitwise_unary_ops*/, alt /*1*/, /*phrases*/ 3, T /*T[1], T[2], T[3]*/);
  } else               {
    T[0] = mktuple(phrase /*P_rest_of_bitwise_unary_ops*/, alt /*2*/, /*phrases*/ 0, T /**/);
  }
  return T[0];



 
//\\ P<address-operator> = 
//\\    <?sp> '&';

case P_address_operator:
  T[1] = -1; // <?sp>
  T[2] = lit('&');
  return mktuple(phrase /*P_address_operator*/, alt /*1*/, /*phrases*/ 2, T /*T[1], T[2]*/);


 
//\\ P<pre-increment-op> = 
//\\    <?sp> '+' '+',
//\\    <?sp> '-' '-';

case P_pre_increment_op:
  if (alt == 0)        {
    T[1] = -1; // <?sp>
    T[2] = lit('+');
    T[3] = lit('+');
    T[0] = mktuple(phrase /*P_pre_increment_op*/, alt /*1*/, /*phrases*/ 3, T /*T[1], T[2], T[3]*/);
  } else               {
    T[1] = -1; // <?sp>
    T[2] = lit('-');
    T[3] = lit('-');
    T[0] = mktuple(phrase /*P_pre_increment_op*/, alt /*2*/, /*phrases*/ 3, T /*T[1], T[2], T[3]*/);
  }
  return T[0];



 
//\\ P<optionally-cast-unary-rvalue-expression> = 
//\\    <?sp> '(' <type-specifier> <?sp> ')' <optionally-cast-unary-rvalue-expression>,
//\\    <unary-rvalue-expression>;

case P_optionally_cast_unary_rvalue_expression:
  if (alt == 0)        {
    T[1] = -1; // <?sp>
    T[2] = lit('(');
    T[3] = build_ast(A[ap+1], depth+1); // <type-specifier>
    T[4] = -1; // <?sp>
    T[5] = lit(')');
    T[6] = build_ast(A[ap+3], depth+1); // <optionally-cast-unary-rvalue-expression>
    T[0] = mktuple(phrase /*P_optionally_cast_unary_rvalue_expression*/, alt /*1*/, /*phrases*/ 6, T /*T[1], T[2], T[3], T[4], T[5], T[6]*/);
  } else               {
    T[1] = build_ast(A[ap+0], depth+1); // <unary-rvalue-expression>
    T[0] = mktuple(phrase /*P_optionally_cast_unary_rvalue_expression*/, alt /*2*/, /*phrases*/ 1, T /*T[1]*/);
  }
  return T[0];



 
//\\ P<optionally-cast-postfix-rvalue-expression> = 
//\\    <?sp> '(' <type-specifier> <?sp> ')' <optionally-cast-postfix-rvalue-expression>,
//\\    <postfix-rvalue-expression>;

case P_optionally_cast_postfix_rvalue_expression:
  if (alt == 0)        {
    T[1] = -1; // <?sp>
    T[2] = lit('(');
    T[3] = build_ast(A[ap+1], depth+1); // <type-specifier>
    T[4] = -1; // <?sp>
    T[5] = lit(')');
    T[6] = build_ast(A[ap+3], depth+1); // <optionally-cast-postfix-rvalue-expression>
    T[0] = mktuple(phrase /*P_optionally_cast_postfix_rvalue_expression*/, alt /*1*/, /*phrases*/ 6, T /*T[1], T[2], T[3], T[4], T[5], T[6]*/);
  } else               {
    T[1] = build_ast(A[ap+0], depth+1); // <postfix-rvalue-expression>
    T[0] = mktuple(phrase /*P_optionally_cast_postfix_rvalue_expression*/, alt /*2*/, /*phrases*/ 1, T /*T[1]*/);
  }
  return T[0];



 
//\\ P<unary-rvalue-expression> = 
//\\    <arithmetic-unary-op> <optionally-cast-unary-rvalue-expression>,
//\\    <boolean-unary-ops> <optionally-cast-unary-rvalue-expression>,
//\\    <bitwise-unary-ops> <optionally-cast-unary-rvalue-expression>,
//\\    <indirection-unary-ops> <unary-address-expression>,
//\\    <?sp> "sizeof" <unary-rvalue-expression>,
//\\    <?sp> "sizeof" <unary-lvalue-expression>,
//\\    <?sp> "sizeof" <type-specifier>,
//\\    <optionally-cast-postfix-rvalue-expression>;

case P_unary_rvalue_expression:
  if (alt == 0)        {
    T[1] = build_ast(A[ap+0], depth+1); // <arithmetic-unary-op>
    T[2] = build_ast(A[ap+1], depth+1); // <optionally-cast-unary-rvalue-expression>
    T[0] = mktuple(phrase /*P_unary_rvalue_expression*/, alt /*1*/, /*phrases*/ 2, T /*T[1], T[2]*/);
  } else if (alt == 1) {
    T[1] = build_ast(A[ap+0], depth+1); // <boolean-unary-ops>
    T[2] = build_ast(A[ap+1], depth+1); // <optionally-cast-unary-rvalue-expression>
    T[0] = mktuple(phrase /*P_unary_rvalue_expression*/, alt /*2*/, /*phrases*/ 2, T /*T[1], T[2]*/);
  } else if (alt == 2) {
    T[1] = build_ast(A[ap+0], depth+1); // <bitwise-unary-ops>
    T[2] = build_ast(A[ap+1], depth+1); // <optionally-cast-unary-rvalue-expression>
    T[0] = mktuple(phrase /*P_unary_rvalue_expression*/, alt /*3*/, /*phrases*/ 2, T /*T[1], T[2]*/);
  } else if (alt == 3) {
    T[1] = build_ast(A[ap+0], depth+1); // <indirection-unary-ops>
    T[2] = build_ast(A[ap+1], depth+1); // <unary-address-expression>
    T[0] = mktuple(phrase /*P_unary_rvalue_expression*/, alt /*4*/, /*phrases*/ 2, T /*T[1], T[2]*/);
  } else if (alt == 4) {
    T[1] = -1; // <?sp>
    T[2] = kw(/*"sizeof"*/ 9);
    T[3] = build_ast(A[ap+1], depth+1); // <unary-rvalue-expression>
    T[0] = mktuple(phrase /*P_unary_rvalue_expression*/, alt /*5*/, /*phrases*/ 3, T /*T[1], T[2], T[3]*/);
  } else if (alt == 5) {
    T[1] = -1; // <?sp>
    T[2] = kw(/*"sizeof"*/ 9);
    T[3] = build_ast(A[ap+1], depth+1); // <unary-lvalue-expression>
    T[0] = mktuple(phrase /*P_unary_rvalue_expression*/, alt /*6*/, /*phrases*/ 3, T /*T[1], T[2], T[3]*/);
  } else if (alt == 6) {
    T[1] = -1; // <?sp>
    T[2] = kw(/*"sizeof"*/ 9);
    T[3] = build_ast(A[ap+1], depth+1); // <type-specifier>
    T[0] = mktuple(phrase /*P_unary_rvalue_expression*/, alt /*7*/, /*phrases*/ 3, T /*T[1], T[2], T[3]*/);
  } else               {
    T[1] = build_ast(A[ap+0], depth+1); // <optionally-cast-postfix-rvalue-expression>
    T[0] = mktuple(phrase /*P_unary_rvalue_expression*/, alt /*8*/, /*phrases*/ 1, T /*T[1]*/);
  }
  return T[0];



 
//\\ P<optionally-cast-unary-lvalue-expression> = 
//\\    <?sp> '(' <type-specifier> <?sp> ')' <optionally-cast-unary-lvalue-expression>,
//\\    <unary-lvalue-expression>;

case P_optionally_cast_unary_lvalue_expression:
  if (alt == 0)        {
    T[1] = -1; // <?sp>
    T[2] = lit('(');
    T[3] = build_ast(A[ap+1], depth+1); // <type-specifier>
    T[4] = -1; // <?sp>
    T[5] = lit(')');
    T[6] = build_ast(A[ap+3], depth+1); // <optionally-cast-unary-lvalue-expression>
    T[0] = mktuple(phrase /*P_optionally_cast_unary_lvalue_expression*/, alt /*1*/, /*phrases*/ 6, T /*T[1], T[2], T[3], T[4], T[5], T[6]*/);
  } else               {
    T[1] = build_ast(A[ap+0], depth+1); // <unary-lvalue-expression>
    T[0] = mktuple(phrase /*P_optionally_cast_unary_lvalue_expression*/, alt /*2*/, /*phrases*/ 1, T /*T[1]*/);
  }
  return T[0];



 
//\\ P<unary-lvalue-expression> = 
//\\    <pre-increment-op> <unary-lvalue-expression>,
//\\    <indirection-unary-ops> <unary-address-expression>,
//\\    <postfix-lvalue-expression>;

case P_unary_lvalue_expression:
  if (alt == 0)        {
    T[1] = build_ast(A[ap+0], depth+1); // <pre-increment-op>
    T[2] = build_ast(A[ap+1], depth+1); // <unary-lvalue-expression>
    T[0] = mktuple(phrase /*P_unary_lvalue_expression*/, alt /*1*/, /*phrases*/ 2, T /*T[1], T[2]*/);
  } else if (alt == 1) {
    T[1] = build_ast(A[ap+0], depth+1); // <indirection-unary-ops>
    T[2] = build_ast(A[ap+1], depth+1); // <unary-address-expression>
    T[0] = mktuple(phrase /*P_unary_lvalue_expression*/, alt /*2*/, /*phrases*/ 2, T /*T[1], T[2]*/);
  } else               {
    T[1] = build_ast(A[ap+0], depth+1); // <postfix-lvalue-expression>
    T[0] = mktuple(phrase /*P_unary_lvalue_expression*/, alt /*3*/, /*phrases*/ 1, T /*T[1]*/);
  }
  return T[0];



 
//\\ P<unary-address-expression> = 
//\\    <address-operator> <optionally-cast-unary-lvalue-expression>;

case P_unary_address_expression:
  T[1] = build_ast(A[ap+0], depth+1); // <address-operator>
  T[2] = build_ast(A[ap+1], depth+1); // <optionally-cast-unary-lvalue-expression>
  return mktuple(phrase /*P_unary_address_expression*/, alt /*1*/, /*phrases*/ 2, T /*T[1], T[2]*/);


 
//\\ P<multiplicative-expression> = 
//\\    <unary-rvalue-expression> <rest-of-multiplicative-expression>;

case P_multiplicative_expression:
  T[1] = build_ast(A[ap+0], depth+1); // <unary-rvalue-expression>
  T[2] = build_ast(A[ap+1], depth+1); // <rest-of-multiplicative-expression>
  return mktuple(phrase /*P_multiplicative_expression*/, alt /*1*/, /*phrases*/ 2, T /*T[1], T[2]*/);


 
//\\ P<rest-of-multiplicative-expression> = 
//\\    <mulop> <unary-rvalue-expression> <rest-of-multiplicative-expression>,
//\\   ;

case P_rest_of_multiplicative_expression:
  if (alt == 0)        {
    T[1] = build_ast(A[ap+0], depth+1); // <mulop>
    T[2] = build_ast(A[ap+1], depth+1); // <unary-rvalue-expression>
    T[3] = build_ast(A[ap+2], depth+1); // <rest-of-multiplicative-expression>
    T[0] = mktuple(phrase /*P_rest_of_multiplicative_expression*/, alt /*1*/, /*phrases*/ 3, T /*T[1], T[2], T[3]*/);
  } else               {
    T[0] = mktuple(phrase /*P_rest_of_multiplicative_expression*/, alt /*2*/, /*phrases*/ 0, T /**/);
  }
  return T[0];



 
//\\ P<mulop> = 
//\\    <?sp> '*',
//\\    <?sp> '/',
//\\    <?sp> '%';

case P_mulop:
  if (alt == 0)        {
    T[1] = -1; // <?sp>
    T[2] = lit('*');
    T[0] = mktuple(phrase /*P_mulop*/, alt /*1*/, /*phrases*/ 2, T /*T[1], T[2]*/);
  } else if (alt == 1) {
    T[1] = -1; // <?sp>
    T[2] = lit('/');
    T[0] = mktuple(phrase /*P_mulop*/, alt /*2*/, /*phrases*/ 2, T /*T[1], T[2]*/);
  } else               {
    T[1] = -1; // <?sp>
    T[2] = lit('%');
    T[0] = mktuple(phrase /*P_mulop*/, alt /*3*/, /*phrases*/ 2, T /*T[1], T[2]*/);
  }
  return T[0];



 
//\\ P<additive-expression> = 
//\\    <multiplicative-expression> <rest-of-additive-expression>;

case P_additive_expression:
  T[1] = build_ast(A[ap+0], depth+1); // <multiplicative-expression>
  T[2] = build_ast(A[ap+1], depth+1); // <rest-of-additive-expression>
  return mktuple(phrase /*P_additive_expression*/, alt /*1*/, /*phrases*/ 2, T /*T[1], T[2]*/);


 
//\\ P<rest-of-additive-expression> = 
//\\    <plusminus> <multiplicative-expression> <rest-of-additive-expression>,
//\\   ;

case P_rest_of_additive_expression:
  if (alt == 0)        {
    T[1] = build_ast(A[ap+0], depth+1); // <plusminus>
    T[2] = build_ast(A[ap+1], depth+1); // <multiplicative-expression>
    T[3] = build_ast(A[ap+2], depth+1); // <rest-of-additive-expression>
    T[0] = mktuple(phrase /*P_rest_of_additive_expression*/, alt /*1*/, /*phrases*/ 3, T /*T[1], T[2], T[3]*/);
  } else               {
    T[0] = mktuple(phrase /*P_rest_of_additive_expression*/, alt /*2*/, /*phrases*/ 0, T /**/);
  }
  return T[0];



 
//\\ P<plusminus> = 
//\\    <?sp> '+',
//\\    <?sp> '-';

case P_plusminus:
  if (alt == 0)        {
    T[1] = -1; // <?sp>
    T[2] = lit('+');
    T[0] = mktuple(phrase /*P_plusminus*/, alt /*1*/, /*phrases*/ 2, T /*T[1], T[2]*/);
  } else               {
    T[1] = -1; // <?sp>
    T[2] = lit('-');
    T[0] = mktuple(phrase /*P_plusminus*/, alt /*2*/, /*phrases*/ 2, T /*T[1], T[2]*/);
  }
  return T[0];



 
//\\ P<shift-expression> = 
//\\    <additive-expression> <rest-of-shift-expression>;

case P_shift_expression:
  T[1] = build_ast(A[ap+0], depth+1); // <additive-expression>
  T[2] = build_ast(A[ap+1], depth+1); // <rest-of-shift-expression>
  return mktuple(phrase /*P_shift_expression*/, alt /*1*/, /*phrases*/ 2, T /*T[1], T[2]*/);


 
//\\ P<rest-of-shift-expression> = 
//\\    <shiftop> <additive-expression> <rest-of-shift-expression>,
//\\   ;

case P_rest_of_shift_expression:
  if (alt == 0)        {
    T[1] = build_ast(A[ap+0], depth+1); // <shiftop>
    T[2] = build_ast(A[ap+1], depth+1); // <additive-expression>
    T[3] = build_ast(A[ap+2], depth+1); // <rest-of-shift-expression>
    T[0] = mktuple(phrase /*P_rest_of_shift_expression*/, alt /*1*/, /*phrases*/ 3, T /*T[1], T[2], T[3]*/);
  } else               {
    T[0] = mktuple(phrase /*P_rest_of_shift_expression*/, alt /*2*/, /*phrases*/ 0, T /**/);
  }
  return T[0];



 
//\\ P<shiftop> = 
//\\    <?sp> '<' '<',
//\\    <?sp> '>' '>';

case P_shiftop:
  if (alt == 0)        {
    T[1] = -1; // <?sp>
    T[2] = lit('<');
    T[3] = lit('<');
    T[0] = mktuple(phrase /*P_shiftop*/, alt /*1*/, /*phrases*/ 3, T /*T[1], T[2], T[3]*/);
  } else               {
    T[1] = -1; // <?sp>
    T[2] = lit('>');
    T[3] = lit('>');
    T[0] = mktuple(phrase /*P_shiftop*/, alt /*2*/, /*phrases*/ 3, T /*T[1], T[2], T[3]*/);
  }
  return T[0];



 
//\\ P<relational-expression> = 
//\\    <shift-expression> <rest-of-relational-expression>;

case P_relational_expression:
  T[1] = build_ast(A[ap+0], depth+1); // <shift-expression>
  T[2] = build_ast(A[ap+1], depth+1); // <rest-of-relational-expression>
  return mktuple(phrase /*P_relational_expression*/, alt /*1*/, /*phrases*/ 2, T /*T[1], T[2]*/);


 
//\\ P<rest-of-relational-expression> = 
//\\    <relop> <shift-expression> <rest-of-relational-expression>,
//\\   ;

case P_rest_of_relational_expression:
  if (alt == 0)        {
    T[1] = build_ast(A[ap+0], depth+1); // <relop>
    T[2] = build_ast(A[ap+1], depth+1); // <shift-expression>
    T[3] = build_ast(A[ap+2], depth+1); // <rest-of-relational-expression>
    T[0] = mktuple(phrase /*P_rest_of_relational_expression*/, alt /*1*/, /*phrases*/ 3, T /*T[1], T[2], T[3]*/);
  } else               {
    T[0] = mktuple(phrase /*P_rest_of_relational_expression*/, alt /*2*/, /*phrases*/ 0, T /**/);
  }
  return T[0];



 
//\\ P<relop> = 
//\\    <?sp> '<' '=',
//\\    <?sp> '<',
//\\    <?sp> '>' '=',
//\\    <?sp> '>';

case P_relop:
  if (alt == 0)        {
    T[1] = -1; // <?sp>
    T[2] = lit('<');
    T[3] = lit('=');
    T[0] = mktuple(phrase /*P_relop*/, alt /*1*/, /*phrases*/ 3, T /*T[1], T[2], T[3]*/);
  } else if (alt == 1) {
    T[1] = -1; // <?sp>
    T[2] = lit('<');
    T[0] = mktuple(phrase /*P_relop*/, alt /*2*/, /*phrases*/ 2, T /*T[1], T[2]*/);
  } else if (alt == 2) {
    T[1] = -1; // <?sp>
    T[2] = lit('>');
    T[3] = lit('=');
    T[0] = mktuple(phrase /*P_relop*/, alt /*3*/, /*phrases*/ 3, T /*T[1], T[2], T[3]*/);
  } else               {
    T[1] = -1; // <?sp>
    T[2] = lit('>');
    T[0] = mktuple(phrase /*P_relop*/, alt /*4*/, /*phrases*/ 2, T /*T[1], T[2]*/);
  }
  return T[0];



 
//\\ P<equality-expression> = 
//\\    <relational-expression> <rest-of-equality-expression>;

case P_equality_expression:
  T[1] = build_ast(A[ap+0], depth+1); // <relational-expression>
  T[2] = build_ast(A[ap+1], depth+1); // <rest-of-equality-expression>
  return mktuple(phrase /*P_equality_expression*/, alt /*1*/, /*phrases*/ 2, T /*T[1], T[2]*/);


 
//\\ P<rest-of-equality-expression> = 
//\\    <eqop> <relational-expression> <rest-of-equality-expression>,
//\\   ;

case P_rest_of_equality_expression:
  if (alt == 0)        {
    T[1] = build_ast(A[ap+0], depth+1); // <eqop>
    T[2] = build_ast(A[ap+1], depth+1); // <relational-expression>
    T[3] = build_ast(A[ap+2], depth+1); // <rest-of-equality-expression>
    T[0] = mktuple(phrase /*P_rest_of_equality_expression*/, alt /*1*/, /*phrases*/ 3, T /*T[1], T[2], T[3]*/);
  } else               {
    T[0] = mktuple(phrase /*P_rest_of_equality_expression*/, alt /*2*/, /*phrases*/ 0, T /**/);
  }
  return T[0];



 
//\\ P<eqop> = 
//\\    <?sp> '=' '=',
//\\    <?sp> '!' '=';

case P_eqop:
  if (alt == 0)        {
    T[1] = -1; // <?sp>
    T[2] = lit('=');
    T[3] = lit('=');
    T[0] = mktuple(phrase /*P_eqop*/, alt /*1*/, /*phrases*/ 3, T /*T[1], T[2], T[3]*/);
  } else               {
    T[1] = -1; // <?sp>
    T[2] = lit('!');
    T[3] = lit('=');
    T[0] = mktuple(phrase /*P_eqop*/, alt /*2*/, /*phrases*/ 3, T /*T[1], T[2], T[3]*/);
  }
  return T[0];



 
//\\ P<bitwise-and-expression> = 
//\\    <equality-expression> <rest-of-bitwise-and-expression>;

case P_bitwise_and_expression:
  T[1] = build_ast(A[ap+0], depth+1); // <equality-expression>
  T[2] = build_ast(A[ap+1], depth+1); // <rest-of-bitwise-and-expression>
  return mktuple(phrase /*P_bitwise_and_expression*/, alt /*1*/, /*phrases*/ 2, T /*T[1], T[2]*/);


 
//\\ P<rest-of-bitwise-and-expression> = 
//\\    <?sp> '&' <equality-expression> <rest-of-bitwise-and-expression>,
//\\   ;

case P_rest_of_bitwise_and_expression:
  if (alt == 0)        {
    T[1] = -1; // <?sp>
    T[2] = lit('&');
    T[3] = build_ast(A[ap+1], depth+1); // <equality-expression>
    T[4] = build_ast(A[ap+2], depth+1); // <rest-of-bitwise-and-expression>
    T[0] = mktuple(phrase /*P_rest_of_bitwise_and_expression*/, alt /*1*/, /*phrases*/ 4, T /*T[1], T[2], T[3], T[4]*/);
  } else               {
    T[0] = mktuple(phrase /*P_rest_of_bitwise_and_expression*/, alt /*2*/, /*phrases*/ 0, T /**/);
  }
  return T[0];



 
//\\ P<exclusive-or-expression> = 
//\\    <bitwise-and-expression> <rest-of-exclusive-or-expression>;

case P_exclusive_or_expression:
  T[1] = build_ast(A[ap+0], depth+1); // <bitwise-and-expression>
  T[2] = build_ast(A[ap+1], depth+1); // <rest-of-exclusive-or-expression>
  return mktuple(phrase /*P_exclusive_or_expression*/, alt /*1*/, /*phrases*/ 2, T /*T[1], T[2]*/);


 
//\\ P<rest-of-exclusive-or-expression> = 
//\\    <?sp> '^' <bitwise-and-expression> <rest-of-exclusive-or-expression>,
//\\   ;

case P_rest_of_exclusive_or_expression:
  if (alt == 0)        {
    T[1] = -1; // <?sp>
    T[2] = lit('^');
    T[3] = build_ast(A[ap+1], depth+1); // <bitwise-and-expression>
    T[4] = build_ast(A[ap+2], depth+1); // <rest-of-exclusive-or-expression>
    T[0] = mktuple(phrase /*P_rest_of_exclusive_or_expression*/, alt /*1*/, /*phrases*/ 4, T /*T[1], T[2], T[3], T[4]*/);
  } else               {
    T[0] = mktuple(phrase /*P_rest_of_exclusive_or_expression*/, alt /*2*/, /*phrases*/ 0, T /**/);
  }
  return T[0];



 
//\\ P<inclusive-or-expression> = 
//\\    <exclusive-or-expression> <rest-of-inclusive-or-expression>;

case P_inclusive_or_expression:
  T[1] = build_ast(A[ap+0], depth+1); // <exclusive-or-expression>
  T[2] = build_ast(A[ap+1], depth+1); // <rest-of-inclusive-or-expression>
  return mktuple(phrase /*P_inclusive_or_expression*/, alt /*1*/, /*phrases*/ 2, T /*T[1], T[2]*/);


 
//\\ P<rest-of-inclusive-or-expression> = 
//\\    <?sp> '|' <exclusive-or-expression> <rest-of-inclusive-or-expression>,
//\\   ;

case P_rest_of_inclusive_or_expression:
  if (alt == 0)        {
    T[1] = -1; // <?sp>
    T[2] = lit('|');
    T[3] = build_ast(A[ap+1], depth+1); // <exclusive-or-expression>
    T[4] = build_ast(A[ap+2], depth+1); // <rest-of-inclusive-or-expression>
    T[0] = mktuple(phrase /*P_rest_of_inclusive_or_expression*/, alt /*1*/, /*phrases*/ 4, T /*T[1], T[2], T[3], T[4]*/);
  } else               {
    T[0] = mktuple(phrase /*P_rest_of_inclusive_or_expression*/, alt /*2*/, /*phrases*/ 0, T /**/);
  }
  return T[0];



 
//\\ P<logical-and-expression> = 
//\\    <inclusive-or-expression> <rest-of-logical-and-expression>;

case P_logical_and_expression:
  T[1] = build_ast(A[ap+0], depth+1); // <inclusive-or-expression>
  T[2] = build_ast(A[ap+1], depth+1); // <rest-of-logical-and-expression>
  return mktuple(phrase /*P_logical_and_expression*/, alt /*1*/, /*phrases*/ 2, T /*T[1], T[2]*/);


 
//\\ P<rest-of-logical-and-expression> = 
//\\    <?sp> '&' '&' <inclusive-or-expression> <rest-of-logical-and-expression>,
//\\   ;

case P_rest_of_logical_and_expression:
  if (alt == 0)        {
    T[1] = -1; // <?sp>
    T[2] = lit('&');
    T[3] = lit('&');
    T[4] = build_ast(A[ap+1], depth+1); // <inclusive-or-expression>
    T[5] = build_ast(A[ap+2], depth+1); // <rest-of-logical-and-expression>
    T[0] = mktuple(phrase /*P_rest_of_logical_and_expression*/, alt /*1*/, /*phrases*/ 5, T /*T[1], T[2], T[3], T[4], T[5]*/);
  } else               {
    T[0] = mktuple(phrase /*P_rest_of_logical_and_expression*/, alt /*2*/, /*phrases*/ 0, T /**/);
  }
  return T[0];



 
//\\ P<logical-or-expression> = 
//\\    <logical-and-expression> <rest-of-logical-or-expression>;

case P_logical_or_expression:
  T[1] = build_ast(A[ap+0], depth+1); // <logical-and-expression>
  T[2] = build_ast(A[ap+1], depth+1); // <rest-of-logical-or-expression>
  return mktuple(phrase /*P_logical_or_expression*/, alt /*1*/, /*phrases*/ 2, T /*T[1], T[2]*/);


 
//\\ P<rest-of-logical-or-expression> = 
//\\    <?sp> '|' '|' <logical-and-expression> <rest-of-logical-or-expression>,
//\\   ;

case P_rest_of_logical_or_expression:
  if (alt == 0)        {
    T[1] = -1; // <?sp>
    T[2] = lit('|');
    T[3] = lit('|');
    T[4] = build_ast(A[ap+1], depth+1); // <logical-and-expression>
    T[5] = build_ast(A[ap+2], depth+1); // <rest-of-logical-or-expression>
    T[0] = mktuple(phrase /*P_rest_of_logical_or_expression*/, alt /*1*/, /*phrases*/ 5, T /*T[1], T[2], T[3], T[4], T[5]*/);
  } else               {
    T[0] = mktuple(phrase /*P_rest_of_logical_or_expression*/, alt /*2*/, /*phrases*/ 0, T /**/);
  }
  return T[0];



 
//\\ P<conditional-expression> = 
//\\    <logical-or-expression> <rest-of-conditional-expression>;

case P_conditional_expression:
  T[1] = build_ast(A[ap+0], depth+1); // <logical-or-expression>
  T[2] = build_ast(A[ap+1], depth+1); // <rest-of-conditional-expression>
  return mktuple(phrase /*P_conditional_expression*/, alt /*1*/, /*phrases*/ 2, T /*T[1], T[2]*/);


 
//\\ P<rest-of-conditional-expression> = 
//\\    <?sp> '?' <expression> <?sp> ':' <conditional-expression>,
//\\   ;

case P_rest_of_conditional_expression:
  if (alt == 0)        {
    T[1] = -1; // <?sp>
    T[2] = lit('?');
    T[3] = build_ast(A[ap+1], depth+1); // <expression>
    T[4] = -1; // <?sp>
    T[5] = lit(':');
    T[6] = build_ast(A[ap+3], depth+1); // <conditional-expression>
    T[0] = mktuple(phrase /*P_rest_of_conditional_expression*/, alt /*1*/, /*phrases*/ 6, T /*T[1], T[2], T[3], T[4], T[5], T[6]*/);
  } else               {
    T[0] = mktuple(phrase /*P_rest_of_conditional_expression*/, alt /*2*/, /*phrases*/ 0, T /**/);
  }
  return T[0];



 
//\\ P<assignment-expression> = 
//\\    <opt-lvalue-assign> <conditional-expression>;

case P_assignment_expression:
  T[1] = build_ast(A[ap+0], depth+1); // <opt-lvalue-assign>
  T[2] = build_ast(A[ap+1], depth+1); // <conditional-expression>
  return mktuple(phrase /*P_assignment_expression*/, alt /*1*/, /*phrases*/ 2, T /*T[1], T[2]*/);


 
//\\ P<opt-lvalue-assign> = 
//\\    <unary-lvalue-expression> <assignment-operator>,
//\\   ;

case P_opt_lvalue_assign:
  if (alt == 0)        {
    T[1] = build_ast(A[ap+0], depth+1); // <unary-lvalue-expression>
    T[2] = build_ast(A[ap+1], depth+1); // <assignment-operator>
    T[0] = mktuple(phrase /*P_opt_lvalue_assign*/, alt /*1*/, /*phrases*/ 2, T /*T[1], T[2]*/);
  } else               {
    T[0] = mktuple(phrase /*P_opt_lvalue_assign*/, alt /*2*/, /*phrases*/ 0, T /**/);
  }
  return T[0];



 
//\\ P<assignment-operator> = 
//\\    <?sp> '=',
//\\    <?sp> '*' '=',
//\\    <?sp> '/' '=',
//\\    <?sp> '%' '=',
//\\    <?sp> '+' '=',
//\\    <?sp> '-' '=',
//\\    <?sp> '<' '<' '=',
//\\    <?sp> '>' '>' '=',
//\\    <?sp> '&' '=',
//\\    <?sp> '^' '=',
//\\    <?sp> '|' '=';

case P_assignment_operator:
  if (alt == 0)        {
    T[1] = -1; // <?sp>
    T[2] = lit('=');
    T[0] = mktuple(phrase /*P_assignment_operator*/, alt /*1*/, /*phrases*/ 2, T /*T[1], T[2]*/);
  } else if (alt == 1) {
    T[1] = -1; // <?sp>
    T[2] = lit('*');
    T[3] = lit('=');
    T[0] = mktuple(phrase /*P_assignment_operator*/, alt /*2*/, /*phrases*/ 3, T /*T[1], T[2], T[3]*/);
  } else if (alt == 2) {
    T[1] = -1; // <?sp>
    T[2] = lit('/');
    T[3] = lit('=');
    T[0] = mktuple(phrase /*P_assignment_operator*/, alt /*3*/, /*phrases*/ 3, T /*T[1], T[2], T[3]*/);
  } else if (alt == 3) {
    T[1] = -1; // <?sp>
    T[2] = lit('%');
    T[3] = lit('=');
    T[0] = mktuple(phrase /*P_assignment_operator*/, alt /*4*/, /*phrases*/ 3, T /*T[1], T[2], T[3]*/);
  } else if (alt == 4) {
    T[1] = -1; // <?sp>
    T[2] = lit('+');
    T[3] = lit('=');
    T[0] = mktuple(phrase /*P_assignment_operator*/, alt /*5*/, /*phrases*/ 3, T /*T[1], T[2], T[3]*/);
  } else if (alt == 5) {
    T[1] = -1; // <?sp>
    T[2] = lit('-');
    T[3] = lit('=');
    T[0] = mktuple(phrase /*P_assignment_operator*/, alt /*6*/, /*phrases*/ 3, T /*T[1], T[2], T[3]*/);
  } else if (alt == 6) {
    T[1] = -1; // <?sp>
    T[2] = lit('<');
    T[3] = lit('<');
    T[4] = lit('=');
    T[0] = mktuple(phrase /*P_assignment_operator*/, alt /*7*/, /*phrases*/ 4, T /*T[1], T[2], T[3], T[4]*/);
  } else if (alt == 7) {
    T[1] = -1; // <?sp>
    T[2] = lit('>');
    T[3] = lit('>');
    T[4] = lit('=');
    T[0] = mktuple(phrase /*P_assignment_operator*/, alt /*8*/, /*phrases*/ 4, T /*T[1], T[2], T[3], T[4]*/);
  } else if (alt == 8) {
    T[1] = -1; // <?sp>
    T[2] = lit('&');
    T[3] = lit('=');
    T[0] = mktuple(phrase /*P_assignment_operator*/, alt /*9*/, /*phrases*/ 3, T /*T[1], T[2], T[3]*/);
  } else if (alt == 9) {
    T[1] = -1; // <?sp>
    T[2] = lit('^');
    T[3] = lit('=');
    T[0] = mktuple(phrase /*P_assignment_operator*/, alt /*10*/, /*phrases*/ 3, T /*T[1], T[2], T[3]*/);
  } else               {
    T[1] = -1; // <?sp>
    T[2] = lit('|');
    T[3] = lit('=');
    T[0] = mktuple(phrase /*P_assignment_operator*/, alt /*11*/, /*phrases*/ 3, T /*T[1], T[2], T[3]*/);
  }
  return T[0];



 
//\\ P<comma-statement> = 
//\\    <assignment-expression> <rest-of-comma-statement>;

case P_comma_statement:
  T[1] = build_ast(A[ap+0], depth+1); // <assignment-expression>
  T[2] = build_ast(A[ap+1], depth+1); // <rest-of-comma-statement>
  return mktuple(phrase /*P_comma_statement*/, alt /*1*/, /*phrases*/ 2, T /*T[1], T[2]*/);


 
//\\ P<rest-of-comma-statement> = 
//\\    <?sp> ',' <assignment-expression> <rest-of-comma-statement>,
//\\   ;

case P_rest_of_comma_statement:
  if (alt == 0)        {
    T[1] = -1; // <?sp>
    T[2] = lit(',');
    T[3] = build_ast(A[ap+1], depth+1); // <assignment-expression>
    T[4] = build_ast(A[ap+2], depth+1); // <rest-of-comma-statement>
    T[0] = mktuple(phrase /*P_rest_of_comma_statement*/, alt /*1*/, /*phrases*/ 4, T /*T[1], T[2], T[3], T[4]*/);
  } else               {
    T[0] = mktuple(phrase /*P_rest_of_comma_statement*/, alt /*2*/, /*phrases*/ 0, T /**/);
  }
  return T[0];



 
//\\ P<expression> = 
//\\    <comma-statement>;

case P_expression:
  T[1] = build_ast(A[ap+0], depth+1); // <comma-statement>
  return mktuple(phrase /*P_expression*/, alt /*1*/, /*phrases*/ 1, T /*T[1]*/);


 
//\\ P<constant-expression> = 
//\\    <conditional-expression>;

case P_constant_expression:
  T[1] = build_ast(A[ap+0], depth+1); // <conditional-expression>
  return mktuple(phrase /*P_constant_expression*/, alt /*1*/, /*phrases*/ 1, T /*T[1]*/);


 
//\\ P<param-list> = 
//\\    <assignment-expression> <rest-of-param-list>,
//\\   ;

case P_param_list:
  if (alt == 0)        {
    T[1] = build_ast(A[ap+0], depth+1); // <assignment-expression>
    T[2] = build_ast(A[ap+1], depth+1); // <rest-of-param-list>
    T[0] = mktuple(phrase /*P_param_list*/, alt /*1*/, /*phrases*/ 2, T /*T[1], T[2]*/);
  } else               {
    T[0] = mktuple(phrase /*P_param_list*/, alt /*2*/, /*phrases*/ 0, T /**/);
  }
  return T[0];



 
//\\ P<rest-of-param-list> = 
//\\    <?sp> ',' <assignment-expression> <rest-of-param-list>,
//\\   ;

case P_rest_of_param_list:
  if (alt == 0)        {
    T[1] = -1; // <?sp>
    T[2] = lit(',');
    T[3] = build_ast(A[ap+1], depth+1); // <assignment-expression>
    T[4] = build_ast(A[ap+2], depth+1); // <rest-of-param-list>
    T[0] = mktuple(phrase /*P_rest_of_param_list*/, alt /*1*/, /*phrases*/ 4, T /*T[1], T[2], T[3], T[4]*/);
  } else               {
    T[0] = mktuple(phrase /*P_rest_of_param_list*/, alt /*2*/, /*phrases*/ 0, T /**/);
  }
  return T[0];



 
//\\ P<constant> = 
//\\    <integer-constant>,
//\\    <character-constant>,
//\\    <floating-constant>,
//\\    <enumeration-constant>;

case P_constant:
  if (alt == 0)        {
    T[1] = integer_constant(ap+0);
    T[0] = mktuple(phrase /*P_constant*/, alt /*1*/, /*phrases*/ 1, T /*T[1]*/);
  } else if (alt == 1) {
    T[1] = character_constant(ap+0);
    T[0] = mktuple(phrase /*P_constant*/, alt /*2*/, /*phrases*/ 1, T /*T[1]*/);
  } else if (alt == 2) {
    T[1] = floating_constant(ap+0);
    T[0] = mktuple(phrase /*P_constant*/, alt /*3*/, /*phrases*/ 1, T /*T[1]*/);
  } else               {
    T[1] = build_ast(A[ap+0], depth+1); // <enumeration-constant>
    T[0] = mktuple(phrase /*P_constant*/, alt /*4*/, /*phrases*/ 1, T /*T[1]*/);
  }
  return T[0];



 
//\\ P<enumeration-constant> = 
//\\    <identifier>;

case P_enumeration_constant:
  T[1] = identifier(ap+0);
  return mktuple(phrase /*P_enumeration_constant*/, alt /*1*/, /*phrases*/ 1, T /*T[1]*/);


 
//\\ P<typedef-name> = 
//\\    <identifier>;

case P_typedef_name:
  T[1] = identifier(ap+0);
  return mktuple(phrase /*P_typedef_name*/, alt /*1*/, /*phrases*/ 1, T /*T[1]*/);


 
//\\ P<opt-labels> = 
//\\    <label> <?sp> ':' <opt-labels>,
//\\    <?sp> "case" <constant-expression> <?sp> ':' <opt-labels>,
//\\    <?sp> "default" <?sp> ':' <opt-labels>,
//\\   ;

case P_opt_labels:
  if (alt == 0)        {
    T[1] = build_ast(A[ap+0], depth+1); // <label>
    T[2] = -1; // <?sp>
    T[3] = lit(':');
    T[4] = build_ast(A[ap+2], depth+1); // <opt-labels>
    T[0] = mktuple(phrase /*P_opt_labels*/, alt /*1*/, /*phrases*/ 4, T /*T[1], T[2], T[3], T[4]*/);
  } else if (alt == 1) {
    T[1] = -1; // <?sp>
    T[2] = kw(/*"case"*/ 10);
    T[3] = build_ast(A[ap+1], depth+1); // <constant-expression>
    T[4] = -1; // <?sp>
    T[5] = lit(':');
    T[6] = build_ast(A[ap+3], depth+1); // <opt-labels>
    T[0] = mktuple(phrase /*P_opt_labels*/, alt /*2*/, /*phrases*/ 6, T /*T[1], T[2], T[3], T[4], T[5], T[6]*/);
  } else if (alt == 2) {
    T[1] = -1; // <?sp>
    T[2] = kw(/*"default"*/ 11);
    T[3] = -1; // <?sp>
    T[4] = lit(':');
    T[5] = build_ast(A[ap+2], depth+1); // <opt-labels>
    T[0] = mktuple(phrase /*P_opt_labels*/, alt /*3*/, /*phrases*/ 5, T /*T[1], T[2], T[3], T[4], T[5]*/);
  } else               {
    T[0] = mktuple(phrase /*P_opt_labels*/, alt /*4*/, /*phrases*/ 0, T /**/);
  }
  return T[0];



 
//\\ P<label> = 
//\\    <identifier>;

case P_label:
  T[1] = identifier(ap+0);
  return mktuple(phrase /*P_label*/, alt /*1*/, /*phrases*/ 1, T /*T[1]*/);


 
//\\ P<SS> = 
//\\    <opt-labels> <?sp> "if" <?sp> '(' <expression> <?sp> ')' <?sp> '{',
//\\    <?sp> '}',
//\\    <opt-labels> <expression> <?sp> ';';

case P_SS:
  if (alt == 0)        {
    T[1] = build_ast(A[ap+0], depth+1); // <opt-labels>
    T[2] = -1; // <?sp>
    T[3] = kw(/*"if"*/ 12);
    T[4] = -1; // <?sp>
    T[5] = lit('(');
    T[6] = build_ast(A[ap+3], depth+1); // <expression>
    T[7] = -1; // <?sp>
    T[8] = lit(')');
    T[9] = -1; // <?sp>
    T[10] = lit('{');
    T[0] = mktuple(phrase /*P_SS*/, alt /*1*/, /*phrases*/ 10, T /*T[1], T[2], T[3], T[4], T[5], T[6], T[7], T[8], T[9], T[10]*/);
  } else if (alt == 1) {
    T[1] = -1; // <?sp>
    T[2] = lit('}');
    T[0] = mktuple(phrase /*P_SS*/, alt /*2*/, /*phrases*/ 2, T /*T[1], T[2]*/);
  } else               {
    T[1] = build_ast(A[ap+0], depth+1); // <opt-labels>
    T[2] = build_ast(A[ap+1], depth+1); // <expression>
    T[3] = -1; // <?sp>
    T[4] = lit(';');
    T[0] = mktuple(phrase /*P_SS*/, alt /*3*/, /*phrases*/ 4, T /*T[1], T[2], T[3], T[4]*/);
  }
  return T[0];


//\\ E
