verbose ()
{
  char vflag.0;
  int nrules.1;
  unsigned int nrules.2;
  unsigned int D.3459;
  void * null_rules.3;
  short int * null_rules.4;
  struct FILE * verbose_file.5;
  int nstates.6;
  short int nunused.7;
  int SRtotal.8;
  int RRtotal.9;
  int nvars.10;
  int ntokens.11;
  int D.3476;
  register int i;
  extern int no_space ();
  extern int print_state ();
  extern int log_unused ();
  extern int log_conflicts ();

  vflag.0 = vflag;
  if (vflag.0 == 0) goto <D.3455>; else goto <D.3456>;
  <D.3455>:
  return;
  <D.3456>:
  nrules.1 = nrules;
  nrules.2 = (unsigned int) nrules.1;
  D.3459 = nrules.2 * 2;
  null_rules.3 = malloc (D.3459);
  null_rules = null_rules.3;
  null_rules.4 = null_rules;
  if (null_rules.4 == 0B) goto <D.3462>; else goto <D.3463>;
  <D.3462>:
  no_space ();
  <D.3463>:
  verbose_file.5 = verbose_file;
  fprintf (verbose_file.5, "\f\n");
  i = 0;
  goto <D.3318>;
  <D.3317>:
  print_state (i);
  i = i + 1;
  <D.3318>:
  nstates.6 = nstates;
  if (i < nstates.6) goto <D.3317>; else goto <D.3319>;
  <D.3319>:
  null_rules.4 = null_rules;
  free (null_rules.4);
  nunused.7 = nunused;
  if (nunused.7 != 0) goto <D.3467>; else goto <D.3468>;
  <D.3467>:
  log_unused ();
  <D.3468>:
  SRtotal.8 = SRtotal;
  if (SRtotal.8 != 0) goto <D.3469>; else goto <D.3472>;
  <D.3472>:
  RRtotal.9 = RRtotal;
  if (RRtotal.9 != 0) goto <D.3469>; else goto <D.3470>;
  <D.3469>:
  log_conflicts ();
  <D.3470>:
  nvars.10 = nvars;
  ntokens.11 = ntokens;
  verbose_file.5 = verbose_file;
  fprintf (verbose_file.5, "\n\n%d terminals, %d nonterminals\n", ntokens.11, nvars.10);
  nstates.6 = nstates;
  nrules.1 = nrules;
  D.3476 = nrules.1 + -2;
  verbose_file.5 = verbose_file;
  fprintf (verbose_file.5, "%d grammar rules, %d states\n", D.3476, nstates.6);
}


fprintf (struct FILE * restrict __stream, const char * restrict __fmt)
{
  int D.3478;

  D.3478 = __fprintf_chk (__stream, 1, __fmt, __builtin_va_arg_pack ());
  return D.3478;
}


log_unused ()
{
  struct FILE * verbose_file.12;
  short int * rules_used.13;
  unsigned int i.14;
  unsigned int D.3483;
  short int * D.3484;
  short int D.3485;
  char * * symbol_name.15;
  short int * rlhs.16;
  short int * D.3490;
  short int D.3491;
  unsigned int D.3492;
  unsigned int D.3493;
  char * * D.3494;
  char * D.3495;
  short int * ritem.17;
  short int * rrhs.18;
  short int * D.3498;
  short int D.3499;
  unsigned int D.3500;
  unsigned int D.3501;
  short int D.3502;
  unsigned int D.3503;
  unsigned int D.3504;
  char * * D.3505;
  char * D.3506;
  int D.3507;
  int nrules.19;
  register int i;
  register short int * p;

  verbose_file.12 = verbose_file;
  fprintf (verbose_file.12, "\n\nRules never reduced:\n");
  i = 3;
  goto <D.3334>;
  <D.3333>:
  rules_used.13 = rules_used;
  i.14 = (unsigned int) i;
  D.3483 = i.14 * 2;
  D.3484 = rules_used.13 + D.3483;
  D.3485 = *D.3484;
  if (D.3485 == 0) goto <D.3486>; else goto <D.3487>;
  <D.3486>:
  symbol_name.15 = symbol_name;
  rlhs.16 = rlhs;
  i.14 = (unsigned int) i;
  D.3483 = i.14 * 2;
  D.3490 = rlhs.16 + D.3483;
  D.3491 = *D.3490;
  D.3492 = (unsigned int) D.3491;
  D.3493 = D.3492 * 4;
  D.3494 = symbol_name.15 + D.3493;
  D.3495 = *D.3494;
  verbose_file.12 = verbose_file;
  fprintf (verbose_file.12, "\t%s :", D.3495);
  ritem.17 = ritem;
  rrhs.18 = rrhs;
  i.14 = (unsigned int) i;
  D.3483 = i.14 * 2;
  D.3498 = rrhs.18 + D.3483;
  D.3499 = *D.3498;
  D.3500 = (unsigned int) D.3499;
  D.3501 = D.3500 * 2;
  p = ritem.17 + D.3501;
  goto <D.3331>;
  <D.3330>:
  symbol_name.15 = symbol_name;
  D.3502 = *p;
  D.3503 = (unsigned int) D.3502;
  D.3504 = D.3503 * 4;
  D.3505 = symbol_name.15 + D.3504;
  D.3506 = *D.3505;
  verbose_file.12 = verbose_file;
  fprintf (verbose_file.12, " %s", D.3506);
  p = p + 2;
  <D.3331>:
  D.3502 = *p;
  if (D.3502 >= 0) goto <D.3330>; else goto <D.3332>;
  <D.3332>:
  D.3507 = i + -2;
  verbose_file.12 = verbose_file;
  fprintf (verbose_file.12, "  (%d)\n", D.3507);
  <D.3487>:
  i = i + 1;
  <D.3334>:
  nrules.19 = nrules;
  if (i < nrules.19) goto <D.3333>; else goto <D.3335>;
  <D.3335>:
}


