test_queue_push ()
{
  unsigned int D.5137;
  gchar * D.5140;
  struct GList * D.5141;
  struct GList * D.5142;
  int D.4957;
  int iftmp.0;
  int D.4953;
  char[4] * D.5148;
  unsigned char D.5149;
  int D.5150;
  unsigned char D.5151;
  int D.5152;
  _Bool D.5153;
  _Bool D.5154;
  _Bool D.5155;
  const unsigned char * D.5158;
  unsigned char D.5159;
  int D.5160;
  const unsigned char * D.5161;
  unsigned char D.5162;
  int D.5163;
  _Bool D.5164;
  _Bool D.5165;
  const unsigned char * D.5168;
  unsigned char D.5169;
  int D.5170;
  const unsigned char * D.5171;
  unsigned char D.5172;
  int D.5173;
  _Bool D.5174;
  _Bool D.5175;
  const unsigned char * D.5178;
  unsigned char D.5179;
  int D.5180;
  const unsigned char * D.5181;
  unsigned char D.5182;
  int D.5183;
  void * D.5185;
  int D.4966;
  int iftmp.1;
  int D.4962;
  struct GList * D.5191;
  char[4] * D.5192;
  unsigned char D.5193;
  int D.5194;
  unsigned char D.5195;
  int D.5196;
  _Bool D.5197;
  _Bool D.5198;
  _Bool D.5199;
  const unsigned char * D.5202;
  unsigned char D.5203;
  int D.5204;
  const unsigned char * D.5205;
  unsigned char D.5206;
  int D.5207;
  _Bool D.5208;
  _Bool D.5209;
  const unsigned char * D.5212;
  unsigned char D.5213;
  int D.5214;
  const unsigned char * D.5215;
  unsigned char D.5216;
  int D.5217;
  _Bool D.5218;
  _Bool D.5219;
  const unsigned char * D.5222;
  unsigned char D.5223;
  int D.5224;
  const unsigned char * D.5225;
  unsigned char D.5226;
  int D.5227;
  void * D.5229;
  int D.4975;
  int iftmp.2;
  int D.4971;
  struct GList * D.5235;
  char[4] * 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;
  void * D.5273;
  struct GList * D.5276;
  struct GList * D.5279;
  struct GList * D.5280;
  int D.4984;
  int iftmp.3;
  int D.4980;
  unsigned char D.5286;
  int D.5287;
  _Bool D.5288;
  _Bool D.5289;
  _Bool D.5290;
  const unsigned char * D.5293;
  unsigned char D.5294;
  int D.5295;
  _Bool D.5296;
  _Bool D.5297;
  const unsigned char * D.5300;
  unsigned char D.5301;
  int D.5302;
  _Bool D.5303;
  _Bool D.5304;
  const unsigned char * D.5307;
  unsigned char D.5308;
  int D.5309;
  void * D.5311;
  int D.4993;
  int iftmp.4;
  int D.4989;
  struct GList * D.5317;
  unsigned char D.5318;
  int D.5319;
  _Bool D.5320;
  _Bool D.5321;
  _Bool D.5322;
  const unsigned char * D.5325;
  unsigned char D.5326;
  int D.5327;
  _Bool D.5328;
  _Bool D.5329;
  const unsigned char * D.5332;
  unsigned char D.5333;
  int D.5334;
  _Bool D.5335;
  _Bool D.5336;
  const unsigned char * D.5339;
  unsigned char D.5340;
  int D.5341;
  void * D.5343;
  int D.5002;
  int iftmp.5;
  int D.4998;
  struct GList * D.5349;
  unsigned char D.5350;
  int D.5351;
  _Bool D.5352;
  _Bool D.5353;
  _Bool D.5354;
  const unsigned char * D.5357;
  unsigned char D.5358;
  int D.5359;
  _Bool D.5360;
  _Bool D.5361;
  const unsigned char * D.5364;
  unsigned char D.5365;
  int D.5366;
  _Bool D.5367;
  _Bool D.5368;
  const unsigned char * D.5371;
  unsigned char D.5372;
  int D.5373;
  void * D.5375;
  struct GList * D.5378;
  struct GQueue * queue;

  queue = monoeg_g_queue_new ();
  monoeg_g_queue_push_head (queue, "foo");
  monoeg_g_queue_push_head (queue, "bar");
  monoeg_g_queue_push_head (queue, "baz");
  D.5137 = queue->length;
  if (D.5137 != 3) goto <D.5138>; else goto <D.5139>;
  <D.5138>:
  D.5140 = FAILED ("push failed");
  return D.5140;
  <D.5139>:
  D.5141 = queue->head;
  D.5142 = D.5141->prev;
  if (D.5142 != 0B) goto <D.5143>; else goto <D.5144>;
  <D.5143>:
  D.5140 = FAILED ("HEAD: prev is wrong");
  return D.5140;
  <D.5144>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s1_len = 3;
    if (__s1_len <= 3) goto <D.5146>; else goto <D.5147>;
    <D.5146>:
    {
      const unsigned char * __s2;
      int __result;

      D.5141 = queue->head;
      __s2 = D.5141->data;
      D.5148 = "baz";
      D.5149 = MEM[(const unsigned char *)D.5148];
      D.5150 = (int) D.5149;
      D.5151 = *__s2;
      D.5152 = (int) D.5151;
      __result = D.5150 - D.5152;
      {
        D.5153 = __s1_len != 0;
        D.5154 = __result == 0;
        D.5155 = D.5153 & D.5154;
        if (D.5155 != 0) goto <D.5156>; else goto <D.5157>;
        <D.5156>:
        D.5158 = &MEM[(void *)"baz" + 1B];
        D.5159 = *D.5158;
        D.5160 = (int) D.5159;
        D.5161 = __s2 + 1;
        D.5162 = *D.5161;
        D.5163 = (int) D.5162;
        __result = D.5160 - D.5163;
        D.5164 = __s1_len > 1;
        D.5154 = __result == 0;
        D.5165 = D.5164 & D.5154;
        if (D.5165 != 0) goto <D.5166>; else goto <D.5167>;
        <D.5166>:
        D.5168 = &MEM[(void *)"baz" + 2B];
        D.5169 = *D.5168;
        D.5170 = (int) D.5169;
        D.5171 = __s2 + 2;
        D.5172 = *D.5171;
        D.5173 = (int) D.5172;
        __result = D.5170 - D.5173;
        D.5174 = __s1_len > 2;
        D.5154 = __result == 0;
        D.5175 = D.5174 & D.5154;
        if (D.5175 != 0) goto <D.5176>; else goto <D.5177>;
        <D.5176>:
        D.5178 = &MEM[(void *)"baz" + 3B];
        D.5179 = *D.5178;
        D.5180 = (int) D.5179;
        D.5181 = __s2 + 3;
        D.5182 = *D.5181;
        D.5183 = (int) D.5182;
        __result = D.5180 - D.5183;
        <D.5177>:
        <D.5167>:
        <D.5157>:
      }
      D.4953 = __result;
    }
    iftmp.0 = D.4953;
    goto <D.5184>;
    <D.5147>:
    D.5141 = queue->head;
    D.5185 = D.5141->data;
    iftmp.0 = __builtin_strcmp ("baz", D.5185);
    <D.5184>:
    D.4957 = iftmp.0;
  }
  if (D.4957 != 0) goto <D.5186>; else goto <D.5187>;
  <D.5186>:
  D.5140 = FAILED ("HEAD: First element is wrong");
  return D.5140;
  <D.5187>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s1_len = 3;
    if (__s1_len <= 3) goto <D.5189>; else goto <D.5190>;
    <D.5189>:
    {
      const unsigned char * __s2;
      int __result;

      D.5141 = queue->head;
      D.5191 = D.5141->next;
      __s2 = D.5191->data;
      D.5192 = "bar";
      D.5193 = MEM[(const unsigned char *)D.5192];
      D.5194 = (int) D.5193;
      D.5195 = *__s2;
      D.5196 = (int) D.5195;
      __result = D.5194 - D.5196;
      {
        D.5197 = __s1_len != 0;
        D.5198 = __result == 0;
        D.5199 = D.5197 & D.5198;
        if (D.5199 != 0) goto <D.5200>; else goto <D.5201>;
        <D.5200>:
        D.5202 = &MEM[(void *)"bar" + 1B];
        D.5203 = *D.5202;
        D.5204 = (int) D.5203;
        D.5205 = __s2 + 1;
        D.5206 = *D.5205;
        D.5207 = (int) D.5206;
        __result = D.5204 - D.5207;
        D.5208 = __s1_len > 1;
        D.5198 = __result == 0;
        D.5209 = D.5208 & D.5198;
        if (D.5209 != 0) goto <D.5210>; else goto <D.5211>;
        <D.5210>:
        D.5212 = &MEM[(void *)"bar" + 2B];
        D.5213 = *D.5212;
        D.5214 = (int) D.5213;
        D.5215 = __s2 + 2;
        D.5216 = *D.5215;
        D.5217 = (int) D.5216;
        __result = D.5214 - D.5217;
        D.5218 = __s1_len > 2;
        D.5198 = __result == 0;
        D.5219 = D.5218 & D.5198;
        if (D.5219 != 0) goto <D.5220>; else goto <D.5221>;
        <D.5220>:
        D.5222 = &MEM[(void *)"bar" + 3B];
        D.5223 = *D.5222;
        D.5224 = (int) D.5223;
        D.5225 = __s2 + 3;
        D.5226 = *D.5225;
        D.5227 = (int) D.5226;
        __result = D.5224 - D.5227;
        <D.5221>:
        <D.5211>:
        <D.5201>:
      }
      D.4962 = __result;
    }
    iftmp.1 = D.4962;
    goto <D.5228>;
    <D.5190>:
    D.5141 = queue->head;
    D.5191 = D.5141->next;
    D.5229 = D.5191->data;
    iftmp.1 = __builtin_strcmp ("bar", D.5229);
    <D.5228>:
    D.4966 = iftmp.1;
  }
  if (D.4966 != 0) goto <D.5230>; else goto <D.5231>;
  <D.5230>:
  D.5140 = FAILED ("HEAD: Second element is wrong");
  return D.5140;
  <D.5231>:
  {
    size_t __s1_len;
    size_t __s2_len;

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

      D.5141 = queue->head;
      D.5191 = D.5141->next;
      D.5235 = D.5191->next;
      __s2 = D.5235->data;
      D.5236 = "foo";
      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 = __s1_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 *)"foo" + 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 = __s1_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 *)"foo" + 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 = __s1_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 *)"foo" + 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.4971 = __result;
    }
    iftmp.2 = D.4971;
    goto <D.5272>;
    <D.5234>:
    D.5141 = queue->head;
    D.5191 = D.5141->next;
    D.5235 = D.5191->next;
    D.5273 = D.5235->data;
    iftmp.2 = __builtin_strcmp ("foo", D.5273);
    <D.5272>:
    D.4975 = iftmp.2;
  }
  if (D.4975 != 0) goto <D.5274>; else goto <D.5275>;
  <D.5274>:
  D.5140 = FAILED ("HEAD: Third element is wrong");
  return D.5140;
  <D.5275>:
  D.5141 = queue->head;
  D.5191 = D.5141->next;
  D.5235 = D.5191->next;
  D.5276 = D.5235->next;
  if (D.5276 != 0B) goto <D.5277>; else goto <D.5278>;
  <D.5277>:
  D.5140 = FAILED ("HEAD: End is wrong");
  return D.5140;
  <D.5278>:
  D.5279 = queue->tail;
  D.5280 = D.5279->next;
  if (D.5280 != 0B) goto <D.5281>; else goto <D.5282>;
  <D.5281>:
  D.5140 = FAILED ("TAIL: next is wrong");
  return D.5140;
  <D.5282>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s1_len = 3;
    if (__s1_len <= 3) goto <D.5284>; else goto <D.5285>;
    <D.5284>:
    {
      const unsigned char * __s2;
      int __result;

      D.5279 = queue->tail;
      __s2 = D.5279->data;
      D.5236 = "foo";
      D.5237 = MEM[(const unsigned char *)D.5236];
      D.5238 = (int) D.5237;
      D.5286 = *__s2;
      D.5287 = (int) D.5286;
      __result = D.5238 - D.5287;
      {
        D.5288 = __s1_len != 0;
        D.5289 = __result == 0;
        D.5290 = D.5288 & D.5289;
        if (D.5290 != 0) goto <D.5291>; else goto <D.5292>;
        <D.5291>:
        D.5246 = &MEM[(void *)"foo" + 1B];
        D.5247 = *D.5246;
        D.5248 = (int) D.5247;
        D.5293 = __s2 + 1;
        D.5294 = *D.5293;
        D.5295 = (int) D.5294;
        __result = D.5248 - D.5295;
        D.5296 = __s1_len > 1;
        D.5289 = __result == 0;
        D.5297 = D.5296 & D.5289;
        if (D.5297 != 0) goto <D.5298>; else goto <D.5299>;
        <D.5298>:
        D.5256 = &MEM[(void *)"foo" + 2B];
        D.5257 = *D.5256;
        D.5258 = (int) D.5257;
        D.5300 = __s2 + 2;
        D.5301 = *D.5300;
        D.5302 = (int) D.5301;
        __result = D.5258 - D.5302;
        D.5303 = __s1_len > 2;
        D.5289 = __result == 0;
        D.5304 = D.5303 & D.5289;
        if (D.5304 != 0) goto <D.5305>; else goto <D.5306>;
        <D.5305>:
        D.5266 = &MEM[(void *)"foo" + 3B];
        D.5267 = *D.5266;
        D.5268 = (int) D.5267;
        D.5307 = __s2 + 3;
        D.5308 = *D.5307;
        D.5309 = (int) D.5308;
        __result = D.5268 - D.5309;
        <D.5306>:
        <D.5299>:
        <D.5292>:
      }
      D.4980 = __result;
    }
    iftmp.3 = D.4980;
    goto <D.5310>;
    <D.5285>:
    D.5279 = queue->tail;
    D.5311 = D.5279->data;
    iftmp.3 = __builtin_strcmp ("foo", D.5311);
    <D.5310>:
    D.4984 = iftmp.3;
  }
  if (D.4984 != 0) goto <D.5312>; else goto <D.5313>;
  <D.5312>:
  D.5140 = FAILED ("TAIL: Third element is wrong");
  return D.5140;
  <D.5313>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s1_len = 3;
    if (__s1_len <= 3) goto <D.5315>; else goto <D.5316>;
    <D.5315>:
    {
      const unsigned char * __s2;
      int __result;

      D.5279 = queue->tail;
      D.5317 = D.5279->prev;
      __s2 = D.5317->data;
      D.5192 = "bar";
      D.5193 = MEM[(const unsigned char *)D.5192];
      D.5194 = (int) D.5193;
      D.5318 = *__s2;
      D.5319 = (int) D.5318;
      __result = D.5194 - D.5319;
      {
        D.5320 = __s1_len != 0;
        D.5321 = __result == 0;
        D.5322 = D.5320 & D.5321;
        if (D.5322 != 0) goto <D.5323>; else goto <D.5324>;
        <D.5323>:
        D.5202 = &MEM[(void *)"bar" + 1B];
        D.5203 = *D.5202;
        D.5204 = (int) D.5203;
        D.5325 = __s2 + 1;
        D.5326 = *D.5325;
        D.5327 = (int) D.5326;
        __result = D.5204 - D.5327;
        D.5328 = __s1_len > 1;
        D.5321 = __result == 0;
        D.5329 = D.5328 & D.5321;
        if (D.5329 != 0) goto <D.5330>; else goto <D.5331>;
        <D.5330>:
        D.5212 = &MEM[(void *)"bar" + 2B];
        D.5213 = *D.5212;
        D.5214 = (int) D.5213;
        D.5332 = __s2 + 2;
        D.5333 = *D.5332;
        D.5334 = (int) D.5333;
        __result = D.5214 - D.5334;
        D.5335 = __s1_len > 2;
        D.5321 = __result == 0;
        D.5336 = D.5335 & D.5321;
        if (D.5336 != 0) goto <D.5337>; else goto <D.5338>;
        <D.5337>:
        D.5222 = &MEM[(void *)"bar" + 3B];
        D.5223 = *D.5222;
        D.5224 = (int) D.5223;
        D.5339 = __s2 + 3;
        D.5340 = *D.5339;
        D.5341 = (int) D.5340;
        __result = D.5224 - D.5341;
        <D.5338>:
        <D.5331>:
        <D.5324>:
      }
      D.4989 = __result;
    }
    iftmp.4 = D.4989;
    goto <D.5342>;
    <D.5316>:
    D.5279 = queue->tail;
    D.5317 = D.5279->prev;
    D.5343 = D.5317->data;
    iftmp.4 = __builtin_strcmp ("bar", D.5343);
    <D.5342>:
    D.4993 = iftmp.4;
  }
  if (D.4993 != 0) goto <D.5344>; else goto <D.5345>;
  <D.5344>:
  D.5140 = FAILED ("TAIL: Second element is wrong");
  return D.5140;
  <D.5345>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s1_len = 3;
    if (__s1_len <= 3) goto <D.5347>; else goto <D.5348>;
    <D.5347>:
    {
      const unsigned char * __s2;
      int __result;

      D.5279 = queue->tail;
      D.5317 = D.5279->prev;
      D.5349 = D.5317->prev;
      __s2 = D.5349->data;
      D.5148 = "baz";
      D.5149 = MEM[(const unsigned char *)D.5148];
      D.5150 = (int) D.5149;
      D.5350 = *__s2;
      D.5351 = (int) D.5350;
      __result = D.5150 - D.5351;
      {
        D.5352 = __s1_len != 0;
        D.5353 = __result == 0;
        D.5354 = D.5352 & D.5353;
        if (D.5354 != 0) goto <D.5355>; else goto <D.5356>;
        <D.5355>:
        D.5158 = &MEM[(void *)"baz" + 1B];
        D.5159 = *D.5158;
        D.5160 = (int) D.5159;
        D.5357 = __s2 + 1;
        D.5358 = *D.5357;
        D.5359 = (int) D.5358;
        __result = D.5160 - D.5359;
        D.5360 = __s1_len > 1;
        D.5353 = __result == 0;
        D.5361 = D.5360 & D.5353;
        if (D.5361 != 0) goto <D.5362>; else goto <D.5363>;
        <D.5362>:
        D.5168 = &MEM[(void *)"baz" + 2B];
        D.5169 = *D.5168;
        D.5170 = (int) D.5169;
        D.5364 = __s2 + 2;
        D.5365 = *D.5364;
        D.5366 = (int) D.5365;
        __result = D.5170 - D.5366;
        D.5367 = __s1_len > 2;
        D.5353 = __result == 0;
        D.5368 = D.5367 & D.5353;
        if (D.5368 != 0) goto <D.5369>; else goto <D.5370>;
        <D.5369>:
        D.5178 = &MEM[(void *)"baz" + 3B];
        D.5179 = *D.5178;
        D.5180 = (int) D.5179;
        D.5371 = __s2 + 3;
        D.5372 = *D.5371;
        D.5373 = (int) D.5372;
        __result = D.5180 - D.5373;
        <D.5370>:
        <D.5363>:
        <D.5356>:
      }
      D.4998 = __result;
    }
    iftmp.5 = D.4998;
    goto <D.5374>;
    <D.5348>:
    D.5279 = queue->tail;
    D.5317 = D.5279->prev;
    D.5349 = D.5317->prev;
    D.5375 = D.5349->data;
    iftmp.5 = __builtin_strcmp ("baz", D.5375);
    <D.5374>:
    D.5002 = iftmp.5;
  }
  if (D.5002 != 0) goto <D.5376>; else goto <D.5377>;
  <D.5376>:
  D.5140 = FAILED ("TAIL: First element is wrong");
  return D.5140;
  <D.5377>:
  D.5279 = queue->tail;
  D.5317 = D.5279->prev;
  D.5349 = D.5317->prev;
  D.5378 = D.5349->prev;
  if (D.5378 != 0B) goto <D.5379>; else goto <D.5380>;
  <D.5379>:
  D.5140 = FAILED ("TAIL: End is wrong");
  return D.5140;
  <D.5380>:
  monoeg_g_queue_free (queue);
  D.5140 = 0B;
  return D.5140;
}


