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

  cinc.0 = cinc;
  if (cinc.0 < 0) goto <D.3979>; else goto <D.3980>;
  <D.3979>:
  __assert_fail ("cinc >= 0", "reader.c", 83, &__PRETTY_FUNCTION__);
  <D.3980>:
  cinc.0 = cinc;
  cache_size.1 = cache_size;
  if (cinc.0 >= cache_size.1) goto <D.3982>; else goto <D.3983>;
  <D.3982>:
  {
    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;
    cache.4 = cache;
    cache.5 = realloc (cache.4, cache_size.3);
    cache = cache.5;
    cache.4 = cache;
    if (cache.4 == 0B) goto <D.3988>; else goto <D.3989>;
    <D.3988>:
    no_space ();
    <D.3989>:
  }
  <D.3983>:
  cache.4 = cache;
  cinc.0 = cinc;
  cinc.6 = (sizetype) cinc.0;
  D.3991 = cache.4 + cinc.6;
  D.3992 = (char) c;
  *D.3991 = D.3992;
  cinc.0 = cinc;
  cinc.7 = cinc.0 + 1;
  cinc = cinc.7;
}


get_line ()
{
  char saw_eof.8;
  char * line.9;
  int linesize.10;
  unsigned int linesize.11;
  void * line.12;
  int lineno.13;
  int lineno.14;
  sizetype i.15;
  char * D.4014;
  char D.4015;
  int linesize.16;
  void * line.17;
  register struct FILE * f;
  register int c;
  register int i;

  f = input_file;
  saw_eof.8 = saw_eof;
  if (saw_eof.8 != 0) goto <D.3994>; else goto <D.3997>;
  <D.3997>:
  c = _IO_getc (f);
  if (c == -1) goto <D.3994>; else goto <D.3995>;
  <D.3994>:
  line.9 = line;
  if (line.9 != 0B) goto <D.3999>; else goto <D.4000>;
  <D.3999>:
  line.9 = line;
  free (line.9);
  line = 0B;
  <D.4000>:
  cptr = 0B;
  saw_eof = 1;
  return;
  <D.3995>:
  line.9 = line;
  if (line.9 == 0B) goto <D.4001>; else goto <D.4003>;
  <D.4003>:
  linesize.10 = linesize;
  if (linesize.10 != 101) goto <D.4001>; else goto <D.4002>;
  <D.4001>:
  {
    extern int no_space ();

    line.9 = line;
    if (line.9 != 0B) goto <D.4005>; else goto <D.4006>;
    <D.4005>:
    line.9 = line;
    free (line.9);
    <D.4006>:
    linesize = 101;
    linesize.10 = linesize;
    linesize.11 = (unsigned int) linesize.10;
    line.12 = malloc (linesize.11);
    line = line.12;
    line.9 = line;
    if (line.9 == 0B) goto <D.4009>; else goto <D.4010>;
    <D.4009>:
    no_space ();
    <D.4010>:
  }
  <D.4002>:
  i = 0;
  lineno.13 = lineno;
  lineno.14 = lineno.13 + 1;
  lineno = lineno.14;
  <D.3347>:
  line.9 = line;
  i.15 = (sizetype) i;
  D.4014 = line.9 + i.15;
  D.4015 = (char) c;
  *D.4014 = D.4015;
  if (c == 10) goto <D.4016>; else goto <D.4017>;
  <D.4016>:
  line.9 = line;
  cptr = line.9;
  return;
  <D.4017>:
  i = i + 1;
  linesize.10 = linesize;
  if (i >= linesize.10) goto <D.4018>; else goto <D.4019>;
  <D.4018>:
  {
    extern int no_space ();

    linesize.10 = linesize;
    linesize.16 = linesize.10 + 100;
    linesize = linesize.16;
    linesize.10 = linesize;
    linesize.11 = (unsigned int) linesize.10;
    line.9 = line;
    line.17 = realloc (line.9, linesize.11);
    line = line.17;
    line.9 = line;
    if (line.9 == 0B) goto <D.4022>; else goto <D.4023>;
    <D.4022>:
    no_space ();
    <D.4023>:
  }
  <D.4019>:
  c = _IO_getc (f);
  if (c == -1) goto <D.4024>; else goto <D.4025>;
  <D.4024>:
  line.9 = line;
  i.15 = (sizetype) i;
  D.4014 = line.9 + i.15;
  *D.4014 = 10;
  saw_eof = 1;
  line.9 = line;
  cptr = line.9;
  return;
  <D.4025>:
  goto <D.3347>;
}


dup_line ()
{
  char * line.18;
  char * D.4030;
  char D.4031;
  int s.19;
  int line.20;
  int D.4034;
  int D.4035;
  unsigned int D.4036;
  char * t.21;
  char * s.22;
  char D.4041;
  char D.4042;
  register char * p;
  register char * s;
  register char * t;
  extern int no_space ();

  line.18 = line;
  if (line.18 == 0B) goto <D.4028>; else goto <D.4029>;
  <D.4028>:
  D.4030 = 0B;
  return D.4030;
  <D.4029>:
  s = line;
  goto <D.3354>;
  <D.3353>:
  s = s + 1;
  <D.3354>:
  D.4031 = *s;
  if (D.4031 != 10) goto <D.3353>; else goto <D.3355>;
  <D.3355>:
  s.19 = (int) s;
  line.18 = line;
  line.20 = (int) line.18;
  D.4034 = s.19 - line.20;
  D.4035 = D.4034 + 1;
  D.4036 = (unsigned int) D.4035;
  p = malloc (D.4036);
  if (p == 0B) goto <D.4037>; else goto <D.4038>;
  <D.4037>:
  no_space ();
  <D.4038>:
  s = line;
  t = p;
  goto <D.3356>;
  <D.3357>:
  // predicted unlikely by continue predictor.
  goto <D.3356>;
  <D.3356>:
  t.21 = t;
  t = t.21 + 1;
  s.22 = s;
  s = s.22 + 1;
  D.4041 = *s.22;
  *t.21 = D.4041;
  D.4042 = *t.21;
  if (D.4042 != 10) goto <D.3357>; else goto <D.3358>;
  <D.3358>:
  D.4030 = p;
  return D.4030;
}


skip_comment ()
{
  char * cptr.23;
  int cptr.24;
  char * line.25;
  int line.26;
  int D.4048;
  sizetype D.4049;
  char D.4050;
  char * D.4053;
  char D.4054;
  char * cptr.27;
  register char * s;
  int st_lineno;
  char * st_line;
  char * st_cptr;

  st_lineno = lineno;
  st_line = dup_line ();
  cptr.23 = cptr;
  cptr.24 = (int) cptr.23;
  line.25 = line;
  line.26 = (int) line.25;
  D.4048 = cptr.24 - line.26;
  D.4049 = (sizetype) D.4048;
  st_cptr = st_line + D.4049;
  cptr.23 = cptr;
  s = cptr.23 + 2;
  <D.3368>:
  D.4050 = *s;
  if (D.4050 == 42) goto <D.4051>; else goto <D.4052>;
  <D.4051>:
  D.4053 = s + 1;
  D.4054 = *D.4053;
  if (D.4054 == 47) goto <D.4055>; else goto <D.4056>;
  <D.4055>:
  cptr.27 = s + 2;
  cptr = cptr.27;
  free (st_line);
  return;
  <D.4056>:
  <D.4052>:
  D.4050 = *s;
  if (D.4050 == 10) goto <D.4058>; else goto <D.4059>;
  <D.4058>:
  {
    extern int unterminated_comment ();

    get_line ();
    line.25 = line;
    if (line.25 == 0B) goto <D.4060>; else goto <D.4061>;
    <D.4060>:
    unterminated_comment (st_lineno, st_line, st_cptr);
    <D.4061>:
    s = cptr;
  }
  goto <D.4062>;
  <D.4059>:
  s = s + 1;
  <D.4062>:
  goto <D.3368>;
}


nextc ()
{
  char * line.28;
  int D.4069;
  char D.4070;
  int D.4071;
  char * D.4074;
  char D.4075;
  register char * s;

  line.28 = line;
  if (line.28 == 0B) goto <D.4065>; else goto <D.4066>;
  <D.4065>:
  get_line ();
  line.28 = line;
  if (line.28 == 0B) goto <D.4067>; else goto <D.4068>;
  <D.4067>:
  D.4069 = -1;
  return D.4069;
  <D.4068>:
  <D.4066>:
  s = cptr;
  <D.3384>:
  D.4070 = *s;
  D.4071 = (int) D.4070;
  switch (D.4071) <default: <D.3383>, case 9: <D.3375>, case 10: <D.3372>, case 11: <D.3378>, case 12: <D.3376>, case 13: <D.3377>, case 32: <D.3374>, case 44: <D.3379>, case 47: <D.3382>, case 59: <D.3380>, case 92: <D.3381>>
  <D.3372>:
  get_line ();
  line.28 = line;
  if (line.28 == 0B) goto <D.4072>; else goto <D.4073>;
  <D.4072>:
  D.4069 = -1;
  return D.4069;
  <D.4073>:
  s = cptr;
  goto <D.3373>;
  <D.3374>:
  <D.3375>:
  <D.3376>:
  <D.3377>:
  <D.3378>:
  <D.3379>:
  <D.3380>:
  s = s + 1;
  goto <D.3373>;
  <D.3381>:
  cptr = s;
  D.4069 = 37;
  return D.4069;
  <D.3382>:
  D.4074 = s + 1;
  D.4075 = *D.4074;
  if (D.4075 == 42) goto <D.4076>; else goto <D.4077>;
  <D.4076>:
  cptr = s;
  skip_comment ();
  s = cptr;
  goto <D.3373>;
  <D.4077>:
  D.4074 = s + 1;
  D.4075 = *D.4074;
  if (D.4075 == 47) goto <D.4078>; else goto <D.4079>;
  <D.4078>:
  get_line ();
  line.28 = line;
  if (line.28 == 0B) goto <D.4080>; else goto <D.4081>;
  <D.4080>:
  D.4069 = -1;
  return D.4069;
  <D.4081>:
  s = cptr;
  goto <D.3373>;
  <D.4079>:
  <D.3383>:
  cptr = s;
  D.4070 = *s;
  D.4069 = (int) D.4070;
  return D.4069;
  <D.3373>:
  goto <D.3384>;
}


