monoeg_g_array_new (gboolean zero_terminated, gboolean clear_, guint element_size)
{
  struct GArray * D.4650;
  struct GArrayPriv * rv;

  rv = monoeg_malloc0 (24);
  rv->zero_terminated = zero_terminated;
  rv->clear_ = clear_;
  rv->element_size = element_size;
  ensure_capacity (rv, 16);
  D.4650 = rv;
  return D.4650;
}


ensure_capacity (struct GArrayPriv * priv, guint capacity)
{
  unsigned int D.4652;
  unsigned int D.4655;
  gchar * D.4656;
  unsigned int D.4657;
  unsigned int D.4658;
  void * D.4659;
  int D.4660;
  unsigned int D.4663;
  void * D.4664;
  unsigned int D.4665;
  unsigned int D.4666;
  guint new_capacity;

  D.4652 = priv->capacity;
  if (D.4652 >= capacity) goto <D.4653>; else goto <D.4654>;
  <D.4653>:
  return;
  <D.4654>:
  D.4655 = capacity + 63;
  new_capacity = D.4655 & 4294967232;
  D.4656 = priv->array.data;
  D.4657 = priv->element_size;
  D.4658 = D.4657 * new_capacity;
  D.4659 = monoeg_realloc (D.4656, D.4658);
  priv->array.data = D.4659;
  D.4660 = priv->clear_;
  if (D.4660 != 0) goto <D.4661>; else goto <D.4662>;
  <D.4661>:
  D.4656 = priv->array.data;
  D.4652 = priv->capacity;
  D.4657 = priv->element_size;
  D.4663 = D.4652 * D.4657;
  D.4664 = D.4656 + D.4663;
  D.4652 = priv->capacity;
  D.4665 = new_capacity - D.4652;
  D.4657 = priv->element_size;
  D.4666 = D.4665 * D.4657;
  memset (D.4664, 0, D.4666);
  <D.4662>:
  priv->capacity = new_capacity;
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.4670;
  int D.4675;
  void * D.4677;
  unsigned int D.4678;

  D.4670 = __builtin_constant_p (__len);
  if (D.4670 != 0) goto <D.4671>; else goto <D.4672>;
  <D.4671>:
  if (__len == 0) goto <D.4673>; else goto <D.4674>;
  <D.4673>:
  D.4675 = __builtin_constant_p (__ch);
  if (D.4675 == 0) goto <D.4668>; else goto <D.4676>;
  <D.4676>:
  if (__ch != 0) goto <D.4668>; else goto <D.4669>;
  <D.4668>:
  __warn_memset_zero_len ();
  D.4677 = __dest;
  return D.4677;
  <D.4669>:
  <D.4674>:
  <D.4672>:
  D.4678 = __builtin_object_size (__dest, 0);
  D.4677 = __builtin___memset_chk (__dest, __ch, __len, D.4678);
  return D.4677;
}


monoeg_g_array_sized_new (gboolean zero_terminated, gboolean clear_, guint element_size, guint reserved_size)
{
  struct GArray * D.4680;
  struct GArrayPriv * rv;

  rv = monoeg_malloc0 (24);
  rv->zero_terminated = zero_terminated;
  rv->clear_ = clear_;
  rv->element_size = element_size;
  ensure_capacity (rv, reserved_size);
  D.4680 = rv;
  return D.4680;
}


monoeg_g_array_free (struct GArray * array, gboolean free_segment)
{
  gchar * D.4684;
  gchar * D.4687;
  gchar * rv;

  rv = 0B;
  if (array == 0B) goto <D.4682>; else goto <D.4683>;
  <D.4682>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "garray.c", 103, "array != NULL");
  D.4684 = 0B;
  return D.4684;
  <D.4683>:
  if (free_segment != 0) goto <D.4685>; else goto <D.4686>;
  <D.4685>:
  D.4687 = array->data;
  monoeg_g_free (D.4687);
  goto <D.4688>;
  <D.4686>:
  rv = array->data;
  <D.4688>:
  monoeg_g_free (array);
  D.4684 = rv;
  return D.4684;
}


