monoeg_g_ptr_array_new ()
{
  struct GPtrArray * D.4668;

  D.4668 = monoeg_g_ptr_array_sized_new (0);
  return D.4668;
}


monoeg_g_ptr_array_sized_new (guint reserved_size)
{
  struct GPtrArray * D.4672;
  struct GPtrArrayPriv * array;

  array = monoeg_malloc0 (12);
  array->pdata = 0B;
  array->len = 0;
  array->size = 0;
  if (reserved_size != 0) goto <D.4670>; else goto <D.4671>;
  <D.4670>:
  monoeg_ptr_array_grow (array, reserved_size);
  <D.4671>:
  D.4672 = array;
  return D.4672;
}


monoeg_ptr_array_grow (struct GPtrArrayPriv * array, guint length)
{
  unsigned int D.4674;
  unsigned int D.4677;
  unsigned int D.4680;
  unsigned int D.4681;
  void * * D.4682;
  unsigned int D.4683;
  void * D.4684;
  guint new_length;

  D.4674 = array->len;
  new_length = D.4674 + length;
  if (array == 0B) goto <D.4675>; else goto <D.4676>;
  <D.4675>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gptrarray.c", 45, "array != NULL");
  return;
  <D.4676>:
  D.4677 = array->size;
  if (D.4677 >= new_length) goto <D.4678>; else goto <D.4679>;
  <D.4678>:
  return;
  <D.4679>:
  array->size = 1;
  goto <D.4601>;
  <D.4600>:
  D.4677 = array->size;
  D.4680 = D.4677 << 1;
  array->size = D.4680;
  <D.4601>:
  D.4677 = array->size;
  if (D.4677 < new_length) goto <D.4600>; else goto <D.4602>;
  <D.4602>:
  D.4677 = array->size;
  D.4681 = MAX_EXPR <D.4677, 16>;
  array->size = D.4681;
  D.4682 = array->pdata;
  D.4677 = array->size;
  D.4683 = D.4677 * 4;
  D.4684 = monoeg_realloc (D.4682, D.4683);
  array->pdata = D.4684;
}


monoeg_g_ptr_array_free (struct GPtrArray * array, gboolean free_seg)
{
  void * * D.4688;
  void * * D.4691;
  void * * data;

  data = 0B;
  if (array == 0B) goto <D.4686>; else goto <D.4687>;
  <D.4686>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gptrarray.c", 88, "array != NULL");
  D.4688 = 0B;
  return D.4688;
  <D.4687>:
  if (free_seg != 0) goto <D.4689>; else goto <D.4690>;
  <D.4689>:
  D.4691 = array->pdata;
  monoeg_g_free (D.4691);
  goto <D.4692>;
  <D.4690>:
  data = array->pdata;
  <D.4692>:
  monoeg_g_free (array);
  D.4688 = data;
  return D.4688;
}


monoeg_g_ptr_array_set_size (struct GPtrArray * array, gint length)
{
  unsigned int length.0;
  unsigned int D.4697;
  unsigned int length.1;
  void * * D.4701;
  unsigned int D.4702;
  void * D.4703;
  unsigned int D.4704;
  unsigned int D.4705;

  if (array == 0B) goto <D.4694>; else goto <D.4695>;
  <D.4694>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gptrarray.c", 104, "array != NULL");
  return;
  <D.4695>:
  length.0 = (unsigned int) length;
  D.4697 = array->len;
  if (length.0 > D.4697) goto <D.4698>; else goto <D.4699>;
  <D.4698>:
  length.1 = (unsigned int) length;
  monoeg_ptr_array_grow (array, length.1);
  D.4701 = array->pdata;
  D.4697 = array->len;
  D.4702 = D.4697 * 4;
  D.4703 = D.4701 + D.4702;
  length.1 = (unsigned int) length;
  D.4697 = array->len;
  D.4704 = length.1 - D.4697;
  D.4705 = D.4704 * 4;
  memset (D.4703, 0, D.4705);
  <D.4699>:
  length.1 = (unsigned int) length;
  array->len = length.1;
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.4709;
  int D.4714;
  void * D.4716;
  unsigned int D.4717;

  D.4709 = __builtin_constant_p (__len);
  if (D.4709 != 0) goto <D.4710>; else goto <D.4711>;
  <D.4710>:
  if (__len == 0) goto <D.4712>; else goto <D.4713>;
  <D.4712>:
  D.4714 = __builtin_constant_p (__ch);
  if (D.4714 == 0) goto <D.4707>; else goto <D.4715>;
  <D.4715>:
  if (__ch != 0) goto <D.4707>; else goto <D.4708>;
  <D.4707>:
  __warn_memset_zero_len ();
  D.4716 = __dest;
  return D.4716;
  <D.4708>:
  <D.4713>:
  <D.4711>:
  D.4717 = __builtin_object_size (__dest, 0);
  D.4716 = __builtin___memset_chk (__dest, __ch, __len, D.4717);
  return D.4716;
}


