monoeg_g_array_new (gboolean zero_terminated, gboolean clear_, guint element_size)
{
  struct GArray * D.4630;
  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.4630 = rv;
  return D.4630;
}


ensure_capacity (struct GArrayPriv * priv, guint capacity)
{
  unsigned int D.4632;
  unsigned int D.4635;
  unsigned int D.4636;
  unsigned int D.4637;
  gchar * D.4638;
  void * D.4639;
  int D.4640;
  unsigned int D.4643;
  unsigned int D.4644;
  unsigned int D.4645;
  void * D.4646;
  guint new_capacity;

  D.4632 = priv->capacity;
  if (D.4632 >= capacity) goto <D.4633>; else goto <D.4634>;
  <D.4633>:
  return;
  <D.4634>:
  D.4635 = capacity + 63;
  new_capacity = D.4635 & 4294967232;
  D.4636 = priv->element_size;
  D.4637 = D.4636 * new_capacity;
  D.4638 = priv->array.data;
  D.4639 = monoeg_realloc (D.4638, D.4637);
  priv->array.data = D.4639;
  D.4640 = priv->clear_;
  if (D.4640 != 0) goto <D.4641>; else goto <D.4642>;
  <D.4641>:
  D.4632 = priv->capacity;
  D.4643 = new_capacity - D.4632;
  D.4636 = priv->element_size;
  D.4644 = D.4643 * D.4636;
  D.4638 = priv->array.data;
  D.4632 = priv->capacity;
  D.4636 = priv->element_size;
  D.4645 = D.4632 * D.4636;
  D.4646 = D.4638 + D.4645;
  memset (D.4646, 0, D.4644);
  <D.4642>:
  priv->capacity = new_capacity;
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.4650;
  int D.4655;
  void * D.4657;
  unsigned int D.4658;

  D.4650 = __builtin_constant_p (__len);
  if (D.4650 != 0) goto <D.4651>; else goto <D.4652>;
  <D.4651>:
  if (__len == 0) goto <D.4653>; else goto <D.4654>;
  <D.4653>:
  D.4655 = __builtin_constant_p (__ch);
  if (D.4655 == 0) goto <D.4648>; else goto <D.4656>;
  <D.4656>:
  if (__ch != 0) goto <D.4648>; else goto <D.4649>;
  <D.4648>:
  __warn_memset_zero_len ();
  D.4657 = __dest;
  return D.4657;
  <D.4649>:
  <D.4654>:
  <D.4652>:
  D.4658 = __builtin_object_size (__dest, 0);
  D.4657 = __builtin___memset_chk (__dest, __ch, __len, D.4658);
  return D.4657;
}


monoeg_g_array_sized_new (gboolean zero_terminated, gboolean clear_, guint element_size, guint reserved_size)
{
  struct GArray * D.4660;
  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.4660 = rv;
  return D.4660;
}


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

  rv = 0B;
  if (array == 0B) goto <D.4662>; else goto <D.4663>;
  <D.4662>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "garray.c", 103, "array != NULL");
  D.4664 = 0B;
  return D.4664;
  <D.4663>:
  if (free_segment != 0) goto <D.4665>; else goto <D.4666>;
  <D.4665>:
  D.4667 = array->data;
  monoeg_g_free (D.4667);
  goto <D.4668>;
  <D.4666>:
  rv = array->data;
  <D.4668>:
  monoeg_g_free (array);
  D.4664 = rv;
  return D.4664;
}


