ptrarray_alloc ()
{
  unsigned int D.5074;
  unsigned int D.5075;
  unsigned int D.5076;
  gchar * D.5079;
  unsigned int D.5080;
  unsigned int i.0;
  struct GPtrArrayPriv * array;
  guint i;

  try
    {
      array = ptrarray_alloc_and_fill (&i);
      D.5074 = array->size;
      D.5075 = array->len;
      D.5076 = guess_size (D.5075);
      if (D.5074 != D.5076) goto <D.5077>; else goto <D.5078>;
      <D.5077>:
      D.5074 = array->size;
      D.5075 = array->len;
      D.5080 = guess_size (D.5075);
      D.5079 = FAILED ("Size should be %d, but it is %d", D.5080, D.5074);
      return D.5079;
      <D.5078>:
      D.5075 = array->len;
      i.0 = i;
      if (D.5075 != i.0) goto <D.5082>; else goto <D.5083>;
      <D.5082>:
      i.0 = i;
      D.5079 = FAILED ("Expected %d node(s) in the array", i.0);
      return D.5079;
      <D.5083>:
      monoeg_g_ptr_array_free (array, 1);
      D.5079 = 0B;
      return D.5079;
    }
  finally
    {
      i = {CLOBBER};
    }
}


ptrarray_alloc_and_fill (guint * item_count)
{
  const char * D.5086;
  unsigned int i.1;
  struct GPtrArray * D.5090;
  struct GPtrArray * array;
  gint i;

  array = monoeg_g_ptr_array_new ();
  i = 0;
  goto <D.4958>;
  <D.4957>:
  D.5086 = items[i];
  monoeg_g_ptr_array_add (array, D.5086);
  i = i + 1;
  <D.4958>:
  D.5086 = items[i];
  if (D.5086 != 0B) goto <D.4957>; else goto <D.4959>;
  <D.4959>:
  if (item_count != 0B) goto <D.5087>; else goto <D.5088>;
  <D.5087>:
  i.1 = (unsigned int) i;
  *item_count = i.1;
  <D.5088>:
  D.5090 = array;
  return D.5090;
}


guess_size (guint length)
{
  guint D.5092;
  guint size;

  size = 1;
  goto <D.4965>;
  <D.4964>:
  size = size << 1;
  <D.4965>:
  if (size < length) goto <D.4964>; else goto <D.4966>;
  <D.4966>:
  D.5092 = size;
  return D.5092;
}


ptrarray_for_iterate ()
{
  void * * D.5094;
  long unsigned int D.5095;
  long unsigned int D.5096;
  void * * D.5097;
  const char * D.5098;
  gchar * D.5101;
  unsigned int D.5102;
  struct GPtrArray * array;
  guint i;

  array = ptrarray_alloc_and_fill (0B);
  i = 0;
  goto <D.4977>;
  <D.4976>:
  {
    char * item;

    D.5094 = array->pdata;
    D.5095 = (long unsigned int) i;
    D.5096 = D.5095 * 8;
    D.5097 = D.5094 + D.5096;
    item = *D.5097;
    D.5098 = items[i];
    if (D.5098 != item) goto <D.5099>; else goto <D.5100>;
    <D.5099>:
    D.5098 = items[i];
    D.5101 = FAILED ("Expected item at %d to be %s, but it was %s", i, D.5098, item);
    return D.5101;
    <D.5100>:
  }
  i = i + 1;
  <D.4977>:
  D.5102 = array->len;
  if (D.5102 > i) goto <D.4976>; else goto <D.4978>;
  <D.4978>:
  monoeg_g_ptr_array_free (array, 1);
  D.5101 = 0B;
  return D.5101;
}


