monoeg_g_ptr_array_new ()
{
  struct GPtrArray * D.4648;

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


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

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


monoeg_ptr_array_grow (struct GPtrArrayPriv * array, guint length)
{
  unsigned int D.4654;
  unsigned int D.4657;
  unsigned int D.4660;
  unsigned int D.4661;
  unsigned int D.4662;
  void * * D.4663;
  void * D.4664;
  guint new_length;

  D.4654 = array->len;
  new_length = D.4654 + length;
  if (array == 0B) goto <D.4655>; else goto <D.4656>;
  <D.4655>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gptrarray.c", 45, "array != NULL");
  return;
  <D.4656>:
  D.4657 = array->size;
  if (D.4657 >= new_length) goto <D.4658>; else goto <D.4659>;
  <D.4658>:
  return;
  <D.4659>:
  array->size = 1;
  goto <D.4581>;
  <D.4580>:
  D.4657 = array->size;
  D.4660 = D.4657 << 1;
  array->size = D.4660;
  <D.4581>:
  D.4657 = array->size;
  if (D.4657 < new_length) goto <D.4580>; else goto <D.4582>;
  <D.4582>:
  D.4657 = array->size;
  D.4661 = MAX_EXPR <D.4657, 16>;
  array->size = D.4661;
  D.4657 = array->size;
  D.4662 = D.4657 * 4;
  D.4663 = array->pdata;
  D.4664 = monoeg_realloc (D.4663, D.4662);
  array->pdata = D.4664;
}


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

  data = 0B;
  if (array == 0B) goto <D.4666>; else goto <D.4667>;
  <D.4666>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gptrarray.c", 88, "array != NULL");
  D.4668 = 0B;
  return D.4668;
  <D.4667>:
  if (free_seg != 0) goto <D.4669>; else goto <D.4670>;
  <D.4669>:
  D.4671 = array->pdata;
  monoeg_g_free (D.4671);
  goto <D.4672>;
  <D.4670>:
  data = array->pdata;
  <D.4672>:
  monoeg_g_free (array);
  D.4668 = data;
  return D.4668;
}


monoeg_g_ptr_array_set_size (struct GPtrArray * array, gint length)
{
  unsigned int length.0;
  unsigned int D.4677;
  unsigned int length.1;
  unsigned int D.4681;
  unsigned int D.4682;
  void * * D.4683;
  unsigned int D.4684;
  void * D.4685;

  if (array == 0B) goto <D.4674>; else goto <D.4675>;
  <D.4674>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gptrarray.c", 104, "array != NULL");
  return;
  <D.4675>:
  length.0 = (unsigned int) length;
  D.4677 = array->len;
  if (length.0 > D.4677) goto <D.4678>; else goto <D.4679>;
  <D.4678>:
  length.1 = (unsigned int) length;
  monoeg_ptr_array_grow (array, length.1);
  length.1 = (unsigned int) length;
  D.4677 = array->len;
  D.4681 = length.1 - D.4677;
  D.4682 = D.4681 * 4;
  D.4683 = array->pdata;
  D.4677 = array->len;
  D.4684 = D.4677 * 4;
  D.4685 = D.4683 + D.4684;
  memset (D.4685, 0, D.4682);
  <D.4679>:
  length.1 = (unsigned int) length;
  array->len = length.1;
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.4689;
  int D.4694;
  void * D.4696;
  unsigned int D.4697;

  D.4689 = __builtin_constant_p (__len);
  if (D.4689 != 0) goto <D.4690>; else goto <D.4691>;
  <D.4690>:
  if (__len == 0) goto <D.4692>; else goto <D.4693>;
  <D.4692>:
  D.4694 = __builtin_constant_p (__ch);
  if (D.4694 == 0) goto <D.4687>; else goto <D.4695>;
  <D.4695>:
  if (__ch != 0) goto <D.4687>; else goto <D.4688>;
  <D.4687>:
  __warn_memset_zero_len ();
  D.4696 = __dest;
  return D.4696;
  <D.4688>:
  <D.4693>:
  <D.4691>:
  D.4697 = __builtin_object_size (__dest, 0);
  D.4696 = __builtin___memset_chk (__dest, __ch, __len, D.4697);
  return D.4696;
}


