make_parser ()
{
  int nstates.0;
  unsigned int nstates.1;
  unsigned int D.3465;
  char * parser.2;
  struct action * * parser.3;
  unsigned int i.4;
  unsigned int D.3469;
  struct action * * D.3470;
  struct action * D.3471;
  int SRtotal.5;
  int RRtotal.6;
  int D.3474;
  register int i;
  extern int find_final_state ();
  extern int remove_conflicts ();
  extern int unused_rules ();
  extern int total_conflicts ();
  extern int defreds ();

  nstates.0 = nstates;
  nstates.1 = (unsigned int) nstates.0;
  D.3465 = nstates.1 * 4;
  parser.2 = allocate (D.3465);
  parser = parser.2;
  i = 0;
  goto <D.3330>;
  <D.3329>:
  parser.3 = parser;
  i.4 = (unsigned int) i;
  D.3469 = i.4 * 4;
  D.3470 = parser.3 + D.3469;
  D.3471 = parse_actions (i);
  *D.3470 = D.3471;
  i = i + 1;
  <D.3330>:
  nstates.0 = nstates;
  if (i < nstates.0) goto <D.3329>; else goto <D.3331>;
  <D.3331>:
  find_final_state ();
  remove_conflicts ();
  unused_rules ();
  SRtotal.5 = SRtotal;
  RRtotal.6 = RRtotal;
  D.3474 = SRtotal.5 + RRtotal.6;
  if (D.3474 > 0) goto <D.3475>; else goto <D.3476>;
  <D.3475>:
  total_conflicts ();
  <D.3476>:
  defreds ();
}


parse_actions (int stateno)
{
  struct action * D.3477;
  register struct action * actions;

  actions = get_shifts (stateno);
  actions = add_reductions (stateno, actions);
  D.3477 = actions;
  return D.3477;
}


get_shifts (int stateno)
{
  struct shifts * * shift_table.7;
  unsigned int stateno.8;
  unsigned int D.3481;
  struct shifts * * D.3482;
  short int D.3485;
  int D.3486;
  unsigned int i.9;
  unsigned int D.3488;
  short int * D.3489;
  short int D.3490;
  short int * accessing_symbol.10;
  unsigned int k.11;
  unsigned int D.3493;
  short int * D.3494;
  short int D.3495;
  int start_symbol.12;
  short int D.3499;
  short int D.3500;
  short int * symbol_prec.13;
  unsigned int symbol.14;
  unsigned int D.3503;
  short int * D.3504;
  short int D.3505;
  char * symbol_assoc.15;
  sizetype symbol.16;
  char * D.3508;
  char D.3509;
  struct action * D.3510;
  register struct action * actions;
  register struct action * temp;
  register struct shifts * sp;
  register short int * to_state;
  register int i;
  register int k;
  register int symbol;

  actions = 0B;
  shift_table.7 = shift_table;
  stateno.8 = (unsigned int) stateno;
  D.3481 = stateno.8 * 4;
  D.3482 = shift_table.7 + D.3481;
  sp = *D.3482;
  if (sp != 0B) goto <D.3483>; else goto <D.3484>;
  <D.3483>:
  to_state = &sp->shift;
  D.3485 = sp->nshifts;
  D.3486 = (int) D.3485;
  i = D.3486 + -1;
  goto <D.3357>;
  <D.3356>:
  i.9 = (unsigned int) i;
  D.3488 = i.9 * 2;
  D.3489 = to_state + D.3488;
  D.3490 = *D.3489;
  k = (int) D.3490;
  accessing_symbol.10 = accessing_symbol;
  k.11 = (unsigned int) k;
  D.3493 = k.11 * 2;
  D.3494 = accessing_symbol.10 + D.3493;
  D.3495 = *D.3494;
  symbol = (int) D.3495;
  start_symbol.12 = start_symbol;
  if (symbol < start_symbol.12) goto <D.3497>; else goto <D.3498>;
  <D.3497>:
  temp = allocate (16);
  temp->next = actions;
  D.3499 = (short int) symbol;
  temp->symbol = D.3499;
  D.3500 = (short int) k;
  temp->number = D.3500;
  symbol_prec.13 = symbol_prec;
  symbol.14 = (unsigned int) symbol;
  D.3503 = symbol.14 * 2;
  D.3504 = symbol_prec.13 + D.3503;
  D.3505 = *D.3504;
  temp->prec = D.3505;
  temp->action_code = 1;
  symbol_assoc.15 = symbol_assoc;
  symbol.16 = (sizetype) symbol;
  D.3508 = symbol_assoc.15 + symbol.16;
  D.3509 = *D.3508;
  temp->assoc = D.3509;
  actions = temp;
  <D.3498>:
  i = i + -1;
  <D.3357>:
  if (i >= 0) goto <D.3356>; else goto <D.3358>;
  <D.3358>:
  <D.3484>:
  D.3510 = actions;
  return D.3510;
}


