make_parser ()
{
  int nstates.0;
  long unsigned int D.4083;
  unsigned int D.4084;
  unsigned int D.4085;
  char * parser.1;
  struct action * * parser.2;
  long unsigned int D.4088;
  long unsigned int D.4089;
  struct action * * D.4090;
  struct action * D.4091;
  int SRtotal.3;
  int RRtotal.4;
  int D.4094;
  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;
  D.4083 = (long unsigned int) nstates.0;
  D.4084 = (unsigned int) D.4083;
  D.4085 = D.4084 * 8;
  parser.1 = allocate (D.4085);
  parser = parser.1;
  i = 0;
  goto <D.3949>;
  <D.3948>:
  parser.2 = parser;
  D.4088 = (long unsigned int) i;
  D.4089 = D.4088 * 8;
  D.4090 = parser.2 + D.4089;
  D.4091 = parse_actions (i);
  *D.4090 = D.4091;
  i = i + 1;
  <D.3949>:
  nstates.0 = nstates;
  if (i < nstates.0) goto <D.3948>; else goto <D.3950>;
  <D.3950>:
  find_final_state ();
  remove_conflicts ();
  unused_rules ();
  SRtotal.3 = SRtotal;
  RRtotal.4 = RRtotal;
  D.4094 = SRtotal.3 + RRtotal.4;
  if (D.4094 > 0) goto <D.4095>; else goto <D.4096>;
  <D.4095>:
  total_conflicts ();
  <D.4096>:
  defreds ();
}


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

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


get_shifts (int stateno)
{
  struct shifts * * shift_table.5;
  long unsigned int D.4100;
  long unsigned int D.4101;
  struct shifts * * D.4102;
  short int D.4105;
  int D.4106;
  long unsigned int D.4107;
  long unsigned int D.4108;
  short int * D.4109;
  short int D.4110;
  short int * accessing_symbol.6;
  long unsigned int D.4112;
  long unsigned int D.4113;
  short int * D.4114;
  short int D.4115;
  int start_symbol.7;
  short int D.4119;
  short int D.4120;
  short int * symbol_prec.8;
  long unsigned int D.4122;
  long unsigned int D.4123;
  short int * D.4124;
  short int D.4125;
  char * symbol_assoc.9;
  sizetype D.4127;
  char * D.4128;
  char D.4129;
  struct action * D.4130;
  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.5 = shift_table;
  D.4100 = (long unsigned int) stateno;
  D.4101 = D.4100 * 8;
  D.4102 = shift_table.5 + D.4101;
  sp = *D.4102;
  if (sp != 0B) goto <D.4103>; else goto <D.4104>;
  <D.4103>:
  to_state = &sp->shift;
  D.4105 = sp->nshifts;
  D.4106 = (int) D.4105;
  i = D.4106 + -1;
  goto <D.3976>;
  <D.3975>:
  D.4107 = (long unsigned int) i;
  D.4108 = D.4107 * 2;
  D.4109 = to_state + D.4108;
  D.4110 = *D.4109;
  k = (int) D.4110;
  accessing_symbol.6 = accessing_symbol;
  D.4112 = (long unsigned int) k;
  D.4113 = D.4112 * 2;
  D.4114 = accessing_symbol.6 + D.4113;
  D.4115 = *D.4114;
  symbol = (int) D.4115;
  start_symbol.7 = start_symbol;
  if (symbol < start_symbol.7) goto <D.4117>; else goto <D.4118>;
  <D.4117>:
  temp = allocate (24);
  temp->next = actions;
  D.4119 = (short int) symbol;
  temp->symbol = D.4119;
  D.4120 = (short int) k;
  temp->number = D.4120;
  symbol_prec.8 = symbol_prec;
  D.4122 = (long unsigned int) symbol;
  D.4123 = D.4122 * 2;
  D.4124 = symbol_prec.8 + D.4123;
  D.4125 = *D.4124;
  temp->prec = D.4125;
  temp->action_code = 1;
  symbol_assoc.9 = symbol_assoc;
  D.4127 = (sizetype) symbol;
  D.4128 = symbol_assoc.9 + D.4127;
  D.4129 = *D.4128;
  temp->assoc = D.4129;
  actions = temp;
  <D.4118>:
  i = i + -1;
  <D.3976>:
  if (i >= 0) goto <D.3975>; else goto <D.3977>;
  <D.3977>:
  <D.4104>:
  D.4130 = actions;
  return D.4130;
}