test_queue_push_tail ()
{
  unsigned int D.5382;
  gchar * D.5385;
  struct GList * D.5386;
  struct GList * D.5387;
  int D.5014;
  int iftmp.6;
  int D.5010;
  char[4] * D.5393;
  unsigned char D.5394;
  int D.5395;
  unsigned char D.5396;
  int D.5397;
  _Bool D.5398;
  _Bool D.5399;
  _Bool D.5400;
  const unsigned char * D.5403;
  unsigned char D.5404;
  int D.5405;
  const unsigned char * D.5406;
  unsigned char D.5407;
  int D.5408;
  _Bool D.5409;
  _Bool D.5410;
  const unsigned char * D.5413;
  unsigned char D.5414;
  int D.5415;
  const unsigned char * D.5416;
  unsigned char D.5417;
  int D.5418;
  _Bool D.5419;
  _Bool D.5420;
  const unsigned char * D.5423;
  unsigned char D.5424;
  int D.5425;
  const unsigned char * D.5426;
  unsigned char D.5427;
  int D.5428;
  void * D.5430;
  int D.5023;
  int iftmp.7;
  int D.5019;
  struct GList * D.5436;
  char[4] * D.5437;
  unsigned char D.5438;
  int D.5439;
  unsigned char D.5440;
  int D.5441;
  _Bool D.5442;
  _Bool D.5443;
  _Bool D.5444;
  const unsigned char * D.5447;
  unsigned char D.5448;
  int D.5449;
  const unsigned char * D.5450;
  unsigned char D.5451;
  int D.5452;
  _Bool D.5453;
  _Bool D.5454;
  const unsigned char * D.5457;
  unsigned char D.5458;
  int D.5459;
  const unsigned char * D.5460;
  unsigned char D.5461;
  int D.5462;
  _Bool D.5463;
  _Bool D.5464;
  const unsigned char * D.5467;
  unsigned char D.5468;
  int D.5469;
  const unsigned char * D.5470;
  unsigned char D.5471;
  int D.5472;
  void * D.5474;
  int D.5032;
  int iftmp.8;
  int D.5028;
  struct GList * D.5480;
  char[4] * D.5481;
  unsigned char D.5482;
  int D.5483;
  unsigned char D.5484;
  int D.5485;
  _Bool D.5486;
  _Bool D.5487;
  _Bool D.5488;
  const unsigned char * D.5491;
  unsigned char D.5492;
  int D.5493;
  const unsigned char * D.5494;
  unsigned char D.5495;
  int D.5496;
  _Bool D.5497;
  _Bool D.5498;
  const unsigned char * D.5501;
  unsigned char D.5502;
  int D.5503;
  const unsigned char * D.5504;
  unsigned char D.5505;
  int D.5506;
  _Bool D.5507;
  _Bool D.5508;
  const unsigned char * D.5511;
  unsigned char D.5512;
  int D.5513;
  const unsigned char * D.5514;
  unsigned char D.5515;
  int D.5516;
  void * D.5518;
  struct GList * D.5521;
  struct GList * D.5524;
  struct GList * D.5525;
  int D.5041;
  int iftmp.9;
  int D.5037;
  unsigned char D.5531;
  int D.5532;
  _Bool D.5533;
  _Bool D.5534;
  _Bool D.5535;
  const unsigned char * D.5538;
  unsigned char D.5539;
  int D.5540;
  _Bool D.5541;
  _Bool D.5542;
  const unsigned char * D.5545;
  unsigned char D.5546;
  int D.5547;
  _Bool D.5548;
  _Bool D.5549;
  const unsigned char * D.5552;
  unsigned char D.5553;
  int D.5554;
  void * D.5556;
  int D.5050;
  int iftmp.10;
  int D.5046;
  struct GList * D.5562;
  unsigned char D.5563;
  int D.5564;
  _Bool D.5565;
  _Bool D.5566;
  _Bool D.5567;
  const unsigned char * D.5570;
  unsigned char D.5571;
  int D.5572;
  _Bool D.5573;
  _Bool D.5574;
  const unsigned char * D.5577;
  unsigned char D.5578;
  int D.5579;
  _Bool D.5580;
  _Bool D.5581;
  const unsigned char * D.5584;
  unsigned char D.5585;
  int D.5586;
  void * D.5588;
  int D.5059;
  int iftmp.11;
  int D.5055;
  struct GList * D.5594;
  unsigned char D.5595;
  int D.5596;
  _Bool D.5597;
  _Bool D.5598;
  _Bool D.5599;
  const unsigned char * D.5602;
  unsigned char D.5603;
  int D.5604;
  _Bool D.5605;
  _Bool D.5606;
  const unsigned char * D.5609;
  unsigned char D.5610;
  int D.5611;
  _Bool D.5612;
  _Bool D.5613;
  const unsigned char * D.5616;
  unsigned char D.5617;
  int D.5618;
  void * D.5620;
  struct GList * D.5623;
  struct GQueue * queue;

  queue = monoeg_g_queue_new ();
  monoeg_g_queue_push_tail (queue, "baz");
  monoeg_g_queue_push_tail (queue, "bar");
  monoeg_g_queue_push_tail (queue, "foo");
  D.5382 = queue->length;
  if (D.5382 != 3) goto <D.5383>; else goto <D.5384>;
  <D.5383>:
  D.5385 = FAILED ("push failed");
  return D.5385;
  <D.5384>:
  D.5386 = queue->head;
  D.5387 = D.5386->prev;
  if (D.5387 != 0B) goto <D.5388>; else goto <D.5389>;
  <D.5388>:
  D.5385 = FAILED ("HEAD: prev is wrong");
  return D.5385;
  <D.5389>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s1_len = 3;
    if (__s1_len <= 3) goto <D.5391>; else goto <D.5392>;
    <D.5391>:
    {
      const unsigned char * __s2;
      int __result;

      D.5386 = queue->head;
      __s2 = D.5386->data;
      D.5393 = "baz";
      D.5394 = MEM[(const unsigned char *)D.5393];
      D.5395 = (int) D.5394;
      D.5396 = *__s2;
      D.5397 = (int) D.5396;
      __result = D.5395 - D.5397;
      {
        D.5398 = __s1_len != 0;
        D.5399 = __result == 0;
        D.5400 = D.5398 & D.5399;
        if (D.5400 != 0) goto <D.5401>; else goto <D.5402>;
        <D.5401>:
        D.5403 = &MEM[(void *)"baz" + 1B];
        D.5404 = *D.5403;
        D.5405 = (int) D.5404;
        D.5406 = __s2 + 1;
        D.5407 = *D.5406;
        D.5408 = (int) D.5407;
        __result = D.5405 - D.5408;
        D.5409 = __s1_len > 1;
        D.5399 = __result == 0;
        D.5410 = D.5409 & D.5399;
        if (D.5410 != 0) goto <D.5411>; else goto <D.5412>;
        <D.5411>:
        D.5413 = &MEM[(void *)"baz" + 2B];
        D.5414 = *D.5413;
        D.5415 = (int) D.5414;
        D.5416 = __s2 + 2;
        D.5417 = *D.5416;
        D.5418 = (int) D.5417;
        __result = D.5415 - D.5418;
        D.5419 = __s1_len > 2;
        D.5399 = __result == 0;
        D.5420 = D.5419 & D.5399;
        if (D.5420 != 0) goto <D.5421>; else goto <D.5422>;
        <D.5421>:
        D.5423 = &MEM[(void *)"baz" + 3B];
        D.5424 = *D.5423;
        D.5425 = (int) D.5424;
        D.5426 = __s2 + 3;
        D.5427 = *D.5426;
        D.5428 = (int) D.5427;
        __result = D.5425 - D.5428;
        <D.5422>:
        <D.5412>:
        <D.5402>:
      }
      D.5010 = __result;
    }
    iftmp.6 = D.5010;
    goto <D.5429>;
    <D.5392>:
    D.5386 = queue->head;
    D.5430 = D.5386->data;
    iftmp.6 = __builtin_strcmp ("baz", D.5430);
    <D.5429>:
    D.5014 = iftmp.6;
  }
  if (D.5014 != 0) goto <D.5431>; else goto <D.5432>;
  <D.5431>:
  D.5385 = FAILED ("HEAD: First element is wrong");
  return D.5385;
  <D.5432>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s1_len = 3;
    if (__s1_len <= 3) goto <D.5434>; else goto <D.5435>;
    <D.5434>:
    {
      const unsigned char * __s2;
      int __result;

      D.5386 = queue->head;
      D.5436 = D.5386->next;
      __s2 = D.5436->data;
      D.5437 = "bar";
      D.5438 = MEM[(const unsigned char *)D.5437];
      D.5439 = (int) D.5438;
      D.5440 = *__s2;
      D.5441 = (int) D.5440;
      __result = D.5439 - D.5441;
      {
        D.5442 = __s1_len != 0;
        D.5443 = __result == 0;
        D.5444 = D.5442 & D.5443;
        if (D.5444 != 0) goto <D.5445>; else goto <D.5446>;
        <D.5445>:
        D.5447 = &MEM[(void *)"bar" + 1B];
        D.5448 = *D.5447;
        D.5449 = (int) D.5448;
        D.5450 = __s2 + 1;
        D.5451 = *D.5450;
        D.5452 = (int) D.5451;
        __result = D.5449 - D.5452;
        D.5453 = __s1_len > 1;
        D.5443 = __result == 0;
        D.5454 = D.5453 & D.5443;
        if (D.5454 != 0) goto <D.5455>; else goto <D.5456>;
        <D.5455>:
        D.5457 = &MEM[(void *)"bar" + 2B];
        D.5458 = *D.5457;
        D.5459 = (int) D.5458;
        D.5460 = __s2 + 2;
        D.5461 = *D.5460;
        D.5462 = (int) D.5461;
        __result = D.5459 - D.5462;
        D.5463 = __s1_len > 2;
        D.5443 = __result == 0;
        D.5464 = D.5463 & D.5443;
        if (D.5464 != 0) goto <D.5465>; else goto <D.5466>;
        <D.5465>:
        D.5467 = &MEM[(void *)"bar" + 3B];
        D.5468 = *D.5467;
        D.5469 = (int) D.5468;
        D.5470 = __s2 + 3;
        D.5471 = *D.5470;
        D.5472 = (int) D.5471;
        __result = D.5469 - D.5472;
        <D.5466>:
        <D.5456>:
        <D.5446>:
      }
      D.5019 = __result;
    }
    iftmp.7 = D.5019;
    goto <D.5473>;
    <D.5435>:
    D.5386 = queue->head;
    D.5436 = D.5386->next;
    D.5474 = D.5436->data;
    iftmp.7 = __builtin_strcmp ("bar", D.5474);
    <D.5473>:
    D.5023 = iftmp.7;
  }
  if (D.5023 != 0) goto <D.5475>; else goto <D.5476>;
  <D.5475>:
  D.5385 = FAILED ("HEAD: Second element is wrong");
  return D.5385;
  <D.5476>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s1_len = 3;
    if (__s1_len <= 3) goto <D.5478>; else goto <D.5479>;
    <D.5478>:
    {
      const unsigned char * __s2;
      int __result;

      D.5386 = queue->head;
      D.5436 = D.5386->next;
      D.5480 = D.5436->next;
      __s2 = D.5480->data;
      D.5481 = "foo";
      D.5482 = MEM[(const unsigned char *)D.5481];
      D.5483 = (int) D.5482;
      D.5484 = *__s2;
      D.5485 = (int) D.5484;
      __result = D.5483 - D.5485;
      {
        D.5486 = __s1_len != 0;
        D.5487 = __result == 0;
        D.5488 = D.5486 & D.5487;
        if (D.5488 != 0) goto <D.5489>; else goto <D.5490>;
        <D.5489>:
        D.5491 = &MEM[(void *)"foo" + 1B];
        D.5492 = *D.5491;
        D.5493 = (int) D.5492;
        D.5494 = __s2 + 1;
        D.5495 = *D.5494;
        D.5496 = (int) D.5495;
        __result = D.5493 - D.5496;
        D.5497 = __s1_len > 1;
        D.5487 = __result == 0;
        D.5498 = D.5497 & D.5487;
        if (D.5498 != 0) goto <D.5499>; else goto <D.5500>;
        <D.5499>:
        D.5501 = &MEM[(void *)"foo" + 2B];
        D.5502 = *D.5501;
        D.5503 = (int) D.5502;
        D.5504 = __s2 + 2;
        D.5505 = *D.5504;
        D.5506 = (int) D.5505;
        __result = D.5503 - D.5506;
        D.5507 = __s1_len > 2;
        D.5487 = __result == 0;
        D.5508 = D.5507 & D.5487;
        if (D.5508 != 0) goto <D.5509>; else goto <D.5510>;
        <D.5509>:
        D.5511 = &MEM[(void *)"foo" + 3B];
        D.5512 = *D.5511;
        D.5513 = (int) D.5512;
        D.5514 = __s2 + 3;
        D.5515 = *D.5514;
        D.5516 = (int) D.5515;
        __result = D.5513 - D.5516;
        <D.5510>:
        <D.5500>:
        <D.5490>:
      }
      D.5028 = __result;
    }
    iftmp.8 = D.5028;
    goto <D.5517>;
    <D.5479>:
    D.5386 = queue->head;
    D.5436 = D.5386->next;
    D.5480 = D.5436->next;
    D.5518 = D.5480->data;
    iftmp.8 = __builtin_strcmp ("foo", D.5518);
    <D.5517>:
    D.5032 = iftmp.8;
  }
  if (D.5032 != 0) goto <D.5519>; else goto <D.5520>;
  <D.5519>:
  D.5385 = FAILED ("HEAD: Third element is wrong");
  return D.5385;
  <D.5520>:
  D.5386 = queue->head;
  D.5436 = D.5386->next;
  D.5480 = D.5436->next;
  D.5521 = D.5480->next;
  if (D.5521 != 0B) goto <D.5522>; else goto <D.5523>;
  <D.5522>:
  D.5385 = FAILED ("HEAD: End is wrong");
  return D.5385;
  <D.5523>:
  D.5524 = queue->tail;
  D.5525 = D.5524->next;
  if (D.5525 != 0B) goto <D.5526>; else goto <D.5527>;
  <D.5526>:
  D.5385 = FAILED ("TAIL: next is wrong");
  return D.5385;
  <D.5527>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s1_len = 3;
    if (__s1_len <= 3) goto <D.5529>; else goto <D.5530>;
    <D.5529>:
    {
      const unsigned char * __s2;
      int __result;

      D.5524 = queue->tail;
      __s2 = D.5524->data;
      D.5481 = "foo";
      D.5482 = MEM[(const unsigned char *)D.5481];
      D.5483 = (int) D.5482;
      D.5531 = *__s2;
      D.5532 = (int) D.5531;
      __result = D.5483 - D.5532;
      {
        D.5533 = __s1_len != 0;
        D.5534 = __result == 0;
        D.5535 = D.5533 & D.5534;
        if (D.5535 != 0) goto <D.5536>; else goto <D.5537>;
        <D.5536>:
        D.5491 = &MEM[(void *)"foo" + 1B];
        D.5492 = *D.5491;
        D.5493 = (int) D.5492;
        D.5538 = __s2 + 1;
        D.5539 = *D.5538;
        D.5540 = (int) D.5539;
        __result = D.5493 - D.5540;
        D.5541 = __s1_len > 1;
        D.5534 = __result == 0;
        D.5542 = D.5541 & D.5534;
        if (D.5542 != 0) goto <D.5543>; else goto <D.5544>;
        <D.5543>:
        D.5501 = &MEM[(void *)"foo" + 2B];
        D.5502 = *D.5501;
        D.5503 = (int) D.5502;
        D.5545 = __s2 + 2;
        D.5546 = *D.5545;
        D.5547 = (int) D.5546;
        __result = D.5503 - D.5547;
        D.5548 = __s1_len > 2;
        D.5534 = __result == 0;
        D.5549 = D.5548 & D.5534;
        if (D.5549 != 0) goto <D.5550>; else goto <D.5551>;
        <D.5550>:
        D.5511 = &MEM[(void *)"foo" + 3B];
        D.5512 = *D.5511;
        D.5513 = (int) D.5512;
        D.5552 = __s2 + 3;
        D.5553 = *D.5552;
        D.5554 = (int) D.5553;
        __result = D.5513 - D.5554;
        <D.5551>:
        <D.5544>:
        <D.5537>:
      }
      D.5037 = __result;
    }
    iftmp.9 = D.5037;
    goto <D.5555>;
    <D.5530>:
    D.5524 = queue->tail;
    D.5556 = D.5524->data;
    iftmp.9 = __builtin_strcmp ("foo", D.5556);
    <D.5555>:
    D.5041 = iftmp.9;
  }
  if (D.5041 != 0) goto <D.5557>; else goto <D.5558>;
  <D.5557>:
  D.5385 = FAILED ("TAIL: Third element is wrong");
  return D.5385;
  <D.5558>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s1_len = 3;
    if (__s1_len <= 3) goto <D.5560>; else goto <D.5561>;
    <D.5560>:
    {
      const unsigned char * __s2;
      int __result;

      D.5524 = queue->tail;
      D.5562 = D.5524->prev;
      __s2 = D.5562->data;
      D.5437 = "bar";
      D.5438 = MEM[(const unsigned char *)D.5437];
      D.5439 = (int) D.5438;
      D.5563 = *__s2;
      D.5564 = (int) D.5563;
      __result = D.5439 - D.5564;
      {
        D.5565 = __s1_len != 0;
        D.5566 = __result == 0;
        D.5567 = D.5565 & D.5566;
        if (D.5567 != 0) goto <D.5568>; else goto <D.5569>;
        <D.5568>:
        D.5447 = &MEM[(void *)"bar" + 1B];
        D.5448 = *D.5447;
        D.5449 = (int) D.5448;
        D.5570 = __s2 + 1;
        D.5571 = *D.5570;
        D.5572 = (int) D.5571;
        __result = D.5449 - D.5572;
        D.5573 = __s1_len > 1;
        D.5566 = __result == 0;
        D.5574 = D.5573 & D.5566;
        if (D.5574 != 0) goto <D.5575>; else goto <D.5576>;
        <D.5575>:
        D.5457 = &MEM[(void *)"bar" + 2B];
        D.5458 = *D.5457;
        D.5459 = (int) D.5458;
        D.5577 = __s2 + 2;
        D.5578 = *D.5577;
        D.5579 = (int) D.5578;
        __result = D.5459 - D.5579;
        D.5580 = __s1_len > 2;
        D.5566 = __result == 0;
        D.5581 = D.5580 & D.5566;
        if (D.5581 != 0) goto <D.5582>; else goto <D.5583>;
        <D.5582>:
        D.5467 = &MEM[(void *)"bar" + 3B];
        D.5468 = *D.5467;
        D.5469 = (int) D.5468;
        D.5584 = __s2 + 3;
        D.5585 = *D.5584;
        D.5586 = (int) D.5585;
        __result = D.5469 - D.5586;
        <D.5583>:
        <D.5576>:
        <D.5569>:
      }
      D.5046 = __result;
    }
    iftmp.10 = D.5046;
    goto <D.5587>;
    <D.5561>:
    D.5524 = queue->tail;
    D.5562 = D.5524->prev;
    D.5588 = D.5562->data;
    iftmp.10 = __builtin_strcmp ("bar", D.5588);
    <D.5587>:
    D.5050 = iftmp.10;
  }
  if (D.5050 != 0) goto <D.5589>; else goto <D.5590>;
  <D.5589>:
  D.5385 = FAILED ("TAIL: Second element is wrong");
  return D.5385;
  <D.5590>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s1_len = 3;
    if (__s1_len <= 3) goto <D.5592>; else goto <D.5593>;
    <D.5592>:
    {
      const unsigned char * __s2;
      int __result;

      D.5524 = queue->tail;
      D.5562 = D.5524->prev;
      D.5594 = D.5562->prev;
      __s2 = D.5594->data;
      D.5393 = "baz";
      D.5394 = MEM[(const unsigned char *)D.5393];
      D.5395 = (int) D.5394;
      D.5595 = *__s2;
      D.5596 = (int) D.5595;
      __result = D.5395 - D.5596;
      {
        D.5597 = __s1_len != 0;
        D.5598 = __result == 0;
        D.5599 = D.5597 & D.5598;
        if (D.5599 != 0) goto <D.5600>; else goto <D.5601>;
        <D.5600>:
        D.5403 = &MEM[(void *)"baz" + 1B];
        D.5404 = *D.5403;
        D.5405 = (int) D.5404;
        D.5602 = __s2 + 1;
        D.5603 = *D.5602;
        D.5604 = (int) D.5603;
        __result = D.5405 - D.5604;
        D.5605 = __s1_len > 1;
        D.5598 = __result == 0;
        D.5606 = D.5605 & D.5598;
        if (D.5606 != 0) goto <D.5607>; else goto <D.5608>;
        <D.5607>:
        D.5413 = &MEM[(void *)"baz" + 2B];
        D.5414 = *D.5413;
        D.5415 = (int) D.5414;
        D.5609 = __s2 + 2;
        D.5610 = *D.5609;
        D.5611 = (int) D.5610;
        __result = D.5415 - D.5611;
        D.5612 = __s1_len > 2;
        D.5598 = __result == 0;
        D.5613 = D.5612 & D.5598;
        if (D.5613 != 0) goto <D.5614>; else goto <D.5615>;
        <D.5614>:
        D.5423 = &MEM[(void *)"baz" + 3B];
        D.5424 = *D.5423;
        D.5425 = (int) D.5424;
        D.5616 = __s2 + 3;
        D.5617 = *D.5616;
        D.5618 = (int) D.5617;
        __result = D.5425 - D.5618;
        <D.5615>:
        <D.5608>:
        <D.5601>:
      }
      D.5055 = __result;
    }
    iftmp.11 = D.5055;
    goto <D.5619>;
    <D.5593>:
    D.5524 = queue->tail;
    D.5562 = D.5524->prev;
    D.5594 = D.5562->prev;
    D.5620 = D.5594->data;
    iftmp.11 = __builtin_strcmp ("baz", D.5620);
    <D.5619>:
    D.5059 = iftmp.11;
  }
  if (D.5059 != 0) goto <D.5621>; else goto <D.5622>;
  <D.5621>:
  D.5385 = FAILED ("TAIL: First element is wrong");
  return D.5385;
  <D.5622>:
  D.5524 = queue->tail;
  D.5562 = D.5524->prev;
  D.5594 = D.5562->prev;
  D.5623 = D.5594->prev;
  if (D.5623 != 0B) goto <D.5624>; else goto <D.5625>;
  <D.5624>:
  D.5385 = FAILED ("TAIL: End is wrong");
  return D.5385;
  <D.5625>:
  monoeg_g_queue_free (queue);
  D.5385 = 0B;
  return D.5385;
}


