monoeg_g_markup_parse_context_new (const struct GMarkupParser * parser, GMarkupParseFlags flags, void * user_data, void (*GDestroyNotify) (void *) user_data_dnotify)
{
  struct GMarkupParseContext * D.5568;
  struct GMarkupParseContext * context;

  context = monoeg_malloc0 (80);
  context->parser = *parser;
  context->user_data = user_data;
  context->user_data_dnotify = user_data_dnotify;
  D.5568 = context;
  return D.5568;
}


monoeg_g_markup_parse_context_free (struct GMarkupParseContext * context)
{
  void (*<Tbf6>) (void *) D.5572;
  void * D.5575;
  struct GString * D.5576;
  void * D.5579;
  struct GSList * D.5580;
  struct GSList * l;

  if (context == 0B) goto <D.5570>; else goto <D.5571>;
  <D.5570>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gmarkup.c", 90, "context != NULL");
  return;
  <D.5571>:
  D.5572 = context->user_data_dnotify;
  if (D.5572 != 0B) goto <D.5573>; else goto <D.5574>;
  <D.5573>:
  D.5572 = context->user_data_dnotify;
  D.5575 = context->user_data;
  D.5572 (D.5575);
  <D.5574>:
  D.5576 = context->text;
  if (D.5576 != 0B) goto <D.5577>; else goto <D.5578>;
  <D.5577>:
  D.5576 = context->text;
  monoeg_g_string_free (D.5576, 1);
  <D.5578>:
  l = context->level;
  goto <D.5461>;
  <D.5460>:
  D.5579 = l->data;
  monoeg_g_free (D.5579);
  l = l->next;
  <D.5461>:
  if (l != 0B) goto <D.5460>; else goto <D.5462>;
  <D.5462>:
  D.5580 = context->level;
  monoeg_g_slist_free (D.5580);
  monoeg_g_free (context);
}