foreach_callback (void * data, void * user_data)
{
  int foreach_iterate_index.2;
  int foreach_iterate_index.3;
  int foreach_iterate_index.4;
  char * foreach_iterate_error.5;
  int D.5112;
  gchar * foreach_iterate_error.6;
  char * item;
  const char * item_cmp;

  item = data;
  foreach_iterate_index.2 = foreach_iterate_index;
  foreach_iterate_index.3 = foreach_iterate_index.2;
  foreach_iterate_index.4 = foreach_iterate_index.3 + 1;
  foreach_iterate_index = foreach_iterate_index.4;
  item_cmp = items[foreach_iterate_index.3];
  foreach_iterate_error.5 = foreach_iterate_error;
  if (foreach_iterate_error.5 != 0B) goto <D.5108>; else goto <D.5109>;
  <D.5108>:
  return;
  <D.5109>:
  if (item != item_cmp) goto <D.5110>; else goto <D.5111>;
  <D.5110>:
  foreach_iterate_index.2 = foreach_iterate_index;
  D.5112 = foreach_iterate_index.2 + -1;
  foreach_iterate_error.6 = FAILED ("Expected item at %d to be %s, but it was %s", D.5112, item_cmp, item);
  foreach_iterate_error = foreach_iterate_error.6;
  <D.5111>:
}


ptrarray_foreach_iterate ()
{
  gchar * D.5115;
  struct GPtrArray * array;

  array = ptrarray_alloc_and_fill (0B);
  foreach_iterate_index = 0;
  foreach_iterate_error = 0B;
  monoeg_g_ptr_array_foreach (array, foreach_callback, array);
  monoeg_g_ptr_array_free (array, 1);
  D.5115 = foreach_iterate_error;
  return D.5115;
}


ptrarray_set_size ()
{
  const char * D.5117;
  const char * D.5118;
  int grow_length.7;
  unsigned int D.5120;
  gchar * D.5123;
  void * * D.5124;
  void * D.5125;
  void * * D.5128;
  void * D.5129;
  long unsigned int D.5132;
  long unsigned int D.5133;
  void * * D.5134;
  void * D.5135;
  struct GPtrArray * array;
  guint i;
  guint grow_length;

  array = monoeg_g_ptr_array_new ();
  grow_length = 50;
  D.5117 = items[0];
  monoeg_g_ptr_array_add (array, D.5117);
  D.5118 = items[1];
  monoeg_g_ptr_array_add (array, D.5118);
  grow_length.7 = (int) grow_length;
  monoeg_g_ptr_array_set_size (array, grow_length.7);
  D.5120 = array->len;
  if (D.5120 != grow_length) goto <D.5121>; else goto <D.5122>;
  <D.5121>:
  D.5120 = array->len;
  D.5123 = FAILED ("Array length should be 50, it is %d", D.5120);
  return D.5123;
  <D.5122>:
  D.5124 = array->pdata;
  D.5125 = *D.5124;
  D.5117 = items[0];
  if (D.5125 != D.5117) goto <D.5126>; else goto <D.5127>;
  <D.5126>:
  D.5117 = items[0];
  D.5123 = FAILED ("Item 0 was overwritten, should be %s", D.5117);
  return D.5123;
  <D.5127>:
  D.5124 = array->pdata;
  D.5128 = D.5124 + 8;
  D.5129 = *D.5128;
  D.5118 = items[1];
  if (D.5129 != D.5118) goto <D.5130>; else goto <D.5131>;
  <D.5130>:
  D.5118 = items[1];
  D.5123 = FAILED ("Item 1 was overwritten, should be %s", D.5118);
  return D.5123;
  <D.5131>:
  i = 2;
  goto <D.4996>;
  <D.4995>:
  D.5124 = array->pdata;
  D.5132 = (long unsigned int) i;
  D.5133 = D.5132 * 8;
  D.5134 = D.5124 + D.5133;
  D.5135 = *D.5134;
  if (D.5135 != 0B) goto <D.5136>; else goto <D.5137>;
  <D.5136>:
  D.5124 = array->pdata;
  D.5132 = (long unsigned int) i;
  D.5133 = D.5132 * 8;
  D.5134 = D.5124 + D.5133;
  D.5135 = *D.5134;
  D.5123 = FAILED ("Item %d is not NULL, it is %p", i, D.5135);
  return D.5123;
  <D.5137>:
  i = i + 1;
  <D.4996>:
  D.5120 = array->len;
  if (D.5120 > i) goto <D.4995>; else goto <D.4997>;
  <D.4997>:
  monoeg_g_ptr_array_free (array, 1);
  D.5123 = 0B;
  return D.5123;
}


