cachec (int c)
{
  int cinc.0;
  int cache_size.1;
  int cache_size.2;
  unsigned int cache_size.3;
  long unsigned int D.4605;
  char * cache.4;
  void * cache.5;
  sizetype D.4610;
  char * D.4611;
  char D.4612;
  int cinc.6;
  static const char __PRETTY_FUNCTION__[7] = "cachec";

  cinc.0 = cinc;
  if (cinc.0 < 0) goto <D.4598>; else goto <D.4599>;
  <D.4598>:
  __assert_fail ("cinc >= 0", "reader.c", 83, &__PRETTY_FUNCTION__);
  <D.4599>:
  cinc.0 = cinc;
  cache_size.1 = cache_size;
  if (cinc.0 >= cache_size.1) goto <D.4601>; else goto <D.4602>;
  <D.4601>:
  {
    extern int no_space ();

    cache_size.1 = cache_size;
    cache_size.2 = cache_size.1 + 256;
    cache_size = cache_size.2;
    cache_size.1 = cache_size;
    cache_size.3 = (unsigned int) cache_size.1;
    D.4605 = (long unsigned int) cache_size.3;
    cache.4 = cache;
    cache.5 = realloc (cache.4, D.4605);
    cache = cache.5;
    cache.4 = cache;
    if (cache.4 == 0B) goto <D.4608>; else goto <D.4609>;
    <D.4608>:
    no_space ();
    <D.4609>:
  }
  <D.4602>:
  cache.4 = cache;
  cinc.0 = cinc;
  D.4610 = (sizetype) cinc.0;
  D.4611 = cache.4 + D.4610;
  D.4612 = (char) c;
  *D.4611 = D.4612;
  cinc.0 = cinc;
  cinc.6 = cinc.0 + 1;
  cinc = cinc.6;
}


get_line ()
{
  char saw_eof.7;
  char * line.8;
  int linesize.9;
  unsigned int linesize.10;
  long unsigned int D.4628;
  void * line.11;
  int lineno.12;
  int lineno.13;
  sizetype D.4634;
  char * D.4635;
  char D.4636;
  int linesize.14;
  void * line.15;
  register struct FILE * f;
  register int c;
  register int i;

  f = input_file;
  saw_eof.7 = saw_eof;
  if (saw_eof.7 != 0) goto <D.4614>; else goto <D.4617>;
  <D.4617>:
  c = _IO_getc (f);
  if (c == -1) goto <D.4614>; else goto <D.4615>;
  <D.4614>:
  line.8 = line;
  if (line.8 != 0B) goto <D.4619>; else goto <D.4620>;
  <D.4619>:
  line.8 = line;
  free (line.8);
  line = 0B;
  <D.4620>:
  cptr = 0B;
  saw_eof = 1;
  return;
  <D.4615>:
  line.8 = line;
  if (line.8 == 0B) goto <D.4621>; else goto <D.4623>;
  <D.4623>:
  linesize.9 = linesize;
  if (linesize.9 != 101) goto <D.4621>; else goto <D.4622>;
  <D.4621>:
  {
    extern int no_space ();

    line.8 = line;
    if (line.8 != 0B) goto <D.4625>; else goto <D.4626>;
    <D.4625>:
    line.8 = line;
    free (line.8);
    <D.4626>:
    linesize = 101;
    linesize.9 = linesize;
    linesize.10 = (unsigned int) linesize.9;
    D.4628 = (long unsigned int) linesize.10;
    line.11 = malloc (D.4628);
    line = line.11;
    line.8 = line;
    if (line.8 == 0B) goto <D.4630>; else goto <D.4631>;
    <D.4630>:
    no_space ();
    <D.4631>:
  }
  <D.4622>:
  i = 0;
  lineno.12 = lineno;
  lineno.13 = lineno.12 + 1;
  lineno = lineno.13;
  <D.3966>:
  line.8 = line;
  D.4634 = (sizetype) i;
  D.4635 = line.8 + D.4634;
  D.4636 = (char) c;
  *D.4635 = D.4636;
  if (c == 10) goto <D.4637>; else goto <D.4638>;
  <D.4637>:
  line.8 = line;
  cptr = line.8;
  return;
  <D.4638>:
  i = i + 1;
  linesize.9 = linesize;
  if (i >= linesize.9) goto <D.4639>; else goto <D.4640>;
  <D.4639>:
  {
    extern int no_space ();

    linesize.9 = linesize;
    linesize.14 = linesize.9 + 100;
    linesize = linesize.14;
    linesize.9 = linesize;
    linesize.10 = (unsigned int) linesize.9;
    D.4628 = (long unsigned int) linesize.10;
    line.8 = line;
    line.15 = realloc (line.8, D.4628);
    line = line.15;
    line.8 = line;
    if (line.8 == 0B) goto <D.4643>; else goto <D.4644>;
    <D.4643>:
    no_space ();
    <D.4644>:
  }
  <D.4640>:
  c = _IO_getc (f);
  if (c == -1) goto <D.4645>; else goto <D.4646>;
  <D.4645>:
  line.8 = line;
  D.4634 = (sizetype) i;
  D.4635 = line.8 + D.4634;
  *D.4635 = 10;
  saw_eof = 1;
  line.8 = line;
  cptr = line.8;
  return;
  <D.4646>:
  goto <D.3966>;
}


dup_line ()
{
  char * line.16;
  char * D.4651;
  char D.4652;
  long int s.17;
  long int line.18;
  long int D.4655;
  unsigned int D.4656;
  unsigned int D.4657;
  long unsigned int D.4658;
  char * t.19;
  char * s.20;
  char D.4663;
  char D.4664;
  register char * p;
  register char * s;
  register char * t;
  extern int no_space ();

  line.16 = line;
  if (line.16 == 0B) goto <D.4649>; else goto <D.4650>;
  <D.4649>:
  D.4651 = 0B;
  return D.4651;
  <D.4650>:
  s = line;
  goto <D.3973>;
  <D.3972>:
  s = s + 1;
  <D.3973>:
  D.4652 = *s;
  if (D.4652 != 10) goto <D.3972>; else goto <D.3974>;
  <D.3974>:
  s.17 = (long int) s;
  line.16 = line;
  line.18 = (long int) line.16;
  D.4655 = s.17 - line.18;
  D.4656 = (unsigned int) D.4655;
  D.4657 = D.4656 + 1;
  D.4658 = (long unsigned int) D.4657;
  p = malloc (D.4658);
  if (p == 0B) goto <D.4659>; else goto <D.4660>;
  <D.4659>:
  no_space ();
  <D.4660>:
  s = line;
  t = p;
  goto <D.3975>;
  <D.3976>:
  // predicted unlikely by continue predictor.
  goto <D.3975>;
  <D.3975>:
  t.19 = t;
  t = t.19 + 1;
  s.20 = s;
  s = s.20 + 1;
  D.4663 = *s.20;
  *t.19 = D.4663;
  D.4664 = *t.19;
  if (D.4664 != 10) goto <D.3976>; else goto <D.3977>;
  <D.3977>:
  D.4651 = p;
  return D.4651;
}


skip_comment ()
{
  char * cptr.21;
  long int cptr.22;
  char * line.23;
  long int line.24;
  long int D.4670;
  sizetype D.4671;
  char D.4672;
  char * D.4675;
  char D.4676;
  char * cptr.25;
  register char * s;
  int st_lineno;
  char * st_line;
  char * st_cptr;

  st_lineno = lineno;
  st_line = dup_line ();
  cptr.21 = cptr;
  cptr.22 = (long int) cptr.21;
  line.23 = line;
  line.24 = (long int) line.23;
  D.4670 = cptr.22 - line.24;
  D.4671 = (sizetype) D.4670;
  st_cptr = st_line + D.4671;
  cptr.21 = cptr;
  s = cptr.21 + 2;
  <D.3987>:
  D.4672 = *s;
  if (D.4672 == 42) goto <D.4673>; else goto <D.4674>;
  <D.4673>:
  D.4675 = s + 1;
  D.4676 = *D.4675;
  if (D.4676 == 47) goto <D.4677>; else goto <D.4678>;
  <D.4677>:
  cptr.25 = s + 2;
  cptr = cptr.25;
  free (st_line);
  return;
  <D.4678>:
  <D.4674>:
  D.4672 = *s;
  if (D.4672 == 10) goto <D.4680>; else goto <D.4681>;
  <D.4680>:
  {
    extern int unterminated_comment ();

    get_line ();
    line.23 = line;
    if (line.23 == 0B) goto <D.4682>; else goto <D.4683>;
    <D.4682>:
    unterminated_comment (st_lineno, st_line, st_cptr);
    <D.4683>:
    s = cptr;
  }
  goto <D.4684>;
  <D.4681>:
  s = s + 1;
  <D.4684>:
  goto <D.3987>;
}


nextc ()
{
  char * line.26;
  int D.4691;
  char D.4692;
  int D.4693;
  char * D.4696;
  char D.4697;
  register char * s;

  line.26 = line;
  if (line.26 == 0B) goto <D.4687>; else goto <D.4688>;
  <D.4687>:
  get_line ();
  line.26 = line;
  if (line.26 == 0B) goto <D.4689>; else goto <D.4690>;
  <D.4689>:
  D.4691 = -1;
  return D.4691;
  <D.4690>:
  <D.4688>:
  s = cptr;
  <D.4003>:
  D.4692 = *s;
  D.4693 = (int) D.4692;
  switch (D.4693) <default: <D.4002>, case 9: <D.3994>, case 10: <D.3991>, case 11: <D.3997>, case 12: <D.3995>, case 13: <D.3996>, case 32: <D.3993>, case 44: <D.3998>, case 47: <D.4001>, case 59: <D.3999>, case 92: <D.4000>>
  <D.3991>:
  get_line ();
  line.26 = line;
  if (line.26 == 0B) goto <D.4694>; else goto <D.4695>;
  <D.4694>:
  D.4691 = -1;
  return D.4691;
  <D.4695>:
  s = cptr;
  goto <D.3992>;
  <D.3993>:
  <D.3994>:
  <D.3995>:
  <D.3996>:
  <D.3997>:
  <D.3998>:
  <D.3999>:
  s = s + 1;
  goto <D.3992>;
  <D.4000>:
  cptr = s;
  D.4691 = 37;
  return D.4691;
  <D.4001>:
  D.4696 = s + 1;
  D.4697 = *D.4696;
  if (D.4697 == 42) goto <D.4698>; else goto <D.4699>;
  <D.4698>:
  cptr = s;
  skip_comment ();
  s = cptr;
  goto <D.3992>;
  <D.4699>:
  D.4696 = s + 1;
  D.4697 = *D.4696;
  if (D.4697 == 47) goto <D.4700>; else goto <D.4701>;
  <D.4700>:
  get_line ();
  line.26 = line;
  if (line.26 == 0B) goto <D.4702>; else goto <D.4703>;
  <D.4702>:
  D.4691 = -1;
  return D.4691;
  <D.4703>:
  s = cptr;
  goto <D.3992>;
  <D.4701>:
  <D.4002>:
  cptr = s;
  D.4692 = *s;
  D.4691 = (int) D.4692;
  return D.4691;
  <D.3992>:
  goto <D.4003>;
}