monoeg_g_array_append_vals (struct GArray * array, const void * data, guint len)
{
  struct GArray * D.4672;
  int D.4673;
  unsigned int D.4674;
  unsigned int D.4675;
  guint iftmp.0;
  int D.4677;
  unsigned int D.4681;
  unsigned int D.4682;
  unsigned int D.4683;
  gchar * D.4684;
  unsigned int D.4685;
  void * D.4686;
  int D.4687;
  struct GArrayPriv * priv;

  priv = array;
  if (array == 0B) goto <D.4670>; else goto <D.4671>;
  <D.4670>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "garray.c", 122, "array != NULL");
  D.4672 = 0B;
  return D.4672;
  <D.4671>:
  D.4673 = priv->array.len;
  D.4674 = (unsigned int) D.4673;
  D.4675 = D.4674 + len;
  D.4677 = priv->zero_terminated;
  if (D.4677 != 0) goto <D.4678>; else goto <D.4679>;
  <D.4678>:
  iftmp.0 = 1;
  goto <D.4680>;
  <D.4679>:
  iftmp.0 = 0;
  <D.4680>:
  D.4681 = D.4675 + iftmp.0;
  ensure_capacity (priv, D.4681);
  D.4682 = priv->element_size;
  D.4683 = D.4682 * len;
  D.4684 = priv->array.data;
  D.4673 = priv->array.len;
  D.4674 = (unsigned int) D.4673;
  D.4682 = priv->element_size;
  D.4685 = D.4674 * D.4682;
  D.4686 = D.4684 + D.4685;
  memmove (D.4686, data, D.4683);
  D.4673 = priv->array.len;
  D.4674 = (unsigned int) D.4673;
  D.4675 = D.4674 + len;
  D.4687 = (int) D.4675;
  priv->array.len = D.4687;
  D.4677 = priv->zero_terminated;
  if (D.4677 != 0) goto <D.4688>; else goto <D.4689>;
  <D.4688>:
  D.4682 = priv->element_size;
  D.4684 = priv->array.data;
  D.4673 = priv->array.len;
  D.4674 = (unsigned int) D.4673;
  D.4682 = priv->element_size;
  D.4685 = D.4674 * D.4682;
  D.4686 = D.4684 + D.4685;
  memset (D.4686, 0, D.4682);
  <D.4689>:
  D.4672 = array;
  return D.4672;
}


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

  D.4692 = __builtin_object_size (__dest, 0);
  D.4691 = __builtin___memmove_chk (__dest, __src, __len, D.4692);
  return D.4691;
}


monoeg_g_array_insert_vals (struct GArray * array, guint index_, const void * data, guint len)
{
  int D.4694;
  _Bool D.4695;
  struct GArray * D.4698;
  int D.4699;
  unsigned int D.4700;
  unsigned int D.4701;
  unsigned int D.4702;
  unsigned int D.4703;
  unsigned int D.4704;
  unsigned int D.4705;
  gchar * D.4706;
  unsigned int D.4707;
  const void * D.4708;
  unsigned int D.4709;
  unsigned int D.4710;
  void * D.4711;
  unsigned int D.4712;
  void * D.4713;
  int D.4714;
  int D.4717;
  unsigned int D.4718;
  unsigned int D.4719;
  void * D.4720;
  struct GArrayPriv * priv;
  guint extra;

  priv = array;
  D.4694 = priv->zero_terminated;
  D.4695 = D.4694 != 0;
  extra = (guint) D.4695;
  if (array == 0B) goto <D.4696>; else goto <D.4697>;
  <D.4696>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "garray.c", 150, "array != NULL");
  D.4698 = 0B;
  return D.4698;
  <D.4697>:
  D.4699 = array->len;
  D.4700 = (unsigned int) D.4699;
  D.4701 = D.4700 + len;
  D.4702 = D.4701 + extra;
  ensure_capacity (priv, D.4702);
  D.4699 = array->len;
  D.4700 = (unsigned int) D.4699;
  D.4703 = D.4700 - index_;
  D.4704 = priv->element_size;
  D.4705 = D.4703 * D.4704;
  D.4706 = priv->array.data;
  D.4704 = priv->element_size;
  D.4707 = D.4704 * index_;
  D.4708 = D.4706 + D.4707;
  D.4706 = priv->array.data;
  D.4709 = index_ + len;
  D.4704 = priv->element_size;
  D.4710 = D.4709 * D.4704;
  D.4711 = D.4706 + D.4710;
  memmove (D.4711, D.4708, D.4705);
  D.4704 = priv->element_size;
  D.4712 = D.4704 * len;
  D.4706 = priv->array.data;
  D.4704 = priv->element_size;
  D.4707 = D.4704 * index_;
  D.4713 = D.4706 + D.4707;
  memmove (D.4713, data, D.4712);
  D.4699 = array->len;
  D.4700 = (unsigned int) D.4699;
  D.4701 = D.4700 + len;
  D.4714 = (int) D.4701;
  array->len = D.4714;
  D.4694 = priv->zero_terminated;
  if (D.4694 != 0) goto <D.4715>; else goto <D.4716>;
  <D.4715>:
  D.4704 = priv->element_size;
  D.4706 = priv->array.data;
  D.4717 = priv->array.len;
  D.4718 = (unsigned int) D.4717;
  D.4704 = priv->element_size;
  D.4719 = D.4718 * D.4704;
  D.4720 = D.4706 + D.4719;
  memset (D.4720, 0, D.4704);
  <D.4716>:
  D.4698 = array;
  return D.4698;
}