keyword ()
{
  char * cptr.29;
  char * cptr.30;
  char D.4085;
  const short unsigned int * * D.4086;
  const short unsigned int * D.4087;
  unsigned int c.31;
  unsigned int D.4089;
  const short unsigned int * D.4090;
  short unsigned int D.4091;
  int D.4092;
  int D.4093;
  int D.4098;
  int c.35;
  int D.4103;
  const int iftmp.32;
  unsigned int __c.33;
  unsigned int D.4108;
  const __int32_t * * D.4111;
  const __int32_t * D.4112;
  unsigned int __c.34;
  unsigned int D.4114;
  const __int32_t * D.4115;
  unsigned int D.4119;
  const __int32_t * D.4120;
  int D.4123;
  _Bool D.4125;
  _Bool D.4126;
  _Bool D.4127;
  int D.3402;
  int iftmp.36;
  int D.3401;
  char[6] * D.4134;
  unsigned char D.4135;
  int D.4136;
  unsigned char D.4137;
  int D.4138;
  _Bool D.4139;
  _Bool D.4140;
  _Bool D.4141;
  const unsigned char * D.4144;
  unsigned char D.4145;
  int D.4146;
  const unsigned char * D.4147;
  unsigned char D.4148;
  int D.4149;
  _Bool D.4150;
  _Bool D.4151;
  const unsigned char * D.4154;
  unsigned char D.4155;
  int D.4156;
  const unsigned char * D.4157;
  unsigned char D.4158;
  int D.4159;
  _Bool D.4160;
  _Bool D.4161;
  const unsigned char * D.4164;
  unsigned char D.4165;
  int D.4166;
  const unsigned char * D.4167;
  unsigned char D.4168;
  int D.4169;
  char * cache.37;
  int D.3411;
  int iftmp.38;
  int D.3410;
  char[5] * D.4176;
  unsigned char D.4177;
  int D.4178;
  unsigned char D.4179;
  int D.4180;
  _Bool D.4181;
  _Bool D.4182;
  _Bool D.4183;
  const unsigned char * D.4186;
  unsigned char D.4187;
  int D.4188;
  const unsigned char * D.4189;
  unsigned char D.4190;
  int D.4191;
  _Bool D.4192;
  _Bool D.4193;
  const unsigned char * D.4196;
  unsigned char D.4197;
  int D.4198;
  const unsigned char * D.4199;
  unsigned char D.4200;
  int D.4201;
  _Bool D.4202;
  _Bool D.4203;
  const unsigned char * D.4206;
  unsigned char D.4207;
  int D.4208;
  const unsigned char * D.4209;
  unsigned char D.4210;
  int D.4211;
  int D.4213;
  int D.3420;
  int iftmp.39;
  int D.3419;
  char[5] * D.4217;
  unsigned char D.4218;
  int D.4219;
  unsigned char D.4220;
  int D.4221;
  _Bool D.4222;
  _Bool D.4223;
  _Bool D.4224;
  const unsigned char * D.4227;
  unsigned char D.4228;
  int D.4229;
  const unsigned char * D.4230;
  unsigned char D.4231;
  int D.4232;
  _Bool D.4233;
  _Bool D.4234;
  const unsigned char * D.4237;
  unsigned char D.4238;
  int D.4239;
  const unsigned char * D.4240;
  unsigned char D.4241;
  int D.4242;
  _Bool D.4243;
  _Bool D.4244;
  const unsigned char * D.4247;
  unsigned char D.4248;
  int D.4249;
  const unsigned char * D.4250;
  unsigned char D.4251;
  int D.4252;
  int D.3429;
  int iftmp.40;
  int D.3428;
  char[5] * D.4259;
  unsigned char D.4260;
  int D.4261;
  unsigned char D.4262;
  int D.4263;
  _Bool D.4264;
  _Bool D.4265;
  _Bool D.4266;
  const unsigned char * D.4269;
  unsigned char D.4270;
  int D.4271;
  const unsigned char * D.4272;
  unsigned char D.4273;
  int D.4274;
  _Bool D.4275;
  _Bool D.4276;
  const unsigned char * D.4279;
  unsigned char D.4280;
  int D.4281;
  const unsigned char * D.4282;
  unsigned char D.4283;
  int D.4284;
  _Bool D.4285;
  _Bool D.4286;
  const unsigned char * D.4289;
  unsigned char D.4290;
  int D.4291;
  const unsigned char * D.4292;
  unsigned char D.4293;
  int D.4294;
  int D.3438;
  int iftmp.41;
  int D.3437;
  char[6] * D.4301;
  unsigned char D.4302;
  int D.4303;
  unsigned char D.4304;
  int D.4305;
  _Bool D.4306;
  _Bool D.4307;
  _Bool D.4308;
  const unsigned char * D.4311;
  unsigned char D.4312;
  int D.4313;
  const unsigned char * D.4314;
  unsigned char D.4315;
  int D.4316;
  _Bool D.4317;
  _Bool D.4318;
  const unsigned char * D.4321;
  unsigned char D.4322;
  int D.4323;
  const unsigned char * D.4324;
  unsigned char D.4325;
  int D.4326;
  _Bool D.4327;
  _Bool D.4328;
  const unsigned char * D.4331;
  unsigned char D.4332;
  int D.4333;
  const unsigned char * D.4334;
  unsigned char D.4335;
  int D.4336;
  int D.3447;
  int iftmp.42;
  int D.3446;
  char[9] * D.4345;
  unsigned char D.4346;
  int D.4347;
  unsigned char D.4348;
  int D.4349;
  _Bool D.4350;
  _Bool D.4351;
  _Bool D.4352;
  const unsigned char * D.4355;
  unsigned char D.4356;
  int D.4357;
  const unsigned char * D.4358;
  unsigned char D.4359;
  int D.4360;
  _Bool D.4361;
  _Bool D.4362;
  const unsigned char * D.4365;
  unsigned char D.4366;
  int D.4367;
  const unsigned char * D.4368;
  unsigned char D.4369;
  int D.4370;
  _Bool D.4371;
  _Bool D.4372;
  const unsigned char * D.4375;
  unsigned char D.4376;
  int D.4377;
  const unsigned char * D.4378;
  unsigned char D.4379;
  int D.4380;
  int D.3456;
  int iftmp.43;
  int D.3455;
  char[7] * D.4386;
  unsigned char D.4387;
  int D.4388;
  unsigned char D.4389;
  int D.4390;
  _Bool D.4391;
  _Bool D.4392;
  _Bool D.4393;
  const unsigned char * D.4396;
  unsigned char D.4397;
  int D.4398;
  const unsigned char * D.4399;
  unsigned char D.4400;
  int D.4401;
  _Bool D.4402;
  _Bool D.4403;
  const unsigned char * D.4406;
  unsigned char D.4407;
  int D.4408;
  const unsigned char * D.4409;
  unsigned char D.4410;
  int D.4411;
  _Bool D.4412;
  _Bool D.4413;
  const unsigned char * D.4416;
  unsigned char D.4417;
  int D.4418;
  const unsigned char * D.4419;
  unsigned char D.4420;
  int D.4421;
  int D.3465;
  int iftmp.44;
  int D.3464;
  char[6] * D.4426;
  unsigned char D.4427;
  int D.4428;
  unsigned char D.4429;
  int D.4430;
  _Bool D.4431;
  _Bool D.4432;
  _Bool D.4433;
  const unsigned char * D.4436;
  unsigned char D.4437;
  int D.4438;
  const unsigned char * D.4439;
  unsigned char D.4440;
  int D.4441;
  _Bool D.4442;
  _Bool D.4443;
  const unsigned char * D.4446;
  unsigned char D.4447;
  int D.4448;
  const unsigned char * D.4449;
  unsigned char D.4450;
  int D.4451;
  _Bool D.4452;
  _Bool D.4453;
  const unsigned char * D.4456;
  unsigned char D.4457;
  int D.4458;
  const unsigned char * D.4459;
  unsigned char D.4460;
  int D.4461;
  _Bool D.4468;
  _Bool D.4469;
  _Bool D.4470;
  char * line.45;
  int lineno.46;
  register int c;
  char * t_cptr;
  extern int syntax_error ();

  t_cptr = cptr;
  cptr.29 = cptr;
  cptr.30 = cptr.29 + 1;
  cptr = cptr.30;
  cptr.29 = cptr;
  D.4085 = *cptr.29;
  c = (int) D.4085;
  D.4086 = __ctype_b_loc ();
  D.4087 = *D.4086;
  c.31 = (unsigned int) c;
  D.4089 = c.31 * 2;
  D.4090 = D.4087 + D.4089;
  D.4091 = *D.4090;
  D.4092 = (int) D.4091;
  D.4093 = D.4092 & 1024;
  if (D.4093 != 0) goto <D.4094>; else goto <D.4095>;
  <D.4094>:
  cinc = 0;
  <D.3393>:
  D.4086 = __ctype_b_loc ();
  D.4087 = *D.4086;
  c.31 = (unsigned int) c;
  D.4089 = c.31 * 2;
  D.4090 = D.4087 + D.4089;
  D.4091 = *D.4090;
  D.4092 = (int) D.4091;
  D.4093 = D.4092 & 1024;
  if (D.4093 != 0) goto <D.4096>; else goto <D.4097>;
  <D.4096>:
  D.4086 = __ctype_b_loc ();
  D.4087 = *D.4086;
  c.31 = (unsigned int) c;
  D.4089 = c.31 * 2;
  D.4090 = D.4087 + D.4089;
  D.4091 = *D.4090;
  D.4092 = (int) D.4091;
  D.4098 = D.4092 & 256;
  if (D.4098 != 0) goto <D.4099>; else goto <D.4100>;
  <D.4099>:
  {
    int __res;

    {
      if (1 != 0) goto <D.4101>; else goto <D.4102>;
      <D.4101>:
      D.4103 = __builtin_constant_p (c);
      if (D.4103 != 0) goto <D.4104>; else goto <D.4105>;
      <D.4104>:
      {
        int __c;

        __c = c;
        __c.33 = (unsigned int) __c;
        D.4108 = __c.33 + 128;
        if (D.4108 <= 383) goto <D.4109>; else goto <D.4110>;
        <D.4109>:
        D.4111 = __ctype_tolower_loc ();
        D.4112 = *D.4111;
        __c.34 = (unsigned int) __c;
        D.4114 = __c.34 * 4;
        D.4115 = D.4112 + D.4114;
        iftmp.32 = *D.4115;
        goto <D.4116>;
        <D.4110>:
        iftmp.32 = __c;
        <D.4116>:
        __res = iftmp.32;
      }
      goto <D.4117>;
      <D.4105>:
      __res = tolower (c);
      <D.4117>:
      goto <D.4118>;
      <D.4102>:
      D.4111 = __ctype_tolower_loc ();
      D.4112 = *D.4111;
      c.31 = (unsigned int) c;
      D.4119 = c.31 * 4;
      D.4120 = D.4112 + D.4119;
      __res = *D.4120;
      <D.4118>:
    }
    c.35 = __res;
  }
  c = c.35;
  <D.4100>:
  cachec (c);
  goto <D.4121>;
  <D.4097>:
  D.4086 = __ctype_b_loc ();
  D.4087 = *D.4086;
  c.31 = (unsigned int) c;
  D.4089 = c.31 * 2;
  D.4090 = D.4087 + D.4089;
  D.4091 = *D.4090;
  D.4092 = (int) D.4091;
  D.4123 = D.4092 & 2048;
  if (D.4123 != 0) goto <D.4122>; else goto <D.4124>;
  <D.4124>:
  D.4125 = c == 95;
  D.4126 = c == 46;
  D.4127 = D.4125 | D.4126;
  if (D.4127 != 0) goto <D.4122>; else goto <D.4128>;
  <D.4128>:
  if (c == 36) goto <D.4122>; else goto <D.3392>;
  <D.4122>:
  cachec (c);
  <D.4121>:
  cptr.29 = cptr;
  cptr.30 = cptr.29 + 1;
  cptr = cptr.30;
  cptr.29 = cptr;
  D.4085 = *cptr.29;
  c = (int) D.4085;
  goto <D.3393>;
  <D.3392>:
  cachec (0);
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = cache;
      D.4134 = "token";
      D.4135 = MEM[(const unsigned char *)D.4134];
      D.4136 = (int) D.4135;
      D.4137 = *__s2;
      D.4138 = (int) D.4137;
      __result = D.4136 - D.4138;
      {
        D.4139 = __s2_len != 0;
        D.4140 = __result == 0;
        D.4141 = D.4139 & D.4140;
        if (D.4141 != 0) goto <D.4142>; else goto <D.4143>;
        <D.4142>:
        D.4144 = &MEM[(void *)"token" + 1B];
        D.4145 = *D.4144;
        D.4146 = (int) D.4145;
        D.4147 = __s2 + 1;
        D.4148 = *D.4147;
        D.4149 = (int) D.4148;
        __result = D.4146 - D.4149;
        D.4150 = __s2_len > 1;
        D.4140 = __result == 0;
        D.4151 = D.4150 & D.4140;
        if (D.4151 != 0) goto <D.4152>; else goto <D.4153>;
        <D.4152>:
        D.4154 = &MEM[(void *)"token" + 2B];
        D.4155 = *D.4154;
        D.4156 = (int) D.4155;
        D.4157 = __s2 + 2;
        D.4158 = *D.4157;
        D.4159 = (int) D.4158;
        __result = D.4156 - D.4159;
        D.4160 = __s2_len > 2;
        D.4140 = __result == 0;
        D.4161 = D.4160 & D.4140;
        if (D.4161 != 0) goto <D.4162>; else goto <D.4163>;
        <D.4162>:
        D.4164 = &MEM[(void *)"token" + 3B];
        D.4165 = *D.4164;
        D.4166 = (int) D.4165;
        D.4167 = __s2 + 3;
        D.4168 = *D.4167;
        D.4169 = (int) D.4168;
        __result = D.4166 - D.4169;
        <D.4163>:
        <D.4153>:
        <D.4143>:
      }
      D.3401 = __result;
    }
    iftmp.36 = -D.3401;
    goto <D.4170>;
    <D.4133>:
    cache.37 = cache;
    iftmp.36 = __builtin_strcmp (cache.37, "token");
    <D.4170>:
    D.3402 = iftmp.36;
  }
  if (D.3402 == 0) goto <D.4129>; else goto <D.4172>;
  <D.4172>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = cache;
      D.4176 = "term";
      D.4177 = MEM[(const unsigned char *)D.4176];
      D.4178 = (int) D.4177;
      D.4179 = *__s2;
      D.4180 = (int) D.4179;
      __result = D.4178 - D.4180;
      {
        D.4181 = __s2_len != 0;
        D.4182 = __result == 0;
        D.4183 = D.4181 & D.4182;
        if (D.4183 != 0) goto <D.4184>; else goto <D.4185>;
        <D.4184>:
        D.4186 = &MEM[(void *)"term" + 1B];
        D.4187 = *D.4186;
        D.4188 = (int) D.4187;
        D.4189 = __s2 + 1;
        D.4190 = *D.4189;
        D.4191 = (int) D.4190;
        __result = D.4188 - D.4191;
        D.4192 = __s2_len > 1;
        D.4182 = __result == 0;
        D.4193 = D.4192 & D.4182;
        if (D.4193 != 0) goto <D.4194>; else goto <D.4195>;
        <D.4194>:
        D.4196 = &MEM[(void *)"term" + 2B];
        D.4197 = *D.4196;
        D.4198 = (int) D.4197;
        D.4199 = __s2 + 2;
        D.4200 = *D.4199;
        D.4201 = (int) D.4200;
        __result = D.4198 - D.4201;
        D.4202 = __s2_len > 2;
        D.4182 = __result == 0;
        D.4203 = D.4202 & D.4182;
        if (D.4203 != 0) goto <D.4204>; else goto <D.4205>;
        <D.4204>:
        D.4206 = &MEM[(void *)"term" + 3B];
        D.4207 = *D.4206;
        D.4208 = (int) D.4207;
        D.4209 = __s2 + 3;
        D.4210 = *D.4209;
        D.4211 = (int) D.4210;
        __result = D.4208 - D.4211;
        <D.4205>:
        <D.4195>:
        <D.4185>:
      }
      D.3410 = __result;
    }
    iftmp.38 = -D.3410;
    goto <D.4212>;
    <D.4175>:
    cache.37 = cache;
    iftmp.38 = __builtin_strcmp (cache.37, "term");
    <D.4212>:
    D.3411 = iftmp.38;
  }
  if (D.3411 == 0) goto <D.4129>; else goto <D.4130>;
  <D.4129>:
  D.4213 = 0;
  return D.4213;
  <D.4130>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = cache;
      D.4217 = "type";
      D.4218 = MEM[(const unsigned char *)D.4217];
      D.4219 = (int) D.4218;
      D.4220 = *__s2;
      D.4221 = (int) D.4220;
      __result = D.4219 - D.4221;
      {
        D.4222 = __s2_len != 0;
        D.4223 = __result == 0;
        D.4224 = D.4222 & D.4223;
        if (D.4224 != 0) goto <D.4225>; else goto <D.4226>;
        <D.4225>:
        D.4227 = &MEM[(void *)"type" + 1B];
        D.4228 = *D.4227;
        D.4229 = (int) D.4228;
        D.4230 = __s2 + 1;
        D.4231 = *D.4230;
        D.4232 = (int) D.4231;
        __result = D.4229 - D.4232;
        D.4233 = __s2_len > 1;
        D.4223 = __result == 0;
        D.4234 = D.4233 & D.4223;
        if (D.4234 != 0) goto <D.4235>; else goto <D.4236>;
        <D.4235>:
        D.4237 = &MEM[(void *)"type" + 2B];
        D.4238 = *D.4237;
        D.4239 = (int) D.4238;
        D.4240 = __s2 + 2;
        D.4241 = *D.4240;
        D.4242 = (int) D.4241;
        __result = D.4239 - D.4242;
        D.4243 = __s2_len > 2;
        D.4223 = __result == 0;
        D.4244 = D.4243 & D.4223;
        if (D.4244 != 0) goto <D.4245>; else goto <D.4246>;
        <D.4245>:
        D.4247 = &MEM[(void *)"type" + 3B];
        D.4248 = *D.4247;
        D.4249 = (int) D.4248;
        D.4250 = __s2 + 3;
        D.4251 = *D.4250;
        D.4252 = (int) D.4251;
        __result = D.4249 - D.4252;
        <D.4246>:
        <D.4236>:
        <D.4226>:
      }
      D.3419 = __result;
    }
    iftmp.39 = -D.3419;
    goto <D.4253>;
    <D.4216>:
    cache.37 = cache;
    iftmp.39 = __builtin_strcmp (cache.37, "type");
    <D.4253>:
    D.3420 = iftmp.39;
  }
  if (D.3420 == 0) goto <D.4254>; else goto <D.4255>;
  <D.4254>:
  D.4213 = 6;
  return D.4213;
  <D.4255>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = cache;
      D.4259 = "left";
      D.4260 = MEM[(const unsigned char *)D.4259];
      D.4261 = (int) D.4260;
      D.4262 = *__s2;
      D.4263 = (int) D.4262;
      __result = D.4261 - D.4263;
      {
        D.4264 = __s2_len != 0;
        D.4265 = __result == 0;
        D.4266 = D.4264 & D.4265;
        if (D.4266 != 0) goto <D.4267>; else goto <D.4268>;
        <D.4267>:
        D.4269 = &MEM[(void *)"left" + 1B];
        D.4270 = *D.4269;
        D.4271 = (int) D.4270;
        D.4272 = __s2 + 1;
        D.4273 = *D.4272;
        D.4274 = (int) D.4273;
        __result = D.4271 - D.4274;
        D.4275 = __s2_len > 1;
        D.4265 = __result == 0;
        D.4276 = D.4275 & D.4265;
        if (D.4276 != 0) goto <D.4277>; else goto <D.4278>;
        <D.4277>:
        D.4279 = &MEM[(void *)"left" + 2B];
        D.4280 = *D.4279;
        D.4281 = (int) D.4280;
        D.4282 = __s2 + 2;
        D.4283 = *D.4282;
        D.4284 = (int) D.4283;
        __result = D.4281 - D.4284;
        D.4285 = __s2_len > 2;
        D.4265 = __result == 0;
        D.4286 = D.4285 & D.4265;
        if (D.4286 != 0) goto <D.4287>; else goto <D.4288>;
        <D.4287>:
        D.4289 = &MEM[(void *)"left" + 3B];
        D.4290 = *D.4289;
        D.4291 = (int) D.4290;
        D.4292 = __s2 + 3;
        D.4293 = *D.4292;
        D.4294 = (int) D.4293;
        __result = D.4291 - D.4294;
        <D.4288>:
        <D.4278>:
        <D.4268>:
      }
      D.3428 = __result;
    }
    iftmp.40 = -D.3428;
    goto <D.4295>;
    <D.4258>:
    cache.37 = cache;
    iftmp.40 = __builtin_strcmp (cache.37, "left");
    <D.4295>:
    D.3429 = iftmp.40;
  }
  if (D.3429 == 0) goto <D.4296>; else goto <D.4297>;
  <D.4296>:
  D.4213 = 1;
  return D.4213;
  <D.4297>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = cache;
      D.4301 = "right";
      D.4302 = MEM[(const unsigned char *)D.4301];
      D.4303 = (int) D.4302;
      D.4304 = *__s2;
      D.4305 = (int) D.4304;
      __result = D.4303 - D.4305;
      {
        D.4306 = __s2_len != 0;
        D.4307 = __result == 0;
        D.4308 = D.4306 & D.4307;
        if (D.4308 != 0) goto <D.4309>; else goto <D.4310>;
        <D.4309>:
        D.4311 = &MEM[(void *)"right" + 1B];
        D.4312 = *D.4311;
        D.4313 = (int) D.4312;
        D.4314 = __s2 + 1;
        D.4315 = *D.4314;
        D.4316 = (int) D.4315;
        __result = D.4313 - D.4316;
        D.4317 = __s2_len > 1;
        D.4307 = __result == 0;
        D.4318 = D.4317 & D.4307;
        if (D.4318 != 0) goto <D.4319>; else goto <D.4320>;
        <D.4319>:
        D.4321 = &MEM[(void *)"right" + 2B];
        D.4322 = *D.4321;
        D.4323 = (int) D.4322;
        D.4324 = __s2 + 2;
        D.4325 = *D.4324;
        D.4326 = (int) D.4325;
        __result = D.4323 - D.4326;
        D.4327 = __s2_len > 2;
        D.4307 = __result == 0;
        D.4328 = D.4327 & D.4307;
        if (D.4328 != 0) goto <D.4329>; else goto <D.4330>;
        <D.4329>:
        D.4331 = &MEM[(void *)"right" + 3B];
        D.4332 = *D.4331;
        D.4333 = (int) D.4332;
        D.4334 = __s2 + 3;
        D.4335 = *D.4334;
        D.4336 = (int) D.4335;
        __result = D.4333 - D.4336;
        <D.4330>:
        <D.4320>:
        <D.4310>:
      }
      D.3437 = __result;
    }
    iftmp.41 = -D.3437;
    goto <D.4337>;
    <D.4300>:
    cache.37 = cache;
    iftmp.41 = __builtin_strcmp (cache.37, "right");
    <D.4337>:
    D.3438 = iftmp.41;
  }
  if (D.3438 == 0) goto <D.4338>; else goto <D.4339>;
  <D.4338>:
  D.4213 = 2;
  return D.4213;
  <D.4339>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = cache;
      D.4345 = "nonassoc";
      D.4346 = MEM[(const unsigned char *)D.4345];
      D.4347 = (int) D.4346;
      D.4348 = *__s2;
      D.4349 = (int) D.4348;
      __result = D.4347 - D.4349;
      {
        D.4350 = __s2_len != 0;
        D.4351 = __result == 0;
        D.4352 = D.4350 & D.4351;
        if (D.4352 != 0) goto <D.4353>; else goto <D.4354>;
        <D.4353>:
        D.4355 = &MEM[(void *)"nonassoc" + 1B];
        D.4356 = *D.4355;
        D.4357 = (int) D.4356;
        D.4358 = __s2 + 1;
        D.4359 = *D.4358;
        D.4360 = (int) D.4359;
        __result = D.4357 - D.4360;
        D.4361 = __s2_len > 1;
        D.4351 = __result == 0;
        D.4362 = D.4361 & D.4351;
        if (D.4362 != 0) goto <D.4363>; else goto <D.4364>;
        <D.4363>:
        D.4365 = &MEM[(void *)"nonassoc" + 2B];
        D.4366 = *D.4365;
        D.4367 = (int) D.4366;
        D.4368 = __s2 + 2;
        D.4369 = *D.4368;
        D.4370 = (int) D.4369;
        __result = D.4367 - D.4370;
        D.4371 = __s2_len > 2;
        D.4351 = __result == 0;
        D.4372 = D.4371 & D.4351;
        if (D.4372 != 0) goto <D.4373>; else goto <D.4374>;
        <D.4373>:
        D.4375 = &MEM[(void *)"nonassoc" + 3B];
        D.4376 = *D.4375;
        D.4377 = (int) D.4376;
        D.4378 = __s2 + 3;
        D.4379 = *D.4378;
        D.4380 = (int) D.4379;
        __result = D.4377 - D.4380;
        <D.4374>:
        <D.4364>:
        <D.4354>:
      }
      D.3446 = __result;
    }
    iftmp.42 = -D.3446;
    goto <D.4381>;
    <D.4344>:
    cache.37 = cache;
    iftmp.42 = __builtin_strcmp (cache.37, "nonassoc");
    <D.4381>:
    D.3447 = iftmp.42;
  }
  if (D.3447 == 0) goto <D.4340>; else goto <D.4382>;
  <D.4382>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = cache;
      D.4386 = "binary";
      D.4387 = MEM[(const unsigned char *)D.4386];
      D.4388 = (int) D.4387;
      D.4389 = *__s2;
      D.4390 = (int) D.4389;
      __result = D.4388 - D.4390;
      {
        D.4391 = __s2_len != 0;
        D.4392 = __result == 0;
        D.4393 = D.4391 & D.4392;
        if (D.4393 != 0) goto <D.4394>; else goto <D.4395>;
        <D.4394>:
        D.4396 = &MEM[(void *)"binary" + 1B];
        D.4397 = *D.4396;
        D.4398 = (int) D.4397;
        D.4399 = __s2 + 1;
        D.4400 = *D.4399;
        D.4401 = (int) D.4400;
        __result = D.4398 - D.4401;
        D.4402 = __s2_len > 1;
        D.4392 = __result == 0;
        D.4403 = D.4402 & D.4392;
        if (D.4403 != 0) goto <D.4404>; else goto <D.4405>;
        <D.4404>:
        D.4406 = &MEM[(void *)"binary" + 2B];
        D.4407 = *D.4406;
        D.4408 = (int) D.4407;
        D.4409 = __s2 + 2;
        D.4410 = *D.4409;
        D.4411 = (int) D.4410;
        __result = D.4408 - D.4411;
        D.4412 = __s2_len > 2;
        D.4392 = __result == 0;
        D.4413 = D.4412 & D.4392;
        if (D.4413 != 0) goto <D.4414>; else goto <D.4415>;
        <D.4414>:
        D.4416 = &MEM[(void *)"binary" + 3B];
        D.4417 = *D.4416;
        D.4418 = (int) D.4417;
        D.4419 = __s2 + 3;
        D.4420 = *D.4419;
        D.4421 = (int) D.4420;
        __result = D.4418 - D.4421;
        <D.4415>:
        <D.4405>:
        <D.4395>:
      }
      D.3455 = __result;
    }
    iftmp.43 = -D.3455;
    goto <D.4422>;
    <D.4385>:
    cache.37 = cache;
    iftmp.43 = __builtin_strcmp (cache.37, "binary");
    <D.4422>:
    D.3456 = iftmp.43;
  }
  if (D.3456 == 0) goto <D.4340>; else goto <D.4341>;
  <D.4340>:
  D.4213 = 3;
  return D.4213;
  <D.4341>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = cache;
      D.4426 = "start";
      D.4427 = MEM[(const unsigned char *)D.4426];
      D.4428 = (int) D.4427;
      D.4429 = *__s2;
      D.4430 = (int) D.4429;
      __result = D.4428 - D.4430;
      {
        D.4431 = __s2_len != 0;
        D.4432 = __result == 0;
        D.4433 = D.4431 & D.4432;
        if (D.4433 != 0) goto <D.4434>; else goto <D.4435>;
        <D.4434>:
        D.4436 = &MEM[(void *)"start" + 1B];
        D.4437 = *D.4436;
        D.4438 = (int) D.4437;
        D.4439 = __s2 + 1;
        D.4440 = *D.4439;
        D.4441 = (int) D.4440;
        __result = D.4438 - D.4441;
        D.4442 = __s2_len > 1;
        D.4432 = __result == 0;
        D.4443 = D.4442 & D.4432;
        if (D.4443 != 0) goto <D.4444>; else goto <D.4445>;
        <D.4444>:
        D.4446 = &MEM[(void *)"start" + 2B];
        D.4447 = *D.4446;
        D.4448 = (int) D.4447;
        D.4449 = __s2 + 2;
        D.4450 = *D.4449;
        D.4451 = (int) D.4450;
        __result = D.4448 - D.4451;
        D.4452 = __s2_len > 2;
        D.4432 = __result == 0;
        D.4453 = D.4452 & D.4432;
        if (D.4453 != 0) goto <D.4454>; else goto <D.4455>;
        <D.4454>:
        D.4456 = &MEM[(void *)"start" + 3B];
        D.4457 = *D.4456;
        D.4458 = (int) D.4457;
        D.4459 = __s2 + 3;
        D.4460 = *D.4459;
        D.4461 = (int) D.4460;
        __result = D.4458 - D.4461;
        <D.4455>:
        <D.4445>:
        <D.4435>:
      }
      D.3464 = __result;
    }
    iftmp.44 = -D.3464;
    goto <D.4462>;
    <D.4425>:
    cache.37 = cache;
    iftmp.44 = __builtin_strcmp (cache.37, "start");
    <D.4462>:
    D.3465 = iftmp.44;
  }
  if (D.3465 == 0) goto <D.4463>; else goto <D.4464>;
  <D.4463>:
  D.4213 = 7;
  return D.4213;
  <D.4464>:
  goto <D.4465>;
  <D.4095>:
  cptr.29 = cptr;
  cptr.30 = cptr.29 + 1;
  cptr = cptr.30;
  if (c == 123) goto <D.4466>; else goto <D.4467>;
  <D.4466>:
  D.4213 = 5;
  return D.4213;
  <D.4467>:
  D.4468 = c == 37;
  D.4469 = c == 92;
  D.4470 = D.4468 | D.4469;
  if (D.4470 != 0) goto <D.4471>; else goto <D.4472>;
  <D.4471>:
  D.4213 = 4;
  return D.4213;
  <D.4472>:
  if (c == 60) goto <D.4473>; else goto <D.4474>;
  <D.4473>:
  D.4213 = 1;
  return D.4213;
  <D.4474>:
  if (c == 62) goto <D.4475>; else goto <D.4476>;
  <D.4475>:
  D.4213 = 2;
  return D.4213;
  <D.4476>:
  if (c == 48) goto <D.4477>; else goto <D.4478>;
  <D.4477>:
  D.4213 = 0;
  return D.4213;
  <D.4478>:
  if (c == 50) goto <D.4479>; else goto <D.4480>;
  <D.4479>:
  D.4213 = 3;
  return D.4213;
  <D.4480>:
  <D.4465>:
  line.45 = line;
  lineno.46 = lineno;
  syntax_error (lineno.46, line.45, t_cptr);
}


tolower (int __c)
{
  int D.4484;
  int iftmp.47;
  unsigned int __c.48;
  unsigned int D.4487;
  const __int32_t * * D.4490;
  const __int32_t * D.4491;
  unsigned int __c.49;
  unsigned int D.4493;
  const __int32_t * D.4494;

  __c.48 = (unsigned int) __c;
  D.4487 = __c.48 + 128;
  if (D.4487 <= 383) goto <D.4488>; else goto <D.4489>;
  <D.4488>:
  D.4490 = __ctype_tolower_loc ();
  D.4491 = *D.4490;
  __c.49 = (unsigned int) __c;
  D.4493 = __c.49 * 4;
  D.4494 = D.4491 + D.4493;
  iftmp.47 = *D.4494;
  goto <D.4495>;
  <D.4489>:
  iftmp.47 = __c;
  <D.4495>:
  D.4484 = iftmp.47;
  return D.4484;
}


copy_text (struct FILE * f)
{
  char * cptr.50;
  int cptr.51;
  char * line.52;
  int line.53;
  int D.4501;
  sizetype D.4502;
  sizetype D.4503;
  char D.4504;
  char * input_file_name.54;
  int lineno.55;
  char * line_format.56;
  char * cptr.57;
  char * cptr.58;
  char D.4514;
  sizetype D.4516;
  char * cptr.59;
  char * cptr.60;
  char D.4519;
  char * cptr.61;
  char * cptr.62;
  char D.4528;
  char * cptr.63;
  char * cptr.64;
  char * cptr.65;
  char D.4540;
  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.50 = cptr;
  cptr.51 = (int) cptr.50;
  line.52 = line;
  line.53 = (int) line.52;
  D.4501 = cptr.51 - line.53;
  D.4502 = (sizetype) D.4501;
  D.4503 = D.4502 + 4294967294;
  t_cptr = t_line + D.4503;
  cptr.50 = cptr;
  D.4504 = *cptr.50;
  if (D.4504 == 10) goto <D.4505>; else goto <D.4506>;
  <D.4505>:
  {
    extern int unterminated_text ();

    get_line ();
    line.52 = line;
    if (line.52 == 0B) goto <D.4507>; else goto <D.4508>;
    <D.4507>:
    unterminated_text (t_lineno, t_line, t_cptr);
    <D.4508>:
  }
  <D.4506>:
  input_file_name.54 = input_file_name;
  lineno.55 = lineno;
  line_format.56 = line_format;
  fprintf (f, line_format.56, lineno.55, input_file_name.54);
  loop:
  cptr.50 = cptr;
  cptr.57 = cptr.50;
  cptr.58 = cptr.57 + 1;
  cptr = cptr.58;
  D.4514 = *cptr.57;
  c = (int) D.4514;
  switch (c) <default: <D.3500>, case 10: <D.3480>, case 34: <D.3483>, case 37: <D.3498>, case 39: <D.3482>, case 47: <D.3490>, case 92: <D.3499>>
  {
    extern int unterminated_text ();

    <D.3480>:
    next_line:
    _IO_putc (10, f);
    need_newline = 0;
    get_line ();
    line.52 = line;
    if (line.52 != 0B) goto loop; else goto <D.4515>;
    <D.4515>:
    unterminated_text (t_lineno, t_line, t_cptr);
    <D.3482>:
    <D.3483>:
    {
      int s_lineno;
      char * s_line;
      char * s_cptr;

      s_lineno = lineno;
      s_line = dup_line ();
      cptr.50 = cptr;
      cptr.51 = (int) cptr.50;
      line.52 = line;
      line.53 = (int) line.52;
      D.4501 = cptr.51 - line.53;
      D.4502 = (sizetype) D.4501;
      D.4516 = D.4502 + 4294967295;
      s_cptr = s_line + D.4516;
      quote = c;
      _IO_putc (c, f);
      <D.3489>:
      {
        extern int unterminated_string ();

        cptr.50 = cptr;
        cptr.59 = cptr.50;
        cptr.60 = cptr.59 + 1;
        cptr = cptr.60;
        D.4519 = *cptr.59;
        c = (int) D.4519;
        _IO_putc (c, f);
        if (c == quote) goto <D.4520>; else goto <D.4521>;
        <D.4520>:
        need_newline = 1;
        free (s_line);
        goto loop;
        <D.4521>:
        if (c == 10) goto <D.4522>; else goto <D.4523>;
        <D.4522>:
        unterminated_string (s_lineno, s_line, s_cptr);
        <D.4523>:
        if (c == 92) goto <D.4524>; else goto <D.4525>;
        <D.4524>:
        cptr.50 = cptr;
        cptr.61 = cptr.50;
        cptr.62 = cptr.61 + 1;
        cptr = cptr.62;
        D.4528 = *cptr.61;
        c = (int) D.4528;
        _IO_putc (c, f);
        if (c == 10) goto <D.4529>; else goto <D.4530>;
        <D.4529>:
        get_line ();
        line.52 = line;
        if (line.52 == 0B) goto <D.4531>; else goto <D.4532>;
        <D.4531>:
        unterminated_string (s_lineno, s_line, s_cptr);
        <D.4532>:
        <D.4530>:
        <D.4525>:
      }
      goto <D.3489>;
    }
    <D.3490>:
    _IO_putc (c, f);
    need_newline = 1;
    cptr.50 = cptr;
    D.4504 = *cptr.50;
    c = (int) D.4504;
    if (c == 47) goto <D.4533>; else goto <D.4534>;
    <D.4533>:
    <D.3491>:
    _IO_putc (c, f);
    cptr.50 = cptr;
    cptr.63 = cptr.50 + 1;
    cptr = cptr.63;
    cptr.50 = cptr;
    D.4504 = *cptr.50;
    c = (int) D.4504;
    if (c != 10) goto <D.3491>; else goto <D.3492>;
    <D.3492>:
    goto next_line;
    <D.4534>:
    if (c == 42) goto <D.4536>; else goto <D.4537>;
    <D.4536>:
    {
      int c_lineno;
      char * c_line;
      char * c_cptr;

      c_lineno = lineno;
      c_line = dup_line ();
      cptr.50 = cptr;
      cptr.51 = (int) cptr.50;
      line.52 = line;
      line.53 = (int) line.52;
      D.4501 = cptr.51 - line.53;
      D.4502 = (sizetype) D.4501;
      D.4516 = D.4502 + 4294967295;
      c_cptr = c_line + D.4516;
      _IO_putc (42, f);
      cptr.50 = cptr;
      cptr.63 = cptr.50 + 1;
      cptr = cptr.63;
      <D.3497>:
      cptr.50 = cptr;
      cptr.64 = cptr.50;
      cptr.65 = cptr.64 + 1;
      cptr = cptr.65;
      D.4540 = *cptr.64;
      c = (int) D.4540;
      _IO_putc (c, f);
      if (c == 42) goto <D.4541>; else goto <D.4542>;
      <D.4541>:
      cptr.50 = cptr;
      D.4504 = *cptr.50;
      if (D.4504 == 47) goto <D.4543>; else goto <D.4544>;
      <D.4543>:
      _IO_putc (47, f);
      cptr.50 = cptr;
      cptr.63 = cptr.50 + 1;
      cptr = cptr.63;
      free (c_line);
      goto loop;
      <D.4544>:
      <D.4542>:
      if (c == 10) goto <D.4545>; else goto <D.4546>;
      <D.4545>:
      {
        extern int unterminated_comment ();

        get_line ();
        line.52 = line;
        if (line.52 == 0B) goto <D.4547>; else goto <D.4548>;
        <D.4547>:
        unterminated_comment (c_lineno, c_line, c_cptr);
        <D.4548>:
      }
      <D.4546>:
      goto <D.3497>;
    }
    <D.4537>:
    need_newline = 1;
    goto loop;
    <D.3498>:
    <D.3499>:
    cptr.50 = cptr;
    D.4504 = *cptr.50;
    if (D.4504 == 125) goto <D.4549>; else goto <D.4550>;
    <D.4549>:
    if (need_newline != 0) goto <D.4551>; else goto <D.4552>;
    <D.4551>:
    _IO_putc (10, f);
    <D.4552>:
    cptr.50 = cptr;
    cptr.63 = cptr.50 + 1;
    cptr = cptr.63;
    free (t_line);
    return;
    <D.4550>:
    <D.3500>:
    _IO_putc (c, f);
    need_newline = 1;
    goto loop;
  }
}


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

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


hexval (int c)
{
  unsigned int c.66;
  unsigned int D.4557;
  int D.4560;
  unsigned int D.4561;
  unsigned int D.4564;

  c.66 = (unsigned int) c;
  D.4557 = c.66 + 4294967248;
  if (D.4557 <= 9) goto <D.4558>; else goto <D.4559>;
  <D.4558>:
  D.4560 = c + -48;
  return D.4560;
  <D.4559>:
  c.66 = (unsigned int) c;
  D.4561 = c.66 + 4294967231;
  if (D.4561 <= 5) goto <D.4562>; else goto <D.4563>;
  <D.4562>:
  D.4560 = c + -55;
  return D.4560;
  <D.4563>:
  c.66 = (unsigned int) c;
  D.4564 = c.66 + 4294967199;
  if (D.4564 <= 5) goto <D.4565>; else goto <D.4566>;
  <D.4565>:
  D.4560 = c + -87;
  return D.4560;
  <D.4566>:
  D.4560 = -1;
  return D.4560;
}