add_reductions (int stateno, struct action * actions)
{
  int ntokens.17;
  int D.3513;
  short int * lookaheads.18;
  unsigned int stateno.19;
  unsigned int D.3516;
  short int * D.3517;
  short int D.3518;
  sizetype stateno.20;
  sizetype D.3520;
  sizetype D.3521;
  short int * D.3522;
  short int D.3523;
  short int * LAruleno.21;
  unsigned int i.22;
  unsigned int D.3526;
  short int * D.3527;
  short int D.3528;
  unsigned int * LA.23;
  int D.3530;
  unsigned int D.3531;
  unsigned int D.3532;
  int D.3533;
  unsigned int D.3534;
  unsigned int D.3535;
  unsigned int * D.3536;
  unsigned int D.3537;
  int D.3538;
  unsigned int D.3539;
  unsigned int D.3540;
  struct action * D.3543;
  register int i;
  register int j;
  register int m;
  register int n;
  register int ruleno;
  register int tokensetsize;
  register unsigned int * rowp;

  ntokens.17 = ntokens;
  D.3513 = ntokens.17 + 31;
  tokensetsize = D.3513 / 32;
  lookaheads.18 = lookaheads;
  stateno.19 = (unsigned int) stateno;
  D.3516 = stateno.19 * 2;
  D.3517 = lookaheads.18 + D.3516;
  D.3518 = *D.3517;
  m = (int) D.3518;
  lookaheads.18 = lookaheads;
  stateno.20 = (sizetype) stateno;
  D.3520 = stateno.20 + 1;
  D.3521 = D.3520 * 2;
  D.3522 = lookaheads.18 + D.3521;
  D.3523 = *D.3522;
  n = (int) D.3523;
  i = m;
  goto <D.3374>;
  <D.3373>:
  LAruleno.21 = LAruleno;
  i.22 = (unsigned int) i;
  D.3526 = i.22 * 2;
  D.3527 = LAruleno.21 + D.3526;
  D.3528 = *D.3527;
  ruleno = (int) D.3528;
  LA.23 = LA;
  D.3530 = i * tokensetsize;
  D.3531 = (unsigned int) D.3530;
  D.3532 = D.3531 * 4;
  rowp = LA.23 + D.3532;
  ntokens.17 = ntokens;
  j = ntokens.17 + -1;
  goto <D.3371>;
  <D.3370>:
  D.3533 = j >> 5;
  D.3534 = (unsigned int) D.3533;
  D.3535 = D.3534 * 4;
  D.3536 = rowp + D.3535;
  D.3537 = *D.3536;
  D.3538 = j & 31;
  D.3539 = D.3537 >> D.3538;
  D.3540 = D.3539 & 1;
  if (D.3540 != 0) goto <D.3541>; else goto <D.3542>;
  <D.3541>:
  actions = add_reduce (actions, ruleno, j);
  <D.3542>:
  j = j + -1;
  <D.3371>:
  if (j >= 0) goto <D.3370>; else goto <D.3372>;
  <D.3372>:
  i = i + 1;
  <D.3374>:
  if (i < n) goto <D.3373>; else goto <D.3375>;
  <D.3375>:
  D.3543 = actions;
  return D.3543;
}