log_conflicts ()
{
  struct FILE * verbose_file.20;
  short int * SRconflicts.21;
  unsigned int i.22;
  unsigned int D.3514;
  short int * D.3515;
  short int D.3516;
  short int * RRconflicts.23;
  short int * D.3519;
  short int D.3520;
  int D.3526;
  int D.3536;
  int nstates.24;
  register int i;

  verbose_file.20 = verbose_file;
  fprintf (verbose_file.20, "\n\n");
  i = 0;
  goto <D.3340>;
  <D.3339>:
  SRconflicts.21 = SRconflicts;
  i.22 = (unsigned int) i;
  D.3514 = i.22 * 2;
  D.3515 = SRconflicts.21 + D.3514;
  D.3516 = *D.3515;
  if (D.3516 != 0) goto <D.3510>; else goto <D.3517>;
  <D.3517>:
  RRconflicts.23 = RRconflicts;
  i.22 = (unsigned int) i;
  D.3514 = i.22 * 2;
  D.3519 = RRconflicts.23 + D.3514;
  D.3520 = *D.3519;
  if (D.3520 != 0) goto <D.3510>; else goto <D.3511>;
  <D.3510>:
  verbose_file.20 = verbose_file;
  fprintf (verbose_file.20, "State %d contains ", i);
  SRconflicts.21 = SRconflicts;
  i.22 = (unsigned int) i;
  D.3514 = i.22 * 2;
  D.3515 = SRconflicts.21 + D.3514;
  D.3516 = *D.3515;
  if (D.3516 == 1) goto <D.3521>; else goto <D.3522>;
  <D.3521>:
  verbose_file.20 = verbose_file;
  fprintf (verbose_file.20, "1 shift/reduce conflict");
  goto <D.3523>;
  <D.3522>:
  SRconflicts.21 = SRconflicts;
  i.22 = (unsigned int) i;
  D.3514 = i.22 * 2;
  D.3515 = SRconflicts.21 + D.3514;
  D.3516 = *D.3515;
  if (D.3516 > 1) goto <D.3524>; else goto <D.3525>;
  <D.3524>:
  SRconflicts.21 = SRconflicts;
  i.22 = (unsigned int) i;
  D.3514 = i.22 * 2;
  D.3515 = SRconflicts.21 + D.3514;
  D.3516 = *D.3515;
  D.3526 = (int) D.3516;
  verbose_file.20 = verbose_file;
  fprintf (verbose_file.20, "%d shift/reduce conflicts", D.3526);
  <D.3525>:
  <D.3523>:
  SRconflicts.21 = SRconflicts;
  i.22 = (unsigned int) i;
  D.3514 = i.22 * 2;
  D.3515 = SRconflicts.21 + D.3514;
  D.3516 = *D.3515;
  if (D.3516 != 0) goto <D.3527>; else goto <D.3528>;
  <D.3527>:
  RRconflicts.23 = RRconflicts;
  i.22 = (unsigned int) i;
  D.3514 = i.22 * 2;
  D.3519 = RRconflicts.23 + D.3514;
  D.3520 = *D.3519;
  if (D.3520 != 0) goto <D.3529>; else goto <D.3530>;
  <D.3529>:
  verbose_file.20 = verbose_file;
  fprintf (verbose_file.20, ", ");
  <D.3530>:
  <D.3528>:
  RRconflicts.23 = RRconflicts;
  i.22 = (unsigned int) i;
  D.3514 = i.22 * 2;
  D.3519 = RRconflicts.23 + D.3514;
  D.3520 = *D.3519;
  if (D.3520 == 1) goto <D.3531>; else goto <D.3532>;
  <D.3531>:
  verbose_file.20 = verbose_file;
  fprintf (verbose_file.20, "1 reduce/reduce conflict");
  goto <D.3533>;
  <D.3532>:
  RRconflicts.23 = RRconflicts;
  i.22 = (unsigned int) i;
  D.3514 = i.22 * 2;
  D.3519 = RRconflicts.23 + D.3514;
  D.3520 = *D.3519;
  if (D.3520 > 1) goto <D.3534>; else goto <D.3535>;
  <D.3534>:
  RRconflicts.23 = RRconflicts;
  i.22 = (unsigned int) i;
  D.3514 = i.22 * 2;
  D.3519 = RRconflicts.23 + D.3514;
  D.3520 = *D.3519;
  D.3536 = (int) D.3520;
  verbose_file.20 = verbose_file;
  fprintf (verbose_file.20, "%d reduce/reduce conflicts", D.3536);
  <D.3535>:
  <D.3533>:
  verbose_file.20 = verbose_file;
  fprintf (verbose_file.20, ".\n");
  <D.3511>:
  i = i + 1;
  <D.3340>:
  nstates.24 = nstates;
  if (i < nstates.24) goto <D.3339>; else goto <D.3341>;
  <D.3341>:
}