add_reductions (int stateno, struct action * actions)
{
  int ntokens.10;
  int D.4133;
  short int * lookaheads.11;
  long unsigned int D.4135;
  long unsigned int D.4136;
  short int * D.4137;
  short int D.4138;
  sizetype D.4139;
  sizetype D.4140;
  sizetype D.4141;
  short int * D.4142;
  short int D.4143;
  short int * LAruleno.12;
  long unsigned int D.4145;
  long unsigned int D.4146;
  short int * D.4147;
  short int D.4148;
  unsigned int * LA.13;
  int D.4150;
  long unsigned int D.4151;
  long unsigned int D.4152;
  int D.4153;
  long unsigned int D.4154;
  long unsigned int D.4155;
  unsigned int * D.4156;
  unsigned int D.4157;
  int D.4158;
  unsigned int D.4159;
  unsigned int D.4160;
  struct action * D.4163;
  register int i;
  register int j;
  register int m;
  register int n;
  register int ruleno;
  register int tokensetsize;
  register unsigned int * rowp;

  ntokens.10 = ntokens;
  D.4133 = ntokens.10 + 31;
  tokensetsize = D.4133 / 32;
  lookaheads.11 = lookaheads;
  D.4135 = (long unsigned int) stateno;
  D.4136 = D.4135 * 2;
  D.4137 = lookaheads.11 + D.4136;
  D.4138 = *D.4137;
  m = (int) D.4138;
  lookaheads.11 = lookaheads;
  D.4139 = (sizetype) stateno;
  D.4140 = D.4139 + 1;
  D.4141 = D.4140 * 2;
  D.4142 = lookaheads.11 + D.4141;
  D.4143 = *D.4142;
  n = (int) D.4143;
  i = m;
  goto <D.3993>;
  <D.3992>:
  LAruleno.12 = LAruleno;
  D.4145 = (long unsigned int) i;
  D.4146 = D.4145 * 2;
  D.4147 = LAruleno.12 + D.4146;
  D.4148 = *D.4147;
  ruleno = (int) D.4148;
  LA.13 = LA;
  D.4150 = i * tokensetsize;
  D.4151 = (long unsigned int) D.4150;
  D.4152 = D.4151 * 4;
  rowp = LA.13 + D.4152;
  ntokens.10 = ntokens;
  j = ntokens.10 + -1;
  goto <D.3990>;
  <D.3989>:
  D.4153 = j >> 5;
  D.4154 = (long unsigned int) D.4153;
  D.4155 = D.4154 * 4;
  D.4156 = rowp + D.4155;
  D.4157 = *D.4156;
  D.4158 = j & 31;
  D.4159 = D.4157 >> D.4158;
  D.4160 = D.4159 & 1;
  if (D.4160 != 0) goto <D.4161>; else goto <D.4162>;
  <D.4161>:
  actions = add_reduce (actions, ruleno, j);
  <D.4162>:
  j = j + -1;
  <D.3990>:
  if (j >= 0) goto <D.3989>; else goto <D.3991>;
  <D.3991>:
  i = i + 1;
  <D.3993>:
  if (i < n) goto <D.3992>; else goto <D.3994>;
  <D.3994>:
  D.4163 = actions;
  return D.4163;
}


