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

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


ensure_capacity (struct GArrayPriv * priv, guint capacity)
{
  unsigned int D.5085;
  unsigned int D.5088;
  gchar * D.5089;
  unsigned int D.5090;
  unsigned int D.5091;
  long unsigned int D.5092;
  void * D.5093;
  int D.5094;
  unsigned int D.5097;
  sizetype D.5098;
  gchar * D.5099;
  unsigned int D.5100;
  unsigned int D.5101;
  long unsigned int D.5102;
  guint new_capacity;

  D.5085 = priv->capacity;
  if (D.5085 >= capacity) goto <D.5086>; else goto <D.5087>;
  <D.5086>:
  return;
  <D.5087>:
  D.5088 = capacity + 63;
  new_capacity = D.5088 & 4294967232;
  D.5089 = priv->array.data;
  D.5090 = priv->element_size;
  D.5091 = D.5090 * new_capacity;
  D.5092 = (long unsigned int) D.5091;
  D.5093 = monoeg_realloc (D.5089, D.5092);
  priv->array.data = D.5093;
  D.5094 = priv->clear_;
  if (D.5094 != 0) goto <D.5095>; else goto <D.5096>;
  <D.5095>:
  D.5089 = priv->array.data;
  D.5085 = priv->capacity;
  D.5090 = priv->element_size;
  D.5097 = D.5085 * D.5090;
  D.5098 = (sizetype) D.5097;
  D.5099 = D.5089 + D.5098;
  D.5085 = priv->capacity;
  D.5100 = new_capacity - D.5085;
  D.5090 = priv->element_size;
  D.5101 = D.5100 * D.5090;
  D.5102 = (long unsigned int) D.5101;
  memset (D.5099, 0, D.5102);
  <D.5096>:
  priv->capacity = new_capacity;
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__, __nothrow__, __leaf__))
memset (void * __dest, int __ch, size_t __len)
{
  void * D.5104;
  long unsigned int D.5105;

  D.5105 = __builtin_object_size (__dest, 0);
  D.5104 = __builtin___memset_chk (__dest, __ch, __len, D.5105);
  return D.5104;
}


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

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


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

  rv = 0B;
  if (array == 0B) goto <D.5109>; else goto <D.5110>;
  <D.5109>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "garray.c", 103, "array != NULL");
  D.5111 = 0B;
  return D.5111;
  <D.5110>:
  if (free_segment != 0) goto <D.5112>; else goto <D.5113>;
  <D.5112>:
  D.5114 = array->data;
  monoeg_g_free (D.5114);
  goto <D.5115>;
  <D.5113>:
  rv = array->data;
  <D.5115>:
  monoeg_g_free (array);
  D.5111 = rv;
  return D.5111;
}


monoeg_g_array_append_vals (struct GArray * array, const void * data, guint len)
{
  struct GArray * D.5119;
  int D.5120;
  unsigned int D.5121;
  unsigned int D.5122;
  guint iftmp.0;
  int D.5124;
  unsigned int D.5128;
  gchar * D.5129;
  unsigned int D.5130;
  unsigned int D.5131;
  sizetype D.5132;
  gchar * D.5133;
  unsigned int D.5134;
  long unsigned int D.5135;
  int D.5136;
  long unsigned int D.5139;
  struct GArrayPriv * priv;

  priv = array;
  if (array == 0B) goto <D.5117>; else goto <D.5118>;
  <D.5117>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "garray.c", 122, "array != NULL");
  D.5119 = 0B;
  return D.5119;
  <D.5118>:
  D.5120 = priv->array.len;
  D.5121 = (unsigned int) D.5120;
  D.5122 = D.5121 + len;
  D.5124 = priv->zero_terminated;
  if (D.5124 != 0) goto <D.5125>; else goto <D.5126>;
  <D.5125>:
  iftmp.0 = 1;
  goto <D.5127>;
  <D.5126>:
  iftmp.0 = 0;
  <D.5127>:
  D.5128 = D.5122 + iftmp.0;
  ensure_capacity (priv, D.5128);
  D.5129 = priv->array.data;
  D.5120 = priv->array.len;
  D.5121 = (unsigned int) D.5120;
  D.5130 = priv->element_size;
  D.5131 = D.5121 * D.5130;
  D.5132 = (sizetype) D.5131;
  D.5133 = D.5129 + D.5132;
  D.5130 = priv->element_size;
  D.5134 = D.5130 * len;
  D.5135 = (long unsigned int) D.5134;
  memmove (D.5133, data, D.5135);
  D.5120 = priv->array.len;
  D.5121 = (unsigned int) D.5120;
  D.5122 = D.5121 + len;
  D.5136 = (int) D.5122;
  priv->array.len = D.5136;
  D.5124 = priv->zero_terminated;
  if (D.5124 != 0) goto <D.5137>; else goto <D.5138>;
  <D.5137>:
  D.5129 = priv->array.data;
  D.5120 = priv->array.len;
  D.5121 = (unsigned int) D.5120;
  D.5130 = priv->element_size;
  D.5131 = D.5121 * D.5130;
  D.5132 = (sizetype) D.5131;
  D.5133 = D.5129 + D.5132;
  D.5130 = priv->element_size;
  D.5139 = (long unsigned int) D.5130;
  memset (D.5133, 0, D.5139);
  <D.5138>:
  D.5119 = array;
  return D.5119;
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__, __nothrow__, __leaf__))
memmove (void * __dest, const void * __src, size_t __len)
{
  void * D.5141;
  long unsigned int D.5142;

  D.5142 = __builtin_object_size (__dest, 0);
  D.5141 = __builtin___memmove_chk (__dest, __src, __len, D.5142);
  return D.5141;
}