print_state (int state)
{
  struct FILE * verbose_file.25;
  short int * SRconflicts.26;
  unsigned int state.27;
  unsigned int D.3545;
  short int * D.3546;
  short int D.3547;
  short int * RRconflicts.28;
  short int * D.3550;
  short int D.3551;
  extern int print_conflicts ();
  extern int print_core ();
  extern int print_nulls ();
  extern int print_actions ();

  if (state != 0) goto <D.3538>; else goto <D.3539>;
  <D.3538>:
  verbose_file.25 = verbose_file;
  fprintf (verbose_file.25, "\n\n");
  <D.3539>:
  SRconflicts.26 = SRconflicts;
  state.27 = (unsigned int) state;
  D.3545 = state.27 * 2;
  D.3546 = SRconflicts.26 + D.3545;
  D.3547 = *D.3546;
  if (D.3547 != 0) goto <D.3541>; else goto <D.3548>;
  <D.3548>:
  RRconflicts.28 = RRconflicts;
  state.27 = (unsigned int) state;
  D.3545 = state.27 * 2;
  D.3550 = RRconflicts.28 + D.3545;
  D.3551 = *D.3550;
  if (D.3551 != 0) goto <D.3541>; else goto <D.3542>;
  <D.3541>:
  print_conflicts (state);
  <D.3542>:
  verbose_file.25 = verbose_file;
  fprintf (verbose_file.25, "state %d\n", state);
  print_core (state);
  print_nulls (state);
  print_actions (state);
}