get_literal ()
{
  char * cptr.67;
  int cptr.68;
  char * line.69;
  int line.70;
  int D.4572;
  sizetype D.4573;
  char * cptr.71;
  char * cptr.72;
  char D.4576;
  char * cptr.73;
  char * cptr.74;
  char D.4579;
  char * cptr.75;
  char * cptr.76;
  char D.4587;
  char D.4590;
  unsigned int c.77;
  unsigned int D.4592;
  int D.4595;
  int D.4596;
  char * cptr.78;
  char * cptr.79;
  char * cptr.80;
  char D.4604;
  unsigned int n.81;
  unsigned int i.82;
  int D.4610;
  unsigned int n.83;
  sizetype i.84;
  char * D.4618;
  char * cache.85;
  char * D.4620;
  char D.4621;
  unsigned char * D.4625;
  unsigned char D.4626;
  char D.4631;
  int D.4632;
  const short unsigned int * * D.4633;
  const short unsigned int * D.4634;
  unsigned int c.86;
  unsigned int D.4636;
  const short unsigned int * D.4637;
  short unsigned int D.4638;
  int D.4639;
  int D.4640;
  int D.4644;
  int D.4645;
  int D.4646;
  int D.4647;
  int D.4648;
  int D.4649;
  int D.4650;
  int D.4651;
  short int D.4657;
  unsigned char D.4660;
  short int D.4661;
  struct bucket * D.4662;
  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.67 = cptr;
  cptr.68 = (int) cptr.67;
  line.69 = line;
  line.70 = (int) line.69;
  D.4572 = cptr.68 - line.70;
  D.4573 = (sizetype) D.4572;
  s_cptr = s_line + D.4573;
  cptr.67 = cptr;
  cptr.71 = cptr.67;
  cptr.72 = cptr.71 + 1;
  cptr = cptr.72;
  D.4576 = *cptr.71;
  quote = (int) D.4576;
  cinc = 0;
  <D.3542>:
  {
    extern int unterminated_string ();

    cptr.67 = cptr;
    cptr.73 = cptr.67;
    cptr.74 = cptr.73 + 1;
    cptr = cptr.74;
    D.4579 = *cptr.73;
    c = (int) D.4579;
    if (c == quote) goto <D.3516>; else goto <D.4580>;
    <D.4580>:
    if (c == 10) goto <D.4581>; else goto <D.4582>;
    <D.4581>:
    unterminated_string (s_lineno, s_line, s_cptr);
    <D.4582>:
    if (c == 92) goto <D.4583>; else goto <D.4584>;
    <D.4583>:
    {
      char * c_cptr;

      cptr.67 = cptr;
      c_cptr = cptr.67 + 4294967295;
      cptr.67 = cptr;
      cptr.75 = cptr.67;
      cptr.76 = cptr.75 + 1;
      cptr = cptr.76;
      D.4587 = *cptr.75;
      c = (int) D.4587;
      switch (c) <default: <D.4613>, case 10: <D.3518>, case 48: <D.3520>, case 49: <D.3521>, case 50: <D.3522>, case 51: <D.3523>, case 52: <D.3524>, case 53: <D.3525>, case 54: <D.3526>, case 55: <D.3527>, case 97: <D.3533>, case 98: <D.3534>, case 102: <D.3535>, case 110: <D.3536>, case 114: <D.3537>, case 116: <D.3538>, case 118: <D.3539>, case 120: <D.3530>>
      {
        extern int illegal_character ();

        <D.3518>:
        get_line ();
        line.69 = line;
        if (line.69 == 0B) goto <D.4588>; else goto <D.4589>;
        <D.4588>:
        unterminated_string (s_lineno, s_line, s_cptr);
        <D.4589>:
        // predicted unlikely by continue predictor.
        goto <D.3519>;
        <D.3520>:
        <D.3521>:
        <D.3522>:
        <D.3523>:
        <D.3524>:
        <D.3525>:
        <D.3526>:
        <D.3527>:
        n = c + -48;
        cptr.67 = cptr;
        D.4590 = *cptr.67;
        c = (int) D.4590;
        c.77 = (unsigned int) c;
        D.4592 = c.77 + 4294967248;
        if (D.4592 <= 7) goto <D.4593>; else goto <D.4594>;
        <D.4593>:
        D.4595 = n << 3;
        D.4596 = c + -48;
        n = D.4595 + D.4596;
        cptr.67 = cptr;
        cptr.78 = cptr.67 + 1;
        cptr = cptr.78;
        cptr.67 = cptr;
        D.4590 = *cptr.67;
        c = (int) D.4590;
        c.77 = (unsigned int) c;
        D.4592 = c.77 + 4294967248;
        if (D.4592 <= 7) goto <D.4598>; else goto <D.4599>;
        <D.4598>:
        D.4595 = n << 3;
        D.4596 = c + -48;
        n = D.4595 + D.4596;
        cptr.67 = cptr;
        cptr.78 = cptr.67 + 1;
        cptr = cptr.78;
        <D.4599>:
        <D.4594>:
        if (n > 255) goto <D.4600>; else goto <D.4601>;
        <D.4600>:
        illegal_character (c_cptr);
        <D.4601>:
        c = n;
        goto <D.3529>;
        <D.3530>:
        cptr.67 = cptr;
        cptr.79 = cptr.67;
        cptr.80 = cptr.79 + 1;
        cptr = cptr.80;
        D.4604 = *cptr.79;
        c = (int) D.4604;
        n = hexval (c);
        n.81 = (unsigned int) n;
        if (n.81 > 15) goto <D.4606>; else goto <D.4607>;
        <D.4606>:
        illegal_character (c_cptr);
        <D.4607>:
        <D.3532>:
        cptr.67 = cptr;
        D.4590 = *cptr.67;
        c = (int) D.4590;
        i = hexval (c);
        i.82 = (unsigned int) i;
        if (i.82 > 15) goto <D.3531>; else goto <D.4609>;
        <D.4609>:
        cptr.67 = cptr;
        cptr.78 = cptr.67 + 1;
        cptr = cptr.78;
        D.4610 = n << 4;
        n = D.4610 + i;
        if (n > 255) goto <D.4611>; else goto <D.4612>;
        <D.4611>:
        illegal_character (c_cptr);
        <D.4612>:
        goto <D.3532>;
        <D.3531>:
        c = n;
        goto <D.3529>;
        <D.3533>:
        c = 7;
        goto <D.3529>;
        <D.3534>:
        c = 8;
        goto <D.3529>;
        <D.3535>:
        c = 12;
        goto <D.3529>;
        <D.3536>:
        c = 10;
        goto <D.3529>;
        <D.3537>:
        c = 13;
        goto <D.3529>;
        <D.3538>:
        c = 9;
        goto <D.3529>;
        <D.3539>:
        c = 11;
        goto <D.3529>;
      }
      <D.4613>:
      <D.3529>:
    }
    <D.4584>:
    cachec (c);
  }
  <D.3519>:
  goto <D.3542>;
  <D.3516>:
  free (s_line);
  n = cinc;
  n.83 = (unsigned int) n;
  s = malloc (n.83);
  if (s == 0B) goto <D.4615>; else goto <D.4616>;
  <D.4615>:
  no_space ();
  <D.4616>:
  i = 0;
  goto <D.3544>;
  <D.3543>:
  i.84 = (sizetype) i;
  D.4618 = s + i.84;
  cache.85 = cache;
  i.84 = (sizetype) i;
  D.4620 = cache.85 + i.84;
  D.4621 = *D.4620;
  *D.4618 = D.4621;
  i = i + 1;
  <D.3544>:
  if (i < n) goto <D.3543>; else goto <D.3545>;
  <D.3545>:
  cinc = 0;
  if (n == 1) goto <D.4622>; else goto <D.4623>;
  <D.4622>:
  cachec (39);
  goto <D.4624>;
  <D.4623>:
  cachec (34);
  <D.4624>:
  i = 0;
  goto <D.3556>;
  <D.3555>:
  i.84 = (sizetype) i;
  D.4625 = s + i.84;
  D.4626 = *D.4625;
  c = (int) D.4626;
  if (c == 92) goto <D.4627>; else goto <D.4630>;
  <D.4630>:
  cache.85 = cache;
  D.4631 = *cache.85;
  D.4632 = (int) D.4631;
  if (D.4632 == c) goto <D.4627>; else goto <D.4628>;
  <D.4627>:
  cachec (92);
  cachec (c);
  goto <D.4629>;
  <D.4628>:
  D.4633 = __ctype_b_loc ();
  D.4634 = *D.4633;
  c.86 = (unsigned int) c;
  D.4636 = c.86 * 2;
  D.4637 = D.4634 + D.4636;
  D.4638 = *D.4637;
  D.4639 = (int) D.4638;
  D.4640 = D.4639 & 16384;
  if (D.4640 != 0) goto <D.4641>; else goto <D.4642>;
  <D.4641>:
  cachec (c);
  goto <D.4643>;
  <D.4642>:
  cachec (92);
  switch (c) <default: <D.3554>, case 7: <D.3546>, case 8: <D.3548>, case 9: <D.3552>, case 10: <D.3550>, case 11: <D.3553>, case 12: <D.3549>, case 13: <D.3551>>
  <D.3546>:
  cachec (97);
  goto <D.3547>;
  <D.3548>:
  cachec (98);
  goto <D.3547>;
  <D.3549>:
  cachec (102);
  goto <D.3547>;
  <D.3550>:
  cachec (110);
  goto <D.3547>;
  <D.3551>:
  cachec (114);
  goto <D.3547>;
  <D.3552>:
  cachec (116);
  goto <D.3547>;
  <D.3553>:
  cachec (118);
  goto <D.3547>;
  <D.3554>:
  D.4644 = c >> 6;
  D.4645 = D.4644 & 7;
  D.4646 = D.4645 + 48;
  cachec (D.4646);
  D.4647 = c >> 3;
  D.4648 = D.4647 & 7;
  D.4649 = D.4648 + 48;
  cachec (D.4649);
  D.4650 = c & 7;
  D.4651 = D.4650 + 48;
  cachec (D.4651);
  goto <D.3547>;
  <D.3547>:
  <D.4643>:
  <D.4629>:
  i = i + 1;
  <D.3556>:
  if (i < n) goto <D.3555>; else goto <D.3557>;
  <D.3557>:
  if (n == 1) goto <D.4652>; else goto <D.4653>;
  <D.4652>:
  cachec (39);
  goto <D.4654>;
  <D.4653>:
  cachec (34);
  <D.4654>:
  cachec (0);
  cache.85 = cache;
  bp = lookup (cache.85);
  bp->class = 1;
  if (n == 1) goto <D.4655>; else goto <D.4656>;
  <D.4655>:
  D.4657 = bp->value;
  if (D.4657 == -1) goto <D.4658>; else goto <D.4659>;
  <D.4658>:
  D.4660 = MEM[(unsigned char *)s];
  D.4661 = (short int) D.4660;
  bp->value = D.4661;
  <D.4659>:
  <D.4656>:
  free (s);
  D.4662 = bp;
  return D.4662;
}


is_reserved (char * name)
{
  int D.3571;
  int iftmp.87;
  int D.3570;
  char[2] * D.4669;
  unsigned char D.4670;
  int D.4671;
  unsigned char D.4672;
  int D.4673;
  _Bool D.4674;
  _Bool D.4675;
  _Bool D.4676;
  const unsigned char * D.4679;
  unsigned char D.4680;
  int D.4681;
  const unsigned char * D.4682;
  unsigned char D.4683;
  int D.4684;
  _Bool D.4685;
  _Bool D.4686;
  const unsigned char * D.4689;
  unsigned char D.4690;
  int D.4691;
  const unsigned char * D.4692;
  unsigned char D.4693;
  int D.4694;
  _Bool D.4695;
  _Bool D.4696;
  const unsigned char * D.4699;
  unsigned char D.4700;
  int D.4701;
  const unsigned char * D.4702;
  unsigned char D.4703;
  int D.4704;
  int D.3580;
  int iftmp.88;
  int D.3579;
  char[8] * D.4710;
  unsigned char D.4711;
  int D.4712;
  unsigned char D.4713;
  int D.4714;
  _Bool D.4715;
  _Bool D.4716;
  _Bool D.4717;
  const unsigned char * D.4720;
  unsigned char D.4721;
  int D.4722;
  const unsigned char * D.4723;
  unsigned char D.4724;
  int D.4725;
  _Bool D.4726;
  _Bool D.4727;
  const unsigned char * D.4730;
  unsigned char D.4731;
  int D.4732;
  const unsigned char * D.4733;
  unsigned char D.4734;
  int D.4735;
  _Bool D.4736;
  _Bool D.4737;
  const unsigned char * D.4740;
  unsigned char D.4741;
  int D.4742;
  const unsigned char * D.4743;
  unsigned char D.4744;
  int D.4745;
  int D.3589;
  int iftmp.89;
  int D.3588;
  char[5] * D.4751;
  unsigned char D.4752;
  int D.4753;
  unsigned char D.4754;
  int D.4755;
  _Bool D.4756;
  _Bool D.4757;
  _Bool D.4758;
  const unsigned char * D.4761;
  unsigned char D.4762;
  int D.4763;
  const unsigned char * D.4764;
  unsigned char D.4765;
  int D.4766;
  _Bool D.4767;
  _Bool D.4768;
  const unsigned char * D.4771;
  unsigned char D.4772;
  int D.4773;
  const unsigned char * D.4774;
  unsigned char D.4775;
  int D.4776;
  _Bool D.4777;
  _Bool D.4778;
  const unsigned char * D.4781;
  unsigned char D.4782;
  int D.4783;
  const unsigned char * D.4784;
  unsigned char D.4785;
  int D.4786;
  int D.4788;
  char D.4789;
  char * D.4792;
  char D.4793;
  const short unsigned int * * D.4796;
  const short unsigned int * D.4797;
  char * D.4798;
  char D.4799;
  unsigned int D.4800;
  unsigned int D.4801;
  const short unsigned int * D.4802;
  short unsigned int D.4803;
  int D.4804;
  int D.4805;
  char D.4808;
  unsigned int D.4809;
  unsigned int D.4810;
  const short unsigned int * D.4811;
  short unsigned int D.4812;
  int D.4813;
  int D.4814;
  char * s;

  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.4669 = ".";
      D.4670 = MEM[(const unsigned char *)D.4669];
      D.4671 = (int) D.4670;
      D.4672 = *__s2;
      D.4673 = (int) D.4672;
      __result = D.4671 - D.4673;
      {
        D.4674 = __s2_len != 0;
        D.4675 = __result == 0;
        D.4676 = D.4674 & D.4675;
        if (D.4676 != 0) goto <D.4677>; else goto <D.4678>;
        <D.4677>:
        D.4679 = &MEM[(void *)"." + 1B];
        D.4680 = *D.4679;
        D.4681 = (int) D.4680;
        D.4682 = __s2 + 1;
        D.4683 = *D.4682;
        D.4684 = (int) D.4683;
        __result = D.4681 - D.4684;
        D.4685 = __s2_len > 1;
        D.4675 = __result == 0;
        D.4686 = D.4685 & D.4675;
        if (D.4686 != 0) goto <D.4687>; else goto <D.4688>;
        <D.4687>:
        D.4689 = &MEM[(void *)"." + 2B];
        D.4690 = *D.4689;
        D.4691 = (int) D.4690;
        D.4692 = __s2 + 2;
        D.4693 = *D.4692;
        D.4694 = (int) D.4693;
        __result = D.4691 - D.4694;
        D.4695 = __s2_len > 2;
        D.4675 = __result == 0;
        D.4696 = D.4695 & D.4675;
        if (D.4696 != 0) goto <D.4697>; else goto <D.4698>;
        <D.4697>:
        D.4699 = &MEM[(void *)"." + 3B];
        D.4700 = *D.4699;
        D.4701 = (int) D.4700;
        D.4702 = __s2 + 3;
        D.4703 = *D.4702;
        D.4704 = (int) D.4703;
        __result = D.4701 - D.4704;
        <D.4698>:
        <D.4688>:
        <D.4678>:
      }
      D.3570 = __result;
    }
    iftmp.87 = -D.3570;
    goto <D.4705>;
    <D.4668>:
    iftmp.87 = __builtin_strcmp (name, ".");
    <D.4705>:
    D.3571 = iftmp.87;
  }
  if (D.3571 == 0) goto <D.4664>; else goto <D.4706>;
  <D.4706>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.4710 = "$accept";
      D.4711 = MEM[(const unsigned char *)D.4710];
      D.4712 = (int) D.4711;
      D.4713 = *__s2;
      D.4714 = (int) D.4713;
      __result = D.4712 - D.4714;
      {
        D.4715 = __s2_len != 0;
        D.4716 = __result == 0;
        D.4717 = D.4715 & D.4716;
        if (D.4717 != 0) goto <D.4718>; else goto <D.4719>;
        <D.4718>:
        D.4720 = &MEM[(void *)"$accept" + 1B];
        D.4721 = *D.4720;
        D.4722 = (int) D.4721;
        D.4723 = __s2 + 1;
        D.4724 = *D.4723;
        D.4725 = (int) D.4724;
        __result = D.4722 - D.4725;
        D.4726 = __s2_len > 1;
        D.4716 = __result == 0;
        D.4727 = D.4726 & D.4716;
        if (D.4727 != 0) goto <D.4728>; else goto <D.4729>;
        <D.4728>:
        D.4730 = &MEM[(void *)"$accept" + 2B];
        D.4731 = *D.4730;
        D.4732 = (int) D.4731;
        D.4733 = __s2 + 2;
        D.4734 = *D.4733;
        D.4735 = (int) D.4734;
        __result = D.4732 - D.4735;
        D.4736 = __s2_len > 2;
        D.4716 = __result == 0;
        D.4737 = D.4736 & D.4716;
        if (D.4737 != 0) goto <D.4738>; else goto <D.4739>;
        <D.4738>:
        D.4740 = &MEM[(void *)"$accept" + 3B];
        D.4741 = *D.4740;
        D.4742 = (int) D.4741;
        D.4743 = __s2 + 3;
        D.4744 = *D.4743;
        D.4745 = (int) D.4744;
        __result = D.4742 - D.4745;
        <D.4739>:
        <D.4729>:
        <D.4719>:
      }
      D.3579 = __result;
    }
    iftmp.88 = -D.3579;
    goto <D.4746>;
    <D.4709>:
    iftmp.88 = __builtin_strcmp (name, "$accept");
    <D.4746>:
    D.3580 = iftmp.88;
  }
  if (D.3580 == 0) goto <D.4664>; else goto <D.4747>;
  <D.4747>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      __s2 = name;
      D.4751 = "$end";
      D.4752 = MEM[(const unsigned char *)D.4751];
      D.4753 = (int) D.4752;
      D.4754 = *__s2;
      D.4755 = (int) D.4754;
      __result = D.4753 - D.4755;
      {
        D.4756 = __s2_len != 0;
        D.4757 = __result == 0;
        D.4758 = D.4756 & D.4757;
        if (D.4758 != 0) goto <D.4759>; else goto <D.4760>;
        <D.4759>:
        D.4761 = &MEM[(void *)"$end" + 1B];
        D.4762 = *D.4761;
        D.4763 = (int) D.4762;
        D.4764 = __s2 + 1;
        D.4765 = *D.4764;
        D.4766 = (int) D.4765;
        __result = D.4763 - D.4766;
        D.4767 = __s2_len > 1;
        D.4757 = __result == 0;
        D.4768 = D.4767 & D.4757;
        if (D.4768 != 0) goto <D.4769>; else goto <D.4770>;
        <D.4769>:
        D.4771 = &MEM[(void *)"$end" + 2B];
        D.4772 = *D.4771;
        D.4773 = (int) D.4772;
        D.4774 = __s2 + 2;
        D.4775 = *D.4774;
        D.4776 = (int) D.4775;
        __result = D.4773 - D.4776;
        D.4777 = __s2_len > 2;
        D.4757 = __result == 0;
        D.4778 = D.4777 & D.4757;
        if (D.4778 != 0) goto <D.4779>; else goto <D.4780>;
        <D.4779>:
        D.4781 = &MEM[(void *)"$end" + 3B];
        D.4782 = *D.4781;
        D.4783 = (int) D.4782;
        D.4784 = __s2 + 3;
        D.4785 = *D.4784;
        D.4786 = (int) D.4785;
        __result = D.4783 - D.4786;
        <D.4780>:
        <D.4770>:
        <D.4760>:
      }
      D.3588 = __result;
    }
    iftmp.89 = -D.3588;
    goto <D.4787>;
    <D.4750>:
    iftmp.89 = __builtin_strcmp (name, "$end");
    <D.4787>:
    D.3589 = iftmp.89;
  }
  if (D.3589 == 0) goto <D.4664>; else goto <D.4665>;
  <D.4664>:
  D.4788 = 1;
  return D.4788;
  <D.4665>:
  D.4789 = *name;
  if (D.4789 == 36) goto <D.4790>; else goto <D.4791>;
  <D.4790>:
  D.4792 = name + 1;
  D.4793 = *D.4792;
  if (D.4793 == 36) goto <D.4794>; else goto <D.4795>;
  <D.4794>:
  D.4796 = __ctype_b_loc ();
  D.4797 = *D.4796;
  D.4798 = name + 2;
  D.4799 = *D.4798;
  D.4800 = (unsigned int) D.4799;
  D.4801 = D.4800 * 2;
  D.4802 = D.4797 + D.4801;
  D.4803 = *D.4802;
  D.4804 = (int) D.4803;
  D.4805 = D.4804 & 2048;
  if (D.4805 != 0) goto <D.4806>; else goto <D.4807>;
  <D.4806>:
  s = name + 3;
  goto <D.3591>;
  <D.3590>:
  s = s + 1;
  <D.3591>:
  D.4796 = __ctype_b_loc ();
  D.4797 = *D.4796;
  D.4808 = *s;
  D.4809 = (unsigned int) D.4808;
  D.4810 = D.4809 * 2;
  D.4811 = D.4797 + D.4810;
  D.4812 = *D.4811;
  D.4813 = (int) D.4812;
  D.4814 = D.4813 & 2048;
  if (D.4814 != 0) goto <D.3590>; else goto <D.3592>;
  <D.3592>:
  D.4808 = *s;
  if (D.4808 == 0) goto <D.4815>; else goto <D.4816>;
  <D.4815>:
  D.4788 = 1;
  return D.4788;
  <D.4816>:
  <D.4807>:
  <D.4795>:
  <D.4791>:
  D.4788 = 0;
  return D.4788;
}


get_name ()
{
  char * cptr.90;
  char D.4819;
  char * cptr.91;
  const short unsigned int * * D.4821;
  const short unsigned int * D.4822;
  unsigned int c.92;
  unsigned int D.4824;
  const short unsigned int * D.4825;
  short unsigned int D.4826;
  int D.4827;
  int D.4828;
  _Bool D.4830;
  _Bool D.4831;
  _Bool D.4832;
  char * cache.93;
  int D.4835;
  struct bucket * D.4838;
  register int c;
  extern int used_reserved ();

  cinc = 0;
  cptr.90 = cptr;
  D.4819 = *cptr.90;
  c = (int) D.4819;
  goto <D.3597>;
  <D.3596>:
  cachec (c);
  cptr.90 = cptr;
  cptr.91 = cptr.90 + 1;
  cptr = cptr.91;
  cptr.90 = cptr;
  D.4819 = *cptr.90;
  c = (int) D.4819;
  <D.3597>:
  D.4821 = __ctype_b_loc ();
  D.4822 = *D.4821;
  c.92 = (unsigned int) c;
  D.4824 = c.92 * 2;
  D.4825 = D.4822 + D.4824;
  D.4826 = *D.4825;
  D.4827 = (int) D.4826;
  D.4828 = D.4827 & 8;
  if (D.4828 != 0) goto <D.3596>; else goto <D.4829>;
  <D.4829>:
  D.4830 = c == 95;
  D.4831 = c == 46;
  D.4832 = D.4830 | D.4831;
  if (D.4832 != 0) goto <D.3596>; else goto <D.4833>;
  <D.4833>:
  if (c == 36) goto <D.3596>; else goto <D.3598>;
  <D.3598>:
  cachec (0);
  cache.93 = cache;
  D.4835 = is_reserved (cache.93);
  if (D.4835 != 0) goto <D.4836>; else goto <D.4837>;
  <D.4836>:
  cache.93 = cache;
  used_reserved (cache.93);
  <D.4837>:
  cache.93 = cache;
  D.4838 = lookup (cache.93);
  return D.4838;
}


get_number ()
{
  char * cptr.94;
  char D.4841;
  int D.4842;
  int D.4843;
  char * cptr.95;
  const short unsigned int * * D.4845;
  const short unsigned int * D.4846;
  unsigned int c.96;
  unsigned int D.4848;
  const short unsigned int * D.4849;
  short unsigned int D.4850;
  int D.4851;
  int D.4852;
  int D.4853;
  register int c;
  register int n;

  n = 0;
  cptr.94 = cptr;
  D.4841 = *cptr.94;
  c = (int) D.4841;
  goto <D.3606>;
  <D.3605>:
  D.4842 = n * 10;
  D.4843 = c + -48;
  n = D.4842 + D.4843;
  cptr.94 = cptr;
  cptr.95 = cptr.94 + 1;
  cptr = cptr.95;
  cptr.94 = cptr;
  D.4841 = *cptr.94;
  c = (int) D.4841;
  <D.3606>:
  D.4845 = __ctype_b_loc ();
  D.4846 = *D.4845;
  c.96 = (unsigned int) c;
  D.4848 = c.96 * 2;
  D.4849 = D.4846 + D.4848;
  D.4850 = *D.4849;
  D.4851 = (int) D.4850;
  D.4852 = D.4851 & 2048;
  if (D.4852 != 0) goto <D.3605>; else goto <D.3607>;
  <D.3607>:
  D.4853 = n;
  return D.4853;
}