monoeg_g_array_insert_vals (struct GArray * array, guint index_, const void * data, guint len)
{
  int D.5144;
  _Bool D.5145;
  struct GArray * D.5148;
  int D.5149;
  unsigned int D.5150;
  unsigned int D.5151;
  unsigned int D.5152;
  gchar * D.5153;
  unsigned int D.5154;
  unsigned int D.5155;
  unsigned int D.5156;
  sizetype D.5157;
  gchar * D.5158;
  unsigned int D.5159;
  sizetype D.5160;
  gchar * D.5161;
  unsigned int D.5162;
  unsigned int D.5163;
  long unsigned int D.5164;
  unsigned int D.5165;
  long unsigned int D.5166;
  int D.5167;
  int D.5170;
  unsigned int D.5171;
  unsigned int D.5172;
  sizetype D.5173;
  gchar * D.5174;
  long unsigned int D.5175;
  struct GArrayPriv * priv;
  guint extra;

  priv = array;
  D.5144 = priv->zero_terminated;
  D.5145 = D.5144 != 0;
  extra = (guint) D.5145;
  if (array == 0B) goto <D.5146>; else goto <D.5147>;
  <D.5146>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "garray.c", 150, "array != NULL");
  D.5148 = 0B;
  return D.5148;
  <D.5147>:
  D.5149 = array->len;
  D.5150 = (unsigned int) D.5149;
  D.5151 = D.5150 + len;
  D.5152 = D.5151 + extra;
  ensure_capacity (priv, D.5152);
  D.5153 = priv->array.data;
  D.5154 = index_ + len;
  D.5155 = priv->element_size;
  D.5156 = D.5154 * D.5155;
  D.5157 = (sizetype) D.5156;
  D.5158 = D.5153 + D.5157;
  D.5153 = priv->array.data;
  D.5155 = priv->element_size;
  D.5159 = D.5155 * index_;
  D.5160 = (sizetype) D.5159;
  D.5161 = D.5153 + D.5160;
  D.5149 = array->len;
  D.5150 = (unsigned int) D.5149;
  D.5162 = D.5150 - index_;
  D.5155 = priv->element_size;
  D.5163 = D.5162 * D.5155;
  D.5164 = (long unsigned int) D.5163;
  memmove (D.5158, D.5161, D.5164);
  D.5153 = priv->array.data;
  D.5155 = priv->element_size;
  D.5159 = D.5155 * index_;
  D.5160 = (sizetype) D.5159;
  D.5161 = D.5153 + D.5160;
  D.5155 = priv->element_size;
  D.5165 = D.5155 * len;
  D.5166 = (long unsigned int) D.5165;
  memmove (D.5161, data, D.5166);
  D.5149 = array->len;
  D.5150 = (unsigned int) D.5149;
  D.5151 = D.5150 + len;
  D.5167 = (int) D.5151;
  array->len = D.5167;
  D.5144 = priv->zero_terminated;
  if (D.5144 != 0) goto <D.5168>; else goto <D.5169>;
  <D.5168>:
  D.5153 = priv->array.data;
  D.5170 = priv->array.len;
  D.5171 = (unsigned int) D.5170;
  D.5155 = priv->element_size;
  D.5172 = D.5171 * D.5155;
  D.5173 = (sizetype) D.5172;
  D.5174 = D.5153 + D.5173;
  D.5155 = priv->element_size;
  D.5175 = (long unsigned int) D.5155;
  memset (D.5174, 0, D.5175);
  <D.5169>:
  D.5148 = array;
  return D.5148;
}