keyword ()
{
  char * cptr.27;
  char * cptr.28;
  char D.4707;
  const short unsigned int * * D.4708;
  const short unsigned int * D.4709;
  long unsigned int D.4710;
  long unsigned int D.4711;
  const short unsigned int * D.4712;
  short unsigned int D.4713;
  int D.4714;
  int D.4715;
  int D.4720;
  int c.31;
  int D.4725;
  const int iftmp.29;
  unsigned int __c.30;
  unsigned int D.4730;
  const __int32_t * * D.4733;
  const __int32_t * D.4734;
  long unsigned int D.4735;
  long unsigned int D.4736;
  const __int32_t * D.4737;
  long unsigned int D.4741;
  const __int32_t * D.4742;
  int D.4745;
  _Bool D.4747;
  _Bool D.4748;
  _Bool D.4749;
  int D.4021;
  int iftmp.32;
  int D.4020;
  const char[6] * D.4756;
  unsigned char D.4757;
  int D.4758;
  unsigned char D.4759;
  int D.4760;
  _Bool D.4761;
  _Bool D.4762;
  _Bool D.4763;
  const unsigned char * D.4766;
  unsigned char D.4767;
  int D.4768;
  const unsigned char * D.4769;
  unsigned char D.4770;
  int D.4771;
  _Bool D.4772;
  _Bool D.4773;
  const unsigned char * D.4776;
  unsigned char D.4777;
  int D.4778;
  const unsigned char * D.4779;
  unsigned char D.4780;
  int D.4781;
  _Bool D.4782;
  _Bool D.4783;
  const unsigned char * D.4786;
  unsigned char D.4787;
  int D.4788;
  const unsigned char * D.4789;
  unsigned char D.4790;
  int D.4791;
  char * cache.33;
  int D.4030;
  int iftmp.34;
  int D.4029;
  const char[5] * D.4798;
  unsigned char D.4799;
  int D.4800;
  unsigned char D.4801;
  int D.4802;
  _Bool D.4803;
  _Bool D.4804;
  _Bool D.4805;
  const unsigned char * D.4808;
  unsigned char D.4809;
  int D.4810;
  const unsigned char * D.4811;
  unsigned char D.4812;
  int D.4813;
  _Bool D.4814;
  _Bool D.4815;
  const unsigned char * D.4818;
  unsigned char D.4819;
  int D.4820;
  const unsigned char * D.4821;
  unsigned char D.4822;
  int D.4823;
  _Bool D.4824;
  _Bool D.4825;
  const unsigned char * D.4828;
  unsigned char D.4829;
  int D.4830;
  const unsigned char * D.4831;
  unsigned char D.4832;
  int D.4833;
  int D.4835;
  int D.4039;
  int iftmp.35;
  int D.4038;
  const char[5] * D.4839;
  unsigned char D.4840;
  int D.4841;
  unsigned char D.4842;
  int D.4843;
  _Bool D.4844;
  _Bool D.4845;
  _Bool D.4846;
  const unsigned char * D.4849;
  unsigned char D.4850;
  int D.4851;
  const unsigned char * D.4852;
  unsigned char D.4853;
  int D.4854;
  _Bool D.4855;
  _Bool D.4856;
  const unsigned char * D.4859;
  unsigned char D.4860;
  int D.4861;
  const unsigned char * D.4862;
  unsigned char D.4863;
  int D.4864;
  _Bool D.4865;
  _Bool D.4866;
  const unsigned char * D.4869;
  unsigned char D.4870;
  int D.4871;
  const unsigned char * D.4872;
  unsigned char D.4873;
  int D.4874;
  int D.4048;
  int iftmp.36;
  int D.4047;
  const char[5] * D.4881;
  unsigned char D.4882;
  int D.4883;
  unsigned char D.4884;
  int D.4885;
  _Bool D.4886;
  _Bool D.4887;
  _Bool D.4888;
  const unsigned char * D.4891;
  unsigned char D.4892;
  int D.4893;
  const unsigned char * D.4894;
  unsigned char D.4895;
  int D.4896;
  _Bool D.4897;
  _Bool D.4898;
  const unsigned char * D.4901;
  unsigned char D.4902;
  int D.4903;
  const unsigned char * D.4904;
  unsigned char D.4905;
  int D.4906;
  _Bool D.4907;
  _Bool D.4908;
  const unsigned char * D.4911;
  unsigned char D.4912;
  int D.4913;
  const unsigned char * D.4914;
  unsigned char D.4915;
  int D.4916;
  int D.4057;
  int iftmp.37;
  int D.4056;
  const char[6] * D.4923;
  unsigned char D.4924;
  int D.4925;
  unsigned char D.4926;
  int D.4927;
  _Bool D.4928;
  _Bool D.4929;
  _Bool D.4930;
  const unsigned char * D.4933;
  unsigned char D.4934;
  int D.4935;
  const unsigned char * D.4936;
  unsigned char D.4937;
  int D.4938;
  _Bool D.4939;
  _Bool D.4940;
  const unsigned char * D.4943;
  unsigned char D.4944;
  int D.4945;
  const unsigned char * D.4946;
  unsigned char D.4947;
  int D.4948;
  _Bool D.4949;
  _Bool D.4950;
  const unsigned char * D.4953;
  unsigned char D.4954;
  int D.4955;
  const unsigned char * D.4956;
  unsigned char D.4957;
  int D.4958;
  int D.4066;
  int iftmp.38;
  int D.4065;
  const char[9] * D.4967;
  unsigned char D.4968;
  int D.4969;
  unsigned char D.4970;
  int D.4971;
  _Bool D.4972;
  _Bool D.4973;
  _Bool D.4974;
  const unsigned char * D.4977;
  unsigned char D.4978;
  int D.4979;
  const unsigned char * D.4980;
  unsigned char D.4981;
  int D.4982;
  _Bool D.4983;
  _Bool D.4984;
  const unsigned char * D.4987;
  unsigned char D.4988;
  int D.4989;
  const unsigned char * D.4990;
  unsigned char D.4991;
  int D.4992;
  _Bool D.4993;
  _Bool D.4994;
  const unsigned char * D.4997;
  unsigned char D.4998;
  int D.4999;
  const unsigned char * D.5000;
  unsigned char D.5001;
  int D.5002;
  int D.4075;
  int iftmp.39;
  int D.4074;
  const char[7] * D.5008;
  unsigned char D.5009;
  int D.5010;
  unsigned char D.5011;
  int D.5012;
  _Bool D.5013;
  _Bool D.5014;
  _Bool D.5015;
  const unsigned char * D.5018;
  unsigned char D.5019;
  int D.5020;
  const unsigned char * D.5021;
  unsigned char D.5022;
  int D.5023;
  _Bool D.5024;
  _Bool D.5025;
  const unsigned char * D.5028;
  unsigned char D.5029;
  int D.5030;
  const unsigned char * D.5031;
  unsigned char D.5032;
  int D.5033;
  _Bool D.5034;
  _Bool D.5035;
  const unsigned char * D.5038;
  unsigned char D.5039;
  int D.5040;
  const unsigned char * D.5041;
  unsigned char D.5042;
  int D.5043;
  int D.4084;
  int iftmp.40;
  int D.4083;
  const char[6] * D.5048;
  unsigned char D.5049;
  int D.5050;
  unsigned char D.5051;
  int D.5052;
  _Bool D.5053;
  _Bool D.5054;
  _Bool D.5055;
  const unsigned char * D.5058;
  unsigned char D.5059;
  int D.5060;
  const unsigned char * D.5061;
  unsigned char D.5062;
  int D.5063;
  _Bool D.5064;
  _Bool D.5065;
  const unsigned char * D.5068;
  unsigned char D.5069;
  int D.5070;
  const unsigned char * D.5071;
  unsigned char D.5072;
  int D.5073;
  _Bool D.5074;
  _Bool D.5075;
  const unsigned char * D.5078;
  unsigned char D.5079;
  int D.5080;
  const unsigned char * D.5081;
  unsigned char D.5082;
  int D.5083;
  _Bool D.5090;
  _Bool D.5091;
  _Bool D.5092;
  char * line.41;
  int lineno.42;
  register int c;
  char * t_cptr;
  extern int syntax_error ();

  t_cptr = cptr;
  cptr.27 = cptr;
  cptr.28 = cptr.27 + 1;
  cptr = cptr.28;
  cptr.27 = cptr;
  D.4707 = *cptr.27;
  c = (int) D.4707;
  D.4708 = __ctype_b_loc ();
  D.4709 = *D.4708;
  D.4710 = (long unsigned int) c;
  D.4711 = D.4710 * 2;
  D.4712 = D.4709 + D.4711;
  D.4713 = *D.4712;
  D.4714 = (int) D.4713;
  D.4715 = D.4714 & 1024;
  if (D.4715 != 0) goto <D.4716>; else goto <D.4717>;
  <D.4716>:
  cinc = 0;
  <D.4012>:
  D.4708 = __ctype_b_loc ();
  D.4709 = *D.4708;
  D.4710 = (long unsigned int) c;
  D.4711 = D.4710 * 2;
  D.4712 = D.4709 + D.4711;
  D.4713 = *D.4712;
  D.4714 = (int) D.4713;
  D.4715 = D.4714 & 1024;
  if (D.4715 != 0) goto <D.4718>; else goto <D.4719>;
  <D.4718>:
  D.4708 = __ctype_b_loc ();
  D.4709 = *D.4708;
  D.4710 = (long unsigned int) c;
  D.4711 = D.4710 * 2;
  D.4712 = D.4709 + D.4711;
  D.4713 = *D.4712;
  D.4714 = (int) D.4713;
  D.4720 = D.4714 & 256;
  if (D.4720 != 0) goto <D.4721>; else goto <D.4722>;
  <D.4721>:
  {
    int __res;

    {
      if (1 != 0) goto <D.4723>; else goto <D.4724>;
      <D.4723>:
      D.4725 = __builtin_constant_p (c);
      if (D.4725 != 0) goto <D.4726>; else goto <D.4727>;
      <D.4726>:
      {
        int __c;

        __c = c;
        __c.30 = (unsigned int) __c;
        D.4730 = __c.30 + 128;
        if (D.4730 <= 383) goto <D.4731>; else goto <D.4732>;
        <D.4731>:
        D.4733 = __ctype_tolower_loc ();
        D.4734 = *D.4733;
        D.4735 = (long unsigned int) __c;
        D.4736 = D.4735 * 4;
        D.4737 = D.4734 + D.4736;
        iftmp.29 = *D.4737;
        goto <D.4738>;
        <D.4732>:
        iftmp.29 = __c;
        <D.4738>:
        __res = iftmp.29;
      }
      goto <D.4739>;
      <D.4727>:
      __res = tolower (c);
      <D.4739>:
      goto <D.4740>;
      <D.4724>:
      D.4733 = __ctype_tolower_loc ();
      D.4734 = *D.4733;
      D.4710 = (long unsigned int) c;
      D.4741 = D.4710 * 4;
      D.4742 = D.4734 + D.4741;
      __res = *D.4742;
      <D.4740>:
    }
    c.31 = __res;
  }
  c = c.31;
  <D.4722>:
  cachec (c);
  goto <D.4743>;
  <D.4719>:
  D.4708 = __ctype_b_loc ();
  D.4709 = *D.4708;
  D.4710 = (long unsigned int) c;
  D.4711 = D.4710 * 2;
  D.4712 = D.4709 + D.4711;
  D.4713 = *D.4712;
  D.4714 = (int) D.4713;
  D.4745 = D.4714 & 2048;
  if (D.4745 != 0) goto <D.4744>; else goto <D.4746>;
  <D.4746>:
  D.4747 = c == 95;
  D.4748 = c == 46;
  D.4749 = D.4747 | D.4748;
  if (D.4749 != 0) goto <D.4744>; else goto <D.4750>;
  <D.4750>:
  if (c == 36) goto <D.4744>; else goto <D.4011>;
  <D.4744>:
  cachec (c);
  <D.4743>:
  cptr.27 = cptr;
  cptr.28 = cptr.27 + 1;
  cptr = cptr.28;
  cptr.27 = cptr;
  D.4707 = *cptr.27;
  c = (int) D.4707;
  goto <D.4012>;
  <D.4011>:
  cachec (0);
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 5;
    if (__s2_len <= 3) goto <D.4754>; else goto <D.4755>;
    <D.4754>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = cache;
      D.4756 = "token";
      D.4757 = MEM[(const unsigned char *)D.4756];
      D.4758 = (int) D.4757;
      D.4759 = *__s2;
      D.4760 = (int) D.4759;
      __result = D.4758 - D.4760;
      {
        D.4761 = __s2_len != 0;
        D.4762 = __result == 0;
        D.4763 = D.4761 & D.4762;
        if (D.4763 != 0) goto <D.4764>; else goto <D.4765>;
        <D.4764>:
        D.4766 = &MEM[(void *)"token" + 1B];
        D.4767 = *D.4766;
        D.4768 = (int) D.4767;
        D.4769 = __s2 + 1;
        D.4770 = *D.4769;
        D.4771 = (int) D.4770;
        __result = D.4768 - D.4771;
        D.4772 = __s2_len > 1;
        D.4762 = __result == 0;
        D.4773 = D.4772 & D.4762;
        if (D.4773 != 0) goto <D.4774>; else goto <D.4775>;
        <D.4774>:
        D.4776 = &MEM[(void *)"token" + 2B];
        D.4777 = *D.4776;
        D.4778 = (int) D.4777;
        D.4779 = __s2 + 2;
        D.4780 = *D.4779;
        D.4781 = (int) D.4780;
        __result = D.4778 - D.4781;
        D.4782 = __s2_len > 2;
        D.4762 = __result == 0;
        D.4783 = D.4782 & D.4762;
        if (D.4783 != 0) goto <D.4784>; else goto <D.4785>;
        <D.4784>:
        D.4786 = &MEM[(void *)"token" + 3B];
        D.4787 = *D.4786;
        D.4788 = (int) D.4787;
        D.4789 = __s2 + 3;
        D.4790 = *D.4789;
        D.4791 = (int) D.4790;
        __result = D.4788 - D.4791;
        <D.4785>:
        <D.4775>:
        <D.4765>:
      }
      D.4020 = __result;
    }
    iftmp.32 = -D.4020;
    goto <D.4792>;
    <D.4755>:
    cache.33 = cache;
    iftmp.32 = __builtin_strcmp (cache.33, "token");
    <D.4792>:
    D.4021 = iftmp.32;
  }
  if (D.4021 == 0) goto <D.4751>; else goto <D.4794>;
  <D.4794>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 4;
    if (__s2_len <= 3) goto <D.4796>; else goto <D.4797>;
    <D.4796>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = cache;
      D.4798 = "term";
      D.4799 = MEM[(const unsigned char *)D.4798];
      D.4800 = (int) D.4799;
      D.4801 = *__s2;
      D.4802 = (int) D.4801;
      __result = D.4800 - D.4802;
      {
        D.4803 = __s2_len != 0;
        D.4804 = __result == 0;
        D.4805 = D.4803 & D.4804;
        if (D.4805 != 0) goto <D.4806>; else goto <D.4807>;
        <D.4806>:
        D.4808 = &MEM[(void *)"term" + 1B];
        D.4809 = *D.4808;
        D.4810 = (int) D.4809;
        D.4811 = __s2 + 1;
        D.4812 = *D.4811;
        D.4813 = (int) D.4812;
        __result = D.4810 - D.4813;
        D.4814 = __s2_len > 1;
        D.4804 = __result == 0;
        D.4815 = D.4814 & D.4804;
        if (D.4815 != 0) goto <D.4816>; else goto <D.4817>;
        <D.4816>:
        D.4818 = &MEM[(void *)"term" + 2B];
        D.4819 = *D.4818;
        D.4820 = (int) D.4819;
        D.4821 = __s2 + 2;
        D.4822 = *D.4821;
        D.4823 = (int) D.4822;
        __result = D.4820 - D.4823;
        D.4824 = __s2_len > 2;
        D.4804 = __result == 0;
        D.4825 = D.4824 & D.4804;
        if (D.4825 != 0) goto <D.4826>; else goto <D.4827>;
        <D.4826>:
        D.4828 = &MEM[(void *)"term" + 3B];
        D.4829 = *D.4828;
        D.4830 = (int) D.4829;
        D.4831 = __s2 + 3;
        D.4832 = *D.4831;
        D.4833 = (int) D.4832;
        __result = D.4830 - D.4833;
        <D.4827>:
        <D.4817>:
        <D.4807>:
      }
      D.4029 = __result;
    }
    iftmp.34 = -D.4029;
    goto <D.4834>;
    <D.4797>:
    cache.33 = cache;
    iftmp.34 = __builtin_strcmp (cache.33, "term");
    <D.4834>:
    D.4030 = iftmp.34;
  }
  if (D.4030 == 0) goto <D.4751>; else goto <D.4752>;
  <D.4751>:
  D.4835 = 0;
  return D.4835;
  <D.4752>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 4;
    if (__s2_len <= 3) goto <D.4837>; else goto <D.4838>;
    <D.4837>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = cache;
      D.4839 = "type";
      D.4840 = MEM[(const unsigned char *)D.4839];
      D.4841 = (int) D.4840;
      D.4842 = *__s2;
      D.4843 = (int) D.4842;
      __result = D.4841 - D.4843;
      {
        D.4844 = __s2_len != 0;
        D.4845 = __result == 0;
        D.4846 = D.4844 & D.4845;
        if (D.4846 != 0) goto <D.4847>; else goto <D.4848>;
        <D.4847>:
        D.4849 = &MEM[(void *)"type" + 1B];
        D.4850 = *D.4849;
        D.4851 = (int) D.4850;
        D.4852 = __s2 + 1;
        D.4853 = *D.4852;
        D.4854 = (int) D.4853;
        __result = D.4851 - D.4854;
        D.4855 = __s2_len > 1;
        D.4845 = __result == 0;
        D.4856 = D.4855 & D.4845;
        if (D.4856 != 0) goto <D.4857>; else goto <D.4858>;
        <D.4857>:
        D.4859 = &MEM[(void *)"type" + 2B];
        D.4860 = *D.4859;
        D.4861 = (int) D.4860;
        D.4862 = __s2 + 2;
        D.4863 = *D.4862;
        D.4864 = (int) D.4863;
        __result = D.4861 - D.4864;
        D.4865 = __s2_len > 2;
        D.4845 = __result == 0;
        D.4866 = D.4865 & D.4845;
        if (D.4866 != 0) goto <D.4867>; else goto <D.4868>;
        <D.4867>:
        D.4869 = &MEM[(void *)"type" + 3B];
        D.4870 = *D.4869;
        D.4871 = (int) D.4870;
        D.4872 = __s2 + 3;
        D.4873 = *D.4872;
        D.4874 = (int) D.4873;
        __result = D.4871 - D.4874;
        <D.4868>:
        <D.4858>:
        <D.4848>:
      }
      D.4038 = __result;
    }
    iftmp.35 = -D.4038;
    goto <D.4875>;
    <D.4838>:
    cache.33 = cache;
    iftmp.35 = __builtin_strcmp (cache.33, "type");
    <D.4875>:
    D.4039 = iftmp.35;
  }
  if (D.4039 == 0) goto <D.4876>; else goto <D.4877>;
  <D.4876>:
  D.4835 = 6;
  return D.4835;
  <D.4877>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 4;
    if (__s2_len <= 3) goto <D.4879>; else goto <D.4880>;
    <D.4879>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = cache;
      D.4881 = "left";
      D.4882 = MEM[(const unsigned char *)D.4881];
      D.4883 = (int) D.4882;
      D.4884 = *__s2;
      D.4885 = (int) D.4884;
      __result = D.4883 - D.4885;
      {
        D.4886 = __s2_len != 0;
        D.4887 = __result == 0;
        D.4888 = D.4886 & D.4887;
        if (D.4888 != 0) goto <D.4889>; else goto <D.4890>;
        <D.4889>:
        D.4891 = &MEM[(void *)"left" + 1B];
        D.4892 = *D.4891;
        D.4893 = (int) D.4892;
        D.4894 = __s2 + 1;
        D.4895 = *D.4894;
        D.4896 = (int) D.4895;
        __result = D.4893 - D.4896;
        D.4897 = __s2_len > 1;
        D.4887 = __result == 0;
        D.4898 = D.4897 & D.4887;
        if (D.4898 != 0) goto <D.4899>; else goto <D.4900>;
        <D.4899>:
        D.4901 = &MEM[(void *)"left" + 2B];
        D.4902 = *D.4901;
        D.4903 = (int) D.4902;
        D.4904 = __s2 + 2;
        D.4905 = *D.4904;
        D.4906 = (int) D.4905;
        __result = D.4903 - D.4906;
        D.4907 = __s2_len > 2;
        D.4887 = __result == 0;
        D.4908 = D.4907 & D.4887;
        if (D.4908 != 0) goto <D.4909>; else goto <D.4910>;
        <D.4909>:
        D.4911 = &MEM[(void *)"left" + 3B];
        D.4912 = *D.4911;
        D.4913 = (int) D.4912;
        D.4914 = __s2 + 3;
        D.4915 = *D.4914;
        D.4916 = (int) D.4915;
        __result = D.4913 - D.4916;
        <D.4910>:
        <D.4900>:
        <D.4890>:
      }
      D.4047 = __result;
    }
    iftmp.36 = -D.4047;
    goto <D.4917>;
    <D.4880>:
    cache.33 = cache;
    iftmp.36 = __builtin_strcmp (cache.33, "left");
    <D.4917>:
    D.4048 = iftmp.36;
  }
  if (D.4048 == 0) goto <D.4918>; else goto <D.4919>;
  <D.4918>:
  D.4835 = 1;
  return D.4835;
  <D.4919>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 5;
    if (__s2_len <= 3) goto <D.4921>; else goto <D.4922>;
    <D.4921>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = cache;
      D.4923 = "right";
      D.4924 = MEM[(const unsigned char *)D.4923];
      D.4925 = (int) D.4924;
      D.4926 = *__s2;
      D.4927 = (int) D.4926;
      __result = D.4925 - D.4927;
      {
        D.4928 = __s2_len != 0;
        D.4929 = __result == 0;
        D.4930 = D.4928 & D.4929;
        if (D.4930 != 0) goto <D.4931>; else goto <D.4932>;
        <D.4931>:
        D.4933 = &MEM[(void *)"right" + 1B];
        D.4934 = *D.4933;
        D.4935 = (int) D.4934;
        D.4936 = __s2 + 1;
        D.4937 = *D.4936;
        D.4938 = (int) D.4937;
        __result = D.4935 - D.4938;
        D.4939 = __s2_len > 1;
        D.4929 = __result == 0;
        D.4940 = D.4939 & D.4929;
        if (D.4940 != 0) goto <D.4941>; else goto <D.4942>;
        <D.4941>:
        D.4943 = &MEM[(void *)"right" + 2B];
        D.4944 = *D.4943;
        D.4945 = (int) D.4944;
        D.4946 = __s2 + 2;
        D.4947 = *D.4946;
        D.4948 = (int) D.4947;
        __result = D.4945 - D.4948;
        D.4949 = __s2_len > 2;
        D.4929 = __result == 0;
        D.4950 = D.4949 & D.4929;
        if (D.4950 != 0) goto <D.4951>; else goto <D.4952>;
        <D.4951>:
        D.4953 = &MEM[(void *)"right" + 3B];
        D.4954 = *D.4953;
        D.4955 = (int) D.4954;
        D.4956 = __s2 + 3;
        D.4957 = *D.4956;
        D.4958 = (int) D.4957;
        __result = D.4955 - D.4958;
        <D.4952>:
        <D.4942>:
        <D.4932>:
      }
      D.4056 = __result;
    }
    iftmp.37 = -D.4056;
    goto <D.4959>;
    <D.4922>:
    cache.33 = cache;
    iftmp.37 = __builtin_strcmp (cache.33, "right");
    <D.4959>:
    D.4057 = iftmp.37;
  }
  if (D.4057 == 0) goto <D.4960>; else goto <D.4961>;
  <D.4960>:
  D.4835 = 2;
  return D.4835;
  <D.4961>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 8;
    if (__s2_len <= 3) goto <D.4965>; else goto <D.4966>;
    <D.4965>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = cache;
      D.4967 = "nonassoc";
      D.4968 = MEM[(const unsigned char *)D.4967];
      D.4969 = (int) D.4968;
      D.4970 = *__s2;
      D.4971 = (int) D.4970;
      __result = D.4969 - D.4971;
      {
        D.4972 = __s2_len != 0;
        D.4973 = __result == 0;
        D.4974 = D.4972 & D.4973;
        if (D.4974 != 0) goto <D.4975>; else goto <D.4976>;
        <D.4975>:
        D.4977 = &MEM[(void *)"nonassoc" + 1B];
        D.4978 = *D.4977;
        D.4979 = (int) D.4978;
        D.4980 = __s2 + 1;
        D.4981 = *D.4980;
        D.4982 = (int) D.4981;
        __result = D.4979 - D.4982;
        D.4983 = __s2_len > 1;
        D.4973 = __result == 0;
        D.4984 = D.4983 & D.4973;
        if (D.4984 != 0) goto <D.4985>; else goto <D.4986>;
        <D.4985>:
        D.4987 = &MEM[(void *)"nonassoc" + 2B];
        D.4988 = *D.4987;
        D.4989 = (int) D.4988;
        D.4990 = __s2 + 2;
        D.4991 = *D.4990;
        D.4992 = (int) D.4991;
        __result = D.4989 - D.4992;
        D.4993 = __s2_len > 2;
        D.4973 = __result == 0;
        D.4994 = D.4993 & D.4973;
        if (D.4994 != 0) goto <D.4995>; else goto <D.4996>;
        <D.4995>:
        D.4997 = &MEM[(void *)"nonassoc" + 3B];
        D.4998 = *D.4997;
        D.4999 = (int) D.4998;
        D.5000 = __s2 + 3;
        D.5001 = *D.5000;
        D.5002 = (int) D.5001;
        __result = D.4999 - D.5002;
        <D.4996>:
        <D.4986>:
        <D.4976>:
      }
      D.4065 = __result;
    }
    iftmp.38 = -D.4065;
    goto <D.5003>;
    <D.4966>:
    cache.33 = cache;
    iftmp.38 = __builtin_strcmp (cache.33, "nonassoc");
    <D.5003>:
    D.4066 = iftmp.38;
  }
  if (D.4066 == 0) goto <D.4962>; else goto <D.5004>;
  <D.5004>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 6;
    if (__s2_len <= 3) goto <D.5006>; else goto <D.5007>;
    <D.5006>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = cache;
      D.5008 = "binary";
      D.5009 = MEM[(const unsigned char *)D.5008];
      D.5010 = (int) D.5009;
      D.5011 = *__s2;
      D.5012 = (int) D.5011;
      __result = D.5010 - D.5012;
      {
        D.5013 = __s2_len != 0;
        D.5014 = __result == 0;
        D.5015 = D.5013 & D.5014;
        if (D.5015 != 0) goto <D.5016>; else goto <D.5017>;
        <D.5016>:
        D.5018 = &MEM[(void *)"binary" + 1B];
        D.5019 = *D.5018;
        D.5020 = (int) D.5019;
        D.5021 = __s2 + 1;
        D.5022 = *D.5021;
        D.5023 = (int) D.5022;
        __result = D.5020 - D.5023;
        D.5024 = __s2_len > 1;
        D.5014 = __result == 0;
        D.5025 = D.5024 & D.5014;
        if (D.5025 != 0) goto <D.5026>; else goto <D.5027>;
        <D.5026>:
        D.5028 = &MEM[(void *)"binary" + 2B];
        D.5029 = *D.5028;
        D.5030 = (int) D.5029;
        D.5031 = __s2 + 2;
        D.5032 = *D.5031;
        D.5033 = (int) D.5032;
        __result = D.5030 - D.5033;
        D.5034 = __s2_len > 2;
        D.5014 = __result == 0;
        D.5035 = D.5034 & D.5014;
        if (D.5035 != 0) goto <D.5036>; else goto <D.5037>;
        <D.5036>:
        D.5038 = &MEM[(void *)"binary" + 3B];
        D.5039 = *D.5038;
        D.5040 = (int) D.5039;
        D.5041 = __s2 + 3;
        D.5042 = *D.5041;
        D.5043 = (int) D.5042;
        __result = D.5040 - D.5043;
        <D.5037>:
        <D.5027>:
        <D.5017>:
      }
      D.4074 = __result;
    }
    iftmp.39 = -D.4074;
    goto <D.5044>;
    <D.5007>:
    cache.33 = cache;
    iftmp.39 = __builtin_strcmp (cache.33, "binary");
    <D.5044>:
    D.4075 = iftmp.39;
  }
  if (D.4075 == 0) goto <D.4962>; else goto <D.4963>;
  <D.4962>:
  D.4835 = 3;
  return D.4835;
  <D.4963>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 5;
    if (__s2_len <= 3) goto <D.5046>; else goto <D.5047>;
    <D.5046>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = cache;
      D.5048 = "start";
      D.5049 = MEM[(const unsigned char *)D.5048];
      D.5050 = (int) D.5049;
      D.5051 = *__s2;
      D.5052 = (int) D.5051;
      __result = D.5050 - D.5052;
      {
        D.5053 = __s2_len != 0;
        D.5054 = __result == 0;
        D.5055 = D.5053 & D.5054;
        if (D.5055 != 0) goto <D.5056>; else goto <D.5057>;
        <D.5056>:
        D.5058 = &MEM[(void *)"start" + 1B];
        D.5059 = *D.5058;
        D.5060 = (int) D.5059;
        D.5061 = __s2 + 1;
        D.5062 = *D.5061;
        D.5063 = (int) D.5062;
        __result = D.5060 - D.5063;
        D.5064 = __s2_len > 1;
        D.5054 = __result == 0;
        D.5065 = D.5064 & D.5054;
        if (D.5065 != 0) goto <D.5066>; else goto <D.5067>;
        <D.5066>:
        D.5068 = &MEM[(void *)"start" + 2B];
        D.5069 = *D.5068;
        D.5070 = (int) D.5069;
        D.5071 = __s2 + 2;
        D.5072 = *D.5071;
        D.5073 = (int) D.5072;
        __result = D.5070 - D.5073;
        D.5074 = __s2_len > 2;
        D.5054 = __result == 0;
        D.5075 = D.5074 & D.5054;
        if (D.5075 != 0) goto <D.5076>; else goto <D.5077>;
        <D.5076>:
        D.5078 = &MEM[(void *)"start" + 3B];
        D.5079 = *D.5078;
        D.5080 = (int) D.5079;
        D.5081 = __s2 + 3;
        D.5082 = *D.5081;
        D.5083 = (int) D.5082;
        __result = D.5080 - D.5083;
        <D.5077>:
        <D.5067>:
        <D.5057>:
      }
      D.4083 = __result;
    }
    iftmp.40 = -D.4083;
    goto <D.5084>;
    <D.5047>:
    cache.33 = cache;
    iftmp.40 = __builtin_strcmp (cache.33, "start");
    <D.5084>:
    D.4084 = iftmp.40;
  }
  if (D.4084 == 0) goto <D.5085>; else goto <D.5086>;
  <D.5085>:
  D.4835 = 7;
  return D.4835;
  <D.5086>:
  goto <D.5087>;
  <D.4717>:
  cptr.27 = cptr;
  cptr.28 = cptr.27 + 1;
  cptr = cptr.28;
  if (c == 123) goto <D.5088>; else goto <D.5089>;
  <D.5088>:
  D.4835 = 5;
  return D.4835;
  <D.5089>:
  D.5090 = c == 37;
  D.5091 = c == 92;
  D.5092 = D.5090 | D.5091;
  if (D.5092 != 0) goto <D.5093>; else goto <D.5094>;
  <D.5093>:
  D.4835 = 4;
  return D.4835;
  <D.5094>:
  if (c == 60) goto <D.5095>; else goto <D.5096>;
  <D.5095>:
  D.4835 = 1;
  return D.4835;
  <D.5096>:
  if (c == 62) goto <D.5097>; else goto <D.5098>;
  <D.5097>:
  D.4835 = 2;
  return D.4835;
  <D.5098>:
  if (c == 48) goto <D.5099>; else goto <D.5100>;
  <D.5099>:
  D.4835 = 0;
  return D.4835;
  <D.5100>:
  if (c == 50) goto <D.5101>; else goto <D.5102>;
  <D.5101>:
  D.4835 = 3;
  return D.4835;
  <D.5102>:
  <D.5087>:
  line.41 = line;
  lineno.42 = lineno;
  syntax_error (lineno.42, line.41, t_cptr);
}


tolower (int __c)
{
  int D.5106;
  int iftmp.43;
  unsigned int __c.44;
  unsigned int D.5109;
  const __int32_t * * D.5112;
  const __int32_t * D.5113;
  long unsigned int D.5114;
  long unsigned int D.5115;
  const __int32_t * D.5116;

  __c.44 = (unsigned int) __c;
  D.5109 = __c.44 + 128;
  if (D.5109 <= 383) goto <D.5110>; else goto <D.5111>;
  <D.5110>:
  D.5112 = __ctype_tolower_loc ();
  D.5113 = *D.5112;
  D.5114 = (long unsigned int) __c;
  D.5115 = D.5114 * 4;
  D.5116 = D.5113 + D.5115;
  iftmp.43 = *D.5116;
  goto <D.5117>;
  <D.5111>:
  iftmp.43 = __c;
  <D.5117>:
  D.5106 = iftmp.43;
  return D.5106;
}


copy_text (struct FILE * f)
{
  char * cptr.45;
  long int cptr.46;
  char * line.47;
  long int line.48;
  long int D.5123;
  sizetype D.5124;
  sizetype D.5125;
  char D.5126;
  char * input_file_name.49;
  int lineno.50;
  char * line_format.51;
  char * cptr.52;
  char * cptr.53;
  char D.5136;
  sizetype D.5138;
  char * cptr.54;
  char * cptr.55;
  char D.5141;
  char * cptr.56;
  char * cptr.57;
  char D.5150;
  char * cptr.58;
  char * cptr.59;
  char * cptr.60;
  char D.5162;
  register int c;
  int quote;
  int need_newline;
  int t_lineno;
  char * t_line;
  char * t_cptr;
  void loop = <<< error >>>;
  void next_line = <<< error >>>;

  need_newline = 0;
  t_lineno = lineno;
  t_line = dup_line ();
  cptr.45 = cptr;
  cptr.46 = (long int) cptr.45;
  line.47 = line;
  line.48 = (long int) line.47;
  D.5123 = cptr.46 - line.48;
  D.5124 = (sizetype) D.5123;
  D.5125 = D.5124 + 18446744073709551614;
  t_cptr = t_line + D.5125;
  cptr.45 = cptr;
  D.5126 = *cptr.45;
  if (D.5126 == 10) goto <D.5127>; else goto <D.5128>;
  <D.5127>:
  {
    extern int unterminated_text ();

    get_line ();
    line.47 = line;
    if (line.47 == 0B) goto <D.5129>; else goto <D.5130>;
    <D.5129>:
    unterminated_text (t_lineno, t_line, t_cptr);
    <D.5130>:
  }
  <D.5128>:
  input_file_name.49 = input_file_name;
  lineno.50 = lineno;
  line_format.51 = line_format;
  fprintf (f, line_format.51, lineno.50, input_file_name.49);
  loop:
  cptr.45 = cptr;
  cptr.52 = cptr.45;
  cptr.53 = cptr.52 + 1;
  cptr = cptr.53;
  D.5136 = *cptr.52;
  c = (int) D.5136;
  switch (c) <default: <D.4119>, case 10: <D.4099>, case 34: <D.4102>, case 37: <D.4117>, case 39: <D.4101>, case 47: <D.4109>, case 92: <D.4118>>
  {
    extern int unterminated_text ();

    <D.4099>:
    next_line:
    _IO_putc (10, f);
    need_newline = 0;
    get_line ();
    line.47 = line;
    if (line.47 != 0B) goto loop; else goto <D.5137>;
    <D.5137>:
    unterminated_text (t_lineno, t_line, t_cptr);
    <D.4101>:
    <D.4102>:
    {
      int s_lineno;
      char * s_line;
      char * s_cptr;

      s_lineno = lineno;
      s_line = dup_line ();
      cptr.45 = cptr;
      cptr.46 = (long int) cptr.45;
      line.47 = line;
      line.48 = (long int) line.47;
      D.5123 = cptr.46 - line.48;
      D.5124 = (sizetype) D.5123;
      D.5138 = D.5124 + 18446744073709551615;
      s_cptr = s_line + D.5138;
      quote = c;
      _IO_putc (c, f);
      <D.4108>:
      {
        extern int unterminated_string ();

        cptr.45 = cptr;
        cptr.54 = cptr.45;
        cptr.55 = cptr.54 + 1;
        cptr = cptr.55;
        D.5141 = *cptr.54;
        c = (int) D.5141;
        _IO_putc (c, f);
        if (c == quote) goto <D.5142>; else goto <D.5143>;
        <D.5142>:
        need_newline = 1;
        free (s_line);
        goto loop;
        <D.5143>:
        if (c == 10) goto <D.5144>; else goto <D.5145>;
        <D.5144>:
        unterminated_string (s_lineno, s_line, s_cptr);
        <D.5145>:
        if (c == 92) goto <D.5146>; else goto <D.5147>;
        <D.5146>:
        cptr.45 = cptr;
        cptr.56 = cptr.45;
        cptr.57 = cptr.56 + 1;
        cptr = cptr.57;
        D.5150 = *cptr.56;
        c = (int) D.5150;
        _IO_putc (c, f);
        if (c == 10) goto <D.5151>; else goto <D.5152>;
        <D.5151>:
        get_line ();
        line.47 = line;
        if (line.47 == 0B) goto <D.5153>; else goto <D.5154>;
        <D.5153>:
        unterminated_string (s_lineno, s_line, s_cptr);
        <D.5154>:
        <D.5152>:
        <D.5147>:
      }
      goto <D.4108>;
    }
    <D.4109>:
    _IO_putc (c, f);
    need_newline = 1;
    cptr.45 = cptr;
    D.5126 = *cptr.45;
    c = (int) D.5126;
    if (c == 47) goto <D.5155>; else goto <D.5156>;
    <D.5155>:
    <D.4110>:
    _IO_putc (c, f);
    cptr.45 = cptr;
    cptr.58 = cptr.45 + 1;
    cptr = cptr.58;
    cptr.45 = cptr;
    D.5126 = *cptr.45;
    c = (int) D.5126;
    if (c != 10) goto <D.4110>; else goto <D.4111>;
    <D.4111>:
    goto next_line;
    <D.5156>:
    if (c == 42) goto <D.5158>; else goto <D.5159>;
    <D.5158>:
    {
      int c_lineno;
      char * c_line;
      char * c_cptr;

      c_lineno = lineno;
      c_line = dup_line ();
      cptr.45 = cptr;
      cptr.46 = (long int) cptr.45;
      line.47 = line;
      line.48 = (long int) line.47;
      D.5123 = cptr.46 - line.48;
      D.5124 = (sizetype) D.5123;
      D.5138 = D.5124 + 18446744073709551615;
      c_cptr = c_line + D.5138;
      _IO_putc (42, f);
      cptr.45 = cptr;
      cptr.58 = cptr.45 + 1;
      cptr = cptr.58;
      <D.4116>:
      cptr.45 = cptr;
      cptr.59 = cptr.45;
      cptr.60 = cptr.59 + 1;
      cptr = cptr.60;
      D.5162 = *cptr.59;
      c = (int) D.5162;
      _IO_putc (c, f);
      if (c == 42) goto <D.5163>; else goto <D.5164>;
      <D.5163>:
      cptr.45 = cptr;
      D.5126 = *cptr.45;
      if (D.5126 == 47) goto <D.5165>; else goto <D.5166>;
      <D.5165>:
      _IO_putc (47, f);
      cptr.45 = cptr;
      cptr.58 = cptr.45 + 1;
      cptr = cptr.58;
      free (c_line);
      goto loop;
      <D.5166>:
      <D.5164>:
      if (c == 10) goto <D.5167>; else goto <D.5168>;
      <D.5167>:
      {
        extern int unterminated_comment ();

        get_line ();
        line.47 = line;
        if (line.47 == 0B) goto <D.5169>; else goto <D.5170>;
        <D.5169>:
        unterminated_comment (c_lineno, c_line, c_cptr);
        <D.5170>:
      }
      <D.5168>:
      goto <D.4116>;
    }
    <D.5159>:
    need_newline = 1;
    goto loop;
    <D.4117>:
    <D.4118>:
    cptr.45 = cptr;
    D.5126 = *cptr.45;
    if (D.5126 == 125) goto <D.5171>; else goto <D.5172>;
    <D.5171>:
    if (need_newline != 0) goto <D.5173>; else goto <D.5174>;
    <D.5173>:
    _IO_putc (10, f);
    <D.5174>:
    cptr.45 = cptr;
    cptr.58 = cptr.45 + 1;
    cptr = cptr.58;
    free (t_line);
    return;
    <D.5172>:
    <D.4119>:
    _IO_putc (c, f);
    need_newline = 1;
    goto loop;
  }
}


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

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


hexval (int c)
{
  unsigned int c.61;
  unsigned int D.5179;
  int D.5182;
  unsigned int D.5183;
  unsigned int D.5186;

  c.61 = (unsigned int) c;
  D.5179 = c.61 + 4294967248;
  if (D.5179 <= 9) goto <D.5180>; else goto <D.5181>;
  <D.5180>:
  D.5182 = c + -48;
  return D.5182;
  <D.5181>:
  c.61 = (unsigned int) c;
  D.5183 = c.61 + 4294967231;
  if (D.5183 <= 5) goto <D.5184>; else goto <D.5185>;
  <D.5184>:
  D.5182 = c + -55;
  return D.5182;
  <D.5185>:
  c.61 = (unsigned int) c;
  D.5186 = c.61 + 4294967199;
  if (D.5186 <= 5) goto <D.5187>; else goto <D.5188>;
  <D.5187>:
  D.5182 = c + -87;
  return D.5182;
  <D.5188>:
  D.5182 = -1;
  return D.5182;
}