monoeg_g_array_append_vals (struct GArray * array, const void * data, guint len)
{
  struct GArray * D.4692;
  int D.4693;
  unsigned int D.4694;
  unsigned int D.4695;
  guint iftmp.0;
  int D.4697;
  unsigned int D.4701;
  gchar * D.4702;
  unsigned int D.4703;
  unsigned int D.4704;
  void * D.4705;
  unsigned int D.4706;
  int D.4707;
  struct GArrayPriv * priv;

  priv = array;
  if (array == 0B) goto <D.4690>; else goto <D.4691>;
  <D.4690>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "garray.c", 122, "array != NULL");
  D.4692 = 0B;
  return D.4692;
  <D.4691>:
  D.4693 = priv->array.len;
  D.4694 = (unsigned int) D.4693;
  D.4695 = D.4694 + len;
  D.4697 = priv->zero_terminated;
  if (D.4697 != 0) goto <D.4698>; else goto <D.4699>;
  <D.4698>:
  iftmp.0 = 1;
  goto <D.4700>;
  <D.4699>:
  iftmp.0 = 0;
  <D.4700>:
  D.4701 = D.4695 + iftmp.0;
  ensure_capacity (priv, D.4701);
  D.4702 = priv->array.data;
  D.4693 = priv->array.len;
  D.4694 = (unsigned int) D.4693;
  D.4703 = priv->element_size;
  D.4704 = D.4694 * D.4703;
  D.4705 = D.4702 + D.4704;
  D.4703 = priv->element_size;
  D.4706 = D.4703 * len;
  memmove (D.4705, data, D.4706);
  D.4693 = priv->array.len;
  D.4694 = (unsigned int) D.4693;
  D.4695 = D.4694 + len;
  D.4707 = (int) D.4695;
  priv->array.len = D.4707;
  D.4697 = priv->zero_terminated;
  if (D.4697 != 0) goto <D.4708>; else goto <D.4709>;
  <D.4708>:
  D.4702 = priv->array.data;
  D.4693 = priv->array.len;
  D.4694 = (unsigned int) D.4693;
  D.4703 = priv->element_size;
  D.4704 = D.4694 * D.4703;
  D.4705 = D.4702 + D.4704;
  D.4703 = priv->element_size;
  memset (D.4705, 0, D.4703);
  <D.4709>:
  D.4692 = array;
  return D.4692;
}


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

  D.4712 = __builtin_object_size (__dest, 0);
  D.4711 = __builtin___memmove_chk (__dest, __src, __len, D.4712);
  return D.4711;
}


monoeg_g_array_insert_vals (struct GArray * array, guint index_, const void * data, guint len)
{
  int D.4714;
  _Bool D.4715;
  struct GArray * D.4718;
  int D.4719;
  unsigned int D.4720;
  unsigned int D.4721;
  unsigned int D.4722;
  gchar * D.4723;
  unsigned int D.4724;
  unsigned int D.4725;
  unsigned int D.4726;
  void * D.4727;
  unsigned int D.4728;
  const void * D.4729;
  unsigned int D.4730;
  unsigned int D.4731;
  void * D.4732;
  unsigned int D.4733;
  int D.4734;
  int D.4737;
  unsigned int D.4738;
  unsigned int D.4739;
  void * D.4740;
  struct GArrayPriv * priv;
  guint extra;

  priv = array;
  D.4714 = priv->zero_terminated;
  D.4715 = D.4714 != 0;
  extra = (guint) D.4715;
  if (array == 0B) goto <D.4716>; else goto <D.4717>;
  <D.4716>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "garray.c", 150, "array != NULL");
  D.4718 = 0B;
  return D.4718;
  <D.4717>:
  D.4719 = array->len;
  D.4720 = (unsigned int) D.4719;
  D.4721 = D.4720 + len;
  D.4722 = D.4721 + extra;
  ensure_capacity (priv, D.4722);
  D.4723 = priv->array.data;
  D.4724 = index_ + len;
  D.4725 = priv->element_size;
  D.4726 = D.4724 * D.4725;
  D.4727 = D.4723 + D.4726;
  D.4723 = priv->array.data;
  D.4725 = priv->element_size;
  D.4728 = D.4725 * index_;
  D.4729 = D.4723 + D.4728;
  D.4719 = array->len;
  D.4720 = (unsigned int) D.4719;
  D.4730 = D.4720 - index_;
  D.4725 = priv->element_size;
  D.4731 = D.4730 * D.4725;
  memmove (D.4727, D.4729, D.4731);
  D.4723 = priv->array.data;
  D.4725 = priv->element_size;
  D.4728 = D.4725 * index_;
  D.4732 = D.4723 + D.4728;
  D.4725 = priv->element_size;
  D.4733 = D.4725 * len;
  memmove (D.4732, data, D.4733);
  D.4719 = array->len;
  D.4720 = (unsigned int) D.4719;
  D.4721 = D.4720 + len;
  D.4734 = (int) D.4721;
  array->len = D.4734;
  D.4714 = priv->zero_terminated;
  if (D.4714 != 0) goto <D.4735>; else goto <D.4736>;
  <D.4735>:
  D.4723 = priv->array.data;
  D.4737 = priv->array.len;
  D.4738 = (unsigned int) D.4737;
  D.4725 = priv->element_size;
  D.4739 = D.4738 * D.4725;
  D.4740 = D.4723 + D.4739;
  D.4725 = priv->element_size;
  memset (D.4740, 0, D.4725);
  <D.4736>:
  D.4718 = array;
  return D.4718;
}