add_reduce (struct action * actions, int ruleno, int symbol)
{
  short int D.4166;
  int D.4167;
  char D.4170;
  short int D.4174;
  int D.4175;
  short int D.4176;
  short int D.4177;
  short int * rprec.14;
  long unsigned int D.4179;
  long unsigned int D.4180;
  short int * D.4181;
  short int D.4182;
  char * rassoc.15;
  sizetype D.4184;
  char * D.4185;
  char D.4186;
  struct action * D.4190;
  register struct action * temp;
  register struct action * prev;
  register struct action * next;

  prev = 0B;
  next = actions;
  goto <D.4004>;
  <D.4003>:
  prev = next;
  next = next->next;
  <D.4004>:
  if (next != 0B) goto <D.4165>; else goto <D.4005>;
  <D.4165>:
  D.4166 = next->symbol;
  D.4167 = (int) D.4166;
  if (D.4167 < symbol) goto <D.4003>; else goto <D.4005>;
  <D.4005>:
  goto <D.4007>;
  <D.4006>:
  prev = next;
  next = next->next;
  <D.4007>:
  if (next != 0B) goto <D.4168>; else goto <D.4008>;
  <D.4168>:
  D.4166 = next->symbol;
  D.4167 = (int) D.4166;
  if (D.4167 == symbol) goto <D.4169>; else goto <D.4008>;
  <D.4169>:
  D.4170 = next->action_code;
  if (D.4170 == 1) goto <D.4006>; else goto <D.4008>;
  <D.4008>:
  goto <D.4010>;
  <D.4009>:
  prev = next;
  next = next->next;
  <D.4010>:
  if (next != 0B) goto <D.4171>; else goto <D.4011>;
  <D.4171>:
  D.4166 = next->symbol;
  D.4167 = (int) D.4166;
  if (D.4167 == symbol) goto <D.4172>; else goto <D.4011>;
  <D.4172>:
  D.4170 = next->action_code;
  if (D.4170 == 2) goto <D.4173>; else goto <D.4011>;
  <D.4173>:
  D.4174 = next->number;
  D.4175 = (int) D.4174;
  if (D.4175 < ruleno) goto <D.4009>; else goto <D.4011>;
  <D.4011>:
  temp = allocate (24);
  temp->next = next;
  D.4176 = (short int) symbol;
  temp->symbol = D.4176;
  D.4177 = (short int) ruleno;
  temp->number = D.4177;
  rprec.14 = rprec;
  D.4179 = (long unsigned int) ruleno;
  D.4180 = D.4179 * 2;
  D.4181 = rprec.14 + D.4180;
  D.4182 = *D.4181;
  temp->prec = D.4182;
  temp->action_code = 2;
  rassoc.15 = rassoc;
  D.4184 = (sizetype) ruleno;
  D.4185 = rassoc.15 + D.4184;
  D.4186 = *D.4185;
  temp->assoc = D.4186;
  if (prev != 0B) goto <D.4187>; else goto <D.4188>;
  <D.4187>:
  prev->next = temp;
  goto <D.4189>;
  <D.4188>:
  actions = temp;
  <D.4189>:
  D.4190 = actions;
  return D.4190;
}


find_final_state ()
{
  struct shifts * * shift_table.16;
  short int * ritem.17;
  short int * D.4194;
  short int D.4195;
  short int D.4196;
  int D.4197;
  long unsigned int D.4198;
  long unsigned int D.4199;
  short int * D.4200;
  short int final_state.18;
  short int * accessing_symbol.19;
  short int final_state.20;
  long unsigned int D.4204;
  long unsigned int D.4205;
  short int * D.4206;
  short int D.4207;
  int D.4208;
  register int goal;
  register int i;
  register short int * to_state;
  register struct shifts * p;

  shift_table.16 = shift_table;
  p = *shift_table.16;
  to_state = &p->shift;
  ritem.17 = ritem;
  D.4194 = ritem.17 + 2;
  D.4195 = *D.4194;
  goal = (int) D.4195;
  D.4196 = p->nshifts;
  D.4197 = (int) D.4196;
  i = D.4197 + -1;
  goto <D.4020>;
  <D.4019>:
  D.4198 = (long unsigned int) i;
  D.4199 = D.4198 * 2;
  D.4200 = to_state + D.4199;
  final_state.18 = *D.4200;
  final_state = final_state.18;
  accessing_symbol.19 = accessing_symbol;
  final_state.20 = final_state;
  D.4204 = (long unsigned int) final_state.20;
  D.4205 = D.4204 * 2;
  D.4206 = accessing_symbol.19 + D.4205;
  D.4207 = *D.4206;
  D.4208 = (int) D.4207;
  if (D.4208 == goal) goto <D.4018>; else goto <D.4209>;
  <D.4209>:
  i = i + -1;
  <D.4020>:
  if (i >= 0) goto <D.4019>; else goto <D.4018>;
  <D.4018>:
}