monoeg_g_ptr_array_add (struct GPtrArray * array, void * data)
{
  void * * D.4721;
  unsigned int D.4722;
  unsigned int D.4723;
  unsigned int D.4724;
  unsigned int D.4725;
  void * * D.4726;

  if (array == 0B) goto <D.4719>; else goto <D.4720>;
  <D.4719>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gptrarray.c", 118, "array != NULL");
  return;
  <D.4720>:
  monoeg_ptr_array_grow (array, 1);
  D.4721 = array->pdata;
  D.4722 = array->len;
  D.4723 = D.4722;
  D.4724 = D.4723 + 1;
  array->len = D.4724;
  D.4725 = D.4723 * 4;
  D.4726 = D.4721 + D.4725;
  *D.4726 = data;
}


monoeg_g_ptr_array_remove_index (struct GPtrArray * array, guint index)
{
  void * D.4730;
  void * * D.4733;
  unsigned int D.4734;
  void * * D.4735;
  unsigned int D.4736;
  unsigned int D.4737;
  void * D.4740;
  sizetype D.4741;
  sizetype D.4742;
  void * * D.4743;
  unsigned int D.4744;
  unsigned int D.4745;
  unsigned int D.4746;
  unsigned int D.4747;
  void * * D.4748;
  void * removed_node;

  if (array == 0B) goto <D.4728>; else goto <D.4729>;
  <D.4728>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gptrarray.c", 128, "array != NULL");
  D.4730 = 0B;
  return D.4730;
  <D.4729>:
  if (0 != 0) goto <D.4731>; else goto <D.4732>;
  <D.4731>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gptrarray.c", 129, "index >= 0 || index < array->len");
  D.4730 = 0B;
  return D.4730;
  <D.4732>:
  D.4733 = array->pdata;
  D.4734 = index * 4;
  D.4735 = D.4733 + D.4734;
  removed_node = *D.4735;
  D.4736 = array->len;
  D.4737 = D.4736 + 4294967295;
  if (D.4737 != index) goto <D.4738>; else goto <D.4739>;
  <D.4738>:
  D.4733 = array->pdata;
  D.4734 = index * 4;
  D.4740 = D.4733 + D.4734;
  D.4733 = array->pdata;
  D.4741 = index + 1;
  D.4742 = D.4741 * 4;
  D.4743 = D.4733 + D.4742;
  D.4736 = array->len;
  D.4744 = D.4736 - index;
  D.4745 = D.4744 + 1073741823;
  D.4746 = D.4745 * 4;
  memmove (D.4740, D.4743, D.4746);
  <D.4739>:
  D.4736 = array->len;
  D.4737 = D.4736 + 4294967295;
  array->len = D.4737;
  D.4733 = array->pdata;
  D.4736 = array->len;
  D.4747 = D.4736 * 4;
  D.4748 = D.4733 + D.4747;
  *D.4748 = 0B;
  D.4730 = removed_node;
  return D.4730;
}


memmove (void * __dest, const void * __src, size_t __len)
{
  void * D.4750;
  unsigned int D.4751;

  D.4751 = __builtin_object_size (__dest, 0);
  D.4750 = __builtin___memmove_chk (__dest, __src, __len, D.4751);
  return D.4750;
}


monoeg_g_ptr_array_remove_index_fast (struct GPtrArray * array, guint index)
{
  void * D.4755;
  void * * D.4758;
  unsigned int D.4759;
  void * * D.4760;
  unsigned int D.4761;
  unsigned int D.4762;
  void * D.4765;
  sizetype D.4766;
  sizetype D.4767;
  void * * D.4768;
  unsigned int D.4769;
  void * * D.4770;
  void * removed_node;

  if (array == 0B) goto <D.4753>; else goto <D.4754>;
  <D.4753>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gptrarray.c", 149, "array != NULL");
  D.4755 = 0B;
  return D.4755;
  <D.4754>:
  if (0 != 0) goto <D.4756>; else goto <D.4757>;
  <D.4756>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gptrarray.c", 150, "index >= 0 || index < array->len");
  D.4755 = 0B;
  return D.4755;
  <D.4757>:
  D.4758 = array->pdata;
  D.4759 = index * 4;
  D.4760 = D.4758 + D.4759;
  removed_node = *D.4760;
  D.4761 = array->len;
  D.4762 = D.4761 + 4294967295;
  if (D.4762 != index) goto <D.4763>; else goto <D.4764>;
  <D.4763>:
  D.4758 = array->pdata;
  D.4759 = index * 4;
  D.4765 = D.4758 + D.4759;
  D.4758 = array->pdata;
  D.4761 = array->len;
  D.4766 = D.4761 + 1073741823;
  D.4767 = D.4766 * 4;
  D.4768 = D.4758 + D.4767;
  memmove (D.4765, D.4768, 4);
  <D.4764>:
  D.4761 = array->len;
  D.4762 = D.4761 + 4294967295;
  array->len = D.4762;
  D.4758 = array->pdata;
  D.4761 = array->len;
  D.4769 = D.4761 * 4;
  D.4770 = D.4758 + D.4769;
  *D.4770 = 0B;
  D.4755 = removed_node;
  return D.4755;
}