ptrarray_remove_index ()
{
  void * * D.5139;
  void * D.5140;
  const char * D.5141;
  gchar * D.5144;
  unsigned int D.5145;
  unsigned int D.5146;
  long unsigned int D.5147;
  long unsigned int D.5148;
  void * * D.5149;
  void * D.5150;
  const char * D.5151;
  unsigned int D.5154;
  const char * D.5155;
  struct GPtrArray * array;
  guint i;

  try
    {
      array = ptrarray_alloc_and_fill (&i);
      monoeg_g_ptr_array_remove_index (array, 0);
      D.5139 = array->pdata;
      D.5140 = *D.5139;
      D.5141 = items[1];
      if (D.5140 != D.5141) goto <D.5142>; else goto <D.5143>;
      <D.5142>:
      D.5139 = array->pdata;
      D.5140 = *D.5139;
      D.5141 = items[1];
      D.5144 = FAILED ("First item is not %s, it is %s", D.5141, D.5140);
      return D.5144;
      <D.5143>:
      D.5145 = array->len;
      D.5146 = D.5145 + 4294967295;
      monoeg_g_ptr_array_remove_index (array, D.5146);
      D.5139 = array->pdata;
      D.5145 = array->len;
      D.5146 = D.5145 + 4294967295;
      D.5147 = (long unsigned int) D.5146;
      D.5148 = D.5147 * 8;
      D.5149 = D.5139 + D.5148;
      D.5150 = *D.5149;
      D.5145 = array->len;
      D.5151 = items[D.5145];
      if (D.5150 != D.5151) goto <D.5152>; else goto <D.5153>;
      <D.5152>:
      D.5139 = array->pdata;
      D.5145 = array->len;
      D.5146 = D.5145 + 4294967295;
      D.5147 = (long unsigned int) D.5146;
      D.5148 = D.5147 * 8;
      D.5149 = D.5139 + D.5148;
      D.5150 = *D.5149;
      D.5145 = array->len;
      D.5154 = D.5145 + 4294967294;
      D.5155 = items[D.5154];
      D.5144 = FAILED ("Last item is not %s, it is %s", D.5155, D.5150);
      return D.5144;
      <D.5153>:
      monoeg_g_ptr_array_free (array, 1);
      D.5144 = 0B;
      return D.5144;
    }
  finally
    {
      i = {CLOBBER};
    }
}


ptrarray_remove_index_fast ()
{
  void * * D.5158;
  void * D.5159;
  unsigned int D.5160;
  const char * D.5161;
  gchar * D.5164;
  unsigned int D.5165;
  long unsigned int D.5166;
  long unsigned int D.5167;
  void * * D.5168;
  void * D.5169;
  const char * D.5170;
  struct GPtrArray * array;
  guint i;

  try
    {
      array = ptrarray_alloc_and_fill (&i);
      monoeg_g_ptr_array_remove_index_fast (array, 0);
      D.5158 = array->pdata;
      D.5159 = *D.5158;
      D.5160 = array->len;
      D.5161 = items[D.5160];
      if (D.5159 != D.5161) goto <D.5162>; else goto <D.5163>;
      <D.5162>:
      D.5158 = array->pdata;
      D.5159 = *D.5158;
      D.5160 = array->len;
      D.5161 = items[D.5160];
      D.5164 = FAILED ("First item is not %s, it is %s", D.5161, D.5159);
      return D.5164;
      <D.5163>:
      D.5160 = array->len;
      D.5165 = D.5160 + 4294967295;
      monoeg_g_ptr_array_remove_index_fast (array, D.5165);
      D.5158 = array->pdata;
      D.5160 = array->len;
      D.5165 = D.5160 + 4294967295;
      D.5166 = (long unsigned int) D.5165;
      D.5167 = D.5166 * 8;
      D.5168 = D.5158 + D.5167;
      D.5169 = *D.5168;
      D.5160 = array->len;
      D.5165 = D.5160 + 4294967295;
      D.5170 = items[D.5165];
      if (D.5169 != D.5170) goto <D.5171>; else goto <D.5172>;
      <D.5171>:
      D.5158 = array->pdata;
      D.5160 = array->len;
      D.5165 = D.5160 + 4294967295;
      D.5166 = (long unsigned int) D.5165;
      D.5167 = D.5166 * 8;
      D.5168 = D.5158 + D.5167;
      D.5169 = *D.5168;
      D.5160 = array->len;
      D.5165 = D.5160 + 4294967295;
      D.5170 = items[D.5165];
      D.5164 = FAILED ("Last item is not %s, it is %s", D.5170, D.5169);
      return D.5164;
      <D.5172>:
      monoeg_g_ptr_array_free (array, 1);
      D.5164 = 0B;
      return D.5164;
    }
  finally
    {
      i = {CLOBBER};
    }
}