print_conflicts (int state)
{
  struct action * * parser.29;
  unsigned int state.30;
  unsigned int D.3554;
  struct action * * D.3555;
  char D.3556;
  short int D.3559;
  int D.3560;
  short int D.3563;
  char D.3564;
  short int final_state.31;
  int D.3574;
  int D.3577;
  int D.3578;
  struct FILE * verbose_file.32;
  char * * symbol_name.33;
  unsigned int symbol.34;
  unsigned int D.3584;
  char * * D.3585;
  char * D.3586;
  int D.3588;
  register int symbol;
  register int act;
  register int number;
  register struct action * p;

  symbol = -1;
  parser.29 = parser;
  state.30 = (unsigned int) state;
  D.3554 = state.30 * 4;
  D.3555 = parser.29 + D.3554;
  p = *D.3555;
  goto <D.3362>;
  <D.3361>:
  D.3556 = p->suppressed;
  if (D.3556 == 2) goto <D.3557>; else goto <D.3558>;
  <D.3557>:
  // predicted unlikely by continue predictor.
  goto <D.3360>;
  <D.3558>:
  D.3559 = p->symbol;
  D.3560 = (int) D.3559;
  if (D.3560 != symbol) goto <D.3561>; else goto <D.3562>;
  <D.3561>:
  D.3559 = p->symbol;
  symbol = (int) D.3559;
  D.3563 = p->number;
  number = (int) D.3563;
  D.3564 = p->action_code;
  if (D.3564 == 1) goto <D.3565>; else goto <D.3566>;
  <D.3565>:
  act = 1;
  goto <D.3567>;
  <D.3566>:
  act = 2;
  <D.3567>:
  goto <D.3568>;
  <D.3562>:
  D.3556 = p->suppressed;
  if (D.3556 == 1) goto <D.3569>; else goto <D.3570>;
  <D.3569>:
  final_state.31 = final_state;
  D.3574 = (int) final_state.31;
  if (D.3574 == state) goto <D.3575>; else goto <D.3571>;
  <D.3575>:
  if (symbol == 0) goto <D.3576>; else goto <D.3571>;
  <D.3576>:
  D.3563 = p->number;
  D.3577 = (int) D.3563;
  D.3578 = D.3577 + -2;
  verbose_file.32 = verbose_file;
  fprintf (verbose_file.32, "%d: shift/reduce conflict (accept, reduce %d) on $end\n", state, D.3578);
  goto <D.3572>;
  <D.3571>:
  if (act == 1) goto <D.3580>; else goto <D.3581>;
  <D.3580>:
  symbol_name.33 = symbol_name;
  symbol.34 = (unsigned int) symbol;
  D.3584 = symbol.34 * 4;
  D.3585 = symbol_name.33 + D.3584;
  D.3586 = *D.3585;
  D.3563 = p->number;
  D.3577 = (int) D.3563;
  D.3578 = D.3577 + -2;
  verbose_file.32 = verbose_file;
  fprintf (verbose_file.32, "%d: shift/reduce conflict (shift %d, reduce %d) on %s\n", state, number, D.3578, D.3586);
  goto <D.3587>;
  <D.3581>:
  symbol_name.33 = symbol_name;
  symbol.34 = (unsigned int) symbol;
  D.3584 = symbol.34 * 4;
  D.3585 = symbol_name.33 + D.3584;
  D.3586 = *D.3585;
  D.3563 = p->number;
  D.3577 = (int) D.3563;
  D.3578 = D.3577 + -2;
  D.3588 = number + -2;
  verbose_file.32 = verbose_file;
  fprintf (verbose_file.32, "%d: reduce/reduce conflict (reduce %d, reduce %d) on %s\n", state, D.3588, D.3578, D.3586);
  <D.3587>:
  <D.3572>:
  <D.3570>:
  <D.3568>:
  <D.3360>:
  p = p->next;
  <D.3362>:
  if (p != 0B) goto <D.3361>; else goto <D.3363>;
  <D.3363>:
}


print_core (int state)
{
  struct core * * state_table.35;
  unsigned int state.36;
  unsigned int D.3591;
  struct core * * D.3592;
  short int D.3593;
  short int * ritem.37;
  short int D.3595;
  unsigned int D.3596;
  unsigned int D.3597;
  short int D.3598;
  int D.3599;
  char * * symbol_name.38;
  short int * rlhs.39;
  unsigned int rule.40;
  unsigned int D.3603;
  short int * D.3604;
  short int D.3605;
  unsigned int D.3606;
  unsigned int D.3607;
  char * * D.3608;
  char * D.3609;
  struct FILE * verbose_file.41;
  short int * rrhs.42;
  short int * D.3612;
  short int D.3613;
  unsigned int D.3614;
  unsigned int D.3615;
  unsigned int D.3616;
  unsigned int D.3617;
  char * * D.3618;
  char * D.3619;
  int D.3620;
  register int i;
  register int k;
  register int rule;
  register struct core * statep;
  register short int * sp;
  register short int * sp1;

  state_table.35 = state_table;
  state.36 = (unsigned int) state;
  D.3591 = state.36 * 4;
  D.3592 = state_table.35 + D.3591;
  statep = *D.3592;
  D.3593 = statep->nitems;
  k = (int) D.3593;
  i = 0;
  goto <D.3383>;
  <D.3382>:
  ritem.37 = ritem;
  D.3595 = statep->items[i];
  D.3596 = (unsigned int) D.3595;
  D.3597 = D.3596 * 2;
  sp = ritem.37 + D.3597;
  sp1 = sp;
  goto <D.3374>;
  <D.3373>:
  sp = sp + 2;
  <D.3374>:
  D.3598 = *sp;
  if (D.3598 >= 0) goto <D.3373>; else goto <D.3375>;
  <D.3375>:
  D.3598 = *sp;
  D.3599 = (int) D.3598;
  rule = -D.3599;
  symbol_name.38 = symbol_name;
  rlhs.39 = rlhs;
  rule.40 = (unsigned int) rule;
  D.3603 = rule.40 * 2;
  D.3604 = rlhs.39 + D.3603;
  D.3605 = *D.3604;
  D.3606 = (unsigned int) D.3605;
  D.3607 = D.3606 * 4;
  D.3608 = symbol_name.38 + D.3607;
  D.3609 = *D.3608;
  verbose_file.41 = verbose_file;
  fprintf (verbose_file.41, "\t%s : ", D.3609);
  ritem.37 = ritem;
  rrhs.42 = rrhs;
  rule.40 = (unsigned int) rule;
  D.3603 = rule.40 * 2;
  D.3612 = rrhs.42 + D.3603;
  D.3613 = *D.3612;
  D.3614 = (unsigned int) D.3613;
  D.3615 = D.3614 * 2;
  sp = ritem.37 + D.3615;
  goto <D.3377>;
  <D.3376>:
  symbol_name.38 = symbol_name;
  D.3598 = *sp;
  D.3616 = (unsigned int) D.3598;
  D.3617 = D.3616 * 4;
  D.3618 = symbol_name.38 + D.3617;
  D.3619 = *D.3618;
  verbose_file.41 = verbose_file;
  fprintf (verbose_file.41, "%s ", D.3619);
  sp = sp + 2;
  <D.3377>:
  if (sp < sp1) goto <D.3376>; else goto <D.3378>;
  <D.3378>:
  verbose_file.41 = verbose_file;
  _IO_putc (46, verbose_file.41);
  goto <D.3380>;
  <D.3379>:
  symbol_name.38 = symbol_name;
  D.3598 = *sp;
  D.3616 = (unsigned int) D.3598;
  D.3617 = D.3616 * 4;
  D.3618 = symbol_name.38 + D.3617;
  D.3619 = *D.3618;
  verbose_file.41 = verbose_file;
  fprintf (verbose_file.41, " %s", D.3619);
  sp = sp + 2;
  <D.3380>:
  D.3598 = *sp;
  if (D.3598 >= 0) goto <D.3379>; else goto <D.3381>;
  <D.3381>:
  D.3598 = *sp;
  D.3599 = (int) D.3598;
  D.3620 = -2 - D.3599;
  verbose_file.41 = verbose_file;
  fprintf (verbose_file.41, "  (%d)\n", D.3620);
  i = i + 1;
  <D.3383>:
  if (i < k) goto <D.3382>; else goto <D.3384>;
  <D.3384>:
}