monoeg_g_markup_parse_context_parse (struct GMarkupParseContext * context, const gchar * text, gssize text_len, struct GError * * error)
{
  gboolean D.5584;
  sizetype text_len.0;
  <unnamed type> D.5590;
  signed char c.1;
  const char * D.5602;
  char D.5604;
  struct GError * D.5608;
  char D.5610;
  int D.5611;
  struct GError * D.5616;
  const char * D.5619;
  char D.5624;
  int D.5627;
  struct GError * D.5632;
  int D.5634;
  struct GError * D.5640;
  int D.5642;
  struct GError * D.5647;
  int D.5648;
  gchar * * names.2;
  gchar * * values.3;
  struct GError * D.5657;
  struct GError * D.5662;
  long int element_end.4;
  long int element_start.5;
  long int D.5665;
  int D.5666;
  long unsigned int D.5667;
  long unsigned int D.5669;
  sizetype D.5670;
  char * D.5671;
  void (*<Te5f>) (struct GMarkupParseContext *, const gchar *, const gchar * *, const gchar * *, void *, struct GError * *) D.5674;
  void * D.5677;
  int full_stop.6;
  void (*<Te63>) (struct GMarkupParseContext *, const gchar *, void *, struct GError * *) D.5687;
  struct GSList * D.5697;
  struct GSList * D.5698;
  void (*<Te67>) (struct GMarkupParseContext *, const gchar *, gsize, void *, struct GError * *) D.5701;
  struct GString * D.5704;
  struct GString * D.5707;
  char * D.5719;
  long unsigned int D.5720;
  struct GError * D.5731;
  struct GSList * D.5739;
  void (*<Te6d>) (struct GMarkupParseContext *, struct GError *, void *) D.5741;
  const char * p;
  const char * end;
  void fail = <<< error >>>;

  if (context == 0B) goto <D.5582>; else goto <D.5583>;
  <D.5582>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gmarkup.c", 268, "context != NULL");
  D.5584 = 0;
  return D.5584;
  <D.5583>:
  if (text == 0B) goto <D.5585>; else goto <D.5586>;
  <D.5585>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gmarkup.c", 269, "text != NULL");
  D.5584 = 0;
  return D.5584;
  <D.5586>:
  if (text_len < 0) goto <D.5587>; else goto <D.5588>;
  <D.5587>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gmarkup.c", 270, "text_len >= 0");
  D.5584 = 0;
  return D.5584;
  <D.5588>:
  text_len.0 = (sizetype) text_len;
  end = text + text_len.0;
  p = text;
  goto <D.5561>;
  <D.5560>:
  {
    char c;

    c = *p;
    D.5590 = context->state;
    switch (D.5590) <default: <D.5740>, case 0: <D.5529>, case 1: <D.5533>, case 2: <D.5551>, case 3: <D.5553>, case 4: <D.5554>, case 5: <D.5552>, case 6: <D.5532>>
    <D.5529>:
    if (c == 32) goto <D.5591>; else goto <D.5593>;
    <D.5593>:
    if (c == 9) goto <D.5591>; else goto <D.5594>;
    <D.5594>:
    if (c == 12) goto <D.5591>; else goto <D.5595>;
    <D.5595>:
    if (c == 10) goto <D.5591>; else goto <D.5596>;
    <D.5596>:
    c.1 = (signed char) c;
    if (c.1 < 0) goto <D.5591>; else goto <D.5592>;
    <D.5591>:
    // predicted unlikely by continue predictor.
    goto <D.5530>;
    <D.5592>:
    if (c == 60) goto <D.5598>; else goto <D.5599>;
    <D.5598>:
    D.5602 = p + 1;
    if (D.5602 < end) goto <D.5603>; else goto <D.5600>;
    <D.5603>:
    D.5602 = p + 1;
    D.5604 = *D.5602;
    if (D.5604 == 63) goto <D.5605>; else goto <D.5600>;
    <D.5605>:
    context->state = 6;
    p = p + 1;
    goto <D.5601>;
    <D.5600>:
    context->state = 1;
    <D.5601>:
    // predicted unlikely by continue predictor.
    goto <D.5530>;
    <D.5599>:
    if (error != 0B) goto <D.5606>; else goto <D.5607>;
    <D.5606>:
    D.5608 = monoeg_g_error_new (1B, 1, "%s", "Expected < to start the document");
    *error = D.5608;
    <D.5607>:
    goto fail;
    <D.5532>:
    <D.5533>:
    {
      const char * element_start;
      const char * element_end;
      char * ename;
      int full_stop;
      int l;
      gchar * * names;
      gchar * * values;

      try
        {
          element_start = p;
          ename = 0B;
          full_stop = 0;
          names = 0B;
          values = 0B;
          goto <D.5542>;
          <D.5541>:
          p = p + 1;
          <D.5542>:
          if (p < end) goto <D.5609>; else goto <D.5543>;
          <D.5609>:
          D.5610 = *p;
          D.5611 = my_isspace (D.5610);
          if (D.5611 != 0) goto <D.5541>; else goto <D.5543>;
          <D.5543>:
          if (p == end) goto <D.5612>; else goto <D.5613>;
          <D.5612>:
          if (error != 0B) goto <D.5614>; else goto <D.5615>;
          <D.5614>:
          D.5616 = monoeg_g_error_new (1B, 1, "%s", "Unfinished element");
          *error = D.5616;
          <D.5615>:
          goto fail;
          <D.5613>:
          D.5610 = *p;
          if (D.5610 == 33) goto <D.5617>; else goto <D.5618>;
          <D.5617>:
          D.5619 = p + 2;
          if (D.5619 < end) goto <D.5620>; else goto <D.5621>;
          <D.5620>:
          D.5602 = p + 1;
          D.5604 = *D.5602;
          if (D.5604 == 45) goto <D.5622>; else goto <D.5623>;
          <D.5622>:
          D.5619 = p + 2;
          D.5624 = *D.5619;
          if (D.5624 == 45) goto <D.5625>; else goto <D.5626>;
          <D.5625>:
          context->state = 5;
          p = p + 2;
          goto <D.5544>;
          <D.5626>:
          <D.5623>:
          <D.5621>:
          <D.5618>:
          D.5610 = *p;
          D.5627 = my_isalpha (D.5610);
          if (D.5627 == 0) goto <D.5628>; else goto <D.5629>;
          <D.5628>:
          if (error != 0B) goto <D.5630>; else goto <D.5631>;
          <D.5630>:
          D.5632 = monoeg_g_error_new (1B, 1, "%s", "Expected an element name");
          *error = D.5632;
          <D.5631>:
          goto fail;
          <D.5629>:
          p = p + 1;
          goto <D.5546>;
          <D.5545>:
          p = p + 1;
          <D.5546>:
          if (p < end) goto <D.5633>; else goto <D.5547>;
          <D.5633>:
          D.5610 = *p;
          D.5634 = my_isalnum (D.5610);
          if (D.5634 != 0) goto <D.5545>; else goto <D.5635>;
          <D.5635>:
          D.5610 = *p;
          if (D.5610 == 46) goto <D.5545>; else goto <D.5547>;
          <D.5547>:
          if (p == end) goto <D.5636>; else goto <D.5637>;
          <D.5636>:
          if (error != 0B) goto <D.5638>; else goto <D.5639>;
          <D.5638>:
          D.5640 = monoeg_g_error_new (1B, 1, "%s", "Expected an element");
          *error = D.5640;
          <D.5639>:
          goto fail;
          <D.5637>:
          element_end = p;
          goto <D.5549>;
          <D.5548>:
          p = p + 1;
          <D.5549>:
          if (p < end) goto <D.5641>; else goto <D.5550>;
          <D.5641>:
          D.5610 = *p;
          D.5642 = my_isspace (D.5610);
          if (D.5642 != 0) goto <D.5548>; else goto <D.5550>;
          <D.5550>:
          if (p == end) goto <D.5643>; else goto <D.5644>;
          <D.5643>:
          if (error != 0B) goto <D.5645>; else goto <D.5646>;
          <D.5645>:
          D.5647 = monoeg_g_error_new (1B, 1, "%s", "Unfinished element");
          *error = D.5647;
          <D.5646>:
          goto fail;
          <D.5644>:
          D.5590 = context->state;
          D.5648 = (int) D.5590;
          p = parse_attributes (p, end, &names, &values, error, &full_stop, D.5648);
          if (p == end) goto <D.5649>; else goto <D.5650>;
          <D.5649>:
          names.2 = names;
          if (names.2 != 0B) goto <D.5652>; else goto <D.5653>;
          <D.5652>:
          names.2 = names;
          monoeg_g_strfreev (names.2);
          values.3 = values;
          monoeg_g_strfreev (values.3);
          <D.5653>:
          if (error != 0B) goto <D.5655>; else goto <D.5656>;
          <D.5655>:
          D.5657 = *error;
          if (D.5657 == 0B) goto <D.5658>; else goto <D.5659>;
          <D.5658>:
          if (error != 0B) goto <D.5660>; else goto <D.5661>;
          <D.5660>:
          D.5662 = monoeg_g_error_new (1B, 1, "%s", "Unfinished sequence");
          *error = D.5662;
          <D.5661>:
          <D.5659>:
          <D.5656>:
          goto fail;
          <D.5650>:
          element_end.4 = (long int) element_end;
          element_start.5 = (long int) element_start;
          D.5665 = element_end.4 - element_start.5;
          l = (int) D.5665;
          D.5666 = l + 1;
          D.5667 = (long unsigned int) D.5666;
          ename = monoeg_malloc (D.5667);
          if (ename == 0B) goto fail; else goto <D.5668>;
          <D.5668>:
          D.5669 = (long unsigned int) l;
          strncpy (ename, element_start, D.5669);
          D.5670 = (sizetype) l;
          D.5671 = ename + D.5670;
          *D.5671 = 0;
          D.5590 = context->state;
          if (D.5590 == 1) goto <D.5672>; else goto <D.5673>;
          <D.5672>:
          D.5674 = context->parser.start_element;
          if (D.5674 != 0B) goto <D.5675>; else goto <D.5676>;
          <D.5675>:
          D.5674 = context->parser.start_element;
          names.2 = names;
          values.3 = values;
          D.5677 = context->user_data;
          D.5674 (context, ename, names.2, values.3, D.5677, error);
          <D.5676>:
          <D.5673>:
          names.2 = names;
          if (names.2 != 0B) goto <D.5678>; else goto <D.5679>;
          <D.5678>:
          names.2 = names;
          monoeg_g_strfreev (names.2);
          values.3 = values;
          monoeg_g_strfreev (values.3);
          <D.5679>:
          if (error != 0B) goto <D.5680>; else goto <D.5681>;
          <D.5680>:
          D.5657 = *error;
          if (D.5657 != 0B) goto <D.5682>; else goto <D.5683>;
          <D.5682>:
          monoeg_g_free (ename);
          goto fail;
          <D.5683>:
          <D.5681>:
          full_stop.6 = full_stop;
          if (full_stop.6 != 0) goto <D.5685>; else goto <D.5686>;
          <D.5685>:
          D.5687 = context->parser.end_element;
          if (D.5687 != 0B) goto <D.5688>; else goto <D.5689>;
          <D.5688>:
          D.5590 = context->state;
          if (D.5590 == 1) goto <D.5690>; else goto <D.5691>;
          <D.5690>:
          D.5687 = context->parser.end_element;
          D.5677 = context->user_data;
          D.5687 (context, ename, D.5677, error);
          if (error != 0B) goto <D.5692>; else goto <D.5693>;
          <D.5692>:
          D.5657 = *error;
          if (D.5657 != 0B) goto <D.5694>; else goto <D.5695>;
          <D.5694>:
          free (ename);
          goto fail;
          <D.5695>:
          <D.5693>:
          <D.5691>:
          <D.5689>:
          monoeg_g_free (ename);
          goto <D.5696>;
          <D.5686>:
          D.5697 = context->level;
          D.5698 = monoeg_g_slist_prepend (D.5697, ename);
          context->level = D.5698;
          <D.5696>:
          context->state = 2;
          goto <D.5544>;
        }
      finally
        {
          full_stop = {CLOBBER};
          names = {CLOBBER};
          values = {CLOBBER};
        }
    }
    <D.5551>:
    if (c == 60) goto <D.5699>; else goto <D.5700>;
    <D.5699>:
    context->state = 3;
    goto <D.5544>;
    <D.5700>:
    D.5701 = context->parser.text;
    if (D.5701 != 0B) goto <D.5702>; else goto <D.5703>;
    <D.5702>:
    D.5704 = context->text;
    if (D.5704 == 0B) goto <D.5705>; else goto <D.5706>;
    <D.5705>:
    D.5707 = monoeg_g_string_new ("");
    context->text = D.5707;
    <D.5706>:
    D.5704 = context->text;
    monoeg_g_string_append_c (D.5704, c);
    <D.5703>:
    goto <D.5544>;
    <D.5552>:
    D.5610 = *p;
    if (D.5610 != 45) goto <D.5544>; else goto <D.5708>;
    <D.5708>:
    D.5619 = p + 2;
    if (D.5619 < end) goto <D.5709>; else goto <D.5710>;
    <D.5709>:
    D.5602 = p + 1;
    D.5604 = *D.5602;
    if (D.5604 == 45) goto <D.5711>; else goto <D.5712>;
    <D.5711>:
    D.5619 = p + 2;
    D.5624 = *D.5619;
    if (D.5624 == 62) goto <D.5713>; else goto <D.5714>;
    <D.5713>:
    context->state = 2;
    p = p + 2;
    goto <D.5544>;
    <D.5714>:
    <D.5712>:
    <D.5710>:
    goto <D.5544>;
    <D.5553>:
    D.5701 = context->parser.text;
    if (D.5701 != 0B) goto <D.5715>; else goto <D.5716>;
    <D.5715>:
    D.5704 = context->text;
    if (D.5704 != 0B) goto <D.5717>; else goto <D.5718>;
    <D.5717>:
    D.5701 = context->parser.text;
    D.5704 = context->text;
    D.5719 = D.5704->str;
    D.5704 = context->text;
    D.5720 = D.5704->len;
    D.5677 = context->user_data;
    D.5701 (context, D.5719, D.5720, D.5677, error);
    if (error != 0B) goto <D.5721>; else goto <D.5722>;
    <D.5721>:
    D.5657 = *error;
    if (D.5657 != 0B) goto fail; else goto <D.5723>;
    <D.5723>:
    <D.5722>:
    <D.5718>:
    <D.5716>:
    if (c == 47) goto <D.5724>; else goto <D.5725>;
    <D.5724>:
    context->state = 4;
    goto <D.5726>;
    <D.5725>:
    p = p + 18446744073709551615;
    context->state = 1;
    <D.5726>:
    goto <D.5544>;
    <D.5554>:
    {
      struct GSList * current;
      char * text;

      current = context->level;
      D.5697 = context->level;
      if (D.5697 == 0B) goto <D.5727>; else goto <D.5728>;
      <D.5727>:
      if (error != 0B) goto <D.5729>; else goto <D.5730>;
      <D.5729>:
      D.5731 = monoeg_g_error_new (1B, 1, "%s", "Too many closing tags, not enough open tags");
      *error = D.5731;
      <D.5730>:
      goto fail;
      <D.5728>:
      text = current->data;
      D.5687 = context->parser.end_element;
      if (D.5687 != 0B) goto <D.5732>; else goto <D.5733>;
      <D.5732>:
      D.5687 = context->parser.end_element;
      D.5677 = context->user_data;
      D.5687 (context, text, D.5677, error);
      if (error != 0B) goto <D.5734>; else goto <D.5735>;
      <D.5734>:
      D.5657 = *error;
      if (D.5657 != 0B) goto <D.5736>; else goto <D.5737>;
      <D.5736>:
      monoeg_g_free (text);
      goto fail;
      <D.5737>:
      <D.5735>:
      <D.5733>:
      monoeg_g_free (text);
      goto <D.5558>;
      <D.5557>:
      p = p + 1;
      <D.5558>:
      if (p < end) goto <D.5738>; else goto <D.5559>;
      <D.5738>:
      D.5610 = *p;
      if (D.5610 != 62) goto <D.5557>; else goto <D.5559>;
      <D.5559>:
      D.5697 = context->level;
      D.5739 = D.5697->next;
      context->level = D.5739;
      monoeg_g_slist_free_1 (current);
      context->state = 2;
      goto <D.5544>;
    }
    <D.5740>:
    <D.5544>:
  }
  <D.5530>:
  p = p + 1;
  <D.5561>:
  if (p < end) goto <D.5560>; else goto <D.5562>;
  <D.5562>:
  D.5584 = 1;
  return D.5584;
  fail:
  D.5741 = context->parser.error;
  if (D.5741 != 0B) goto <D.5742>; else goto <D.5743>;
  <D.5742>:
  if (error != 0B) goto <D.5744>; else goto <D.5745>;
  <D.5744>:
  D.5657 = *error;
  if (D.5657 != 0B) goto <D.5746>; else goto <D.5747>;
  <D.5746>:
  D.5741 = context->parser.error;
  D.5657 = *error;
  D.5677 = context->user_data;
  D.5741 (context, D.5657, D.5677);
  <D.5747>:
  <D.5745>:
  <D.5743>:
  destroy_parse_state (context);
  D.5584 = 0;
  return D.5584;
}