unused_rules ()
{
  int nrules.21;
  long unsigned int D.4211;
  unsigned int D.4212;
  unsigned int D.4213;
  long unsigned int D.4214;
  void * rules_used.22;
  short int * rules_used.23;
  long unsigned int D.4219;
  long unsigned int D.4220;
  short int * D.4221;
  struct action * * parser.24;
  long unsigned int D.4223;
  struct action * * D.4224;
  char D.4225;
  char D.4228;
  short int D.4231;
  long unsigned int D.4232;
  long unsigned int D.4233;
  short int * D.4234;
  int nstates.25;
  short int D.4236;
  short int nunused.26;
  unsigned short nunused.27;
  unsigned short D.4241;
  short int nunused.28;
  char * myname.29;
  struct _IO_FILE * stderr.30;
  int D.4250;
  register int i;
  register struct action * p;
  extern int no_space ();

  nrules.21 = nrules;
  D.4211 = (long unsigned int) nrules.21;
  D.4212 = (unsigned int) D.4211;
  D.4213 = D.4212 * 2;
  D.4214 = (long unsigned int) D.4213;
  rules_used.22 = malloc (D.4214);
  rules_used = rules_used.22;
  rules_used.23 = rules_used;
  if (rules_used.23 == 0B) goto <D.4217>; else goto <D.4218>;
  <D.4217>:
  no_space ();
  <D.4218>:
  i = 0;
  goto <D.4027>;
  <D.4026>:
  rules_used.23 = rules_used;
  D.4219 = (long unsigned int) i;
  D.4220 = D.4219 * 2;
  D.4221 = rules_used.23 + D.4220;
  *D.4221 = 0;
  i = i + 1;
  <D.4027>:
  nrules.21 = nrules;
  if (i < nrules.21) goto <D.4026>; else goto <D.4028>;
  <D.4028>:
  i = 0;
  goto <D.4033>;
  <D.4032>:
  parser.24 = parser;
  D.4219 = (long unsigned int) i;
  D.4223 = D.4219 * 8;
  D.4224 = parser.24 + D.4223;
  p = *D.4224;
  goto <D.4030>;
  <D.4029>:
  D.4225 = p->action_code;
  if (D.4225 == 2) goto <D.4226>; else goto <D.4227>;
  <D.4226>:
  D.4228 = p->suppressed;
  if (D.4228 == 0) goto <D.4229>; else goto <D.4230>;
  <D.4229>:
  rules_used.23 = rules_used;
  D.4231 = p->number;
  D.4232 = (long unsigned int) D.4231;
  D.4233 = D.4232 * 2;
  D.4234 = rules_used.23 + D.4233;
  *D.4234 = 1;
  <D.4230>:
  <D.4227>:
  p = p->next;
  <D.4030>:
  if (p != 0B) goto <D.4029>; else goto <D.4031>;
  <D.4031>:
  i = i + 1;
  <D.4033>:
  nstates.25 = nstates;
  if (i < nstates.25) goto <D.4032>; else goto <D.4034>;
  <D.4034>:
  nunused = 0;
  i = 3;
  goto <D.4036>;
  <D.4035>:
  rules_used.23 = rules_used;
  D.4219 = (long unsigned int) i;
  D.4220 = D.4219 * 2;
  D.4221 = rules_used.23 + D.4220;
  D.4236 = *D.4221;
  if (D.4236 == 0) goto <D.4237>; else goto <D.4238>;
  <D.4237>:
  nunused.26 = nunused;
  nunused.27 = (unsigned short) nunused.26;
  D.4241 = nunused.27 + 1;
  nunused.28 = (short int) D.4241;
  nunused = nunused.28;
  <D.4238>:
  i = i + 1;
  <D.4036>:
  nrules.21 = nrules;
  if (i < nrules.21) goto <D.4035>; else goto <D.4037>;
  <D.4037>:
  nunused.26 = nunused;
  if (nunused.26 != 0) goto <D.4243>; else goto <D.4244>;
  <D.4243>:
  nunused.26 = nunused;
  if (nunused.26 == 1) goto <D.4245>; else goto <D.4246>;
  <D.4245>:
  myname.29 = myname;
  stderr.30 = stderr;
  fprintf (stderr.30, "%s: 1 rule never reduced\n", myname.29);
  goto <D.4249>;
  <D.4246>:
  nunused.26 = nunused;
  D.4250 = (int) nunused.26;
  myname.29 = myname;
  stderr.30 = stderr;
  fprintf (stderr.30, "%s: %d rules never reduced\n", myname.29, D.4250);
  <D.4249>:
  <D.4244>:
}


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

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