print_nulls (int state)
{
  struct action * * parser.43;
  unsigned int state.44;
  unsigned int D.3623;
  struct action * * D.3624;
  char D.3625;
  char D.3628;
  unsigned char D.3629;
  short int D.3632;
  short int * rrhs.45;
  unsigned int i.46;
  unsigned int D.3635;
  short int * D.3636;
  short int D.3637;
  int D.3638;
  int D.3639;
  sizetype i.47;
  sizetype D.3641;
  sizetype D.3642;
  short int * D.3643;
  short int D.3644;
  int D.3645;
  short int * null_rules.48;
  unsigned int j.49;
  unsigned int D.3651;
  short int * D.3652;
  short int D.3653;
  int D.3654;
  short int D.3657;
  unsigned int k.50;
  unsigned int D.3662;
  short int * D.3663;
  sizetype k.51;
  sizetype D.3665;
  sizetype D.3666;
  short int * D.3667;
  short int D.3668;
  short int * D.3669;
  short int D.3670;
  int D.3671;
  char * * symbol_name.52;
  short int * rlhs.53;
  short int * D.3674;
  short int D.3675;
  unsigned int D.3676;
  unsigned int D.3677;
  char * * D.3678;
  char * D.3679;
  struct FILE * verbose_file.54;
  register struct action * p;
  register int i;
  register int j;
  register int k;
  register int nnulls;

  nnulls = 0;
  parser.43 = parser;
  state.44 = (unsigned int) state;
  D.3623 = state.44 * 4;
  D.3624 = parser.43 + D.3623;
  p = *D.3624;
  goto <D.3401>;
  <D.3400>:
  D.3625 = p->action_code;
  if (D.3625 == 2) goto <D.3626>; else goto <D.3627>;
  <D.3626>:
  D.3628 = p->suppressed;
  D.3629 = (unsigned char) D.3628;
  if (D.3629 <= 1) goto <D.3630>; else goto <D.3631>;
  <D.3630>:
  D.3632 = p->number;
  i = (int) D.3632;
  rrhs.45 = rrhs;
  i.46 = (unsigned int) i;
  D.3635 = i.46 * 2;
  D.3636 = rrhs.45 + D.3635;
  D.3637 = *D.3636;
  D.3638 = (int) D.3637;
  D.3639 = D.3638 + 1;
  rrhs.45 = rrhs;
  i.47 = (sizetype) i;
  D.3641 = i.47 + 1;
  D.3642 = D.3641 * 2;
  D.3643 = rrhs.45 + D.3642;
  D.3644 = *D.3643;
  D.3645 = (int) D.3644;
  if (D.3639 == D.3645) goto <D.3646>; else goto <D.3647>;
  <D.3646>:
  j = 0;
  goto <D.3395>;
  <D.3394>:
  // predicted unlikely by continue predictor.
  goto <D.3393>;
  <D.3393>:
  j = j + 1;
  <D.3395>:
  if (j < nnulls) goto <D.3648>; else goto <D.3396>;
  <D.3648>:
  null_rules.48 = null_rules;
  j.49 = (unsigned int) j;
  D.3651 = j.49 * 2;
  D.3652 = null_rules.48 + D.3651;
  D.3653 = *D.3652;
  D.3654 = (int) D.3653;
  if (D.3654 < i) goto <D.3394>; else goto <D.3396>;
  <D.3396>:
  if (j == nnulls) goto <D.3655>; else goto <D.3656>;
  <D.3655>:
  nnulls = nnulls + 1;
  null_rules.48 = null_rules;
  j.49 = (unsigned int) j;
  D.3651 = j.49 * 2;
  D.3652 = null_rules.48 + D.3651;
  D.3657 = (short int) i;
  *D.3652 = D.3657;
  goto <D.3658>;
  <D.3656>:
  null_rules.48 = null_rules;
  j.49 = (unsigned int) j;
  D.3651 = j.49 * 2;
  D.3652 = null_rules.48 + D.3651;
  D.3653 = *D.3652;
  D.3654 = (int) D.3653;
  if (D.3654 != i) goto <D.3659>; else goto <D.3660>;
  <D.3659>:
  nnulls = nnulls + 1;
  k = nnulls + -1;
  goto <D.3398>;
  <D.3397>:
  null_rules.48 = null_rules;
  k.50 = (unsigned int) k;
  D.3662 = k.50 * 2;
  D.3663 = null_rules.48 + D.3662;
  null_rules.48 = null_rules;
  k.51 = (sizetype) k;
  D.3665 = k.51 + 2147483647;
  D.3666 = D.3665 * 2;
  D.3667 = null_rules.48 + D.3666;
  D.3668 = *D.3667;
  *D.3663 = D.3668;
  k = k + -1;
  <D.3398>:
  if (k > j) goto <D.3397>; else goto <D.3399>;
  <D.3399>:
  null_rules.48 = null_rules;
  j.49 = (unsigned int) j;
  D.3651 = j.49 * 2;
  D.3652 = null_rules.48 + D.3651;
  D.3657 = (short int) i;
  *D.3652 = D.3657;
  <D.3660>:
  <D.3658>:
  <D.3647>:
  <D.3631>:
  <D.3627>:
  p = p->next;
  <D.3401>:
  if (p != 0B) goto <D.3400>; else goto <D.3402>;
  <D.3402>:
  i = 0;
  goto <D.3404>;
  <D.3403>:
  null_rules.48 = null_rules;
  i.46 = (unsigned int) i;
  D.3635 = i.46 * 2;
  D.3669 = null_rules.48 + D.3635;
  D.3670 = *D.3669;
  j = (int) D.3670;
  D.3671 = j + -2;
  symbol_name.52 = symbol_name;
  rlhs.53 = rlhs;
  j.49 = (unsigned int) j;
  D.3651 = j.49 * 2;
  D.3674 = rlhs.53 + D.3651;
  D.3675 = *D.3674;
  D.3676 = (unsigned int) D.3675;
  D.3677 = D.3676 * 4;
  D.3678 = symbol_name.52 + D.3677;
  D.3679 = *D.3678;
  verbose_file.54 = verbose_file;
  fprintf (verbose_file.54, "\t%s : .  (%d)\n", D.3679, D.3671);
  i = i + 1;
  <D.3404>:
  if (i < nnulls) goto <D.3403>; else goto <D.3405>;
  <D.3405>:
  verbose_file.54 = verbose_file;
  fprintf (verbose_file.54, "\n");
}