get_literal ()
{
  char * cptr.62;
  long int cptr.63;
  char * line.64;
  long int line.65;
  long int D.5194;
  sizetype D.5195;
  char * cptr.66;
  char * cptr.67;
  char D.5198;
  char * cptr.68;
  char * cptr.69;
  char D.5201;
  char * cptr.70;
  char * cptr.71;
  char D.5209;
  char D.5212;
  unsigned int c.72;
  unsigned int D.5214;
  int D.5217;
  int D.5218;
  char * cptr.73;
  char * cptr.74;
  char * cptr.75;
  char D.5226;
  unsigned int n.76;
  unsigned int i.77;
  int D.5232;
  unsigned int n.78;
  long unsigned int D.5237;
  sizetype D.5240;
  char * D.5241;
  char * cache.79;
  char * D.5243;
  char D.5244;
  unsigned char * D.5248;
  unsigned char D.5249;
  char D.5254;
  int D.5255;
  const short unsigned int * * D.5256;
  const short unsigned int * D.5257;
  long unsigned int D.5258;
  long unsigned int D.5259;
  const short unsigned int * D.5260;
  short unsigned int D.5261;
  int D.5262;
  int D.5263;
  int D.5267;
  int D.5268;
  int D.5269;
  int D.5270;
  int D.5271;
  int D.5272;
  int D.5273;
  int D.5274;
  short int D.5280;
  unsigned char D.5283;
  short int D.5284;
  struct bucket * D.5285;
  register int c;
  register int quote;
  register int i;
  register int n;
  register char * s;
  register struct bucket * bp;
  int s_lineno;
  char * s_line;
  char * s_cptr;
  extern int no_space ();

  s_lineno = lineno;
  s_line = dup_line ();
  cptr.62 = cptr;
  cptr.63 = (long int) cptr.62;
  line.64 = line;
  line.65 = (long int) line.64;
  D.5194 = cptr.63 - line.65;
  D.5195 = (sizetype) D.5194;
  s_cptr = s_line + D.5195;
  cptr.62 = cptr;
  cptr.66 = cptr.62;
  cptr.67 = cptr.66 + 1;
  cptr = cptr.67;
  D.5198 = *cptr.66;
  quote = (int) D.5198;
  cinc = 0;
  <D.4161>:
  {
    extern int unterminated_string ();

    cptr.62 = cptr;
    cptr.68 = cptr.62;
    cptr.69 = cptr.68 + 1;
    cptr = cptr.69;
    D.5201 = *cptr.68;
    c = (int) D.5201;
    if (c == quote) goto <D.4135>; else goto <D.5202>;
    <D.5202>:
    if (c == 10) goto <D.5203>; else goto <D.5204>;
    <D.5203>:
    unterminated_string (s_lineno, s_line, s_cptr);
    <D.5204>:
    if (c == 92) goto <D.5205>; else goto <D.5206>;
    <D.5205>:
    {
      char * c_cptr;

      cptr.62 = cptr;
      c_cptr = cptr.62 + 18446744073709551615;
      cptr.62 = cptr;
      cptr.70 = cptr.62;
      cptr.71 = cptr.70 + 1;
      cptr = cptr.71;
      D.5209 = *cptr.70;
      c = (int) D.5209;
      switch (c) <default: <D.5235>, case 10: <D.4137>, case 48: <D.4139>, case 49: <D.4140>, case 50: <D.4141>, case 51: <D.4142>, case 52: <D.4143>, case 53: <D.4144>, case 54: <D.4145>, case 55: <D.4146>, case 97: <D.4152>, case 98: <D.4153>, case 102: <D.4154>, case 110: <D.4155>, case 114: <D.4156>, case 116: <D.4157>, case 118: <D.4158>, case 120: <D.4149>>
      {
        extern int illegal_character ();

        <D.4137>:
        get_line ();
        line.64 = line;
        if (line.64 == 0B) goto <D.5210>; else goto <D.5211>;
        <D.5210>:
        unterminated_string (s_lineno, s_line, s_cptr);
        <D.5211>:
        // predicted unlikely by continue predictor.
        goto <D.4138>;
        <D.4139>:
        <D.4140>:
        <D.4141>:
        <D.4142>:
        <D.4143>:
        <D.4144>:
        <D.4145>:
        <D.4146>:
        n = c + -48;
        cptr.62 = cptr;
        D.5212 = *cptr.62;
        c = (int) D.5212;
        c.72 = (unsigned int) c;
        D.5214 = c.72 + 4294967248;
        if (D.5214 <= 7) goto <D.5215>; else goto <D.5216>;
        <D.5215>:
        D.5217 = n << 3;
        D.5218 = c + -48;
        n = D.5217 + D.5218;
        cptr.62 = cptr;
        cptr.73 = cptr.62 + 1;
        cptr = cptr.73;
        cptr.62 = cptr;
        D.5212 = *cptr.62;
        c = (int) D.5212;
        c.72 = (unsigned int) c;
        D.5214 = c.72 + 4294967248;
        if (D.5214 <= 7) goto <D.5220>; else goto <D.5221>;
        <D.5220>:
        D.5217 = n << 3;
        D.5218 = c + -48;
        n = D.5217 + D.5218;
        cptr.62 = cptr;
        cptr.73 = cptr.62 + 1;
        cptr = cptr.73;
        <D.5221>:
        <D.5216>:
        if (n > 255) goto <D.5222>; else goto <D.5223>;
        <D.5222>:
        illegal_character (c_cptr);
        <D.5223>:
        c = n;
        goto <D.4148>;
        <D.4149>:
        cptr.62 = cptr;
        cptr.74 = cptr.62;
        cptr.75 = cptr.74 + 1;
        cptr = cptr.75;
        D.5226 = *cptr.74;
        c = (int) D.5226;
        n = hexval (c);
        n.76 = (unsigned int) n;
        if (n.76 > 15) goto <D.5228>; else goto <D.5229>;
        <D.5228>:
        illegal_character (c_cptr);
        <D.5229>:
        <D.4151>:
        cptr.62 = cptr;
        D.5212 = *cptr.62;
        c = (int) D.5212;
        i = hexval (c);
        i.77 = (unsigned int) i;
        if (i.77 > 15) goto <D.4150>; else goto <D.5231>;
        <D.5231>:
        cptr.62 = cptr;
        cptr.73 = cptr.62 + 1;
        cptr = cptr.73;
        D.5232 = n << 4;
        n = D.5232 + i;
        if (n > 255) goto <D.5233>; else goto <D.5234>;
        <D.5233>:
        illegal_character (c_cptr);
        <D.5234>:
        goto <D.4151>;
        <D.4150>:
        c = n;
        goto <D.4148>;
        <D.4152>:
        c = 7;
        goto <D.4148>;
        <D.4153>:
        c = 8;
        goto <D.4148>;
        <D.4154>:
        c = 12;
        goto <D.4148>;
        <D.4155>:
        c = 10;
        goto <D.4148>;
        <D.4156>:
        c = 13;
        goto <D.4148>;
        <D.4157>:
        c = 9;
        goto <D.4148>;
        <D.4158>:
        c = 11;
        goto <D.4148>;
      }
      <D.5235>:
      <D.4148>:
    }
    <D.5206>:
    cachec (c);
  }
  <D.4138>:
  goto <D.4161>;
  <D.4135>:
  free (s_line);
  n = cinc;
  n.78 = (unsigned int) n;
  D.5237 = (long unsigned int) n.78;
  s = malloc (D.5237);
  if (s == 0B) goto <D.5238>; else goto <D.5239>;
  <D.5238>:
  no_space ();
  <D.5239>:
  i = 0;
  goto <D.4163>;
  <D.4162>:
  D.5240 = (sizetype) i;
  D.5241 = s + D.5240;
  cache.79 = cache;
  D.5240 = (sizetype) i;
  D.5243 = cache.79 + D.5240;
  D.5244 = *D.5243;
  *D.5241 = D.5244;
  i = i + 1;
  <D.4163>:
  if (i < n) goto <D.4162>; else goto <D.4164>;
  <D.4164>:
  cinc = 0;
  if (n == 1) goto <D.5245>; else goto <D.5246>;
  <D.5245>:
  cachec (39);
  goto <D.5247>;
  <D.5246>:
  cachec (34);
  <D.5247>:
  i = 0;
  goto <D.4175>;
  <D.4174>:
  D.5240 = (sizetype) i;
  D.5248 = s + D.5240;
  D.5249 = *D.5248;
  c = (int) D.5249;
  if (c == 92) goto <D.5250>; else goto <D.5253>;
  <D.5253>:
  cache.79 = cache;
  D.5254 = *cache.79;
  D.5255 = (int) D.5254;
  if (D.5255 == c) goto <D.5250>; else goto <D.5251>;
  <D.5250>:
  cachec (92);
  cachec (c);
  goto <D.5252>;
  <D.5251>:
  D.5256 = __ctype_b_loc ();
  D.5257 = *D.5256;
  D.5258 = (long unsigned int) c;
  D.5259 = D.5258 * 2;
  D.5260 = D.5257 + D.5259;
  D.5261 = *D.5260;
  D.5262 = (int) D.5261;
  D.5263 = D.5262 & 16384;
  if (D.5263 != 0) goto <D.5264>; else goto <D.5265>;
  <D.5264>:
  cachec (c);
  goto <D.5266>;
  <D.5265>:
  cachec (92);
  switch (c) <default: <D.4173>, case 7: <D.4165>, case 8: <D.4167>, case 9: <D.4171>, case 10: <D.4169>, case 11: <D.4172>, case 12: <D.4168>, case 13: <D.4170>>
  <D.4165>:
  cachec (97);
  goto <D.4166>;
  <D.4167>:
  cachec (98);
  goto <D.4166>;
  <D.4168>:
  cachec (102);
  goto <D.4166>;
  <D.4169>:
  cachec (110);
  goto <D.4166>;
  <D.4170>:
  cachec (114);
  goto <D.4166>;
  <D.4171>:
  cachec (116);
  goto <D.4166>;
  <D.4172>:
  cachec (118);
  goto <D.4166>;
  <D.4173>:
  D.5267 = c >> 6;
  D.5268 = D.5267 & 7;
  D.5269 = D.5268 + 48;
  cachec (D.5269);
  D.5270 = c >> 3;
  D.5271 = D.5270 & 7;
  D.5272 = D.5271 + 48;
  cachec (D.5272);
  D.5273 = c & 7;
  D.5274 = D.5273 + 48;
  cachec (D.5274);
  goto <D.4166>;
  <D.4166>:
  <D.5266>:
  <D.5252>:
  i = i + 1;
  <D.4175>:
  if (i < n) goto <D.4174>; else goto <D.4176>;
  <D.4176>:
  if (n == 1) goto <D.5275>; else goto <D.5276>;
  <D.5275>:
  cachec (39);
  goto <D.5277>;
  <D.5276>:
  cachec (34);
  <D.5277>:
  cachec (0);
  cache.79 = cache;
  bp = lookup (cache.79);
  bp->class = 1;
  if (n == 1) goto <D.5278>; else goto <D.5279>;
  <D.5278>:
  D.5280 = bp->value;
  if (D.5280 == -1) goto <D.5281>; else goto <D.5282>;
  <D.5281>:
  D.5283 = MEM[(unsigned char *)s];
  D.5284 = (short int) D.5283;
  bp->value = D.5284;
  <D.5282>:
  <D.5279>:
  free (s);
  D.5285 = bp;
  return D.5285;
}


is_reserved (char * name)
{
  int D.4190;
  int iftmp.80;
  int D.4189;
  const char[2] * D.5292;
  unsigned char D.5293;
  int D.5294;
  unsigned char D.5295;
  int D.5296;
  _Bool D.5297;
  _Bool D.5298;
  _Bool D.5299;
  const unsigned char * D.5302;
  unsigned char D.5303;
  int D.5304;
  const unsigned char * D.5305;
  unsigned char D.5306;
  int D.5307;
  _Bool D.5308;
  _Bool D.5309;
  const unsigned char * D.5312;
  unsigned char D.5313;
  int D.5314;
  const unsigned char * D.5315;
  unsigned char D.5316;
  int D.5317;
  _Bool D.5318;
  _Bool D.5319;
  const unsigned char * D.5322;
  unsigned char D.5323;
  int D.5324;
  const unsigned char * D.5325;
  unsigned char D.5326;
  int D.5327;
  int D.4199;
  int iftmp.81;
  int D.4198;
  const char[8] * D.5333;
  unsigned char D.5334;
  int D.5335;
  unsigned char D.5336;
  int D.5337;
  _Bool D.5338;
  _Bool D.5339;
  _Bool D.5340;
  const unsigned char * D.5343;
  unsigned char D.5344;
  int D.5345;
  const unsigned char * D.5346;
  unsigned char D.5347;
  int D.5348;
  _Bool D.5349;
  _Bool D.5350;
  const unsigned char * D.5353;
  unsigned char D.5354;
  int D.5355;
  const unsigned char * D.5356;
  unsigned char D.5357;
  int D.5358;
  _Bool D.5359;
  _Bool D.5360;
  const unsigned char * D.5363;
  unsigned char D.5364;
  int D.5365;
  const unsigned char * D.5366;
  unsigned char D.5367;
  int D.5368;
  int D.4208;
  int iftmp.82;
  int D.4207;
  const char[5] * D.5374;
  unsigned char D.5375;
  int D.5376;
  unsigned char D.5377;
  int D.5378;
  _Bool D.5379;
  _Bool D.5380;
  _Bool D.5381;
  const unsigned char * D.5384;
  unsigned char D.5385;
  int D.5386;
  const unsigned char * D.5387;
  unsigned char D.5388;
  int D.5389;
  _Bool D.5390;
  _Bool D.5391;
  const unsigned char * D.5394;
  unsigned char D.5395;
  int D.5396;
  const unsigned char * D.5397;
  unsigned char D.5398;
  int D.5399;
  _Bool D.5400;
  _Bool D.5401;
  const unsigned char * D.5404;
  unsigned char D.5405;
  int D.5406;
  const unsigned char * D.5407;
  unsigned char D.5408;
  int D.5409;
  int D.5411;
  char D.5412;
  char * D.5415;
  char D.5416;
  const short unsigned int * * D.5419;
  const short unsigned int * D.5420;
  char * D.5421;
  char D.5422;
  long unsigned int D.5423;
  long unsigned int D.5424;
  const short unsigned int * D.5425;
  short unsigned int D.5426;
  int D.5427;
  int D.5428;
  char D.5431;
  long unsigned int D.5432;
  long unsigned int D.5433;
  const short unsigned int * D.5434;
  short unsigned int D.5435;
  int D.5436;
  int D.5437;
  char * s;

  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 1;
    if (__s2_len <= 3) goto <D.5290>; else goto <D.5291>;
    <D.5290>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = name;
      D.5292 = ".";
      D.5293 = MEM[(const unsigned char *)D.5292];
      D.5294 = (int) D.5293;
      D.5295 = *__s2;
      D.5296 = (int) D.5295;
      __result = D.5294 - D.5296;
      {
        D.5297 = __s2_len != 0;
        D.5298 = __result == 0;
        D.5299 = D.5297 & D.5298;
        if (D.5299 != 0) goto <D.5300>; else goto <D.5301>;
        <D.5300>:
        D.5302 = &MEM[(void *)"." + 1B];
        D.5303 = *D.5302;
        D.5304 = (int) D.5303;
        D.5305 = __s2 + 1;
        D.5306 = *D.5305;
        D.5307 = (int) D.5306;
        __result = D.5304 - D.5307;
        D.5308 = __s2_len > 1;
        D.5298 = __result == 0;
        D.5309 = D.5308 & D.5298;
        if (D.5309 != 0) goto <D.5310>; else goto <D.5311>;
        <D.5310>:
        D.5312 = &MEM[(void *)"." + 2B];
        D.5313 = *D.5312;
        D.5314 = (int) D.5313;
        D.5315 = __s2 + 2;
        D.5316 = *D.5315;
        D.5317 = (int) D.5316;
        __result = D.5314 - D.5317;
        D.5318 = __s2_len > 2;
        D.5298 = __result == 0;
        D.5319 = D.5318 & D.5298;
        if (D.5319 != 0) goto <D.5320>; else goto <D.5321>;
        <D.5320>:
        D.5322 = &MEM[(void *)"." + 3B];
        D.5323 = *D.5322;
        D.5324 = (int) D.5323;
        D.5325 = __s2 + 3;
        D.5326 = *D.5325;
        D.5327 = (int) D.5326;
        __result = D.5324 - D.5327;
        <D.5321>:
        <D.5311>:
        <D.5301>:
      }
      D.4189 = __result;
    }
    iftmp.80 = -D.4189;
    goto <D.5328>;
    <D.5291>:
    iftmp.80 = __builtin_strcmp (name, ".");
    <D.5328>:
    D.4190 = iftmp.80;
  }
  if (D.4190 == 0) goto <D.5287>; else goto <D.5329>;
  <D.5329>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 7;
    if (__s2_len <= 3) goto <D.5331>; else goto <D.5332>;
    <D.5331>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = name;
      D.5333 = "$accept";
      D.5334 = MEM[(const unsigned char *)D.5333];
      D.5335 = (int) D.5334;
      D.5336 = *__s2;
      D.5337 = (int) D.5336;
      __result = D.5335 - D.5337;
      {
        D.5338 = __s2_len != 0;
        D.5339 = __result == 0;
        D.5340 = D.5338 & D.5339;
        if (D.5340 != 0) goto <D.5341>; else goto <D.5342>;
        <D.5341>:
        D.5343 = &MEM[(void *)"$accept" + 1B];
        D.5344 = *D.5343;
        D.5345 = (int) D.5344;
        D.5346 = __s2 + 1;
        D.5347 = *D.5346;
        D.5348 = (int) D.5347;
        __result = D.5345 - D.5348;
        D.5349 = __s2_len > 1;
        D.5339 = __result == 0;
        D.5350 = D.5349 & D.5339;
        if (D.5350 != 0) goto <D.5351>; else goto <D.5352>;
        <D.5351>:
        D.5353 = &MEM[(void *)"$accept" + 2B];
        D.5354 = *D.5353;
        D.5355 = (int) D.5354;
        D.5356 = __s2 + 2;
        D.5357 = *D.5356;
        D.5358 = (int) D.5357;
        __result = D.5355 - D.5358;
        D.5359 = __s2_len > 2;
        D.5339 = __result == 0;
        D.5360 = D.5359 & D.5339;
        if (D.5360 != 0) goto <D.5361>; else goto <D.5362>;
        <D.5361>:
        D.5363 = &MEM[(void *)"$accept" + 3B];
        D.5364 = *D.5363;
        D.5365 = (int) D.5364;
        D.5366 = __s2 + 3;
        D.5367 = *D.5366;
        D.5368 = (int) D.5367;
        __result = D.5365 - D.5368;
        <D.5362>:
        <D.5352>:
        <D.5342>:
      }
      D.4198 = __result;
    }
    iftmp.81 = -D.4198;
    goto <D.5369>;
    <D.5332>:
    iftmp.81 = __builtin_strcmp (name, "$accept");
    <D.5369>:
    D.4199 = iftmp.81;
  }
  if (D.4199 == 0) goto <D.5287>; else goto <D.5370>;
  <D.5370>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 4;
    if (__s2_len <= 3) goto <D.5372>; else goto <D.5373>;
    <D.5372>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = name;
      D.5374 = "$end";
      D.5375 = MEM[(const unsigned char *)D.5374];
      D.5376 = (int) D.5375;
      D.5377 = *__s2;
      D.5378 = (int) D.5377;
      __result = D.5376 - D.5378;
      {
        D.5379 = __s2_len != 0;
        D.5380 = __result == 0;
        D.5381 = D.5379 & D.5380;
        if (D.5381 != 0) goto <D.5382>; else goto <D.5383>;
        <D.5382>:
        D.5384 = &MEM[(void *)"$end" + 1B];
        D.5385 = *D.5384;
        D.5386 = (int) D.5385;
        D.5387 = __s2 + 1;
        D.5388 = *D.5387;
        D.5389 = (int) D.5388;
        __result = D.5386 - D.5389;
        D.5390 = __s2_len > 1;
        D.5380 = __result == 0;
        D.5391 = D.5390 & D.5380;
        if (D.5391 != 0) goto <D.5392>; else goto <D.5393>;
        <D.5392>:
        D.5394 = &MEM[(void *)"$end" + 2B];
        D.5395 = *D.5394;
        D.5396 = (int) D.5395;
        D.5397 = __s2 + 2;
        D.5398 = *D.5397;
        D.5399 = (int) D.5398;
        __result = D.5396 - D.5399;
        D.5400 = __s2_len > 2;
        D.5380 = __result == 0;
        D.5401 = D.5400 & D.5380;
        if (D.5401 != 0) goto <D.5402>; else goto <D.5403>;
        <D.5402>:
        D.5404 = &MEM[(void *)"$end" + 3B];
        D.5405 = *D.5404;
        D.5406 = (int) D.5405;
        D.5407 = __s2 + 3;
        D.5408 = *D.5407;
        D.5409 = (int) D.5408;
        __result = D.5406 - D.5409;
        <D.5403>:
        <D.5393>:
        <D.5383>:
      }
      D.4207 = __result;
    }
    iftmp.82 = -D.4207;
    goto <D.5410>;
    <D.5373>:
    iftmp.82 = __builtin_strcmp (name, "$end");
    <D.5410>:
    D.4208 = iftmp.82;
  }
  if (D.4208 == 0) goto <D.5287>; else goto <D.5288>;
  <D.5287>:
  D.5411 = 1;
  return D.5411;
  <D.5288>:
  D.5412 = *name;
  if (D.5412 == 36) goto <D.5413>; else goto <D.5414>;
  <D.5413>:
  D.5415 = name + 1;
  D.5416 = *D.5415;
  if (D.5416 == 36) goto <D.5417>; else goto <D.5418>;
  <D.5417>:
  D.5419 = __ctype_b_loc ();
  D.5420 = *D.5419;
  D.5421 = name + 2;
  D.5422 = *D.5421;
  D.5423 = (long unsigned int) D.5422;
  D.5424 = D.5423 * 2;
  D.5425 = D.5420 + D.5424;
  D.5426 = *D.5425;
  D.5427 = (int) D.5426;
  D.5428 = D.5427 & 2048;
  if (D.5428 != 0) goto <D.5429>; else goto <D.5430>;
  <D.5429>:
  s = name + 3;
  goto <D.4210>;
  <D.4209>:
  s = s + 1;
  <D.4210>:
  D.5419 = __ctype_b_loc ();
  D.5420 = *D.5419;
  D.5431 = *s;
  D.5432 = (long unsigned int) D.5431;
  D.5433 = D.5432 * 2;
  D.5434 = D.5420 + D.5433;
  D.5435 = *D.5434;
  D.5436 = (int) D.5435;
  D.5437 = D.5436 & 2048;
  if (D.5437 != 0) goto <D.4209>; else goto <D.4211>;
  <D.4211>:
  D.5431 = *s;
  if (D.5431 == 0) goto <D.5438>; else goto <D.5439>;
  <D.5438>:
  D.5411 = 1;
  return D.5411;
  <D.5439>:
  <D.5430>:
  <D.5418>:
  <D.5414>:
  D.5411 = 0;
  return D.5411;
}


get_name ()
{
  char * cptr.83;
  char D.5442;
  char * cptr.84;
  const short unsigned int * * D.5444;
  const short unsigned int * D.5445;
  long unsigned int D.5446;
  long unsigned int D.5447;
  const short unsigned int * D.5448;
  short unsigned int D.5449;
  int D.5450;
  int D.5451;
  _Bool D.5453;
  _Bool D.5454;
  _Bool D.5455;
  char * cache.85;
  int D.5458;
  struct bucket * D.5461;
  register int c;
  extern int used_reserved ();

  cinc = 0;
  cptr.83 = cptr;
  D.5442 = *cptr.83;
  c = (int) D.5442;
  goto <D.4216>;
  <D.4215>:
  cachec (c);
  cptr.83 = cptr;
  cptr.84 = cptr.83 + 1;
  cptr = cptr.84;
  cptr.83 = cptr;
  D.5442 = *cptr.83;
  c = (int) D.5442;
  <D.4216>:
  D.5444 = __ctype_b_loc ();
  D.5445 = *D.5444;
  D.5446 = (long unsigned int) c;
  D.5447 = D.5446 * 2;
  D.5448 = D.5445 + D.5447;
  D.5449 = *D.5448;
  D.5450 = (int) D.5449;
  D.5451 = D.5450 & 8;
  if (D.5451 != 0) goto <D.4215>; else goto <D.5452>;
  <D.5452>:
  D.5453 = c == 95;
  D.5454 = c == 46;
  D.5455 = D.5453 | D.5454;
  if (D.5455 != 0) goto <D.4215>; else goto <D.5456>;
  <D.5456>:
  if (c == 36) goto <D.4215>; else goto <D.4217>;
  <D.4217>:
  cachec (0);
  cache.85 = cache;
  D.5458 = is_reserved (cache.85);
  if (D.5458 != 0) goto <D.5459>; else goto <D.5460>;
  <D.5459>:
  cache.85 = cache;
  used_reserved (cache.85);
  <D.5460>:
  cache.85 = cache;
  D.5461 = lookup (cache.85);
  return D.5461;
}


get_number ()
{
  char * cptr.86;
  char D.5464;
  int D.5465;
  int D.5466;
  char * cptr.87;
  const short unsigned int * * D.5468;
  const short unsigned int * D.5469;
  long unsigned int D.5470;
  long unsigned int D.5471;
  const short unsigned int * D.5472;
  short unsigned int D.5473;
  int D.5474;
  int D.5475;
  int D.5476;
  register int c;
  register int n;

  n = 0;
  cptr.86 = cptr;
  D.5464 = *cptr.86;
  c = (int) D.5464;
  goto <D.4225>;
  <D.4224>:
  D.5465 = n * 10;
  D.5466 = c + -48;
  n = D.5465 + D.5466;
  cptr.86 = cptr;
  cptr.87 = cptr.86 + 1;
  cptr = cptr.87;
  cptr.86 = cptr;
  D.5464 = *cptr.86;
  c = (int) D.5464;
  <D.4225>:
  D.5468 = __ctype_b_loc ();
  D.5469 = *D.5468;
  D.5470 = (long unsigned int) c;
  D.5471 = D.5470 * 2;
  D.5472 = D.5469 + D.5471;
  D.5473 = *D.5472;
  D.5474 = (int) D.5473;
  D.5475 = D.5474 & 2048;
  if (D.5475 != 0) goto <D.4224>; else goto <D.4226>;
  <D.4226>:
  D.5476 = n;
  return D.5476;
}