test_queue_pop ()
{
  int D.5072;
  int iftmp.12;
  int D.5068;
  char[4] * D.5630;
  unsigned char D.5631;
  int D.5632;
  unsigned char D.5633;
  int D.5634;
  _Bool D.5635;
  _Bool D.5636;
  _Bool D.5637;
  const unsigned char * D.5640;
  unsigned char D.5641;
  int D.5642;
  const unsigned char * D.5643;
  unsigned char D.5644;
  int D.5645;
  _Bool D.5646;
  _Bool D.5647;
  const unsigned char * D.5650;
  unsigned char D.5651;
  int D.5652;
  const unsigned char * D.5653;
  unsigned char D.5654;
  int D.5655;
  _Bool D.5656;
  _Bool D.5657;
  const unsigned char * D.5660;
  unsigned char D.5661;
  int D.5662;
  const unsigned char * D.5663;
  unsigned char D.5664;
  int D.5665;
  gchar * D.5669;
  int D.5081;
  int iftmp.13;
  int D.5077;
  char[4] * D.5673;
  unsigned char D.5674;
  int D.5675;
  unsigned char D.5676;
  int D.5677;
  _Bool D.5678;
  _Bool D.5679;
  _Bool D.5680;
  const unsigned char * D.5683;
  unsigned char D.5684;
  int D.5685;
  const unsigned char * D.5686;
  unsigned char D.5687;
  int D.5688;
  _Bool D.5689;
  _Bool D.5690;
  const unsigned char * D.5693;
  unsigned char D.5694;
  int D.5695;
  const unsigned char * D.5696;
  unsigned char D.5697;
  int D.5698;
  _Bool D.5699;
  _Bool D.5700;
  const unsigned char * D.5703;
  unsigned char D.5704;
  int D.5705;
  const unsigned char * D.5706;
  unsigned char D.5707;
  int D.5708;
  int D.5090;
  int iftmp.14;
  int D.5086;
  char[4] * D.5715;
  unsigned char D.5716;
  int D.5717;
  unsigned char D.5718;
  int D.5719;
  _Bool D.5720;
  _Bool D.5721;
  _Bool D.5722;
  const unsigned char * D.5725;
  unsigned char D.5726;
  int D.5727;
  const unsigned char * D.5728;
  unsigned char D.5729;
  int D.5730;
  _Bool D.5731;
  _Bool D.5732;
  const unsigned char * D.5735;
  unsigned char D.5736;
  int D.5737;
  const unsigned char * D.5738;
  unsigned char D.5739;
  int D.5740;
  _Bool D.5741;
  _Bool D.5742;
  const unsigned char * D.5745;
  unsigned char D.5746;
  int D.5747;
  const unsigned char * D.5748;
  unsigned char D.5749;
  int D.5750;
  int D.5754;
  unsigned int D.5757;
  struct GList * D.5760;
  struct GList * D.5761;
  int D.5099;
  int iftmp.15;
  int D.5095;
  unsigned char D.5767;
  int D.5768;
  _Bool D.5769;
  _Bool D.5770;
  _Bool D.5771;
  const unsigned char * D.5774;
  unsigned char D.5775;
  int D.5776;
  _Bool D.5777;
  _Bool D.5778;
  const unsigned char * D.5781;
  unsigned char D.5782;
  int D.5783;
  _Bool D.5784;
  _Bool D.5785;
  const unsigned char * D.5788;
  unsigned char D.5789;
  int D.5790;
  void * D.5792;
  int D.5108;
  int iftmp.16;
  int D.5104;
  struct GList * D.5798;
  unsigned char D.5799;
  int D.5800;
  _Bool D.5801;
  _Bool D.5802;
  _Bool D.5803;
  const unsigned char * D.5806;
  unsigned char D.5807;
  int D.5808;
  _Bool D.5809;
  _Bool D.5810;
  const unsigned char * D.5813;
  unsigned char D.5814;
  int D.5815;
  _Bool D.5816;
  _Bool D.5817;
  const unsigned char * D.5820;
  unsigned char D.5821;
  int D.5822;
  void * D.5824;
  struct GList * D.5827;
  struct GList * D.5830;
  struct GList * D.5831;
  int D.5117;
  int iftmp.17;
  int D.5113;
  unsigned char D.5837;
  int D.5838;
  _Bool D.5839;
  _Bool D.5840;
  _Bool D.5841;
  const unsigned char * D.5844;
  unsigned char D.5845;
  int D.5846;
  _Bool D.5847;
  _Bool D.5848;
  const unsigned char * D.5851;
  unsigned char D.5852;
  int D.5853;
  _Bool D.5854;
  _Bool D.5855;
  const unsigned char * D.5858;
  unsigned char D.5859;
  int D.5860;
  void * D.5862;
  int D.5126;
  int iftmp.18;
  int D.5122;
  struct GList * D.5868;
  unsigned char D.5869;
  int D.5870;
  _Bool D.5871;
  _Bool D.5872;
  _Bool D.5873;
  const unsigned char * D.5876;
  unsigned char D.5877;
  int D.5878;
  _Bool D.5879;
  _Bool D.5880;
  const unsigned char * D.5883;
  unsigned char D.5884;
  int D.5885;
  _Bool D.5886;
  _Bool D.5887;
  const unsigned char * D.5890;
  unsigned char D.5891;
  int D.5892;
  void * D.5894;
  struct GList * D.5897;
  struct GQueue * queue;
  void * data;

  queue = monoeg_g_queue_new ();
  monoeg_g_queue_push_head (queue, "foo");
  monoeg_g_queue_push_head (queue, "bar");
  monoeg_g_queue_push_head (queue, "baz");
  data = monoeg_g_queue_pop_head (queue);
  {
    size_t __s1_len;
    size_t __s2_len;

    __s1_len = 3;
    if (__s1_len <= 3) goto <D.5628>; else goto <D.5629>;
    <D.5628>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = data;
      D.5630 = "baz";
      D.5631 = MEM[(const unsigned char *)D.5630];
      D.5632 = (int) D.5631;
      D.5633 = *__s2;
      D.5634 = (int) D.5633;
      __result = D.5632 - D.5634;
      {
        D.5635 = __s1_len != 0;
        D.5636 = __result == 0;
        D.5637 = D.5635 & D.5636;
        if (D.5637 != 0) goto <D.5638>; else goto <D.5639>;
        <D.5638>:
        D.5640 = &MEM[(void *)"baz" + 1B];
        D.5641 = *D.5640;
        D.5642 = (int) D.5641;
        D.5643 = __s2 + 1;
        D.5644 = *D.5643;
        D.5645 = (int) D.5644;
        __result = D.5642 - D.5645;
        D.5646 = __s1_len > 1;
        D.5636 = __result == 0;
        D.5647 = D.5646 & D.5636;
        if (D.5647 != 0) goto <D.5648>; else goto <D.5649>;
        <D.5648>:
        D.5650 = &MEM[(void *)"baz" + 2B];
        D.5651 = *D.5650;
        D.5652 = (int) D.5651;
        D.5653 = __s2 + 2;
        D.5654 = *D.5653;
        D.5655 = (int) D.5654;
        __result = D.5652 - D.5655;
        D.5656 = __s1_len > 2;
        D.5636 = __result == 0;
        D.5657 = D.5656 & D.5636;
        if (D.5657 != 0) goto <D.5658>; else goto <D.5659>;
        <D.5658>:
        D.5660 = &MEM[(void *)"baz" + 3B];
        D.5661 = *D.5660;
        D.5662 = (int) D.5661;
        D.5663 = __s2 + 3;
        D.5664 = *D.5663;
        D.5665 = (int) D.5664;
        __result = D.5662 - D.5665;
        <D.5659>:
        <D.5649>:
        <D.5639>:
      }
      D.5068 = __result;
    }
    iftmp.12 = D.5068;
    goto <D.5666>;
    <D.5629>:
    iftmp.12 = __builtin_strcmp ("baz", data);
    <D.5666>:
    D.5072 = iftmp.12;
  }
  if (D.5072 != 0) goto <D.5667>; else goto <D.5668>;
  <D.5667>:
  D.5669 = FAILED ("expect baz.");
  return D.5669;
  <D.5668>:
  data = monoeg_g_queue_pop_head (queue);
  {
    size_t __s1_len;
    size_t __s2_len;

    __s1_len = 3;
    if (__s1_len <= 3) goto <D.5671>; else goto <D.5672>;
    <D.5671>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = data;
      D.5673 = "bar";
      D.5674 = MEM[(const unsigned char *)D.5673];
      D.5675 = (int) D.5674;
      D.5676 = *__s2;
      D.5677 = (int) D.5676;
      __result = D.5675 - D.5677;
      {
        D.5678 = __s1_len != 0;
        D.5679 = __result == 0;
        D.5680 = D.5678 & D.5679;
        if (D.5680 != 0) goto <D.5681>; else goto <D.5682>;
        <D.5681>:
        D.5683 = &MEM[(void *)"bar" + 1B];
        D.5684 = *D.5683;
        D.5685 = (int) D.5684;
        D.5686 = __s2 + 1;
        D.5687 = *D.5686;
        D.5688 = (int) D.5687;
        __result = D.5685 - D.5688;
        D.5689 = __s1_len > 1;
        D.5679 = __result == 0;
        D.5690 = D.5689 & D.5679;
        if (D.5690 != 0) goto <D.5691>; else goto <D.5692>;
        <D.5691>:
        D.5693 = &MEM[(void *)"bar" + 2B];
        D.5694 = *D.5693;
        D.5695 = (int) D.5694;
        D.5696 = __s2 + 2;
        D.5697 = *D.5696;
        D.5698 = (int) D.5697;
        __result = D.5695 - D.5698;
        D.5699 = __s1_len > 2;
        D.5679 = __result == 0;
        D.5700 = D.5699 & D.5679;
        if (D.5700 != 0) goto <D.5701>; else goto <D.5702>;
        <D.5701>:
        D.5703 = &MEM[(void *)"bar" + 3B];
        D.5704 = *D.5703;
        D.5705 = (int) D.5704;
        D.5706 = __s2 + 3;
        D.5707 = *D.5706;
        D.5708 = (int) D.5707;
        __result = D.5705 - D.5708;
        <D.5702>:
        <D.5692>:
        <D.5682>:
      }
      D.5077 = __result;
    }
    iftmp.13 = D.5077;
    goto <D.5709>;
    <D.5672>:
    iftmp.13 = __builtin_strcmp ("bar", data);
    <D.5709>:
    D.5081 = iftmp.13;
  }
  if (D.5081 != 0) goto <D.5710>; else goto <D.5711>;
  <D.5710>:
  D.5669 = FAILED ("expect bar.");
  return D.5669;
  <D.5711>:
  data = monoeg_g_queue_pop_head (queue);
  {
    size_t __s1_len;
    size_t __s2_len;

    __s1_len = 3;
    if (__s1_len <= 3) goto <D.5713>; else goto <D.5714>;
    <D.5713>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = data;
      D.5715 = "foo";
      D.5716 = MEM[(const unsigned char *)D.5715];
      D.5717 = (int) D.5716;
      D.5718 = *__s2;
      D.5719 = (int) D.5718;
      __result = D.5717 - D.5719;
      {
        D.5720 = __s1_len != 0;
        D.5721 = __result == 0;
        D.5722 = D.5720 & D.5721;
        if (D.5722 != 0) goto <D.5723>; else goto <D.5724>;
        <D.5723>:
        D.5725 = &MEM[(void *)"foo" + 1B];
        D.5726 = *D.5725;
        D.5727 = (int) D.5726;
        D.5728 = __s2 + 1;
        D.5729 = *D.5728;
        D.5730 = (int) D.5729;
        __result = D.5727 - D.5730;
        D.5731 = __s1_len > 1;
        D.5721 = __result == 0;
        D.5732 = D.5731 & D.5721;
        if (D.5732 != 0) goto <D.5733>; else goto <D.5734>;
        <D.5733>:
        D.5735 = &MEM[(void *)"foo" + 2B];
        D.5736 = *D.5735;
        D.5737 = (int) D.5736;
        D.5738 = __s2 + 2;
        D.5739 = *D.5738;
        D.5740 = (int) D.5739;
        __result = D.5737 - D.5740;
        D.5741 = __s1_len > 2;
        D.5721 = __result == 0;
        D.5742 = D.5741 & D.5721;
        if (D.5742 != 0) goto <D.5743>; else goto <D.5744>;
        <D.5743>:
        D.5745 = &MEM[(void *)"foo" + 3B];
        D.5746 = *D.5745;
        D.5747 = (int) D.5746;
        D.5748 = __s2 + 3;
        D.5749 = *D.5748;
        D.5750 = (int) D.5749;
        __result = D.5747 - D.5750;
        <D.5744>:
        <D.5734>:
        <D.5724>:
      }
      D.5086 = __result;
    }
    iftmp.14 = D.5086;
    goto <D.5751>;
    <D.5714>:
    iftmp.14 = __builtin_strcmp ("foo", data);
    <D.5751>:
    D.5090 = iftmp.14;
  }
  if (D.5090 != 0) goto <D.5752>; else goto <D.5753>;
  <D.5752>:
  D.5669 = FAILED ("expect foo.");
  return D.5669;
  <D.5753>:
  D.5754 = monoeg_g_queue_is_empty (queue);
  if (D.5754 == 0) goto <D.5755>; else goto <D.5756>;
  <D.5755>:
  D.5669 = FAILED ("expect is_empty.");
  return D.5669;
  <D.5756>:
  D.5757 = queue->length;
  if (D.5757 != 0) goto <D.5758>; else goto <D.5759>;
  <D.5758>:
  D.5669 = FAILED ("expect 0 length .");
  return D.5669;
  <D.5759>:
  monoeg_g_queue_push_head (queue, "foo");
  monoeg_g_queue_push_head (queue, "bar");
  monoeg_g_queue_push_head (queue, "baz");
  monoeg_g_queue_pop_head (queue);
  D.5760 = queue->head;
  D.5761 = D.5760->prev;
  if (D.5761 != 0B) goto <D.5762>; else goto <D.5763>;
  <D.5762>:
  D.5669 = FAILED ("HEAD: prev is wrong");
  return D.5669;
  <D.5763>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s1_len = 3;
    if (__s1_len <= 3) goto <D.5765>; else goto <D.5766>;
    <D.5765>:
    {
      const unsigned char * __s2;
      int __result;

      D.5760 = queue->head;
      __s2 = D.5760->data;
      D.5673 = "bar";
      D.5674 = MEM[(const unsigned char *)D.5673];
      D.5675 = (int) D.5674;
      D.5767 = *__s2;
      D.5768 = (int) D.5767;
      __result = D.5675 - D.5768;
      {
        D.5769 = __s1_len != 0;
        D.5770 = __result == 0;
        D.5771 = D.5769 & D.5770;
        if (D.5771 != 0) goto <D.5772>; else goto <D.5773>;
        <D.5772>:
        D.5683 = &MEM[(void *)"bar" + 1B];
        D.5684 = *D.5683;
        D.5685 = (int) D.5684;
        D.5774 = __s2 + 1;
        D.5775 = *D.5774;
        D.5776 = (int) D.5775;
        __result = D.5685 - D.5776;
        D.5777 = __s1_len > 1;
        D.5770 = __result == 0;
        D.5778 = D.5777 & D.5770;
        if (D.5778 != 0) goto <D.5779>; else goto <D.5780>;
        <D.5779>:
        D.5693 = &MEM[(void *)"bar" + 2B];
        D.5694 = *D.5693;
        D.5695 = (int) D.5694;
        D.5781 = __s2 + 2;
        D.5782 = *D.5781;
        D.5783 = (int) D.5782;
        __result = D.5695 - D.5783;
        D.5784 = __s1_len > 2;
        D.5770 = __result == 0;
        D.5785 = D.5784 & D.5770;
        if (D.5785 != 0) goto <D.5786>; else goto <D.5787>;
        <D.5786>:
        D.5703 = &MEM[(void *)"bar" + 3B];
        D.5704 = *D.5703;
        D.5705 = (int) D.5704;
        D.5788 = __s2 + 3;
        D.5789 = *D.5788;
        D.5790 = (int) D.5789;
        __result = D.5705 - D.5790;
        <D.5787>:
        <D.5780>:
        <D.5773>:
      }
      D.5095 = __result;
    }
    iftmp.15 = D.5095;
    goto <D.5791>;
    <D.5766>:
    D.5760 = queue->head;
    D.5792 = D.5760->data;
    iftmp.15 = __builtin_strcmp ("bar", D.5792);
    <D.5791>:
    D.5099 = iftmp.15;
  }
  if (D.5099 != 0) goto <D.5793>; else goto <D.5794>;
  <D.5793>:
  D.5669 = FAILED ("HEAD: Second element is wrong");
  return D.5669;
  <D.5794>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s1_len = 3;
    if (__s1_len <= 3) goto <D.5796>; else goto <D.5797>;
    <D.5796>:
    {
      const unsigned char * __s2;
      int __result;

      D.5760 = queue->head;
      D.5798 = D.5760->next;
      __s2 = D.5798->data;
      D.5715 = "foo";
      D.5716 = MEM[(const unsigned char *)D.5715];
      D.5717 = (int) D.5716;
      D.5799 = *__s2;
      D.5800 = (int) D.5799;
      __result = D.5717 - D.5800;
      {
        D.5801 = __s1_len != 0;
        D.5802 = __result == 0;
        D.5803 = D.5801 & D.5802;
        if (D.5803 != 0) goto <D.5804>; else goto <D.5805>;
        <D.5804>:
        D.5725 = &MEM[(void *)"foo" + 1B];
        D.5726 = *D.5725;
        D.5727 = (int) D.5726;
        D.5806 = __s2 + 1;
        D.5807 = *D.5806;
        D.5808 = (int) D.5807;
        __result = D.5727 - D.5808;
        D.5809 = __s1_len > 1;
        D.5802 = __result == 0;
        D.5810 = D.5809 & D.5802;
        if (D.5810 != 0) goto <D.5811>; else goto <D.5812>;
        <D.5811>:
        D.5735 = &MEM[(void *)"foo" + 2B];
        D.5736 = *D.5735;
        D.5737 = (int) D.5736;
        D.5813 = __s2 + 2;
        D.5814 = *D.5813;
        D.5815 = (int) D.5814;
        __result = D.5737 - D.5815;
        D.5816 = __s1_len > 2;
        D.5802 = __result == 0;
        D.5817 = D.5816 & D.5802;
        if (D.5817 != 0) goto <D.5818>; else goto <D.5819>;
        <D.5818>:
        D.5745 = &MEM[(void *)"foo" + 3B];
        D.5746 = *D.5745;
        D.5747 = (int) D.5746;
        D.5820 = __s2 + 3;
        D.5821 = *D.5820;
        D.5822 = (int) D.5821;
        __result = D.5747 - D.5822;
        <D.5819>:
        <D.5812>:
        <D.5805>:
      }
      D.5104 = __result;
    }
    iftmp.16 = D.5104;
    goto <D.5823>;
    <D.5797>:
    D.5760 = queue->head;
    D.5798 = D.5760->next;
    D.5824 = D.5798->data;
    iftmp.16 = __builtin_strcmp ("foo", D.5824);
    <D.5823>:
    D.5108 = iftmp.16;
  }
  if (D.5108 != 0) goto <D.5825>; else goto <D.5826>;
  <D.5825>:
  D.5669 = FAILED ("HEAD: Third element is wrong");
  return D.5669;
  <D.5826>:
  D.5760 = queue->head;
  D.5798 = D.5760->next;
  D.5827 = D.5798->next;
  if (D.5827 != 0B) goto <D.5828>; else goto <D.5829>;
  <D.5828>:
  D.5669 = FAILED ("HEAD: End is wrong");
  return D.5669;
  <D.5829>:
  D.5830 = queue->tail;
  D.5831 = D.5830->next;
  if (D.5831 != 0B) goto <D.5832>; else goto <D.5833>;
  <D.5832>:
  D.5669 = FAILED ("TAIL: next is wrong");
  return D.5669;
  <D.5833>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s1_len = 3;
    if (__s1_len <= 3) goto <D.5835>; else goto <D.5836>;
    <D.5835>:
    {
      const unsigned char * __s2;
      int __result;

      D.5830 = queue->tail;
      __s2 = D.5830->data;
      D.5715 = "foo";
      D.5716 = MEM[(const unsigned char *)D.5715];
      D.5717 = (int) D.5716;
      D.5837 = *__s2;
      D.5838 = (int) D.5837;
      __result = D.5717 - D.5838;
      {
        D.5839 = __s1_len != 0;
        D.5840 = __result == 0;
        D.5841 = D.5839 & D.5840;
        if (D.5841 != 0) goto <D.5842>; else goto <D.5843>;
        <D.5842>:
        D.5725 = &MEM[(void *)"foo" + 1B];
        D.5726 = *D.5725;
        D.5727 = (int) D.5726;
        D.5844 = __s2 + 1;
        D.5845 = *D.5844;
        D.5846 = (int) D.5845;
        __result = D.5727 - D.5846;
        D.5847 = __s1_len > 1;
        D.5840 = __result == 0;
        D.5848 = D.5847 & D.5840;
        if (D.5848 != 0) goto <D.5849>; else goto <D.5850>;
        <D.5849>:
        D.5735 = &MEM[(void *)"foo" + 2B];
        D.5736 = *D.5735;
        D.5737 = (int) D.5736;
        D.5851 = __s2 + 2;
        D.5852 = *D.5851;
        D.5853 = (int) D.5852;
        __result = D.5737 - D.5853;
        D.5854 = __s1_len > 2;
        D.5840 = __result == 0;
        D.5855 = D.5854 & D.5840;
        if (D.5855 != 0) goto <D.5856>; else goto <D.5857>;
        <D.5856>:
        D.5745 = &MEM[(void *)"foo" + 3B];
        D.5746 = *D.5745;
        D.5747 = (int) D.5746;
        D.5858 = __s2 + 3;
        D.5859 = *D.5858;
        D.5860 = (int) D.5859;
        __result = D.5747 - D.5860;
        <D.5857>:
        <D.5850>:
        <D.5843>:
      }
      D.5113 = __result;
    }
    iftmp.17 = D.5113;
    goto <D.5861>;
    <D.5836>:
    D.5830 = queue->tail;
    D.5862 = D.5830->data;
    iftmp.17 = __builtin_strcmp ("foo", D.5862);
    <D.5861>:
    D.5117 = iftmp.17;
  }
  if (D.5117 != 0) goto <D.5863>; else goto <D.5864>;
  <D.5863>:
  D.5669 = FAILED ("TAIL: Second element is wrong");
  return D.5669;
  <D.5864>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s1_len = 3;
    if (__s1_len <= 3) goto <D.5866>; else goto <D.5867>;
    <D.5866>:
    {
      const unsigned char * __s2;
      int __result;

      D.5830 = queue->tail;
      D.5868 = D.5830->prev;
      __s2 = D.5868->data;
      D.5673 = "bar";
      D.5674 = MEM[(const unsigned char *)D.5673];
      D.5675 = (int) D.5674;
      D.5869 = *__s2;
      D.5870 = (int) D.5869;
      __result = D.5675 - D.5870;
      {
        D.5871 = __s1_len != 0;
        D.5872 = __result == 0;
        D.5873 = D.5871 & D.5872;
        if (D.5873 != 0) goto <D.5874>; else goto <D.5875>;
        <D.5874>:
        D.5683 = &MEM[(void *)"bar" + 1B];
        D.5684 = *D.5683;
        D.5685 = (int) D.5684;
        D.5876 = __s2 + 1;
        D.5877 = *D.5876;
        D.5878 = (int) D.5877;
        __result = D.5685 - D.5878;
        D.5879 = __s1_len > 1;
        D.5872 = __result == 0;
        D.5880 = D.5879 & D.5872;
        if (D.5880 != 0) goto <D.5881>; else goto <D.5882>;
        <D.5881>:
        D.5693 = &MEM[(void *)"bar" + 2B];
        D.5694 = *D.5693;
        D.5695 = (int) D.5694;
        D.5883 = __s2 + 2;
        D.5884 = *D.5883;
        D.5885 = (int) D.5884;
        __result = D.5695 - D.5885;
        D.5886 = __s1_len > 2;
        D.5872 = __result == 0;
        D.5887 = D.5886 & D.5872;
        if (D.5887 != 0) goto <D.5888>; else goto <D.5889>;
        <D.5888>:
        D.5703 = &MEM[(void *)"bar" + 3B];
        D.5704 = *D.5703;
        D.5705 = (int) D.5704;
        D.5890 = __s2 + 3;
        D.5891 = *D.5890;
        D.5892 = (int) D.5891;
        __result = D.5705 - D.5892;
        <D.5889>:
        <D.5882>:
        <D.5875>:
      }
      D.5122 = __result;
    }
    iftmp.18 = D.5122;
    goto <D.5893>;
    <D.5867>:
    D.5830 = queue->tail;
    D.5868 = D.5830->prev;
    D.5894 = D.5868->data;
    iftmp.18 = __builtin_strcmp ("bar", D.5894);
    <D.5893>:
    D.5126 = iftmp.18;
  }
  if (D.5126 != 0) goto <D.5895>; else goto <D.5896>;
  <D.5895>:
  D.5669 = FAILED ("TAIL: First element is wrong");
  return D.5669;
  <D.5896>:
  D.5830 = queue->tail;
  D.5868 = D.5830->prev;
  D.5897 = D.5868->prev;
  if (D.5897 != 0B) goto <D.5898>; else goto <D.5899>;
  <D.5898>:
  D.5669 = FAILED ("TAIL: End is wrong");
  return D.5669;
  <D.5899>:
  monoeg_g_queue_free (queue);
  D.5669 = 0B;
  return D.5669;
}