get_tag (int emptyOk)
{
  char * cptr.97;
  int cptr.98;
  char * line.99;
  int line.100;
  int D.4859;
  sizetype D.4860;
  char * cptr.101;
  _Bool D.4864;
  _Bool D.4865;
  _Bool D.4866;
  char * D.4869;
  const short unsigned int * * D.4870;
  const short unsigned int * D.4871;
  unsigned int c.102;
  unsigned int D.4873;
  const short unsigned int * D.4874;
  short unsigned int D.4875;
  int D.4876;
  int D.4877;
  _Bool D.4880;
  _Bool D.4881;
  _Bool D.4882;
  char D.4885;
  int D.4886;
  _Bool D.4888;
  _Bool D.4889;
  _Bool D.4890;
  int D.3629;
  char * * tag_table.103;
  unsigned int i.104;
  unsigned int D.4898;
  char * * D.4899;
  char * D.4900;
  char * cache.105;
  int ntags.106;
  int tagmax.107;
  int tagmax.108;
  void * iftmp.109;
  unsigned int tagmax.110;
  unsigned int D.4913;
  int cinc.111;
  unsigned int cinc.112;
  unsigned int ntags.113;
  unsigned int D.4922;
  char * * D.4923;
  int ntags.114;
  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.97 = cptr;
  cptr.98 = (int) cptr.97;
  line.99 = line;
  line.100 = (int) line.99;
  D.4859 = cptr.98 - line.100;
  D.4860 = (sizetype) D.4859;
  t_cptr = t_line + D.4860;
  cptr.97 = cptr;
  cptr.101 = cptr.97 + 1;
  cptr = cptr.101;
  c = nextc ();
  if (c == -1) goto <D.4862>; else goto <D.4863>;
  <D.4862>:
  unexpected_EOF ();
  <D.4863>:
  D.4864 = emptyOk != 0;
  D.4865 = c == 62;
  D.4866 = D.4864 & D.4865;
  if (D.4866 != 0) goto <D.4867>; else goto <D.4868>;
  <D.4867>:
  cptr.97 = cptr;
  cptr.101 = cptr.97 + 1;
  cptr = cptr.101;
  D.4869 = 0B;
  return D.4869;
  <D.4868>:
  D.4870 = __ctype_b_loc ();
  D.4871 = *D.4870;
  c.102 = (unsigned int) c;
  D.4873 = c.102 * 2;
  D.4874 = D.4871 + D.4873;
  D.4875 = *D.4874;
  D.4876 = (int) D.4875;
  D.4877 = D.4876 & 1024;
  if (D.4877 == 0) goto <D.4878>; else goto <D.4879>;
  <D.4878>:
  D.4880 = c != 95;
  D.4881 = c != 36;
  D.4882 = D.4880 & D.4881;
  if (D.4882 != 0) goto <D.4883>; else goto <D.4884>;
  <D.4883>:
  illegal_tag (t_lineno, t_line, t_cptr);
  <D.4884>:
  <D.4879>:
  cinc = 0;
  <D.3619>:
  cachec (c);
  cptr.97 = cptr;
  cptr.101 = cptr.97 + 1;
  cptr = cptr.101;
  cptr.97 = cptr;
  D.4885 = *cptr.97;
  c = (int) D.4885;
  D.4870 = __ctype_b_loc ();
  D.4871 = *D.4870;
  c.102 = (unsigned int) c;
  D.4873 = c.102 * 2;
  D.4874 = D.4871 + D.4873;
  D.4875 = *D.4874;
  D.4876 = (int) D.4875;
  D.4886 = D.4876 & 8;
  if (D.4886 != 0) goto <D.3619>; else goto <D.4887>;
  <D.4887>:
  D.4888 = c == 95;
  D.4889 = c == 46;
  D.4890 = D.4888 | D.4889;
  if (D.4890 != 0) goto <D.3619>; else goto <D.4891>;
  <D.4891>:
  if (c == 36) goto <D.3619>; else goto <D.3620>;
  <D.3620>:
  cachec (0);
  c = nextc ();
  if (c == -1) goto <D.4892>; else goto <D.4893>;
  <D.4892>:
  unexpected_EOF ();
  <D.4893>:
  if (c != 62) goto <D.4894>; else goto <D.4895>;
  <D.4894>:
  illegal_tag (t_lineno, t_line, t_cptr);
  <D.4895>:
  cptr.97 = cptr;
  cptr.101 = cptr.97 + 1;
  cptr = cptr.101;
  i = 0;
  goto <D.3631>;
  <D.3630>:
  {
    size_t __s1_len;
    size_t __s2_len;

    tag_table.103 = tag_table;
    i.104 = (unsigned int) i;
    D.4898 = i.104 * 4;
    D.4899 = tag_table.103 + D.4898;
    D.4900 = *D.4899;
    cache.105 = cache;
    D.3629 = __builtin_strcmp (cache.105, D.4900);
  }
  if (D.3629 == 0) goto <D.4902>; else goto <D.4903>;
  <D.4902>:
  tag_table.103 = tag_table;
  i.104 = (unsigned int) i;
  D.4898 = i.104 * 4;
  D.4899 = tag_table.103 + D.4898;
  D.4869 = *D.4899;
  return D.4869;
  <D.4903>:
  i = i + 1;
  <D.3631>:
  ntags.106 = ntags;
  if (i < ntags.106) goto <D.3630>; else goto <D.3632>;
  <D.3632>:
  ntags.106 = ntags;
  tagmax.107 = tagmax;
  if (ntags.106 >= tagmax.107) goto <D.4906>; else goto <D.4907>;
  <D.4906>:
  {
    extern int no_space ();

    tagmax.107 = tagmax;
    tagmax.108 = tagmax.107 + 16;
    tagmax = tagmax.108;
    tag_table.103 = tag_table;
    if (tag_table.103 != 0B) goto <D.4910>; else goto <D.4911>;
    <D.4910>:
    tagmax.107 = tagmax;
    tagmax.110 = (unsigned int) tagmax.107;
    D.4913 = tagmax.110 * 4;
    tag_table.103 = tag_table;
    iftmp.109 = realloc (tag_table.103, D.4913);
    goto <D.4914>;
    <D.4911>:
    tagmax.107 = tagmax;
    tagmax.110 = (unsigned int) tagmax.107;
    D.4913 = tagmax.110 * 4;
    iftmp.109 = malloc (D.4913);
    <D.4914>:
    tag_table = iftmp.109;
    tag_table.103 = tag_table;
    if (tag_table.103 == 0B) goto <D.4915>; else goto <D.4916>;
    <D.4915>:
    no_space ();
    <D.4916>:
  }
  <D.4907>:
  cinc.111 = cinc;
  cinc.112 = (unsigned int) cinc.111;
  s = malloc (cinc.112);
  if (s == 0B) goto <D.4919>; else goto <D.4920>;
  <D.4919>:
  no_space ();
  <D.4920>:
  cache.105 = cache;
  strcpy (s, cache.105);
  tag_table.103 = tag_table;
  ntags.106 = ntags;
  ntags.113 = (unsigned int) ntags.106;
  D.4922 = ntags.113 * 4;
  D.4923 = tag_table.103 + D.4922;
  *D.4923 = s;
  ntags.106 = ntags;
  ntags.114 = ntags.106 + 1;
  ntags = ntags.114;
  free (t_line);
  D.4869 = s;
  return D.4869;
}


strcpy (char * restrict __dest, const char * restrict __src)
{
  char * D.4926;
  unsigned int D.4927;

  D.4927 = __builtin_object_size (__dest, 1);
  D.4926 = __builtin___strcpy_chk (__dest, __src, D.4927);
  return D.4926;
}


declare_tokens (int assoc)
{
  int prec.115;
  int prec.116;
  const short unsigned int * * D.4942;
  const short unsigned int * D.4943;
  unsigned int c.117;
  unsigned int D.4945;
  const short unsigned int * D.4946;
  short unsigned int D.4947;
  int D.4948;
  int D.4949;
  _Bool D.4951;
  _Bool D.4952;
  _Bool D.4953;
  _Bool D.4955;
  _Bool D.4956;
  _Bool D.4957;
  struct bucket * goal.118;
  char * D.4964;
  char * D.4967;
  short int D.4974;
  int D.4977;
  char D.4980;
  short int D.4981;
  int D.4984;
  short int D.4987;
  int D.4990;
  short int D.4993;
  register int c;
  register struct bucket * bp;
  int value;
  char * tag;
  extern int unexpected_EOF ();

  tag = 0B;
  if (assoc != 0) goto <D.4929>; else goto <D.4930>;
  <D.4929>:
  prec.115 = prec;
  prec.116 = prec.115 + 1;
  prec = prec.116;
  <D.4930>:
  c = nextc ();
  if (c == -1) goto <D.4933>; else goto <D.4934>;
  <D.4933>:
  unexpected_EOF ();
  <D.4934>:
  if (c == 60) goto <D.4935>; else goto <D.4936>;
  <D.4935>:
  tag = get_tag (0);
  c = nextc ();
  if (c == -1) goto <D.4937>; else goto <D.4938>;
  <D.4937>:
  unexpected_EOF ();
  <D.4938>:
  <D.4936>:
  <D.3652>:
  {
    extern int tokenized_start ();

    D.4942 = __ctype_b_loc ();
    D.4943 = *D.4942;
    c.117 = (unsigned int) c;
    D.4945 = c.117 * 2;
    D.4946 = D.4943 + D.4945;
    D.4947 = *D.4946;
    D.4948 = (int) D.4947;
    D.4949 = D.4948 & 1024;
    if (D.4949 != 0) goto <D.4939>; else goto <D.4950>;
    <D.4950>:
    D.4951 = c == 95;
    D.4952 = c == 46;
    D.4953 = D.4951 | D.4952;
    if (D.4953 != 0) goto <D.4939>; else goto <D.4954>;
    <D.4954>:
    if (c == 36) goto <D.4939>; else goto <D.4940>;
    <D.4939>:
    bp = get_name ();
    goto <D.4941>;
    <D.4940>:
    D.4955 = c == 39;
    D.4956 = c == 34;
    D.4957 = D.4955 | D.4956;
    if (D.4957 != 0) goto <D.4958>; else goto <D.4959>;
    <D.4958>:
    bp = get_literal ();
    goto <D.4960>;
    <D.4959>:
    return;
    <D.4960>:
    <D.4941>:
    goal.118 = goal;
    if (bp == goal.118) goto <D.4962>; else goto <D.4963>;
    <D.4962>:
    D.4964 = bp->name;
    tokenized_start (D.4964);
    <D.4963>:
    bp->class = 1;
    if (tag != 0B) goto <D.4965>; else goto <D.4966>;
    <D.4965>:
    {
      extern int retyped_warning ();

      D.4967 = bp->tag;
      if (D.4967 != 0B) goto <D.4968>; else goto <D.4969>;
      <D.4968>:
      D.4967 = bp->tag;
      if (D.4967 != tag) goto <D.4970>; else goto <D.4971>;
      <D.4970>:
      D.4964 = bp->name;
      retyped_warning (D.4964);
      <D.4971>:
      <D.4969>:
      bp->tag = tag;
    }
    <D.4966>:
    if (assoc != 0) goto <D.4972>; else goto <D.4973>;
    <D.4972>:
    {
      extern int reprec_warning ();

      D.4974 = bp->prec;
      if (D.4974 != 0) goto <D.4975>; else goto <D.4976>;
      <D.4975>:
      D.4974 = bp->prec;
      D.4977 = (int) D.4974;
      prec.115 = prec;
      if (D.4977 != prec.115) goto <D.4978>; else goto <D.4979>;
      <D.4978>:
      D.4964 = bp->name;
      reprec_warning (D.4964);
      <D.4979>:
      <D.4976>:
      D.4980 = (char) assoc;
      bp->assoc = D.4980;
      prec.115 = prec;
      D.4981 = (short int) prec.115;
      bp->prec = D.4981;
    }
    <D.4973>:
    c = nextc ();
    if (c == -1) goto <D.4982>; else goto <D.4983>;
    <D.4982>:
    unexpected_EOF ();
    <D.4983>:
    value = -1;
    D.4942 = __ctype_b_loc ();
    D.4943 = *D.4942;
    c.117 = (unsigned int) c;
    D.4945 = c.117 * 2;
    D.4946 = D.4943 + D.4945;
    D.4947 = *D.4946;
    D.4948 = (int) D.4947;
    D.4984 = D.4948 & 2048;
    if (D.4984 != 0) goto <D.4985>; else goto <D.4986>;
    <D.4985>:
    {
      extern int revalued_warning ();

      value = get_number ();
      D.4987 = bp->value;
      if (D.4987 != -1) goto <D.4988>; else goto <D.4989>;
      <D.4988>:
      D.4987 = bp->value;
      D.4990 = (int) D.4987;
      if (D.4990 != value) goto <D.4991>; else goto <D.4992>;
      <D.4991>:
      D.4964 = bp->name;
      revalued_warning (D.4964);
      <D.4992>:
      <D.4989>:
      D.4993 = (short int) value;
      bp->value = D.4993;
      c = nextc ();
      if (c == -1) goto <D.4994>; else goto <D.4995>;
      <D.4994>:
      unexpected_EOF ();
      <D.4995>:
    }
    <D.4986>:
  }
  goto <D.3652>;
}


declare_types ()
{
  char * cptr.119;
  char * line.120;
  int lineno.121;
  const short unsigned int * * D.5007;
  const short unsigned int * D.5008;
  unsigned int c.122;
  unsigned int D.5010;
  const short unsigned int * D.5011;
  short unsigned int D.5012;
  int D.5013;
  int D.5014;
  _Bool D.5016;
  _Bool D.5017;
  _Bool D.5018;
  _Bool D.5020;
  _Bool D.5021;
  _Bool D.5022;
  char * D.5026;
  char * D.5031;
  register int c;
  register struct bucket * bp;
  char * tag;
  extern int unexpected_EOF ();
  extern int syntax_error ();

  c = nextc ();
  if (c == -1) goto <D.4997>; else goto <D.4998>;
  <D.4997>:
  unexpected_EOF ();
  <D.4998>:
  if (c != 60) goto <D.4999>; else goto <D.5000>;
  <D.4999>:
  cptr.119 = cptr;
  line.120 = line;
  lineno.121 = lineno;
  syntax_error (lineno.121, line.120, cptr.119);
  <D.5000>:
  tag = get_tag (0);
  <D.3660>:
  {
    extern int retyped_warning ();

    c = nextc ();
    D.5007 = __ctype_b_loc ();
    D.5008 = *D.5007;
    c.122 = (unsigned int) c;
    D.5010 = c.122 * 2;
    D.5011 = D.5008 + D.5010;
    D.5012 = *D.5011;
    D.5013 = (int) D.5012;
    D.5014 = D.5013 & 1024;
    if (D.5014 != 0) goto <D.5004>; else goto <D.5015>;
    <D.5015>:
    D.5016 = c == 95;
    D.5017 = c == 46;
    D.5018 = D.5016 | D.5017;
    if (D.5018 != 0) goto <D.5004>; else goto <D.5019>;
    <D.5019>:
    if (c == 36) goto <D.5004>; else goto <D.5005>;
    <D.5004>:
    bp = get_name ();
    goto <D.5006>;
    <D.5005>:
    D.5020 = c == 39;
    D.5021 = c == 34;
    D.5022 = D.5020 | D.5021;
    if (D.5022 != 0) goto <D.5023>; else goto <D.5024>;
    <D.5023>:
    bp = get_literal ();
    goto <D.5025>;
    <D.5024>:
    return;
    <D.5025>:
    <D.5006>:
    D.5026 = bp->tag;
    if (D.5026 != 0B) goto <D.5027>; else goto <D.5028>;
    <D.5027>:
    D.5026 = bp->tag;
    if (D.5026 != tag) goto <D.5029>; else goto <D.5030>;
    <D.5029>:
    D.5031 = bp->name;
    retyped_warning (D.5031);
    <D.5030>:
    <D.5028>:
    bp->tag = tag;
  }
  goto <D.3660>;
}


declare_start ()
{
  const short unsigned int * * D.5035;
  const short unsigned int * D.5036;
  unsigned int c.123;
  unsigned int D.5038;
  const short unsigned int * D.5039;
  short unsigned int D.5040;
  int D.5041;
  int D.5042;
  _Bool D.5045;
  _Bool D.5046;
  _Bool D.5047;
  char * cptr.124;
  char * line.125;
  int lineno.126;
  char D.5055;
  char * D.5058;
  struct bucket * goal.127;
  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.5033>; else goto <D.5034>;
  <D.5033>:
  unexpected_EOF ();
  <D.5034>:
  D.5035 = __ctype_b_loc ();
  D.5036 = *D.5035;
  c.123 = (unsigned int) c;
  D.5038 = c.123 * 2;
  D.5039 = D.5036 + D.5038;
  D.5040 = *D.5039;
  D.5041 = (int) D.5040;
  D.5042 = D.5041 & 1024;
  if (D.5042 == 0) goto <D.5043>; else goto <D.5044>;
  <D.5043>:
  D.5045 = c != 95;
  D.5046 = c != 46;
  D.5047 = D.5045 & D.5046;
  if (D.5047 != 0) goto <D.5048>; else goto <D.5049>;
  <D.5048>:
  if (c != 36) goto <D.5050>; else goto <D.5051>;
  <D.5050>:
  cptr.124 = cptr;
  line.125 = line;
  lineno.126 = lineno;
  syntax_error (lineno.126, line.125, cptr.124);
  <D.5051>:
  <D.5049>:
  <D.5044>:
  bp = get_name ();
  D.5055 = bp->class;
  if (D.5055 == 1) goto <D.5056>; else goto <D.5057>;
  <D.5056>:
  D.5058 = bp->name;
  terminal_start (D.5058);
  <D.5057>:
  goal.127 = goal;
  if (goal.127 != 0B) goto <D.5060>; else goto <D.5061>;
  <D.5060>:
  goal.127 = goal;
  if (goal.127 != bp) goto <D.5062>; else goto <D.5063>;
  <D.5062>:
  restarted_warning ();
  <D.5063>:
  <D.5061>:
  goal = bp;
}


read_declarations ()
{
  int cache_size.128;
  unsigned int cache_size.129;
  void * cache.130;
  char * cache.131;
  char * cptr.132;
  char * line.133;
  int lineno.134;
  struct FILE * prolog_file.135;
  register int c;
  register int k;
  extern int no_space ();

  cache_size = 256;
  cache_size.128 = cache_size;
  cache_size.129 = (unsigned int) cache_size.128;
  cache.130 = malloc (cache_size.129);
  cache = cache.130;
  cache.131 = cache;
  if (cache.131 == 0B) goto <D.5068>; else goto <D.5069>;
  <D.5068>:
  no_space ();
  <D.5069>:
  <D.3688>:
  {
    extern int unexpected_EOF ();
    extern int syntax_error ();

    c = nextc ();
    if (c == -1) goto <D.5070>; else goto <D.5071>;
    <D.5070>:
    unexpected_EOF ();
    <D.5071>:
    if (c != 37) goto <D.5072>; else goto <D.5073>;
    <D.5072>:
    cptr.132 = cptr;
    line.133 = line;
    lineno.134 = lineno;
    syntax_error (lineno.134, line.133, cptr.132);
    <D.5073>:
    k = keyword ();
    switch (k) <default: <D.5078>, case 0: <D.3680>, case 1: <D.3681>, case 2: <D.3682>, case 3: <D.3683>, case 4: <D.3677>, case 5: <D.3678>, case 6: <D.3684>, case 7: <D.3685>>
    <D.3677>:
    return;
    <D.3678>:
    prolog_file.135 = prolog_file;
    copy_text (prolog_file.135);
    goto <D.3679>;
    <D.3680>:
    <D.3681>:
    <D.3682>:
    <D.3683>:
    declare_tokens (k);
    goto <D.3679>;
    <D.3684>:
    declare_types ();
    goto <D.3679>;
    <D.3685>:
    declare_start ();
    goto <D.3679>;
    <D.5078>:
    <D.3679>:
  }
  goto <D.3688>;
}


initialize_grammar ()
{
  int maxitems.136;
  unsigned int maxitems.137;
  unsigned int D.5084;
  void * pitem.138;
  struct bucket * * pitem.139;
  struct bucket * * D.5089;
  struct bucket * * D.5090;
  struct bucket * * D.5091;
  int maxrules.140;
  unsigned int maxrules.141;
  unsigned int D.5094;
  void * plhs.142;
  struct bucket * * plhs.143;
  struct bucket * * D.5099;
  struct bucket * * D.5100;
  unsigned int D.5101;
  void * rprec.144;
  short int * rprec.145;
  short int * D.5106;
  short int * D.5107;
  void * rassoc.146;
  char * rassoc.147;
  char * D.5112;
  char * D.5113;
  extern int no_space ();

  nitems = 4;
  maxitems = 300;
  maxitems.136 = maxitems;
  maxitems.137 = (unsigned int) maxitems.136;
  D.5084 = maxitems.137 * 4;
  pitem.138 = malloc (D.5084);
  pitem = pitem.138;
  pitem.139 = pitem;
  if (pitem.139 == 0B) goto <D.5087>; else goto <D.5088>;
  <D.5087>:
  no_space ();
  <D.5088>:
  pitem.139 = pitem;
  *pitem.139 = 0B;
  pitem.139 = pitem;
  D.5089 = pitem.139 + 4;
  *D.5089 = 0B;
  pitem.139 = pitem;
  D.5090 = pitem.139 + 8;
  *D.5090 = 0B;
  pitem.139 = pitem;
  D.5091 = pitem.139 + 12;
  *D.5091 = 0B;
  nmethods = 0;
  nrules = 3;
  maxrules = 100;
  maxrules.140 = maxrules;
  maxrules.141 = (unsigned int) maxrules.140;
  D.5094 = maxrules.141 * 4;
  plhs.142 = malloc (D.5094);
  plhs = plhs.142;
  plhs.143 = plhs;
  if (plhs.143 == 0B) goto <D.5097>; else goto <D.5098>;
  <D.5097>:
  no_space ();
  <D.5098>:
  plhs.143 = plhs;
  *plhs.143 = 0B;
  plhs.143 = plhs;
  D.5099 = plhs.143 + 4;
  *D.5099 = 0B;
  plhs.143 = plhs;
  D.5100 = plhs.143 + 8;
  *D.5100 = 0B;
  maxrules.140 = maxrules;
  maxrules.141 = (unsigned int) maxrules.140;
  D.5101 = maxrules.141 * 2;
  rprec.144 = malloc (D.5101);
  rprec = rprec.144;
  rprec.145 = rprec;
  if (rprec.145 == 0B) goto <D.5104>; else goto <D.5105>;
  <D.5104>:
  no_space ();
  <D.5105>:
  rprec.145 = rprec;
  *rprec.145 = 0;
  rprec.145 = rprec;
  D.5106 = rprec.145 + 2;
  *D.5106 = 0;
  rprec.145 = rprec;
  D.5107 = rprec.145 + 4;
  *D.5107 = 0;
  maxrules.140 = maxrules;
  maxrules.141 = (unsigned int) maxrules.140;
  rassoc.146 = malloc (maxrules.141);
  rassoc = rassoc.146;
  rassoc.147 = rassoc;
  if (rassoc.147 == 0B) goto <D.5110>; else goto <D.5111>;
  <D.5110>:
  no_space ();
  <D.5111>:
  rassoc.147 = rassoc;
  *rassoc.147 = 0;
  rassoc.147 = rassoc;
  D.5112 = rassoc.147 + 1;
  *D.5112 = 0;
  rassoc.147 = rassoc;
  D.5113 = rassoc.147 + 2;
  *D.5113 = 0;
}


expand_items ()
{
  int maxitems.148;
  int maxitems.149;
  unsigned int maxitems.150;
  unsigned int D.5117;
  struct bucket * * pitem.151;
  void * pitem.152;
  extern int no_space ();

  maxitems.148 = maxitems;
  maxitems.149 = maxitems.148 + 300;
  maxitems = maxitems.149;
  maxitems.148 = maxitems;
  maxitems.150 = (unsigned int) maxitems.148;
  D.5117 = maxitems.150 * 4;
  pitem.151 = pitem;
  pitem.152 = realloc (pitem.151, D.5117);
  pitem = pitem.152;
  pitem.151 = pitem;
  if (pitem.151 == 0B) goto <D.5120>; else goto <D.5121>;
  <D.5120>:
  no_space ();
  <D.5121>:
}


expand_rules ()
{
  int maxrules.153;
  int maxrules.154;
  unsigned int maxrules.155;
  unsigned int D.5125;
  struct bucket * * plhs.156;
  void * plhs.157;
  unsigned int D.5130;
  short int * rprec.158;
  void * rprec.159;
  char * rassoc.160;
  void * rassoc.161;
  extern int no_space ();

  maxrules.153 = maxrules;
  maxrules.154 = maxrules.153 + 100;
  maxrules = maxrules.154;
  maxrules.153 = maxrules;
  maxrules.155 = (unsigned int) maxrules.153;
  D.5125 = maxrules.155 * 4;
  plhs.156 = plhs;
  plhs.157 = realloc (plhs.156, D.5125);
  plhs = plhs.157;
  plhs.156 = plhs;
  if (plhs.156 == 0B) goto <D.5128>; else goto <D.5129>;
  <D.5128>:
  no_space ();
  <D.5129>:
  maxrules.153 = maxrules;
  maxrules.155 = (unsigned int) maxrules.153;
  D.5130 = maxrules.155 * 2;
  rprec.158 = rprec;
  rprec.159 = realloc (rprec.158, D.5130);
  rprec = rprec.159;
  rprec.158 = rprec;
  if (rprec.158 == 0B) goto <D.5133>; else goto <D.5134>;
  <D.5133>:
  no_space ();
  <D.5134>:
  maxrules.153 = maxrules;
  maxrules.155 = (unsigned int) maxrules.153;
  rassoc.160 = rassoc;
  rassoc.161 = realloc (rassoc.160, maxrules.155);
  rassoc = rassoc.161;
  rassoc.160 = rassoc;
  if (rassoc.160 == 0B) goto <D.5137>; else goto <D.5138>;
  <D.5137>:
  no_space ();
  <D.5138>:
}