get_tag (int emptyOk)
{
  char * cptr.88;
  long int cptr.89;
  char * line.90;
  long int line.91;
  long int D.5482;
  sizetype D.5483;
  char * cptr.92;
  _Bool D.5487;
  _Bool D.5488;
  _Bool D.5489;
  char * D.5492;
  const short unsigned int * * D.5493;
  const short unsigned int * D.5494;
  long unsigned int D.5495;
  long unsigned int D.5496;
  const short unsigned int * D.5497;
  short unsigned int D.5498;
  int D.5499;
  int D.5500;
  _Bool D.5503;
  _Bool D.5504;
  _Bool D.5505;
  char D.5508;
  int D.5509;
  _Bool D.5511;
  _Bool D.5512;
  _Bool D.5513;
  int D.4248;
  char * * tag_table.93;
  long unsigned int D.5520;
  long unsigned int D.5521;
  char * * D.5522;
  char * D.5523;
  char * cache.94;
  int ntags.95;
  int tagmax.96;
  int tagmax.97;
  void * iftmp.98;
  long unsigned int D.5535;
  unsigned int D.5536;
  unsigned int D.5537;
  long unsigned int D.5538;
  int cinc.99;
  unsigned int cinc.100;
  long unsigned int D.5544;
  long unsigned int D.5547;
  long unsigned int D.5548;
  char * * D.5549;
  int ntags.101;
  register int c;
  register int i;
  register char * s;
  int t_lineno;
  char * t_line;
  char * t_cptr;
  extern int unexpected_EOF ();
  extern int illegal_tag ();
  extern int no_space ();

  t_lineno = lineno;
  t_line = dup_line ();
  cptr.88 = cptr;
  cptr.89 = (long int) cptr.88;
  line.90 = line;
  line.91 = (long int) line.90;
  D.5482 = cptr.89 - line.91;
  D.5483 = (sizetype) D.5482;
  t_cptr = t_line + D.5483;
  cptr.88 = cptr;
  cptr.92 = cptr.88 + 1;
  cptr = cptr.92;
  c = nextc ();
  if (c == -1) goto <D.5485>; else goto <D.5486>;
  <D.5485>:
  unexpected_EOF ();
  <D.5486>:
  D.5487 = emptyOk != 0;
  D.5488 = c == 62;
  D.5489 = D.5487 & D.5488;
  if (D.5489 != 0) goto <D.5490>; else goto <D.5491>;
  <D.5490>:
  cptr.88 = cptr;
  cptr.92 = cptr.88 + 1;
  cptr = cptr.92;
  D.5492 = 0B;
  return D.5492;
  <D.5491>:
  D.5493 = __ctype_b_loc ();
  D.5494 = *D.5493;
  D.5495 = (long unsigned int) c;
  D.5496 = D.5495 * 2;
  D.5497 = D.5494 + D.5496;
  D.5498 = *D.5497;
  D.5499 = (int) D.5498;
  D.5500 = D.5499 & 1024;
  if (D.5500 == 0) goto <D.5501>; else goto <D.5502>;
  <D.5501>:
  D.5503 = c != 95;
  D.5504 = c != 36;
  D.5505 = D.5503 & D.5504;
  if (D.5505 != 0) goto <D.5506>; else goto <D.5507>;
  <D.5506>:
  illegal_tag (t_lineno, t_line, t_cptr);
  <D.5507>:
  <D.5502>:
  cinc = 0;
  <D.4238>:
  cachec (c);
  cptr.88 = cptr;
  cptr.92 = cptr.88 + 1;
  cptr = cptr.92;
  cptr.88 = cptr;
  D.5508 = *cptr.88;
  c = (int) D.5508;
  D.5493 = __ctype_b_loc ();
  D.5494 = *D.5493;
  D.5495 = (long unsigned int) c;
  D.5496 = D.5495 * 2;
  D.5497 = D.5494 + D.5496;
  D.5498 = *D.5497;
  D.5499 = (int) D.5498;
  D.5509 = D.5499 & 8;
  if (D.5509 != 0) goto <D.4238>; else goto <D.5510>;
  <D.5510>:
  D.5511 = c == 95;
  D.5512 = c == 46;
  D.5513 = D.5511 | D.5512;
  if (D.5513 != 0) goto <D.4238>; else goto <D.5514>;
  <D.5514>:
  if (c == 36) goto <D.4238>; else goto <D.4239>;
  <D.4239>:
  cachec (0);
  c = nextc ();
  if (c == -1) goto <D.5515>; else goto <D.5516>;
  <D.5515>:
  unexpected_EOF ();
  <D.5516>:
  if (c != 62) goto <D.5517>; else goto <D.5518>;
  <D.5517>:
  illegal_tag (t_lineno, t_line, t_cptr);
  <D.5518>:
  cptr.88 = cptr;
  cptr.92 = cptr.88 + 1;
  cptr = cptr.92;
  i = 0;
  goto <D.4250>;
  <D.4249>:
  {
    size_t __s1_len;
    size_t __s2_len;

    tag_table.93 = tag_table;
    D.5520 = (long unsigned int) i;
    D.5521 = D.5520 * 8;
    D.5522 = tag_table.93 + D.5521;
    D.5523 = *D.5522;
    cache.94 = cache;
    D.4248 = __builtin_strcmp (cache.94, D.5523);
  }
  if (D.4248 == 0) goto <D.5525>; else goto <D.5526>;
  <D.5525>:
  tag_table.93 = tag_table;
  D.5520 = (long unsigned int) i;
  D.5521 = D.5520 * 8;
  D.5522 = tag_table.93 + D.5521;
  D.5492 = *D.5522;
  return D.5492;
  <D.5526>:
  i = i + 1;
  <D.4250>:
  ntags.95 = ntags;
  if (i < ntags.95) goto <D.4249>; else goto <D.4251>;
  <D.4251>:
  ntags.95 = ntags;
  tagmax.96 = tagmax;
  if (ntags.95 >= tagmax.96) goto <D.5529>; else goto <D.5530>;
  <D.5529>:
  {
    extern int no_space ();

    tagmax.96 = tagmax;
    tagmax.97 = tagmax.96 + 16;
    tagmax = tagmax.97;
    tag_table.93 = tag_table;
    if (tag_table.93 != 0B) goto <D.5533>; else goto <D.5534>;
    <D.5533>:
    tagmax.96 = tagmax;
    D.5535 = (long unsigned int) tagmax.96;
    D.5536 = (unsigned int) D.5535;
    D.5537 = D.5536 * 8;
    D.5538 = (long unsigned int) D.5537;
    tag_table.93 = tag_table;
    iftmp.98 = realloc (tag_table.93, D.5538);
    goto <D.5539>;
    <D.5534>:
    tagmax.96 = tagmax;
    D.5535 = (long unsigned int) tagmax.96;
    D.5536 = (unsigned int) D.5535;
    D.5537 = D.5536 * 8;
    D.5538 = (long unsigned int) D.5537;
    iftmp.98 = malloc (D.5538);
    <D.5539>:
    tag_table = iftmp.98;
    tag_table.93 = tag_table;
    if (tag_table.93 == 0B) goto <D.5540>; else goto <D.5541>;
    <D.5540>:
    no_space ();
    <D.5541>:
  }
  <D.5530>:
  cinc.99 = cinc;
  cinc.100 = (unsigned int) cinc.99;
  D.5544 = (long unsigned int) cinc.100;
  s = malloc (D.5544);
  if (s == 0B) goto <D.5545>; else goto <D.5546>;
  <D.5545>:
  no_space ();
  <D.5546>:
  cache.94 = cache;
  strcpy (s, cache.94);
  tag_table.93 = tag_table;
  ntags.95 = ntags;
  D.5547 = (long unsigned int) ntags.95;
  D.5548 = D.5547 * 8;
  D.5549 = tag_table.93 + D.5548;
  *D.5549 = s;
  ntags.95 = ntags;
  ntags.101 = ntags.95 + 1;
  ntags = ntags.101;
  free (t_line);
  D.5492 = s;
  return D.5492;
}


strcpy (char * restrict __dest, const char * restrict __src)
{
  char * D.5552;
  long unsigned int D.5553;

  D.5553 = __builtin_object_size (__dest, 1);
  D.5552 = __builtin___strcpy_chk (__dest, __src, D.5553);
  return D.5552;
}


declare_tokens (int assoc)
{
  int prec.102;
  int prec.103;
  const short unsigned int * * D.5568;
  const short unsigned int * D.5569;
  long unsigned int D.5570;
  long unsigned int D.5571;
  const short unsigned int * D.5572;
  short unsigned int D.5573;
  int D.5574;
  int D.5575;
  _Bool D.5577;
  _Bool D.5578;
  _Bool D.5579;
  _Bool D.5581;
  _Bool D.5582;
  _Bool D.5583;
  struct bucket * goal.104;
  char * D.5590;
  char * D.5593;
  short int D.5600;
  int D.5603;
  char D.5606;
  short int D.5607;
  int D.5610;
  short int D.5613;
  int D.5616;
  short int D.5619;
  register int c;
  register struct bucket * bp;
  int value;
  char * tag;
  extern int unexpected_EOF ();

  tag = 0B;
  if (assoc != 0) goto <D.5555>; else goto <D.5556>;
  <D.5555>:
  prec.102 = prec;
  prec.103 = prec.102 + 1;
  prec = prec.103;
  <D.5556>:
  c = nextc ();
  if (c == -1) goto <D.5559>; else goto <D.5560>;
  <D.5559>:
  unexpected_EOF ();
  <D.5560>:
  if (c == 60) goto <D.5561>; else goto <D.5562>;
  <D.5561>:
  tag = get_tag (0);
  c = nextc ();
  if (c == -1) goto <D.5563>; else goto <D.5564>;
  <D.5563>:
  unexpected_EOF ();
  <D.5564>:
  <D.5562>:
  <D.4271>:
  {
    extern int tokenized_start ();

    D.5568 = __ctype_b_loc ();
    D.5569 = *D.5568;
    D.5570 = (long unsigned int) c;
    D.5571 = D.5570 * 2;
    D.5572 = D.5569 + D.5571;
    D.5573 = *D.5572;
    D.5574 = (int) D.5573;
    D.5575 = D.5574 & 1024;
    if (D.5575 != 0) goto <D.5565>; else goto <D.5576>;
    <D.5576>:
    D.5577 = c == 95;
    D.5578 = c == 46;
    D.5579 = D.5577 | D.5578;
    if (D.5579 != 0) goto <D.5565>; else goto <D.5580>;
    <D.5580>:
    if (c == 36) goto <D.5565>; else goto <D.5566>;
    <D.5565>:
    bp = get_name ();
    goto <D.5567>;
    <D.5566>:
    D.5581 = c == 39;
    D.5582 = c == 34;
    D.5583 = D.5581 | D.5582;
    if (D.5583 != 0) goto <D.5584>; else goto <D.5585>;
    <D.5584>:
    bp = get_literal ();
    goto <D.5586>;
    <D.5585>:
    return;
    <D.5586>:
    <D.5567>:
    goal.104 = goal;
    if (bp == goal.104) goto <D.5588>; else goto <D.5589>;
    <D.5588>:
    D.5590 = bp->name;
    tokenized_start (D.5590);
    <D.5589>:
    bp->class = 1;
    if (tag != 0B) goto <D.5591>; else goto <D.5592>;
    <D.5591>:
    {
      extern int retyped_warning ();

      D.5593 = bp->tag;
      if (D.5593 != 0B) goto <D.5594>; else goto <D.5595>;
      <D.5594>:
      D.5593 = bp->tag;
      if (D.5593 != tag) goto <D.5596>; else goto <D.5597>;
      <D.5596>:
      D.5590 = bp->name;
      retyped_warning (D.5590);
      <D.5597>:
      <D.5595>:
      bp->tag = tag;
    }
    <D.5592>:
    if (assoc != 0) goto <D.5598>; else goto <D.5599>;
    <D.5598>:
    {
      extern int reprec_warning ();

      D.5600 = bp->prec;
      if (D.5600 != 0) goto <D.5601>; else goto <D.5602>;
      <D.5601>:
      D.5600 = bp->prec;
      D.5603 = (int) D.5600;
      prec.102 = prec;
      if (D.5603 != prec.102) goto <D.5604>; else goto <D.5605>;
      <D.5604>:
      D.5590 = bp->name;
      reprec_warning (D.5590);
      <D.5605>:
      <D.5602>:
      D.5606 = (char) assoc;
      bp->assoc = D.5606;
      prec.102 = prec;
      D.5607 = (short int) prec.102;
      bp->prec = D.5607;
    }
    <D.5599>:
    c = nextc ();
    if (c == -1) goto <D.5608>; else goto <D.5609>;
    <D.5608>:
    unexpected_EOF ();
    <D.5609>:
    value = -1;
    D.5568 = __ctype_b_loc ();
    D.5569 = *D.5568;
    D.5570 = (long unsigned int) c;
    D.5571 = D.5570 * 2;
    D.5572 = D.5569 + D.5571;
    D.5573 = *D.5572;
    D.5574 = (int) D.5573;
    D.5610 = D.5574 & 2048;
    if (D.5610 != 0) goto <D.5611>; else goto <D.5612>;
    <D.5611>:
    {
      extern int revalued_warning ();

      value = get_number ();
      D.5613 = bp->value;
      if (D.5613 != -1) goto <D.5614>; else goto <D.5615>;
      <D.5614>:
      D.5613 = bp->value;
      D.5616 = (int) D.5613;
      if (D.5616 != value) goto <D.5617>; else goto <D.5618>;
      <D.5617>:
      D.5590 = bp->name;
      revalued_warning (D.5590);
      <D.5618>:
      <D.5615>:
      D.5619 = (short int) value;
      bp->value = D.5619;
      c = nextc ();
      if (c == -1) goto <D.5620>; else goto <D.5621>;
      <D.5620>:
      unexpected_EOF ();
      <D.5621>:
    }
    <D.5612>:
  }
  goto <D.4271>;
}


declare_types ()
{
  char * cptr.105;
  char * line.106;
  int lineno.107;
  const short unsigned int * * D.5633;
  const short unsigned int * D.5634;
  long unsigned int D.5635;
  long unsigned int D.5636;
  const short unsigned int * D.5637;
  short unsigned int D.5638;
  int D.5639;
  int D.5640;
  _Bool D.5642;
  _Bool D.5643;
  _Bool D.5644;
  _Bool D.5646;
  _Bool D.5647;
  _Bool D.5648;
  char * D.5652;
  char * D.5657;
  register int c;
  register struct bucket * bp;
  char * tag;
  extern int unexpected_EOF ();
  extern int syntax_error ();

  c = nextc ();
  if (c == -1) goto <D.5623>; else goto <D.5624>;
  <D.5623>:
  unexpected_EOF ();
  <D.5624>:
  if (c != 60) goto <D.5625>; else goto <D.5626>;
  <D.5625>:
  cptr.105 = cptr;
  line.106 = line;
  lineno.107 = lineno;
  syntax_error (lineno.107, line.106, cptr.105);
  <D.5626>:
  tag = get_tag (0);
  <D.4279>:
  {
    extern int retyped_warning ();

    c = nextc ();
    D.5633 = __ctype_b_loc ();
    D.5634 = *D.5633;
    D.5635 = (long unsigned int) c;
    D.5636 = D.5635 * 2;
    D.5637 = D.5634 + D.5636;
    D.5638 = *D.5637;
    D.5639 = (int) D.5638;
    D.5640 = D.5639 & 1024;
    if (D.5640 != 0) goto <D.5630>; else goto <D.5641>;
    <D.5641>:
    D.5642 = c == 95;
    D.5643 = c == 46;
    D.5644 = D.5642 | D.5643;
    if (D.5644 != 0) goto <D.5630>; else goto <D.5645>;
    <D.5645>:
    if (c == 36) goto <D.5630>; else goto <D.5631>;
    <D.5630>:
    bp = get_name ();
    goto <D.5632>;
    <D.5631>:
    D.5646 = c == 39;
    D.5647 = c == 34;
    D.5648 = D.5646 | D.5647;
    if (D.5648 != 0) goto <D.5649>; else goto <D.5650>;
    <D.5649>:
    bp = get_literal ();
    goto <D.5651>;
    <D.5650>:
    return;
    <D.5651>:
    <D.5632>:
    D.5652 = bp->tag;
    if (D.5652 != 0B) goto <D.5653>; else goto <D.5654>;
    <D.5653>:
    D.5652 = bp->tag;
    if (D.5652 != tag) goto <D.5655>; else goto <D.5656>;
    <D.5655>:
    D.5657 = bp->name;
    retyped_warning (D.5657);
    <D.5656>:
    <D.5654>:
    bp->tag = tag;
  }
  goto <D.4279>;
}


declare_start ()
{
  const short unsigned int * * D.5661;
  const short unsigned int * D.5662;
  long unsigned int D.5663;
  long unsigned int D.5664;
  const short unsigned int * D.5665;
  short unsigned int D.5666;
  int D.5667;
  int D.5668;
  _Bool D.5671;
  _Bool D.5672;
  _Bool D.5673;
  char * cptr.108;
  char * line.109;
  int lineno.110;
  char D.5681;
  char * D.5684;
  struct bucket * goal.111;
  register int c;
  register struct bucket * bp;
  extern int unexpected_EOF ();
  extern int syntax_error ();
  extern int terminal_start ();
  extern int restarted_warning ();

  c = nextc ();
  if (c == -1) goto <D.5659>; else goto <D.5660>;
  <D.5659>:
  unexpected_EOF ();
  <D.5660>:
  D.5661 = __ctype_b_loc ();
  D.5662 = *D.5661;
  D.5663 = (long unsigned int) c;
  D.5664 = D.5663 * 2;
  D.5665 = D.5662 + D.5664;
  D.5666 = *D.5665;
  D.5667 = (int) D.5666;
  D.5668 = D.5667 & 1024;
  if (D.5668 == 0) goto <D.5669>; else goto <D.5670>;
  <D.5669>:
  D.5671 = c != 95;
  D.5672 = c != 46;
  D.5673 = D.5671 & D.5672;
  if (D.5673 != 0) goto <D.5674>; else goto <D.5675>;
  <D.5674>:
  if (c != 36) goto <D.5676>; else goto <D.5677>;
  <D.5676>:
  cptr.108 = cptr;
  line.109 = line;
  lineno.110 = lineno;
  syntax_error (lineno.110, line.109, cptr.108);
  <D.5677>:
  <D.5675>:
  <D.5670>:
  bp = get_name ();
  D.5681 = bp->class;
  if (D.5681 == 1) goto <D.5682>; else goto <D.5683>;
  <D.5682>:
  D.5684 = bp->name;
  terminal_start (D.5684);
  <D.5683>:
  goal.111 = goal;
  if (goal.111 != 0B) goto <D.5686>; else goto <D.5687>;
  <D.5686>:
  goal.111 = goal;
  if (goal.111 != bp) goto <D.5688>; else goto <D.5689>;
  <D.5688>:
  restarted_warning ();
  <D.5689>:
  <D.5687>:
  goal = bp;
}


read_declarations ()
{
  int cache_size.112;
  unsigned int cache_size.113;
  long unsigned int D.5692;
  void * cache.114;
  char * cache.115;
  char * cptr.116;
  char * line.117;
  int lineno.118;
  struct FILE * prolog_file.119;
  register int c;
  register int k;
  extern int no_space ();

  cache_size = 256;
  cache_size.112 = cache_size;
  cache_size.113 = (unsigned int) cache_size.112;
  D.5692 = (long unsigned int) cache_size.113;
  cache.114 = malloc (D.5692);
  cache = cache.114;
  cache.115 = cache;
  if (cache.115 == 0B) goto <D.5695>; else goto <D.5696>;
  <D.5695>:
  no_space ();
  <D.5696>:
  <D.4307>:
  {
    extern int unexpected_EOF ();
    extern int syntax_error ();

    c = nextc ();
    if (c == -1) goto <D.5697>; else goto <D.5698>;
    <D.5697>:
    unexpected_EOF ();
    <D.5698>:
    if (c != 37) goto <D.5699>; else goto <D.5700>;
    <D.5699>:
    cptr.116 = cptr;
    line.117 = line;
    lineno.118 = lineno;
    syntax_error (lineno.118, line.117, cptr.116);
    <D.5700>:
    k = keyword ();
    switch (k) <default: <D.5705>, case 0: <D.4299>, case 1: <D.4300>, case 2: <D.4301>, case 3: <D.4302>, case 4: <D.4296>, case 5: <D.4297>, case 6: <D.4303>, case 7: <D.4304>>
    <D.4296>:
    return;
    <D.4297>:
    prolog_file.119 = prolog_file;
    copy_text (prolog_file.119);
    goto <D.4298>;
    <D.4299>:
    <D.4300>:
    <D.4301>:
    <D.4302>:
    declare_tokens (k);
    goto <D.4298>;
    <D.4303>:
    declare_types ();
    goto <D.4298>;
    <D.4304>:
    declare_start ();
    goto <D.4298>;
    <D.5705>:
    <D.4298>:
  }
  goto <D.4307>;
}


initialize_grammar ()
{
  int maxitems.120;
  long unsigned int D.5710;
  unsigned int D.5711;
  unsigned int D.5712;
  long unsigned int D.5713;
  void * pitem.121;
  struct bucket * * pitem.122;
  struct bucket * * D.5718;
  struct bucket * * D.5719;
  struct bucket * * D.5720;
  int maxrules.123;
  long unsigned int D.5722;
  unsigned int D.5723;
  unsigned int D.5724;
  long unsigned int D.5725;
  void * plhs.124;
  struct bucket * * plhs.125;
  struct bucket * * D.5730;
  struct bucket * * D.5731;
  unsigned int D.5732;
  long unsigned int D.5733;
  void * rprec.126;
  short int * rprec.127;
  short int * D.5738;
  short int * D.5739;
  long unsigned int D.5740;
  void * rassoc.128;
  char * rassoc.129;
  char * D.5745;
  char * D.5746;
  extern int no_space ();

  nitems = 4;
  maxitems = 300;
  maxitems.120 = maxitems;
  D.5710 = (long unsigned int) maxitems.120;
  D.5711 = (unsigned int) D.5710;
  D.5712 = D.5711 * 8;
  D.5713 = (long unsigned int) D.5712;
  pitem.121 = malloc (D.5713);
  pitem = pitem.121;
  pitem.122 = pitem;
  if (pitem.122 == 0B) goto <D.5716>; else goto <D.5717>;
  <D.5716>:
  no_space ();
  <D.5717>:
  pitem.122 = pitem;
  *pitem.122 = 0B;
  pitem.122 = pitem;
  D.5718 = pitem.122 + 8;
  *D.5718 = 0B;
  pitem.122 = pitem;
  D.5719 = pitem.122 + 16;
  *D.5719 = 0B;
  pitem.122 = pitem;
  D.5720 = pitem.122 + 24;
  *D.5720 = 0B;
  nmethods = 0;
  nrules = 3;
  maxrules = 100;
  maxrules.123 = maxrules;
  D.5722 = (long unsigned int) maxrules.123;
  D.5723 = (unsigned int) D.5722;
  D.5724 = D.5723 * 8;
  D.5725 = (long unsigned int) D.5724;
  plhs.124 = malloc (D.5725);
  plhs = plhs.124;
  plhs.125 = plhs;
  if (plhs.125 == 0B) goto <D.5728>; else goto <D.5729>;
  <D.5728>:
  no_space ();
  <D.5729>:
  plhs.125 = plhs;
  *plhs.125 = 0B;
  plhs.125 = plhs;
  D.5730 = plhs.125 + 8;
  *D.5730 = 0B;
  plhs.125 = plhs;
  D.5731 = plhs.125 + 16;
  *D.5731 = 0B;
  maxrules.123 = maxrules;
  D.5722 = (long unsigned int) maxrules.123;
  D.5723 = (unsigned int) D.5722;
  D.5732 = D.5723 * 2;
  D.5733 = (long unsigned int) D.5732;
  rprec.126 = malloc (D.5733);
  rprec = rprec.126;
  rprec.127 = rprec;
  if (rprec.127 == 0B) goto <D.5736>; else goto <D.5737>;
  <D.5736>:
  no_space ();
  <D.5737>:
  rprec.127 = rprec;
  *rprec.127 = 0;
  rprec.127 = rprec;
  D.5738 = rprec.127 + 2;
  *D.5738 = 0;
  rprec.127 = rprec;
  D.5739 = rprec.127 + 4;
  *D.5739 = 0;
  maxrules.123 = maxrules;
  D.5722 = (long unsigned int) maxrules.123;
  D.5723 = (unsigned int) D.5722;
  D.5740 = (long unsigned int) D.5723;
  rassoc.128 = malloc (D.5740);
  rassoc = rassoc.128;
  rassoc.129 = rassoc;
  if (rassoc.129 == 0B) goto <D.5743>; else goto <D.5744>;
  <D.5743>:
  no_space ();
  <D.5744>:
  rassoc.129 = rassoc;
  *rassoc.129 = 0;
  rassoc.129 = rassoc;
  D.5745 = rassoc.129 + 1;
  *D.5745 = 0;
  rassoc.129 = rassoc;
  D.5746 = rassoc.129 + 2;
  *D.5746 = 0;
}


expand_items ()
{
  int maxitems.130;
  int maxitems.131;
  long unsigned int D.5749;
  unsigned int D.5750;
  unsigned int D.5751;
  long unsigned int D.5752;
  struct bucket * * pitem.132;
  void * pitem.133;
  extern int no_space ();

  maxitems.130 = maxitems;
  maxitems.131 = maxitems.130 + 300;
  maxitems = maxitems.131;
  maxitems.130 = maxitems;
  D.5749 = (long unsigned int) maxitems.130;
  D.5750 = (unsigned int) D.5749;
  D.5751 = D.5750 * 8;
  D.5752 = (long unsigned int) D.5751;
  pitem.132 = pitem;
  pitem.133 = realloc (pitem.132, D.5752);
  pitem = pitem.133;
  pitem.132 = pitem;
  if (pitem.132 == 0B) goto <D.5755>; else goto <D.5756>;
  <D.5755>:
  no_space ();
  <D.5756>:
}


expand_rules ()
{
  int maxrules.134;
  int maxrules.135;
  long unsigned int D.5759;
  unsigned int D.5760;
  unsigned int D.5761;
  long unsigned int D.5762;
  struct bucket * * plhs.136;
  void * plhs.137;
  unsigned int D.5767;
  long unsigned int D.5768;
  short int * rprec.138;
  void * rprec.139;
  long unsigned int D.5773;
  char * rassoc.140;
  void * rassoc.141;
  extern int no_space ();

  maxrules.134 = maxrules;
  maxrules.135 = maxrules.134 + 100;
  maxrules = maxrules.135;
  maxrules.134 = maxrules;
  D.5759 = (long unsigned int) maxrules.134;
  D.5760 = (unsigned int) D.5759;
  D.5761 = D.5760 * 8;
  D.5762 = (long unsigned int) D.5761;
  plhs.136 = plhs;
  plhs.137 = realloc (plhs.136, D.5762);
  plhs = plhs.137;
  plhs.136 = plhs;
  if (plhs.136 == 0B) goto <D.5765>; else goto <D.5766>;
  <D.5765>:
  no_space ();
  <D.5766>:
  maxrules.134 = maxrules;
  D.5759 = (long unsigned int) maxrules.134;
  D.5760 = (unsigned int) D.5759;
  D.5767 = D.5760 * 2;
  D.5768 = (long unsigned int) D.5767;
  rprec.138 = rprec;
  rprec.139 = realloc (rprec.138, D.5768);
  rprec = rprec.139;
  rprec.138 = rprec;
  if (rprec.138 == 0B) goto <D.5771>; else goto <D.5772>;
  <D.5771>:
  no_space ();
  <D.5772>:
  maxrules.134 = maxrules;
  D.5759 = (long unsigned int) maxrules.134;
  D.5760 = (unsigned int) D.5759;
  D.5773 = (long unsigned int) D.5760;
  rassoc.140 = rassoc;
  rassoc.141 = realloc (rassoc.140, D.5773);
  rassoc = rassoc.141;
  rassoc.140 = rassoc;
  if (rassoc.140 == 0B) goto <D.5776>; else goto <D.5777>;
  <D.5776>:
  no_space ();
  <D.5777>:
}