test_queue_new ()
{
  unsigned int D.5901;
  gchar * D.5904;
  struct GList * D.5905;
  struct GList * D.5908;
  struct GQueue * queue;

  queue = monoeg_g_queue_new ();
  D.5901 = queue->length;
  if (D.5901 != 0) goto <D.5902>; else goto <D.5903>;
  <D.5902>:
  D.5904 = FAILED ("expect length == 0");
  return D.5904;
  <D.5903>:
  D.5905 = queue->head;
  if (D.5905 != 0B) goto <D.5906>; else goto <D.5907>;
  <D.5906>:
  D.5904 = FAILED ("expect head == NULL");
  return D.5904;
  <D.5907>:
  D.5908 = queue->tail;
  if (D.5908 != 0B) goto <D.5909>; else goto <D.5910>;
  <D.5909>:
  D.5904 = FAILED ("expect tail == NULL");
  return D.5904;
  <D.5910>:
  monoeg_g_queue_free (queue);
  D.5904 = 0B;
  return D.5904;
}


test_queue_is_empty ()
{
  int D.5912;
  gchar * D.5915;
  int D.5916;
  struct GQueue * queue;

  queue = monoeg_g_queue_new ();
  D.5912 = monoeg_g_queue_is_empty (queue);
  if (D.5912 == 0) goto <D.5913>; else goto <D.5914>;
  <D.5913>:
  D.5915 = FAILED ("new queue should be empty");
  return D.5915;
  <D.5914>:
  monoeg_g_queue_push_head (queue, "foo");
  D.5916 = monoeg_g_queue_is_empty (queue);
  if (D.5916 == 1) goto <D.5917>; else goto <D.5918>;
  <D.5917>:
  D.5915 = FAILED ("expected TRUE");
  return D.5915;
  <D.5918>:
  monoeg_g_queue_free (queue);
  D.5915 = 0B;
  return D.5915;
}


queue_tests_init ()
{
  struct Test * D.5920;

  D.5920 = &queue_tests;
  return D.5920;
}