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


ensure_capacity (struct GArrayPriv * priv, guint capacity)
{
  unsigned int D.7241;
  unsigned int D.7244;
  gchar * D.7245;
  unsigned int D.7246;
  unsigned int D.7247;
  void * D.7248;
  int D.7249;
  unsigned int D.7252;
  void * D.7253;
  unsigned int D.7254;
  unsigned int D.7255;
  guint new_capacity;

  D.7241 = priv->capacity;
  if (D.7241 >= capacity) goto <D.7242>; else goto <D.7243>;
  <D.7242>:
  return;
  <D.7243>:
  D.7244 = capacity + 63;
  new_capacity = D.7244 & 4294967232;
  D.7245 = priv->array.data;
  D.7246 = priv->element_size;
  D.7247 = D.7246 * new_capacity;
  D.7248 = monoeg_realloc (D.7245, D.7247);
  priv->array.data = D.7248;
  D.7249 = priv->clear_;
  if (D.7249 != 0) goto <D.7250>; else goto <D.7251>;
  <D.7250>:
  D.7245 = priv->array.data;
  D.7241 = priv->capacity;
  D.7246 = priv->element_size;
  D.7252 = D.7241 * D.7246;
  D.7253 = D.7245 + D.7252;
  D.7241 = priv->capacity;
  D.7254 = new_capacity - D.7241;
  D.7246 = priv->element_size;
  D.7255 = D.7254 * D.7246;
  memset (D.7253, 0, D.7255);
  <D.7251>:
  priv->capacity = new_capacity;
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.7259;
  int D.7264;
  void * D.7266;
  unsigned int D.7267;

  D.7259 = __builtin_constant_p (__len);
  if (D.7259 != 0) goto <D.7260>; else goto <D.7261>;
  <D.7260>:
  if (__len == 0) goto <D.7262>; else goto <D.7263>;
  <D.7262>:
  D.7264 = __builtin_constant_p (__ch);
  if (D.7264 == 0) goto <D.7257>; else goto <D.7265>;
  <D.7265>:
  if (__ch != 0) goto <D.7257>; else goto <D.7258>;
  <D.7257>:
  __warn_memset_zero_len ();
  D.7266 = __dest;
  return D.7266;
  <D.7258>:
  <D.7263>:
  <D.7261>:
  D.7267 = __builtin_object_size (__dest, 0);
  D.7266 = __builtin___memset_chk (__dest, __ch, __len, D.7267);
  return D.7266;
}


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


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

  rv = 0B;
  if (array == 0B) goto <D.7271>; else goto <D.7272>;
  <D.7271>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "garray.c", 103, "array != NULL");
  D.7273 = 0B;
  return D.7273;
  <D.7272>:
  if (free_segment != 0) goto <D.7274>; else goto <D.7275>;
  <D.7274>:
  D.7276 = array->data;
  monoeg_g_free (D.7276);
  goto <D.7277>;
  <D.7275>:
  rv = array->data;
  <D.7277>:
  monoeg_g_free (array);
  D.7273 = rv;
  return D.7273;
}


monoeg_g_array_append_vals (struct GArray * array, const void * data, guint len)
{
  struct GArray * D.7281;
  int D.7282;
  unsigned int D.7283;
  unsigned int D.7284;
  guint iftmp.0;
  int D.7286;
  unsigned int D.7290;
  gchar * D.7291;
  unsigned int D.7292;
  unsigned int D.7293;
  void * D.7294;
  unsigned int D.7295;
  int D.7296;
  struct GArrayPriv * priv;

  priv = array;
  if (array == 0B) goto <D.7279>; else goto <D.7280>;
  <D.7279>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "garray.c", 122, "array != NULL");
  D.7281 = 0B;
  return D.7281;
  <D.7280>:
  D.7282 = priv->array.len;
  D.7283 = (unsigned int) D.7282;
  D.7284 = D.7283 + len;
  D.7286 = priv->zero_terminated;
  if (D.7286 != 0) goto <D.7287>; else goto <D.7288>;
  <D.7287>:
  iftmp.0 = 1;
  goto <D.7289>;
  <D.7288>:
  iftmp.0 = 0;
  <D.7289>:
  D.7290 = D.7284 + iftmp.0;
  ensure_capacity (priv, D.7290);
  D.7291 = priv->array.data;
  D.7282 = priv->array.len;
  D.7283 = (unsigned int) D.7282;
  D.7292 = priv->element_size;
  D.7293 = D.7283 * D.7292;
  D.7294 = D.7291 + D.7293;
  D.7292 = priv->element_size;
  D.7295 = D.7292 * len;
  memmove (D.7294, data, D.7295);
  D.7282 = priv->array.len;
  D.7283 = (unsigned int) D.7282;
  D.7284 = D.7283 + len;
  D.7296 = (int) D.7284;
  priv->array.len = D.7296;
  D.7286 = priv->zero_terminated;
  if (D.7286 != 0) goto <D.7297>; else goto <D.7298>;
  <D.7297>:
  D.7291 = priv->array.data;
  D.7282 = priv->array.len;
  D.7283 = (unsigned int) D.7282;
  D.7292 = priv->element_size;
  D.7293 = D.7283 * D.7292;
  D.7294 = D.7291 + D.7293;
  D.7292 = priv->element_size;
  memset (D.7294, 0, D.7292);
  <D.7298>:
  D.7281 = array;
  return D.7281;
}


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

  D.7301 = __builtin_object_size (__dest, 0);
  D.7300 = __builtin___memmove_chk (__dest, __src, __len, D.7301);
  return D.7300;
}