advance_to_start ()
{
  int D.5779;
  struct FILE * local_file.142;
  char * line.143;
  int lineno.144;
  const short unsigned int * * D.5783;
  const short unsigned int * D.5784;
  long unsigned int D.5785;
  long unsigned int D.5786;
  const short unsigned int * D.5787;
  short unsigned int D.5788;
  int D.5789;
  int D.5790;
  _Bool D.5793;
  _Bool D.5794;
  _Bool D.5795;
  char * cptr.145;
  struct bucket * goal.146;
  char D.5804;
  char * D.5807;
  char * cptr.147;
  register int c;
  register struct bucket * bp;
  char * s_cptr;
  int s_lineno;
  extern int syntax_error ();
  extern int unexpected_EOF ();
  extern int start_rule ();

  <D.4333>:
  c = nextc ();
  if (c != 37) goto <D.4324>; else goto <D.5778>;
  <D.5778>:
  s_cptr = cptr;
  D.5779 = keyword ();
  switch (D.5779) <default: <D.4330>, case 4: <D.4325>, case 5: <D.4327>, case 7: <D.4329>>
  {
    extern int no_grammar ();
    extern int syntax_error ();

    <D.4325>:
    no_grammar ();
    <D.4327>:
    local_file.142 = local_file;
    copy_text (local_file.142);
    goto <D.4328>;
    <D.4329>:
    declare_start ();
    goto <D.4328>;
    <D.4330>:
    line.143 = line;
    lineno.144 = lineno;
    syntax_error (lineno.144, line.143, s_cptr);
  }
  <D.4328>:
  goto <D.4333>;
  <D.4324>:
  c = nextc ();
  D.5783 = __ctype_b_loc ();
  D.5784 = *D.5783;
  D.5785 = (long unsigned int) c;
  D.5786 = D.5785 * 2;
  D.5787 = D.5784 + D.5786;
  D.5788 = *D.5787;
  D.5789 = (int) D.5788;
  D.5790 = D.5789 & 1024;
  if (D.5790 == 0) goto <D.5791>; else goto <D.5792>;
  <D.5791>:
  D.5793 = c != 95;
  D.5794 = c != 46;
  D.5795 = D.5793 & D.5794;
  if (D.5795 != 0) goto <D.5796>; else goto <D.5797>;
  <D.5796>:
  if (c != 95) goto <D.5798>; else goto <D.5799>;
  <D.5798>:
  cptr.145 = cptr;
  line.143 = line;
  lineno.144 = lineno;
  syntax_error (lineno.144, line.143, cptr.145);
  <D.5799>:
  <D.5797>:
  <D.5792>:
  bp = get_name ();
  goal.146 = goal;
  if (goal.146 == 0B) goto <D.5802>; else goto <D.5803>;
  <D.5802>:
  {
    extern int terminal_start ();

    D.5804 = bp->class;
    if (D.5804 == 1) goto <D.5805>; else goto <D.5806>;
    <D.5805>:
    D.5807 = bp->name;
    terminal_start (D.5807);
    <D.5806>:
    goal = bp;
  }
  <D.5803>:
  s_lineno = lineno;
  c = nextc ();
  if (c == -1) goto <D.5808>; else goto <D.5809>;
  <D.5808>:
  unexpected_EOF ();
  <D.5809>:
  if (c != 58) goto <D.5810>; else goto <D.5811>;
  <D.5810>:
  cptr.145 = cptr;
  line.143 = line;
  lineno.144 = lineno;
  syntax_error (lineno.144, line.143, cptr.145);
  <D.5811>:
  start_rule (bp, s_lineno);
  cptr.145 = cptr;
  cptr.147 = cptr.145 + 1;
  cptr = cptr.147;
}


start_rule (struct bucket * bp, int s_lineno)
{
  char D.5813;
  int nrules.148;
  int maxrules.149;
  struct bucket * * plhs.150;
  long unsigned int D.5821;
  long unsigned int D.5822;
  struct bucket * * D.5823;
  short int * rprec.151;
  long unsigned int D.5825;
  short int * D.5826;
  char * rassoc.152;
  sizetype D.5828;
  char * D.5829;
  extern int terminal_lhs ();

  D.5813 = bp->class;
  if (D.5813 == 1) goto <D.5814>; else goto <D.5815>;
  <D.5814>:
  terminal_lhs (s_lineno);
  <D.5815>:
  bp->class = 2;
  nrules.148 = nrules;
  maxrules.149 = maxrules;
  if (nrules.148 >= maxrules.149) goto <D.5818>; else goto <D.5819>;
  <D.5818>:
  expand_rules ();
  <D.5819>:
  plhs.150 = plhs;
  nrules.148 = nrules;
  D.5821 = (long unsigned int) nrules.148;
  D.5822 = D.5821 * 8;
  D.5823 = plhs.150 + D.5822;
  *D.5823 = bp;
  rprec.151 = rprec;
  nrules.148 = nrules;
  D.5821 = (long unsigned int) nrules.148;
  D.5825 = D.5821 * 2;
  D.5826 = rprec.151 + D.5825;
  *D.5826 = -1;
  rassoc.152 = rassoc;
  nrules.148 = nrules;
  D.5828 = (sizetype) nrules.148;
  D.5829 = rassoc.152 + D.5828;
  *D.5829 = 0;
}


end_rule ()
{
  char last_was_action.153;
  struct bucket * * plhs.154;
  int nrules.155;
  long unsigned int D.5835;
  long unsigned int D.5836;
  struct bucket * * D.5837;
  struct bucket * D.5838;
  char * D.5839;
  int nitems.156;
  struct bucket * * pitem.157;
  long unsigned int D.5844;
  long unsigned int D.5845;
  struct bucket * * D.5846;
  struct bucket * D.5847;
  sizetype D.5850;
  sizetype D.5851;
  sizetype D.5852;
  struct bucket * * D.5853;
  struct bucket * D.5854;
  char * D.5856;
  int maxitems.158;
  long unsigned int D.5860;
  long unsigned int D.5861;
  struct bucket * * D.5862;
  int nitems.159;
  int nrules.160;
  register int i;

  last_was_action.153 = last_was_action;
  if (last_was_action.153 == 0) goto <D.5831>; else goto <D.5832>;
  <D.5831>:
  plhs.154 = plhs;
  nrules.155 = nrules;
  D.5835 = (long unsigned int) nrules.155;
  D.5836 = D.5835 * 8;
  D.5837 = plhs.154 + D.5836;
  D.5838 = *D.5837;
  D.5839 = D.5838->tag;
  if (D.5839 != 0B) goto <D.5840>; else goto <D.5841>;
  <D.5840>:
  {
    extern int default_action_warning ();

    nitems.156 = nitems;
    i = nitems.156 + -1;
    goto <D.4350>;
    <D.4349>:
    // predicted unlikely by continue predictor.
    goto <D.4348>;
    <D.4348>:
    i = i + -1;
    <D.4350>:
    pitem.157 = pitem;
    D.5844 = (long unsigned int) i;
    D.5845 = D.5844 * 8;
    D.5846 = pitem.157 + D.5845;
    D.5847 = *D.5846;
    if (D.5847 != 0B) goto <D.4349>; else goto <D.4351>;
    <D.4351>:
    pitem.157 = pitem;
    D.5850 = (sizetype) i;
    D.5851 = D.5850 + 1;
    D.5852 = D.5851 * 8;
    D.5853 = pitem.157 + D.5852;
    D.5854 = *D.5853;
    if (D.5854 == 0B) goto <D.5848>; else goto <D.5855>;
    <D.5855>:
    pitem.157 = pitem;
    D.5850 = (sizetype) i;
    D.5851 = D.5850 + 1;
    D.5852 = D.5851 * 8;
    D.5853 = pitem.157 + D.5852;
    D.5854 = *D.5853;
    D.5856 = D.5854->tag;
    plhs.154 = plhs;
    nrules.155 = nrules;
    D.5835 = (long unsigned int) nrules.155;
    D.5836 = D.5835 * 8;
    D.5837 = plhs.154 + D.5836;
    D.5838 = *D.5837;
    D.5839 = D.5838->tag;
    if (D.5856 != D.5839) goto <D.5848>; else goto <D.5849>;
    <D.5848>:
    default_action_warning ();
    <D.5849>:
  }
  <D.5841>:
  <D.5832>:
  last_was_action = 0;
  nitems.156 = nitems;
  maxitems.158 = maxitems;
  if (nitems.156 >= maxitems.158) goto <D.5858>; else goto <D.5859>;
  <D.5858>:
  expand_items ();
  <D.5859>:
  pitem.157 = pitem;
  nitems.156 = nitems;
  D.5860 = (long unsigned int) nitems.156;
  D.5861 = D.5860 * 8;
  D.5862 = pitem.157 + D.5861;
  *D.5862 = 0B;
  nitems.156 = nitems;
  nitems.159 = nitems.156 + 1;
  nitems = nitems.159;
  nrules.155 = nrules;
  nrules.160 = nrules.155 + 1;
  nrules = nrules.160;
}


insert_empty_rule ()
{
  char * cache.161;
  int gensym.162;
  int gensym.163;
  struct bucket * last_symbol.164;
  struct bucket * * plhs.165;
  int nrules.166;
  long unsigned int D.5873;
  long unsigned int D.5874;
  struct bucket * * D.5875;
  struct bucket * D.5876;
  char * D.5877;
  int nitems.167;
  int nitems.168;
  int maxitems.169;
  struct bucket * * pitem.170;
  long unsigned int D.5884;
  long unsigned int D.5885;
  sizetype D.5886;
  struct bucket * * bpp.171;
  struct bucket * D.5888;
  struct bucket * D.5889;
  int nrules.172;
  int maxrules.173;
  sizetype D.5894;
  struct bucket * * D.5895;
  struct bucket * D.5896;
  short int * rprec.174;
  long unsigned int D.5898;
  short int * D.5899;
  sizetype D.5900;
  short int * D.5901;
  short int D.5902;
  char * rassoc.175;
  sizetype D.5904;
  char * D.5905;
  sizetype D.5906;
  char * D.5907;
  char D.5908;
  register struct bucket * bp;
  register struct bucket * * bpp;
  static const char __PRETTY_FUNCTION__[18] = "insert_empty_rule";

  cache.161 = cache;
  if (cache.161 == 0B) goto <D.5866>; else goto <D.5867>;
  <D.5866>:
  __assert_fail ("cache", "reader.c", 980, &__PRETTY_FUNCTION__);
  <D.5867>:
  gensym.162 = gensym;
  gensym.163 = gensym.162 + 1;
  gensym = gensym.163;
  gensym.162 = gensym;
  cache.161 = cache;
  sprintf (cache.161, "$$%d", gensym.162);
  cache.161 = cache;
  bp = make_bucket (cache.161);
  last_symbol.164 = last_symbol;
  last_symbol.164->next = bp;
  last_symbol = bp;
  plhs.165 = plhs;
  nrules.166 = nrules;
  D.5873 = (long unsigned int) nrules.166;
  D.5874 = D.5873 * 8;
  D.5875 = plhs.165 + D.5874;
  D.5876 = *D.5875;
  D.5877 = D.5876->tag;
  bp->tag = D.5877;
  bp->class = 2;
  nitems.167 = nitems;
  nitems.168 = nitems.167 + 2;
  nitems = nitems.168;
  nitems.167 = nitems;
  maxitems.169 = maxitems;
  if (nitems.167 > maxitems.169) goto <D.5881>; else goto <D.5882>;
  <D.5881>:
  expand_items ();
  <D.5882>:
  pitem.170 = pitem;
  nitems.167 = nitems;
  D.5884 = (long unsigned int) nitems.167;
  D.5885 = D.5884 * 8;
  D.5886 = D.5885 + 18446744073709551608;
  bpp = pitem.170 + D.5886;
  bpp.171 = bpp;
  bpp = bpp.171 + 18446744073709551608;
  *bpp.171 = bp;
  goto <D.4360>;
  <D.4359>:
  bpp = bpp + 18446744073709551608;
  <D.4360>:
  D.5888 = MEM[(struct bucket * *)bpp + -8B];
  *bpp = D.5888;
  D.5889 = *bpp;
  if (D.5889 != 0B) goto <D.4359>; else goto <D.4361>;
  <D.4361>:
  nrules.166 = nrules;
  nrules.172 = nrules.166 + 1;
  nrules = nrules.172;
  nrules.166 = nrules;
  maxrules.173 = maxrules;
  if (nrules.166 >= maxrules.173) goto <D.5892>; else goto <D.5893>;
  <D.5892>:
  expand_rules ();
  <D.5893>:
  plhs.165 = plhs;
  nrules.166 = nrules;
  D.5873 = (long unsigned int) nrules.166;
  D.5874 = D.5873 * 8;
  D.5875 = plhs.165 + D.5874;
  plhs.165 = plhs;
  nrules.166 = nrules;
  D.5873 = (long unsigned int) nrules.166;
  D.5874 = D.5873 * 8;
  D.5894 = D.5874 + 18446744073709551608;
  D.5895 = plhs.165 + D.5894;
  D.5896 = *D.5895;
  *D.5875 = D.5896;
  plhs.165 = plhs;
  nrules.166 = nrules;
  D.5873 = (long unsigned int) nrules.166;
  D.5874 = D.5873 * 8;
  D.5894 = D.5874 + 18446744073709551608;
  D.5895 = plhs.165 + D.5894;
  *D.5895 = bp;
  rprec.174 = rprec;
  nrules.166 = nrules;
  D.5873 = (long unsigned int) nrules.166;
  D.5898 = D.5873 * 2;
  D.5899 = rprec.174 + D.5898;
  rprec.174 = rprec;
  nrules.166 = nrules;
  D.5873 = (long unsigned int) nrules.166;
  D.5898 = D.5873 * 2;
  D.5900 = D.5898 + 18446744073709551614;
  D.5901 = rprec.174 + D.5900;
  D.5902 = *D.5901;
  *D.5899 = D.5902;
  rprec.174 = rprec;
  nrules.166 = nrules;
  D.5873 = (long unsigned int) nrules.166;
  D.5898 = D.5873 * 2;
  D.5900 = D.5898 + 18446744073709551614;
  D.5901 = rprec.174 + D.5900;
  *D.5901 = 0;
  rassoc.175 = rassoc;
  nrules.166 = nrules;
  D.5904 = (sizetype) nrules.166;
  D.5905 = rassoc.175 + D.5904;
  rassoc.175 = rassoc;
  nrules.166 = nrules;
  D.5904 = (sizetype) nrules.166;
  D.5906 = D.5904 + 18446744073709551615;
  D.5907 = rassoc.175 + D.5906;
  D.5908 = *D.5907;
  *D.5905 = D.5908;
  rassoc.175 = rassoc;
  nrules.166 = nrules;
  D.5904 = (sizetype) nrules.166;
  D.5906 = D.5904 + 18446744073709551615;
  D.5907 = rassoc.175 + D.5906;
  *D.5907 = 0;
}


sprintf (char * restrict __s, const char * restrict __fmt)
{
  int D.5909;
  long unsigned int D.5910;

  D.5910 = __builtin_object_size (__s, 1);
  D.5909 = __builtin___sprintf_chk (__s, 1, D.5910, __fmt, __builtin_va_arg_pack ());
  return D.5909;
}


add_symbol ()
{
  char * cptr.176;
  char D.5913;
  _Bool D.5914;
  _Bool D.5915;
  _Bool D.5916;
  char * cptr.177;
  char last_was_action.178;
  int nitems.179;
  int nitems.180;
  int maxitems.181;
  struct bucket * * pitem.182;
  long unsigned int D.5932;
  long unsigned int D.5933;
  sizetype D.5934;
  struct bucket * * D.5935;
  register int c;
  register struct bucket * bp;
  int s_lineno;

  s_lineno = lineno;
  cptr.176 = cptr;
  D.5913 = *cptr.176;
  c = (int) D.5913;
  D.5914 = c == 39;
  D.5915 = c == 34;
  D.5916 = D.5914 | D.5915;
  if (D.5916 != 0) goto <D.5917>; else goto <D.5918>;
  <D.5917>:
  bp = get_literal ();
  goto <D.5919>;
  <D.5918>:
  bp = get_name ();
  <D.5919>:
  c = nextc ();
  if (c == 58) goto <D.5920>; else goto <D.5921>;
  <D.5920>:
  end_rule ();
  start_rule (bp, s_lineno);
  cptr.176 = cptr;
  cptr.177 = cptr.176 + 1;
  cptr = cptr.177;
  return;
  <D.5921>:
  last_was_action.178 = last_was_action;
  if (last_was_action.178 != 0) goto <D.5924>; else goto <D.5925>;
  <D.5924>:
  insert_empty_rule ();
  <D.5925>:
  last_was_action = 0;
  nitems.179 = nitems;
  nitems.180 = nitems.179 + 1;
  nitems = nitems.180;
  nitems.179 = nitems;
  maxitems.181 = maxitems;
  if (nitems.179 > maxitems.181) goto <D.5929>; else goto <D.5930>;
  <D.5929>:
  expand_items ();
  <D.5930>:
  pitem.182 = pitem;
  nitems.179 = nitems;
  D.5932 = (long unsigned int) nitems.179;
  D.5933 = D.5932 * 8;
  D.5934 = D.5933 + 18446744073709551608;
  D.5935 = pitem.182 + D.5934;
  *D.5935 = bp;
}