add_reduce (struct action * actions, int ruleno, int symbol)
{
  short int D.3546;
  int D.3547;
  char D.3550;
  short int D.3554;
  int D.3555;
  short int D.3556;
  short int D.3557;
  short int * rprec.24;
  unsigned int ruleno.25;
  unsigned int D.3560;
  short int * D.3561;
  short int D.3562;
  char * rassoc.26;
  sizetype ruleno.27;
  char * D.3565;
  char D.3566;
  struct action * D.3570;
  register struct action * temp;
  register struct action * prev;
  register struct action * next;

  prev = 0B;
  next = actions;
  goto <D.3385>;
  <D.3384>:
  prev = next;
  next = next->next;
  <D.3385>:
  if (next != 0B) goto <D.3545>; else goto <D.3386>;
  <D.3545>:
  D.3546 = next->symbol;
  D.3547 = (int) D.3546;
  if (D.3547 < symbol) goto <D.3384>; else goto <D.3386>;
  <D.3386>:
  goto <D.3388>;
  <D.3387>:
  prev = next;
  next = next->next;
  <D.3388>:
  if (next != 0B) goto <D.3548>; else goto <D.3389>;
  <D.3548>:
  D.3546 = next->symbol;
  D.3547 = (int) D.3546;
  if (D.3547 == symbol) goto <D.3549>; else goto <D.3389>;
  <D.3549>:
  D.3550 = next->action_code;
  if (D.3550 == 1) goto <D.3387>; else goto <D.3389>;
  <D.3389>:
  goto <D.3391>;
  <D.3390>:
  prev = next;
  next = next->next;
  <D.3391>:
  if (next != 0B) goto <D.3551>; else goto <D.3392>;
  <D.3551>:
  D.3546 = next->symbol;
  D.3547 = (int) D.3546;
  if (D.3547 == symbol) goto <D.3552>; else goto <D.3392>;
  <D.3552>:
  D.3550 = next->action_code;
  if (D.3550 == 2) goto <D.3553>; else goto <D.3392>;
  <D.3553>:
  D.3554 = next->number;
  D.3555 = (int) D.3554;
  if (D.3555 < ruleno) goto <D.3390>; else goto <D.3392>;
  <D.3392>:
  temp = allocate (16);
  temp->next = next;
  D.3556 = (short int) symbol;
  temp->symbol = D.3556;
  D.3557 = (short int) ruleno;
  temp->number = D.3557;
  rprec.24 = rprec;
  ruleno.25 = (unsigned int) ruleno;
  D.3560 = ruleno.25 * 2;
  D.3561 = rprec.24 + D.3560;
  D.3562 = *D.3561;
  temp->prec = D.3562;
  temp->action_code = 2;
  rassoc.26 = rassoc;
  ruleno.27 = (sizetype) ruleno;
  D.3565 = rassoc.26 + ruleno.27;
  D.3566 = *D.3565;
  temp->assoc = D.3566;
  if (prev != 0B) goto <D.3567>; else goto <D.3568>;
  <D.3567>:
  prev->next = temp;
  goto <D.3569>;
  <D.3568>:
  actions = temp;
  <D.3569>:
  D.3570 = actions;
  return D.3570;
}


find_final_state ()
{
  struct shifts * * shift_table.28;
  short int * ritem.29;
  short int * D.3574;
  short int D.3575;
  short int D.3576;
  int D.3577;
  unsigned int i.30;
  unsigned int D.3579;
  short int * D.3580;
  short int final_state.31;
  short int * accessing_symbol.32;
  short int final_state.33;
  unsigned int D.3584;
  unsigned int D.3585;
  short int * D.3586;
  short int D.3587;
  int D.3588;
  register int goal;
  register int i;
  register short int * to_state;
  register struct shifts * p;

  shift_table.28 = shift_table;
  p = *shift_table.28;
  to_state = &p->shift;
  ritem.29 = ritem;
  D.3574 = ritem.29 + 2;
  D.3575 = *D.3574;
  goal = (int) D.3575;
  D.3576 = p->nshifts;
  D.3577 = (int) D.3576;
  i = D.3577 + -1;
  goto <D.3401>;
  <D.3400>:
  i.30 = (unsigned int) i;
  D.3579 = i.30 * 2;
  D.3580 = to_state + D.3579;
  final_state.31 = *D.3580;
  final_state = final_state.31;
  accessing_symbol.32 = accessing_symbol;
  final_state.33 = final_state;
  D.3584 = (unsigned int) final_state.33;
  D.3585 = D.3584 * 2;
  D.3586 = accessing_symbol.32 + D.3585;
  D.3587 = *D.3586;
  D.3588 = (int) D.3587;
  if (D.3588 == goal) goto <D.3399>; else goto <D.3589>;
  <D.3589>:
  i = i + -1;
  <D.3401>:
  if (i >= 0) goto <D.3400>; else goto <D.3399>;
  <D.3399>:
}