advance_to_start ()
{
  int D.5140;
  struct FILE * local_file.162;
  char * line.163;
  int lineno.164;
  const short unsigned int * * D.5144;
  const short unsigned int * D.5145;
  unsigned int c.165;
  unsigned int D.5147;
  const short unsigned int * D.5148;
  short unsigned int D.5149;
  int D.5150;
  int D.5151;
  _Bool D.5154;
  _Bool D.5155;
  _Bool D.5156;
  char * cptr.166;
  struct bucket * goal.167;
  char D.5165;
  char * D.5168;
  char * cptr.168;
  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.3714>:
  c = nextc ();
  if (c != 37) goto <D.3705>; else goto <D.5139>;
  <D.5139>:
  s_cptr = cptr;
  D.5140 = keyword ();
  switch (D.5140) <default: <D.3711>, case 4: <D.3706>, case 5: <D.3708>, case 7: <D.3710>>
  {
    extern int no_grammar ();
    extern int syntax_error ();

    <D.3706>:
    no_grammar ();
    <D.3708>:
    local_file.162 = local_file;
    copy_text (local_file.162);
    goto <D.3709>;
    <D.3710>:
    declare_start ();
    goto <D.3709>;
    <D.3711>:
    line.163 = line;
    lineno.164 = lineno;
    syntax_error (lineno.164, line.163, s_cptr);
  }
  <D.3709>:
  goto <D.3714>;
  <D.3705>:
  c = nextc ();
  D.5144 = __ctype_b_loc ();
  D.5145 = *D.5144;
  c.165 = (unsigned int) c;
  D.5147 = c.165 * 2;
  D.5148 = D.5145 + D.5147;
  D.5149 = *D.5148;
  D.5150 = (int) D.5149;
  D.5151 = D.5150 & 1024;
  if (D.5151 == 0) goto <D.5152>; else goto <D.5153>;
  <D.5152>:
  D.5154 = c != 95;
  D.5155 = c != 46;
  D.5156 = D.5154 & D.5155;
  if (D.5156 != 0) goto <D.5157>; else goto <D.5158>;
  <D.5157>:
  if (c != 95) goto <D.5159>; else goto <D.5160>;
  <D.5159>:
  cptr.166 = cptr;
  line.163 = line;
  lineno.164 = lineno;
  syntax_error (lineno.164, line.163, cptr.166);
  <D.5160>:
  <D.5158>:
  <D.5153>:
  bp = get_name ();
  goal.167 = goal;
  if (goal.167 == 0B) goto <D.5163>; else goto <D.5164>;
  <D.5163>:
  {
    extern int terminal_start ();

    D.5165 = bp->class;
    if (D.5165 == 1) goto <D.5166>; else goto <D.5167>;
    <D.5166>:
    D.5168 = bp->name;
    terminal_start (D.5168);
    <D.5167>:
    goal = bp;
  }
  <D.5164>:
  s_lineno = lineno;
  c = nextc ();
  if (c == -1) goto <D.5169>; else goto <D.5170>;
  <D.5169>:
  unexpected_EOF ();
  <D.5170>:
  if (c != 58) goto <D.5171>; else goto <D.5172>;
  <D.5171>:
  cptr.166 = cptr;
  line.163 = line;
  lineno.164 = lineno;
  syntax_error (lineno.164, line.163, cptr.166);
  <D.5172>:
  start_rule (bp, s_lineno);
  cptr.166 = cptr;
  cptr.168 = cptr.166 + 1;
  cptr = cptr.168;
}


start_rule (struct bucket * bp, int s_lineno)
{
  char D.5174;
  int nrules.169;
  int maxrules.170;
  struct bucket * * plhs.171;
  unsigned int nrules.172;
  unsigned int D.5183;
  struct bucket * * D.5184;
  short int * rprec.173;
  unsigned int D.5186;
  short int * D.5187;
  char * rassoc.174;
  sizetype nrules.175;
  char * D.5190;
  extern int terminal_lhs ();

  D.5174 = bp->class;
  if (D.5174 == 1) goto <D.5175>; else goto <D.5176>;
  <D.5175>:
  terminal_lhs (s_lineno);
  <D.5176>:
  bp->class = 2;
  nrules.169 = nrules;
  maxrules.170 = maxrules;
  if (nrules.169 >= maxrules.170) goto <D.5179>; else goto <D.5180>;
  <D.5179>:
  expand_rules ();
  <D.5180>:
  plhs.171 = plhs;
  nrules.169 = nrules;
  nrules.172 = (unsigned int) nrules.169;
  D.5183 = nrules.172 * 4;
  D.5184 = plhs.171 + D.5183;
  *D.5184 = bp;
  rprec.173 = rprec;
  nrules.169 = nrules;
  nrules.172 = (unsigned int) nrules.169;
  D.5186 = nrules.172 * 2;
  D.5187 = rprec.173 + D.5186;
  *D.5187 = -1;
  rassoc.174 = rassoc;
  nrules.169 = nrules;
  nrules.175 = (sizetype) nrules.169;
  D.5190 = rassoc.174 + nrules.175;
  *D.5190 = 0;
}


end_rule ()
{
  char last_was_action.176;
  struct bucket * * plhs.177;
  int nrules.178;
  unsigned int nrules.179;
  unsigned int D.5197;
  struct bucket * * D.5198;
  struct bucket * D.5199;
  char * D.5200;
  int nitems.180;
  struct bucket * * pitem.181;
  unsigned int i.182;
  unsigned int D.5206;
  struct bucket * * D.5207;
  struct bucket * D.5208;
  sizetype i.183;
  sizetype D.5212;
  sizetype D.5213;
  struct bucket * * D.5214;
  struct bucket * D.5215;
  char * D.5217;
  int maxitems.184;
  unsigned int nitems.185;
  unsigned int D.5222;
  struct bucket * * D.5223;
  int nitems.186;
  int nrules.187;
  register int i;

  last_was_action.176 = last_was_action;
  if (last_was_action.176 == 0) goto <D.5192>; else goto <D.5193>;
  <D.5192>:
  plhs.177 = plhs;
  nrules.178 = nrules;
  nrules.179 = (unsigned int) nrules.178;
  D.5197 = nrules.179 * 4;
  D.5198 = plhs.177 + D.5197;
  D.5199 = *D.5198;
  D.5200 = D.5199->tag;
  if (D.5200 != 0B) goto <D.5201>; else goto <D.5202>;
  <D.5201>:
  {
    extern int default_action_warning ();

    nitems.180 = nitems;
    i = nitems.180 + -1;
    goto <D.3731>;
    <D.3730>:
    // predicted unlikely by continue predictor.
    goto <D.3729>;
    <D.3729>:
    i = i + -1;
    <D.3731>:
    pitem.181 = pitem;
    i.182 = (unsigned int) i;
    D.5206 = i.182 * 4;
    D.5207 = pitem.181 + D.5206;
    D.5208 = *D.5207;
    if (D.5208 != 0B) goto <D.3730>; else goto <D.3732>;
    <D.3732>:
    pitem.181 = pitem;
    i.183 = (sizetype) i;
    D.5212 = i.183 + 1;
    D.5213 = D.5212 * 4;
    D.5214 = pitem.181 + D.5213;
    D.5215 = *D.5214;
    if (D.5215 == 0B) goto <D.5209>; else goto <D.5216>;
    <D.5216>:
    pitem.181 = pitem;
    i.183 = (sizetype) i;
    D.5212 = i.183 + 1;
    D.5213 = D.5212 * 4;
    D.5214 = pitem.181 + D.5213;
    D.5215 = *D.5214;
    D.5217 = D.5215->tag;
    plhs.177 = plhs;
    nrules.178 = nrules;
    nrules.179 = (unsigned int) nrules.178;
    D.5197 = nrules.179 * 4;
    D.5198 = plhs.177 + D.5197;
    D.5199 = *D.5198;
    D.5200 = D.5199->tag;
    if (D.5217 != D.5200) goto <D.5209>; else goto <D.5210>;
    <D.5209>:
    default_action_warning ();
    <D.5210>:
  }
  <D.5202>:
  <D.5193>:
  last_was_action = 0;
  nitems.180 = nitems;
  maxitems.184 = maxitems;
  if (nitems.180 >= maxitems.184) goto <D.5219>; else goto <D.5220>;
  <D.5219>:
  expand_items ();
  <D.5220>:
  pitem.181 = pitem;
  nitems.180 = nitems;
  nitems.185 = (unsigned int) nitems.180;
  D.5222 = nitems.185 * 4;
  D.5223 = pitem.181 + D.5222;
  *D.5223 = 0B;
  nitems.180 = nitems;
  nitems.186 = nitems.180 + 1;
  nitems = nitems.186;
  nrules.178 = nrules;
  nrules.187 = nrules.178 + 1;
  nrules = nrules.187;
}


insert_empty_rule ()
{
  char * cache.188;
  int gensym.189;
  int gensym.190;
  struct bucket * last_symbol.191;
  struct bucket * * plhs.192;
  int nrules.193;
  unsigned int nrules.194;
  unsigned int D.5235;
  struct bucket * * D.5236;
  struct bucket * D.5237;
  char * D.5238;
  int nitems.195;
  int nitems.196;
  int maxitems.197;
  struct bucket * * pitem.198;
  sizetype nitems.199;
  sizetype D.5246;
  sizetype D.5247;
  struct bucket * * bpp.200;
  struct bucket * D.5249;
  struct bucket * D.5250;
  int nrules.201;
  int maxrules.202;
  sizetype nrules.203;
  sizetype D.5256;
  sizetype D.5257;
  struct bucket * * D.5258;
  struct bucket * D.5259;
  short int * rprec.204;
  unsigned int D.5261;
  short int * D.5262;
  sizetype D.5263;
  sizetype D.5264;
  short int * D.5265;
  short int D.5266;
  char * rassoc.205;
  char * D.5268;
  sizetype D.5269;
  char * D.5270;
  char D.5271;
  register struct bucket * bp;
  register struct bucket * * bpp;
  static const char __PRETTY_FUNCTION__[18] = "insert_empty_rule";

  cache.188 = cache;
  if (cache.188 == 0B) goto <D.5227>; else goto <D.5228>;
  <D.5227>:
  __assert_fail ("cache", "reader.c", 980, &__PRETTY_FUNCTION__);
  <D.5228>:
  gensym.189 = gensym;
  gensym.190 = gensym.189 + 1;
  gensym = gensym.190;
  gensym.189 = gensym;
  cache.188 = cache;
  sprintf (cache.188, "$$%d", gensym.189);
  cache.188 = cache;
  bp = make_bucket (cache.188);
  last_symbol.191 = last_symbol;
  last_symbol.191->next = bp;
  last_symbol = bp;
  plhs.192 = plhs;
  nrules.193 = nrules;
  nrules.194 = (unsigned int) nrules.193;
  D.5235 = nrules.194 * 4;
  D.5236 = plhs.192 + D.5235;
  D.5237 = *D.5236;
  D.5238 = D.5237->tag;
  bp->tag = D.5238;
  bp->class = 2;
  nitems.195 = nitems;
  nitems.196 = nitems.195 + 2;
  nitems = nitems.196;
  nitems.195 = nitems;
  maxitems.197 = maxitems;
  if (nitems.195 > maxitems.197) goto <D.5242>; else goto <D.5243>;
  <D.5242>:
  expand_items ();
  <D.5243>:
  pitem.198 = pitem;
  nitems.195 = nitems;
  nitems.199 = (sizetype) nitems.195;
  D.5246 = nitems.199 + 1073741823;
  D.5247 = D.5246 * 4;
  bpp = pitem.198 + D.5247;
  bpp.200 = bpp;
  bpp = bpp.200 + 4294967292;
  *bpp.200 = bp;
  goto <D.3741>;
  <D.3740>:
  bpp = bpp + 4294967292;
  <D.3741>:
  D.5249 = MEM[(struct bucket * *)bpp + 4294967292B];
  *bpp = D.5249;
  D.5250 = *bpp;
  if (D.5250 != 0B) goto <D.3740>; else goto <D.3742>;
  <D.3742>:
  nrules.193 = nrules;
  nrules.201 = nrules.193 + 1;
  nrules = nrules.201;
  nrules.193 = nrules;
  maxrules.202 = maxrules;
  if (nrules.193 >= maxrules.202) goto <D.5253>; else goto <D.5254>;
  <D.5253>:
  expand_rules ();
  <D.5254>:
  plhs.192 = plhs;
  nrules.193 = nrules;
  nrules.194 = (unsigned int) nrules.193;
  D.5235 = nrules.194 * 4;
  D.5236 = plhs.192 + D.5235;
  plhs.192 = plhs;
  nrules.193 = nrules;
  nrules.203 = (sizetype) nrules.193;
  D.5256 = nrules.203 + 1073741823;
  D.5257 = D.5256 * 4;
  D.5258 = plhs.192 + D.5257;
  D.5259 = *D.5258;
  *D.5236 = D.5259;
  plhs.192 = plhs;
  nrules.193 = nrules;
  nrules.203 = (sizetype) nrules.193;
  D.5256 = nrules.203 + 1073741823;
  D.5257 = D.5256 * 4;
  D.5258 = plhs.192 + D.5257;
  *D.5258 = bp;
  rprec.204 = rprec;
  nrules.193 = nrules;
  nrules.194 = (unsigned int) nrules.193;
  D.5261 = nrules.194 * 2;
  D.5262 = rprec.204 + D.5261;
  rprec.204 = rprec;
  nrules.193 = nrules;
  nrules.203 = (sizetype) nrules.193;
  D.5263 = nrules.203 + 2147483647;
  D.5264 = D.5263 * 2;
  D.5265 = rprec.204 + D.5264;
  D.5266 = *D.5265;
  *D.5262 = D.5266;
  rprec.204 = rprec;
  nrules.193 = nrules;
  nrules.203 = (sizetype) nrules.193;
  D.5263 = nrules.203 + 2147483647;
  D.5264 = D.5263 * 2;
  D.5265 = rprec.204 + D.5264;
  *D.5265 = 0;
  rassoc.205 = rassoc;
  nrules.193 = nrules;
  nrules.203 = (sizetype) nrules.193;
  D.5268 = rassoc.205 + nrules.203;
  rassoc.205 = rassoc;
  nrules.193 = nrules;
  nrules.203 = (sizetype) nrules.193;
  D.5269 = nrules.203 + 4294967295;
  D.5270 = rassoc.205 + D.5269;
  D.5271 = *D.5270;
  *D.5268 = D.5271;
  rassoc.205 = rassoc;
  nrules.193 = nrules;
  nrules.203 = (sizetype) nrules.193;
  D.5269 = nrules.203 + 4294967295;
  D.5270 = rassoc.205 + D.5269;
  *D.5270 = 0;
}


sprintf (char * restrict __s, const char * restrict __fmt)
{
  int D.5272;
  unsigned int D.5273;

  D.5273 = __builtin_object_size (__s, 1);
  D.5272 = __builtin___sprintf_chk (__s, 1, D.5273, __fmt, __builtin_va_arg_pack ());
  return D.5272;
}


add_symbol ()
{
  char * cptr.206;
  char D.5276;
  _Bool D.5277;
  _Bool D.5278;
  _Bool D.5279;
  char * cptr.207;
  char last_was_action.208;
  int nitems.209;
  int nitems.210;
  int maxitems.211;
  struct bucket * * pitem.212;
  sizetype nitems.213;
  sizetype D.5296;
  sizetype D.5297;
  struct bucket * * D.5298;
  register int c;
  register struct bucket * bp;
  int s_lineno;

  s_lineno = lineno;
  cptr.206 = cptr;
  D.5276 = *cptr.206;
  c = (int) D.5276;
  D.5277 = c == 39;
  D.5278 = c == 34;
  D.5279 = D.5277 | D.5278;
  if (D.5279 != 0) goto <D.5280>; else goto <D.5281>;
  <D.5280>:
  bp = get_literal ();
  goto <D.5282>;
  <D.5281>:
  bp = get_name ();
  <D.5282>:
  c = nextc ();
  if (c == 58) goto <D.5283>; else goto <D.5284>;
  <D.5283>:
  end_rule ();
  start_rule (bp, s_lineno);
  cptr.206 = cptr;
  cptr.207 = cptr.206 + 1;
  cptr = cptr.207;
  return;
  <D.5284>:
  last_was_action.208 = last_was_action;
  if (last_was_action.208 != 0) goto <D.5287>; else goto <D.5288>;
  <D.5287>:
  insert_empty_rule ();
  <D.5288>:
  last_was_action = 0;
  nitems.209 = nitems;
  nitems.210 = nitems.209 + 1;
  nitems = nitems.210;
  nitems.209 = nitems;
  maxitems.211 = maxitems;
  if (nitems.209 > maxitems.211) goto <D.5292>; else goto <D.5293>;
  <D.5292>:
  expand_items ();
  <D.5293>:
  pitem.212 = pitem;
  nitems.209 = nitems;
  nitems.213 = (sizetype) nitems.209;
  D.5296 = nitems.213 + 1073741823;
  D.5297 = D.5296 * 4;
  D.5298 = pitem.212 + D.5297;
  *D.5298 = bp;
}