copy_action ()
{
  char * cptr.183;
  long int cptr.184;
  char * line.185;
  long int line.186;
  long int D.5941;
  sizetype D.5942;
  char last_was_action.187;
  int nrules.188;
  int D.5947;
  char D.5948;
  char * cptr.189;
  int nitems.190;
  struct bucket * * pitem.191;
  long unsigned int D.5954;
  long unsigned int D.5955;
  struct bucket * * D.5956;
  struct bucket * D.5957;
  char D.5960;
  int D.4398;
  int iftmp.192;
  int D.4397;
  const char[7] * D.5971;
  unsigned char D.5972;
  int D.5973;
  unsigned char D.5974;
  int D.5975;
  _Bool D.5976;
  _Bool D.5977;
  _Bool D.5978;
  const unsigned char * D.5981;
  unsigned char D.5982;
  int D.5983;
  const unsigned char * D.5984;
  unsigned char D.5985;
  int D.5986;
  _Bool D.5987;
  _Bool D.5988;
  const unsigned char * D.5991;
  unsigned char D.5992;
  int D.5993;
  const unsigned char * D.5994;
  unsigned char D.5995;
  int D.5996;
  _Bool D.5997;
  _Bool D.5998;
  const unsigned char * D.6001;
  unsigned char D.6002;
  int D.6003;
  const unsigned char * D.6004;
  unsigned char D.6005;
  int D.6006;
  sizetype D.6009;
  char * D.6010;
  int D.6011;
  const short unsigned int * * D.6012;
  const short unsigned int * D.6013;
  long unsigned int D.6014;
  long unsigned int D.6015;
  const short unsigned int * D.6016;
  short unsigned int D.6017;
  int D.6018;
  int D.6019;
  int D.4408;
  int iftmp.193;
  int D.4407;
  unsigned char D.6030;
  int D.6031;
  _Bool D.6032;
  _Bool D.6033;
  _Bool D.6034;
  const unsigned char * D.6037;
  unsigned char D.6038;
  int D.6039;
  _Bool D.6040;
  _Bool D.6041;
  const unsigned char * D.6044;
  unsigned char D.6045;
  int D.6046;
  _Bool D.6047;
  _Bool D.6048;
  const unsigned char * D.6051;
  unsigned char D.6052;
  int D.6053;
  int D.6056;
  int D.6057;
  int D.6058;
  long unsigned int D.6061;
  long unsigned int D.6062;
  const short unsigned int * D.6063;
  short unsigned int D.6064;
  int D.6065;
  int D.6066;
  int D.6068;
  int D.6069;
  int D.4418;
  int iftmp.194;
  int D.4417;
  unsigned char D.6076;
  int D.6077;
  _Bool D.6078;
  _Bool D.6079;
  _Bool D.6080;
  const unsigned char * D.6083;
  unsigned char D.6084;
  int D.6085;
  _Bool D.6086;
  _Bool D.6087;
  const unsigned char * D.6090;
  unsigned char D.6091;
  int D.6092;
  _Bool D.6093;
  _Bool D.6094;
  const unsigned char * D.6097;
  unsigned char D.6098;
  int D.6099;
  int D.6102;
  int D.6103;
  int ntags.195;
  struct bucket * * plhs.196;
  long unsigned int D.6111;
  long unsigned int D.6112;
  struct bucket * * D.6113;
  struct bucket * D.6114;
  char * D.6115;
  char * cptr.197;
  _Bool D.6123;
  _Bool D.6124;
  _Bool D.6125;
  int D.6128;
  int D.6129;
  long unsigned int D.6130;
  long unsigned int D.6131;
  sizetype D.6132;
  struct bucket * * D.6133;
  struct bucket * D.6134;
  char * D.6137;
  int D.6138;
  int D.4433;
  int iftmp.198;
  int D.4432;
  unsigned char D.6143;
  int D.6144;
  _Bool D.6145;
  _Bool D.6146;
  _Bool D.6147;
  const unsigned char * D.6150;
  unsigned char D.6151;
  int D.6152;
  _Bool D.6153;
  _Bool D.6154;
  const unsigned char * D.6157;
  unsigned char D.6158;
  int D.6159;
  _Bool D.6160;
  _Bool D.6161;
  const unsigned char * D.6164;
  unsigned char D.6165;
  int D.6166;
  int D.6170;
  int D.6172;
  int lineno.199;
  int D.6177;
  int D.6182;
  int D.6183;
  int D.6184;
  int D.6187;
  _Bool D.6189;
  _Bool D.6190;
  _Bool D.6191;
  int len.200;
  char D.6193;
  int D.6194;
  int len.201;
  sizetype D.6200;
  char * cptr.202;
  char * cptr.203;
  char D.6203;
  int len.204;
  char * cptr.205;
  char * cptr.206;
  char D.6213;
  int len.207;
  int len.208;
  int len.209;
  int len.210;
  int len.211;
  int len.212;
  int len.213;
  int len.214;
  int len.215;
  char * cptr.216;
  char * cptr.217;
  char D.6237;
  int len.218;
  int len.219;
  int D.6250;
  int D.6251;
  int nmethods.220;
  int maxmethods.221;
  long unsigned int D.6258;
  unsigned int D.6259;
  unsigned int D.6260;
  char * methods.222;
  int maxmethods.223;
  long unsigned int D.6266;
  char * * methods.224;
  void * methods.225;
  char * input_file_name.226;
  char * line_format.227;
  long unsigned int D.6271;
  long unsigned int D.6272;
  long unsigned int D.6273;
  long unsigned int D.6274;
  long unsigned int D.6275;
  long unsigned int D.6276;
  unsigned int D.6277;
  int nmethods.228;
  int nmethods.229;
  long unsigned int D.6280;
  long unsigned int D.6281;
  char * * D.6282;
  long unsigned int D.6284;
  register int c;
  register int i;
  register int n;
  int depth;
  int quote;
  char * tag;
  struct FILE * f;
  int a_lineno;
  char * a_line;
  char * a_cptr;
  char buffer[10000];
  int len;
  int comment_lines;
  char * mbody;
  void loop = <<< error >>>;
  void next_line = <<< error >>>;

  try
    {
      f = action_file;
      a_lineno = lineno;
      a_line = dup_line ();
      cptr.183 = cptr;
      cptr.184 = (long int) cptr.183;
      line.185 = line;
      line.186 = (long int) line.185;
      D.5941 = cptr.184 - line.186;
      D.5942 = (sizetype) D.5941;
      a_cptr = a_line + D.5942;
      len = 0;
      comment_lines = 0;
      memset (&buffer, 0, 10000);
      last_was_action.187 = last_was_action;
      if (last_was_action.187 != 0) goto <D.5944>; else goto <D.5945>;
      <D.5944>:
      insert_empty_rule ();
      <D.5945>:
      last_was_action = 1;
      nrules.188 = nrules;
      D.5947 = nrules.188 + -2;
      fprintf (f, "case %d:\n", D.5947);
      cptr.183 = cptr;
      D.5948 = *cptr.183;
      if (D.5948 == 61) goto <D.5949>; else goto <D.5950>;
      <D.5949>:
      cptr.183 = cptr;
      cptr.189 = cptr.183 + 1;
      cptr = cptr.189;
      <D.5950>:
      n = 0;
      nitems.190 = nitems;
      i = nitems.190 + -1;
      goto <D.4384>;
      <D.4383>:
      n = n + 1;
      i = i + -1;
      <D.4384>:
      pitem.191 = pitem;
      D.5954 = (long unsigned int) i;
      D.5955 = D.5954 * 8;
      D.5956 = pitem.191 + D.5955;
      D.5957 = *D.5956;
      if (D.5957 != 0B) goto <D.4383>; else goto <D.4385>;
      <D.4385>:
      depth = 0;
      loop:
      cptr.183 = cptr;
      D.5948 = *cptr.183;
      c = (int) D.5948;
      if (c == 36) goto <D.5958>; else goto <D.5959>;
      <D.5958>:
      cptr.183 = cptr;
      cptr.189 = cptr.183 + 1;
      D.5960 = *cptr.189;
      if (D.5960 == 60) goto <D.5961>; else goto <D.5962>;
      <D.5961>:
      {
        int d_lineno;
        char * d_line;
        char * d_cptr;
        extern int dollar_error ();

        d_lineno = lineno;
        d_line = dup_line ();
        cptr.183 = cptr;
        cptr.184 = (long int) cptr.183;
        line.185 = line;
        line.186 = (long int) line.185;
        D.5941 = cptr.184 - line.186;
        D.5942 = (sizetype) D.5941;
        d_cptr = d_line + D.5942;
        cptr.183 = cptr;
        cptr.189 = cptr.183 + 1;
        cptr = cptr.189;
        tag = get_tag (1);
        cptr.183 = cptr;
        D.5948 = *cptr.183;
        c = (int) D.5948;
        if (c == 36) goto <D.5963>; else goto <D.5964>;
        <D.5963>:
        if (tag != 0B) goto <D.5967>; else goto <D.5965>;
        <D.5967>:
        {
          size_t __s1_len;
          size_t __s2_len;

          __s2_len = 6;
          if (__s2_len <= 3) goto <D.5969>; else goto <D.5970>;
          <D.5969>:
          {
            const unsigned char * __s2;
            int __result;

            __s2 = tag;
            D.5971 = "Object";
            D.5972 = MEM[(const unsigned char *)D.5971];
            D.5973 = (int) D.5972;
            D.5974 = *__s2;
            D.5975 = (int) D.5974;
            __result = D.5973 - D.5975;
            {
              D.5976 = __s2_len != 0;
              D.5977 = __result == 0;
              D.5978 = D.5976 & D.5977;
              if (D.5978 != 0) goto <D.5979>; else goto <D.5980>;
              <D.5979>:
              D.5981 = &MEM[(void *)"Object" + 1B];
              D.5982 = *D.5981;
              D.5983 = (int) D.5982;
              D.5984 = __s2 + 1;
              D.5985 = *D.5984;
              D.5986 = (int) D.5985;
              __result = D.5983 - D.5986;
              D.5987 = __s2_len > 1;
              D.5977 = __result == 0;
              D.5988 = D.5987 & D.5977;
              if (D.5988 != 0) goto <D.5989>; else goto <D.5990>;
              <D.5989>:
              D.5991 = &MEM[(void *)"Object" + 2B];
              D.5992 = *D.5991;
              D.5993 = (int) D.5992;
              D.5994 = __s2 + 2;
              D.5995 = *D.5994;
              D.5996 = (int) D.5995;
              __result = D.5993 - D.5996;
              D.5997 = __s2_len > 2;
              D.5977 = __result == 0;
              D.5998 = D.5997 & D.5977;
              if (D.5998 != 0) goto <D.5999>; else goto <D.6000>;
              <D.5999>:
              D.6001 = &MEM[(void *)"Object" + 3B];
              D.6002 = *D.6001;
              D.6003 = (int) D.6002;
              D.6004 = __s2 + 3;
              D.6005 = *D.6004;
              D.6006 = (int) D.6005;
              __result = D.6003 - D.6006;
              <D.6000>:
              <D.5990>:
              <D.5980>:
            }
            D.4397 = __result;
          }
          iftmp.192 = -D.4397;
          goto <D.6007>;
          <D.5970>:
          iftmp.192 = __builtin_strcmp (tag, "Object");
          <D.6007>:
          D.4398 = iftmp.192;
        }
        if (D.4398 != 0) goto <D.6008>; else goto <D.5965>;
        <D.6008>:
        D.6009 = (sizetype) len;
        D.6010 = &buffer + D.6009;
        D.6011 = sprintf (D.6010, "((%s)yyVal)", tag);
        len = D.6011 + len;
        goto <D.5966>;
        <D.5965>:
        D.6009 = (sizetype) len;
        D.6010 = &buffer + D.6009;
        strcat (D.6010, "yyVal");
        len = len + 5;
        <D.5966>:
        cptr.183 = cptr;
        cptr.189 = cptr.183 + 1;
        cptr = cptr.189;
        free (d_line);
        goto loop;
        <D.5964>:
        D.6012 = __ctype_b_loc ();
        D.6013 = *D.6012;
        D.6014 = (long unsigned int) c;
        D.6015 = D.6014 * 2;
        D.6016 = D.6013 + D.6015;
        D.6017 = *D.6016;
        D.6018 = (int) D.6017;
        D.6019 = D.6018 & 2048;
        if (D.6019 != 0) goto <D.6020>; else goto <D.6021>;
        <D.6020>:
        {
          extern int dollar_warning ();

          i = get_number ();
          if (i > n) goto <D.6022>; else goto <D.6023>;
          <D.6022>:
          dollar_warning (d_lineno, i);
          <D.6023>:
          if (tag != 0B) goto <D.6026>; else goto <D.6024>;
          <D.6026>:
          {
            size_t __s1_len;
            size_t __s2_len;

            __s2_len = 6;
            if (__s2_len <= 3) goto <D.6028>; else goto <D.6029>;
            <D.6028>:
            {
              const unsigned char * __s2;
              int __result;

              __s2 = tag;
              D.5971 = "Object";
              D.5972 = MEM[(const unsigned char *)D.5971];
              D.5973 = (int) D.5972;
              D.6030 = *__s2;
              D.6031 = (int) D.6030;
              __result = D.5973 - D.6031;
              {
                D.6032 = __s2_len != 0;
                D.6033 = __result == 0;
                D.6034 = D.6032 & D.6033;
                if (D.6034 != 0) goto <D.6035>; else goto <D.6036>;
                <D.6035>:
                D.5981 = &MEM[(void *)"Object" + 1B];
                D.5982 = *D.5981;
                D.5983 = (int) D.5982;
                D.6037 = __s2 + 1;
                D.6038 = *D.6037;
                D.6039 = (int) D.6038;
                __result = D.5983 - D.6039;
                D.6040 = __s2_len > 1;
                D.6033 = __result == 0;
                D.6041 = D.6040 & D.6033;
                if (D.6041 != 0) goto <D.6042>; else goto <D.6043>;
                <D.6042>:
                D.5991 = &MEM[(void *)"Object" + 2B];
                D.5992 = *D.5991;
                D.5993 = (int) D.5992;
                D.6044 = __s2 + 2;
                D.6045 = *D.6044;
                D.6046 = (int) D.6045;
                __result = D.5993 - D.6046;
                D.6047 = __s2_len > 2;
                D.6033 = __result == 0;
                D.6048 = D.6047 & D.6033;
                if (D.6048 != 0) goto <D.6049>; else goto <D.6050>;
                <D.6049>:
                D.6001 = &MEM[(void *)"Object" + 3B];
                D.6002 = *D.6001;
                D.6003 = (int) D.6002;
                D.6051 = __s2 + 3;
                D.6052 = *D.6051;
                D.6053 = (int) D.6052;
                __result = D.6003 - D.6053;
                <D.6050>:
                <D.6043>:
                <D.6036>:
              }
              D.4407 = __result;
            }
            iftmp.193 = -D.4407;
            goto <D.6054>;
            <D.6029>:
            iftmp.193 = __builtin_strcmp (tag, "Object");
            <D.6054>:
            D.4408 = iftmp.193;
          }
          if (D.4408 != 0) goto <D.6055>; else goto <D.6024>;
          <D.6055>:
          D.6056 = i - n;
          D.6009 = (sizetype) len;
          D.6010 = &buffer + D.6009;
          D.6057 = sprintf (D.6010, "((%s)yyVals[%d+yyTop])", tag, D.6056);
          len = D.6057 + len;
          goto <D.6025>;
          <D.6024>:
          D.6056 = i - n;
          D.6009 = (sizetype) len;
          D.6010 = &buffer + D.6009;
          D.6058 = sprintf (D.6010, "yyVals[%d+yyTop]", D.6056);
          len = D.6058 + len;
          <D.6025>:
          free (d_line);
          goto loop;
        }
        <D.6021>:
        if (c == 45) goto <D.6060>; else goto <D.6059>;
        <D.6060>:
        D.6012 = __ctype_b_loc ();
        D.6013 = *D.6012;
        cptr.183 = cptr;
        cptr.189 = cptr.183 + 1;
        D.5960 = *cptr.189;
        D.6061 = (long unsigned int) D.5960;
        D.6062 = D.6061 * 2;
        D.6063 = D.6013 + D.6062;
        D.6064 = *D.6063;
        D.6065 = (int) D.6064;
        D.6066 = D.6065 & 2048;
        if (D.6066 != 0) goto <D.6067>; else goto <D.6059>;
        <D.6067>:
        cptr.183 = cptr;
        cptr.189 = cptr.183 + 1;
        cptr = cptr.189;
        D.6068 = get_number ();
        D.6069 = -D.6068;
        i = D.6069 - n;
        if (tag != 0B) goto <D.6072>; else goto <D.6070>;
        <D.6072>:
        {
          size_t __s1_len;
          size_t __s2_len;

          __s2_len = 6;
          if (__s2_len <= 3) goto <D.6074>; else goto <D.6075>;
          <D.6074>:
          {
            const unsigned char * __s2;
            int __result;

            __s2 = tag;
            D.5971 = "Object";
            D.5972 = MEM[(const unsigned char *)D.5971];
            D.5973 = (int) D.5972;
            D.6076 = *__s2;
            D.6077 = (int) D.6076;
            __result = D.5973 - D.6077;
            {
              D.6078 = __s2_len != 0;
              D.6079 = __result == 0;
              D.6080 = D.6078 & D.6079;
              if (D.6080 != 0) goto <D.6081>; else goto <D.6082>;
              <D.6081>:
              D.5981 = &MEM[(void *)"Object" + 1B];
              D.5982 = *D.5981;
              D.5983 = (int) D.5982;
              D.6083 = __s2 + 1;
              D.6084 = *D.6083;
              D.6085 = (int) D.6084;
              __result = D.5983 - D.6085;
              D.6086 = __s2_len > 1;
              D.6079 = __result == 0;
              D.6087 = D.6086 & D.6079;
              if (D.6087 != 0) goto <D.6088>; else goto <D.6089>;
              <D.6088>:
              D.5991 = &MEM[(void *)"Object" + 2B];
              D.5992 = *D.5991;
              D.5993 = (int) D.5992;
              D.6090 = __s2 + 2;
              D.6091 = *D.6090;
              D.6092 = (int) D.6091;
              __result = D.5993 - D.6092;
              D.6093 = __s2_len > 2;
              D.6079 = __result == 0;
              D.6094 = D.6093 & D.6079;
              if (D.6094 != 0) goto <D.6095>; else goto <D.6096>;
              <D.6095>:
              D.6001 = &MEM[(void *)"Object" + 3B];
              D.6002 = *D.6001;
              D.6003 = (int) D.6002;
              D.6097 = __s2 + 3;
              D.6098 = *D.6097;
              D.6099 = (int) D.6098;
              __result = D.6003 - D.6099;
              <D.6096>:
              <D.6089>:
              <D.6082>:
            }
            D.4417 = __result;
          }
          iftmp.194 = -D.4417;
          goto <D.6100>;
          <D.6075>:
          iftmp.194 = __builtin_strcmp (tag, "Object");
          <D.6100>:
          D.4418 = iftmp.194;
        }
        if (D.4418 != 0) goto <D.6101>; else goto <D.6070>;
        <D.6101>:
        D.6009 = (sizetype) len;
        D.6010 = &buffer + D.6009;
        D.6102 = sprintf (D.6010, "((%s)yyVals[%d+yyTop])", tag, i);
        len = D.6102 + len;
        goto <D.6071>;
        <D.6070>:
        D.6009 = (sizetype) len;
        D.6010 = &buffer + D.6009;
        D.6103 = sprintf (D.6010, "yyVals[%d+yyTop]", i);
        len = D.6103 + len;
        <D.6071>:
        free (d_line);
        goto loop;
        <D.6059>:
        dollar_error (d_lineno, d_line, d_cptr);
      }
      goto <D.6104>;
      <D.5962>:
      cptr.183 = cptr;
      cptr.189 = cptr.183 + 1;
      D.5960 = *cptr.189;
      if (D.5960 == 36) goto <D.6105>; else goto <D.6106>;
      <D.6105>:
      {
        extern int untyped_lhs ();

        ntags.195 = ntags;
        if (ntags.195 != 0) goto <D.6108>; else goto <D.6109>;
        <D.6108>:
        plhs.196 = plhs;
        nrules.188 = nrules;
        D.6111 = (long unsigned int) nrules.188;
        D.6112 = D.6111 * 8;
        D.6113 = plhs.196 + D.6112;
        D.6114 = *D.6113;
        D.6115 = D.6114->tag;
        if (D.6115 == 0B) goto <D.6116>; else goto <D.6117>;
        <D.6116>:
        untyped_lhs ();
        <D.6117>:
        <D.6109>:
        strcat (&buffer, "yyVal");
        len = len + 5;
        cptr.183 = cptr;
        cptr.197 = cptr.183 + 2;
        cptr = cptr.197;
        goto loop;
      }
      <D.6106>:
      D.6012 = __ctype_b_loc ();
      D.6013 = *D.6012;
      cptr.183 = cptr;
      cptr.189 = cptr.183 + 1;
      D.5960 = *cptr.189;
      D.6061 = (long unsigned int) D.5960;
      D.6062 = D.6061 * 2;
      D.6063 = D.6013 + D.6062;
      D.6064 = *D.6063;
      D.6065 = (int) D.6064;
      D.6066 = D.6065 & 2048;
      if (D.6066 != 0) goto <D.6119>; else goto <D.6120>;
      <D.6119>:
      cptr.183 = cptr;
      cptr.189 = cptr.183 + 1;
      cptr = cptr.189;
      i = get_number ();
      ntags.195 = ntags;
      if (ntags.195 != 0) goto <D.6121>; else goto <D.6122>;
      <D.6121>:
      {
        extern int unknown_rhs ();
        extern int untyped_rhs ();

        D.6123 = i <= 0;
        D.6124 = i > n;
        D.6125 = D.6123 | D.6124;
        if (D.6125 != 0) goto <D.6126>; else goto <D.6127>;
        <D.6126>:
        unknown_rhs (i);
        <D.6127>:
        pitem.191 = pitem;
        nitems.190 = nitems;
        D.6128 = nitems.190 + i;
        D.6129 = D.6128 - n;
        D.6130 = (long unsigned int) D.6129;
        D.6131 = D.6130 * 8;
        D.6132 = D.6131 + 18446744073709551608;
        D.6133 = pitem.191 + D.6132;
        D.6134 = *D.6133;
        tag = D.6134->tag;
        if (tag == 0B) goto <D.6135>; else goto <D.6136>;
        <D.6135>:
        pitem.191 = pitem;
        nitems.190 = nitems;
        D.6128 = nitems.190 + i;
        D.6129 = D.6128 - n;
        D.6130 = (long unsigned int) D.6129;
        D.6131 = D.6130 * 8;
        D.6132 = D.6131 + 18446744073709551608;
        D.6133 = pitem.191 + D.6132;
        D.6134 = *D.6133;
        D.6137 = D.6134->name;
        untyped_rhs (i, D.6137);
        D.6056 = i - n;
        D.6009 = (sizetype) len;
        D.6010 = &buffer + D.6009;
        D.6138 = sprintf (D.6010, "yyVals[%d+yyTop]", D.6056);
        len = D.6138 + len;
        goto <D.6139>;
        <D.6136>:
        {
          size_t __s1_len;
          size_t __s2_len;

          __s2_len = 6;
          if (__s2_len <= 3) goto <D.6141>; else goto <D.6142>;
          <D.6141>:
          {
            const unsigned char * __s2;
            int __result;

            __s2 = tag;
            D.5971 = "Object";
            D.5972 = MEM[(const unsigned char *)D.5971];
            D.5973 = (int) D.5972;
            D.6143 = *__s2;
            D.6144 = (int) D.6143;
            __result = D.5973 - D.6144;
            {
              D.6145 = __s2_len != 0;
              D.6146 = __result == 0;
              D.6147 = D.6145 & D.6146;
              if (D.6147 != 0) goto <D.6148>; else goto <D.6149>;
              <D.6148>:
              D.5981 = &MEM[(void *)"Object" + 1B];
              D.5982 = *D.5981;
              D.5983 = (int) D.5982;
              D.6150 = __s2 + 1;
              D.6151 = *D.6150;
              D.6152 = (int) D.6151;
              __result = D.5983 - D.6152;
              D.6153 = __s2_len > 1;
              D.6146 = __result == 0;
              D.6154 = D.6153 & D.6146;
              if (D.6154 != 0) goto <D.6155>; else goto <D.6156>;
              <D.6155>:
              D.5991 = &MEM[(void *)"Object" + 2B];
              D.5992 = *D.5991;
              D.5993 = (int) D.5992;
              D.6157 = __s2 + 2;
              D.6158 = *D.6157;
              D.6159 = (int) D.6158;
              __result = D.5993 - D.6159;
              D.6160 = __s2_len > 2;
              D.6146 = __result == 0;
              D.6161 = D.6160 & D.6146;
              if (D.6161 != 0) goto <D.6162>; else goto <D.6163>;
              <D.6162>:
              D.6001 = &MEM[(void *)"Object" + 3B];
              D.6002 = *D.6001;
              D.6003 = (int) D.6002;
              D.6164 = __s2 + 3;
              D.6165 = *D.6164;
              D.6166 = (int) D.6165;
              __result = D.6003 - D.6166;
              <D.6163>:
              <D.6156>:
              <D.6149>:
            }
            D.4432 = __result;
          }
          iftmp.198 = -D.4432;
          goto <D.6167>;
          <D.6142>:
          iftmp.198 = __builtin_strcmp (tag, "Object");
          <D.6167>:
          D.4433 = iftmp.198;
        }
        if (D.4433 != 0) goto <D.6168>; else goto <D.6169>;
        <D.6168>:
        D.6056 = i - n;
        D.6009 = (sizetype) len;
        D.6010 = &buffer + D.6009;
        D.6170 = sprintf (D.6010, "((%s)yyVals[%d+yyTop])", tag, D.6056);
        len = D.6170 + len;
        goto <D.6171>;
        <D.6169>:
        D.6056 = i - n;
        D.6009 = (sizetype) len;
        D.6010 = &buffer + D.6009;
        D.6172 = sprintf (D.6010, "yyVals[%d+yyTop]", D.6056);
        len = D.6172 + len;
        <D.6171>:
        <D.6139>:
      }
      goto <D.6173>;
      <D.6122>:
      {
        extern int dollar_warning ();

        if (i > n) goto <D.6174>; else goto <D.6175>;
        <D.6174>:
        lineno.199 = lineno;
        dollar_warning (lineno.199, i);
        <D.6175>:
        D.6056 = i - n;
        D.6009 = (sizetype) len;
        D.6010 = &buffer + D.6009;
        D.6177 = sprintf (D.6010, "yyVals[%d+yyTop]", D.6056);
        len = D.6177 + len;
      }
      <D.6173>:
      goto loop;
      <D.6120>:
      cptr.183 = cptr;
      cptr.189 = cptr.183 + 1;
      D.5960 = *cptr.189;
      if (D.5960 == 45) goto <D.6178>; else goto <D.6179>;
      <D.6178>:
      {
        extern int unknown_rhs ();

        cptr.183 = cptr;
        cptr.197 = cptr.183 + 2;
        cptr = cptr.197;
        i = get_number ();
        ntags.195 = ntags;
        if (ntags.195 != 0) goto <D.6180>; else goto <D.6181>;
        <D.6180>:
        D.6182 = -i;
        unknown_rhs (D.6182);
        <D.6181>:
        D.6182 = -i;
        D.6183 = D.6182 - n;
        D.6009 = (sizetype) len;
        D.6010 = &buffer + D.6009;
        D.6184 = sprintf (D.6010, "yyVals[%d+yyTop]", D.6183);
        len = D.6184 + len;
        goto loop;
      }
      <D.6179>:
      <D.6104>:
      <D.5959>:
      D.6012 = __ctype_b_loc ();
      D.6013 = *D.6012;
      D.6014 = (long unsigned int) c;
      D.6015 = D.6014 * 2;
      D.6016 = D.6013 + D.6015;
      D.6017 = *D.6016;
      D.6018 = (int) D.6017;
      D.6187 = D.6018 & 1024;
      if (D.6187 != 0) goto <D.6185>; else goto <D.6188>;
      <D.6188>:
      D.6189 = c == 95;
      D.6190 = c == 36;
      D.6191 = D.6189 | D.6190;
      if (D.6191 != 0) goto <D.6185>; else goto <D.6186>;
      <D.6185>:
      <D.4438>:
      len.200 = len;
      len = len.200 + 1;
      D.6193 = (char) c;
      buffer[len.200] = D.6193;
      cptr.183 = cptr;
      cptr.189 = cptr.183 + 1;
      cptr = cptr.189;
      cptr.183 = cptr;
      D.5948 = *cptr.183;
      c = (int) D.5948;
      D.6012 = __ctype_b_loc ();
      D.6013 = *D.6012;
      D.6014 = (long unsigned int) c;
      D.6015 = D.6014 * 2;
      D.6016 = D.6013 + D.6015;
      D.6017 = *D.6016;
      D.6018 = (int) D.6017;
      D.6194 = D.6018 & 8;
      if (D.6194 != 0) goto <D.4438>; else goto <D.6195>;
      <D.6195>:
      D.6189 = c == 95;
      D.6190 = c == 36;
      D.6191 = D.6189 | D.6190;
      if (D.6191 != 0) goto <D.4438>; else goto <D.4439>;
      <D.4439>:
      goto loop;
      <D.6186>:
      len.201 = len;
      len = len.201 + 1;
      D.6193 = (char) c;
      buffer[len.201] = D.6193;
      cptr.183 = cptr;
      cptr.189 = cptr.183 + 1;
      cptr = cptr.189;
      switch (c) <default: <D.4463>, case 10: <D.4440>, case 34: <D.4448>, case 39: <D.4447>, case 47: <D.4454>, case 59: <D.4443>, case 123: <D.4445>, case 125: <D.4446>>
      {
        extern int unterminated_action ();

        <D.4440>:
        next_line:
        get_line ();
        line.185 = line;
        if (line.185 != 0B) goto loop; else goto <D.6197>;
        <D.6197>:
        unterminated_action (a_lineno, a_line, a_cptr);
        <D.4443>:
        if (depth > 0) goto loop; else goto <D.6198>;
        <D.6198>:
        goto <D.4444>;
        <D.4445>:
        depth = depth + 1;
        goto loop;
        <D.4446>:
        depth = depth + -1;
        if (depth > 0) goto loop; else goto <D.6199>;
        <D.6199>:
        goto <D.4444>;
        <D.4447>:
        <D.4448>:
        {
          int s_lineno;
          char * s_line;
          char * s_cptr;

          s_lineno = lineno;
          s_line = dup_line ();
          cptr.183 = cptr;
          cptr.184 = (long int) cptr.183;
          line.185 = line;
          line.186 = (long int) line.185;
          D.5941 = cptr.184 - line.186;
          D.5942 = (sizetype) D.5941;
          D.6200 = D.5942 + 18446744073709551615;
          s_cptr = s_line + D.6200;
          quote = c;
          <D.4453>:
          {
            extern int unterminated_string ();

            cptr.183 = cptr;
            cptr.202 = cptr.183;
            cptr.203 = cptr.202 + 1;
            cptr = cptr.203;
            D.6203 = *cptr.202;
            c = (int) D.6203;
            len.204 = len;
            len = len.204 + 1;
            D.6193 = (char) c;
            buffer[len.204] = D.6193;
            if (c == quote) goto <D.6205>; else goto <D.6206>;
            <D.6205>:
            free (s_line);
            goto loop;
            <D.6206>:
            if (c == 10) goto <D.6207>; else goto <D.6208>;
            <D.6207>:
            unterminated_string (s_lineno, s_line, s_cptr);
            <D.6208>:
            if (c == 92) goto <D.6209>; else goto <D.6210>;
            <D.6209>:
            cptr.183 = cptr;
            cptr.205 = cptr.183;
            cptr.206 = cptr.205 + 1;
            cptr = cptr.206;
            D.6213 = *cptr.205;
            c = (int) D.6213;
            len.207 = len;
            len = len.207 + 1;
            D.6193 = (char) c;
            buffer[len.207] = D.6193;
            if (c == 10) goto <D.6215>; else goto <D.6216>;
            <D.6215>:
            get_line ();
            line.185 = line;
            if (line.185 == 0B) goto <D.6217>; else goto <D.6218>;
            <D.6217>:
            unterminated_string (s_lineno, s_line, s_cptr);
            <D.6218>:
            <D.6216>:
            <D.6210>:
          }
          goto <D.4453>;
        }
        <D.4454>:
        cptr.183 = cptr;
        D.5948 = *cptr.183;
        c = (int) D.5948;
        if (c == 47) goto <D.6219>; else goto <D.6220>;
        <D.6219>:
        len.208 = len;
        len = len.208 + 1;
        buffer[len.208] = 42;
        goto <D.4456>;
        <D.4455>:
        if (c == 42) goto <D.6224>; else goto <D.6222>;
        <D.6224>:
        cptr.183 = cptr;
        cptr.189 = cptr.183 + 1;
        D.5960 = *cptr.189;
        if (D.5960 == 47) goto <D.6225>; else goto <D.6222>;
        <D.6225>:
        len.209 = len;
        len = len.209 + 1;
        buffer[len.209] = 42;
        len.210 = len;
        len = len.210 + 1;
        buffer[len.210] = 32;
        goto <D.6223>;
        <D.6222>:
        len.211 = len;
        len = len.211 + 1;
        D.6193 = (char) c;
        buffer[len.211] = D.6193;
        <D.6223>:
        <D.4456>:
        cptr.183 = cptr;
        cptr.189 = cptr.183 + 1;
        cptr = cptr.189;
        cptr.183 = cptr;
        D.5948 = *cptr.183;
        c = (int) D.5948;
        if (c != 10) goto <D.4455>; else goto <D.4457>;
        <D.4457>:
        len.212 = len;
        len = len.212 + 1;
        buffer[len.212] = 42;
        len.213 = len;
        len = len.213 + 1;
        buffer[len.213] = 47;
        len.214 = len;
        len = len.214 + 1;
        buffer[len.214] = 10;
        goto next_line;
        <D.6220>:
        if (c == 42) goto <D.6232>; else goto <D.6233>;
        <D.6232>:
        {
          int c_lineno;
          char * c_line;
          char * c_cptr;

          c_lineno = lineno;
          c_line = dup_line ();
          cptr.183 = cptr;
          cptr.184 = (long int) cptr.183;
          line.185 = line;
          line.186 = (long int) line.185;
          D.5941 = cptr.184 - line.186;
          D.5942 = (sizetype) D.5941;
          D.6200 = D.5942 + 18446744073709551615;
          c_cptr = c_line + D.6200;
          len.215 = len;
          len = len.215 + 1;
          buffer[len.215] = 42;
          cptr.183 = cptr;
          cptr.189 = cptr.183 + 1;
          cptr = cptr.189;
          <D.4462>:
          cptr.183 = cptr;
          cptr.216 = cptr.183;
          cptr.217 = cptr.216 + 1;
          cptr = cptr.217;
          D.6237 = *cptr.216;
          c = (int) D.6237;
          len.218 = len;
          len = len.218 + 1;
          D.6193 = (char) c;
          buffer[len.218] = D.6193;
          if (c == 42) goto <D.6239>; else goto <D.6240>;
          <D.6239>:
          cptr.183 = cptr;
          D.5948 = *cptr.183;
          if (D.5948 == 47) goto <D.6241>; else goto <D.6242>;
          <D.6241>:
          len.219 = len;
          len = len.219 + 1;
          buffer[len.219] = 47;
          cptr.183 = cptr;
          cptr.189 = cptr.183 + 1;
          cptr = cptr.189;
          free (c_line);
          goto loop;
          <D.6242>:
          <D.6240>:
          if (c == 10) goto <D.6244>; else goto <D.6245>;
          <D.6244>:
          {
            extern int unterminated_comment ();

            comment_lines = comment_lines + 1;
            get_line ();
            line.185 = line;
            if (line.185 == 0B) goto <D.6246>; else goto <D.6247>;
            <D.6246>:
            unterminated_comment (c_lineno, c_line, c_cptr);
            <D.6247>:
          }
          <D.6245>:
          goto <D.4462>;
        }
        <D.6233>:
        goto loop;
        <D.4463>:
        goto loop;
      }
      <D.4444>:
      if (comment_lines > 0) goto <D.6248>; else goto <D.6249>;
      <D.6248>:
      comment_lines = comment_lines + 1;
      <D.6249>:
      lineno.199 = lineno;
      D.6250 = a_lineno + comment_lines;
      D.6251 = lineno.199 - D.6250;
      if (D.6251 > 2) goto <D.6252>; else goto <D.6253>;
      <D.6252>:
      {
        char mname[20];
        char line_define[256];

        try
          {
            nrules.188 = nrules;
            D.5947 = nrules.188 + -2;
            sprintf (&mname, "case_%d()", D.5947);
            _IO_putc (32, f);
            _IO_putc (32, f);
            fputs (&mname, f);
            fprintf (f, ";");
            nmethods.220 = nmethods;
            if (nmethods.220 == 0) goto <D.6255>; else goto <D.6256>;
            <D.6255>:
            maxmethods = 100;
            maxmethods.221 = maxmethods;
            D.6258 = (long unsigned int) maxmethods.221;
            D.6259 = (unsigned int) D.6258;
            D.6260 = D.6259 * 8;
            methods.222 = allocate (D.6260);
            methods = methods.222;
            goto <D.6262>;
            <D.6256>:
            nmethods.220 = nmethods;
            maxmethods.221 = maxmethods;
            if (nmethods.220 == maxmethods.221) goto <D.6263>; else goto <D.6264>;
            <D.6263>:
            maxmethods.221 = maxmethods;
            maxmethods.223 = maxmethods.221 + 500;
            maxmethods = maxmethods.223;
            maxmethods.221 = maxmethods;
            D.6258 = (long unsigned int) maxmethods.221;
            D.6259 = (unsigned int) D.6258;
            D.6260 = D.6259 * 8;
            D.6266 = (long unsigned int) D.6260;
            methods.224 = methods;
            methods.225 = realloc (methods.224, D.6266);
            methods = methods.225;
            <D.6264>:
            <D.6262>:
            input_file_name.226 = input_file_name;
            line_format.227 = line_format;
            sprintf (&line_define, line_format.227, a_lineno, input_file_name.226);
            D.6271 = strlen (&line_define);
            D.6272 = strlen (&mname);
            D.6273 = D.6271 + D.6272;
            D.6274 = strlen (&buffer);
            D.6275 = D.6273 + D.6274;
            D.6276 = D.6275 + 7;
            D.6277 = (unsigned int) D.6276;
            mbody = allocate (D.6277);
            strcpy (mbody, "void ");
            strcat (mbody, &mname);
            strcat (mbody, "\n");
            strcat (mbody, &line_define);
            strcat (mbody, &buffer);
            methods.224 = methods;
            nmethods.220 = nmethods;
            nmethods.228 = nmethods.220;
            nmethods.229 = nmethods.228 + 1;
            nmethods = nmethods.229;
            D.6280 = (long unsigned int) nmethods.228;
            D.6281 = D.6280 * 8;
            D.6282 = methods.224 + D.6281;
            *D.6282 = mbody;
          }
        finally
          {
            mname = {CLOBBER};
            line_define = {CLOBBER};
          }
      }
      goto <D.6283>;
      <D.6253>:
      input_file_name.226 = input_file_name;
      lineno.199 = lineno;
      line_format.227 = line_format;
      fprintf (f, line_format.227, lineno.199, input_file_name.226);
      _IO_putc (32, f);
      _IO_putc (32, f);
      D.6284 = (long unsigned int) len;
      fwrite (&buffer, 1, D.6284, f);
      <D.6283>:
      fprintf (f, "\n  break;\n");
    }
  finally
    {
      buffer = {CLOBBER};
    }
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.6287;
  int D.6292;
  void * D.6294;
  long unsigned int D.6295;

  D.6287 = __builtin_constant_p (__len);
  if (D.6287 != 0) goto <D.6288>; else goto <D.6289>;
  <D.6288>:
  if (__len == 0) goto <D.6290>; else goto <D.6291>;
  <D.6290>:
  D.6292 = __builtin_constant_p (__ch);
  if (D.6292 == 0) goto <D.6285>; else goto <D.6293>;
  <D.6293>:
  if (__ch != 0) goto <D.6285>; else goto <D.6286>;
  <D.6285>:
  __warn_memset_zero_len ();
  D.6294 = __dest;
  return D.6294;
  <D.6286>:
  <D.6291>:
  <D.6289>:
  D.6295 = __builtin_object_size (__dest, 0);
  D.6294 = __builtin___memset_chk (__dest, __ch, __len, D.6295);
  return D.6294;
}