unused_rules ()
{
  int nrules.34;
  unsigned int nrules.35;
  unsigned int D.3592;
  void * rules_used.36;
  short int * rules_used.37;
  unsigned int i.38;
  unsigned int D.3598;
  short int * D.3599;
  struct action * * parser.39;
  unsigned int D.3601;
  struct action * * D.3602;
  char D.3603;
  char D.3606;
  short int D.3609;
  unsigned int D.3610;
  unsigned int D.3611;
  short int * D.3612;
  int nstates.40;
  short int D.3614;
  short int nunused.41;
  unsigned short nunused.42;
  unsigned short D.3619;
  short int nunused.43;
  char * myname.44;
  struct _IO_FILE * stderr.45;
  int D.3628;
  register int i;
  register struct action * p;
  extern int no_space ();

  nrules.34 = nrules;
  nrules.35 = (unsigned int) nrules.34;
  D.3592 = nrules.35 * 2;
  rules_used.36 = malloc (D.3592);
  rules_used = rules_used.36;
  rules_used.37 = rules_used;
  if (rules_used.37 == 0B) goto <D.3595>; else goto <D.3596>;
  <D.3595>:
  no_space ();
  <D.3596>:
  i = 0;
  goto <D.3408>;
  <D.3407>:
  rules_used.37 = rules_used;
  i.38 = (unsigned int) i;
  D.3598 = i.38 * 2;
  D.3599 = rules_used.37 + D.3598;
  *D.3599 = 0;
  i = i + 1;
  <D.3408>:
  nrules.34 = nrules;
  if (i < nrules.34) goto <D.3407>; else goto <D.3409>;
  <D.3409>:
  i = 0;
  goto <D.3414>;
  <D.3413>:
  parser.39 = parser;
  i.38 = (unsigned int) i;
  D.3601 = i.38 * 4;
  D.3602 = parser.39 + D.3601;
  p = *D.3602;
  goto <D.3411>;
  <D.3410>:
  D.3603 = p->action_code;
  if (D.3603 == 2) goto <D.3604>; else goto <D.3605>;
  <D.3604>:
  D.3606 = p->suppressed;
  if (D.3606 == 0) goto <D.3607>; else goto <D.3608>;
  <D.3607>:
  rules_used.37 = rules_used;
  D.3609 = p->number;
  D.3610 = (unsigned int) D.3609;
  D.3611 = D.3610 * 2;
  D.3612 = rules_used.37 + D.3611;
  *D.3612 = 1;
  <D.3608>:
  <D.3605>:
  p = p->next;
  <D.3411>:
  if (p != 0B) goto <D.3410>; else goto <D.3412>;
  <D.3412>:
  i = i + 1;
  <D.3414>:
  nstates.40 = nstates;
  if (i < nstates.40) goto <D.3413>; else goto <D.3415>;
  <D.3415>:
  nunused = 0;
  i = 3;
  goto <D.3417>;
  <D.3416>:
  rules_used.37 = rules_used;
  i.38 = (unsigned int) i;
  D.3598 = i.38 * 2;
  D.3599 = rules_used.37 + D.3598;
  D.3614 = *D.3599;
  if (D.3614 == 0) goto <D.3615>; else goto <D.3616>;
  <D.3615>:
  nunused.41 = nunused;
  nunused.42 = (unsigned short) nunused.41;
  D.3619 = nunused.42 + 1;
  nunused.43 = (short int) D.3619;
  nunused = nunused.43;
  <D.3616>:
  i = i + 1;
  <D.3417>:
  nrules.34 = nrules;
  if (i < nrules.34) goto <D.3416>; else goto <D.3418>;
  <D.3418>:
  nunused.41 = nunused;
  if (nunused.41 != 0) goto <D.3621>; else goto <D.3622>;
  <D.3621>:
  nunused.41 = nunused;
  if (nunused.41 == 1) goto <D.3623>; else goto <D.3624>;
  <D.3623>:
  myname.44 = myname;
  stderr.45 = stderr;
  fprintf (stderr.45, "%s: 1 rule never reduced\n", myname.44);
  goto <D.3627>;
  <D.3624>:
  nunused.41 = nunused;
  D.3628 = (int) nunused.41;
  myname.44 = myname;
  stderr.45 = stderr;
  fprintf (stderr.45, "%s: %d rules never reduced\n", myname.44, D.3628);
  <D.3627>:
  <D.3622>:
}


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

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