remove_conflicts ()
{
  int nstates.31;
  long unsigned int D.4254;
  unsigned int D.4255;
  unsigned int D.4256;
  char * SRconflicts.32;
  char * RRconflicts.33;
  struct action * * parser.34;
  long unsigned int D.4260;
  long unsigned int D.4261;
  struct action * * D.4262;
  short int D.4263;
  int D.4264;
  short int final_state.35;
  int D.4271;
  int SRcount.36;
  int SRcount.37;
  char D.4276;
  short int D.4281;
  short int D.4283;
  char D.4291;
  int RRcount.38;
  int RRcount.39;
  int SRtotal.40;
  int SRtotal.41;
  int RRtotal.42;
  int RRtotal.43;
  short int * SRconflicts.44;
  long unsigned int D.4306;
  short int * D.4307;
  short int D.4308;
  short int * RRconflicts.45;
  short int * D.4310;
  short int D.4311;
  register int i;
  register int symbol;
  register struct action * p;
  register struct action * pref;

  SRtotal = 0;
  RRtotal = 0;
  nstates.31 = nstates;
  D.4254 = (long unsigned int) nstates.31;
  D.4255 = (unsigned int) D.4254;
  D.4256 = D.4255 * 2;
  SRconflicts.32 = allocate (D.4256);
  SRconflicts = SRconflicts.32;
  nstates.31 = nstates;
  D.4254 = (long unsigned int) nstates.31;
  D.4255 = (unsigned int) D.4254;
  D.4256 = D.4255 * 2;
  RRconflicts.33 = allocate (D.4256);
  RRconflicts = RRconflicts.33;
  i = 0;
  goto <D.4049>;
  <D.4048>:
  SRcount = 0;
  RRcount = 0;
  symbol = -1;
  parser.34 = parser;
  D.4260 = (long unsigned int) i;
  D.4261 = D.4260 * 8;
  D.4262 = parser.34 + D.4261;
  p = *D.4262;
  goto <D.4046>;
  <D.4045>:
  D.4263 = p->symbol;
  D.4264 = (int) D.4263;
  if (D.4264 != symbol) goto <D.4265>; else goto <D.4266>;
  <D.4265>:
  pref = p;
  D.4263 = p->symbol;
  symbol = (int) D.4263;
  goto <D.4267>;
  <D.4266>:
  final_state.35 = final_state;
  D.4271 = (int) final_state.35;
  if (D.4271 == i) goto <D.4272>; else goto <D.4268>;
  <D.4272>:
  if (symbol == 0) goto <D.4273>; else goto <D.4268>;
  <D.4273>:
  SRcount.36 = SRcount;
  SRcount.37 = SRcount.36 + 1;
  SRcount = SRcount.37;
  p->suppressed = 1;
  goto <D.4269>;
  <D.4268>:
  D.4276 = pref->action_code;
  if (D.4276 == 1) goto <D.4277>; else goto <D.4278>;
  <D.4277>:
  D.4281 = pref->prec;
  if (D.4281 > 0) goto <D.4282>; else goto <D.4279>;
  <D.4282>:
  D.4283 = p->prec;
  if (D.4283 > 0) goto <D.4284>; else goto <D.4279>;
  <D.4284>:
  D.4281 = pref->prec;
  D.4283 = p->prec;
  if (D.4281 < D.4283) goto <D.4285>; else goto <D.4286>;
  <D.4285>:
  pref->suppressed = 2;
  pref = p;
  goto <D.4287>;
  <D.4286>:
  D.4281 = pref->prec;
  D.4283 = p->prec;
  if (D.4281 > D.4283) goto <D.4288>; else goto <D.4289>;
  <D.4288>:
  p->suppressed = 2;
  goto <D.4290>;
  <D.4289>:
  D.4291 = pref->assoc;
  if (D.4291 == 1) goto <D.4292>; else goto <D.4293>;
  <D.4292>:
  pref->suppressed = 2;
  pref = p;
  goto <D.4294>;
  <D.4293>:
  D.4291 = pref->assoc;
  if (D.4291 == 2) goto <D.4295>; else goto <D.4296>;
  <D.4295>:
  p->suppressed = 2;
  goto <D.4297>;
  <D.4296>:
  pref->suppressed = 2;
  p->suppressed = 2;
  <D.4297>:
  <D.4294>:
  <D.4290>:
  <D.4287>:
  goto <D.4280>;
  <D.4279>:
  SRcount.36 = SRcount;
  SRcount.37 = SRcount.36 + 1;
  SRcount = SRcount.37;
  p->suppressed = 1;
  <D.4280>:
  goto <D.4298>;
  <D.4278>:
  RRcount.38 = RRcount;
  RRcount.39 = RRcount.38 + 1;
  RRcount = RRcount.39;
  p->suppressed = 1;
  <D.4298>:
  <D.4269>:
  <D.4267>:
  p = p->next;
  <D.4046>:
  if (p != 0B) goto <D.4045>; else goto <D.4047>;
  <D.4047>:
  SRtotal.40 = SRtotal;
  SRcount.36 = SRcount;
  SRtotal.41 = SRtotal.40 + SRcount.36;
  SRtotal = SRtotal.41;
  RRtotal.42 = RRtotal;
  RRcount.38 = RRcount;
  RRtotal.43 = RRtotal.42 + RRcount.38;
  RRtotal = RRtotal.43;
  SRconflicts.44 = SRconflicts;
  D.4260 = (long unsigned int) i;
  D.4306 = D.4260 * 2;
  D.4307 = SRconflicts.44 + D.4306;
  SRcount.36 = SRcount;
  D.4308 = (short int) SRcount.36;
  *D.4307 = D.4308;
  RRconflicts.45 = RRconflicts;
  D.4260 = (long unsigned int) i;
  D.4306 = D.4260 * 2;
  D.4310 = RRconflicts.45 + D.4306;
  RRcount.38 = RRcount;
  D.4311 = (short int) RRcount.38;
  *D.4310 = D.4311;
  i = i + 1;
  <D.4049>:
  nstates.31 = nstates;
  if (i < nstates.31) goto <D.4048>; else goto <D.4050>;
  <D.4050>:
}