my_isalpha (char c)
{
  char D.5753;
  char D.5755;
  gboolean D.5756;

  D.5753 = c + 159;
  if (D.5753 <= 25) goto <D.5751>; else goto <D.5754>;
  <D.5754>:
  D.5755 = c + 191;
  if (D.5755 <= 25) goto <D.5751>; else goto <D.5752>;
  <D.5751>:
  D.5756 = 1;
  return D.5756;
  <D.5752>:
  D.5756 = 0;
  return D.5756;
}


my_isalnum (char c)
{
  char D.5760;
  char D.5762;
  gboolean D.5763;
  char D.5764;

  D.5760 = c + 159;
  if (D.5760 <= 25) goto <D.5758>; else goto <D.5761>;
  <D.5761>:
  D.5762 = c + 191;
  if (D.5762 <= 25) goto <D.5758>; else goto <D.5759>;
  <D.5758>:
  D.5763 = 1;
  return D.5763;
  <D.5759>:
  D.5764 = c + 208;
  if (D.5764 <= 9) goto <D.5765>; else goto <D.5766>;
  <D.5765>:
  D.5763 = 1;
  return D.5763;
  <D.5766>:
  D.5763 = 0;
  return D.5763;
}


my_isspace (char c)
{
  gboolean D.5774;

  if (c == 32) goto <D.5768>; else goto <D.5770>;
  <D.5770>:
  if (c == 9) goto <D.5768>; else goto <D.5771>;
  <D.5771>:
  if (c == 13) goto <D.5768>; else goto <D.5772>;
  <D.5772>:
  if (c == 10) goto <D.5768>; else goto <D.5773>;
  <D.5773>:
  if (c == 11) goto <D.5768>; else goto <D.5769>;
  <D.5768>:
  D.5774 = 1;
  return D.5774;
  <D.5769>:
  D.5774 = 0;
  return D.5774;
}