remove_conflicts ()
{
  int nstates.46;
  unsigned int nstates.47;
  unsigned int D.3633;
  char * SRconflicts.48;
  char * RRconflicts.49;
  struct action * * parser.50;
  unsigned int i.51;
  unsigned int D.3638;
  struct action * * D.3639;
  short int D.3640;
  int D.3641;
  short int final_state.52;
  int D.3648;
  int SRcount.53;
  int SRcount.54;
  char D.3653;
  short int D.3658;
  short int D.3660;
  char D.3668;
  int RRcount.55;
  int RRcount.56;
  int SRtotal.57;
  int SRtotal.58;
  int RRtotal.59;
  int RRtotal.60;
  short int * SRconflicts.61;
  unsigned int D.3683;
  short int * D.3684;
  short int D.3685;
  short int * RRconflicts.62;
  short int * D.3687;
  short int D.3688;
  register int i;
  register int symbol;
  register struct action * p;
  register struct action * pref;

  SRtotal = 0;
  RRtotal = 0;
  nstates.46 = nstates;
  nstates.47 = (unsigned int) nstates.46;
  D.3633 = nstates.47 * 2;
  SRconflicts.48 = allocate (D.3633);
  SRconflicts = SRconflicts.48;
  nstates.46 = nstates;
  nstates.47 = (unsigned int) nstates.46;
  D.3633 = nstates.47 * 2;
  RRconflicts.49 = allocate (D.3633);
  RRconflicts = RRconflicts.49;
  i = 0;
  goto <D.3430>;
  <D.3429>:
  SRcount = 0;
  RRcount = 0;
  symbol = -1;
  parser.50 = parser;
  i.51 = (unsigned int) i;
  D.3638 = i.51 * 4;
  D.3639 = parser.50 + D.3638;
  p = *D.3639;
  goto <D.3427>;
  <D.3426>:
  D.3640 = p->symbol;
  D.3641 = (int) D.3640;
  if (D.3641 != symbol) goto <D.3642>; else goto <D.3643>;
  <D.3642>:
  pref = p;
  D.3640 = p->symbol;
  symbol = (int) D.3640;
  goto <D.3644>;
  <D.3643>:
  final_state.52 = final_state;
  D.3648 = (int) final_state.52;
  if (D.3648 == i) goto <D.3649>; else goto <D.3645>;
  <D.3649>:
  if (symbol == 0) goto <D.3650>; else goto <D.3645>;
  <D.3650>:
  SRcount.53 = SRcount;
  SRcount.54 = SRcount.53 + 1;
  SRcount = SRcount.54;
  p->suppressed = 1;
  goto <D.3646>;
  <D.3645>:
  D.3653 = pref->action_code;
  if (D.3653 == 1) goto <D.3654>; else goto <D.3655>;
  <D.3654>:
  D.3658 = pref->prec;
  if (D.3658 > 0) goto <D.3659>; else goto <D.3656>;
  <D.3659>:
  D.3660 = p->prec;
  if (D.3660 > 0) goto <D.3661>; else goto <D.3656>;
  <D.3661>:
  D.3658 = pref->prec;
  D.3660 = p->prec;
  if (D.3658 < D.3660) goto <D.3662>; else goto <D.3663>;
  <D.3662>:
  pref->suppressed = 2;
  pref = p;
  goto <D.3664>;
  <D.3663>:
  D.3658 = pref->prec;
  D.3660 = p->prec;
  if (D.3658 > D.3660) goto <D.3665>; else goto <D.3666>;
  <D.3665>:
  p->suppressed = 2;
  goto <D.3667>;
  <D.3666>:
  D.3668 = pref->assoc;
  if (D.3668 == 1) goto <D.3669>; else goto <D.3670>;
  <D.3669>:
  pref->suppressed = 2;
  pref = p;
  goto <D.3671>;
  <D.3670>:
  D.3668 = pref->assoc;
  if (D.3668 == 2) goto <D.3672>; else goto <D.3673>;
  <D.3672>:
  p->suppressed = 2;
  goto <D.3674>;
  <D.3673>:
  pref->suppressed = 2;
  p->suppressed = 2;
  <D.3674>:
  <D.3671>:
  <D.3667>:
  <D.3664>:
  goto <D.3657>;
  <D.3656>:
  SRcount.53 = SRcount;
  SRcount.54 = SRcount.53 + 1;
  SRcount = SRcount.54;
  p->suppressed = 1;
  <D.3657>:
  goto <D.3675>;
  <D.3655>:
  RRcount.55 = RRcount;
  RRcount.56 = RRcount.55 + 1;
  RRcount = RRcount.56;
  p->suppressed = 1;
  <D.3675>:
  <D.3646>:
  <D.3644>:
  p = p->next;
  <D.3427>:
  if (p != 0B) goto <D.3426>; else goto <D.3428>;
  <D.3428>:
  SRtotal.57 = SRtotal;
  SRcount.53 = SRcount;
  SRtotal.58 = SRtotal.57 + SRcount.53;
  SRtotal = SRtotal.58;
  RRtotal.59 = RRtotal;
  RRcount.55 = RRcount;
  RRtotal.60 = RRtotal.59 + RRcount.55;
  RRtotal = RRtotal.60;
  SRconflicts.61 = SRconflicts;
  i.51 = (unsigned int) i;
  D.3683 = i.51 * 2;
  D.3684 = SRconflicts.61 + D.3683;
  SRcount.53 = SRcount;
  D.3685 = (short int) SRcount.53;
  *D.3684 = D.3685;
  RRconflicts.62 = RRconflicts;
  i.51 = (unsigned int) i;
  D.3683 = i.51 * 2;
  D.3687 = RRconflicts.62 + D.3683;
  RRcount.55 = RRcount;
  D.3688 = (short int) RRcount.55;
  *D.3687 = D.3688;
  i = i + 1;
  <D.3430>:
  nstates.46 = nstates;
  if (i < nstates.46) goto <D.3429>; else goto <D.3431>;
  <D.3431>:
}