total_conflicts ()
{
  char * myname.46;
  struct _IO_FILE * stderr.47;
  int SRtotal.48;
  int RRtotal.49;

  myname.46 = myname;
  stderr.47 = stderr;
  fprintf (stderr.47, "%s: ", myname.46);
  SRtotal.48 = SRtotal;
  if (SRtotal.48 == 1) goto <D.4315>; else goto <D.4316>;
  <D.4315>:
  stderr.47 = stderr;
  fprintf (stderr.47, "1 shift/reduce conflict");
  goto <D.4317>;
  <D.4316>:
  SRtotal.48 = SRtotal;
  if (SRtotal.48 > 1) goto <D.4318>; else goto <D.4319>;
  <D.4318>:
  SRtotal.48 = SRtotal;
  stderr.47 = stderr;
  fprintf (stderr.47, "%d shift/reduce conflicts", SRtotal.48);
  <D.4319>:
  <D.4317>:
  SRtotal.48 = SRtotal;
  if (SRtotal.48 != 0) goto <D.4320>; else goto <D.4321>;
  <D.4320>:
  RRtotal.49 = RRtotal;
  if (RRtotal.49 != 0) goto <D.4323>; else goto <D.4324>;
  <D.4323>:
  stderr.47 = stderr;
  fprintf (stderr.47, ", ");
  <D.4324>:
  <D.4321>:
  RRtotal.49 = RRtotal;
  if (RRtotal.49 == 1) goto <D.4325>; else goto <D.4326>;
  <D.4325>:
  stderr.47 = stderr;
  fprintf (stderr.47, "1 reduce/reduce conflict");
  goto <D.4327>;
  <D.4326>:
  RRtotal.49 = RRtotal;
  if (RRtotal.49 > 1) goto <D.4328>; else goto <D.4329>;
  <D.4328>:
  RRtotal.49 = RRtotal;
  stderr.47 = stderr;
  fprintf (stderr.47, "%d reduce/reduce conflicts", RRtotal.49);
  <D.4329>:
  <D.4327>:
  stderr.47 = stderr;
  fprintf (stderr.47, ".\n");
}