parse_attributes (const char * p, const char * end, char * * * names, char * * * values, struct GError * * error, int * full_stop, int state)
{
  const char * D.5778;
  char D.5779;
  const char * D.5786;
  char D.5789;
  char * name.7;
  struct GError * D.5805;
  char * * D.5810;
  int D.5811;
  long unsigned int D.5812;
  long unsigned int D.5813;
  void * D.5814;
  char * * D.5815;
  void * D.5816;
  long unsigned int D.5817;
  long unsigned int D.5818;
  sizetype D.5819;
  char * * D.5820;
  char * * D.5821;
  char * value.8;
  char * * D.5823;
  char * * D.5824;
  int nnames;

  nnames = 0;
  <D.5512>:
  p = skip_space (p, end);
  if (p == end) goto <D.5776>; else goto <D.5777>;
  <D.5776>:
  D.5778 = end;
  return D.5778;
  <D.5777>:
  D.5779 = *p;
  if (D.5779 == 62) goto <D.5780>; else goto <D.5781>;
  <D.5780>:
  *full_stop = 0;
  D.5778 = p;
  return D.5778;
  <D.5781>:
  if (state == 6) goto <D.5782>; else goto <D.5783>;
  <D.5782>:
  D.5779 = *p;
  if (D.5779 == 63) goto <D.5784>; else goto <D.5785>;
  <D.5784>:
  D.5786 = p + 1;
  if (D.5786 < end) goto <D.5787>; else goto <D.5788>;
  <D.5787>:
  D.5786 = p + 1;
  D.5789 = *D.5786;
  if (D.5789 == 62) goto <D.5790>; else goto <D.5791>;
  <D.5790>:
  *full_stop = 0;
  D.5778 = p + 1;
  return D.5778;
  <D.5791>:
  <D.5788>:
  <D.5785>:
  <D.5783>:
  D.5779 = *p;
  if (D.5779 == 47) goto <D.5793>; else goto <D.5792>;
  <D.5793>:
  D.5786 = p + 1;
  if (D.5786 < end) goto <D.5794>; else goto <D.5792>;
  <D.5794>:
  D.5786 = p + 1;
  D.5789 = *D.5786;
  if (D.5789 == 62) goto <D.5795>; else goto <D.5792>;
  <D.5795>:
  *full_stop = 1;
  D.5778 = p + 1;
  return D.5778;
  <D.5792>:
  {
    char * name;
    char * value;

    try
      {
        p = parse_name (p, end, &name);
        if (p == end) goto <D.5796>; else goto <D.5797>;
        <D.5796>:
        D.5778 = p;
        return D.5778;
        <D.5797>:
        p = skip_space (p, end);
        if (p == end) goto <D.5798>; else goto <D.5799>;
        <D.5798>:
        name.7 = name;
        monoeg_g_free (name.7);
        D.5778 = p;
        return D.5778;
        <D.5799>:
        D.5779 = *p;
        if (D.5779 != 61) goto <D.5801>; else goto <D.5802>;
        <D.5801>:
        if (error != 0B) goto <D.5803>; else goto <D.5804>;
        <D.5803>:
        name.7 = name;
        D.5805 = monoeg_g_error_new (1B, 1, "Expected an = after the attribute name `%s\'", name.7);
        *error = D.5805;
        <D.5804>:
        name.7 = name;
        monoeg_g_free (name.7);
        D.5778 = end;
        return D.5778;
        <D.5802>:
        p = p + 1;
        p = skip_space (p, end);
        if (p == end) goto <D.5806>; else goto <D.5807>;
        <D.5806>:
        name.7 = name;
        monoeg_g_free (name.7);
        D.5778 = end;
        return D.5778;
        <D.5807>:
        p = parse_value (p, end, &value, error);
        if (p == end) goto <D.5808>; else goto <D.5809>;
        <D.5808>:
        name.7 = name;
        monoeg_g_free (name.7);
        D.5778 = p;
        return D.5778;
        <D.5809>:
        nnames = nnames + 1;
        D.5810 = *names;
        D.5811 = nnames + 1;
        D.5812 = (long unsigned int) D.5811;
        D.5813 = D.5812 * 8;
        D.5814 = monoeg_realloc (D.5810, D.5813);
        *names = D.5814;
        D.5815 = *values;
        D.5811 = nnames + 1;
        D.5812 = (long unsigned int) D.5811;
        D.5813 = D.5812 * 8;
        D.5816 = monoeg_realloc (D.5815, D.5813);
        *values = D.5816;
        D.5810 = *names;
        D.5817 = (long unsigned int) nnames;
        D.5818 = D.5817 * 8;
        D.5819 = D.5818 + 18446744073709551608;
        D.5820 = D.5810 + D.5819;
        name.7 = name;
        *D.5820 = name.7;
        D.5815 = *values;
        D.5817 = (long unsigned int) nnames;
        D.5818 = D.5817 * 8;
        D.5819 = D.5818 + 18446744073709551608;
        D.5821 = D.5815 + D.5819;
        value.8 = value;
        *D.5821 = value.8;
        D.5810 = *names;
        D.5817 = (long unsigned int) nnames;
        D.5818 = D.5817 * 8;
        D.5823 = D.5810 + D.5818;
        *D.5823 = 0B;
        D.5815 = *values;
        D.5817 = (long unsigned int) nnames;
        D.5818 = D.5817 * 8;
        D.5824 = D.5815 + D.5818;
        *D.5824 = 0B;
      }
    finally
      {
        name = {CLOBBER};
        value = {CLOBBER};
      }
  }
  goto <D.5512>;
}