print_actions (int stateno)
{
  short int final_state.55;
  int D.3682;
  struct FILE * verbose_file.56;
  struct action * * parser.57;
  unsigned int stateno.58;
  unsigned int D.3688;
  struct action * * D.3689;
  short int * defred.59;
  unsigned int D.3693;
  short int * D.3694;
  short int D.3695;
  int D.3696;
  struct shifts * * shift_table.60;
  struct shifts * * D.3698;
  short int D.3701;
  short int * accessing_symbol.61;
  int D.3705;
  int D.3706;
  short int D.3707;
  unsigned int D.3708;
  unsigned int D.3709;
  short int * D.3710;
  short int D.3711;
  int start_symbol.62;
  register struct action * p;
  register struct shifts * sp;
  register int as;

  final_state.55 = final_state;
  D.3682 = (int) final_state.55;
  if (D.3682 == stateno) goto <D.3683>; else goto <D.3684>;
  <D.3683>:
  verbose_file.56 = verbose_file;
  fprintf (verbose_file.56, "\t$end  accept\n");
  <D.3684>:
  parser.57 = parser;
  stateno.58 = (unsigned int) stateno;
  D.3688 = stateno.58 * 4;
  D.3689 = parser.57 + D.3688;
  p = *D.3689;
  if (p != 0B) goto <D.3690>; else goto <D.3691>;
  <D.3690>:
  {
    extern int print_shifts ();
    extern int print_reductions ();

    print_shifts (p);
    defred.59 = defred;
    stateno.58 = (unsigned int) stateno;
    D.3693 = stateno.58 * 2;
    D.3694 = defred.59 + D.3693;
    D.3695 = *D.3694;
    D.3696 = (int) D.3695;
    print_reductions (p, D.3696);
  }
  <D.3691>:
  shift_table.60 = shift_table;
  stateno.58 = (unsigned int) stateno;
  D.3688 = stateno.58 * 4;
  D.3698 = shift_table.60 + D.3688;
  sp = *D.3698;
  if (sp != 0B) goto <D.3699>; else goto <D.3700>;
  <D.3699>:
  D.3701 = sp->nshifts;
  if (D.3701 > 0) goto <D.3702>; else goto <D.3703>;
  <D.3702>:
  {
    extern int print_gotos ();

    accessing_symbol.61 = accessing_symbol;
    D.3701 = sp->nshifts;
    D.3705 = (int) D.3701;
    D.3706 = D.3705 + -1;
    D.3707 = sp->shift[D.3706];
    D.3708 = (unsigned int) D.3707;
    D.3709 = D.3708 * 2;
    D.3710 = accessing_symbol.61 + D.3709;
    D.3711 = *D.3710;
    as = (int) D.3711;
    start_symbol.62 = start_symbol;
    if (as >= start_symbol.62) goto <D.3713>; else goto <D.3714>;
    <D.3713>:
    print_gotos (stateno);
    <D.3714>:
  }
  <D.3703>:
  <D.3700>:
}