monoeg_g_array_remove_index (struct GArray * array, guint index_)
{
  struct GArray * D.4744;
  gchar * D.4745;
  unsigned int D.4746;
  unsigned int D.4747;
  void * D.4748;
  unsigned int D.4749;
  unsigned int D.4750;
  const void * D.4751;
  int D.4752;
  unsigned int D.4753;
  unsigned int D.4754;
  unsigned int D.4755;
  int D.4756;
  int D.4757;
  int D.4760;
  unsigned int D.4761;
  unsigned int D.4762;
  void * D.4763;
  struct GArrayPriv * priv;

  priv = array;
  if (array == 0B) goto <D.4742>; else goto <D.4743>;
  <D.4742>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "garray.c", 181, "array != NULL");
  D.4744 = 0B;
  return D.4744;
  <D.4743>:
  D.4745 = priv->array.data;
  D.4746 = priv->element_size;
  D.4747 = D.4746 * index_;
  D.4748 = D.4745 + D.4747;
  D.4745 = priv->array.data;
  D.4749 = index_ + 1;
  D.4746 = priv->element_size;
  D.4750 = D.4749 * D.4746;
  D.4751 = D.4745 + D.4750;
  D.4752 = array->len;
  D.4753 = (unsigned int) D.4752;
  D.4754 = D.4753 - index_;
  D.4746 = priv->element_size;
  D.4755 = D.4754 * D.4746;
  memmove (D.4748, D.4751, D.4755);
  D.4752 = array->len;
  D.4756 = D.4752 + -1;
  array->len = D.4756;
  D.4757 = priv->zero_terminated;
  if (D.4757 != 0) goto <D.4758>; else goto <D.4759>;
  <D.4758>:
  D.4745 = priv->array.data;
  D.4760 = priv->array.len;
  D.4761 = (unsigned int) D.4760;
  D.4746 = priv->element_size;
  D.4762 = D.4761 * D.4746;
  D.4763 = D.4745 + D.4762;
  D.4746 = priv->element_size;
  memset (D.4763, 0, D.4746);
  <D.4759>:
  D.4744 = array;
  return D.4744;
}


monoeg_g_array_remove_index_fast (struct GArray * array, guint index_)
{
  struct GArray * D.4767;
  gchar * D.4768;
  unsigned int D.4769;
  unsigned int D.4770;
  void * D.4771;
  int D.4772;
  int D.4773;
  unsigned int D.4774;
  unsigned int D.4775;
  const void * D.4776;
  int D.4777;
  int D.4778;
  int D.4781;
  unsigned int D.4782;
  unsigned int D.4783;
  void * D.4784;
  struct GArrayPriv * priv;

  priv = array;
  if (array == 0B) goto <D.4765>; else goto <D.4766>;
  <D.4765>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "garray.c", 204, "array != NULL");
  D.4767 = 0B;
  return D.4767;
  <D.4766>:
  D.4768 = priv->array.data;
  D.4769 = priv->element_size;
  D.4770 = D.4769 * index_;
  D.4771 = D.4768 + D.4770;
  D.4768 = priv->array.data;
  D.4772 = array->len;
  D.4773 = D.4772 + -1;
  D.4774 = (unsigned int) D.4773;
  D.4769 = priv->element_size;
  D.4775 = D.4774 * D.4769;
  D.4776 = D.4768 + D.4775;
  D.4769 = priv->element_size;
  memmove (D.4771, D.4776, D.4769);
  D.4772 = array->len;
  D.4777 = D.4772 + -1;
  array->len = D.4777;
  D.4778 = priv->zero_terminated;
  if (D.4778 != 0) goto <D.4779>; else goto <D.4780>;
  <D.4779>:
  D.4768 = priv->array.data;
  D.4781 = priv->array.len;
  D.4782 = (unsigned int) D.4781;
  D.4769 = priv->element_size;
  D.4783 = D.4782 * D.4769;
  D.4784 = D.4768 + D.4783;
  D.4769 = priv->element_size;
  memset (D.4784, 0, D.4769);
  <D.4780>:
  D.4767 = array;
  return D.4767;
}


monoeg_g_array_set_size (struct GArray * array, gint length)
{
  unsigned int length.1;
  unsigned int D.4791;
  struct GArrayPriv * priv;

  priv = array;
  if (array == 0B) goto <D.4786>; else goto <D.4787>;
  <D.4786>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "garray.c", 226, "array != NULL");
  return;
  <D.4787>:
  if (length < 0) goto <D.4788>; else goto <D.4789>;
  <D.4788>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "garray.c", 227, "length >= 0");
  return;
  <D.4789>:
  length.1 = (unsigned int) length;
  D.4791 = priv->capacity;
  if (length.1 == D.4791) goto <D.4792>; else goto <D.4793>;
  <D.4792>:
  return;
  <D.4793>:
  length.1 = (unsigned int) length;
  D.4791 = priv->capacity;
  if (length.1 > D.4791) goto <D.4794>; else goto <D.4795>;
  <D.4794>:
  length.1 = (unsigned int) length;
  ensure_capacity (priv, length.1);
  <D.4795>:
  array->len = length;
}