monoeg_g_array_insert_vals (struct GArray * array, guint index_, const void * data, guint len)
{
  int D.7303;
  _Bool D.7304;
  struct GArray * D.7307;
  int D.7308;
  unsigned int D.7309;
  unsigned int D.7310;
  unsigned int D.7311;
  gchar * D.7312;
  unsigned int D.7313;
  unsigned int D.7314;
  unsigned int D.7315;
  void * D.7316;
  unsigned int D.7317;
  const void * D.7318;
  unsigned int D.7319;
  unsigned int D.7320;
  void * D.7321;
  unsigned int D.7322;
  int D.7323;
  int D.7326;
  unsigned int D.7327;
  unsigned int D.7328;
  void * D.7329;
  struct GArrayPriv * priv;
  guint extra;

  priv = array;
  D.7303 = priv->zero_terminated;
  D.7304 = D.7303 != 0;
  extra = (guint) D.7304;
  if (array == 0B) goto <D.7305>; else goto <D.7306>;
  <D.7305>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "garray.c", 150, "array != NULL");
  D.7307 = 0B;
  return D.7307;
  <D.7306>:
  D.7308 = array->len;
  D.7309 = (unsigned int) D.7308;
  D.7310 = D.7309 + len;
  D.7311 = D.7310 + extra;
  ensure_capacity (priv, D.7311);
  D.7312 = priv->array.data;
  D.7313 = index_ + len;
  D.7314 = priv->element_size;
  D.7315 = D.7313 * D.7314;
  D.7316 = D.7312 + D.7315;
  D.7312 = priv->array.data;
  D.7314 = priv->element_size;
  D.7317 = D.7314 * index_;
  D.7318 = D.7312 + D.7317;
  D.7308 = array->len;
  D.7309 = (unsigned int) D.7308;
  D.7319 = D.7309 - index_;
  D.7314 = priv->element_size;
  D.7320 = D.7319 * D.7314;
  memmove (D.7316, D.7318, D.7320);
  D.7312 = priv->array.data;
  D.7314 = priv->element_size;
  D.7317 = D.7314 * index_;
  D.7321 = D.7312 + D.7317;
  D.7314 = priv->element_size;
  D.7322 = D.7314 * len;
  memmove (D.7321, data, D.7322);
  D.7308 = array->len;
  D.7309 = (unsigned int) D.7308;
  D.7310 = D.7309 + len;
  D.7323 = (int) D.7310;
  array->len = D.7323;
  D.7303 = priv->zero_terminated;
  if (D.7303 != 0) goto <D.7324>; else goto <D.7325>;
  <D.7324>:
  D.7312 = priv->array.data;
  D.7326 = priv->array.len;
  D.7327 = (unsigned int) D.7326;
  D.7314 = priv->element_size;
  D.7328 = D.7327 * D.7314;
  D.7329 = D.7312 + D.7328;
  D.7314 = priv->element_size;
  memset (D.7329, 0, D.7314);
  <D.7325>:
  D.7307 = array;
  return D.7307;
}