print_shifts (struct action * p)
{
  char D.3715;
  char D.3718;
  char D.3723;
  char D.3726;
  short int D.3729;
  int D.3730;
  char * * symbol_name.63;
  short int D.3732;
  unsigned int D.3733;
  unsigned int D.3734;
  char * * D.3735;
  char * D.3736;
  struct FILE * verbose_file.64;
  register int count;
  register struct action * q;

  count = 0;
  q = p;
  goto <D.3424>;
  <D.3423>:
  D.3715 = q->suppressed;
  if (D.3715 <= 1) goto <D.3716>; else goto <D.3717>;
  <D.3716>:
  D.3718 = q->action_code;
  if (D.3718 == 1) goto <D.3719>; else goto <D.3720>;
  <D.3719>:
  count = count + 1;
  <D.3720>:
  <D.3717>:
  q = q->next;
  <D.3424>:
  if (q != 0B) goto <D.3423>; else goto <D.3425>;
  <D.3425>:
  if (count > 0) goto <D.3721>; else goto <D.3722>;
  <D.3721>:
  goto <D.3427>;
  <D.3426>:
  D.3723 = p->action_code;
  if (D.3723 == 1) goto <D.3724>; else goto <D.3725>;
  <D.3724>:
  D.3726 = p->suppressed;
  if (D.3726 == 0) goto <D.3727>; else goto <D.3728>;
  <D.3727>:
  D.3729 = p->number;
  D.3730 = (int) D.3729;
  symbol_name.63 = symbol_name;
  D.3732 = p->symbol;
  D.3733 = (unsigned int) D.3732;
  D.3734 = D.3733 * 4;
  D.3735 = symbol_name.63 + D.3734;
  D.3736 = *D.3735;
  verbose_file.64 = verbose_file;
  fprintf (verbose_file.64, "\t%s  shift %d\n", D.3736, D.3730);
  <D.3728>:
  <D.3725>:
  p = p->next;
  <D.3427>:
  if (p != 0B) goto <D.3426>; else goto <D.3428>;
  <D.3428>:
  <D.3722>:
}