parse_name (const char * p, const char * end, char * * value)
{
  char D.5829;
  int D.5830;
  const char * D.5833;
  long int p.9;
  long int start.10;
  long int D.5836;
  int D.5837;
  long unsigned int D.5838;
  void * D.5839;
  char * D.5840;
  long unsigned int D.5843;
  sizetype D.5844;
  char * D.5845;
  const char * start;
  int l;

  start = p;
  goto <D.5498>;
  <D.5497>:
  p = p + 1;
  <D.5498>:
  if (p < end) goto <D.5828>; else goto <D.5499>;
  <D.5828>:
  D.5829 = *p;
  D.5830 = my_isalnum (D.5829);
  if (D.5830 != 0) goto <D.5497>; else goto <D.5499>;
  <D.5499>:
  if (p == end) goto <D.5831>; else goto <D.5832>;
  <D.5831>:
  D.5833 = end;
  return D.5833;
  <D.5832>:
  p.9 = (long int) p;
  start.10 = (long int) start;
  D.5836 = p.9 - start.10;
  l = (int) D.5836;
  D.5837 = l + 1;
  D.5838 = (long unsigned int) D.5837;
  D.5839 = monoeg_malloc (D.5838);
  *value = D.5839;
  D.5840 = *value;
  if (D.5840 == 0B) goto <D.5841>; else goto <D.5842>;
  <D.5841>:
  D.5833 = end;
  return D.5833;
  <D.5842>:
  D.5840 = *value;
  D.5843 = (long unsigned int) l;
  strncpy (D.5840, start, D.5843);
  D.5840 = *value;
  D.5844 = (sizetype) l;
  D.5845 = D.5840 + D.5844;
  *D.5845 = 0;
  D.5833 = p;
  return D.5833;
}