total_conflicts ()
{
  char * myname.63;
  struct _IO_FILE * stderr.64;
  int SRtotal.65;
  int RRtotal.66;

  myname.63 = myname;
  stderr.64 = stderr;
  fprintf (stderr.64, "%s: ", myname.63);
  SRtotal.65 = SRtotal;
  if (SRtotal.65 == 1) goto <D.3692>; else goto <D.3693>;
  <D.3692>:
  stderr.64 = stderr;
  fprintf (stderr.64, "1 shift/reduce conflict");
  goto <D.3694>;
  <D.3693>:
  SRtotal.65 = SRtotal;
  if (SRtotal.65 > 1) goto <D.3695>; else goto <D.3696>;
  <D.3695>:
  SRtotal.65 = SRtotal;
  stderr.64 = stderr;
  fprintf (stderr.64, "%d shift/reduce conflicts", SRtotal.65);
  <D.3696>:
  <D.3694>:
  SRtotal.65 = SRtotal;
  if (SRtotal.65 != 0) goto <D.3697>; else goto <D.3698>;
  <D.3697>:
  RRtotal.66 = RRtotal;
  if (RRtotal.66 != 0) goto <D.3700>; else goto <D.3701>;
  <D.3700>:
  stderr.64 = stderr;
  fprintf (stderr.64, ", ");
  <D.3701>:
  <D.3698>:
  RRtotal.66 = RRtotal;
  if (RRtotal.66 == 1) goto <D.3702>; else goto <D.3703>;
  <D.3702>:
  stderr.64 = stderr;
  fprintf (stderr.64, "1 reduce/reduce conflict");
  goto <D.3704>;
  <D.3703>:
  RRtotal.66 = RRtotal;
  if (RRtotal.66 > 1) goto <D.3705>; else goto <D.3706>;
  <D.3705>:
  RRtotal.66 = RRtotal;
  stderr.64 = stderr;
  fprintf (stderr.64, "%d reduce/reduce conflicts", RRtotal.66);
  <D.3706>:
  <D.3704>:
  stderr.64 = stderr;
  fprintf (stderr.64, ".\n");
}


