monoeg_g_ptr_array_new ()
{
  struct GPtrArray * D.7257;

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


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

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


monoeg_ptr_array_grow (struct GPtrArrayPriv * array, guint length)
{
  unsigned int D.7263;
  unsigned int D.7266;
  unsigned int D.7269;
  unsigned int D.7270;
  void * * D.7271;
  unsigned int D.7272;
  void * D.7273;
  guint new_length;

  D.7263 = array->len;
  new_length = D.7263 + length;
  if (array == 0B) goto <D.7264>; else goto <D.7265>;
  <D.7264>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gptrarray.c", 45, "array != NULL");
  return;
  <D.7265>:
  D.7266 = array->size;
  if (D.7266 >= new_length) goto <D.7267>; else goto <D.7268>;
  <D.7267>:
  return;
  <D.7268>:
  array->size = 1;
  goto <D.7188>;
  <D.7187>:
  D.7266 = array->size;
  D.7269 = D.7266 << 1;
  array->size = D.7269;
  <D.7188>:
  D.7266 = array->size;
  if (D.7266 < new_length) goto <D.7187>; else goto <D.7189>;
  <D.7189>:
  D.7266 = array->size;
  D.7270 = MAX_EXPR <D.7266, 16>;
  array->size = D.7270;
  D.7271 = array->pdata;
  D.7266 = array->size;
  D.7272 = D.7266 * 4;
  D.7273 = monoeg_realloc (D.7271, D.7272);
  array->pdata = D.7273;
}


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

  data = 0B;
  if (array == 0B) goto <D.7275>; else goto <D.7276>;
  <D.7275>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gptrarray.c", 88, "array != NULL");
  D.7277 = 0B;
  return D.7277;
  <D.7276>:
  if (free_seg != 0) goto <D.7278>; else goto <D.7279>;
  <D.7278>:
  D.7280 = array->pdata;
  monoeg_g_free (D.7280);
  goto <D.7281>;
  <D.7279>:
  data = array->pdata;
  <D.7281>:
  monoeg_g_free (array);
  D.7277 = data;
  return D.7277;
}


monoeg_g_ptr_array_set_size (struct GPtrArray * array, gint length)
{
  unsigned int length.0;
  unsigned int D.7286;
  unsigned int length.1;
  void * * D.7290;
  unsigned int D.7291;
  void * D.7292;
  unsigned int D.7293;
  unsigned int D.7294;

  if (array == 0B) goto <D.7283>; else goto <D.7284>;
  <D.7283>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gptrarray.c", 104, "array != NULL");
  return;
  <D.7284>:
  length.0 = (unsigned int) length;
  D.7286 = array->len;
  if (length.0 > D.7286) goto <D.7287>; else goto <D.7288>;
  <D.7287>:
  length.1 = (unsigned int) length;
  monoeg_ptr_array_grow (array, length.1);
  D.7290 = array->pdata;
  D.7286 = array->len;
  D.7291 = D.7286 * 4;
  D.7292 = D.7290 + D.7291;
  length.1 = (unsigned int) length;
  D.7286 = array->len;
  D.7293 = length.1 - D.7286;
  D.7294 = D.7293 * 4;
  memset (D.7292, 0, D.7294);
  <D.7288>:
  length.1 = (unsigned int) length;
  array->len = length.1;
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.7298;
  int D.7303;
  void * D.7305;
  unsigned int D.7306;

  D.7298 = __builtin_constant_p (__len);
  if (D.7298 != 0) goto <D.7299>; else goto <D.7300>;
  <D.7299>:
  if (__len == 0) goto <D.7301>; else goto <D.7302>;
  <D.7301>:
  D.7303 = __builtin_constant_p (__ch);
  if (D.7303 == 0) goto <D.7296>; else goto <D.7304>;
  <D.7304>:
  if (__ch != 0) goto <D.7296>; else goto <D.7297>;
  <D.7296>:
  __warn_memset_zero_len ();
  D.7305 = __dest;
  return D.7305;
  <D.7297>:
  <D.7302>:
  <D.7300>:
  D.7306 = __builtin_object_size (__dest, 0);
  D.7305 = __builtin___memset_chk (__dest, __ch, __len, D.7306);
  return D.7305;
}