copy_action ()
{
  char * cptr.214;
  int cptr.215;
  char * line.216;
  int line.217;
  int D.5304;
  sizetype D.5305;
  char last_was_action.218;
  int nrules.219;
  int D.5310;
  char D.5311;
  char * cptr.220;
  int nitems.221;
  struct bucket * * pitem.222;
  unsigned int i.223;
  unsigned int D.5318;
  struct bucket * * D.5319;
  struct bucket * D.5320;
  char D.5323;
  int D.3779;
  int iftmp.224;
  int D.3778;
  char[7] * D.5334;
  unsigned char D.5335;
  int D.5336;
  unsigned char D.5337;
  int D.5338;
  _Bool D.5339;
  _Bool D.5340;
  _Bool D.5341;
  const unsigned char * D.5344;
  unsigned char D.5345;
  int D.5346;
  const unsigned char * D.5347;
  unsigned char D.5348;
  int D.5349;
  _Bool D.5350;
  _Bool D.5351;
  const unsigned char * D.5354;
  unsigned char D.5355;
  int D.5356;
  const unsigned char * D.5357;
  unsigned char D.5358;
  int D.5359;
  _Bool D.5360;
  _Bool D.5361;
  const unsigned char * D.5364;
  unsigned char D.5365;
  int D.5366;
  const unsigned char * D.5367;
  unsigned char D.5368;
  int D.5369;
  sizetype len.225;
  char * D.5373;
  int D.5374;
  const short unsigned int * * D.5375;
  const short unsigned int * D.5376;
  unsigned int c.226;
  unsigned int D.5378;
  const short unsigned int * D.5379;
  short unsigned int D.5380;
  int D.5381;
  int D.5382;
  int D.3789;
  int iftmp.227;
  int D.3788;
  unsigned char D.5393;
  int D.5394;
  _Bool D.5395;
  _Bool D.5396;
  _Bool D.5397;
  const unsigned char * D.5400;
  unsigned char D.5401;
  int D.5402;
  _Bool D.5403;
  _Bool D.5404;
  const unsigned char * D.5407;
  unsigned char D.5408;
  int D.5409;
  _Bool D.5410;
  _Bool D.5411;
  const unsigned char * D.5414;
  unsigned char D.5415;
  int D.5416;
  int D.5419;
  int D.5420;
  int D.5421;
  unsigned int D.5424;
  unsigned int D.5425;
  const short unsigned int * D.5426;
  short unsigned int D.5427;
  int D.5428;
  int D.5429;
  int D.5431;
  int D.5432;
  int D.3799;
  int iftmp.228;
  int D.3798;
  unsigned char D.5439;
  int D.5440;
  _Bool D.5441;
  _Bool D.5442;
  _Bool D.5443;
  const unsigned char * D.5446;
  unsigned char D.5447;
  int D.5448;
  _Bool D.5449;
  _Bool D.5450;
  const unsigned char * D.5453;
  unsigned char D.5454;
  int D.5455;
  _Bool D.5456;
  _Bool D.5457;
  const unsigned char * D.5460;
  unsigned char D.5461;
  int D.5462;
  int D.5465;
  int D.5466;
  int ntags.229;
  struct bucket * * plhs.230;
  unsigned int nrules.231;
  unsigned int D.5475;
  struct bucket * * D.5476;
  struct bucket * D.5477;
  char * D.5478;
  char * cptr.232;
  _Bool D.5486;
  _Bool D.5487;
  _Bool D.5488;
  int D.5491;
  int D.5492;
  sizetype D.5493;
  sizetype D.5494;
  sizetype D.5495;
  struct bucket * * D.5496;
  struct bucket * D.5497;
  char * D.5500;
  int D.5501;
  int D.3814;
  int iftmp.233;
  int D.3813;
  unsigned char D.5506;
  int D.5507;
  _Bool D.5508;
  _Bool D.5509;
  _Bool D.5510;
  const unsigned char * D.5513;
  unsigned char D.5514;
  int D.5515;
  _Bool D.5516;
  _Bool D.5517;
  const unsigned char * D.5520;
  unsigned char D.5521;
  int D.5522;
  _Bool D.5523;
  _Bool D.5524;
  const unsigned char * D.5527;
  unsigned char D.5528;
  int D.5529;
  int D.5533;
  int D.5535;
  int lineno.234;
  int D.5540;
  int D.5545;
  int D.5546;
  int D.5547;
  int D.5550;
  _Bool D.5552;
  _Bool D.5553;
  _Bool D.5554;
  int len.235;
  char D.5556;
  int D.5557;
  int len.236;
  sizetype D.5563;
  char * cptr.237;
  char * cptr.238;
  char D.5566;
  int len.239;
  char * cptr.240;
  char * cptr.241;
  char D.5576;
  int len.242;
  int len.243;
  int len.244;
  int len.245;
  int len.246;
  int len.247;
  int len.248;
  int len.249;
  int len.250;
  char * cptr.251;
  char * cptr.252;
  char D.5600;
  int len.253;
  int len.254;
  int D.5613;
  int D.5614;
  int nmethods.255;
  int maxmethods.256;
  unsigned int maxmethods.257;
  unsigned int D.5622;
  char * methods.258;
  int maxmethods.259;
  char * * methods.260;
  void * methods.261;
  char * input_file_name.262;
  char * line_format.263;
  unsigned int D.5632;
  unsigned int D.5633;
  unsigned int D.5634;
  unsigned int D.5635;
  unsigned int D.5636;
  unsigned int D.5637;
  int nmethods.264;
  int nmethods.265;
  unsigned int nmethods.266;
  unsigned int D.5641;
  char * * D.5642;
  unsigned int len.267;
  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.214 = cptr;
      cptr.215 = (int) cptr.214;
      line.216 = line;
      line.217 = (int) line.216;
      D.5304 = cptr.215 - line.217;
      D.5305 = (sizetype) D.5304;
      a_cptr = a_line + D.5305;
      len = 0;
      comment_lines = 0;
      memset (&buffer, 0, 10000);
      last_was_action.218 = last_was_action;
      if (last_was_action.218 != 0) goto <D.5307>; else goto <D.5308>;
      <D.5307>:
      insert_empty_rule ();
      <D.5308>:
      last_was_action = 1;
      nrules.219 = nrules;
      D.5310 = nrules.219 + -2;
      fprintf (f, "case %d:\n", D.5310);
      cptr.214 = cptr;
      D.5311 = *cptr.214;
      if (D.5311 == 61) goto <D.5312>; else goto <D.5313>;
      <D.5312>:
      cptr.214 = cptr;
      cptr.220 = cptr.214 + 1;
      cptr = cptr.220;
      <D.5313>:
      n = 0;
      nitems.221 = nitems;
      i = nitems.221 + -1;
      goto <D.3765>;
      <D.3764>:
      n = n + 1;
      i = i + -1;
      <D.3765>:
      pitem.222 = pitem;
      i.223 = (unsigned int) i;
      D.5318 = i.223 * 4;
      D.5319 = pitem.222 + D.5318;
      D.5320 = *D.5319;
      if (D.5320 != 0B) goto <D.3764>; else goto <D.3766>;
      <D.3766>:
      depth = 0;
      loop:
      cptr.214 = cptr;
      D.5311 = *cptr.214;
      c = (int) D.5311;
      if (c == 36) goto <D.5321>; else goto <D.5322>;
      <D.5321>:
      cptr.214 = cptr;
      cptr.220 = cptr.214 + 1;
      D.5323 = *cptr.220;
      if (D.5323 == 60) goto <D.5324>; else goto <D.5325>;
      <D.5324>:
      {
        int d_lineno;
        char * d_line;
        char * d_cptr;
        extern int dollar_error ();

        d_lineno = lineno;
        d_line = dup_line ();
        cptr.214 = cptr;
        cptr.215 = (int) cptr.214;
        line.216 = line;
        line.217 = (int) line.216;
        D.5304 = cptr.215 - line.217;
        D.5305 = (sizetype) D.5304;
        d_cptr = d_line + D.5305;
        cptr.214 = cptr;
        cptr.220 = cptr.214 + 1;
        cptr = cptr.220;
        tag = get_tag (1);
        cptr.214 = cptr;
        D.5311 = *cptr.214;
        c = (int) D.5311;
        if (c == 36) goto <D.5326>; else goto <D.5327>;
        <D.5326>:
        if (tag != 0B) goto <D.5330>; else goto <D.5328>;
        <D.5330>:
        {
          size_t __s1_len;
          size_t __s2_len;

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

            __s2 = tag;
            D.5334 = "Object";
            D.5335 = MEM[(const unsigned char *)D.5334];
            D.5336 = (int) D.5335;
            D.5337 = *__s2;
            D.5338 = (int) D.5337;
            __result = D.5336 - D.5338;
            {
              D.5339 = __s2_len != 0;
              D.5340 = __result == 0;
              D.5341 = D.5339 & D.5340;
              if (D.5341 != 0) goto <D.5342>; else goto <D.5343>;
              <D.5342>:
              D.5344 = &MEM[(void *)"Object" + 1B];
              D.5345 = *D.5344;
              D.5346 = (int) D.5345;
              D.5347 = __s2 + 1;
              D.5348 = *D.5347;
              D.5349 = (int) D.5348;
              __result = D.5346 - D.5349;
              D.5350 = __s2_len > 1;
              D.5340 = __result == 0;
              D.5351 = D.5350 & D.5340;
              if (D.5351 != 0) goto <D.5352>; else goto <D.5353>;
              <D.5352>:
              D.5354 = &MEM[(void *)"Object" + 2B];
              D.5355 = *D.5354;
              D.5356 = (int) D.5355;
              D.5357 = __s2 + 2;
              D.5358 = *D.5357;
              D.5359 = (int) D.5358;
              __result = D.5356 - D.5359;
              D.5360 = __s2_len > 2;
              D.5340 = __result == 0;
              D.5361 = D.5360 & D.5340;
              if (D.5361 != 0) goto <D.5362>; else goto <D.5363>;
              <D.5362>:
              D.5364 = &MEM[(void *)"Object" + 3B];
              D.5365 = *D.5364;
              D.5366 = (int) D.5365;
              D.5367 = __s2 + 3;
              D.5368 = *D.5367;
              D.5369 = (int) D.5368;
              __result = D.5366 - D.5369;
              <D.5363>:
              <D.5353>:
              <D.5343>:
            }
            D.3778 = __result;
          }
          iftmp.224 = -D.3778;
          goto <D.5370>;
          <D.5333>:
          iftmp.224 = __builtin_strcmp (tag, "Object");
          <D.5370>:
          D.3779 = iftmp.224;
        }
        if (D.3779 != 0) goto <D.5371>; else goto <D.5328>;
        <D.5371>:
        len.225 = (sizetype) len;
        D.5373 = &buffer + len.225;
        D.5374 = sprintf (D.5373, "((%s)yyVal)", tag);
        len = D.5374 + len;
        goto <D.5329>;
        <D.5328>:
        len.225 = (sizetype) len;
        D.5373 = &buffer + len.225;
        strcat (D.5373, "yyVal");
        len = len + 5;
        <D.5329>:
        cptr.214 = cptr;
        cptr.220 = cptr.214 + 1;
        cptr = cptr.220;
        free (d_line);
        goto loop;
        <D.5327>:
        D.5375 = __ctype_b_loc ();
        D.5376 = *D.5375;
        c.226 = (unsigned int) c;
        D.5378 = c.226 * 2;
        D.5379 = D.5376 + D.5378;
        D.5380 = *D.5379;
        D.5381 = (int) D.5380;
        D.5382 = D.5381 & 2048;
        if (D.5382 != 0) goto <D.5383>; else goto <D.5384>;
        <D.5383>:
        {
          extern int dollar_warning ();

          i = get_number ();
          if (i > n) goto <D.5385>; else goto <D.5386>;
          <D.5385>:
          dollar_warning (d_lineno, i);
          <D.5386>:
          if (tag != 0B) goto <D.5389>; else goto <D.5387>;
          <D.5389>:
          {
            size_t __s1_len;
            size_t __s2_len;

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

              __s2 = tag;
              D.5334 = "Object";
              D.5335 = MEM[(const unsigned char *)D.5334];
              D.5336 = (int) D.5335;
              D.5393 = *__s2;
              D.5394 = (int) D.5393;
              __result = D.5336 - D.5394;
              {
                D.5395 = __s2_len != 0;
                D.5396 = __result == 0;
                D.5397 = D.5395 & D.5396;
                if (D.5397 != 0) goto <D.5398>; else goto <D.5399>;
                <D.5398>:
                D.5344 = &MEM[(void *)"Object" + 1B];
                D.5345 = *D.5344;
                D.5346 = (int) D.5345;
                D.5400 = __s2 + 1;
                D.5401 = *D.5400;
                D.5402 = (int) D.5401;
                __result = D.5346 - D.5402;
                D.5403 = __s2_len > 1;
                D.5396 = __result == 0;
                D.5404 = D.5403 & D.5396;
                if (D.5404 != 0) goto <D.5405>; else goto <D.5406>;
                <D.5405>:
                D.5354 = &MEM[(void *)"Object" + 2B];
                D.5355 = *D.5354;
                D.5356 = (int) D.5355;
                D.5407 = __s2 + 2;
                D.5408 = *D.5407;
                D.5409 = (int) D.5408;
                __result = D.5356 - D.5409;
                D.5410 = __s2_len > 2;
                D.5396 = __result == 0;
                D.5411 = D.5410 & D.5396;
                if (D.5411 != 0) goto <D.5412>; else goto <D.5413>;
                <D.5412>:
                D.5364 = &MEM[(void *)"Object" + 3B];
                D.5365 = *D.5364;
                D.5366 = (int) D.5365;
                D.5414 = __s2 + 3;
                D.5415 = *D.5414;
                D.5416 = (int) D.5415;
                __result = D.5366 - D.5416;
                <D.5413>:
                <D.5406>:
                <D.5399>:
              }
              D.3788 = __result;
            }
            iftmp.227 = -D.3788;
            goto <D.5417>;
            <D.5392>:
            iftmp.227 = __builtin_strcmp (tag, "Object");
            <D.5417>:
            D.3789 = iftmp.227;
          }
          if (D.3789 != 0) goto <D.5418>; else goto <D.5387>;
          <D.5418>:
          D.5419 = i - n;
          len.225 = (sizetype) len;
          D.5373 = &buffer + len.225;
          D.5420 = sprintf (D.5373, "((%s)yyVals[%d+yyTop])", tag, D.5419);
          len = D.5420 + len;
          goto <D.5388>;
          <D.5387>:
          D.5419 = i - n;
          len.225 = (sizetype) len;
          D.5373 = &buffer + len.225;
          D.5421 = sprintf (D.5373, "yyVals[%d+yyTop]", D.5419);
          len = D.5421 + len;
          <D.5388>:
          free (d_line);
          goto loop;
        }
        <D.5384>:
        if (c == 45) goto <D.5423>; else goto <D.5422>;
        <D.5423>:
        D.5375 = __ctype_b_loc ();
        D.5376 = *D.5375;
        cptr.214 = cptr;
        cptr.220 = cptr.214 + 1;
        D.5323 = *cptr.220;
        D.5424 = (unsigned int) D.5323;
        D.5425 = D.5424 * 2;
        D.5426 = D.5376 + D.5425;
        D.5427 = *D.5426;
        D.5428 = (int) D.5427;
        D.5429 = D.5428 & 2048;
        if (D.5429 != 0) goto <D.5430>; else goto <D.5422>;
        <D.5430>:
        cptr.214 = cptr;
        cptr.220 = cptr.214 + 1;
        cptr = cptr.220;
        D.5431 = get_number ();
        D.5432 = -D.5431;
        i = D.5432 - n;
        if (tag != 0B) goto <D.5435>; else goto <D.5433>;
        <D.5435>:
        {
          size_t __s1_len;
          size_t __s2_len;

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

            __s2 = tag;
            D.5334 = "Object";
            D.5335 = MEM[(const unsigned char *)D.5334];
            D.5336 = (int) D.5335;
            D.5439 = *__s2;
            D.5440 = (int) D.5439;
            __result = D.5336 - D.5440;
            {
              D.5441 = __s2_len != 0;
              D.5442 = __result == 0;
              D.5443 = D.5441 & D.5442;
              if (D.5443 != 0) goto <D.5444>; else goto <D.5445>;
              <D.5444>:
              D.5344 = &MEM[(void *)"Object" + 1B];
              D.5345 = *D.5344;
              D.5346 = (int) D.5345;
              D.5446 = __s2 + 1;
              D.5447 = *D.5446;
              D.5448 = (int) D.5447;
              __result = D.5346 - D.5448;
              D.5449 = __s2_len > 1;
              D.5442 = __result == 0;
              D.5450 = D.5449 & D.5442;
              if (D.5450 != 0) goto <D.5451>; else goto <D.5452>;
              <D.5451>:
              D.5354 = &MEM[(void *)"Object" + 2B];
              D.5355 = *D.5354;
              D.5356 = (int) D.5355;
              D.5453 = __s2 + 2;
              D.5454 = *D.5453;
              D.5455 = (int) D.5454;
              __result = D.5356 - D.5455;
              D.5456 = __s2_len > 2;
              D.5442 = __result == 0;
              D.5457 = D.5456 & D.5442;
              if (D.5457 != 0) goto <D.5458>; else goto <D.5459>;
              <D.5458>:
              D.5364 = &MEM[(void *)"Object" + 3B];
              D.5365 = *D.5364;
              D.5366 = (int) D.5365;
              D.5460 = __s2 + 3;
              D.5461 = *D.5460;
              D.5462 = (int) D.5461;
              __result = D.5366 - D.5462;
              <D.5459>:
              <D.5452>:
              <D.5445>:
            }
            D.3798 = __result;
          }
          iftmp.228 = -D.3798;
          goto <D.5463>;
          <D.5438>:
          iftmp.228 = __builtin_strcmp (tag, "Object");
          <D.5463>:
          D.3799 = iftmp.228;
        }
        if (D.3799 != 0) goto <D.5464>; else goto <D.5433>;
        <D.5464>:
        len.225 = (sizetype) len;
        D.5373 = &buffer + len.225;
        D.5465 = sprintf (D.5373, "((%s)yyVals[%d+yyTop])", tag, i);
        len = D.5465 + len;
        goto <D.5434>;
        <D.5433>:
        len.225 = (sizetype) len;
        D.5373 = &buffer + len.225;
        D.5466 = sprintf (D.5373, "yyVals[%d+yyTop]", i);
        len = D.5466 + len;
        <D.5434>:
        free (d_line);
        goto loop;
        <D.5422>:
        dollar_error (d_lineno, d_line, d_cptr);
      }
      goto <D.5467>;
      <D.5325>:
      cptr.214 = cptr;
      cptr.220 = cptr.214 + 1;
      D.5323 = *cptr.220;
      if (D.5323 == 36) goto <D.5468>; else goto <D.5469>;
      <D.5468>:
      {
        extern int untyped_lhs ();

        ntags.229 = ntags;
        if (ntags.229 != 0) goto <D.5471>; else goto <D.5472>;
        <D.5471>:
        plhs.230 = plhs;
        nrules.219 = nrules;
        nrules.231 = (unsigned int) nrules.219;
        D.5475 = nrules.231 * 4;
        D.5476 = plhs.230 + D.5475;
        D.5477 = *D.5476;
        D.5478 = D.5477->tag;
        if (D.5478 == 0B) goto <D.5479>; else goto <D.5480>;
        <D.5479>:
        untyped_lhs ();
        <D.5480>:
        <D.5472>:
        strcat (&buffer, "yyVal");
        len = len + 5;
        cptr.214 = cptr;
        cptr.232 = cptr.214 + 2;
        cptr = cptr.232;
        goto loop;
      }
      <D.5469>:
      D.5375 = __ctype_b_loc ();
      D.5376 = *D.5375;
      cptr.214 = cptr;
      cptr.220 = cptr.214 + 1;
      D.5323 = *cptr.220;
      D.5424 = (unsigned int) D.5323;
      D.5425 = D.5424 * 2;
      D.5426 = D.5376 + D.5425;
      D.5427 = *D.5426;
      D.5428 = (int) D.5427;
      D.5429 = D.5428 & 2048;
      if (D.5429 != 0) goto <D.5482>; else goto <D.5483>;
      <D.5482>:
      cptr.214 = cptr;
      cptr.220 = cptr.214 + 1;
      cptr = cptr.220;
      i = get_number ();
      ntags.229 = ntags;
      if (ntags.229 != 0) goto <D.5484>; else goto <D.5485>;
      <D.5484>:
      {
        extern int unknown_rhs ();
        extern int untyped_rhs ();

        D.5486 = i <= 0;
        D.5487 = i > n;
        D.5488 = D.5486 | D.5487;
        if (D.5488 != 0) goto <D.5489>; else goto <D.5490>;
        <D.5489>:
        unknown_rhs (i);
        <D.5490>:
        pitem.222 = pitem;
        nitems.221 = nitems;
        D.5491 = nitems.221 + i;
        D.5492 = D.5491 - n;
        D.5493 = (sizetype) D.5492;
        D.5494 = D.5493 + 1073741823;
        D.5495 = D.5494 * 4;
        D.5496 = pitem.222 + D.5495;
        D.5497 = *D.5496;
        tag = D.5497->tag;
        if (tag == 0B) goto <D.5498>; else goto <D.5499>;
        <D.5498>:
        pitem.222 = pitem;
        nitems.221 = nitems;
        D.5491 = nitems.221 + i;
        D.5492 = D.5491 - n;
        D.5493 = (sizetype) D.5492;
        D.5494 = D.5493 + 1073741823;
        D.5495 = D.5494 * 4;
        D.5496 = pitem.222 + D.5495;
        D.5497 = *D.5496;
        D.5500 = D.5497->name;
        untyped_rhs (i, D.5500);
        D.5419 = i - n;
        len.225 = (sizetype) len;
        D.5373 = &buffer + len.225;
        D.5501 = sprintf (D.5373, "yyVals[%d+yyTop]", D.5419);
        len = D.5501 + len;
        goto <D.5502>;
        <D.5499>:
        {
          size_t __s1_len;
          size_t __s2_len;

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

            __s2 = tag;
            D.5334 = "Object";
            D.5335 = MEM[(const unsigned char *)D.5334];
            D.5336 = (int) D.5335;
            D.5506 = *__s2;
            D.5507 = (int) D.5506;
            __result = D.5336 - D.5507;
            {
              D.5508 = __s2_len != 0;
              D.5509 = __result == 0;
              D.5510 = D.5508 & D.5509;
              if (D.5510 != 0) goto <D.5511>; else goto <D.5512>;
              <D.5511>:
              D.5344 = &MEM[(void *)"Object" + 1B];
              D.5345 = *D.5344;
              D.5346 = (int) D.5345;
              D.5513 = __s2 + 1;
              D.5514 = *D.5513;
              D.5515 = (int) D.5514;
              __result = D.5346 - D.5515;
              D.5516 = __s2_len > 1;
              D.5509 = __result == 0;
              D.5517 = D.5516 & D.5509;
              if (D.5517 != 0) goto <D.5518>; else goto <D.5519>;
              <D.5518>:
              D.5354 = &MEM[(void *)"Object" + 2B];
              D.5355 = *D.5354;
              D.5356 = (int) D.5355;
              D.5520 = __s2 + 2;
              D.5521 = *D.5520;
              D.5522 = (int) D.5521;
              __result = D.5356 - D.5522;
              D.5523 = __s2_len > 2;
              D.5509 = __result == 0;
              D.5524 = D.5523 & D.5509;
              if (D.5524 != 0) goto <D.5525>; else goto <D.5526>;
              <D.5525>:
              D.5364 = &MEM[(void *)"Object" + 3B];
              D.5365 = *D.5364;
              D.5366 = (int) D.5365;
              D.5527 = __s2 + 3;
              D.5528 = *D.5527;
              D.5529 = (int) D.5528;
              __result = D.5366 - D.5529;
              <D.5526>:
              <D.5519>:
              <D.5512>:
            }
            D.3813 = __result;
          }
          iftmp.233 = -D.3813;
          goto <D.5530>;
          <D.5505>:
          iftmp.233 = __builtin_strcmp (tag, "Object");
          <D.5530>:
          D.3814 = iftmp.233;
        }
        if (D.3814 != 0) goto <D.5531>; else goto <D.5532>;
        <D.5531>:
        D.5419 = i - n;
        len.225 = (sizetype) len;
        D.5373 = &buffer + len.225;
        D.5533 = sprintf (D.5373, "((%s)yyVals[%d+yyTop])", tag, D.5419);
        len = D.5533 + len;
        goto <D.5534>;
        <D.5532>:
        D.5419 = i - n;
        len.225 = (sizetype) len;
        D.5373 = &buffer + len.225;
        D.5535 = sprintf (D.5373, "yyVals[%d+yyTop]", D.5419);
        len = D.5535 + len;
        <D.5534>:
        <D.5502>:
      }
      goto <D.5536>;
      <D.5485>:
      {
        extern int dollar_warning ();

        if (i > n) goto <D.5537>; else goto <D.5538>;
        <D.5537>:
        lineno.234 = lineno;
        dollar_warning (lineno.234, i);
        <D.5538>:
        D.5419 = i - n;
        len.225 = (sizetype) len;
        D.5373 = &buffer + len.225;
        D.5540 = sprintf (D.5373, "yyVals[%d+yyTop]", D.5419);
        len = D.5540 + len;
      }
      <D.5536>:
      goto loop;
      <D.5483>:
      cptr.214 = cptr;
      cptr.220 = cptr.214 + 1;
      D.5323 = *cptr.220;
      if (D.5323 == 45) goto <D.5541>; else goto <D.5542>;
      <D.5541>:
      {
        extern int unknown_rhs ();

        cptr.214 = cptr;
        cptr.232 = cptr.214 + 2;
        cptr = cptr.232;
        i = get_number ();
        ntags.229 = ntags;
        if (ntags.229 != 0) goto <D.5543>; else goto <D.5544>;
        <D.5543>:
        D.5545 = -i;
        unknown_rhs (D.5545);
        <D.5544>:
        D.5545 = -i;
        D.5546 = D.5545 - n;
        len.225 = (sizetype) len;
        D.5373 = &buffer + len.225;
        D.5547 = sprintf (D.5373, "yyVals[%d+yyTop]", D.5546);
        len = D.5547 + len;
        goto loop;
      }
      <D.5542>:
      <D.5467>:
      <D.5322>:
      D.5375 = __ctype_b_loc ();
      D.5376 = *D.5375;
      c.226 = (unsigned int) c;
      D.5378 = c.226 * 2;
      D.5379 = D.5376 + D.5378;
      D.5380 = *D.5379;
      D.5381 = (int) D.5380;
      D.5550 = D.5381 & 1024;
      if (D.5550 != 0) goto <D.5548>; else goto <D.5551>;
      <D.5551>:
      D.5552 = c == 95;
      D.5553 = c == 36;
      D.5554 = D.5552 | D.5553;
      if (D.5554 != 0) goto <D.5548>; else goto <D.5549>;
      <D.5548>:
      <D.3819>:
      len.235 = len;
      len = len.235 + 1;
      D.5556 = (char) c;
      buffer[len.235] = D.5556;
      cptr.214 = cptr;
      cptr.220 = cptr.214 + 1;
      cptr = cptr.220;
      cptr.214 = cptr;
      D.5311 = *cptr.214;
      c = (int) D.5311;
      D.5375 = __ctype_b_loc ();
      D.5376 = *D.5375;
      c.226 = (unsigned int) c;
      D.5378 = c.226 * 2;
      D.5379 = D.5376 + D.5378;
      D.5380 = *D.5379;
      D.5381 = (int) D.5380;
      D.5557 = D.5381 & 8;
      if (D.5557 != 0) goto <D.3819>; else goto <D.5558>;
      <D.5558>:
      D.5552 = c == 95;
      D.5553 = c == 36;
      D.5554 = D.5552 | D.5553;
      if (D.5554 != 0) goto <D.3819>; else goto <D.3820>;
      <D.3820>:
      goto loop;
      <D.5549>:
      len.236 = len;
      len = len.236 + 1;
      D.5556 = (char) c;
      buffer[len.236] = D.5556;
      cptr.214 = cptr;
      cptr.220 = cptr.214 + 1;
      cptr = cptr.220;
      switch (c) <default: <D.3844>, case 10: <D.3821>, case 34: <D.3829>, case 39: <D.3828>, case 47: <D.3835>, case 59: <D.3824>, case 123: <D.3826>, case 125: <D.3827>>
      {
        extern int unterminated_action ();

        <D.3821>:
        next_line:
        get_line ();
        line.216 = line;
        if (line.216 != 0B) goto loop; else goto <D.5560>;
        <D.5560>:
        unterminated_action (a_lineno, a_line, a_cptr);
        <D.3824>:
        if (depth > 0) goto loop; else goto <D.5561>;
        <D.5561>:
        goto <D.3825>;
        <D.3826>:
        depth = depth + 1;
        goto loop;
        <D.3827>:
        depth = depth + -1;
        if (depth > 0) goto loop; else goto <D.5562>;
        <D.5562>:
        goto <D.3825>;
        <D.3828>:
        <D.3829>:
        {
          int s_lineno;
          char * s_line;
          char * s_cptr;

          s_lineno = lineno;
          s_line = dup_line ();
          cptr.214 = cptr;
          cptr.215 = (int) cptr.214;
          line.216 = line;
          line.217 = (int) line.216;
          D.5304 = cptr.215 - line.217;
          D.5305 = (sizetype) D.5304;
          D.5563 = D.5305 + 4294967295;
          s_cptr = s_line + D.5563;
          quote = c;
          <D.3834>:
          {
            extern int unterminated_string ();

            cptr.214 = cptr;
            cptr.237 = cptr.214;
            cptr.238 = cptr.237 + 1;
            cptr = cptr.238;
            D.5566 = *cptr.237;
            c = (int) D.5566;
            len.239 = len;
            len = len.239 + 1;
            D.5556 = (char) c;
            buffer[len.239] = D.5556;
            if (c == quote) goto <D.5568>; else goto <D.5569>;
            <D.5568>:
            free (s_line);
            goto loop;
            <D.5569>:
            if (c == 10) goto <D.5570>; else goto <D.5571>;
            <D.5570>:
            unterminated_string (s_lineno, s_line, s_cptr);
            <D.5571>:
            if (c == 92) goto <D.5572>; else goto <D.5573>;
            <D.5572>:
            cptr.214 = cptr;
            cptr.240 = cptr.214;
            cptr.241 = cptr.240 + 1;
            cptr = cptr.241;
            D.5576 = *cptr.240;
            c = (int) D.5576;
            len.242 = len;
            len = len.242 + 1;
            D.5556 = (char) c;
            buffer[len.242] = D.5556;
            if (c == 10) goto <D.5578>; else goto <D.5579>;
            <D.5578>:
            get_line ();
            line.216 = line;
            if (line.216 == 0B) goto <D.5580>; else goto <D.5581>;
            <D.5580>:
            unterminated_string (s_lineno, s_line, s_cptr);
            <D.5581>:
            <D.5579>:
            <D.5573>:
          }
          goto <D.3834>;
        }
        <D.3835>:
        cptr.214 = cptr;
        D.5311 = *cptr.214;
        c = (int) D.5311;
        if (c == 47) goto <D.5582>; else goto <D.5583>;
        <D.5582>:
        len.243 = len;
        len = len.243 + 1;
        buffer[len.243] = 42;
        goto <D.3837>;
        <D.3836>:
        if (c == 42) goto <D.5587>; else goto <D.5585>;
        <D.5587>:
        cptr.214 = cptr;
        cptr.220 = cptr.214 + 1;
        D.5323 = *cptr.220;
        if (D.5323 == 47) goto <D.5588>; else goto <D.5585>;
        <D.5588>:
        len.244 = len;
        len = len.244 + 1;
        buffer[len.244] = 42;
        len.245 = len;
        len = len.245 + 1;
        buffer[len.245] = 32;
        goto <D.5586>;
        <D.5585>:
        len.246 = len;
        len = len.246 + 1;
        D.5556 = (char) c;
        buffer[len.246] = D.5556;
        <D.5586>:
        <D.3837>:
        cptr.214 = cptr;
        cptr.220 = cptr.214 + 1;
        cptr = cptr.220;
        cptr.214 = cptr;
        D.5311 = *cptr.214;
        c = (int) D.5311;
        if (c != 10) goto <D.3836>; else goto <D.3838>;
        <D.3838>:
        len.247 = len;
        len = len.247 + 1;
        buffer[len.247] = 42;
        len.248 = len;
        len = len.248 + 1;
        buffer[len.248] = 47;
        len.249 = len;
        len = len.249 + 1;
        buffer[len.249] = 10;
        goto next_line;
        <D.5583>:
        if (c == 42) goto <D.5595>; else goto <D.5596>;
        <D.5595>:
        {
          int c_lineno;
          char * c_line;
          char * c_cptr;

          c_lineno = lineno;
          c_line = dup_line ();
          cptr.214 = cptr;
          cptr.215 = (int) cptr.214;
          line.216 = line;
          line.217 = (int) line.216;
          D.5304 = cptr.215 - line.217;
          D.5305 = (sizetype) D.5304;
          D.5563 = D.5305 + 4294967295;
          c_cptr = c_line + D.5563;
          len.250 = len;
          len = len.250 + 1;
          buffer[len.250] = 42;
          cptr.214 = cptr;
          cptr.220 = cptr.214 + 1;
          cptr = cptr.220;
          <D.3843>:
          cptr.214 = cptr;
          cptr.251 = cptr.214;
          cptr.252 = cptr.251 + 1;
          cptr = cptr.252;
          D.5600 = *cptr.251;
          c = (int) D.5600;
          len.253 = len;
          len = len.253 + 1;
          D.5556 = (char) c;
          buffer[len.253] = D.5556;
          if (c == 42) goto <D.5602>; else goto <D.5603>;
          <D.5602>:
          cptr.214 = cptr;
          D.5311 = *cptr.214;
          if (D.5311 == 47) goto <D.5604>; else goto <D.5605>;
          <D.5604>:
          len.254 = len;
          len = len.254 + 1;
          buffer[len.254] = 47;
          cptr.214 = cptr;
          cptr.220 = cptr.214 + 1;
          cptr = cptr.220;
          free (c_line);
          goto loop;
          <D.5605>:
          <D.5603>:
          if (c == 10) goto <D.5607>; else goto <D.5608>;
          <D.5607>:
          {
            extern int unterminated_comment ();

            comment_lines = comment_lines + 1;
            get_line ();
            line.216 = line;
            if (line.216 == 0B) goto <D.5609>; else goto <D.5610>;
            <D.5609>:
            unterminated_comment (c_lineno, c_line, c_cptr);
            <D.5610>:
          }
          <D.5608>:
          goto <D.3843>;
        }
        <D.5596>:
        goto loop;
        <D.3844>:
        goto loop;
      }
      <D.3825>:
      if (comment_lines > 0) goto <D.5611>; else goto <D.5612>;
      <D.5611>:
      comment_lines = comment_lines + 1;
      <D.5612>:
      lineno.234 = lineno;
      D.5613 = a_lineno + comment_lines;
      D.5614 = lineno.234 - D.5613;
      if (D.5614 > 2) goto <D.5615>; else goto <D.5616>;
      <D.5615>:
      {
        char mname[20];
        char line_define[256];

        try
          {
            nrules.219 = nrules;
            D.5310 = nrules.219 + -2;
            sprintf (&mname, "case_%d()", D.5310);
            _IO_putc (32, f);
            _IO_putc (32, f);
            fputs (&mname, f);
            fprintf (f, ";");
            nmethods.255 = nmethods;
            if (nmethods.255 == 0) goto <D.5618>; else goto <D.5619>;
            <D.5618>:
            maxmethods = 100;
            maxmethods.256 = maxmethods;
            maxmethods.257 = (unsigned int) maxmethods.256;
            D.5622 = maxmethods.257 * 4;
            methods.258 = allocate (D.5622);
            methods = methods.258;
            goto <D.5624>;
            <D.5619>:
            nmethods.255 = nmethods;
            maxmethods.256 = maxmethods;
            if (nmethods.255 == maxmethods.256) goto <D.5625>; else goto <D.5626>;
            <D.5625>:
            maxmethods.256 = maxmethods;
            maxmethods.259 = maxmethods.256 + 500;
            maxmethods = maxmethods.259;
            maxmethods.256 = maxmethods;
            maxmethods.257 = (unsigned int) maxmethods.256;
            D.5622 = maxmethods.257 * 4;
            methods.260 = methods;
            methods.261 = realloc (methods.260, D.5622);
            methods = methods.261;
            <D.5626>:
            <D.5624>:
            input_file_name.262 = input_file_name;
            line_format.263 = line_format;
            sprintf (&line_define, line_format.263, a_lineno, input_file_name.262);
            D.5632 = strlen (&line_define);
            D.5633 = strlen (&mname);
            D.5634 = D.5632 + D.5633;
            D.5635 = strlen (&buffer);
            D.5636 = D.5634 + D.5635;
            D.5637 = D.5636 + 7;
            mbody = allocate (D.5637);
            strcpy (mbody, "void ");
            strcat (mbody, &mname);
            strcat (mbody, "\n");
            strcat (mbody, &line_define);
            strcat (mbody, &buffer);
            methods.260 = methods;
            nmethods.255 = nmethods;
            nmethods.264 = nmethods.255;
            nmethods.265 = nmethods.264 + 1;
            nmethods = nmethods.265;
            nmethods.266 = (unsigned int) nmethods.264;
            D.5641 = nmethods.266 * 4;
            D.5642 = methods.260 + D.5641;
            *D.5642 = mbody;
          }
        finally
          {
            mname = {CLOBBER};
            line_define = {CLOBBER};
          }
      }
      goto <D.5643>;
      <D.5616>:
      input_file_name.262 = input_file_name;
      lineno.234 = lineno;
      line_format.263 = line_format;
      fprintf (f, line_format.263, lineno.234, input_file_name.262);
      _IO_putc (32, f);
      _IO_putc (32, f);
      len.267 = (unsigned int) len;
      fwrite (&buffer, 1, len.267, f);
      <D.5643>:
      fprintf (f, "\n  break;\n");
    }
  finally
    {
      buffer = {CLOBBER};
    }
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.5647;
  int D.5652;
  void * D.5654;
  unsigned int D.5655;

  D.5647 = __builtin_constant_p (__len);
  if (D.5647 != 0) goto <D.5648>; else goto <D.5649>;
  <D.5648>:
  if (__len == 0) goto <D.5650>; else goto <D.5651>;
  <D.5650>:
  D.5652 = __builtin_constant_p (__ch);
  if (D.5652 == 0) goto <D.5645>; else goto <D.5653>;
  <D.5653>:
  if (__ch != 0) goto <D.5645>; else goto <D.5646>;
  <D.5645>:
  __warn_memset_zero_len ();
  D.5654 = __dest;
  return D.5654;
  <D.5646>:
  <D.5651>:
  <D.5649>:
  D.5655 = __builtin_object_size (__dest, 0);
  D.5654 = __builtin___memset_chk (__dest, __ch, __len, D.5655);
  return D.5654;
}