skip_space (const char * p, const char * end)
{
  char D.5848;
  int D.5849;
  const char * D.5850;

  goto <D.5477>;
  <D.5476>:
  p = p + 1;
  <D.5477>:
  if (p < end) goto <D.5847>; else goto <D.5478>;
  <D.5847>:
  D.5848 = *p;
  D.5849 = my_isspace (D.5848);
  if (D.5849 != 0) goto <D.5476>; else goto <D.5478>;
  <D.5478>:
  D.5850 = p;
  return D.5850;
}


parse_value (const char * p, const char * end, char * * value, struct GError * * error)
{
  char D.5852;
  struct GError * D.5857;
  const char * D.5858;
  long int p.11;
  long int start.12;
  long int D.5864;
  int D.5865;
  long unsigned int D.5866;
  void * D.5867;
  char * D.5868;
  long unsigned int D.5871;
  sizetype D.5872;
  char * D.5873;
  const char * start;
  int l;

  D.5852 = *p;
  if (D.5852 != 34) goto <D.5853>; else goto <D.5854>;
  <D.5853>:
  if (error != 0B) goto <D.5855>; else goto <D.5856>;
  <D.5855>:
  D.5857 = monoeg_g_error_new (1B, 1, "%s", "Expected the attribute value to start with a quote");
  *error = D.5857;
  <D.5856>:
  D.5858 = end;
  return D.5858;
  <D.5854>:
  p = p + 1;
  start = p;
  goto <D.5488>;
  <D.5487>:
  p = p + 1;
  <D.5488>:
  if (p < end) goto <D.5859>; else goto <D.5489>;
  <D.5859>:
  D.5852 = *p;
  if (D.5852 != 34) goto <D.5487>; else goto <D.5489>;
  <D.5489>:
  if (p == end) goto <D.5860>; else goto <D.5861>;
  <D.5860>:
  D.5858 = end;
  return D.5858;
  <D.5861>:
  p.11 = (long int) p;
  start.12 = (long int) start;
  D.5864 = p.11 - start.12;
  l = (int) D.5864;
  p = p + 1;
  D.5865 = l + 1;
  D.5866 = (long unsigned int) D.5865;
  D.5867 = monoeg_malloc (D.5866);
  *value = D.5867;
  D.5868 = *value;
  if (D.5868 == 0B) goto <D.5869>; else goto <D.5870>;
  <D.5869>:
  D.5858 = end;
  return D.5858;
  <D.5870>:
  D.5868 = *value;
  D.5871 = (long unsigned int) l;
  strncpy (D.5868, start, D.5871);
  D.5868 = *value;
  D.5872 = (sizetype) l;
  D.5873 = D.5868 + D.5872;
  *D.5873 = 0;
  D.5858 = p;
  return D.5858;
}