monoeg_g_ptr_array_remove (struct GPtrArray * array, void * data)
{
  gboolean D.4774;
  void * * D.4775;
  unsigned int D.4776;
  void * * D.4777;
  void * D.4778;
  unsigned int D.4781;
  guint i;

  if (array == 0B) goto <D.4772>; else goto <D.4773>;
  <D.4772>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gptrarray.c", 170, "array != NULL");
  D.4774 = 0;
  return D.4774;
  <D.4773>:
  i = 0;
  goto <D.4639>;
  <D.4638>:
  D.4775 = array->pdata;
  D.4776 = i * 4;
  D.4777 = D.4775 + D.4776;
  D.4778 = *D.4777;
  if (D.4778 == data) goto <D.4779>; else goto <D.4780>;
  <D.4779>:
  monoeg_g_ptr_array_remove_index (array, i);
  D.4774 = 1;
  return D.4774;
  <D.4780>:
  i = i + 1;
  <D.4639>:
  D.4781 = array->len;
  if (D.4781 > i) goto <D.4638>; else goto <D.4640>;
  <D.4640>:
  D.4774 = 0;
  return D.4774;
}


monoeg_g_ptr_array_remove_fast (struct GPtrArray * array, void * data)
{
  gboolean D.4785;
  void * * D.4786;
  unsigned int D.4787;
  void * * D.4788;
  void * D.4789;
  unsigned int D.4792;
  unsigned int D.4793;
  unsigned int D.4796;
  void * * D.4797;
  void * D.4798;
  guint i;

  if (array == 0B) goto <D.4783>; else goto <D.4784>;
  <D.4783>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gptrarray.c", 187, "array != NULL");
  D.4785 = 0;
  return D.4785;
  <D.4784>:
  i = 0;
  goto <D.4647>;
  <D.4646>:
  D.4786 = array->pdata;
  D.4787 = i * 4;
  D.4788 = D.4786 + D.4787;
  D.4789 = *D.4788;
  if (D.4789 == data) goto <D.4790>; else goto <D.4791>;
  <D.4790>:
  D.4792 = array->len;
  D.4793 = D.4792 + 4294967295;
  array->len = D.4793;
  D.4792 = array->len;
  if (D.4792 != 0) goto <D.4794>; else goto <D.4795>;
  <D.4794>:
  D.4786 = array->pdata;
  D.4787 = i * 4;
  D.4788 = D.4786 + D.4787;
  D.4786 = array->pdata;
  D.4792 = array->len;
  D.4796 = D.4792 * 4;
  D.4797 = D.4786 + D.4796;
  D.4798 = *D.4797;
  *D.4788 = D.4798;
  goto <D.4799>;
  <D.4795>:
  D.4786 = array->pdata;
  D.4787 = i * 4;
  D.4788 = D.4786 + D.4787;
  *D.4788 = 0B;
  <D.4799>:
  D.4785 = 1;
  return D.4785;
  <D.4791>:
  i = i + 1;
  <D.4647>:
  D.4792 = array->len;
  if (D.4792 > i) goto <D.4646>; else goto <D.4648>;
  <D.4648>:
  D.4785 = 0;
  return D.4785;
}


monoeg_g_ptr_array_foreach (struct GPtrArray * array, void (*GFunc) (void *, void *) func, void * user_data)
{
  void * * D.4801;
  unsigned int D.4802;
  void * * D.4803;
  void * D.4804;
  unsigned int D.4805;
  guint i;

  i = 0;
  goto <D.4656>;
  <D.4655>:
  D.4801 = array->pdata;
  D.4802 = i * 4;
  D.4803 = D.4801 + D.4802;
  D.4804 = *D.4803;
  func (D.4804, user_data);
  i = i + 1;
  <D.4656>:
  D.4805 = array->len;
  if (D.4805 > i) goto <D.4655>; else goto <D.4657>;
  <D.4657>:
}


monoeg_g_ptr_array_sort (struct GPtrArray * array, gint (*GCompareFunc) (const void *, const void *) compare)
{
  void * * D.4808;
  unsigned int D.4809;

  if (array == 0B) goto <D.4806>; else goto <D.4807>;
  <D.4806>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gptrarray.c", 216, "array != NULL");
  return;
  <D.4807>:
  D.4808 = array->pdata;
  D.4809 = array->len;
  qsort (D.4808, D.4809, 4, compare);
}


monoeg_g_ptr_array_sort_with_data (struct GPtrArray * array, gint (*GCompareDataFunc) (const void *, const void *, void *) compare, void * user_data)
{
  void * * D.4813;
  unsigned int D.4814;

  if (array == 0B) goto <D.4811>; else goto <D.4812>;
  <D.4811>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gptrarray.c", 223, "array != NULL");
  return;
  <D.4812>:
  D.4813 = array->pdata;
  D.4814 = array->len;
  monoeg_g_qsort_with_data (D.4813, D.4814, 4, compare, user_data);
}