monoeg_g_array_remove_index (struct GArray * array, guint index_)
{
  struct GArray * D.5179;
  gchar * D.5180;
  unsigned int D.5181;
  unsigned int D.5182;
  sizetype D.5183;
  gchar * D.5184;
  unsigned int D.5185;
  unsigned int D.5186;
  sizetype D.5187;
  gchar * D.5188;
  int D.5189;
  unsigned int D.5190;
  unsigned int D.5191;
  unsigned int D.5192;
  long unsigned int D.5193;
  int D.5194;
  int D.5195;
  int D.5198;
  unsigned int D.5199;
  unsigned int D.5200;
  sizetype D.5201;
  gchar * D.5202;
  long unsigned int D.5203;
  struct GArrayPriv * priv;

  priv = array;
  if (array == 0B) goto <D.5177>; else goto <D.5178>;
  <D.5177>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "garray.c", 181, "array != NULL");
  D.5179 = 0B;
  return D.5179;
  <D.5178>:
  D.5180 = priv->array.data;
  D.5181 = priv->element_size;
  D.5182 = D.5181 * index_;
  D.5183 = (sizetype) D.5182;
  D.5184 = D.5180 + D.5183;
  D.5180 = priv->array.data;
  D.5185 = index_ + 1;
  D.5181 = priv->element_size;
  D.5186 = D.5185 * D.5181;
  D.5187 = (sizetype) D.5186;
  D.5188 = D.5180 + D.5187;
  D.5189 = array->len;
  D.5190 = (unsigned int) D.5189;
  D.5191 = D.5190 - index_;
  D.5181 = priv->element_size;
  D.5192 = D.5191 * D.5181;
  D.5193 = (long unsigned int) D.5192;
  memmove (D.5184, D.5188, D.5193);
  D.5189 = array->len;
  D.5194 = D.5189 + -1;
  array->len = D.5194;
  D.5195 = priv->zero_terminated;
  if (D.5195 != 0) goto <D.5196>; else goto <D.5197>;
  <D.5196>:
  D.5180 = priv->array.data;
  D.5198 = priv->array.len;
  D.5199 = (unsigned int) D.5198;
  D.5181 = priv->element_size;
  D.5200 = D.5199 * D.5181;
  D.5201 = (sizetype) D.5200;
  D.5202 = D.5180 + D.5201;
  D.5181 = priv->element_size;
  D.5203 = (long unsigned int) D.5181;
  memset (D.5202, 0, D.5203);
  <D.5197>:
  D.5179 = array;
  return D.5179;
}


monoeg_g_array_remove_index_fast (struct GArray * array, guint index_)
{
  struct GArray * D.5207;
  gchar * D.5208;
  unsigned int D.5209;
  unsigned int D.5210;
  sizetype D.5211;
  gchar * D.5212;
  int D.5213;
  int D.5214;
  unsigned int D.5215;
  unsigned int D.5216;
  sizetype D.5217;
  gchar * D.5218;
  long unsigned int D.5219;
  int D.5220;
  int D.5221;
  int D.5224;
  unsigned int D.5225;
  unsigned int D.5226;
  sizetype D.5227;
  gchar * D.5228;
  struct GArrayPriv * priv;

  priv = array;
  if (array == 0B) goto <D.5205>; else goto <D.5206>;
  <D.5205>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "garray.c", 204, "array != NULL");
  D.5207 = 0B;
  return D.5207;
  <D.5206>:
  D.5208 = priv->array.data;
  D.5209 = priv->element_size;
  D.5210 = D.5209 * index_;
  D.5211 = (sizetype) D.5210;
  D.5212 = D.5208 + D.5211;
  D.5208 = priv->array.data;
  D.5213 = array->len;
  D.5214 = D.5213 + -1;
  D.5215 = (unsigned int) D.5214;
  D.5209 = priv->element_size;
  D.5216 = D.5215 * D.5209;
  D.5217 = (sizetype) D.5216;
  D.5218 = D.5208 + D.5217;
  D.5209 = priv->element_size;
  D.5219 = (long unsigned int) D.5209;
  memmove (D.5212, D.5218, D.5219);
  D.5213 = array->len;
  D.5220 = D.5213 + -1;
  array->len = D.5220;
  D.5221 = priv->zero_terminated;
  if (D.5221 != 0) goto <D.5222>; else goto <D.5223>;
  <D.5222>:
  D.5208 = priv->array.data;
  D.5224 = priv->array.len;
  D.5225 = (unsigned int) D.5224;
  D.5209 = priv->element_size;
  D.5226 = D.5225 * D.5209;
  D.5227 = (sizetype) D.5226;
  D.5228 = D.5208 + D.5227;
  D.5209 = priv->element_size;
  D.5219 = (long unsigned int) D.5209;
  memset (D.5228, 0, D.5219);
  <D.5223>:
  D.5207 = array;
  return D.5207;
}


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

  priv = array;
  if (array == 0B) goto <D.5230>; else goto <D.5231>;
  <D.5230>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "garray.c", 226, "array != NULL");
  return;
  <D.5231>:
  if (length < 0) goto <D.5232>; else goto <D.5233>;
  <D.5232>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "garray.c", 227, "length >= 0");
  return;
  <D.5233>:
  D.5234 = priv->capacity;
  length.1 = (unsigned int) length;
  if (D.5234 == length.1) goto <D.5236>; else goto <D.5237>;
  <D.5236>:
  return;
  <D.5237>:
  D.5234 = priv->capacity;
  length.1 = (unsigned int) length;
  if (D.5234 < length.1) goto <D.5238>; else goto <D.5239>;
  <D.5238>:
  length.1 = (unsigned int) length;
  ensure_capacity (priv, length.1);
  <D.5239>:
  array->len = length;
}