monoeg_g_array_remove_index (struct GArray * array, guint index_)
{
  struct GArray * D.4724;
  int D.4725;
  unsigned int D.4726;
  unsigned int D.4727;
  unsigned int D.4728;
  unsigned int D.4729;
  gchar * D.4730;
  unsigned int D.4731;
  unsigned int D.4732;
  const void * D.4733;
  unsigned int D.4734;
  void * D.4735;
  int D.4736;
  int D.4737;
  int D.4740;
  unsigned int D.4741;
  unsigned int D.4742;
  void * D.4743;
  struct GArrayPriv * priv;

  priv = array;
  if (array == 0B) goto <D.4722>; else goto <D.4723>;
  <D.4722>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "garray.c", 181, "array != NULL");
  D.4724 = 0B;
  return D.4724;
  <D.4723>:
  D.4725 = array->len;
  D.4726 = (unsigned int) D.4725;
  D.4727 = D.4726 - index_;
  D.4728 = priv->element_size;
  D.4729 = D.4727 * D.4728;
  D.4730 = priv->array.data;
  D.4731 = index_ + 1;
  D.4728 = priv->element_size;
  D.4732 = D.4731 * D.4728;
  D.4733 = D.4730 + D.4732;
  D.4730 = priv->array.data;
  D.4728 = priv->element_size;
  D.4734 = D.4728 * index_;
  D.4735 = D.4730 + D.4734;
  memmove (D.4735, D.4733, D.4729);
  D.4725 = array->len;
  D.4736 = D.4725 + -1;
  array->len = D.4736;
  D.4737 = priv->zero_terminated;
  if (D.4737 != 0) goto <D.4738>; else goto <D.4739>;
  <D.4738>:
  D.4728 = priv->element_size;
  D.4730 = priv->array.data;
  D.4740 = priv->array.len;
  D.4741 = (unsigned int) D.4740;
  D.4728 = priv->element_size;
  D.4742 = D.4741 * D.4728;
  D.4743 = D.4730 + D.4742;
  memset (D.4743, 0, D.4728);
  <D.4739>:
  D.4724 = array;
  return D.4724;
}


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

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


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

  priv = array;
  if (array == 0B) goto <D.4766>; else goto <D.4767>;
  <D.4766>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "garray.c", 226, "array != NULL");
  return;
  <D.4767>:
  if (length < 0) goto <D.4768>; else goto <D.4769>;
  <D.4768>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "garray.c", 227, "length >= 0");
  return;
  <D.4769>:
  length.1 = (unsigned int) length;
  D.4771 = priv->capacity;
  if (length.1 == D.4771) goto <D.4772>; else goto <D.4773>;
  <D.4772>:
  return;
  <D.4773>:
  length.1 = (unsigned int) length;
  D.4771 = priv->capacity;
  if (length.1 > D.4771) goto <D.4774>; else goto <D.4775>;
  <D.4774>:
  length.1 = (unsigned int) length;
  ensure_capacity (priv, length.1);
  <D.4775>:
  array->len = length;
}