monoeg_g_ptr_array_add (struct GPtrArray * array, void * data)
{
  void * * D.7310;
  unsigned int D.7311;
  unsigned int D.7312;
  unsigned int D.7313;
  unsigned int D.7314;
  void * * D.7315;

  if (array == 0B) goto <D.7308>; else goto <D.7309>;
  <D.7308>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gptrarray.c", 118, "array != NULL");
  return;
  <D.7309>:
  monoeg_ptr_array_grow (array, 1);
  D.7310 = array->pdata;
  D.7311 = array->len;
  D.7312 = D.7311;
  D.7313 = D.7312 + 1;
  array->len = D.7313;
  D.7314 = D.7312 * 4;
  D.7315 = D.7310 + D.7314;
  *D.7315 = data;
}


monoeg_g_ptr_array_remove_index (struct GPtrArray * array, guint index)
{
  void * D.7319;
  void * * D.7322;
  unsigned int D.7323;
  void * * D.7324;
  unsigned int D.7325;
  unsigned int D.7326;
  void * D.7329;
  sizetype D.7330;
  sizetype D.7331;
  void * * D.7332;
  unsigned int D.7333;
  unsigned int D.7334;
  unsigned int D.7335;
  unsigned int D.7336;
  void * * D.7337;
  void * removed_node;

  if (array == 0B) goto <D.7317>; else goto <D.7318>;
  <D.7317>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gptrarray.c", 128, "array != NULL");
  D.7319 = 0B;
  return D.7319;
  <D.7318>:
  if (0 != 0) goto <D.7320>; else goto <D.7321>;
  <D.7320>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gptrarray.c", 129, "index >= 0 || index < array->len");
  D.7319 = 0B;
  return D.7319;
  <D.7321>:
  D.7322 = array->pdata;
  D.7323 = index * 4;
  D.7324 = D.7322 + D.7323;
  removed_node = *D.7324;
  D.7325 = array->len;
  D.7326 = D.7325 + 4294967295;
  if (D.7326 != index) goto <D.7327>; else goto <D.7328>;
  <D.7327>:
  D.7322 = array->pdata;
  D.7323 = index * 4;
  D.7329 = D.7322 + D.7323;
  D.7322 = array->pdata;
  D.7330 = index + 1;
  D.7331 = D.7330 * 4;
  D.7332 = D.7322 + D.7331;
  D.7325 = array->len;
  D.7333 = D.7325 - index;
  D.7334 = D.7333 + 1073741823;
  D.7335 = D.7334 * 4;
  memmove (D.7329, D.7332, D.7335);
  <D.7328>:
  D.7325 = array->len;
  D.7326 = D.7325 + 4294967295;
  array->len = D.7326;
  D.7322 = array->pdata;
  D.7325 = array->len;
  D.7336 = D.7325 * 4;
  D.7337 = D.7322 + D.7336;
  *D.7337 = 0B;
  D.7319 = removed_node;
  return D.7319;
}


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

  D.7340 = __builtin_object_size (__dest, 0);
  D.7339 = __builtin___memmove_chk (__dest, __src, __len, D.7340);
  return D.7339;
}


monoeg_g_ptr_array_remove_index_fast (struct GPtrArray * array, guint index)
{
  void * D.7344;
  void * * D.7347;
  unsigned int D.7348;
  void * * D.7349;
  unsigned int D.7350;
  unsigned int D.7351;
  void * D.7354;
  sizetype D.7355;
  sizetype D.7356;
  void * * D.7357;
  unsigned int D.7358;
  void * * D.7359;
  void * removed_node;

  if (array == 0B) goto <D.7342>; else goto <D.7343>;
  <D.7342>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gptrarray.c", 149, "array != NULL");
  D.7344 = 0B;
  return D.7344;
  <D.7343>:
  if (0 != 0) goto <D.7345>; else goto <D.7346>;
  <D.7345>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gptrarray.c", 150, "index >= 0 || index < array->len");
  D.7344 = 0B;
  return D.7344;
  <D.7346>:
  D.7347 = array->pdata;
  D.7348 = index * 4;
  D.7349 = D.7347 + D.7348;
  removed_node = *D.7349;
  D.7350 = array->len;
  D.7351 = D.7350 + 4294967295;
  if (D.7351 != index) goto <D.7352>; else goto <D.7353>;
  <D.7352>:
  D.7347 = array->pdata;
  D.7348 = index * 4;
  D.7354 = D.7347 + D.7348;
  D.7347 = array->pdata;
  D.7350 = array->len;
  D.7355 = D.7350 + 1073741823;
  D.7356 = D.7355 * 4;
  D.7357 = D.7347 + D.7356;
  memmove (D.7354, D.7357, 4);
  <D.7353>:
  D.7350 = array->len;
  D.7351 = D.7350 + 4294967295;
  array->len = D.7351;
  D.7347 = array->pdata;
  D.7350 = array->len;
  D.7358 = D.7350 * 4;
  D.7359 = D.7347 + D.7358;
  *D.7359 = 0B;
  D.7344 = removed_node;
  return D.7344;
}