ptrarray_remove ()
{
  const char * D.5175;
  const char * D.5176;
  int D.5177;
  gchar * D.5180;
  int D.5181;
  void * * D.5184;
  unsigned int D.5185;
  unsigned int D.5186;
  long unsigned int D.5187;
  long unsigned int D.5188;
  void * * D.5189;
  void * D.5190;
  unsigned int D.5191;
  const char * D.5192;
  struct GPtrArray * array;
  guint i;

  try
    {
      array = ptrarray_alloc_and_fill (&i);
      D.5175 = items[7];
      monoeg_g_ptr_array_remove (array, D.5175);
      D.5176 = items[4];
      D.5177 = monoeg_g_ptr_array_remove (array, D.5176);
      if (D.5177 == 0) goto <D.5178>; else goto <D.5179>;
      <D.5178>:
      D.5176 = items[4];
      D.5180 = FAILED ("Item %s not removed", D.5176);
      return D.5180;
      <D.5179>:
      D.5176 = items[4];
      D.5181 = monoeg_g_ptr_array_remove (array, D.5176);
      if (D.5181 != 0) goto <D.5182>; else goto <D.5183>;
      <D.5182>:
      D.5176 = items[4];
      D.5180 = FAILED ("Item %s still in array after removal", D.5176);
      return D.5180;
      <D.5183>:
      D.5184 = array->pdata;
      D.5185 = array->len;
      D.5186 = D.5185 + 4294967295;
      D.5187 = (long unsigned int) D.5186;
      D.5188 = D.5187 * 8;
      D.5189 = D.5184 + D.5188;
      D.5190 = *D.5189;
      D.5185 = array->len;
      D.5191 = D.5185 + 1;
      D.5192 = items[D.5191];
      if (D.5190 != D.5192) goto <D.5193>; else goto <D.5194>;
      <D.5193>:
      D.5180 = FAILED ("Last item in GPtrArray not correct");
      return D.5180;
      <D.5194>:
      monoeg_g_ptr_array_free (array, 1);
      D.5180 = 0B;
      return D.5180;
    }
  finally
    {
      i = {CLOBBER};
    }
}


ptrarray_sort ()
{
  gchar * D.5197;
  gchar * D.5198;
  gchar * D.5199;
  gchar * D.5200;
  gchar * D.5201;
  void * * D.5202;
  long unsigned int D.5203;
  long unsigned int D.5204;
  void * * D.5205;
  void * D.5206;
  gchar * D.5207;
  gchar * D.5210;
  unsigned int D.5211;
  struct GPtrArray * array;
  guint i;
  gchar * letters[5];

  try
    {
      array = monoeg_g_ptr_array_new ();
      letters[0] = "A";
      letters[1] = "B";
      letters[2] = "C";
      letters[3] = "D";
      letters[4] = "E";
      D.5197 = letters[0];
      monoeg_g_ptr_array_add (array, D.5197);
      D.5198 = letters[1];
      monoeg_g_ptr_array_add (array, D.5198);
      D.5199 = letters[2];
      monoeg_g_ptr_array_add (array, D.5199);
      D.5200 = letters[3];
      monoeg_g_ptr_array_add (array, D.5200);
      D.5201 = letters[4];
      monoeg_g_ptr_array_add (array, D.5201);
      monoeg_g_ptr_array_sort (array, ptrarray_sort_compare);
      i = 0;
      goto <D.5031>;
      <D.5030>:
      D.5202 = array->pdata;
      D.5203 = (long unsigned int) i;
      D.5204 = D.5203 * 8;
      D.5205 = D.5202 + D.5204;
      D.5206 = *D.5205;
      D.5207 = letters[i];
      if (D.5206 != D.5207) goto <D.5208>; else goto <D.5209>;
      <D.5208>:
      D.5202 = array->pdata;
      D.5203 = (long unsigned int) i;
      D.5204 = D.5203 * 8;
      D.5205 = D.5202 + D.5204;
      D.5206 = *D.5205;
      D.5207 = letters[i];
      D.5210 = FAILED ("Array out of order, expected %s got %s at position %d", D.5207, D.5206, i);
      return D.5210;
      <D.5209>:
      i = i + 1;
      <D.5031>:
      D.5211 = array->len;
      if (D.5211 > i) goto <D.5030>; else goto <D.5032>;
      <D.5032>:
      monoeg_g_ptr_array_free (array, 1);
      D.5210 = 0B;
      return D.5210;
    }
  finally
    {
      letters = {CLOBBER};
    }
}