strcat (char * restrict __dest, const char * restrict __src)
{
  char * D.6297;
  long unsigned int D.6298;

  D.6298 = __builtin_object_size (__dest, 1);
  D.6297 = __builtin___strcat_chk (__dest, __src, D.6298);
  return D.6297;
}


mark_symbol ()
{
  char * cptr.230;
  char * D.6301;
  char D.6302;
  _Bool D.6303;
  _Bool D.6304;
  _Bool D.6305;
  char * cptr.231;
  int D.6309;
  _Bool D.6318;
  _Bool D.6319;
  _Bool D.6320;
  char D.6322;
  char * D.6324;
  char D.6325;
  char * D.6327;
  char D.6328;
  char * cptr.233;
  char D.6331;
  int iftmp.232;
  const short unsigned int * * D.6335;
  const short unsigned int * D.6336;
  long unsigned int D.6337;
  long unsigned int D.6338;
  const short unsigned int * D.6339;
  short unsigned int D.6340;
  int D.6341;
  int D.6342;
  _Bool D.6344;
  _Bool D.6345;
  _Bool D.6346;
  char * line.234;
  int lineno.235;
  int D.6355;
  _Bool D.6357;
  _Bool D.6358;
  _Bool D.6359;
  _Bool D.6361;
  _Bool D.6362;
  _Bool D.6363;
  short int * rprec.236;
  int nrules.237;
  long unsigned int D.6369;
  long unsigned int D.6370;
  short int * D.6371;
  short int D.6372;
  short int D.6375;
  char * rassoc.238;
  sizetype D.6379;
  char * D.6380;
  char D.6381;
  register int c;
  register struct bucket * bp;
  extern int syntax_error ();
  extern int prec_redeclared ();

  cptr.230 = cptr;
  D.6301 = cptr.230 + 1;
  D.6302 = *D.6301;
  c = (int) D.6302;
  D.6303 = c == 37;
  D.6304 = c == 92;
  D.6305 = D.6303 | D.6304;
  if (D.6305 != 0) goto <D.6306>; else goto <D.6307>;
  <D.6306>:
  cptr.230 = cptr;
  cptr.231 = cptr.230 + 2;
  cptr = cptr.231;
  D.6309 = 1;
  return D.6309;
  <D.6307>:
  if (c == 61) goto <D.6310>; else goto <D.6311>;
  <D.6310>:
  cptr.230 = cptr;
  cptr.231 = cptr.230 + 2;
  cptr = cptr.231;
  goto <D.6312>;
  <D.6311>:
  D.6318 = c == 112;
  D.6319 = c == 80;
  D.6320 = D.6318 | D.6319;
  if (D.6320 != 0) goto <D.6321>; else goto <D.6313>;
  <D.6321>:
  cptr.230 = cptr;
  cptr.231 = cptr.230 + 2;
  D.6322 = *cptr.231;
  c = (int) D.6322;
  if (c == 114) goto <D.6314>; else goto <D.6323>;
  <D.6323>:
  if (c == 82) goto <D.6314>; else goto <D.6313>;
  <D.6314>:
  cptr.230 = cptr;
  D.6324 = cptr.230 + 3;
  D.6325 = *D.6324;
  c = (int) D.6325;
  if (c == 101) goto <D.6315>; else goto <D.6326>;
  <D.6326>:
  if (c == 69) goto <D.6315>; else goto <D.6313>;
  <D.6315>:
  cptr.230 = cptr;
  D.6327 = cptr.230 + 4;
  D.6328 = *D.6327;
  c = (int) D.6328;
  if (c == 99) goto <D.6316>; else goto <D.6329>;
  <D.6329>:
  if (c == 67) goto <D.6316>; else goto <D.6313>;
  <D.6316>:
  cptr.230 = cptr;
  cptr.233 = cptr.230 + 5;
  D.6331 = *cptr.233;
  c = (int) D.6331;
  D.6335 = __ctype_b_loc ();
  D.6336 = *D.6335;
  D.6337 = (long unsigned int) c;
  D.6338 = D.6337 * 2;
  D.6339 = D.6336 + D.6338;
  D.6340 = *D.6339;
  D.6341 = (int) D.6340;
  D.6342 = D.6341 & 8;
  if (D.6342 == 0) goto <D.6343>; else goto <D.6333>;
  <D.6343>:
  D.6344 = c != 95;
  D.6345 = c != 46;
  D.6346 = D.6344 & D.6345;
  if (D.6346 != 0) goto <D.6347>; else goto <D.6333>;
  <D.6347>:
  if (c != 36) goto <D.6348>; else goto <D.6333>;
  <D.6348>:
  iftmp.232 = 1;
  goto <D.6334>;
  <D.6333>:
  iftmp.232 = 0;
  <D.6334>:
  if (iftmp.232 != 0) goto <D.6349>; else goto <D.6313>;
  <D.6349>:
  cptr.230 = cptr;
  cptr.233 = cptr.230 + 5;
  cptr = cptr.233;
  goto <D.6317>;
  <D.6313>:
  cptr.230 = cptr;
  line.234 = line;
  lineno.235 = lineno;
  syntax_error (lineno.235, line.234, cptr.230);
  <D.6317>:
  <D.6312>:
  c = nextc ();
  D.6335 = __ctype_b_loc ();
  D.6336 = *D.6335;
  D.6337 = (long unsigned int) c;
  D.6338 = D.6337 * 2;
  D.6339 = D.6336 + D.6338;
  D.6340 = *D.6339;
  D.6341 = (int) D.6340;
  D.6355 = D.6341 & 1024;
  if (D.6355 != 0) goto <D.6352>; else goto <D.6356>;
  <D.6356>:
  D.6357 = c == 95;
  D.6358 = c == 46;
  D.6359 = D.6357 | D.6358;
  if (D.6359 != 0) goto <D.6352>; else goto <D.6360>;
  <D.6360>:
  if (c == 36) goto <D.6352>; else goto <D.6353>;
  <D.6352>:
  bp = get_name ();
  goto <D.6354>;
  <D.6353>:
  D.6361 = c == 39;
  D.6362 = c == 34;
  D.6363 = D.6361 | D.6362;
  if (D.6363 != 0) goto <D.6364>; else goto <D.6365>;
  <D.6364>:
  bp = get_literal ();
  goto <D.6366>;
  <D.6365>:
  cptr.230 = cptr;
  line.234 = line;
  lineno.235 = lineno;
  syntax_error (lineno.235, line.234, cptr.230);
  <D.6366>:
  <D.6354>:
  rprec.236 = rprec;
  nrules.237 = nrules;
  D.6369 = (long unsigned int) nrules.237;
  D.6370 = D.6369 * 2;
  D.6371 = rprec.236 + D.6370;
  D.6372 = *D.6371;
  if (D.6372 != -1) goto <D.6373>; else goto <D.6374>;
  <D.6373>:
  D.6375 = bp->prec;
  rprec.236 = rprec;
  nrules.237 = nrules;
  D.6369 = (long unsigned int) nrules.237;
  D.6370 = D.6369 * 2;
  D.6371 = rprec.236 + D.6370;
  D.6372 = *D.6371;
  if (D.6375 != D.6372) goto <D.6376>; else goto <D.6377>;
  <D.6376>:
  prec_redeclared ();
  <D.6377>:
  <D.6374>:
  rprec.236 = rprec;
  nrules.237 = nrules;
  D.6369 = (long unsigned int) nrules.237;
  D.6370 = D.6369 * 2;
  D.6371 = rprec.236 + D.6370;
  D.6375 = bp->prec;
  *D.6371 = D.6375;
  rassoc.238 = rassoc;
  nrules.237 = nrules;
  D.6379 = (sizetype) nrules.237;
  D.6380 = rassoc.238 + D.6379;
  D.6381 = bp->assoc;
  *D.6380 = D.6381;
  D.6309 = 0;
  return D.6309;
}


read_grammar ()
{
  const short unsigned int * * D.6387;
  const short unsigned int * D.6388;
  long unsigned int D.6389;
  long unsigned int D.6390;
  const short unsigned int * D.6391;
  short unsigned int D.6392;
  int D.6393;
  int D.6394;
  _Bool D.6396;
  _Bool D.6397;
  _Bool D.6398;
  _Bool D.6400;
  _Bool D.6401;
  _Bool D.6402;
  _Bool D.6404;
  _Bool D.6405;
  _Bool D.6406;
  struct bucket * * plhs.239;
  int nrules.240;
  long unsigned int D.6414;
  long unsigned int D.6415;
  sizetype D.6416;
  struct bucket * * D.6417;
  struct bucket * D.6418;
  char * cptr.241;
  char * cptr.242;
  int D.6424;
  char * line.243;
  int lineno.244;
  register int c;

  initialize_grammar ();
  advance_to_start ();
  <D.4479>:
  {
    extern int syntax_error ();

    c = nextc ();
    if (c == -1) goto <D.4477>; else goto <D.6383>;
    <D.6383>:
    D.6387 = __ctype_b_loc ();
    D.6388 = *D.6387;
    D.6389 = (long unsigned int) c;
    D.6390 = D.6389 * 2;
    D.6391 = D.6388 + D.6390;
    D.6392 = *D.6391;
    D.6393 = (int) D.6392;
    D.6394 = D.6393 & 1024;
    if (D.6394 != 0) goto <D.6384>; else goto <D.6395>;
    <D.6395>:
    D.6396 = c == 95;
    D.6397 = c == 46;
    D.6398 = D.6396 | D.6397;
    if (D.6398 != 0) goto <D.6384>; else goto <D.6399>;
    <D.6399>:
    D.6400 = c == 36;
    D.6401 = c == 39;
    D.6402 = D.6400 | D.6401;
    if (D.6402 != 0) goto <D.6384>; else goto <D.6403>;
    <D.6403>:
    if (c == 34) goto <D.6384>; else goto <D.6385>;
    <D.6384>:
    add_symbol ();
    goto <D.6386>;
    <D.6385>:
    D.6404 = c == 123;
    D.6405 = c == 61;
    D.6406 = D.6404 | D.6405;
    if (D.6406 != 0) goto <D.6407>; else goto <D.6408>;
    <D.6407>:
    copy_action ();
    goto <D.6409>;
    <D.6408>:
    if (c == 124) goto <D.6410>; else goto <D.6411>;
    <D.6410>:
    end_rule ();
    plhs.239 = plhs;
    nrules.240 = nrules;
    D.6414 = (long unsigned int) nrules.240;
    D.6415 = D.6414 * 8;
    D.6416 = D.6415 + 18446744073709551608;
    D.6417 = plhs.239 + D.6416;
    D.6418 = *D.6417;
    start_rule (D.6418, 0);
    cptr.241 = cptr;
    cptr.242 = cptr.241 + 1;
    cptr = cptr.242;
    goto <D.6421>;
    <D.6411>:
    if (c == 37) goto <D.6422>; else goto <D.6423>;
    <D.6422>:
    D.6424 = mark_symbol ();
    if (D.6424 != 0) goto <D.4477>; else goto <D.6425>;
    <D.6425>:
    goto <D.6426>;
    <D.6423>:
    cptr.241 = cptr;
    line.243 = line;
    lineno.244 = lineno;
    syntax_error (lineno.244, line.243, cptr.241);
    <D.6426>:
    <D.6421>:
    <D.6409>:
    <D.6386>:
  }
  goto <D.4479>;
  <D.4477>:
  end_rule ();
}


free_tags ()
{
  char * * tag_table.245;
  long unsigned int D.6432;
  long unsigned int D.6433;
  char * * D.6434;
  char * D.6435;
  int ntags.246;
  register int i;
  static const char __PRETTY_FUNCTION__[10] = "free_tags";

  tag_table.245 = tag_table;
  if (tag_table.245 == 0B) goto <D.6430>; else goto <D.6431>;
  <D.6430>:
  return;
  <D.6431>:
  i = 0;
  goto <D.4485>;
  <D.4484>:
  tag_table.245 = tag_table;
  D.6432 = (long unsigned int) i;
  D.6433 = D.6432 * 8;
  D.6434 = tag_table.245 + D.6433;
  D.6435 = *D.6434;
  if (D.6435 == 0B) goto <D.6436>; else goto <D.6437>;
  <D.6436>:
  __assert_fail ("tag_table[i]", "reader.c", 1407, &__PRETTY_FUNCTION__);
  <D.6437>:
  tag_table.245 = tag_table;
  D.6432 = (long unsigned int) i;
  D.6433 = D.6432 * 8;
  D.6434 = tag_table.245 + D.6433;
  D.6435 = *D.6434;
  free (D.6435);
  i = i + 1;
  <D.4485>:
  ntags.246 = ntags;
  if (i < ntags.246) goto <D.4484>; else goto <D.4486>;
  <D.4486>:
  tag_table.245 = tag_table;
  free (tag_table.245);
}


pack_names ()
{
  char * D.6440;
  long unsigned int D.6441;
  unsigned int D.6442;
  int name_pool_size.247;
  unsigned int name_pool_size.248;
  unsigned int D.6445;
  unsigned int D.6446;
  int name_pool_size.249;
  unsigned int name_pool_size.250;
  long unsigned int D.6449;
  void * name_pool.251;
  char * name_pool.252;
  char * D.6454;
  char * t.253;
  char * s.254;
  char D.6457;
  char D.6458;
  register struct bucket * bp;
  register char * p;
  register char * s;
  register char * t;
  extern int no_space ();

  name_pool_size = 13;
  bp = first_symbol;
  goto <D.4494>;
  <D.4493>:
  D.6440 = bp->name;
  D.6441 = strlen (D.6440);
  D.6442 = (unsigned int) D.6441;
  name_pool_size.247 = name_pool_size;
  name_pool_size.248 = (unsigned int) name_pool_size.247;
  D.6445 = D.6442 + name_pool_size.248;
  D.6446 = D.6445 + 1;
  name_pool_size.249 = (int) D.6446;
  name_pool_size = name_pool_size.249;
  bp = bp->next;
  <D.4494>:
  if (bp != 0B) goto <D.4493>; else goto <D.4495>;
  <D.4495>:
  name_pool_size.247 = name_pool_size;
  name_pool_size.250 = (unsigned int) name_pool_size.247;
  D.6449 = (long unsigned int) name_pool_size.250;
  name_pool.251 = malloc (D.6449);
  name_pool = name_pool.251;
  name_pool.252 = name_pool;
  if (name_pool.252 == 0B) goto <D.6452>; else goto <D.6453>;
  <D.6452>:
  no_space ();
  <D.6453>:
  name_pool.252 = name_pool;
  strcpy (name_pool.252, "$accept");
  name_pool.252 = name_pool;
  D.6454 = name_pool.252 + 8;
  strcpy (D.6454, "$end");
  name_pool.252 = name_pool;
  t = name_pool.252 + 13;
  bp = first_symbol;
  goto <D.4500>;
  <D.4499>:
  p = t;
  s = bp->name;
  goto <D.4496>;
  <D.4497>:
  // predicted unlikely by continue predictor.
  goto <D.4496>;
  <D.4496>:
  t.253 = t;
  t = t.253 + 1;
  s.254 = s;
  s = s.254 + 1;
  D.6457 = *s.254;
  *t.253 = D.6457;
  D.6458 = *t.253;
  if (D.6458 != 0) goto <D.4497>; else goto <D.4498>;
  <D.4498>:
  D.6440 = bp->name;
  free (D.6440);
  bp->name = p;
  bp = bp->next;
  <D.4500>:
  if (bp != 0B) goto <D.4499>; else goto <D.4501>;
  <D.4501>:
}


check_symbols ()
{
  struct bucket * goal.255;
  char D.6460;
  char * D.6463;
  char D.6464;
  char * D.6467;
  register struct bucket * bp;
  extern int undefined_goal ();

  goal.255 = goal;
  D.6460 = goal.255->class;
  if (D.6460 == 0) goto <D.6461>; else goto <D.6462>;
  <D.6461>:
  goal.255 = goal;
  D.6463 = goal.255->name;
  undefined_goal (D.6463);
  <D.6462>:
  bp = first_symbol;
  goto <D.4510>;
  <D.4509>:
  D.6464 = bp->class;
  if (D.6464 == 0) goto <D.6465>; else goto <D.6466>;
  <D.6465>:
  {
    extern int undefined_symbol_warning ();

    D.6467 = bp->name;
    undefined_symbol_warning (D.6467);
    bp->class = 1;
  }
  <D.6466>:
  bp = bp->next;
  <D.4510>:
  if (bp != 0B) goto <D.4509>; else goto <D.4511>;
  <D.4511>:
}