strncpy (char * restrict __dest, const char * restrict __src, size_t __len)
{
  char * D.5875;
  long unsigned int D.5876;

  D.5876 = __builtin_object_size (__dest, 1);
  D.5875 = __builtin___strncpy_chk (__dest, __src, __len, D.5876);
  return D.5875;
}


destroy_parse_state (struct GMarkupParseContext * context)
{
  void * D.5878;
  struct GSList * D.5879;
  struct GString * D.5880;
  struct GSList * p;

  p = context->level;
  goto <D.5518>;
  <D.5517>:
  D.5878 = p->data;
  monoeg_g_free (D.5878);
  p = p->next;
  <D.5518>:
  if (p != 0B) goto <D.5517>; else goto <D.5519>;
  <D.5519>:
  D.5879 = context->level;
  monoeg_g_slist_free (D.5879);
  D.5880 = context->text;
  if (D.5880 != 0B) goto <D.5881>; else goto <D.5882>;
  <D.5881>:
  D.5880 = context->text;
  monoeg_g_string_free (D.5880, 1);
  <D.5882>:
  context->text = 0B;
  context->level = 0B;
}


monoeg_g_markup_parse_context_end_parse (struct GMarkupParseContext * context, struct GError * * error)
{
  gboolean D.5885;

  if (context == 0B) goto <D.5883>; else goto <D.5884>;
  <D.5883>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gmarkup.c", 466, "context != NULL");
  D.5885 = 0;
  return D.5885;
  <D.5884>:
  D.5885 = 1;
  return D.5885;
}