ptrarray_sort_compare (const void * a, const void * b)
{
  gint D.5214;
  int D.5024;
  gchar * stra;
  gchar * strb;

  stra = MEM[(gchar * *)a];
  strb = MEM[(gchar * *)b];
  {
    size_t __s1_len;
    size_t __s2_len;

    D.5024 = __builtin_strcmp (stra, strb);
  }
  D.5214 = D.5024;
  return D.5214;
}


ptrarray_sort_with_data ()
{
  gchar * D.5216;
  gchar * D.5217;
  gchar * D.5218;
  gchar * D.5219;
  gchar * D.5220;
  void * * D.5221;
  long unsigned int D.5222;
  long unsigned int D.5223;
  void * * D.5224;
  void * D.5225;
  gchar * D.5226;
  gchar * D.5229;
  unsigned int D.5230;
  struct GPtrArray * array;
  guint i;
  gchar * letters[5];

  try
    {
      array = monoeg_g_ptr_array_new ();
      letters[0] = "A";
      letters[1] = "B";
      letters[2] = "C";
      letters[3] = "D";
      letters[4] = "E";
      D.5216 = letters[4];
      monoeg_g_ptr_array_add (array, D.5216);
      D.5217 = letters[1];
      monoeg_g_ptr_array_add (array, D.5217);
      D.5218 = letters[2];
      monoeg_g_ptr_array_add (array, D.5218);
      D.5219 = letters[0];
      monoeg_g_ptr_array_add (array, D.5219);
      D.5220 = letters[3];
      monoeg_g_ptr_array_add (array, D.5220);
      monoeg_g_ptr_array_sort_with_data (array, ptrarray_sort_compare_with_data, "this is the data for qsort");
      i = 0;
      goto <D.5064>;
      <D.5063>:
      D.5221 = array->pdata;
      D.5222 = (long unsigned int) i;
      D.5223 = D.5222 * 8;
      D.5224 = D.5221 + D.5223;
      D.5225 = *D.5224;
      D.5226 = letters[i];
      if (D.5225 != D.5226) goto <D.5227>; else goto <D.5228>;
      <D.5227>:
      D.5221 = array->pdata;
      D.5222 = (long unsigned int) i;
      D.5223 = D.5222 * 8;
      D.5224 = D.5221 + D.5223;
      D.5225 = *D.5224;
      D.5226 = letters[i];
      D.5229 = FAILED ("Array out of order, expected %s got %s at position %d", D.5226, D.5225, i);
      return D.5229;
      <D.5228>:
      i = i + 1;
      <D.5064>:
      D.5230 = array->len;
      if (D.5230 > i) goto <D.5063>; else goto <D.5065>;
      <D.5065>:
      monoeg_g_ptr_array_free (array, 1);
      D.5229 = 0B;
      return D.5229;
    }
  finally
    {
      letters = {CLOBBER};
    }
}