monoeg_g_array_remove_index (struct GArray * array, guint index_)
{
  struct GArray * D.7333;
  gchar * D.7334;
  unsigned int D.7335;
  unsigned int D.7336;
  void * D.7337;
  unsigned int D.7338;
  unsigned int D.7339;
  const void * D.7340;
  int D.7341;
  unsigned int D.7342;
  unsigned int D.7343;
  unsigned int D.7344;
  int D.7345;
  int D.7346;
  int D.7349;
  unsigned int D.7350;
  unsigned int D.7351;
  void * D.7352;
  struct GArrayPriv * priv;

  priv = array;
  if (array == 0B) goto <D.7331>; else goto <D.7332>;
  <D.7331>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "garray.c", 181, "array != NULL");
  D.7333 = 0B;
  return D.7333;
  <D.7332>:
  D.7334 = priv->array.data;
  D.7335 = priv->element_size;
  D.7336 = D.7335 * index_;
  D.7337 = D.7334 + D.7336;
  D.7334 = priv->array.data;
  D.7338 = index_ + 1;
  D.7335 = priv->element_size;
  D.7339 = D.7338 * D.7335;
  D.7340 = D.7334 + D.7339;
  D.7341 = array->len;
  D.7342 = (unsigned int) D.7341;
  D.7343 = D.7342 - index_;
  D.7335 = priv->element_size;
  D.7344 = D.7343 * D.7335;
  memmove (D.7337, D.7340, D.7344);
  D.7341 = array->len;
  D.7345 = D.7341 + -1;
  array->len = D.7345;
  D.7346 = priv->zero_terminated;
  if (D.7346 != 0) goto <D.7347>; else goto <D.7348>;
  <D.7347>:
  D.7334 = priv->array.data;
  D.7349 = priv->array.len;
  D.7350 = (unsigned int) D.7349;
  D.7335 = priv->element_size;
  D.7351 = D.7350 * D.7335;
  D.7352 = D.7334 + D.7351;
  D.7335 = priv->element_size;
  memset (D.7352, 0, D.7335);
  <D.7348>:
  D.7333 = array;
  return D.7333;
}


monoeg_g_array_remove_index_fast (struct GArray * array, guint index_)
{
  struct GArray * D.7356;
  gchar * D.7357;
  unsigned int D.7358;
  unsigned int D.7359;
  void * D.7360;
  int D.7361;
  int D.7362;
  unsigned int D.7363;
  unsigned int D.7364;
  const void * D.7365;
  int D.7366;
  int D.7367;
  int D.7370;
  unsigned int D.7371;
  unsigned int D.7372;
  void * D.7373;
  struct GArrayPriv * priv;

  priv = array;
  if (array == 0B) goto <D.7354>; else goto <D.7355>;
  <D.7354>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "garray.c", 204, "array != NULL");
  D.7356 = 0B;
  return D.7356;
  <D.7355>:
  D.7357 = priv->array.data;
  D.7358 = priv->element_size;
  D.7359 = D.7358 * index_;
  D.7360 = D.7357 + D.7359;
  D.7357 = priv->array.data;
  D.7361 = array->len;
  D.7362 = D.7361 + -1;
  D.7363 = (unsigned int) D.7362;
  D.7358 = priv->element_size;
  D.7364 = D.7363 * D.7358;
  D.7365 = D.7357 + D.7364;
  D.7358 = priv->element_size;
  memmove (D.7360, D.7365, D.7358);
  D.7361 = array->len;
  D.7366 = D.7361 + -1;
  array->len = D.7366;
  D.7367 = priv->zero_terminated;
  if (D.7367 != 0) goto <D.7368>; else goto <D.7369>;
  <D.7368>:
  D.7357 = priv->array.data;
  D.7370 = priv->array.len;
  D.7371 = (unsigned int) D.7370;
  D.7358 = priv->element_size;
  D.7372 = D.7371 * D.7358;
  D.7373 = D.7357 + D.7372;
  D.7358 = priv->element_size;
  memset (D.7373, 0, D.7358);
  <D.7369>:
  D.7356 = array;
  return D.7356;
}


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

  priv = array;
  if (array == 0B) goto <D.7375>; else goto <D.7376>;
  <D.7375>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "garray.c", 226, "array != NULL");
  return;
  <D.7376>:
  if (length < 0) goto <D.7377>; else goto <D.7378>;
  <D.7377>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "garray.c", 227, "length >= 0");
  return;
  <D.7378>:
  length.1 = (unsigned int) length;
  D.7380 = priv->capacity;
  if (length.1 == D.7380) goto <D.7381>; else goto <D.7382>;
  <D.7381>:
  return;
  <D.7382>:
  length.1 = (unsigned int) length;
  D.7380 = priv->capacity;
  if (length.1 > D.7380) goto <D.7383>; else goto <D.7384>;
  <D.7383>:
  length.1 = (unsigned int) length;
  ensure_capacity (priv, length.1);
  <D.7384>:
  array->len = length;
}