sole_reduction (int stateno)
{
  struct action * * parser.67;
  unsigned int stateno.68;
  unsigned int D.3709;
  struct action * * D.3710;
  char D.3712;
  char D.3714;
  int D.3716;
  short int D.3723;
  int D.3724;
  short int D.3727;
  register int count;
  register int ruleno;
  register struct action * p;

  count = 0;
  ruleno = 0;
  parser.67 = parser;
  stateno.68 = (unsigned int) stateno;
  D.3709 = stateno.68 * 4;
  D.3710 = parser.67 + D.3709;
  p = *D.3710;
  goto <D.3441>;
  <D.3440>:
  D.3712 = p->action_code;
  if (D.3712 == 1) goto <D.3713>; else goto <D.3711>;
  <D.3713>:
  D.3714 = p->suppressed;
  if (D.3714 == 0) goto <D.3715>; else goto <D.3711>;
  <D.3715>:
  D.3716 = 0;
  return D.3716;
  <D.3711>:
  D.3712 = p->action_code;
  if (D.3712 == 2) goto <D.3717>; else goto <D.3718>;
  <D.3717>:
  D.3714 = p->suppressed;
  if (D.3714 == 0) goto <D.3719>; else goto <D.3720>;
  <D.3719>:
  if (ruleno > 0) goto <D.3721>; else goto <D.3722>;
  <D.3721>:
  D.3723 = p->number;
  D.3724 = (int) D.3723;
  if (D.3724 != ruleno) goto <D.3725>; else goto <D.3726>;
  <D.3725>:
  D.3716 = 0;
  return D.3716;
  <D.3726>:
  <D.3722>:
  D.3727 = p->symbol;
  if (D.3727 != 1) goto <D.3728>; else goto <D.3729>;
  <D.3728>:
  count = count + 1;
  <D.3729>:
  D.3723 = p->number;
  ruleno = (int) D.3723;
  <D.3720>:
  <D.3718>:
  p = p->next;
  <D.3441>:
  if (p != 0B) goto <D.3440>; else goto <D.3442>;
  <D.3442>:
  if (count == 0) goto <D.3730>; else goto <D.3731>;
  <D.3730>:
  D.3716 = 0;
  return D.3716;
  <D.3731>:
  D.3716 = ruleno;
  return D.3716;
}


defreds ()
{
  int nstates.69;
  unsigned int nstates.70;
  unsigned int D.3735;
  char * defred.71;
  short int * defred.72;
  unsigned int i.73;
  unsigned int D.3739;
  short int * D.3740;
  int D.3741;
  short int D.3742;
  register int i;

  nstates.69 = nstates;
  nstates.70 = (unsigned int) nstates.69;
  D.3735 = nstates.70 * 2;
  defred.71 = allocate (D.3735);
  defred = defred.71;
  i = 0;
  goto <D.3447>;
  <D.3446>:
  defred.72 = defred;
  i.73 = (unsigned int) i;
  D.3739 = i.73 * 2;
  D.3740 = defred.72 + D.3739;
  D.3741 = sole_reduction (i);
  D.3742 = (short int) D.3741;
  *D.3740 = D.3742;
  i = i + 1;
  <D.3447>:
  nstates.69 = nstates;
  if (i < nstates.69) goto <D.3446>; else goto <D.3448>;
  <D.3448>:
}


free_action_row (struct action * p)
{
  register struct action * q;

  goto <D.3454>;
  <D.3453>:
  q = p->next;
  free (p);
  p = q;
  <D.3454>:
  if (p != 0B) goto <D.3453>; else goto <D.3455>;
  <D.3455>:
}


free_parser ()
{
  struct action * * parser.74;
  unsigned int i.75;
  unsigned int D.3745;
  struct action * * D.3746;
  struct action * D.3747;
  int nstates.76;
  register int i;

  i = 0;
  goto <D.3460>;
  <D.3459>:
  parser.74 = parser;
  i.75 = (unsigned int) i;
  D.3745 = i.75 * 4;
  D.3746 = parser.74 + D.3745;
  D.3747 = *D.3746;
  free_action_row (D.3747);
  i = i + 1;
  <D.3460>:
  nstates.76 = nstates;
  if (i < nstates.76) goto <D.3459>; else goto <D.3461>;
  <D.3461>:
  parser.74 = parser;
  free (parser.74);
}