pack_symbols ()
{
  int nsyms.256;
  int nsyms.257;
  char D.6470;
  int ntokens.258;
  int ntokens.259;
  int nvars.260;
  long unsigned int D.6476;
  unsigned int D.6477;
  unsigned int D.6478;
  long unsigned int D.6479;
  void * symbol_name.261;
  char * * symbol_name.262;
  unsigned int D.6484;
  long unsigned int D.6485;
  void * symbol_value.263;
  short int * symbol_value.264;
  void * symbol_prec.265;
  short int * symbol_prec.266;
  unsigned int nsyms.267;
  long unsigned int D.6495;
  void * symbol_assoc.268;
  char * symbol_assoc.269;
  int start_symbol.270;
  long unsigned int D.6503;
  long unsigned int D.6504;
  struct bucket * * D.6505;
  int i.271;
  long unsigned int D.6509;
  long unsigned int D.6510;
  struct bucket * * D.6511;
  int j.272;
  long unsigned int D.6514;
  long unsigned int D.6515;
  struct bucket * * D.6516;
  long unsigned int D.6520;
  long unsigned int D.6521;
  struct bucket * * D.6522;
  struct bucket * D.6523;
  short int D.6524;
  struct bucket * goal.273;
  unsigned short D.6526;
  unsigned short D.6527;
  short int D.6528;
  short int D.6531;
  short int D.6534;
  int k.274;
  long unsigned int D.6538;
  long unsigned int D.6539;
  short int * D.6540;
  sizetype D.6541;
  short int * D.6542;
  short int D.6543;
  int D.6545;
  short int D.6546;
  struct bucket * * D.6547;
  struct bucket * D.6548;
  short int D.6549;
  short int D.6555;
  int D.6556;
  char * name_pool.275;
  char * D.6559;
  char * * D.6560;
  char * D.6561;
  long unsigned int D.6562;
  short int * D.6563;
  short int * D.6564;
  short int D.6565;
  sizetype D.6566;
  char * D.6567;
  char D.6568;
  char * * D.6569;
  long unsigned int D.6570;
  short int * D.6571;
  short int * D.6572;
  sizetype D.6573;
  char * D.6574;
  short int D.6575;
  long unsigned int D.6576;
  long unsigned int D.6577;
  char * * D.6578;
  long unsigned int D.6579;
  short int * D.6580;
  short int * D.6581;
  sizetype D.6582;
  char * D.6583;
  register struct bucket * bp;
  register struct bucket * * v;
  register int i;
  register int j;
  register int k;
  register int n;
  extern int no_space ();
  static const char __PRETTY_FUNCTION__[13] = "pack_symbols";

  nsyms = 2;
  ntokens = 1;
  bp = first_symbol;
  goto <D.4522>;
  <D.4521>:
  nsyms.256 = nsyms;
  nsyms.257 = nsyms.256 + 1;
  nsyms = nsyms.257;
  D.6470 = bp->class;
  if (D.6470 == 1) goto <D.6471>; else goto <D.6472>;
  <D.6471>:
  ntokens.258 = ntokens;
  ntokens.259 = ntokens.258 + 1;
  ntokens = ntokens.259;
  <D.6472>:
  bp = bp->next;
  <D.4522>:
  if (bp != 0B) goto <D.4521>; else goto <D.4523>;
  <D.4523>:
  ntokens.258 = ntokens;
  start_symbol = ntokens.258;
  nsyms.256 = nsyms;
  ntokens.258 = ntokens;
  nvars.260 = nsyms.256 - ntokens.258;
  nvars = nvars.260;
  nsyms.256 = nsyms;
  D.6476 = (long unsigned int) nsyms.256;
  D.6477 = (unsigned int) D.6476;
  D.6478 = D.6477 * 8;
  D.6479 = (long unsigned int) D.6478;
  symbol_name.261 = malloc (D.6479);
  symbol_name = symbol_name.261;
  symbol_name.262 = symbol_name;
  if (symbol_name.262 == 0B) goto <D.6482>; else goto <D.6483>;
  <D.6482>:
  no_space ();
  <D.6483>:
  nsyms.256 = nsyms;
  D.6476 = (long unsigned int) nsyms.256;
  D.6477 = (unsigned int) D.6476;
  D.6484 = D.6477 * 2;
  D.6485 = (long unsigned int) D.6484;
  symbol_value.263 = malloc (D.6485);
  symbol_value = symbol_value.263;
  symbol_value.264 = symbol_value;
  if (symbol_value.264 == 0B) goto <D.6488>; else goto <D.6489>;
  <D.6488>:
  no_space ();
  <D.6489>:
  nsyms.256 = nsyms;
  D.6476 = (long unsigned int) nsyms.256;
  D.6477 = (unsigned int) D.6476;
  D.6484 = D.6477 * 2;
  D.6485 = (long unsigned int) D.6484;
  symbol_prec.265 = malloc (D.6485);
  symbol_prec = symbol_prec.265;
  symbol_prec.266 = symbol_prec;
  if (symbol_prec.266 == 0B) goto <D.6492>; else goto <D.6493>;
  <D.6492>:
  no_space ();
  <D.6493>:
  nsyms.256 = nsyms;
  nsyms.267 = (unsigned int) nsyms.256;
  D.6495 = (long unsigned int) nsyms.267;
  symbol_assoc.268 = malloc (D.6495);
  symbol_assoc = symbol_assoc.268;
  symbol_assoc.269 = symbol_assoc;
  if (symbol_assoc.269 == 0B) goto <D.6498>; else goto <D.6499>;
  <D.6498>:
  no_space ();
  <D.6499>:
  nsyms.256 = nsyms;
  D.6476 = (long unsigned int) nsyms.256;
  D.6477 = (unsigned int) D.6476;
  D.6478 = D.6477 * 8;
  D.6479 = (long unsigned int) D.6478;
  v = malloc (D.6479);
  if (v == 0B) goto <D.6500>; else goto <D.6501>;
  <D.6500>:
  no_space ();
  <D.6501>:
  *v = 0B;
  start_symbol.270 = start_symbol;
  D.6503 = (long unsigned int) start_symbol.270;
  D.6504 = D.6503 * 8;
  D.6505 = v + D.6504;
  *D.6505 = 0B;
  i = 1;
  start_symbol.270 = start_symbol;
  j = start_symbol.270 + 1;
  bp = first_symbol;
  goto <D.4525>;
  <D.4524>:
  D.6470 = bp->class;
  if (D.6470 == 1) goto <D.6506>; else goto <D.6507>;
  <D.6506>:
  i.271 = i;
  i = i.271 + 1;
  D.6509 = (long unsigned int) i.271;
  D.6510 = D.6509 * 8;
  D.6511 = v + D.6510;
  *D.6511 = bp;
  goto <D.6512>;
  <D.6507>:
  j.272 = j;
  j = j.272 + 1;
  D.6514 = (long unsigned int) j.272;
  D.6515 = D.6514 * 8;
  D.6516 = v + D.6515;
  *D.6516 = bp;
  <D.6512>:
  bp = bp->next;
  <D.4525>:
  if (bp != 0B) goto <D.4524>; else goto <D.4526>;
  <D.4526>:
  ntokens.258 = ntokens;
  if (i != ntokens.258) goto <D.6517>; else goto <D.6519>;
  <D.6519>:
  nsyms.256 = nsyms;
  if (j != nsyms.256) goto <D.6517>; else goto <D.6518>;
  <D.6517>:
  __assert_fail ("i == ntokens && j == nsyms", "reader.c", 1497, &__PRETTY_FUNCTION__);
  <D.6518>:
  i = 1;
  goto <D.4529>;
  <D.4528>:
  D.6520 = (long unsigned int) i;
  D.6521 = D.6520 * 8;
  D.6522 = v + D.6521;
  D.6523 = *D.6522;
  D.6524 = (short int) i;
  D.6523->index = D.6524;
  i = i + 1;
  <D.4529>:
  ntokens.258 = ntokens;
  if (i < ntokens.258) goto <D.4528>; else goto <D.4530>;
  <D.4530>:
  goal.273 = goal;
  start_symbol.270 = start_symbol;
  D.6526 = (unsigned short) start_symbol.270;
  D.6527 = D.6526 + 1;
  D.6528 = (short int) D.6527;
  goal.273->index = D.6528;
  start_symbol.270 = start_symbol;
  k = start_symbol.270 + 2;
  goto <D.4532>;
  <D.4531>:
  D.6520 = (long unsigned int) i;
  D.6521 = D.6520 * 8;
  D.6522 = v + D.6521;
  D.6523 = *D.6522;
  goal.273 = goal;
  if (D.6523 != goal.273) goto <D.6529>; else goto <D.6530>;
  <D.6529>:
  D.6520 = (long unsigned int) i;
  D.6521 = D.6520 * 8;
  D.6522 = v + D.6521;
  D.6523 = *D.6522;
  D.6531 = (short int) k;
  D.6523->index = D.6531;
  k = k + 1;
  <D.6530>:
  <D.4532>:
  i = i + 1;
  nsyms.256 = nsyms;
  if (i < nsyms.256) goto <D.4531>; else goto <D.4533>;
  <D.4533>:
  goal.273 = goal;
  goal.273->value = 0;
  k = 1;
  start_symbol.270 = start_symbol;
  i = start_symbol.270 + 1;
  goto <D.4535>;
  <D.4534>:
  D.6520 = (long unsigned int) i;
  D.6521 = D.6520 * 8;
  D.6522 = v + D.6521;
  D.6523 = *D.6522;
  goal.273 = goal;
  if (D.6523 != goal.273) goto <D.6532>; else goto <D.6533>;
  <D.6532>:
  D.6520 = (long unsigned int) i;
  D.6521 = D.6520 * 8;
  D.6522 = v + D.6521;
  D.6523 = *D.6522;
  D.6531 = (short int) k;
  D.6523->value = D.6531;
  k = k + 1;
  <D.6533>:
  i = i + 1;
  <D.4535>:
  nsyms.256 = nsyms;
  if (i < nsyms.256) goto <D.4534>; else goto <D.4536>;
  <D.4536>:
  k = 0;
  i = 1;
  goto <D.4541>;
  <D.4540>:
  D.6520 = (long unsigned int) i;
  D.6521 = D.6520 * 8;
  D.6522 = v + D.6521;
  D.6523 = *D.6522;
  D.6534 = D.6523->value;
  n = (int) D.6534;
  if (n > 256) goto <D.6535>; else goto <D.6536>;
  <D.6535>:
  k.274 = k;
  k = k.274 + 1;
  j = k.274;
  goto <D.4538>;
  <D.4537>:
  symbol_value.264 = symbol_value;
  D.6538 = (long unsigned int) j;
  D.6539 = D.6538 * 2;
  D.6540 = symbol_value.264 + D.6539;
  symbol_value.264 = symbol_value;
  D.6538 = (long unsigned int) j;
  D.6539 = D.6538 * 2;
  D.6541 = D.6539 + 18446744073709551614;
  D.6542 = symbol_value.264 + D.6541;
  D.6543 = *D.6542;
  *D.6540 = D.6543;
  j = j + -1;
  <D.4538>:
  if (j > 0) goto <D.6544>; else goto <D.4539>;
  <D.6544>:
  symbol_value.264 = symbol_value;
  D.6538 = (long unsigned int) j;
  D.6539 = D.6538 * 2;
  D.6541 = D.6539 + 18446744073709551614;
  D.6542 = symbol_value.264 + D.6541;
  D.6543 = *D.6542;
  D.6545 = (int) D.6543;
  if (D.6545 > n) goto <D.4537>; else goto <D.4539>;
  <D.4539>:
  symbol_value.264 = symbol_value;
  D.6538 = (long unsigned int) j;
  D.6539 = D.6538 * 2;
  D.6540 = symbol_value.264 + D.6539;
  D.6546 = (short int) n;
  *D.6540 = D.6546;
  <D.6536>:
  i = i + 1;
  <D.4541>:
  ntokens.258 = ntokens;
  if (i < ntokens.258) goto <D.4540>; else goto <D.4542>;
  <D.4542>:
  D.6547 = v + 8;
  D.6548 = *D.6547;
  D.6549 = D.6548->value;
  if (D.6549 == -1) goto <D.6550>; else goto <D.6551>;
  <D.6550>:
  D.6547 = v + 8;
  D.6548 = *D.6547;
  D.6548->value = 256;
  <D.6551>:
  j = 0;
  n = 257;
  i = 2;
  goto <D.4550>;
  <D.4549>:
  D.6520 = (long unsigned int) i;
  D.6521 = D.6520 * 8;
  D.6522 = v + D.6521;
  D.6523 = *D.6522;
  D.6534 = D.6523->value;
  if (D.6534 == -1) goto <D.6552>; else goto <D.6553>;
  <D.6552>:
  goto <D.4547>;
  <D.4546>:
  goto <D.4543>;
  <D.4544>:
  // predicted unlikely by continue predictor.
  goto <D.4543>;
  <D.4543>:
  j = j + 1;
  if (j < k) goto <D.6554>; else goto <D.4545>;
  <D.6554>:
  symbol_value.264 = symbol_value;
  D.6538 = (long unsigned int) j;
  D.6539 = D.6538 * 2;
  D.6540 = symbol_value.264 + D.6539;
  D.6555 = *D.6540;
  D.6556 = (int) D.6555;
  if (D.6556 == n) goto <D.4544>; else goto <D.4545>;
  <D.4545>:
  n = n + 1;
  <D.4547>:
  if (j < k) goto <D.6557>; else goto <D.4548>;
  <D.6557>:
  symbol_value.264 = symbol_value;
  D.6538 = (long unsigned int) j;
  D.6539 = D.6538 * 2;
  D.6540 = symbol_value.264 + D.6539;
  D.6555 = *D.6540;
  D.6556 = (int) D.6555;
  if (D.6556 == n) goto <D.4546>; else goto <D.4548>;
  <D.4548>:
  D.6520 = (long unsigned int) i;
  D.6521 = D.6520 * 8;
  D.6522 = v + D.6521;
  D.6523 = *D.6522;
  D.6546 = (short int) n;
  D.6523->value = D.6546;
  n = n + 1;
  <D.6553>:
  i = i + 1;
  <D.4550>:
  ntokens.258 = ntokens;
  if (i < ntokens.258) goto <D.4549>; else goto <D.4551>;
  <D.4551>:
  symbol_name.262 = symbol_name;
  name_pool.275 = name_pool;
  D.6559 = name_pool.275 + 8;
  *symbol_name.262 = D.6559;
  symbol_value.264 = symbol_value;
  *symbol_value.264 = 0;
  symbol_prec.266 = symbol_prec;
  *symbol_prec.266 = 0;
  symbol_assoc.269 = symbol_assoc;
  *symbol_assoc.269 = 0;
  i = 1;
  goto <D.4553>;
  <D.4552>:
  symbol_name.262 = symbol_name;
  D.6520 = (long unsigned int) i;
  D.6521 = D.6520 * 8;
  D.6560 = symbol_name.262 + D.6521;
  D.6520 = (long unsigned int) i;
  D.6521 = D.6520 * 8;
  D.6522 = v + D.6521;
  D.6523 = *D.6522;
  D.6561 = D.6523->name;
  *D.6560 = D.6561;
  symbol_value.264 = symbol_value;
  D.6520 = (long unsigned int) i;
  D.6562 = D.6520 * 2;
  D.6563 = symbol_value.264 + D.6562;
  D.6520 = (long unsigned int) i;
  D.6521 = D.6520 * 8;
  D.6522 = v + D.6521;
  D.6523 = *D.6522;
  D.6534 = D.6523->value;
  *D.6563 = D.6534;
  symbol_prec.266 = symbol_prec;
  D.6520 = (long unsigned int) i;
  D.6562 = D.6520 * 2;
  D.6564 = symbol_prec.266 + D.6562;
  D.6520 = (long unsigned int) i;
  D.6521 = D.6520 * 8;
  D.6522 = v + D.6521;
  D.6523 = *D.6522;
  D.6565 = D.6523->prec;
  *D.6564 = D.6565;
  symbol_assoc.269 = symbol_assoc;
  D.6566 = (sizetype) i;
  D.6567 = symbol_assoc.269 + D.6566;
  D.6520 = (long unsigned int) i;
  D.6521 = D.6520 * 8;
  D.6522 = v + D.6521;
  D.6523 = *D.6522;
  D.6568 = D.6523->assoc;
  *D.6567 = D.6568;
  i = i + 1;
  <D.4553>:
  ntokens.258 = ntokens;
  if (i < ntokens.258) goto <D.4552>; else goto <D.4554>;
  <D.4554>:
  symbol_name.262 = symbol_name;
  start_symbol.270 = start_symbol;
  D.6503 = (long unsigned int) start_symbol.270;
  D.6504 = D.6503 * 8;
  D.6569 = symbol_name.262 + D.6504;
  name_pool.275 = name_pool;
  *D.6569 = name_pool.275;
  symbol_value.264 = symbol_value;
  start_symbol.270 = start_symbol;
  D.6503 = (long unsigned int) start_symbol.270;
  D.6570 = D.6503 * 2;
  D.6571 = symbol_value.264 + D.6570;
  *D.6571 = -1;
  symbol_prec.266 = symbol_prec;
  start_symbol.270 = start_symbol;
  D.6503 = (long unsigned int) start_symbol.270;
  D.6570 = D.6503 * 2;
  D.6572 = symbol_prec.266 + D.6570;
  *D.6572 = 0;
  symbol_assoc.269 = symbol_assoc;
  start_symbol.270 = start_symbol;
  D.6573 = (sizetype) start_symbol.270;
  D.6574 = symbol_assoc.269 + D.6573;
  *D.6574 = 0;
  i = i + 1;
  goto <D.4556>;
  <D.4555>:
  D.6520 = (long unsigned int) i;
  D.6521 = D.6520 * 8;
  D.6522 = v + D.6521;
  D.6523 = *D.6522;
  D.6575 = D.6523->index;
  k = (int) D.6575;
  symbol_name.262 = symbol_name;
  D.6576 = (long unsigned int) k;
  D.6577 = D.6576 * 8;
  D.6578 = symbol_name.262 + D.6577;
  D.6520 = (long unsigned int) i;
  D.6521 = D.6520 * 8;
  D.6522 = v + D.6521;
  D.6523 = *D.6522;
  D.6561 = D.6523->name;
  *D.6578 = D.6561;
  symbol_value.264 = symbol_value;
  D.6576 = (long unsigned int) k;
  D.6579 = D.6576 * 2;
  D.6580 = symbol_value.264 + D.6579;
  D.6520 = (long unsigned int) i;
  D.6521 = D.6520 * 8;
  D.6522 = v + D.6521;
  D.6523 = *D.6522;
  D.6534 = D.6523->value;
  *D.6580 = D.6534;
  symbol_prec.266 = symbol_prec;
  D.6576 = (long unsigned int) k;
  D.6579 = D.6576 * 2;
  D.6581 = symbol_prec.266 + D.6579;
  D.6520 = (long unsigned int) i;
  D.6521 = D.6520 * 8;
  D.6522 = v + D.6521;
  D.6523 = *D.6522;
  D.6565 = D.6523->prec;
  *D.6581 = D.6565;
  symbol_assoc.269 = symbol_assoc;
  D.6582 = (sizetype) k;
  D.6583 = symbol_assoc.269 + D.6582;
  D.6520 = (long unsigned int) i;
  D.6521 = D.6520 * 8;
  D.6522 = v + D.6521;
  D.6523 = *D.6522;
  D.6568 = D.6523->assoc;
  *D.6583 = D.6568;
  i = i + 1;
  <D.4556>:
  nsyms.256 = nsyms;
  if (i < nsyms.256) goto <D.4555>; else goto <D.4557>;
  <D.4557>:
  free (v);
}


pack_grammar ()
{
  int nitems.276;
  long unsigned int D.6585;
  unsigned int D.6586;
  unsigned int D.6587;
  long unsigned int D.6588;
  void * ritem.277;
  short int * ritem.278;
  int nrules.279;
  long unsigned int D.6594;
  unsigned int D.6595;
  unsigned int D.6596;
  long unsigned int D.6597;
  void * rlhs.280;
  short int * rlhs.281;
  int D.6602;
  long unsigned int D.6603;
  unsigned int D.6604;
  unsigned int D.6605;
  long unsigned int D.6606;
  void * rrhs.282;
  short int * rrhs.283;
  short int * rprec.284;
  void * rprec.285;
  unsigned int nrules.286;
  long unsigned int D.6616;
  char * rassoc.287;
  void * rassoc.288;
  short int * D.6621;
  struct bucket * goal.289;
  short int D.6623;
  short int * D.6624;
  short int * D.6625;
  short int * D.6626;
  short int * D.6627;
  int start_symbol.290;
  short int D.6629;
  short int * D.6630;
  short int * D.6631;
  long unsigned int D.6632;
  long unsigned int D.6633;
  short int * D.6634;
  struct bucket * * plhs.291;
  long unsigned int D.6636;
  struct bucket * * D.6637;
  struct bucket * D.6638;
  short int D.6639;
  short int * D.6640;
  short int D.6641;
  long unsigned int D.6642;
  long unsigned int D.6643;
  short int * D.6644;
  struct bucket * * pitem.292;
  long unsigned int D.6646;
  struct bucket * * D.6647;
  struct bucket * D.6648;
  short int D.6649;
  char D.6650;
  short int D.6653;
  char D.6654;
  unsigned short D.6655;
  unsigned short D.6656;
  short int D.6657;
  short int * D.6658;
  short int D.6659;
  short int D.6662;
  sizetype D.6663;
  char * D.6664;
  char D.6665;
  register int i;
  register int j;
  int assoc;
  int prec;
  extern int no_space ();

  nitems.276 = nitems;
  D.6585 = (long unsigned int) nitems.276;
  D.6586 = (unsigned int) D.6585;
  D.6587 = D.6586 * 2;
  D.6588 = (long unsigned int) D.6587;
  ritem.277 = malloc (D.6588);
  ritem = ritem.277;
  ritem.278 = ritem;
  if (ritem.278 == 0B) goto <D.6591>; else goto <D.6592>;
  <D.6591>:
  no_space ();
  <D.6592>:
  nrules.279 = nrules;
  D.6594 = (long unsigned int) nrules.279;
  D.6595 = (unsigned int) D.6594;
  D.6596 = D.6595 * 2;
  D.6597 = (long unsigned int) D.6596;
  rlhs.280 = malloc (D.6597);
  rlhs = rlhs.280;
  rlhs.281 = rlhs;
  if (rlhs.281 == 0B) goto <D.6600>; else goto <D.6601>;
  <D.6600>:
  no_space ();
  <D.6601>:
  nrules.279 = nrules;
  D.6602 = nrules.279 + 1;
  D.6603 = (long unsigned int) D.6602;
  D.6604 = (unsigned int) D.6603;
  D.6605 = D.6604 * 2;
  D.6606 = (long unsigned int) D.6605;
  rrhs.282 = malloc (D.6606);
  rrhs = rrhs.282;
  rrhs.283 = rrhs;
  if (rrhs.283 == 0B) goto <D.6609>; else goto <D.6610>;
  <D.6609>:
  no_space ();
  <D.6610>:
  nrules.279 = nrules;
  D.6594 = (long unsigned int) nrules.279;
  D.6595 = (unsigned int) D.6594;
  D.6596 = D.6595 * 2;
  D.6597 = (long unsigned int) D.6596;
  rprec.284 = rprec;
  rprec.285 = realloc (rprec.284, D.6597);
  rprec = rprec.285;
  rprec.284 = rprec;
  if (rprec.284 == 0B) goto <D.6613>; else goto <D.6614>;
  <D.6613>:
  no_space ();
  <D.6614>:
  nrules.279 = nrules;
  nrules.286 = (unsigned int) nrules.279;
  D.6616 = (long unsigned int) nrules.286;
  rassoc.287 = rassoc;
  rassoc.288 = realloc (rassoc.287, D.6616);
  rassoc = rassoc.288;
  rassoc.287 = rassoc;
  if (rassoc.287 == 0B) goto <D.6619>; else goto <D.6620>;
  <D.6619>:
  no_space ();
  <D.6620>:
  ritem.278 = ritem;
  *ritem.278 = -1;
  ritem.278 = ritem;
  D.6621 = ritem.278 + 2;
  goal.289 = goal;
  D.6623 = goal.289->index;
  *D.6621 = D.6623;
  ritem.278 = ritem;
  D.6624 = ritem.278 + 4;
  *D.6624 = 0;
  ritem.278 = ritem;
  D.6625 = ritem.278 + 6;
  *D.6625 = -2;
  rlhs.281 = rlhs;
  *rlhs.281 = 0;
  rlhs.281 = rlhs;
  D.6626 = rlhs.281 + 2;
  *D.6626 = 0;
  rlhs.281 = rlhs;
  D.6627 = rlhs.281 + 4;
  start_symbol.290 = start_symbol;
  D.6629 = (short int) start_symbol.290;
  *D.6627 = D.6629;
  rrhs.283 = rrhs;
  *rrhs.283 = 0;
  rrhs.283 = rrhs;
  D.6630 = rrhs.283 + 2;
  *D.6630 = 0;
  rrhs.283 = rrhs;
  D.6631 = rrhs.283 + 4;
  *D.6631 = 1;
  j = 4;
  i = 3;
  goto <D.4569>;
  <D.4568>:
  rlhs.281 = rlhs;
  D.6632 = (long unsigned int) i;
  D.6633 = D.6632 * 2;
  D.6634 = rlhs.281 + D.6633;
  plhs.291 = plhs;
  D.6632 = (long unsigned int) i;
  D.6636 = D.6632 * 8;
  D.6637 = plhs.291 + D.6636;
  D.6638 = *D.6637;
  D.6639 = D.6638->index;
  *D.6634 = D.6639;
  rrhs.283 = rrhs;
  D.6632 = (long unsigned int) i;
  D.6633 = D.6632 * 2;
  D.6640 = rrhs.283 + D.6633;
  D.6641 = (short int) j;
  *D.6640 = D.6641;
  assoc = 0;
  prec = 0;
  goto <D.4566>;
  <D.4565>:
  ritem.278 = ritem;
  D.6642 = (long unsigned int) j;
  D.6643 = D.6642 * 2;
  D.6644 = ritem.278 + D.6643;
  pitem.292 = pitem;
  D.6642 = (long unsigned int) j;
  D.6646 = D.6642 * 8;
  D.6647 = pitem.292 + D.6646;
  D.6648 = *D.6647;
  D.6649 = D.6648->index;
  *D.6644 = D.6649;
  pitem.292 = pitem;
  D.6642 = (long unsigned int) j;
  D.6646 = D.6642 * 8;
  D.6647 = pitem.292 + D.6646;
  D.6648 = *D.6647;
  D.6650 = D.6648->class;
  if (D.6650 == 1) goto <D.6651>; else goto <D.6652>;
  <D.6651>:
  pitem.292 = pitem;
  D.6642 = (long unsigned int) j;
  D.6646 = D.6642 * 8;
  D.6647 = pitem.292 + D.6646;
  D.6648 = *D.6647;
  D.6653 = D.6648->prec;
  prec = (int) D.6653;
  pitem.292 = pitem;
  D.6642 = (long unsigned int) j;
  D.6646 = D.6642 * 8;
  D.6647 = pitem.292 + D.6646;
  D.6648 = *D.6647;
  D.6654 = D.6648->assoc;
  assoc = (int) D.6654;
  <D.6652>:
  j = j + 1;
  <D.4566>:
  pitem.292 = pitem;
  D.6642 = (long unsigned int) j;
  D.6646 = D.6642 * 8;
  D.6647 = pitem.292 + D.6646;
  D.6648 = *D.6647;
  if (D.6648 != 0B) goto <D.4565>; else goto <D.4567>;
  <D.4567>:
  ritem.278 = ritem;
  D.6642 = (long unsigned int) j;
  D.6643 = D.6642 * 2;
  D.6644 = ritem.278 + D.6643;
  D.6655 = (unsigned short) i;
  D.6656 = -D.6655;
  D.6657 = (short int) D.6656;
  *D.6644 = D.6657;
  j = j + 1;
  rprec.284 = rprec;
  D.6632 = (long unsigned int) i;
  D.6633 = D.6632 * 2;
  D.6658 = rprec.284 + D.6633;
  D.6659 = *D.6658;
  if (D.6659 == -1) goto <D.6660>; else goto <D.6661>;
  <D.6660>:
  rprec.284 = rprec;
  D.6632 = (long unsigned int) i;
  D.6633 = D.6632 * 2;
  D.6658 = rprec.284 + D.6633;
  D.6662 = (short int) prec;
  *D.6658 = D.6662;
  rassoc.287 = rassoc;
  D.6663 = (sizetype) i;
  D.6664 = rassoc.287 + D.6663;
  D.6665 = (char) assoc;
  *D.6664 = D.6665;
  <D.6661>:
  i = i + 1;
  <D.4569>:
  nrules.279 = nrules;
  if (i < nrules.279) goto <D.4568>; else goto <D.4570>;
  <D.4570>:
  rrhs.283 = rrhs;
  D.6632 = (long unsigned int) i;
  D.6633 = D.6632 * 2;
  D.6640 = rrhs.283 + D.6633;
  D.6641 = (short int) j;
  *D.6640 = D.6641;
  plhs.291 = plhs;
  free (plhs.291);
  pitem.292 = pitem;
  free (pitem.292);
}


print_grammar ()
{
  char vflag.293;
  short int * rlhs.294;
  long unsigned int D.6670;
  long unsigned int D.6671;
  short int * D.6672;
  short int D.6673;
  sizetype D.6674;
  short int * D.6675;
  short int D.6676;
  char * * symbol_name.295;
  long unsigned int D.6682;
  long unsigned int D.6683;
  char * * D.6684;
  char * D.6685;
  int D.6686;
  long unsigned int D.6687;
  unsigned int D.6688;
  unsigned int D.6689;
  short int * ritem.296;
  long unsigned int D.6692;
  long unsigned int D.6693;
  short int * D.6694;
  short int D.6695;
  long unsigned int D.6696;
  long unsigned int D.6697;
  char * * D.6698;
  char * D.6699;
  int nrules.297;
  register int i;
  register int j;
  register int k;
  int spacing;
  register struct FILE * f;

  f = verbose_file;
  vflag.293 = vflag;
  if (vflag.293 == 0) goto <D.6667>; else goto <D.6668>;
  <D.6667>:
  return;
  <D.6668>:
  k = 1;
  i = 2;
  goto <D.4586>;
  <D.4585>:
  rlhs.294 = rlhs;
  D.6670 = (long unsigned int) i;
  D.6671 = D.6670 * 2;
  D.6672 = rlhs.294 + D.6671;
  D.6673 = *D.6672;
  rlhs.294 = rlhs;
  D.6670 = (long unsigned int) i;
  D.6671 = D.6670 * 2;
  D.6674 = D.6671 + 18446744073709551614;
  D.6675 = rlhs.294 + D.6674;
  D.6676 = *D.6675;
  if (D.6673 != D.6676) goto <D.6677>; else goto <D.6678>;
  <D.6677>:
  if (i != 2) goto <D.6679>; else goto <D.6680>;
  <D.6679>:
  fprintf (f, "\n");
  <D.6680>:
  symbol_name.295 = symbol_name;
  rlhs.294 = rlhs;
  D.6670 = (long unsigned int) i;
  D.6671 = D.6670 * 2;
  D.6672 = rlhs.294 + D.6671;
  D.6673 = *D.6672;
  D.6682 = (long unsigned int) D.6673;
  D.6683 = D.6682 * 8;
  D.6684 = symbol_name.295 + D.6683;
  D.6685 = *D.6684;
  D.6686 = i + -2;
  fprintf (f, "%4d  %s :", D.6686, D.6685);
  symbol_name.295 = symbol_name;
  rlhs.294 = rlhs;
  D.6670 = (long unsigned int) i;
  D.6671 = D.6670 * 2;
  D.6672 = rlhs.294 + D.6671;
  D.6673 = *D.6672;
  D.6682 = (long unsigned int) D.6673;
  D.6683 = D.6682 * 8;
  D.6684 = symbol_name.295 + D.6683;
  D.6685 = *D.6684;
  D.6687 = strlen (D.6685);
  D.6688 = (unsigned int) D.6687;
  D.6689 = D.6688 + 1;
  spacing = (int) D.6689;
  goto <D.6690>;
  <D.6678>:
  D.6686 = i + -2;
  fprintf (f, "%4d  ", D.6686);
  j = spacing;
  goto <D.4580>;
  <D.4579>:
  _IO_putc (32, f);
  <D.4580>:
  j = j + -1;
  if (j >= 0) goto <D.4579>; else goto <D.4581>;
  <D.4581>:
  _IO_putc (124, f);
  <D.6690>:
  goto <D.4583>;
  <D.4582>:
  symbol_name.295 = symbol_name;
  ritem.296 = ritem;
  D.6692 = (long unsigned int) k;
  D.6693 = D.6692 * 2;
  D.6694 = ritem.296 + D.6693;
  D.6695 = *D.6694;
  D.6696 = (long unsigned int) D.6695;
  D.6697 = D.6696 * 8;
  D.6698 = symbol_name.295 + D.6697;
  D.6699 = *D.6698;
  fprintf (f, " %s", D.6699);
  k = k + 1;
  <D.4583>:
  ritem.296 = ritem;
  D.6692 = (long unsigned int) k;
  D.6693 = D.6692 * 2;
  D.6694 = ritem.296 + D.6693;
  D.6695 = *D.6694;
  if (D.6695 >= 0) goto <D.4582>; else goto <D.4584>;
  <D.4584>:
  k = k + 1;
  _IO_putc (10, f);
  i = i + 1;
  <D.4586>:
  nrules.297 = nrules;
  if (i < nrules.297) goto <D.4585>; else goto <D.4587>;
  <D.4587>:
}


reader ()
{
  extern int create_symbol_table ();
  extern int free_symbol_table ();
  extern int free_symbols ();

  create_symbol_table ();
  read_declarations ();
  read_grammar ();
  free_symbol_table ();
  free_tags ();
  pack_names ();
  check_symbols ();
  pack_symbols ();
  pack_grammar ();
  free_symbols ();
  print_grammar ();
}