print_reductions (struct action * p, int defred)
{
  char D.3738;
  char D.3741;
  struct FILE * verbose_file.65;
  char D.3748;
  short int D.3751;
  int D.3752;
  char D.3755;
  char * * symbol_name.66;
  short int D.3759;
  unsigned int D.3760;
  unsigned int D.3761;
  char * * D.3762;
  char * D.3763;
  int D.3766;
  register int k;
  register int anyreds;
  register struct action * q;

  anyreds = 0;
  q = p;
  goto <D.3438>;
  <D.3437>:
  D.3738 = q->action_code;
  if (D.3738 == 2) goto <D.3739>; else goto <D.3740>;
  <D.3739>:
  D.3741 = q->suppressed;
  if (D.3741 <= 1) goto <D.3742>; else goto <D.3743>;
  <D.3742>:
  anyreds = 1;
  goto <D.3436>;
  <D.3743>:
  <D.3740>:
  q = q->next;
  <D.3438>:
  if (q != 0B) goto <D.3437>; else goto <D.3436>;
  <D.3436>:
  if (anyreds == 0) goto <D.3744>; else goto <D.3745>;
  <D.3744>:
  verbose_file.65 = verbose_file;
  fprintf (verbose_file.65, "\t.  error\n");
  goto <D.3747>;
  <D.3745>:
  goto <D.3440>;
  <D.3439>:
  D.3748 = p->action_code;
  if (D.3748 == 2) goto <D.3749>; else goto <D.3750>;
  <D.3749>:
  D.3751 = p->number;
  D.3752 = (int) D.3751;
  if (D.3752 != defred) goto <D.3753>; else goto <D.3754>;
  <D.3753>:
  D.3751 = p->number;
  D.3752 = (int) D.3751;
  k = D.3752 + -2;
  D.3755 = p->suppressed;
  if (D.3755 == 0) goto <D.3756>; else goto <D.3757>;
  <D.3756>:
  symbol_name.66 = symbol_name;
  D.3759 = p->symbol;
  D.3760 = (unsigned int) D.3759;
  D.3761 = D.3760 * 4;
  D.3762 = symbol_name.66 + D.3761;
  D.3763 = *D.3762;
  verbose_file.65 = verbose_file;
  fprintf (verbose_file.65, "\t%s  reduce %d\n", D.3763, k);
  <D.3757>:
  <D.3754>:
  <D.3750>:
  p = p->next;
  <D.3440>:
  if (p != 0B) goto <D.3439>; else goto <D.3441>;
  <D.3441>:
  if (defred > 0) goto <D.3764>; else goto <D.3765>;
  <D.3764>:
  D.3766 = defred + -2;
  verbose_file.65 = verbose_file;
  fprintf (verbose_file.65, "\t.  reduce %d\n", D.3766);
  <D.3765>:
  <D.3747>:
}


print_gotos (int stateno)
{
  struct FILE * verbose_file.67;
  struct shifts * * shift_table.68;
  unsigned int stateno.69;
  unsigned int D.3770;
  struct shifts * * D.3771;
  unsigned int i.70;
  unsigned int D.3773;
  short int * D.3774;
  short int D.3775;
  short int * accessing_symbol.71;
  unsigned int k.72;
  unsigned int D.3778;
  short int * D.3779;
  short int D.3780;
  int start_symbol.73;
  char * * symbol_name.74;
  unsigned int as.75;
  unsigned int D.3786;
  char * * D.3787;
  char * D.3788;
  short int D.3789;
  int D.3790;
  register int i;
  register int k;
  register int as;
  register short int * to_state;
  register struct shifts * sp;

  verbose_file.67 = verbose_file;
  _IO_putc (10, verbose_file.67);
  shift_table.68 = shift_table;
  stateno.69 = (unsigned int) stateno;
  D.3770 = stateno.69 * 4;
  D.3771 = shift_table.68 + D.3770;
  sp = *D.3771;
  to_state = &sp->shift;
  i = 0;
  goto <D.3451>;
  <D.3450>:
  i.70 = (unsigned int) i;
  D.3773 = i.70 * 2;
  D.3774 = to_state + D.3773;
  D.3775 = *D.3774;
  k = (int) D.3775;
  accessing_symbol.71 = accessing_symbol;
  k.72 = (unsigned int) k;
  D.3778 = k.72 * 2;
  D.3779 = accessing_symbol.71 + D.3778;
  D.3780 = *D.3779;
  as = (int) D.3780;
  start_symbol.73 = start_symbol;
  if (as >= start_symbol.73) goto <D.3782>; else goto <D.3783>;
  <D.3782>:
  symbol_name.74 = symbol_name;
  as.75 = (unsigned int) as;
  D.3786 = as.75 * 4;
  D.3787 = symbol_name.74 + D.3786;
  D.3788 = *D.3787;
  verbose_file.67 = verbose_file;
  fprintf (verbose_file.67, "\t%s  goto %d\n", D.3788, k);
  <D.3783>:
  i = i + 1;
  <D.3451>:
  D.3789 = sp->nshifts;
  D.3790 = (int) D.3789;
  if (D.3790 > i) goto <D.3450>; else goto <D.3452>;
  <D.3452>:
}