monoeg_g_ptr_array_add (struct GPtrArray * array, void * data)
{
  void * * D.4701;
  unsigned int D.4702;
  unsigned int D.4703;
  unsigned int D.4704;
  unsigned int D.4705;
  void * * D.4706;

  if (array == 0B) goto <D.4699>; else goto <D.4700>;
  <D.4699>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gptrarray.c", 118, "array != NULL");
  return;
  <D.4700>:
  monoeg_ptr_array_grow (array, 1);
  D.4701 = array->pdata;
  D.4702 = array->len;
  D.4703 = D.4702;
  D.4704 = D.4703 + 1;
  array->len = D.4704;
  D.4705 = D.4703 * 4;
  D.4706 = D.4701 + D.4705;
  *D.4706 = data;
}


monoeg_g_ptr_array_remove_index (struct GPtrArray * array, guint index)
{
  void * D.4710;
  void * * D.4713;
  unsigned int D.4714;
  void * * D.4715;
  unsigned int D.4716;
  unsigned int D.4717;
  unsigned int D.4720;
  unsigned int D.4721;
  unsigned int D.4722;
  sizetype D.4723;
  sizetype D.4724;
  void * * D.4725;
  void * D.4726;
  unsigned int D.4727;
  void * * D.4728;
  void * removed_node;

  if (array == 0B) goto <D.4708>; else goto <D.4709>;
  <D.4708>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gptrarray.c", 128, "array != NULL");
  D.4710 = 0B;
  return D.4710;
  <D.4709>:
  if (0 != 0) goto <D.4711>; else goto <D.4712>;
  <D.4711>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gptrarray.c", 129, "index >= 0 || index < array->len");
  D.4710 = 0B;
  return D.4710;
  <D.4712>:
  D.4713 = array->pdata;
  D.4714 = index * 4;
  D.4715 = D.4713 + D.4714;
  removed_node = *D.4715;
  D.4716 = array->len;
  D.4717 = D.4716 + 4294967295;
  if (D.4717 != index) goto <D.4718>; else goto <D.4719>;
  <D.4718>:
  D.4716 = array->len;
  D.4720 = D.4716 - index;
  D.4721 = D.4720 + 1073741823;
  D.4722 = D.4721 * 4;
  D.4713 = array->pdata;
  D.4723 = index + 1;
  D.4724 = D.4723 * 4;
  D.4725 = D.4713 + D.4724;
  D.4713 = array->pdata;
  D.4714 = index * 4;
  D.4726 = D.4713 + D.4714;
  memmove (D.4726, D.4725, D.4722);
  <D.4719>:
  D.4716 = array->len;
  D.4717 = D.4716 + 4294967295;
  array->len = D.4717;
  D.4713 = array->pdata;
  D.4716 = array->len;
  D.4727 = D.4716 * 4;
  D.4728 = D.4713 + D.4727;
  *D.4728 = 0B;
  D.4710 = removed_node;
  return D.4710;
}


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

  D.4731 = __builtin_object_size (__dest, 0);
  D.4730 = __builtin___memmove_chk (__dest, __src, __len, D.4731);
  return D.4730;
}