strcat (char * restrict __dest, const char * restrict __src)
{
  char * D.5657;
  unsigned int D.5658;

  D.5658 = __builtin_object_size (__dest, 1);
  D.5657 = __builtin___strcat_chk (__dest, __src, D.5658);
  return D.5657;
}


mark_symbol ()
{
  char * cptr.268;
  char * D.5661;
  char D.5662;
  _Bool D.5663;
  _Bool D.5664;
  _Bool D.5665;
  char * cptr.269;
  int D.5669;
  _Bool D.5678;
  _Bool D.5679;
  _Bool D.5680;
  char D.5682;
  char * D.5684;
  char D.5685;
  char * D.5687;
  char D.5688;
  char * cptr.272;
  char D.5691;
  int iftmp.270;
  const short unsigned int * * D.5695;
  const short unsigned int * D.5696;
  unsigned int c.271;
  unsigned int D.5698;
  const short unsigned int * D.5699;
  short unsigned int D.5700;
  int D.5701;
  int D.5702;
  _Bool D.5704;
  _Bool D.5705;
  _Bool D.5706;
  char * line.273;
  int lineno.274;
  int D.5715;
  _Bool D.5717;
  _Bool D.5718;
  _Bool D.5719;
  _Bool D.5721;
  _Bool D.5722;
  _Bool D.5723;
  short int * rprec.275;
  int nrules.276;
  unsigned int nrules.277;
  unsigned int D.5730;
  short int * D.5731;
  short int D.5732;
  short int D.5735;
  char * rassoc.278;
  sizetype nrules.279;
  char * D.5740;
  char D.5741;
  register int c;
  register struct bucket * bp;
  extern int syntax_error ();
  extern int prec_redeclared ();

  cptr.268 = cptr;
  D.5661 = cptr.268 + 1;
  D.5662 = *D.5661;
  c = (int) D.5662;
  D.5663 = c == 37;
  D.5664 = c == 92;
  D.5665 = D.5663 | D.5664;
  if (D.5665 != 0) goto <D.5666>; else goto <D.5667>;
  <D.5666>:
  cptr.268 = cptr;
  cptr.269 = cptr.268 + 2;
  cptr = cptr.269;
  D.5669 = 1;
  return D.5669;
  <D.5667>:
  if (c == 61) goto <D.5670>; else goto <D.5671>;
  <D.5670>:
  cptr.268 = cptr;
  cptr.269 = cptr.268 + 2;
  cptr = cptr.269;
  goto <D.5672>;
  <D.5671>:
  D.5678 = c == 112;
  D.5679 = c == 80;
  D.5680 = D.5678 | D.5679;
  if (D.5680 != 0) goto <D.5681>; else goto <D.5673>;
  <D.5681>:
  cptr.268 = cptr;
  cptr.269 = cptr.268 + 2;
  D.5682 = *cptr.269;
  c = (int) D.5682;
  if (c == 114) goto <D.5674>; else goto <D.5683>;
  <D.5683>:
  if (c == 82) goto <D.5674>; else goto <D.5673>;
  <D.5674>:
  cptr.268 = cptr;
  D.5684 = cptr.268 + 3;
  D.5685 = *D.5684;
  c = (int) D.5685;
  if (c == 101) goto <D.5675>; else goto <D.5686>;
  <D.5686>:
  if (c == 69) goto <D.5675>; else goto <D.5673>;
  <D.5675>:
  cptr.268 = cptr;
  D.5687 = cptr.268 + 4;
  D.5688 = *D.5687;
  c = (int) D.5688;
  if (c == 99) goto <D.5676>; else goto <D.5689>;
  <D.5689>:
  if (c == 67) goto <D.5676>; else goto <D.5673>;
  <D.5676>:
  cptr.268 = cptr;
  cptr.272 = cptr.268 + 5;
  D.5691 = *cptr.272;
  c = (int) D.5691;
  D.5695 = __ctype_b_loc ();
  D.5696 = *D.5695;
  c.271 = (unsigned int) c;
  D.5698 = c.271 * 2;
  D.5699 = D.5696 + D.5698;
  D.5700 = *D.5699;
  D.5701 = (int) D.5700;
  D.5702 = D.5701 & 8;
  if (D.5702 == 0) goto <D.5703>; else goto <D.5693>;
  <D.5703>:
  D.5704 = c != 95;
  D.5705 = c != 46;
  D.5706 = D.5704 & D.5705;
  if (D.5706 != 0) goto <D.5707>; else goto <D.5693>;
  <D.5707>:
  if (c != 36) goto <D.5708>; else goto <D.5693>;
  <D.5708>:
  iftmp.270 = 1;
  goto <D.5694>;
  <D.5693>:
  iftmp.270 = 0;
  <D.5694>:
  if (iftmp.270 != 0) goto <D.5709>; else goto <D.5673>;
  <D.5709>:
  cptr.268 = cptr;
  cptr.272 = cptr.268 + 5;
  cptr = cptr.272;
  goto <D.5677>;
  <D.5673>:
  cptr.268 = cptr;
  line.273 = line;
  lineno.274 = lineno;
  syntax_error (lineno.274, line.273, cptr.268);
  <D.5677>:
  <D.5672>:
  c = nextc ();
  D.5695 = __ctype_b_loc ();
  D.5696 = *D.5695;
  c.271 = (unsigned int) c;
  D.5698 = c.271 * 2;
  D.5699 = D.5696 + D.5698;
  D.5700 = *D.5699;
  D.5701 = (int) D.5700;
  D.5715 = D.5701 & 1024;
  if (D.5715 != 0) goto <D.5712>; else goto <D.5716>;
  <D.5716>:
  D.5717 = c == 95;
  D.5718 = c == 46;
  D.5719 = D.5717 | D.5718;
  if (D.5719 != 0) goto <D.5712>; else goto <D.5720>;
  <D.5720>:
  if (c == 36) goto <D.5712>; else goto <D.5713>;
  <D.5712>:
  bp = get_name ();
  goto <D.5714>;
  <D.5713>:
  D.5721 = c == 39;
  D.5722 = c == 34;
  D.5723 = D.5721 | D.5722;
  if (D.5723 != 0) goto <D.5724>; else goto <D.5725>;
  <D.5724>:
  bp = get_literal ();
  goto <D.5726>;
  <D.5725>:
  cptr.268 = cptr;
  line.273 = line;
  lineno.274 = lineno;
  syntax_error (lineno.274, line.273, cptr.268);
  <D.5726>:
  <D.5714>:
  rprec.275 = rprec;
  nrules.276 = nrules;
  nrules.277 = (unsigned int) nrules.276;
  D.5730 = nrules.277 * 2;
  D.5731 = rprec.275 + D.5730;
  D.5732 = *D.5731;
  if (D.5732 != -1) goto <D.5733>; else goto <D.5734>;
  <D.5733>:
  D.5735 = bp->prec;
  rprec.275 = rprec;
  nrules.276 = nrules;
  nrules.277 = (unsigned int) nrules.276;
  D.5730 = nrules.277 * 2;
  D.5731 = rprec.275 + D.5730;
  D.5732 = *D.5731;
  if (D.5735 != D.5732) goto <D.5736>; else goto <D.5737>;
  <D.5736>:
  prec_redeclared ();
  <D.5737>:
  <D.5734>:
  rprec.275 = rprec;
  nrules.276 = nrules;
  nrules.277 = (unsigned int) nrules.276;
  D.5730 = nrules.277 * 2;
  D.5731 = rprec.275 + D.5730;
  D.5735 = bp->prec;
  *D.5731 = D.5735;
  rassoc.278 = rassoc;
  nrules.276 = nrules;
  nrules.279 = (sizetype) nrules.276;
  D.5740 = rassoc.278 + nrules.279;
  D.5741 = bp->assoc;
  *D.5740 = D.5741;
  D.5669 = 0;
  return D.5669;
}


read_grammar ()
{
  const short unsigned int * * D.5747;
  const short unsigned int * D.5748;
  unsigned int c.280;
  unsigned int D.5750;
  const short unsigned int * D.5751;
  short unsigned int D.5752;
  int D.5753;
  int D.5754;
  _Bool D.5756;
  _Bool D.5757;
  _Bool D.5758;
  _Bool D.5760;
  _Bool D.5761;
  _Bool D.5762;
  _Bool D.5764;
  _Bool D.5765;
  _Bool D.5766;
  struct bucket * * plhs.281;
  int nrules.282;
  sizetype nrules.283;
  sizetype D.5775;
  sizetype D.5776;
  struct bucket * * D.5777;
  struct bucket * D.5778;
  char * cptr.284;
  char * cptr.285;
  int D.5784;
  char * line.286;
  int lineno.287;
  register int c;

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

    c = nextc ();
    if (c == -1) goto <D.3858>; else goto <D.5743>;
    <D.5743>:
    D.5747 = __ctype_b_loc ();
    D.5748 = *D.5747;
    c.280 = (unsigned int) c;
    D.5750 = c.280 * 2;
    D.5751 = D.5748 + D.5750;
    D.5752 = *D.5751;
    D.5753 = (int) D.5752;
    D.5754 = D.5753 & 1024;
    if (D.5754 != 0) goto <D.5744>; else goto <D.5755>;
    <D.5755>:
    D.5756 = c == 95;
    D.5757 = c == 46;
    D.5758 = D.5756 | D.5757;
    if (D.5758 != 0) goto <D.5744>; else goto <D.5759>;
    <D.5759>:
    D.5760 = c == 36;
    D.5761 = c == 39;
    D.5762 = D.5760 | D.5761;
    if (D.5762 != 0) goto <D.5744>; else goto <D.5763>;
    <D.5763>:
    if (c == 34) goto <D.5744>; else goto <D.5745>;
    <D.5744>:
    add_symbol ();
    goto <D.5746>;
    <D.5745>:
    D.5764 = c == 123;
    D.5765 = c == 61;
    D.5766 = D.5764 | D.5765;
    if (D.5766 != 0) goto <D.5767>; else goto <D.5768>;
    <D.5767>:
    copy_action ();
    goto <D.5769>;
    <D.5768>:
    if (c == 124) goto <D.5770>; else goto <D.5771>;
    <D.5770>:
    end_rule ();
    plhs.281 = plhs;
    nrules.282 = nrules;
    nrules.283 = (sizetype) nrules.282;
    D.5775 = nrules.283 + 1073741823;
    D.5776 = D.5775 * 4;
    D.5777 = plhs.281 + D.5776;
    D.5778 = *D.5777;
    start_rule (D.5778, 0);
    cptr.284 = cptr;
    cptr.285 = cptr.284 + 1;
    cptr = cptr.285;
    goto <D.5781>;
    <D.5771>:
    if (c == 37) goto <D.5782>; else goto <D.5783>;
    <D.5782>:
    D.5784 = mark_symbol ();
    if (D.5784 != 0) goto <D.3858>; else goto <D.5785>;
    <D.5785>:
    goto <D.5786>;
    <D.5783>:
    cptr.284 = cptr;
    line.286 = line;
    lineno.287 = lineno;
    syntax_error (lineno.287, line.286, cptr.284);
    <D.5786>:
    <D.5781>:
    <D.5769>:
    <D.5746>:
  }
  goto <D.3860>;
  <D.3858>:
  end_rule ();
}


free_tags ()
{
  char * * tag_table.288;
  unsigned int i.289;
  unsigned int D.5793;
  char * * D.5794;
  char * D.5795;
  int ntags.290;
  register int i;
  static const char __PRETTY_FUNCTION__[10] = "free_tags";

  tag_table.288 = tag_table;
  if (tag_table.288 == 0B) goto <D.5790>; else goto <D.5791>;
  <D.5790>:
  return;
  <D.5791>:
  i = 0;
  goto <D.3866>;
  <D.3865>:
  tag_table.288 = tag_table;
  i.289 = (unsigned int) i;
  D.5793 = i.289 * 4;
  D.5794 = tag_table.288 + D.5793;
  D.5795 = *D.5794;
  if (D.5795 == 0B) goto <D.5796>; else goto <D.5797>;
  <D.5796>:
  __assert_fail ("tag_table[i]", "reader.c", 1407, &__PRETTY_FUNCTION__);
  <D.5797>:
  tag_table.288 = tag_table;
  i.289 = (unsigned int) i;
  D.5793 = i.289 * 4;
  D.5794 = tag_table.288 + D.5793;
  D.5795 = *D.5794;
  free (D.5795);
  i = i + 1;
  <D.3866>:
  ntags.290 = ntags;
  if (i < ntags.290) goto <D.3865>; else goto <D.3867>;
  <D.3867>:
  tag_table.288 = tag_table;
  free (tag_table.288);
}


pack_names ()
{
  char * D.5800;
  unsigned int D.5801;
  int name_pool_size.291;
  unsigned int name_pool_size.292;
  unsigned int D.5804;
  unsigned int D.5805;
  int name_pool_size.293;
  unsigned int name_pool_size.294;
  void * name_pool.295;
  char * name_pool.296;
  char * D.5812;
  char * t.297;
  char * s.298;
  char D.5815;
  char D.5816;
  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.3875>;
  <D.3874>:
  D.5800 = bp->name;
  D.5801 = strlen (D.5800);
  name_pool_size.291 = name_pool_size;
  name_pool_size.292 = (unsigned int) name_pool_size.291;
  D.5804 = D.5801 + name_pool_size.292;
  D.5805 = D.5804 + 1;
  name_pool_size.293 = (int) D.5805;
  name_pool_size = name_pool_size.293;
  bp = bp->next;
  <D.3875>:
  if (bp != 0B) goto <D.3874>; else goto <D.3876>;
  <D.3876>:
  name_pool_size.291 = name_pool_size;
  name_pool_size.294 = (unsigned int) name_pool_size.291;
  name_pool.295 = malloc (name_pool_size.294);
  name_pool = name_pool.295;
  name_pool.296 = name_pool;
  if (name_pool.296 == 0B) goto <D.5810>; else goto <D.5811>;
  <D.5810>:
  no_space ();
  <D.5811>:
  name_pool.296 = name_pool;
  strcpy (name_pool.296, "$accept");
  name_pool.296 = name_pool;
  D.5812 = name_pool.296 + 8;
  strcpy (D.5812, "$end");
  name_pool.296 = name_pool;
  t = name_pool.296 + 13;
  bp = first_symbol;
  goto <D.3881>;
  <D.3880>:
  p = t;
  s = bp->name;
  goto <D.3877>;
  <D.3878>:
  // predicted unlikely by continue predictor.
  goto <D.3877>;
  <D.3877>:
  t.297 = t;
  t = t.297 + 1;
  s.298 = s;
  s = s.298 + 1;
  D.5815 = *s.298;
  *t.297 = D.5815;
  D.5816 = *t.297;
  if (D.5816 != 0) goto <D.3878>; else goto <D.3879>;
  <D.3879>:
  D.5800 = bp->name;
  free (D.5800);
  bp->name = p;
  bp = bp->next;
  <D.3881>:
  if (bp != 0B) goto <D.3880>; else goto <D.3882>;
  <D.3882>:
}


check_symbols ()
{
  struct bucket * goal.299;
  char D.5818;
  char * D.5821;
  char D.5822;
  char * D.5825;
  register struct bucket * bp;
  extern int undefined_goal ();

  goal.299 = goal;
  D.5818 = goal.299->class;
  if (D.5818 == 0) goto <D.5819>; else goto <D.5820>;
  <D.5819>:
  goal.299 = goal;
  D.5821 = goal.299->name;
  undefined_goal (D.5821);
  <D.5820>:
  bp = first_symbol;
  goto <D.3891>;
  <D.3890>:
  D.5822 = bp->class;
  if (D.5822 == 0) goto <D.5823>; else goto <D.5824>;
  <D.5823>:
  {
    extern int undefined_symbol_warning ();

    D.5825 = bp->name;
    undefined_symbol_warning (D.5825);
    bp->class = 1;
  }
  <D.5824>:
  bp = bp->next;
  <D.3891>:
  if (bp != 0B) goto <D.3890>; else goto <D.3892>;
  <D.3892>:
}