sole_reduction (int stateno)
{
  struct action * * parser.50;
  long unsigned int D.4331;
  long unsigned int D.4332;
  struct action * * D.4333;
  char D.4335;
  char D.4337;
  int D.4339;
  short int D.4346;
  int D.4347;
  short int D.4350;
  register int count;
  register int ruleno;
  register struct action * p;

  count = 0;
  ruleno = 0;
  parser.50 = parser;
  D.4331 = (long unsigned int) stateno;
  D.4332 = D.4331 * 8;
  D.4333 = parser.50 + D.4332;
  p = *D.4333;
  goto <D.4060>;
  <D.4059>:
  D.4335 = p->action_code;
  if (D.4335 == 1) goto <D.4336>; else goto <D.4334>;
  <D.4336>:
  D.4337 = p->suppressed;
  if (D.4337 == 0) goto <D.4338>; else goto <D.4334>;
  <D.4338>:
  D.4339 = 0;
  return D.4339;
  <D.4334>:
  D.4335 = p->action_code;
  if (D.4335 == 2) goto <D.4340>; else goto <D.4341>;
  <D.4340>:
  D.4337 = p->suppressed;
  if (D.4337 == 0) goto <D.4342>; else goto <D.4343>;
  <D.4342>:
  if (ruleno > 0) goto <D.4344>; else goto <D.4345>;
  <D.4344>:
  D.4346 = p->number;
  D.4347 = (int) D.4346;
  if (D.4347 != ruleno) goto <D.4348>; else goto <D.4349>;
  <D.4348>:
  D.4339 = 0;
  return D.4339;
  <D.4349>:
  <D.4345>:
  D.4350 = p->symbol;
  if (D.4350 != 1) goto <D.4351>; else goto <D.4352>;
  <D.4351>:
  count = count + 1;
  <D.4352>:
  D.4346 = p->number;
  ruleno = (int) D.4346;
  <D.4343>:
  <D.4341>:
  p = p->next;
  <D.4060>:
  if (p != 0B) goto <D.4059>; else goto <D.4061>;
  <D.4061>:
  if (count == 0) goto <D.4353>; else goto <D.4354>;
  <D.4353>:
  D.4339 = 0;
  return D.4339;
  <D.4354>:
  D.4339 = ruleno;
  return D.4339;
}


defreds ()
{
  int nstates.51;
  long unsigned int D.4357;
  unsigned int D.4358;
  unsigned int D.4359;
  char * defred.52;
  short int * defred.53;
  long unsigned int D.4362;
  long unsigned int D.4363;
  short int * D.4364;
  int D.4365;
  short int D.4366;
  register int i;

  nstates.51 = nstates;
  D.4357 = (long unsigned int) nstates.51;
  D.4358 = (unsigned int) D.4357;
  D.4359 = D.4358 * 2;
  defred.52 = allocate (D.4359);
  defred = defred.52;
  i = 0;
  goto <D.4066>;
  <D.4065>:
  defred.53 = defred;
  D.4362 = (long unsigned int) i;
  D.4363 = D.4362 * 2;
  D.4364 = defred.53 + D.4363;
  D.4365 = sole_reduction (i);
  D.4366 = (short int) D.4365;
  *D.4364 = D.4366;
  i = i + 1;
  <D.4066>:
  nstates.51 = nstates;
  if (i < nstates.51) goto <D.4065>; else goto <D.4067>;
  <D.4067>:
}


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

  goto <D.4073>;
  <D.4072>:
  q = p->next;
  free (p);
  p = q;
  <D.4073>:
  if (p != 0B) goto <D.4072>; else goto <D.4074>;
  <D.4074>:
}


free_parser ()
{
  struct action * * parser.54;
  long unsigned int D.4368;
  long unsigned int D.4369;
  struct action * * D.4370;
  struct action * D.4371;
  int nstates.55;
  register int i;

  i = 0;
  goto <D.4079>;
  <D.4078>:
  parser.54 = parser;
  D.4368 = (long unsigned int) i;
  D.4369 = D.4368 * 8;
  D.4370 = parser.54 + D.4369;
  D.4371 = *D.4370;
  free_action_row (D.4371);
  i = i + 1;
  <D.4079>:
  nstates.55 = nstates;
  if (i < nstates.55) goto <D.4078>; else goto <D.4080>;
  <D.4080>:
  parser.54 = parser;
  free (parser.54);
}