monoeg_g_ptr_array_remove (struct GPtrArray * array, void * data)
{
  gboolean D.7363;
  void * * D.7364;
  unsigned int D.7365;
  void * * D.7366;
  void * D.7367;
  unsigned int D.7370;
  guint i;

  if (array == 0B) goto <D.7361>; else goto <D.7362>;
  <D.7361>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gptrarray.c", 170, "array != NULL");
  D.7363 = 0;
  return D.7363;
  <D.7362>:
  i = 0;
  goto <D.7226>;
  <D.7225>:
  D.7364 = array->pdata;
  D.7365 = i * 4;
  D.7366 = D.7364 + D.7365;
  D.7367 = *D.7366;
  if (D.7367 == data) goto <D.7368>; else goto <D.7369>;
  <D.7368>:
  monoeg_g_ptr_array_remove_index (array, i);
  D.7363 = 1;
  return D.7363;
  <D.7369>:
  i = i + 1;
  <D.7226>:
  D.7370 = array->len;
  if (D.7370 > i) goto <D.7225>; else goto <D.7227>;
  <D.7227>:
  D.7363 = 0;
  return D.7363;
}


monoeg_g_ptr_array_remove_fast (struct GPtrArray * array, void * data)
{
  gboolean D.7374;
  void * * D.7375;
  unsigned int D.7376;
  void * * D.7377;
  void * D.7378;
  unsigned int D.7381;
  unsigned int D.7382;
  unsigned int D.7385;
  void * * D.7386;
  void * D.7387;
  guint i;

  if (array == 0B) goto <D.7372>; else goto <D.7373>;
  <D.7372>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "gptrarray.c", 187, "array != NULL");
  D.7374 = 0;
  return D.7374;
  <D.7373>:
  i = 0;
  goto <D.7234>;
  <D.7233>:
  D.7375 = array->pdata;
  D.7376 = i * 4;
  D.7377 = D.7375 + D.7376;
  D.7378 = *D.7377;
  if (D.7378 == data) goto <D.7379>; else goto <D.7380>;
  <D.7379>:
  D.7381 = array->len;
  D.7382 = D.7381 + 4294967295;
  array->len = D.7382;
  D.7381 = array->len;
  if (D.7381 != 0) goto <D.7383>; else goto <D.7384>;
  <D.7383>:
  D.7375 = array->pdata;
  D.7376 = i * 4;
  D.7377 = D.7375 + D.7376;
  D.7375 = array->pdata;
  D.7381 = array->len;
  D.7385 = D.7381 * 4;
  D.7386 = D.7375 + D.7385;
  D.7387 = *D.7386;
  *D.7377 = D.7387;
  goto <D.7388>;
  <D.7384>:
  D.7375 = array->pdata;
  D.7376 = i * 4;
  D.7377 = D.7375 + D.7376;
  *D.7377 = 0B;
  <D.7388>:
  D.7374 = 1;
  return D.7374;
  <D.7380>:
  i = i + 1;
  <D.7234>:
  D.7381 = array->len;
  if (D.7381 > i) goto <D.7233>; else goto <D.7235>;
  <D.7235>:
  D.7374 = 0;
  return D.7374;
}


monoeg_g_ptr_array_foreach (struct GPtrArray * array, void (*GFunc) (void *, void *) func, void * user_data)
{
  void * * D.7390;
  unsigned int D.7391;
  void * * D.7392;
  void * D.7393;
  unsigned int D.7394;
  guint i;

  i = 0;
  goto <D.7243>;
  <D.7242>:
  D.7390 = array->pdata;
  D.7391 = i * 4;
  D.7392 = D.7390 + D.7391;
  D.7393 = *D.7392;
  func (D.7393, user_data);
  i = i + 1;
  <D.7243>:
  D.7394 = array->len;
  if (D.7394 > i) goto <D.7242>; else goto <D.7244>;
  <D.7244>:
}


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

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


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

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