pack_symbols ()
{
  int nsyms.300;
  int nsyms.301;
  char D.5828;
  int ntokens.302;
  int ntokens.303;
  int nvars.304;
  unsigned int nsyms.305;
  unsigned int D.5835;
  void * symbol_name.306;
  char * * symbol_name.307;
  unsigned int D.5840;
  void * symbol_value.308;
  short int * symbol_value.309;
  void * symbol_prec.310;
  short int * symbol_prec.311;
  void * symbol_assoc.312;
  char * symbol_assoc.313;
  int start_symbol.314;
  unsigned int start_symbol.315;
  unsigned int D.5857;
  struct bucket * * D.5858;
  int i.316;
  unsigned int i.317;
  unsigned int D.5863;
  struct bucket * * D.5864;
  int j.318;
  unsigned int j.319;
  unsigned int D.5868;
  struct bucket * * D.5869;
  unsigned int i.320;
  unsigned int D.5874;
  struct bucket * * D.5875;
  struct bucket * D.5876;
  short int D.5877;
  struct bucket * goal.321;
  unsigned short D.5879;
  unsigned short D.5880;
  short int D.5881;
  short int D.5884;
  short int D.5887;
  int k.322;
  unsigned int j.323;
  unsigned int D.5892;
  short int * D.5893;
  sizetype j.324;
  sizetype D.5895;
  sizetype D.5896;
  short int * D.5897;
  short int D.5898;
  int D.5900;
  short int D.5901;
  struct bucket * * D.5902;
  struct bucket * D.5903;
  short int D.5904;
  short int D.5910;
  int D.5911;
  char * name_pool.325;
  char * D.5914;
  char * * D.5915;
  char * D.5916;
  unsigned int D.5917;
  short int * D.5918;
  short int * D.5919;
  short int D.5920;
  sizetype i.326;
  char * D.5922;
  char D.5923;
  char * * D.5924;
  unsigned int D.5925;
  short int * D.5926;
  short int * D.5927;
  sizetype start_symbol.327;
  char * D.5929;
  short int D.5930;
  unsigned int k.328;
  unsigned int D.5932;
  char * * D.5933;
  unsigned int D.5934;
  short int * D.5935;
  short int * D.5936;
  sizetype k.329;
  char * D.5938;
  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.3903>;
  <D.3902>:
  nsyms.300 = nsyms;
  nsyms.301 = nsyms.300 + 1;
  nsyms = nsyms.301;
  D.5828 = bp->class;
  if (D.5828 == 1) goto <D.5829>; else goto <D.5830>;
  <D.5829>:
  ntokens.302 = ntokens;
  ntokens.303 = ntokens.302 + 1;
  ntokens = ntokens.303;
  <D.5830>:
  bp = bp->next;
  <D.3903>:
  if (bp != 0B) goto <D.3902>; else goto <D.3904>;
  <D.3904>:
  ntokens.302 = ntokens;
  start_symbol = ntokens.302;
  nsyms.300 = nsyms;
  ntokens.302 = ntokens;
  nvars.304 = nsyms.300 - ntokens.302;
  nvars = nvars.304;
  nsyms.300 = nsyms;
  nsyms.305 = (unsigned int) nsyms.300;
  D.5835 = nsyms.305 * 4;
  symbol_name.306 = malloc (D.5835);
  symbol_name = symbol_name.306;
  symbol_name.307 = symbol_name;
  if (symbol_name.307 == 0B) goto <D.5838>; else goto <D.5839>;
  <D.5838>:
  no_space ();
  <D.5839>:
  nsyms.300 = nsyms;
  nsyms.305 = (unsigned int) nsyms.300;
  D.5840 = nsyms.305 * 2;
  symbol_value.308 = malloc (D.5840);
  symbol_value = symbol_value.308;
  symbol_value.309 = symbol_value;
  if (symbol_value.309 == 0B) goto <D.5843>; else goto <D.5844>;
  <D.5843>:
  no_space ();
  <D.5844>:
  nsyms.300 = nsyms;
  nsyms.305 = (unsigned int) nsyms.300;
  D.5840 = nsyms.305 * 2;
  symbol_prec.310 = malloc (D.5840);
  symbol_prec = symbol_prec.310;
  symbol_prec.311 = symbol_prec;
  if (symbol_prec.311 == 0B) goto <D.5847>; else goto <D.5848>;
  <D.5847>:
  no_space ();
  <D.5848>:
  nsyms.300 = nsyms;
  nsyms.305 = (unsigned int) nsyms.300;
  symbol_assoc.312 = malloc (nsyms.305);
  symbol_assoc = symbol_assoc.312;
  symbol_assoc.313 = symbol_assoc;
  if (symbol_assoc.313 == 0B) goto <D.5851>; else goto <D.5852>;
  <D.5851>:
  no_space ();
  <D.5852>:
  nsyms.300 = nsyms;
  nsyms.305 = (unsigned int) nsyms.300;
  D.5835 = nsyms.305 * 4;
  v = malloc (D.5835);
  if (v == 0B) goto <D.5853>; else goto <D.5854>;
  <D.5853>:
  no_space ();
  <D.5854>:
  *v = 0B;
  start_symbol.314 = start_symbol;
  start_symbol.315 = (unsigned int) start_symbol.314;
  D.5857 = start_symbol.315 * 4;
  D.5858 = v + D.5857;
  *D.5858 = 0B;
  i = 1;
  start_symbol.314 = start_symbol;
  j = start_symbol.314 + 1;
  bp = first_symbol;
  goto <D.3906>;
  <D.3905>:
  D.5828 = bp->class;
  if (D.5828 == 1) goto <D.5859>; else goto <D.5860>;
  <D.5859>:
  i.316 = i;
  i = i.316 + 1;
  i.317 = (unsigned int) i.316;
  D.5863 = i.317 * 4;
  D.5864 = v + D.5863;
  *D.5864 = bp;
  goto <D.5865>;
  <D.5860>:
  j.318 = j;
  j = j.318 + 1;
  j.319 = (unsigned int) j.318;
  D.5868 = j.319 * 4;
  D.5869 = v + D.5868;
  *D.5869 = bp;
  <D.5865>:
  bp = bp->next;
  <D.3906>:
  if (bp != 0B) goto <D.3905>; else goto <D.3907>;
  <D.3907>:
  ntokens.302 = ntokens;
  if (i != ntokens.302) goto <D.5870>; else goto <D.5872>;
  <D.5872>:
  nsyms.300 = nsyms;
  if (j != nsyms.300) goto <D.5870>; else goto <D.5871>;
  <D.5870>:
  __assert_fail ("i == ntokens && j == nsyms", "reader.c", 1497, &__PRETTY_FUNCTION__);
  <D.5871>:
  i = 1;
  goto <D.3910>;
  <D.3909>:
  i.320 = (unsigned int) i;
  D.5874 = i.320 * 4;
  D.5875 = v + D.5874;
  D.5876 = *D.5875;
  D.5877 = (short int) i;
  D.5876->index = D.5877;
  i = i + 1;
  <D.3910>:
  ntokens.302 = ntokens;
  if (i < ntokens.302) goto <D.3909>; else goto <D.3911>;
  <D.3911>:
  goal.321 = goal;
  start_symbol.314 = start_symbol;
  D.5879 = (unsigned short) start_symbol.314;
  D.5880 = D.5879 + 1;
  D.5881 = (short int) D.5880;
  goal.321->index = D.5881;
  start_symbol.314 = start_symbol;
  k = start_symbol.314 + 2;
  goto <D.3913>;
  <D.3912>:
  i.320 = (unsigned int) i;
  D.5874 = i.320 * 4;
  D.5875 = v + D.5874;
  D.5876 = *D.5875;
  goal.321 = goal;
  if (D.5876 != goal.321) goto <D.5882>; else goto <D.5883>;
  <D.5882>:
  i.320 = (unsigned int) i;
  D.5874 = i.320 * 4;
  D.5875 = v + D.5874;
  D.5876 = *D.5875;
  D.5884 = (short int) k;
  D.5876->index = D.5884;
  k = k + 1;
  <D.5883>:
  <D.3913>:
  i = i + 1;
  nsyms.300 = nsyms;
  if (i < nsyms.300) goto <D.3912>; else goto <D.3914>;
  <D.3914>:
  goal.321 = goal;
  goal.321->value = 0;
  k = 1;
  start_symbol.314 = start_symbol;
  i = start_symbol.314 + 1;
  goto <D.3916>;
  <D.3915>:
  i.320 = (unsigned int) i;
  D.5874 = i.320 * 4;
  D.5875 = v + D.5874;
  D.5876 = *D.5875;
  goal.321 = goal;
  if (D.5876 != goal.321) goto <D.5885>; else goto <D.5886>;
  <D.5885>:
  i.320 = (unsigned int) i;
  D.5874 = i.320 * 4;
  D.5875 = v + D.5874;
  D.5876 = *D.5875;
  D.5884 = (short int) k;
  D.5876->value = D.5884;
  k = k + 1;
  <D.5886>:
  i = i + 1;
  <D.3916>:
  nsyms.300 = nsyms;
  if (i < nsyms.300) goto <D.3915>; else goto <D.3917>;
  <D.3917>:
  k = 0;
  i = 1;
  goto <D.3922>;
  <D.3921>:
  i.320 = (unsigned int) i;
  D.5874 = i.320 * 4;
  D.5875 = v + D.5874;
  D.5876 = *D.5875;
  D.5887 = D.5876->value;
  n = (int) D.5887;
  if (n > 256) goto <D.5888>; else goto <D.5889>;
  <D.5888>:
  k.322 = k;
  k = k.322 + 1;
  j = k.322;
  goto <D.3919>;
  <D.3918>:
  symbol_value.309 = symbol_value;
  j.323 = (unsigned int) j;
  D.5892 = j.323 * 2;
  D.5893 = symbol_value.309 + D.5892;
  symbol_value.309 = symbol_value;
  j.324 = (sizetype) j;
  D.5895 = j.324 + 2147483647;
  D.5896 = D.5895 * 2;
  D.5897 = symbol_value.309 + D.5896;
  D.5898 = *D.5897;
  *D.5893 = D.5898;
  j = j + -1;
  <D.3919>:
  if (j > 0) goto <D.5899>; else goto <D.3920>;
  <D.5899>:
  symbol_value.309 = symbol_value;
  j.324 = (sizetype) j;
  D.5895 = j.324 + 2147483647;
  D.5896 = D.5895 * 2;
  D.5897 = symbol_value.309 + D.5896;
  D.5898 = *D.5897;
  D.5900 = (int) D.5898;
  if (D.5900 > n) goto <D.3918>; else goto <D.3920>;
  <D.3920>:
  symbol_value.309 = symbol_value;
  j.323 = (unsigned int) j;
  D.5892 = j.323 * 2;
  D.5893 = symbol_value.309 + D.5892;
  D.5901 = (short int) n;
  *D.5893 = D.5901;
  <D.5889>:
  i = i + 1;
  <D.3922>:
  ntokens.302 = ntokens;
  if (i < ntokens.302) goto <D.3921>; else goto <D.3923>;
  <D.3923>:
  D.5902 = v + 4;
  D.5903 = *D.5902;
  D.5904 = D.5903->value;
  if (D.5904 == -1) goto <D.5905>; else goto <D.5906>;
  <D.5905>:
  D.5902 = v + 4;
  D.5903 = *D.5902;
  D.5903->value = 256;
  <D.5906>:
  j = 0;
  n = 257;
  i = 2;
  goto <D.3931>;
  <D.3930>:
  i.320 = (unsigned int) i;
  D.5874 = i.320 * 4;
  D.5875 = v + D.5874;
  D.5876 = *D.5875;
  D.5887 = D.5876->value;
  if (D.5887 == -1) goto <D.5907>; else goto <D.5908>;
  <D.5907>:
  goto <D.3928>;
  <D.3927>:
  goto <D.3924>;
  <D.3925>:
  // predicted unlikely by continue predictor.
  goto <D.3924>;
  <D.3924>:
  j = j + 1;
  if (j < k) goto <D.5909>; else goto <D.3926>;
  <D.5909>:
  symbol_value.309 = symbol_value;
  j.323 = (unsigned int) j;
  D.5892 = j.323 * 2;
  D.5893 = symbol_value.309 + D.5892;
  D.5910 = *D.5893;
  D.5911 = (int) D.5910;
  if (D.5911 == n) goto <D.3925>; else goto <D.3926>;
  <D.3926>:
  n = n + 1;
  <D.3928>:
  if (j < k) goto <D.5912>; else goto <D.3929>;
  <D.5912>:
  symbol_value.309 = symbol_value;
  j.323 = (unsigned int) j;
  D.5892 = j.323 * 2;
  D.5893 = symbol_value.309 + D.5892;
  D.5910 = *D.5893;
  D.5911 = (int) D.5910;
  if (D.5911 == n) goto <D.3927>; else goto <D.3929>;
  <D.3929>:
  i.320 = (unsigned int) i;
  D.5874 = i.320 * 4;
  D.5875 = v + D.5874;
  D.5876 = *D.5875;
  D.5901 = (short int) n;
  D.5876->value = D.5901;
  n = n + 1;
  <D.5908>:
  i = i + 1;
  <D.3931>:
  ntokens.302 = ntokens;
  if (i < ntokens.302) goto <D.3930>; else goto <D.3932>;
  <D.3932>:
  symbol_name.307 = symbol_name;
  name_pool.325 = name_pool;
  D.5914 = name_pool.325 + 8;
  *symbol_name.307 = D.5914;
  symbol_value.309 = symbol_value;
  *symbol_value.309 = 0;
  symbol_prec.311 = symbol_prec;
  *symbol_prec.311 = 0;
  symbol_assoc.313 = symbol_assoc;
  *symbol_assoc.313 = 0;
  i = 1;
  goto <D.3934>;
  <D.3933>:
  symbol_name.307 = symbol_name;
  i.320 = (unsigned int) i;
  D.5874 = i.320 * 4;
  D.5915 = symbol_name.307 + D.5874;
  i.320 = (unsigned int) i;
  D.5874 = i.320 * 4;
  D.5875 = v + D.5874;
  D.5876 = *D.5875;
  D.5916 = D.5876->name;
  *D.5915 = D.5916;
  symbol_value.309 = symbol_value;
  i.320 = (unsigned int) i;
  D.5917 = i.320 * 2;
  D.5918 = symbol_value.309 + D.5917;
  i.320 = (unsigned int) i;
  D.5874 = i.320 * 4;
  D.5875 = v + D.5874;
  D.5876 = *D.5875;
  D.5887 = D.5876->value;
  *D.5918 = D.5887;
  symbol_prec.311 = symbol_prec;
  i.320 = (unsigned int) i;
  D.5917 = i.320 * 2;
  D.5919 = symbol_prec.311 + D.5917;
  i.320 = (unsigned int) i;
  D.5874 = i.320 * 4;
  D.5875 = v + D.5874;
  D.5876 = *D.5875;
  D.5920 = D.5876->prec;
  *D.5919 = D.5920;
  symbol_assoc.313 = symbol_assoc;
  i.326 = (sizetype) i;
  D.5922 = symbol_assoc.313 + i.326;
  i.320 = (unsigned int) i;
  D.5874 = i.320 * 4;
  D.5875 = v + D.5874;
  D.5876 = *D.5875;
  D.5923 = D.5876->assoc;
  *D.5922 = D.5923;
  i = i + 1;
  <D.3934>:
  ntokens.302 = ntokens;
  if (i < ntokens.302) goto <D.3933>; else goto <D.3935>;
  <D.3935>:
  symbol_name.307 = symbol_name;
  start_symbol.314 = start_symbol;
  start_symbol.315 = (unsigned int) start_symbol.314;
  D.5857 = start_symbol.315 * 4;
  D.5924 = symbol_name.307 + D.5857;
  name_pool.325 = name_pool;
  *D.5924 = name_pool.325;
  symbol_value.309 = symbol_value;
  start_symbol.314 = start_symbol;
  start_symbol.315 = (unsigned int) start_symbol.314;
  D.5925 = start_symbol.315 * 2;
  D.5926 = symbol_value.309 + D.5925;
  *D.5926 = -1;
  symbol_prec.311 = symbol_prec;
  start_symbol.314 = start_symbol;
  start_symbol.315 = (unsigned int) start_symbol.314;
  D.5925 = start_symbol.315 * 2;
  D.5927 = symbol_prec.311 + D.5925;
  *D.5927 = 0;
  symbol_assoc.313 = symbol_assoc;
  start_symbol.314 = start_symbol;
  start_symbol.327 = (sizetype) start_symbol.314;
  D.5929 = symbol_assoc.313 + start_symbol.327;
  *D.5929 = 0;
  i = i + 1;
  goto <D.3937>;
  <D.3936>:
  i.320 = (unsigned int) i;
  D.5874 = i.320 * 4;
  D.5875 = v + D.5874;
  D.5876 = *D.5875;
  D.5930 = D.5876->index;
  k = (int) D.5930;
  symbol_name.307 = symbol_name;
  k.328 = (unsigned int) k;
  D.5932 = k.328 * 4;
  D.5933 = symbol_name.307 + D.5932;
  i.320 = (unsigned int) i;
  D.5874 = i.320 * 4;
  D.5875 = v + D.5874;
  D.5876 = *D.5875;
  D.5916 = D.5876->name;
  *D.5933 = D.5916;
  symbol_value.309 = symbol_value;
  k.328 = (unsigned int) k;
  D.5934 = k.328 * 2;
  D.5935 = symbol_value.309 + D.5934;
  i.320 = (unsigned int) i;
  D.5874 = i.320 * 4;
  D.5875 = v + D.5874;
  D.5876 = *D.5875;
  D.5887 = D.5876->value;
  *D.5935 = D.5887;
  symbol_prec.311 = symbol_prec;
  k.328 = (unsigned int) k;
  D.5934 = k.328 * 2;
  D.5936 = symbol_prec.311 + D.5934;
  i.320 = (unsigned int) i;
  D.5874 = i.320 * 4;
  D.5875 = v + D.5874;
  D.5876 = *D.5875;
  D.5920 = D.5876->prec;
  *D.5936 = D.5920;
  symbol_assoc.313 = symbol_assoc;
  k.329 = (sizetype) k;
  D.5938 = symbol_assoc.313 + k.329;
  i.320 = (unsigned int) i;
  D.5874 = i.320 * 4;
  D.5875 = v + D.5874;
  D.5876 = *D.5875;
  D.5923 = D.5876->assoc;
  *D.5938 = D.5923;
  i = i + 1;
  <D.3937>:
  nsyms.300 = nsyms;
  if (i < nsyms.300) goto <D.3936>; else goto <D.3938>;
  <D.3938>:
  free (v);
}


pack_grammar ()
{
  int nitems.330;
  unsigned int nitems.331;
  unsigned int D.5941;
  void * ritem.332;
  short int * ritem.333;
  int nrules.334;
  unsigned int nrules.335;
  unsigned int D.5948;
  void * rlhs.336;
  short int * rlhs.337;
  int D.5953;
  unsigned int D.5954;
  unsigned int D.5955;
  void * rrhs.338;
  short int * rrhs.339;
  short int * rprec.340;
  void * rprec.341;
  char * rassoc.342;
  void * rassoc.343;
  short int * D.5968;
  struct bucket * goal.344;
  short int D.5970;
  short int * D.5971;
  short int * D.5972;
  short int * D.5973;
  short int * D.5974;
  int start_symbol.345;
  short int D.5976;
  short int * D.5977;
  short int * D.5978;
  unsigned int i.346;
  unsigned int D.5980;
  short int * D.5981;
  struct bucket * * plhs.347;
  unsigned int D.5983;
  struct bucket * * D.5984;
  struct bucket * D.5985;
  short int D.5986;
  short int * D.5987;
  short int D.5988;
  unsigned int j.348;
  unsigned int D.5990;
  short int * D.5991;
  struct bucket * * pitem.349;
  unsigned int D.5993;
  struct bucket * * D.5994;
  struct bucket * D.5995;
  short int D.5996;
  char D.5997;
  short int D.6000;
  char D.6001;
  unsigned short D.6002;
  unsigned short D.6003;
  short int D.6004;
  short int * D.6005;
  short int D.6006;
  short int D.6009;
  sizetype i.350;
  char * D.6011;
  char D.6012;
  register int i;
  register int j;
  int assoc;
  int prec;
  extern int no_space ();

  nitems.330 = nitems;
  nitems.331 = (unsigned int) nitems.330;
  D.5941 = nitems.331 * 2;
  ritem.332 = malloc (D.5941);
  ritem = ritem.332;
  ritem.333 = ritem;
  if (ritem.333 == 0B) goto <D.5944>; else goto <D.5945>;
  <D.5944>:
  no_space ();
  <D.5945>:
  nrules.334 = nrules;
  nrules.335 = (unsigned int) nrules.334;
  D.5948 = nrules.335 * 2;
  rlhs.336 = malloc (D.5948);
  rlhs = rlhs.336;
  rlhs.337 = rlhs;
  if (rlhs.337 == 0B) goto <D.5951>; else goto <D.5952>;
  <D.5951>:
  no_space ();
  <D.5952>:
  nrules.334 = nrules;
  D.5953 = nrules.334 + 1;
  D.5954 = (unsigned int) D.5953;
  D.5955 = D.5954 * 2;
  rrhs.338 = malloc (D.5955);
  rrhs = rrhs.338;
  rrhs.339 = rrhs;
  if (rrhs.339 == 0B) goto <D.5958>; else goto <D.5959>;
  <D.5958>:
  no_space ();
  <D.5959>:
  nrules.334 = nrules;
  nrules.335 = (unsigned int) nrules.334;
  D.5948 = nrules.335 * 2;
  rprec.340 = rprec;
  rprec.341 = realloc (rprec.340, D.5948);
  rprec = rprec.341;
  rprec.340 = rprec;
  if (rprec.340 == 0B) goto <D.5962>; else goto <D.5963>;
  <D.5962>:
  no_space ();
  <D.5963>:
  nrules.334 = nrules;
  nrules.335 = (unsigned int) nrules.334;
  rassoc.342 = rassoc;
  rassoc.343 = realloc (rassoc.342, nrules.335);
  rassoc = rassoc.343;
  rassoc.342 = rassoc;
  if (rassoc.342 == 0B) goto <D.5966>; else goto <D.5967>;
  <D.5966>:
  no_space ();
  <D.5967>:
  ritem.333 = ritem;
  *ritem.333 = -1;
  ritem.333 = ritem;
  D.5968 = ritem.333 + 2;
  goal.344 = goal;
  D.5970 = goal.344->index;
  *D.5968 = D.5970;
  ritem.333 = ritem;
  D.5971 = ritem.333 + 4;
  *D.5971 = 0;
  ritem.333 = ritem;
  D.5972 = ritem.333 + 6;
  *D.5972 = -2;
  rlhs.337 = rlhs;
  *rlhs.337 = 0;
  rlhs.337 = rlhs;
  D.5973 = rlhs.337 + 2;
  *D.5973 = 0;
  rlhs.337 = rlhs;
  D.5974 = rlhs.337 + 4;
  start_symbol.345 = start_symbol;
  D.5976 = (short int) start_symbol.345;
  *D.5974 = D.5976;
  rrhs.339 = rrhs;
  *rrhs.339 = 0;
  rrhs.339 = rrhs;
  D.5977 = rrhs.339 + 2;
  *D.5977 = 0;
  rrhs.339 = rrhs;
  D.5978 = rrhs.339 + 4;
  *D.5978 = 1;
  j = 4;
  i = 3;
  goto <D.3950>;
  <D.3949>:
  rlhs.337 = rlhs;
  i.346 = (unsigned int) i;
  D.5980 = i.346 * 2;
  D.5981 = rlhs.337 + D.5980;
  plhs.347 = plhs;
  i.346 = (unsigned int) i;
  D.5983 = i.346 * 4;
  D.5984 = plhs.347 + D.5983;
  D.5985 = *D.5984;
  D.5986 = D.5985->index;
  *D.5981 = D.5986;
  rrhs.339 = rrhs;
  i.346 = (unsigned int) i;
  D.5980 = i.346 * 2;
  D.5987 = rrhs.339 + D.5980;
  D.5988 = (short int) j;
  *D.5987 = D.5988;
  assoc = 0;
  prec = 0;
  goto <D.3947>;
  <D.3946>:
  ritem.333 = ritem;
  j.348 = (unsigned int) j;
  D.5990 = j.348 * 2;
  D.5991 = ritem.333 + D.5990;
  pitem.349 = pitem;
  j.348 = (unsigned int) j;
  D.5993 = j.348 * 4;
  D.5994 = pitem.349 + D.5993;
  D.5995 = *D.5994;
  D.5996 = D.5995->index;
  *D.5991 = D.5996;
  pitem.349 = pitem;
  j.348 = (unsigned int) j;
  D.5993 = j.348 * 4;
  D.5994 = pitem.349 + D.5993;
  D.5995 = *D.5994;
  D.5997 = D.5995->class;
  if (D.5997 == 1) goto <D.5998>; else goto <D.5999>;
  <D.5998>:
  pitem.349 = pitem;
  j.348 = (unsigned int) j;
  D.5993 = j.348 * 4;
  D.5994 = pitem.349 + D.5993;
  D.5995 = *D.5994;
  D.6000 = D.5995->prec;
  prec = (int) D.6000;
  pitem.349 = pitem;
  j.348 = (unsigned int) j;
  D.5993 = j.348 * 4;
  D.5994 = pitem.349 + D.5993;
  D.5995 = *D.5994;
  D.6001 = D.5995->assoc;
  assoc = (int) D.6001;
  <D.5999>:
  j = j + 1;
  <D.3947>:
  pitem.349 = pitem;
  j.348 = (unsigned int) j;
  D.5993 = j.348 * 4;
  D.5994 = pitem.349 + D.5993;
  D.5995 = *D.5994;
  if (D.5995 != 0B) goto <D.3946>; else goto <D.3948>;
  <D.3948>:
  ritem.333 = ritem;
  j.348 = (unsigned int) j;
  D.5990 = j.348 * 2;
  D.5991 = ritem.333 + D.5990;
  D.6002 = (unsigned short) i;
  D.6003 = -D.6002;
  D.6004 = (short int) D.6003;
  *D.5991 = D.6004;
  j = j + 1;
  rprec.340 = rprec;
  i.346 = (unsigned int) i;
  D.5980 = i.346 * 2;
  D.6005 = rprec.340 + D.5980;
  D.6006 = *D.6005;
  if (D.6006 == -1) goto <D.6007>; else goto <D.6008>;
  <D.6007>:
  rprec.340 = rprec;
  i.346 = (unsigned int) i;
  D.5980 = i.346 * 2;
  D.6005 = rprec.340 + D.5980;
  D.6009 = (short int) prec;
  *D.6005 = D.6009;
  rassoc.342 = rassoc;
  i.350 = (sizetype) i;
  D.6011 = rassoc.342 + i.350;
  D.6012 = (char) assoc;
  *D.6011 = D.6012;
  <D.6008>:
  i = i + 1;
  <D.3950>:
  nrules.334 = nrules;
  if (i < nrules.334) goto <D.3949>; else goto <D.3951>;
  <D.3951>:
  rrhs.339 = rrhs;
  i.346 = (unsigned int) i;
  D.5980 = i.346 * 2;
  D.5987 = rrhs.339 + D.5980;
  D.5988 = (short int) j;
  *D.5987 = D.5988;
  plhs.347 = plhs;
  free (plhs.347);
  pitem.349 = pitem;
  free (pitem.349);
}


print_grammar ()
{
  char vflag.351;
  short int * rlhs.352;
  unsigned int i.353;
  unsigned int D.6018;
  short int * D.6019;
  short int D.6020;
  sizetype i.354;
  sizetype D.6022;
  sizetype D.6023;
  short int * D.6024;
  short int D.6025;
  char * * symbol_name.355;
  unsigned int D.6031;
  unsigned int D.6032;
  char * * D.6033;
  char * D.6034;
  int D.6035;
  unsigned int D.6036;
  unsigned int D.6037;
  short int * ritem.356;
  unsigned int k.357;
  unsigned int D.6041;
  short int * D.6042;
  short int D.6043;
  unsigned int D.6044;
  unsigned int D.6045;
  char * * D.6046;
  char * D.6047;
  int nrules.358;
  register int i;
  register int j;
  register int k;
  int spacing;
  register struct FILE * f;

  f = verbose_file;
  vflag.351 = vflag;
  if (vflag.351 == 0) goto <D.6014>; else goto <D.6015>;
  <D.6014>:
  return;
  <D.6015>:
  k = 1;
  i = 2;
  goto <D.3967>;
  <D.3966>:
  rlhs.352 = rlhs;
  i.353 = (unsigned int) i;
  D.6018 = i.353 * 2;
  D.6019 = rlhs.352 + D.6018;
  D.6020 = *D.6019;
  rlhs.352 = rlhs;
  i.354 = (sizetype) i;
  D.6022 = i.354 + 2147483647;
  D.6023 = D.6022 * 2;
  D.6024 = rlhs.352 + D.6023;
  D.6025 = *D.6024;
  if (D.6020 != D.6025) goto <D.6026>; else goto <D.6027>;
  <D.6026>:
  if (i != 2) goto <D.6028>; else goto <D.6029>;
  <D.6028>:
  fprintf (f, "\n");
  <D.6029>:
  symbol_name.355 = symbol_name;
  rlhs.352 = rlhs;
  i.353 = (unsigned int) i;
  D.6018 = i.353 * 2;
  D.6019 = rlhs.352 + D.6018;
  D.6020 = *D.6019;
  D.6031 = (unsigned int) D.6020;
  D.6032 = D.6031 * 4;
  D.6033 = symbol_name.355 + D.6032;
  D.6034 = *D.6033;
  D.6035 = i + -2;
  fprintf (f, "%4d  %s :", D.6035, D.6034);
  symbol_name.355 = symbol_name;
  rlhs.352 = rlhs;
  i.353 = (unsigned int) i;
  D.6018 = i.353 * 2;
  D.6019 = rlhs.352 + D.6018;
  D.6020 = *D.6019;
  D.6031 = (unsigned int) D.6020;
  D.6032 = D.6031 * 4;
  D.6033 = symbol_name.355 + D.6032;
  D.6034 = *D.6033;
  D.6036 = strlen (D.6034);
  D.6037 = D.6036 + 1;
  spacing = (int) D.6037;
  goto <D.6038>;
  <D.6027>:
  D.6035 = i + -2;
  fprintf (f, "%4d  ", D.6035);
  j = spacing;
  goto <D.3961>;
  <D.3960>:
  _IO_putc (32, f);
  <D.3961>:
  j = j + -1;
  if (j >= 0) goto <D.3960>; else goto <D.3962>;
  <D.3962>:
  _IO_putc (124, f);
  <D.6038>:
  goto <D.3964>;
  <D.3963>:
  symbol_name.355 = symbol_name;
  ritem.356 = ritem;
  k.357 = (unsigned int) k;
  D.6041 = k.357 * 2;
  D.6042 = ritem.356 + D.6041;
  D.6043 = *D.6042;
  D.6044 = (unsigned int) D.6043;
  D.6045 = D.6044 * 4;
  D.6046 = symbol_name.355 + D.6045;
  D.6047 = *D.6046;
  fprintf (f, " %s", D.6047);
  k = k + 1;
  <D.3964>:
  ritem.356 = ritem;
  k.357 = (unsigned int) k;
  D.6041 = k.357 * 2;
  D.6042 = ritem.356 + D.6041;
  D.6043 = *D.6042;
  if (D.6043 >= 0) goto <D.3963>; else goto <D.3965>;
  <D.3965>:
  k = k + 1;
  _IO_putc (10, f);
  i = i + 1;
  <D.3967>:
  nrules.358 = nrules;
  if (i < nrules.358) goto <D.3966>; else goto <D.3968>;
  <D.3968>:
}


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 ();
}