ptrarray_sort_compare_with_data (const void * a, const void * b, void * user_data)
{
  int D.5048;
  int iftmp.8;
  int D.5047;
  char[27] * D.5236;
  unsigned char D.5237;
  int D.5238;
  unsigned char D.5239;
  int D.5240;
  _Bool D.5241;
  _Bool D.5242;
  _Bool D.5243;
  const unsigned char * D.5246;
  unsigned char D.5247;
  int D.5248;
  const unsigned char * D.5249;
  unsigned char D.5250;
  int D.5251;
  _Bool D.5252;
  _Bool D.5253;
  const unsigned char * D.5256;
  unsigned char D.5257;
  int D.5258;
  const unsigned char * D.5259;
  unsigned char D.5260;
  int D.5261;
  _Bool D.5262;
  _Bool D.5263;
  const unsigned char * D.5266;
  unsigned char D.5267;
  int D.5268;
  const unsigned char * D.5269;
  unsigned char D.5270;
  int D.5271;
  struct _IO_FILE * stderr.9;
  gint D.5276;
  int D.5057;
  gchar * stra;
  gchar * strb;

  stra = MEM[(gchar * *)a];
  strb = MEM[(gchar * *)b];
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 26;
    if (__s2_len <= 3) goto <D.5234>; else goto <D.5235>;
    <D.5234>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = user_data;
      D.5236 = "this is the data for qsort";
      D.5237 = MEM[(const unsigned char *)D.5236];
      D.5238 = (int) D.5237;
      D.5239 = *__s2;
      D.5240 = (int) D.5239;
      __result = D.5238 - D.5240;
      {
        D.5241 = __s2_len != 0;
        D.5242 = __result == 0;
        D.5243 = D.5241 & D.5242;
        if (D.5243 != 0) goto <D.5244>; else goto <D.5245>;
        <D.5244>:
        D.5246 = &MEM[(void *)"this is the data for qsort" + 1B];
        D.5247 = *D.5246;
        D.5248 = (int) D.5247;
        D.5249 = __s2 + 1;
        D.5250 = *D.5249;
        D.5251 = (int) D.5250;
        __result = D.5248 - D.5251;
        D.5252 = __s2_len > 1;
        D.5242 = __result == 0;
        D.5253 = D.5252 & D.5242;
        if (D.5253 != 0) goto <D.5254>; else goto <D.5255>;
        <D.5254>:
        D.5256 = &MEM[(void *)"this is the data for qsort" + 2B];
        D.5257 = *D.5256;
        D.5258 = (int) D.5257;
        D.5259 = __s2 + 2;
        D.5260 = *D.5259;
        D.5261 = (int) D.5260;
        __result = D.5258 - D.5261;
        D.5262 = __s2_len > 2;
        D.5242 = __result == 0;
        D.5263 = D.5262 & D.5242;
        if (D.5263 != 0) goto <D.5264>; else goto <D.5265>;
        <D.5264>:
        D.5266 = &MEM[(void *)"this is the data for qsort" + 3B];
        D.5267 = *D.5266;
        D.5268 = (int) D.5267;
        D.5269 = __s2 + 3;
        D.5270 = *D.5269;
        D.5271 = (int) D.5270;
        __result = D.5268 - D.5271;
        <D.5265>:
        <D.5255>:
        <D.5245>:
      }
      D.5047 = __result;
    }
    iftmp.8 = -D.5047;
    goto <D.5272>;
    <D.5235>:
    iftmp.8 = __builtin_strcmp (user_data, "this is the data for qsort");
    <D.5272>:
    D.5048 = iftmp.8;
  }
  if (D.5048 != 0) goto <D.5273>; else goto <D.5274>;
  <D.5273>:
  stderr.9 = stderr;
  fprintf (stderr.9, "oops at compare with_data\n");
  <D.5274>:
  {
    size_t __s1_len;
    size_t __s2_len;

    D.5057 = __builtin_strcmp (stra, strb);
  }
  D.5276 = D.5057;
  return D.5276;
}


fprintf (struct FILE * restrict __stream, const char * restrict __fmt)
{
  int D.5278;

  D.5278 = __fprintf_chk (__stream, 1, __fmt, __builtin_va_arg_pack ());
  return D.5278;
}