monoeg_g_ptr_array_remove_index_fast (struct GPtrArray * array, guint index)
{
  void * D.4735;
  void * * D.4738;
  unsigned int D.4739;
  void * * D.4740;
  unsigned int D.4741;
  unsigned int D.4742;
  sizetype D.4745;
  sizetype D.4746;
  void * * D.4747;
  void * D.4748;
  unsigned int D.4749;
  void * * D.4750;
  void * removed_node;

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


monoeg_g_ptr_array_remove (struct GPtrArray * array, void * data)
{
  gboolean D.4754;
  void * * D.4755;
  unsigned int D.4756;
  void * * D.4757;
  void * D.4758;
  unsigned int D.4761;
  guint i;

  if (array == 0B) goto <D.4752>; else goto <D.4753>;
  <D.4752>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gptrarray.c", 170, "array != NULL");
  D.4754 = 0;
  return D.4754;
  <D.4753>:
  i = 0;
  goto <D.4619>;
  <D.4618>:
  D.4755 = array->pdata;
  D.4756 = i * 4;
  D.4757 = D.4755 + D.4756;
  D.4758 = *D.4757;
  if (D.4758 == data) goto <D.4759>; else goto <D.4760>;
  <D.4759>:
  monoeg_g_ptr_array_remove_index (array, i);
  D.4754 = 1;
  return D.4754;
  <D.4760>:
  i = i + 1;
  <D.4619>:
  D.4761 = array->len;
  if (D.4761 > i) goto <D.4618>; else goto <D.4620>;
  <D.4620>:
  D.4754 = 0;
  return D.4754;
}


monoeg_g_ptr_array_remove_fast (struct GPtrArray * array, void * data)
{
  gboolean D.4765;
  void * * D.4766;
  unsigned int D.4767;
  void * * D.4768;
  void * D.4769;
  unsigned int D.4772;
  unsigned int D.4773;
  unsigned int D.4776;
  void * * D.4777;
  void * D.4778;
  guint i;

  if (array == 0B) goto <D.4763>; else goto <D.4764>;
  <D.4763>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gptrarray.c", 187, "array != NULL");
  D.4765 = 0;
  return D.4765;
  <D.4764>:
  i = 0;
  goto <D.4627>;
  <D.4626>:
  D.4766 = array->pdata;
  D.4767 = i * 4;
  D.4768 = D.4766 + D.4767;
  D.4769 = *D.4768;
  if (D.4769 == data) goto <D.4770>; else goto <D.4771>;
  <D.4770>:
  D.4772 = array->len;
  D.4773 = D.4772 + 4294967295;
  array->len = D.4773;
  D.4772 = array->len;
  if (D.4772 != 0) goto <D.4774>; else goto <D.4775>;
  <D.4774>:
  D.4766 = array->pdata;
  D.4767 = i * 4;
  D.4768 = D.4766 + D.4767;
  D.4766 = array->pdata;
  D.4772 = array->len;
  D.4776 = D.4772 * 4;
  D.4777 = D.4766 + D.4776;
  D.4778 = *D.4777;
  *D.4768 = D.4778;
  goto <D.4779>;
  <D.4775>:
  D.4766 = array->pdata;
  D.4767 = i * 4;
  D.4768 = D.4766 + D.4767;
  *D.4768 = 0B;
  <D.4779>:
  D.4765 = 1;
  return D.4765;
  <D.4771>:
  i = i + 1;
  <D.4627>:
  D.4772 = array->len;
  if (D.4772 > i) goto <D.4626>; else goto <D.4628>;
  <D.4628>:
  D.4765 = 0;
  return D.4765;
}


monoeg_g_ptr_array_foreach (struct GPtrArray * array, void (*GFunc) (void *, void *) func, void * user_data)
{
  void * * D.4781;
  unsigned int D.4782;
  void * * D.4783;
  void * D.4784;
  unsigned int D.4785;
  guint i;

  i = 0;
  goto <D.4636>;
  <D.4635>:
  D.4781 = array->pdata;
  D.4782 = i * 4;
  D.4783 = D.4781 + D.4782;
  D.4784 = *D.4783;
  func (D.4784, user_data);
  i = i + 1;
  <D.4636>:
  D.4785 = array->len;
  if (D.4785 > i) goto <D.4635>; else goto <D.4637>;
  <D.4637>:
}


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

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


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

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