ptrarray_remove_fast ()
{
  int D.5280;
  gchar * D.5283;
  gchar * D.5284;
  int D.5287;
  unsigned int D.5289;
  gchar * D.5290;
  gchar * D.5291;
  gchar * D.5292;
  gchar * D.5293;
  int D.5296;
  void * * D.5298;
  void * D.5299;
  int D.5302;
  int D.5307;
  int D.5311;
  void * * D.5316;
  void * D.5317;
  struct GPtrArray * array;
  gchar * letters[5];

  try
    {
      array = monoeg_g_ptr_array_new ();
      letters[0] = "A";
      letters[1] = "B";
      letters[2] = "C";
      letters[3] = "D";
      letters[4] = "E";
      D.5280 = monoeg_g_ptr_array_remove_fast (array, 0B);
      if (D.5280 != 0) goto <D.5281>; else goto <D.5282>;
      <D.5281>:
      D.5283 = FAILED ("Removing NULL succeeded");
      return D.5283;
      <D.5282>:
      D.5284 = letters[0];
      monoeg_g_ptr_array_add (array, D.5284);
      D.5284 = letters[0];
      D.5287 = monoeg_g_ptr_array_remove_fast (array, D.5284);
      if (D.5287 == 0) goto <D.5285>; else goto <D.5288>;
      <D.5288>:
      D.5289 = array->len;
      if (D.5289 != 0) goto <D.5285>; else goto <D.5286>;
      <D.5285>:
      D.5283 = FAILED ("Removing last element failed");
      return D.5283;
      <D.5286>:
      D.5284 = letters[0];
      monoeg_g_ptr_array_add (array, D.5284);
      D.5290 = letters[1];
      monoeg_g_ptr_array_add (array, D.5290);
      D.5291 = letters[2];
      monoeg_g_ptr_array_add (array, D.5291);
      D.5292 = letters[3];
      monoeg_g_ptr_array_add (array, D.5292);
      D.5293 = letters[4];
      monoeg_g_ptr_array_add (array, D.5293);
      D.5284 = letters[0];
      D.5296 = monoeg_g_ptr_array_remove_fast (array, D.5284);
      if (D.5296 == 0) goto <D.5294>; else goto <D.5297>;
      <D.5297>:
      D.5289 = array->len;
      if (D.5289 != 4) goto <D.5294>; else goto <D.5295>;
      <D.5294>:
      D.5283 = FAILED ("Removing first element failed");
      return D.5283;
      <D.5295>:
      D.5298 = array->pdata;
      D.5299 = *D.5298;
      D.5293 = letters[4];
      if (D.5299 != D.5293) goto <D.5300>; else goto <D.5301>;
      <D.5300>:
      D.5283 = FAILED ("First element wasn\'t replaced with last upon removal");
      return D.5283;
      <D.5301>:
      D.5284 = letters[0];
      D.5302 = monoeg_g_ptr_array_remove_fast (array, D.5284);
      if (D.5302 != 0) goto <D.5303>; else goto <D.5304>;
      <D.5303>:
      D.5283 = FAILED ("Succedeed removing a non-existing element");
      return D.5283;
      <D.5304>:
      D.5292 = letters[3];
      D.5307 = monoeg_g_ptr_array_remove_fast (array, D.5292);
      if (D.5307 == 0) goto <D.5305>; else goto <D.5308>;
      <D.5308>:
      D.5289 = array->len;
      if (D.5289 != 3) goto <D.5305>; else goto <D.5306>;
      <D.5305>:
      D.5283 = FAILED ("Failed removing \"D\"");
      return D.5283;
      <D.5306>:
      D.5290 = letters[1];
      D.5311 = monoeg_g_ptr_array_remove_fast (array, D.5290);
      if (D.5311 == 0) goto <D.5309>; else goto <D.5312>;
      <D.5312>:
      D.5289 = array->len;
      if (D.5289 != 2) goto <D.5309>; else goto <D.5310>;
      <D.5309>:
      D.5283 = FAILED ("Failed removing \"B\"");
      return D.5283;
      <D.5310>:
      D.5298 = array->pdata;
      D.5299 = *D.5298;
      D.5293 = letters[4];
      if (D.5299 != D.5293) goto <D.5313>; else goto <D.5315>;
      <D.5315>:
      D.5298 = array->pdata;
      D.5316 = D.5298 + 8;
      D.5317 = *D.5316;
      D.5291 = letters[2];
      if (D.5317 != D.5291) goto <D.5313>; else goto <D.5314>;
      <D.5313>:
      D.5283 = FAILED ("Last two elements are wrong");
      return D.5283;
      <D.5314>:
      monoeg_g_ptr_array_free (array, 1);
      D.5283 = 0B;
      return D.5283;
    }
  finally
    {
      letters = {CLOBBER};
    }
}


ptrarray_tests_init ()
{
  struct Test * D.5320;

  D.5320 = &ptrarray_tests;
  return D.5320;
}