monoeg_g_iconv_open (const char * to_charset, const char * from_charset)
{
  _Bool D.5338;
  _Bool D.5339;
  _Bool D.5340;
  char D.5342;
  char D.5344;
  int * D.5345;
  struct _GIConv * D.5346;
  const char * D.5347;
  int D.5348;
  int D.5351;
  _Bool D.5354;
  _Bool D.5355;
  _Bool D.5356;
  void * icd;
  int (*Decoder) (char *, size_t, gunichar *) decoder;
  int (*Encoder) (gunichar, char *, size_t) encoder;
  struct _GIConv * cd;
  guint i;

  icd = -1B;
  decoder = 0B;
  encoder = 0B;
  D.5338 = to_charset == 0B;
  D.5339 = from_charset == 0B;
  D.5340 = D.5338 | D.5339;
  if (D.5340 != 0) goto <D.5336>; else goto <D.5341>;
  <D.5341>:
  D.5342 = *to_charset;
  if (D.5342 == 0) goto <D.5336>; else goto <D.5343>;
  <D.5343>:
  D.5344 = *from_charset;
  if (D.5344 == 0) goto <D.5336>; else goto <D.5337>;
  <D.5336>:
  D.5345 = __errno_location ();
  *D.5345 = 22;
  D.5346 = -1B;
  return D.5346;
  <D.5337>:
  i = 0;
  goto <D.5012>;
  <D.5011>:
  D.5347 = charsets[i].name;
  D.5348 = monoeg_ascii_strcasecmp (D.5347, from_charset);
  if (D.5348 == 0) goto <D.5349>; else goto <D.5350>;
  <D.5349>:
  decoder = charsets[i].decoder;
  <D.5350>:
  D.5347 = charsets[i].name;
  D.5351 = monoeg_ascii_strcasecmp (D.5347, to_charset);
  if (D.5351 == 0) goto <D.5352>; else goto <D.5353>;
  <D.5352>:
  encoder = charsets[i].encoder;
  <D.5353>:
  i = i + 1;
  <D.5012>:
  if (i <= 14) goto <D.5011>; else goto <D.5013>;
  <D.5013>:
  D.5354 = encoder == 0B;
  D.5355 = decoder == 0B;
  D.5356 = D.5354 | D.5355;
  if (D.5356 != 0) goto <D.5357>; else goto <D.5358>;
  <D.5357>:
  icd = iconv_open (to_charset, from_charset);
  if (icd == -1B) goto <D.5359>; else goto <D.5360>;
  <D.5359>:
  D.5346 = -1B;
  return D.5346;
  <D.5360>:
  <D.5358>:
  cd = monoeg_malloc (32);
  cd->decode = decoder;
  cd->encode = encoder;
  cd->c = 4294967295;
  cd->cd = icd;
  D.5346 = cd;
  return D.5346;
}


encode_utf8 (gunichar c, char * outbuf, size_t outleft)
{
  unsigned char D.5364;
  int D.5365;
  long unsigned int D.5378;
  int * D.5381;
  sizetype D.5382;
  unsigned char * D.5383;
  unsigned char D.5384;
  unsigned char D.5385;
  unsigned char D.5386;
  unsigned char D.5387;
  unsigned char * outptr;
  int base;
  int n;
  int i;

  outptr = outbuf;
  if (c <= 127) goto <D.5362>; else goto <D.5363>;
  <D.5362>:
  D.5364 = (unsigned char) c;
  *outptr = D.5364;
  D.5365 = 1;
  return D.5365;
  <D.5363>:
  if (c <= 2047) goto <D.5366>; else goto <D.5367>;
  <D.5366>:
  base = 192;
  n = 2;
  goto <D.5368>;
  <D.5367>:
  if (c <= 65535) goto <D.5369>; else goto <D.5370>;
  <D.5369>:
  base = 224;
  n = 3;
  goto <D.5371>;
  <D.5370>:
  if (c <= 2097151) goto <D.5372>; else goto <D.5373>;
  <D.5372>:
  base = 240;
  n = 4;
  goto <D.5374>;
  <D.5373>:
  if (c <= 67108863) goto <D.5375>; else goto <D.5376>;
  <D.5375>:
  base = 248;
  n = 5;
  goto <D.5377>;
  <D.5376>:
  base = 252;
  n = 6;
  <D.5377>:
  <D.5374>:
  <D.5371>:
  <D.5368>:
  D.5378 = (long unsigned int) n;
  if (D.5378 > outleft) goto <D.5379>; else goto <D.5380>;
  <D.5379>:
  D.5381 = __errno_location ();
  *D.5381 = 7;
  D.5365 = -1;
  return D.5365;
  <D.5380>:
  i = n + -1;
  goto <D.5118>;
  <D.5117>:
  D.5382 = (sizetype) i;
  D.5383 = outptr + D.5382;
  D.5364 = (unsigned char) c;
  D.5384 = D.5364 & 63;
  D.5385 = D.5384 | 128;
  *D.5383 = D.5385;
  c = c >> 6;
  i = i + -1;
  <D.5118>:
  if (i > 0) goto <D.5117>; else goto <D.5119>;
  <D.5119>:
  D.5364 = (unsigned char) c;
  D.5386 = (unsigned char) base;
  D.5387 = D.5364 | D.5386;
  *outptr = D.5387;
  D.5365 = n;
  return D.5365;
}


decode_utf8 (char * inbuf, size_t inleft, gunichar * outchar)
{
  unsigned char D.5389;
  int D.5392;
  int * D.5395;
  long unsigned int D.5411;
  unsigned int D.5414;
  unsigned char D.5415;
  unsigned int D.5416;
  unsigned char * inptr;
  gunichar u;
  int n;
  int i;

  inptr = inbuf;
  D.5389 = *inptr;
  u = (gunichar) D.5389;
  if (u <= 127) goto <D.5390>; else goto <D.5391>;
  <D.5390>:
  *outchar = u;
  D.5392 = 1;
  return D.5392;
  <D.5391>:
  if (u <= 193) goto <D.5393>; else goto <D.5394>;
  <D.5393>:
  D.5395 = __errno_location ();
  *D.5395 = 84;
  D.5392 = -1;
  return D.5392;
  <D.5394>:
  if (u <= 223) goto <D.5396>; else goto <D.5397>;
  <D.5396>:
  u = u & 31;
  n = 2;
  goto <D.5398>;
  <D.5397>:
  if (u <= 239) goto <D.5399>; else goto <D.5400>;
  <D.5399>:
  u = u & 15;
  n = 3;
  goto <D.5401>;
  <D.5400>:
  if (u <= 247) goto <D.5402>; else goto <D.5403>;
  <D.5402>:
  u = u & 7;
  n = 4;
  goto <D.5404>;
  <D.5403>:
  if (u <= 251) goto <D.5405>; else goto <D.5406>;
  <D.5405>:
  u = u & 3;
  n = 5;
  goto <D.5407>;
  <D.5406>:
  if (u <= 253) goto <D.5408>; else goto <D.5409>;
  <D.5408>:
  u = u & 1;
  n = 6;
  goto <D.5410>;
  <D.5409>:
  D.5395 = __errno_location ();
  *D.5395 = 84;
  D.5392 = -1;
  return D.5392;
  <D.5410>:
  <D.5407>:
  <D.5404>:
  <D.5401>:
  <D.5398>:
  D.5411 = (long unsigned int) n;
  if (D.5411 > inleft) goto <D.5412>; else goto <D.5413>;
  <D.5412>:
  D.5395 = __errno_location ();
  *D.5395 = 22;
  D.5392 = -1;
  return D.5392;
  <D.5413>:
  i = 1;
  goto <D.5106>;
  <D.5105>:
  D.5414 = u << 6;
  inptr = inptr + 1;
  D.5389 = *inptr;
  D.5415 = D.5389 ^ 128;
  D.5416 = (unsigned int) D.5415;
  u = D.5414 | D.5416;
  i = i + 1;
  <D.5106>:
  if (i < n) goto <D.5105>; else goto <D.5107>;
  <D.5107>:
  *outchar = u;
  D.5392 = n;
  return D.5392;
}


encode_utf16le (gunichar c, char * outbuf, size_t outleft)
{
  int * D.5422;
  int D.5423;
  unsigned char D.5424;
  unsigned char * D.5425;
  unsigned int D.5426;
  unsigned char D.5427;
  unsigned int D.5430;
  short unsigned int D.5431;
  unsigned char D.5432;
  short unsigned int D.5433;
  unsigned char D.5434;
  short unsigned int D.5435;
  short unsigned int D.5436;
  unsigned char * D.5437;
  unsigned char * D.5438;
  unsigned char * outptr;
  gunichar2 ch;
  gunichar c2;

  outptr = outbuf;
  if (c <= 65535) goto <D.5418>; else goto <D.5419>;
  <D.5418>:
  if (outleft <= 1) goto <D.5420>; else goto <D.5421>;
  <D.5420>:
  D.5422 = __errno_location ();
  *D.5422 = 7;
  D.5423 = -1;
  return D.5423;
  <D.5421>:
  D.5424 = (unsigned char) c;
  *outptr = D.5424;
  D.5425 = outptr + 1;
  D.5426 = c >> 8;
  D.5427 = (unsigned char) D.5426;
  *D.5425 = D.5427;
  D.5423 = 2;
  return D.5423;
  <D.5419>:
  if (outleft <= 3) goto <D.5428>; else goto <D.5429>;
  <D.5428>:
  D.5422 = __errno_location ();
  *D.5422 = 7;
  D.5423 = -1;
  return D.5423;
  <D.5429>:
  c2 = c + 4294901760;
  D.5430 = c2 >> 10;
  D.5431 = (short unsigned int) D.5430;
  ch = D.5431 + 55296;
  D.5432 = (unsigned char) ch;
  *outptr = D.5432;
  D.5425 = outptr + 1;
  D.5433 = ch >> 8;
  D.5434 = (unsigned char) D.5433;
  *D.5425 = D.5434;
  D.5435 = (short unsigned int) c2;
  D.5436 = D.5435 & 1023;
  ch = D.5436 + 56320;
  D.5437 = outptr + 2;
  D.5432 = (unsigned char) ch;
  *D.5437 = D.5432;
  D.5438 = outptr + 3;
  D.5433 = ch >> 8;
  D.5434 = (unsigned char) D.5433;
  *D.5438 = D.5434;
  D.5423 = 4;
  return D.5423;
}


decode_utf16le (char * inbuf, size_t inleft, gunichar * outchar)
{
  int * D.5442;
  int D.5443;
  unsigned char * D.5444;
  unsigned char D.5445;
  int D.5446;
  int D.5447;
  unsigned char D.5448;
  int D.5449;
  int D.5450;
  unsigned char * D.5457;
  unsigned char D.5458;
  int D.5459;
  int D.5460;
  signed short D.5461;
  unsigned char * D.5462;
  unsigned char D.5463;
  signed short D.5464;
  signed short D.5465;
  short unsigned int D.5466;
  unsigned int D.5469;
  unsigned int D.5470;
  unsigned int D.5471;
  unsigned int D.5472;
  unsigned char * inptr;
  gunichar2 c;
  gunichar u;

  inptr = inbuf;
  if (inleft <= 1) goto <D.5440>; else goto <D.5441>;
  <D.5440>:
  D.5442 = __errno_location ();
  *D.5442 = 22;
  D.5443 = -1;
  return D.5443;
  <D.5441>:
  D.5444 = inptr + 1;
  D.5445 = *D.5444;
  D.5446 = (int) D.5445;
  D.5447 = D.5446 << 8;
  D.5448 = *inptr;
  D.5449 = (int) D.5448;
  D.5450 = D.5447 | D.5449;
  u = (gunichar) D.5450;
  if (u <= 55295) goto <D.5451>; else goto <D.5452>;
  <D.5451>:
  *outchar = u;
  D.5443 = 2;
  return D.5443;
  <D.5452>:
  if (u <= 56319) goto <D.5453>; else goto <D.5454>;
  <D.5453>:
  if (inleft <= 3) goto <D.5455>; else goto <D.5456>;
  <D.5455>:
  D.5442 = __errno_location ();
  *D.5442 = 22;
  D.5443 = -2;
  return D.5443;
  <D.5456>:
  D.5457 = inptr + 3;
  D.5458 = *D.5457;
  D.5459 = (int) D.5458;
  D.5460 = D.5459 << 8;
  D.5461 = (signed short) D.5460;
  D.5462 = inptr + 2;
  D.5463 = *D.5462;
  D.5464 = (signed short) D.5463;
  D.5465 = D.5461 | D.5464;
  c = (gunichar2) D.5465;
  D.5466 = c + 9216;
  if (D.5466 > 1023) goto <D.5467>; else goto <D.5468>;
  <D.5467>:
  D.5442 = __errno_location ();
  *D.5442 = 84;
  D.5443 = -2;
  return D.5443;
  <D.5468>:
  D.5469 = u + 4294912000;
  D.5470 = D.5469 << 10;
  D.5471 = (unsigned int) c;
  D.5472 = D.5470 + D.5471;
  u = D.5472 + 9216;
  *outchar = u;
  D.5443 = 4;
  return D.5443;
  <D.5454>:
  if (u <= 57343) goto <D.5473>; else goto <D.5474>;
  <D.5473>:
  D.5442 = __errno_location ();
  *D.5442 = 84;
  D.5443 = -1;
  return D.5443;
  <D.5474>:
  *outchar = u;
  D.5443 = 2;
  return D.5443;
}


encode_utf16be (gunichar c, char * outbuf, size_t outleft)
{
  int * D.5480;
  int D.5481;
  unsigned int D.5482;
  unsigned char D.5483;
  unsigned char * D.5484;
  unsigned char D.5485;
  unsigned int D.5488;
  short unsigned int D.5489;
  short unsigned int D.5490;
  unsigned char D.5491;
  unsigned char D.5492;
  short unsigned int D.5493;
  short unsigned int D.5494;
  unsigned char * D.5495;
  unsigned char * D.5496;
  unsigned char * outptr;
  gunichar2 ch;
  gunichar c2;

  outptr = outbuf;
  if (c <= 65535) goto <D.5476>; else goto <D.5477>;
  <D.5476>:
  if (outleft <= 1) goto <D.5478>; else goto <D.5479>;
  <D.5478>:
  D.5480 = __errno_location ();
  *D.5480 = 7;
  D.5481 = -1;
  return D.5481;
  <D.5479>:
  D.5482 = c >> 8;
  D.5483 = (unsigned char) D.5482;
  *outptr = D.5483;
  D.5484 = outptr + 1;
  D.5485 = (unsigned char) c;
  *D.5484 = D.5485;
  D.5481 = 2;
  return D.5481;
  <D.5477>:
  if (outleft <= 3) goto <D.5486>; else goto <D.5487>;
  <D.5486>:
  D.5480 = __errno_location ();
  *D.5480 = 7;
  D.5481 = -1;
  return D.5481;
  <D.5487>:
  c2 = c + 4294901760;
  D.5488 = c2 >> 10;
  D.5489 = (short unsigned int) D.5488;
  ch = D.5489 + 55296;
  D.5490 = ch >> 8;
  D.5491 = (unsigned char) D.5490;
  *outptr = D.5491;
  D.5484 = outptr + 1;
  D.5492 = (unsigned char) ch;
  *D.5484 = D.5492;
  D.5493 = (short unsigned int) c2;
  D.5494 = D.5493 & 1023;
  ch = D.5494 + 56320;
  D.5495 = outptr + 2;
  D.5490 = ch >> 8;
  D.5491 = (unsigned char) D.5490;
  *D.5495 = D.5491;
  D.5496 = outptr + 3;
  D.5492 = (unsigned char) ch;
  *D.5496 = D.5492;
  D.5481 = 4;
  return D.5481;
}


decode_utf16be (char * inbuf, size_t inleft, gunichar * outchar)
{
  int * D.5500;
  int D.5501;
  unsigned char D.5502;
  int D.5503;
  int D.5504;
  unsigned char * D.5505;
  unsigned char D.5506;
  int D.5507;
  int D.5508;
  unsigned char * D.5515;
  unsigned char D.5516;
  int D.5517;
  int D.5518;
  signed short D.5519;
  unsigned char * D.5520;
  unsigned char D.5521;
  signed short D.5522;
  signed short D.5523;
  short unsigned int D.5524;
  unsigned int D.5527;
  unsigned int D.5528;
  unsigned int D.5529;
  unsigned int D.5530;
  unsigned char * inptr;
  gunichar2 c;
  gunichar u;

  inptr = inbuf;
  if (inleft <= 1) goto <D.5498>; else goto <D.5499>;
  <D.5498>:
  D.5500 = __errno_location ();
  *D.5500 = 22;
  D.5501 = -1;
  return D.5501;
  <D.5499>:
  D.5502 = *inptr;
  D.5503 = (int) D.5502;
  D.5504 = D.5503 << 8;
  D.5505 = inptr + 1;
  D.5506 = *D.5505;
  D.5507 = (int) D.5506;
  D.5508 = D.5504 | D.5507;
  u = (gunichar) D.5508;
  if (u <= 55295) goto <D.5509>; else goto <D.5510>;
  <D.5509>:
  *outchar = u;
  D.5501 = 2;
  return D.5501;
  <D.5510>:
  if (u <= 56319) goto <D.5511>; else goto <D.5512>;
  <D.5511>:
  if (inleft <= 3) goto <D.5513>; else goto <D.5514>;
  <D.5513>:
  D.5500 = __errno_location ();
  *D.5500 = 22;
  D.5501 = -2;
  return D.5501;
  <D.5514>:
  D.5515 = inptr + 2;
  D.5516 = *D.5515;
  D.5517 = (int) D.5516;
  D.5518 = D.5517 << 8;
  D.5519 = (signed short) D.5518;
  D.5520 = inptr + 3;
  D.5521 = *D.5520;
  D.5522 = (signed short) D.5521;
  D.5523 = D.5519 | D.5522;
  c = (gunichar2) D.5523;
  D.5524 = c + 9216;
  if (D.5524 > 1023) goto <D.5525>; else goto <D.5526>;
  <D.5525>:
  D.5500 = __errno_location ();
  *D.5500 = 84;
  D.5501 = -2;
  return D.5501;
  <D.5526>:
  D.5527 = u + 4294912000;
  D.5528 = D.5527 << 10;
  D.5529 = (unsigned int) c;
  D.5530 = D.5528 + D.5529;
  u = D.5530 + 9216;
  *outchar = u;
  D.5501 = 4;
  return D.5501;
  <D.5512>:
  if (u <= 57343) goto <D.5531>; else goto <D.5532>;
  <D.5531>:
  D.5500 = __errno_location ();
  *D.5500 = 84;
  D.5501 = -1;
  return D.5501;
  <D.5532>:
  *outchar = u;
  D.5501 = 2;
  return D.5501;
}


encode_utf32le (gunichar c, char * outbuf, size_t outleft)
{
  int * D.5536;
  int D.5537;
  unsigned char D.5538;
  unsigned char * D.5539;
  unsigned int D.5540;
  unsigned char D.5541;
  unsigned char * D.5542;
  unsigned int D.5543;
  unsigned char D.5544;
  unsigned char * D.5545;
  unsigned int D.5546;
  unsigned char D.5547;
  unsigned char * outptr;

  outptr = outbuf;
  if (outleft <= 3) goto <D.5534>; else goto <D.5535>;
  <D.5534>:
  D.5536 = __errno_location ();
  *D.5536 = 7;
  D.5537 = -1;
  return D.5537;
  <D.5535>:
  D.5538 = (unsigned char) c;
  *outptr = D.5538;
  D.5539 = outptr + 1;
  D.5540 = c >> 8;
  D.5541 = (unsigned char) D.5540;
  *D.5539 = D.5541;
  D.5542 = outptr + 2;
  D.5543 = c >> 16;
  D.5544 = (unsigned char) D.5543;
  *D.5542 = D.5544;
  D.5545 = outptr + 3;
  D.5546 = c >> 24;
  D.5547 = (unsigned char) D.5546;
  *D.5545 = D.5547;
  D.5537 = 4;
  return D.5537;
}


decode_utf32le (char * inbuf, size_t inleft, gunichar * outchar)
{
  int * D.5551;
  int D.5552;
  unsigned char * D.5553;
  unsigned char D.5554;
  int D.5555;
  int D.5556;
  unsigned char * D.5557;
  unsigned char D.5558;
  int D.5559;
  int D.5560;
  int D.5561;
  unsigned char * D.5562;
  unsigned char D.5563;
  int D.5564;
  int D.5565;
  int D.5566;
  unsigned char D.5567;
  int D.5568;
  int D.5569;
  unsigned int D.5570;
  unsigned char * inptr;
  gunichar c;

  inptr = inbuf;
  if (inleft <= 3) goto <D.5549>; else goto <D.5550>;
  <D.5549>:
  D.5551 = __errno_location ();
  *D.5551 = 22;
  D.5552 = -1;
  return D.5552;
  <D.5550>:
  D.5553 = inptr + 3;
  D.5554 = *D.5553;
  D.5555 = (int) D.5554;
  D.5556 = D.5555 << 24;
  D.5557 = inptr + 2;
  D.5558 = *D.5557;
  D.5559 = (int) D.5558;
  D.5560 = D.5559 << 16;
  D.5561 = D.5556 | D.5560;
  D.5562 = inptr + 1;
  D.5563 = *D.5562;
  D.5564 = (int) D.5563;
  D.5565 = D.5564 << 8;
  D.5566 = D.5561 | D.5565;
  D.5567 = *inptr;
  D.5568 = (int) D.5567;
  D.5569 = D.5566 | D.5568;
  c = (gunichar) D.5569;
  D.5570 = c + 4294912000;
  if (D.5570 <= 2047) goto <D.5571>; else goto <D.5572>;
  <D.5571>:
  D.5551 = __errno_location ();
  *D.5551 = 84;
  D.5552 = -1;
  return D.5552;
  <D.5572>:
  if (c > 1114111) goto <D.5573>; else goto <D.5574>;
  <D.5573>:
  D.5551 = __errno_location ();
  *D.5551 = 84;
  D.5552 = -1;
  return D.5552;
  <D.5574>:
  *outchar = c;
  D.5552 = 4;
  return D.5552;
}


encode_utf32be (gunichar c, char * outbuf, size_t outleft)
{
  int * D.5578;
  int D.5579;
  unsigned int D.5580;
  unsigned char D.5581;
  unsigned char * D.5582;
  unsigned int D.5583;
  unsigned char D.5584;
  unsigned char * D.5585;
  unsigned int D.5586;
  unsigned char D.5587;
  unsigned char * D.5588;
  unsigned char D.5589;
  unsigned char * outptr;

  outptr = outbuf;
  if (outleft <= 3) goto <D.5576>; else goto <D.5577>;
  <D.5576>:
  D.5578 = __errno_location ();
  *D.5578 = 7;
  D.5579 = -1;
  return D.5579;
  <D.5577>:
  D.5580 = c >> 24;
  D.5581 = (unsigned char) D.5580;
  *outptr = D.5581;
  D.5582 = outptr + 1;
  D.5583 = c >> 16;
  D.5584 = (unsigned char) D.5583;
  *D.5582 = D.5584;
  D.5585 = outptr + 2;
  D.5586 = c >> 8;
  D.5587 = (unsigned char) D.5586;
  *D.5585 = D.5587;
  D.5588 = outptr + 3;
  D.5589 = (unsigned char) c;
  *D.5588 = D.5589;
  D.5579 = 4;
  return D.5579;
}


decode_utf32be (char * inbuf, size_t inleft, gunichar * outchar)
{
  int * D.5593;
  int D.5594;
  unsigned char D.5595;
  int D.5596;
  int D.5597;
  unsigned char * D.5598;
  unsigned char D.5599;
  int D.5600;
  int D.5601;
  int D.5602;
  unsigned char * D.5603;
  unsigned char D.5604;
  int D.5605;
  int D.5606;
  int D.5607;
  unsigned char * D.5608;
  unsigned char D.5609;
  int D.5610;
  int D.5611;
  unsigned int D.5612;
  unsigned char * inptr;
  gunichar c;

  inptr = inbuf;
  if (inleft <= 3) goto <D.5591>; else goto <D.5592>;
  <D.5591>:
  D.5593 = __errno_location ();
  *D.5593 = 22;
  D.5594 = -1;
  return D.5594;
  <D.5592>:
  D.5595 = *inptr;
  D.5596 = (int) D.5595;
  D.5597 = D.5596 << 24;
  D.5598 = inptr + 1;
  D.5599 = *D.5598;
  D.5600 = (int) D.5599;
  D.5601 = D.5600 << 16;
  D.5602 = D.5597 | D.5601;
  D.5603 = inptr + 2;
  D.5604 = *D.5603;
  D.5605 = (int) D.5604;
  D.5606 = D.5605 << 8;
  D.5607 = D.5602 | D.5606;
  D.5608 = inptr + 3;
  D.5609 = *D.5608;
  D.5610 = (int) D.5609;
  D.5611 = D.5607 | D.5610;
  c = (gunichar) D.5611;
  D.5612 = c + 4294912000;
  if (D.5612 <= 2047) goto <D.5613>; else goto <D.5614>;
  <D.5613>:
  D.5593 = __errno_location ();
  *D.5593 = 84;
  D.5594 = -1;
  return D.5594;
  <D.5614>:
  if (c > 1114111) goto <D.5615>; else goto <D.5616>;
  <D.5615>:
  D.5593 = __errno_location ();
  *D.5593 = 84;
  D.5594 = -1;
  return D.5594;
  <D.5616>:
  *outchar = c;
  D.5594 = 4;
  return D.5594;
}


encode_latin1 (gunichar c, char * outbuf, size_t outleft)
{
  int * D.5620;
  int D.5621;
  char D.5624;

  if (outleft == 0) goto <D.5618>; else goto <D.5619>;
  <D.5618>:
  D.5620 = __errno_location ();
  *D.5620 = 7;
  D.5621 = -1;
  return D.5621;
  <D.5619>:
  if (c > 255) goto <D.5622>; else goto <D.5623>;
  <D.5622>:
  D.5620 = __errno_location ();
  *D.5620 = 84;
  D.5621 = -1;
  return D.5621;
  <D.5623>:
  D.5624 = (char) c;
  *outbuf = D.5624;
  D.5621 = 1;
  return D.5621;
}


decode_latin1 (char * inbuf, size_t inleft, gunichar * outchar)
{
  char D.5626;
  unsigned char D.5627;
  unsigned int D.5628;
  int D.5629;

  D.5626 = *inbuf;
  D.5627 = (unsigned char) D.5626;
  D.5628 = (unsigned int) D.5627;
  *outchar = D.5628;
  D.5629 = 1;
  return D.5629;
}


monoeg_g_iconv_close (struct _GIConv * cd)
{
  void * D.5631;
  int D.5634;

  D.5631 = cd->cd;
  if (D.5631 != -1B) goto <D.5632>; else goto <D.5633>;
  <D.5632>:
  D.5631 = cd->cd;
  iconv_close (D.5631);
  <D.5633>:
  monoeg_g_free (cd);
  D.5634 = 0;
  return D.5634;
}


monoeg_g_iconv (struct _GIConv * cd, gchar * * inbytes, gsize * inbytesleft, gchar * * outbytes, gsize * outbytesleft)
{
  void * D.5636;
  long unsigned int n_inleft.0;
  long unsigned int n_outleft.1;
  gsize D.5647;
  _Bool D.5648;
  _Bool D.5649;
  _Bool D.5650;
  gsize iftmp.2;
  char * iftmp.3;
  unsigned int c.4;
  unsigned int c.5;
  int (*<Te7c>) (char *, size_t, gunichar *) D.5664;
  long unsigned int D.5666;
  sizetype D.5667;
  int (*<Te81>) (gunichar, char *, size_t) D.5668;
  gsize iftmp.6;
  gsize inleft;
  gsize outleft;
  char * inptr;
  char * outptr;
  gunichar c;
  int rc;
  void encode = <<< error >>>;

  try
    {
      rc = 0;
      D.5636 = cd->cd;
      if (D.5636 != -1B) goto <D.5637>; else goto <D.5638>;
      <D.5637>:
      {
        size_t * outleftptr;
        size_t * inleftptr;
        size_t n_outleft;
        size_t n_inleft;

        try
          {
            if (inbytesleft != 0B) goto <D.5639>; else goto <D.5640>;
            <D.5639>:
            n_inleft.0 = *inbytesleft;
            n_inleft = n_inleft.0;
            inleftptr = &n_inleft;
            goto <D.5642>;
            <D.5640>:
            inleftptr = 0B;
            <D.5642>:
            if (outbytesleft != 0B) goto <D.5643>; else goto <D.5644>;
            <D.5643>:
            n_outleft.1 = *outbytesleft;
            n_outleft = n_outleft.1;
            outleftptr = &n_outleft;
            goto <D.5646>;
            <D.5644>:
            outleftptr = 0B;
            <D.5646>:
            D.5636 = cd->cd;
            D.5647 = iconv (D.5636, inbytes, inleftptr, outbytes, outleftptr);
            return D.5647;
          }
        finally
          {
            n_outleft = {CLOBBER};
            n_inleft = {CLOBBER};
          }
      }
      <D.5638>:
      D.5648 = outbytes == 0B;
      D.5649 = outbytesleft == 0B;
      D.5650 = D.5648 | D.5649;
      if (D.5650 != 0) goto <D.5651>; else goto <D.5652>;
      <D.5651>:
      cd->c = 4294967295;
      D.5647 = 0;
      return D.5647;
      <D.5652>:
      if (inbytesleft != 0B) goto <D.5654>; else goto <D.5655>;
      <D.5654>:
      iftmp.2 = *inbytesleft;
      goto <D.5656>;
      <D.5655>:
      iftmp.2 = 0;
      <D.5656>:
      inleft = iftmp.2;
      if (inbytes != 0B) goto <D.5658>; else goto <D.5659>;
      <D.5658>:
      iftmp.3 = *inbytes;
      goto <D.5660>;
      <D.5659>:
      iftmp.3 = 0B;
      <D.5660>:
      inptr = iftmp.3;
      outleft = *outbytesleft;
      outptr = *outbytes;
      c.4 = cd->c;
      c = c.4;
      c.5 = c;
      if (c.5 != 4294967295) goto encode; else goto <D.5663>;
      <D.5663>:
      goto <D.5037>;
      <D.5036>:
      D.5664 = cd->decode;
      rc = D.5664 (inptr, inleft, &c);
      if (rc < 0) goto <D.5035>; else goto <D.5665>;
      <D.5665>:
      D.5666 = (long unsigned int) rc;
      inleft = inleft - D.5666;
      D.5667 = (sizetype) rc;
      inptr = inptr + D.5667;
      encode:
      D.5668 = cd->encode;
      c.5 = c;
      rc = D.5668 (c.5, outptr, outleft);
      if (rc < 0) goto <D.5035>; else goto <D.5669>;
      <D.5669>:
      c = 4294967295;
      D.5666 = (long unsigned int) rc;
      outleft = outleft - D.5666;
      D.5667 = (sizetype) rc;
      outptr = outptr + D.5667;
      <D.5037>:
      if (inleft != 0) goto <D.5036>; else goto <D.5035>;
      <D.5035>:
      if (inbytesleft != 0B) goto <D.5670>; else goto <D.5671>;
      <D.5670>:
      *inbytesleft = inleft;
      <D.5671>:
      if (inbytes != 0B) goto <D.5672>; else goto <D.5673>;
      <D.5672>:
      *inbytes = inptr;
      <D.5673>:
      *outbytesleft = outleft;
      *outbytes = outptr;
      c.5 = c;
      cd->c = c.5;
      if (rc < 0) goto <D.5675>; else goto <D.5676>;
      <D.5675>:
      iftmp.6 = 18446744073709551615;
      goto <D.5677>;
      <D.5676>:
      iftmp.6 = 0;
      <D.5677>:
      D.5647 = iftmp.6;
      return D.5647;
    }
  finally
    {
      c = {CLOBBER};
    }
}


monoeg_g_convert_error_quark ()
{
  void * D.5681;

  D.5681 = error_quark;
  return D.5681;
}


monoeg_g_convert (const gchar * str, gssize len, const gchar * to_charset, const gchar * from_charset, gsize * bytes_read, gsize * bytes_written, struct GError * * err)
{
  gchar * D.5685;
  void * D.5692;
  long unsigned int iftmp.7;
  long unsigned int inleft.8;
  long unsigned int D.5702;
  int * D.5708;
  int D.5709;
  long unsigned int D.5710;
  char * outbuf.9;
  long int outbuf.10;
  long int result.11;
  long int D.5714;
  long unsigned int outleft.12;
  long unsigned int outleft.13;
  char * outbuf.14;
  const gchar * D.5721;
  void * D.5722;
  char * inbuf.15;
  long int inbuf.16;
  long int str.17;
  long int D.5728;
  long unsigned int D.5729;
  const gchar * D.5732;
  void * D.5733;
  long unsigned int D.5742;
  gsize outsize;
  gsize outused;
  gsize outleft;
  gsize inleft;
  gsize grow;
  gsize rc;
  char * result;
  char * outbuf;
  char * inbuf;
  gboolean flush;
  gboolean done;
  struct _GIConv * cd;

  try
    {
      flush = 0;
      done = 0;
      if (str == 0B) goto <D.5683>; else goto <D.5684>;
      <D.5683>:
      monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "giconv.c", 669, "str != NULL");
      D.5685 = 0B;
      return D.5685;
      <D.5684>:
      if (to_charset == 0B) goto <D.5686>; else goto <D.5687>;
      <D.5686>:
      monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "giconv.c", 670, "to_charset != NULL");
      D.5685 = 0B;
      return D.5685;
      <D.5687>:
      if (from_charset == 0B) goto <D.5688>; else goto <D.5689>;
      <D.5688>:
      monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "giconv.c", 671, "from_charset != NULL");
      D.5685 = 0B;
      return D.5685;
      <D.5689>:
      cd = monoeg_g_iconv_open (to_charset, from_charset);
      if (cd == -1B) goto <D.5690>; else goto <D.5691>;
      <D.5690>:
      D.5692 = monoeg_g_convert_error_quark ();
      monoeg_g_set_error (err, D.5692, 0, "Conversion from %s to %s not supported.", from_charset, to_charset);
      if (bytes_written != 0B) goto <D.5693>; else goto <D.5694>;
      <D.5693>:
      *bytes_written = 0;
      <D.5694>:
      if (bytes_read != 0B) goto <D.5695>; else goto <D.5696>;
      <D.5695>:
      *bytes_read = 0;
      <D.5696>:
      D.5685 = 0B;
      return D.5685;
      <D.5691>:
      if (len < 0) goto <D.5698>; else goto <D.5699>;
      <D.5698>:
      iftmp.7 = strlen (str);
      goto <D.5700>;
      <D.5699>:
      iftmp.7 = (long unsigned int) len;
      <D.5700>:
      inleft = iftmp.7;
      inbuf = str;
      inleft.8 = inleft;
      outsize = MAX_EXPR <inleft.8, 8>;
      outleft = outsize;
      D.5702 = outsize + 4;
      result = monoeg_malloc (D.5702);
      outbuf = result;
      <D.5161>:
      if (flush == 0) goto <D.5703>; else goto <D.5704>;
      <D.5703>:
      rc = monoeg_g_iconv (cd, &inbuf, &inleft, &outbuf, &outleft);
      goto <D.5705>;
      <D.5704>:
      rc = monoeg_g_iconv (cd, 0B, 0B, &outbuf, &outleft);
      <D.5705>:
      if (rc == 18446744073709551615) goto <D.5706>; else goto <D.5707>;
      <D.5706>:
      D.5708 = __errno_location ();
      D.5709 = *D.5708;
      switch (D.5709) <default: <D.5159>, case 7: <D.5155>, case 22: <D.5157>, case 84: <D.5158>>
      <D.5155>:
      inleft.8 = inleft;
      D.5710 = MAX_EXPR <inleft.8, 8>;
      grow = D.5710 << 1;
      outbuf.9 = outbuf;
      outbuf.10 = (long int) outbuf.9;
      result.11 = (long int) result;
      D.5714 = outbuf.10 - result.11;
      outused = (gsize) D.5714;
      outsize = outsize + grow;
      outleft.12 = outleft;
      outleft.13 = outleft.12 + grow;
      outleft = outleft.13;
      D.5702 = outsize + 4;
      result = monoeg_realloc (result, D.5702);
      outbuf.14 = result + outused;
      outbuf = outbuf.14;
      goto <D.5156>;
      <D.5157>:
      if (flush != 0) goto <D.5718>; else goto <D.5719>;
      <D.5718>:
      done = 1;
      goto <D.5720>;
      <D.5719>:
      flush = 1;
      <D.5720>:
      goto <D.5156>;
      <D.5158>:
      D.5708 = __errno_location ();
      D.5709 = *D.5708;
      D.5721 = monoeg_g_strerror (D.5709);
      D.5722 = monoeg_g_convert_error_quark ();
      monoeg_g_set_error (err, D.5722, 1, "%s", D.5721);
      if (bytes_read != 0B) goto <D.5723>; else goto <D.5724>;
      <D.5723>:
      inbuf.15 = inbuf;
      inbuf.16 = (long int) inbuf.15;
      str.17 = (long int) str;
      D.5728 = inbuf.16 - str.17;
      D.5729 = (long unsigned int) D.5728;
      *bytes_read = D.5729;
      <D.5724>:
      if (bytes_written != 0B) goto <D.5730>; else goto <D.5731>;
      <D.5730>:
      *bytes_written = 0;
      <D.5731>:
      monoeg_g_iconv_close (cd);
      monoeg_g_free (result);
      D.5685 = 0B;
      return D.5685;
      <D.5159>:
      D.5708 = __errno_location ();
      D.5709 = *D.5708;
      D.5732 = monoeg_g_strerror (D.5709);
      D.5733 = monoeg_g_convert_error_quark ();
      monoeg_g_set_error (err, D.5733, 2, "%s", D.5732);
      if (bytes_written != 0B) goto <D.5734>; else goto <D.5735>;
      <D.5734>:
      *bytes_written = 0;
      <D.5735>:
      if (bytes_read != 0B) goto <D.5736>; else goto <D.5737>;
      <D.5736>:
      *bytes_read = 0;
      <D.5737>:
      monoeg_g_iconv_close (cd);
      monoeg_g_free (result);
      D.5685 = 0B;
      return D.5685;
      <D.5156>:
      goto <D.5738>;
      <D.5707>:
      if (flush != 0) goto <D.5160>; else goto <D.5739>;
      <D.5739>:
      flush = 1;
      <D.5738>:
      if (done == 0) goto <D.5161>; else goto <D.5160>;
      <D.5160>:
      monoeg_g_iconv_close (cd);
      outbuf.9 = outbuf;
      memset (outbuf.9, 0, 4);
      if (bytes_written != 0B) goto <D.5740>; else goto <D.5741>;
      <D.5740>:
      outbuf.9 = outbuf;
      outbuf.10 = (long int) outbuf.9;
      result.11 = (long int) result;
      D.5714 = outbuf.10 - result.11;
      D.5742 = (long unsigned int) D.5714;
      *bytes_written = D.5742;
      <D.5741>:
      if (bytes_read != 0B) goto <D.5743>; else goto <D.5744>;
      <D.5743>:
      inbuf.15 = inbuf;
      inbuf.16 = (long int) inbuf.15;
      str.17 = (long int) str;
      D.5728 = inbuf.16 - str.17;
      D.5729 = (long unsigned int) D.5728;
      *bytes_read = D.5729;
      <D.5744>:
      D.5685 = result;
      return D.5685;
    }
  finally
    {
      outleft = {CLOBBER};
      inleft = {CLOBBER};
      outbuf = {CLOBBER};
      inbuf = {CLOBBER};
    }
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.5749;
  int D.5754;
  void * D.5756;
  long unsigned int D.5757;

  D.5749 = __builtin_constant_p (__len);
  if (D.5749 != 0) goto <D.5750>; else goto <D.5751>;
  <D.5750>:
  if (__len == 0) goto <D.5752>; else goto <D.5753>;
  <D.5752>:
  D.5754 = __builtin_constant_p (__ch);
  if (D.5754 == 0) goto <D.5747>; else goto <D.5755>;
  <D.5755>:
  if (__ch != 0) goto <D.5747>; else goto <D.5748>;
  <D.5747>:
  __warn_memset_zero_len ();
  D.5756 = __dest;
  return D.5756;
  <D.5748>:
  <D.5753>:
  <D.5751>:
  D.5757 = __builtin_object_size (__dest, 0);
  D.5756 = __builtin___memset_chk (__dest, __ch, __len, D.5757);
  return D.5756;
}


monoeg_g_unichar_to_utf8 (gunichar c, gchar * outbuf)
{
  signed int c.18;
  gint D.5778;
  sizetype D.5781;
  gchar * D.5782;
  unsigned char D.5783;
  unsigned char D.5784;
  unsigned char D.5785;
  char D.5786;
  unsigned char D.5787;
  unsigned char D.5788;
  char D.5789;
  int base;
  int n;
  int i;

  if (c <= 127) goto <D.5759>; else goto <D.5760>;
  <D.5759>:
  base = 0;
  n = 1;
  goto <D.5761>;
  <D.5760>:
  if (c <= 2047) goto <D.5762>; else goto <D.5763>;
  <D.5762>:
  base = 192;
  n = 2;
  goto <D.5764>;
  <D.5763>:
  if (c <= 65535) goto <D.5765>; else goto <D.5766>;
  <D.5765>:
  base = 224;
  n = 3;
  goto <D.5767>;
  <D.5766>:
  if (c <= 2097151) goto <D.5768>; else goto <D.5769>;
  <D.5768>:
  base = 240;
  n = 4;
  goto <D.5770>;
  <D.5769>:
  if (c <= 67108863) goto <D.5771>; else goto <D.5772>;
  <D.5771>:
  base = 248;
  n = 5;
  goto <D.5773>;
  <D.5772>:
  c.18 = (signed int) c;
  if (c.18 >= 0) goto <D.5775>; else goto <D.5776>;
  <D.5775>:
  base = 252;
  n = 6;
  goto <D.5777>;
  <D.5776>:
  D.5778 = -1;
  return D.5778;
  <D.5777>:
  <D.5773>:
  <D.5770>:
  <D.5767>:
  <D.5764>:
  <D.5761>:
  if (outbuf != 0B) goto <D.5779>; else goto <D.5780>;
  <D.5779>:
  i = n + -1;
  goto <D.5170>;
  <D.5169>:
  D.5781 = (sizetype) i;
  D.5782 = outbuf + D.5781;
  D.5783 = (unsigned char) c;
  D.5784 = D.5783 & 63;
  D.5785 = D.5784 | 128;
  D.5786 = (char) D.5785;
  *D.5782 = D.5786;
  c = c >> 6;
  i = i + -1;
  <D.5170>:
  if (i > 0) goto <D.5169>; else goto <D.5171>;
  <D.5171>:
  D.5783 = (unsigned char) c;
  D.5787 = (unsigned char) base;
  D.5788 = D.5783 | D.5787;
  D.5789 = (char) D.5788;
  *outbuf = D.5789;
  <D.5780>:
  D.5778 = n;
  return D.5778;
}


monoeg_g_utf8_to_ucs4_fast (const gchar * str, glong len, glong * items_written)
{
  gunichar * D.5793;
  long int D.5796;
  long unsigned int D.5797;
  long unsigned int D.5798;
  gunichar * outptr.19;
  unsigned int D.5800;
  char D.5801;
  unsigned char D.5802;
  int D.5803;
  unsigned char D.5804;
  sizetype D.5805;
  gunichar * outbuf;
  gunichar * outptr;
  char * inptr;
  glong n;
  glong i;

  if (str == 0B) goto <D.5791>; else goto <D.5792>;
  <D.5791>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "giconv.c", 896, "str != NULL");
  D.5793 = 0B;
  return D.5793;
  <D.5792>:
  n = monoeg_g_utf8_strlen (str, len);
  if (items_written != 0B) goto <D.5794>; else goto <D.5795>;
  <D.5794>:
  *items_written = n;
  <D.5795>:
  D.5796 = n + 1;
  D.5797 = (long unsigned int) D.5796;
  D.5798 = D.5797 * 4;
  outbuf = monoeg_malloc (D.5798);
  outptr = outbuf;
  inptr = str;
  i = 0;
  goto <D.5188>;
  <D.5187>:
  outptr.19 = outptr;
  outptr = outptr.19 + 4;
  D.5800 = monoeg_g_utf8_get_char (inptr);
  *outptr.19 = D.5800;
  D.5801 = *inptr;
  D.5802 = (unsigned char) D.5801;
  D.5803 = (int) D.5802;
  D.5804 = g_utf8_jump_table[D.5803];
  D.5805 = (sizetype) D.5804;
  inptr = inptr + D.5805;
  i = i + 1;
  <D.5188>:
  if (i < n) goto <D.5187>; else goto <D.5189>;
  <D.5189>:
  *outptr = 0;
  D.5793 = outbuf;
  return D.5793;
}


monoeg_g_utf8_to_utf16 (const gchar * str, glong len, glong * items_read, glong * items_written, struct GError * * err)
{
  gunichar2 * D.5807;

  D.5807 = eg_utf8_to_utf16_general (str, len, items_read, items_written, 0, err);
  return D.5807;
}


eg_utf8_to_utf16_general (const gchar * str, glong len, glong * items_read, glong * items_written, gboolean include_nuls, struct GError * * err)
{
  gunichar2 * D.5811;
  void * D.5816;
  long unsigned int D.5817;
  unsigned int c.20;
  int * D.5825;
  long unsigned int D.5826;
  long unsigned int D.5827;
  sizetype D.5828;
  long int inptr.21;
  long int str.22;
  long int D.5833;
  long int outlen.23;
  long unsigned int D.5837;
  long unsigned int D.5838;
  int D.5843;
  long unsigned int D.5844;
  long unsigned int D.5845;
  int D.5846;
  void * D.5849;
  void * D.5854;
  gunichar2 * outbuf;
  gunichar2 * outptr;
  size_t outlen;
  size_t inleft;
  char * inptr;
  gunichar c;
  int u;
  int n;
  void error = <<< error >>>;

  try
    {
      outlen = 0;
      if (str == 0B) goto <D.5809>; else goto <D.5810>;
      <D.5809>:
      monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "giconv.c", 926, "str != NULL");
      D.5811 = 0B;
      return D.5811;
      <D.5810>:
      if (len < 0) goto <D.5812>; else goto <D.5813>;
      <D.5812>:
      if (include_nuls != 0) goto <D.5814>; else goto <D.5815>;
      <D.5814>:
      D.5816 = monoeg_g_convert_error_quark ();
      monoeg_g_set_error (err, D.5816, 2, "Conversions with embedded nulls must pass the string length");
      D.5811 = 0B;
      return D.5811;
      <D.5815>:
      D.5817 = strlen (str);
      len = (glong) D.5817;
      <D.5813>:
      inptr = str;
      inleft = (size_t) len;
      goto <D.5209>;
      <D.5208>:
      n = decode_utf8 (inptr, inleft, &c);
      if (n < 0) goto error; else goto <D.5818>;
      <D.5818>:
      c.20 = c;
      if (c.20 == 0) goto <D.5820>; else goto <D.5821>;
      <D.5820>:
      if (include_nuls == 0) goto <D.5207>; else goto <D.5822>;
      <D.5822>:
      <D.5821>:
      c.20 = c;
      u = monoeg_unichar_to_utf16 (c.20, 0B);
      if (u < 0) goto <D.5823>; else goto <D.5824>;
      <D.5823>:
      D.5825 = __errno_location ();
      *D.5825 = 84;
      goto error;
      <D.5824>:
      D.5826 = (long unsigned int) u;
      outlen = D.5826 + outlen;
      D.5827 = (long unsigned int) n;
      inleft = inleft - D.5827;
      D.5828 = (sizetype) n;
      inptr = inptr + D.5828;
      <D.5209>:
      if (inleft != 0) goto <D.5208>; else goto <D.5207>;
      <D.5207>:
      if (items_read != 0B) goto <D.5829>; else goto <D.5830>;
      <D.5829>:
      inptr.21 = (long int) inptr;
      str.22 = (long int) str;
      D.5833 = inptr.21 - str.22;
      *items_read = D.5833;
      <D.5830>:
      if (items_written != 0B) goto <D.5834>; else goto <D.5835>;
      <D.5834>:
      outlen.23 = (long int) outlen;
      *items_written = outlen.23;
      <D.5835>:
      D.5837 = outlen + 1;
      D.5838 = D.5837 * 2;
      outbuf = monoeg_malloc (D.5838);
      outptr = outbuf;
      inptr = str;
      inleft = (size_t) len;
      goto <D.5212>;
      <D.5211>:
      n = decode_utf8 (inptr, inleft, &c);
      if (n < 0) goto <D.5210>; else goto <D.5839>;
      <D.5839>:
      c.20 = c;
      if (c.20 == 0) goto <D.5840>; else goto <D.5841>;
      <D.5840>:
      if (include_nuls == 0) goto <D.5210>; else goto <D.5842>;
      <D.5842>:
      <D.5841>:
      c.20 = c;
      D.5843 = monoeg_unichar_to_utf16 (c.20, outptr);
      D.5844 = (long unsigned int) D.5843;
      D.5845 = D.5844 * 2;
      outptr = outptr + D.5845;
      D.5827 = (long unsigned int) n;
      inleft = inleft - D.5827;
      D.5828 = (sizetype) n;
      inptr = inptr + D.5828;
      <D.5212>:
      if (inleft != 0) goto <D.5211>; else goto <D.5210>;
      <D.5210>:
      *outptr = 0;
      D.5811 = outbuf;
      return D.5811;
      error:
      D.5825 = __errno_location ();
      D.5846 = *D.5825;
      if (D.5846 == 84) goto <D.5847>; else goto <D.5848>;
      <D.5847>:
      D.5849 = monoeg_g_convert_error_quark ();
      monoeg_g_set_error (err, D.5849, 1, "Illegal byte sequence encounted in the input.");
      goto <D.5850>;
      <D.5848>:
      if (items_read != 0B) goto <D.5851>; else goto <D.5852>;
      <D.5851>:
      goto <D.5853>;
      <D.5852>:
      D.5854 = monoeg_g_convert_error_quark ();
      monoeg_g_set_error (err, D.5854, 3, "Partial byte sequence encountered in the input.");
      <D.5853>:
      <D.5850>:
      if (items_read != 0B) goto <D.5855>; else goto <D.5856>;
      <D.5855>:
      inptr.21 = (long int) inptr;
      str.22 = (long int) str;
      D.5833 = inptr.21 - str.22;
      *items_read = D.5833;
      <D.5856>:
      if (items_written != 0B) goto <D.5857>; else goto <D.5858>;
      <D.5857>:
      *items_written = 0;
      <D.5858>:
      D.5811 = 0B;
      return D.5811;
    }
  finally
    {
      c = {CLOBBER};
    }
}


monoeg_unichar_to_utf16 (gunichar c, gunichar2 * outbuf)
{
  short unsigned int D.5865;
  int D.5866;
  unsigned int D.5877;
  short unsigned int D.5878;
  short unsigned int D.5879;
  gunichar2 * D.5880;
  short unsigned int D.5881;
  short unsigned int D.5882;
  short unsigned int D.5883;
  gunichar c2;

  if (c <= 55295) goto <D.5861>; else goto <D.5862>;
  <D.5861>:
  if (outbuf != 0B) goto <D.5863>; else goto <D.5864>;
  <D.5863>:
  D.5865 = (short unsigned int) c;
  *outbuf = D.5865;
  <D.5864>:
  D.5866 = 1;
  return D.5866;
  <D.5862>:
  if (c <= 57343) goto <D.5867>; else goto <D.5868>;
  <D.5867>:
  D.5866 = -1;
  return D.5866;
  <D.5868>:
  if (c <= 65535) goto <D.5869>; else goto <D.5870>;
  <D.5869>:
  if (outbuf != 0B) goto <D.5871>; else goto <D.5872>;
  <D.5871>:
  D.5865 = (short unsigned int) c;
  *outbuf = D.5865;
  <D.5872>:
  D.5866 = 1;
  return D.5866;
  <D.5870>:
  if (c <= 1114111) goto <D.5873>; else goto <D.5874>;
  <D.5873>:
  if (outbuf != 0B) goto <D.5875>; else goto <D.5876>;
  <D.5875>:
  c2 = c + 4294901760;
  D.5877 = c2 >> 10;
  D.5878 = (short unsigned int) D.5877;
  D.5879 = D.5878 + 55296;
  *outbuf = D.5879;
  D.5880 = outbuf + 2;
  D.5881 = (short unsigned int) c2;
  D.5882 = D.5881 & 1023;
  D.5883 = D.5882 + 56320;
  *D.5880 = D.5883;
  <D.5876>:
  D.5866 = 2;
  return D.5866;
  <D.5874>:
  D.5866 = -1;
  return D.5866;
}


eg_utf8_to_utf16_with_nuls (const gchar * str, glong len, glong * items_read, glong * items_written, struct GError * * err)
{
  gunichar2 * D.5885;

  D.5885 = eg_utf8_to_utf16_general (str, len, items_read, items_written, 1, err);
  return D.5885;
}


monoeg_utf8_to_ucs4 (const gchar * str, glong len, glong * items_read, glong * items_written, struct GError * * err)
{
  gunichar * D.5889;
  long unsigned int D.5892;
  int * D.5895;
  int D.5896;
  void * D.5899;
  void * D.5902;
  long int inptr.24;
  long int str.25;
  long int D.5907;
  unsigned int c.26;
  long unsigned int D.5912;
  sizetype D.5913;
  long unsigned int D.5916;
  long int D.5917;
  long unsigned int D.5920;
  gunichar * outptr.27;
  gunichar * outbuf;
  gunichar * outptr;
  size_t outlen;
  size_t inleft;
  char * inptr;
  gunichar c;
  int n;

  try
    {
      outlen = 0;
      if (str == 0B) goto <D.5887>; else goto <D.5888>;
      <D.5887>:
      monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "giconv.c", 1025, "str != NULL");
      D.5889 = 0B;
      return D.5889;
      <D.5888>:
      if (len < 0) goto <D.5890>; else goto <D.5891>;
      <D.5890>:
      D.5892 = strlen (str);
      len = (glong) D.5892;
      <D.5891>:
      inptr = str;
      inleft = (size_t) len;
      goto <D.5243>;
      <D.5242>:
      n = decode_utf8 (inptr, inleft, &c);
      if (n < 0) goto <D.5893>; else goto <D.5894>;
      <D.5893>:
      D.5895 = __errno_location ();
      D.5896 = *D.5895;
      if (D.5896 == 84) goto <D.5897>; else goto <D.5898>;
      <D.5897>:
      D.5899 = monoeg_g_convert_error_quark ();
      monoeg_g_set_error (err, D.5899, 1, "Illegal byte sequence encounted in the input.");
      goto <D.5900>;
      <D.5898>:
      if (items_read != 0B) goto <D.5241>; else goto <D.5901>;
      <D.5901>:
      D.5902 = monoeg_g_convert_error_quark ();
      monoeg_g_set_error (err, D.5902, 3, "Partial byte sequence encountered in the input.");
      <D.5900>:
      if (items_read != 0B) goto <D.5903>; else goto <D.5904>;
      <D.5903>:
      inptr.24 = (long int) inptr;
      str.25 = (long int) str;
      D.5907 = inptr.24 - str.25;
      *items_read = D.5907;
      <D.5904>:
      if (items_written != 0B) goto <D.5908>; else goto <D.5909>;
      <D.5908>:
      *items_written = 0;
      <D.5909>:
      D.5889 = 0B;
      return D.5889;
      <D.5894>:
      c.26 = c;
      if (c.26 == 0) goto <D.5241>; else goto <D.5911>;
      <D.5911>:
      outlen = outlen + 4;
      D.5912 = (long unsigned int) n;
      inleft = inleft - D.5912;
      D.5913 = (sizetype) n;
      inptr = inptr + D.5913;
      <D.5243>:
      if (inleft != 0) goto <D.5242>; else goto <D.5241>;
      <D.5241>:
      if (items_written != 0B) goto <D.5914>; else goto <D.5915>;
      <D.5914>:
      D.5916 = outlen / 4;
      D.5917 = (long int) D.5916;
      *items_written = D.5917;
      <D.5915>:
      if (items_read != 0B) goto <D.5918>; else goto <D.5919>;
      <D.5918>:
      inptr.24 = (long int) inptr;
      str.25 = (long int) str;
      D.5907 = inptr.24 - str.25;
      *items_read = D.5907;
      <D.5919>:
      D.5920 = outlen + 4;
      outbuf = monoeg_malloc (D.5920);
      outptr = outbuf;
      inptr = str;
      inleft = (size_t) len;
      goto <D.5246>;
      <D.5245>:
      n = decode_utf8 (inptr, inleft, &c);
      if (n < 0) goto <D.5244>; else goto <D.5921>;
      <D.5921>:
      c.26 = c;
      if (c.26 == 0) goto <D.5244>; else goto <D.5922>;
      <D.5922>:
      outptr.27 = outptr;
      outptr = outptr.27 + 4;
      c.26 = c;
      *outptr.27 = c.26;
      D.5912 = (long unsigned int) n;
      inleft = inleft - D.5912;
      D.5913 = (sizetype) n;
      inptr = inptr + D.5913;
      <D.5246>:
      if (inleft != 0) goto <D.5245>; else goto <D.5244>;
      <D.5244>:
      *outptr = 0;
      D.5889 = outbuf;
      return D.5889;
    }
  finally
    {
      c = {CLOBBER};
    }
}


monoeg_g_utf16_to_utf8 (const gunichar2 * str, glong len, glong * items_read, glong * items_written, struct GError * * err)
{
  gchar * D.5928;
  long unsigned int len.28;
  long unsigned int D.5932;
  const gunichar2 * D.5933;
  short unsigned int D.5934;
  long int D.5935;
  _Bool D.5938;
  _Bool D.5939;
  _Bool D.5940;
  int * D.5943;
  int D.5944;
  void * D.5947;
  void * D.5950;
  long int inptr.29;
  long int str.30;
  long int D.5955;
  long int D.5956;
  unsigned int c.31;
  int D.5961;
  long unsigned int D.5962;
  long unsigned int D.5963;
  sizetype D.5964;
  long int outlen.32;
  long unsigned int D.5970;
  int D.5973;
  sizetype D.5974;
  char * inptr;
  char * outbuf;
  char * outptr;
  size_t outlen;
  size_t inleft;
  gunichar c;
  int n;

  try
    {
      outlen = 0;
      if (str == 0B) goto <D.5926>; else goto <D.5927>;
      <D.5926>:
      monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "giconv.c", 1096, "str != NULL");
      D.5928 = 0B;
      return D.5928;
      <D.5927>:
      if (len < 0) goto <D.5929>; else goto <D.5930>;
      <D.5929>:
      len = 0;
      goto <D.5262>;
      <D.5261>:
      len = len + 1;
      <D.5262>:
      len.28 = (long unsigned int) len;
      D.5932 = len.28 * 2;
      D.5933 = str + D.5932;
      D.5934 = *D.5933;
      if (D.5934 != 0) goto <D.5261>; else goto <D.5263>;
      <D.5263>:
      <D.5930>:
      inptr = str;
      D.5935 = len * 2;
      inleft = (size_t) D.5935;
      goto <D.5266>;
      <D.5265>:
      n = decode_utf16le (inptr, inleft, &c);
      if (n < 0) goto <D.5936>; else goto <D.5937>;
      <D.5936>:
      D.5938 = n == -2;
      D.5939 = inleft > 2;
      D.5940 = D.5938 & D.5939;
      if (D.5940 != 0) goto <D.5941>; else goto <D.5942>;
      <D.5941>:
      inleft = inleft + 18446744073709551614;
      inptr = inptr + 2;
      <D.5942>:
      D.5943 = __errno_location ();
      D.5944 = *D.5943;
      if (D.5944 == 84) goto <D.5945>; else goto <D.5946>;
      <D.5945>:
      D.5947 = monoeg_g_convert_error_quark ();
      monoeg_g_set_error (err, D.5947, 1, "Illegal byte sequence encounted in the input.");
      goto <D.5948>;
      <D.5946>:
      if (items_read != 0B) goto <D.5264>; else goto <D.5949>;
      <D.5949>:
      D.5950 = monoeg_g_convert_error_quark ();
      monoeg_g_set_error (err, D.5950, 3, "Partial byte sequence encountered in the input.");
      <D.5948>:
      if (items_read != 0B) goto <D.5951>; else goto <D.5952>;
      <D.5951>:
      inptr.29 = (long int) inptr;
      str.30 = (long int) str;
      D.5955 = inptr.29 - str.30;
      D.5956 = D.5955 / 2;
      *items_read = D.5956;
      <D.5952>:
      if (items_written != 0B) goto <D.5957>; else goto <D.5958>;
      <D.5957>:
      *items_written = 0;
      <D.5958>:
      D.5928 = 0B;
      return D.5928;
      <D.5937>:
      c.31 = c;
      if (c.31 == 0) goto <D.5264>; else goto <D.5960>;
      <D.5960>:
      c.31 = c;
      D.5961 = monoeg_g_unichar_to_utf8 (c.31, 0B);
      D.5962 = (long unsigned int) D.5961;
      outlen = D.5962 + outlen;
      D.5963 = (long unsigned int) n;
      inleft = inleft - D.5963;
      D.5964 = (sizetype) n;
      inptr = inptr + D.5964;
      <D.5266>:
      if (inleft != 0) goto <D.5265>; else goto <D.5264>;
      <D.5264>:
      if (items_read != 0B) goto <D.5965>; else goto <D.5966>;
      <D.5965>:
      inptr.29 = (long int) inptr;
      str.30 = (long int) str;
      D.5955 = inptr.29 - str.30;
      D.5956 = D.5955 / 2;
      *items_read = D.5956;
      <D.5966>:
      if (items_written != 0B) goto <D.5967>; else goto <D.5968>;
      <D.5967>:
      outlen.32 = (long int) outlen;
      *items_written = outlen.32;
      <D.5968>:
      D.5970 = outlen + 1;
      outbuf = monoeg_malloc (D.5970);
      outptr = outbuf;
      inptr = str;
      D.5935 = len * 2;
      inleft = (size_t) D.5935;
      goto <D.5269>;
      <D.5268>:
      n = decode_utf16le (inptr, inleft, &c);
      if (n < 0) goto <D.5267>; else goto <D.5971>;
      <D.5971>:
      c.31 = c;
      if (c.31 == 0) goto <D.5267>; else goto <D.5972>;
      <D.5972>:
      c.31 = c;
      D.5973 = monoeg_g_unichar_to_utf8 (c.31, outptr);
      D.5974 = (sizetype) D.5973;
      outptr = outptr + D.5974;
      D.5963 = (long unsigned int) n;
      inleft = inleft - D.5963;
      D.5964 = (sizetype) n;
      inptr = inptr + D.5964;
      <D.5269>:
      if (inleft != 0) goto <D.5268>; else goto <D.5267>;
      <D.5267>:
      *outptr = 0;
      D.5928 = outbuf;
      return D.5928;
    }
  finally
    {
      c = {CLOBBER};
    }
}


monoeg_g_utf16_to_ucs4 (const gunichar2 * str, glong len, glong * items_read, glong * items_written, struct GError * * err)
{
  gunichar * D.5979;
  long unsigned int len.33;
  long unsigned int D.5983;
  const gunichar2 * D.5984;
  short unsigned int D.5985;
  long int D.5986;
  _Bool D.5989;
  _Bool D.5990;
  _Bool D.5991;
  int * D.5994;
  int D.5995;
  void * D.5998;
  void * D.6001;
  long int inptr.34;
  long int str.35;
  long int D.6006;
  long int D.6007;
  unsigned int c.36;
  long unsigned int D.6012;
  sizetype D.6013;
  long unsigned int D.6018;
  long int D.6019;
  long unsigned int D.6020;
  gunichar * outptr.37;
  gunichar * outbuf;
  gunichar * outptr;
  size_t outlen;
  size_t inleft;
  char * inptr;
  gunichar c;
  int n;

  try
    {
      outlen = 0;
      if (str == 0B) goto <D.5977>; else goto <D.5978>;
      <D.5977>:
      monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "giconv.c", 1177, "str != NULL");
      D.5979 = 0B;
      return D.5979;
      <D.5978>:
      if (len < 0) goto <D.5980>; else goto <D.5981>;
      <D.5980>:
      len = 0;
      goto <D.5285>;
      <D.5284>:
      len = len + 1;
      <D.5285>:
      len.33 = (long unsigned int) len;
      D.5983 = len.33 * 2;
      D.5984 = str + D.5983;
      D.5985 = *D.5984;
      if (D.5985 != 0) goto <D.5284>; else goto <D.5286>;
      <D.5286>:
      <D.5981>:
      inptr = str;
      D.5986 = len * 2;
      inleft = (size_t) D.5986;
      goto <D.5289>;
      <D.5288>:
      n = decode_utf16le (inptr, inleft, &c);
      if (n < 0) goto <D.5987>; else goto <D.5988>;
      <D.5987>:
      D.5989 = n == -2;
      D.5990 = inleft > 2;
      D.5991 = D.5989 & D.5990;
      if (D.5991 != 0) goto <D.5992>; else goto <D.5993>;
      <D.5992>:
      inleft = inleft + 18446744073709551614;
      inptr = inptr + 2;
      <D.5993>:
      D.5994 = __errno_location ();
      D.5995 = *D.5994;
      if (D.5995 == 84) goto <D.5996>; else goto <D.5997>;
      <D.5996>:
      D.5998 = monoeg_g_convert_error_quark ();
      monoeg_g_set_error (err, D.5998, 1, "Illegal byte sequence encounted in the input.");
      goto <D.5999>;
      <D.5997>:
      if (items_read != 0B) goto <D.5287>; else goto <D.6000>;
      <D.6000>:
      D.6001 = monoeg_g_convert_error_quark ();
      monoeg_g_set_error (err, D.6001, 3, "Partial byte sequence encountered in the input.");
      <D.5999>:
      if (items_read != 0B) goto <D.6002>; else goto <D.6003>;
      <D.6002>:
      inptr.34 = (long int) inptr;
      str.35 = (long int) str;
      D.6006 = inptr.34 - str.35;
      D.6007 = D.6006 / 2;
      *items_read = D.6007;
      <D.6003>:
      if (items_written != 0B) goto <D.6008>; else goto <D.6009>;
      <D.6008>:
      *items_written = 0;
      <D.6009>:
      D.5979 = 0B;
      return D.5979;
      <D.5988>:
      c.36 = c;
      if (c.36 == 0) goto <D.5287>; else goto <D.6011>;
      <D.6011>:
      outlen = outlen + 4;
      D.6012 = (long unsigned int) n;
      inleft = inleft - D.6012;
      D.6013 = (sizetype) n;
      inptr = inptr + D.6013;
      <D.5289>:
      if (inleft != 0) goto <D.5288>; else goto <D.5287>;
      <D.5287>:
      if (items_read != 0B) goto <D.6014>; else goto <D.6015>;
      <D.6014>:
      inptr.34 = (long int) inptr;
      str.35 = (long int) str;
      D.6006 = inptr.34 - str.35;
      D.6007 = D.6006 / 2;
      *items_read = D.6007;
      <D.6015>:
      if (items_written != 0B) goto <D.6016>; else goto <D.6017>;
      <D.6016>:
      D.6018 = outlen / 4;
      D.6019 = (long int) D.6018;
      *items_written = D.6019;
      <D.6017>:
      D.6020 = outlen + 4;
      outbuf = monoeg_malloc (D.6020);
      outptr = outbuf;
      inptr = str;
      D.5986 = len * 2;
      inleft = (size_t) D.5986;
      goto <D.5292>;
      <D.5291>:
      n = decode_utf16le (inptr, inleft, &c);
      if (n < 0) goto <D.5290>; else goto <D.6021>;
      <D.6021>:
      c.36 = c;
      if (c.36 == 0) goto <D.5290>; else goto <D.6022>;
      <D.6022>:
      outptr.37 = outptr;
      outptr = outptr.37 + 4;
      c.36 = c;
      *outptr.37 = c.36;
      D.6012 = (long unsigned int) n;
      inleft = inleft - D.6012;
      D.6013 = (sizetype) n;
      inptr = inptr + D.6013;
      <D.5292>:
      if (inleft != 0) goto <D.5291>; else goto <D.5290>;
      <D.5290>:
      *outptr = 0;
      D.5979 = outbuf;
      return D.5979;
    }
  finally
    {
      c = {CLOBBER};
    }
}


monoeg_g_ucs4_to_utf8 (const gunichar * str, glong len, glong * items_read, glong * items_written, struct GError * * err)
{
  gchar * D.6028;
  long unsigned int i.38;
  long unsigned int D.6032;
  const gunichar * D.6033;
  unsigned int D.6034;
  void * D.6037;
  long unsigned int D.6042;
  void * D.6046;
  long unsigned int D.6052;
  int D.6053;
  sizetype D.6054;
  long int outlen.39;
  char * outbuf;
  char * outptr;
  size_t outlen;
  glong i;
  int n;

  outlen = 0;
  if (str == 0B) goto <D.6026>; else goto <D.6027>;
  <D.6026>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "giconv.c", 1256, "str != NULL");
  D.6028 = 0B;
  return D.6028;
  <D.6027>:
  if (len < 0) goto <D.6029>; else goto <D.6030>;
  <D.6029>:
  i = 0;
  goto <D.5306>;
  <D.5305>:
  i.38 = (long unsigned int) i;
  D.6032 = i.38 * 4;
  D.6033 = str + D.6032;
  D.6034 = *D.6033;
  n = monoeg_g_unichar_to_utf8 (D.6034, 0B);
  if (n < 0) goto <D.6035>; else goto <D.6036>;
  <D.6035>:
  D.6037 = monoeg_g_convert_error_quark ();
  monoeg_g_set_error (err, D.6037, 1, "Illegal byte sequence encounted in the input.");
  if (items_written != 0B) goto <D.6038>; else goto <D.6039>;
  <D.6038>:
  *items_written = 0;
  <D.6039>:
  if (items_read != 0B) goto <D.6040>; else goto <D.6041>;
  <D.6040>:
  *items_read = i;
  <D.6041>:
  D.6028 = 0B;
  return D.6028;
  <D.6036>:
  D.6042 = (long unsigned int) n;
  outlen = D.6042 + outlen;
  i = i + 1;
  <D.5306>:
  i.38 = (long unsigned int) i;
  D.6032 = i.38 * 4;
  D.6033 = str + D.6032;
  D.6034 = *D.6033;
  if (D.6034 != 0) goto <D.5305>; else goto <D.5307>;
  <D.5307>:
  goto <D.6043>;
  <D.6030>:
  i = 0;
  goto <D.5309>;
  <D.5308>:
  i.38 = (long unsigned int) i;
  D.6032 = i.38 * 4;
  D.6033 = str + D.6032;
  D.6034 = *D.6033;
  n = monoeg_g_unichar_to_utf8 (D.6034, 0B);
  if (n < 0) goto <D.6044>; else goto <D.6045>;
  <D.6044>:
  D.6046 = monoeg_g_convert_error_quark ();
  monoeg_g_set_error (err, D.6046, 1, "Illegal byte sequence encounted in the input.");
  if (items_written != 0B) goto <D.6047>; else goto <D.6048>;
  <D.6047>:
  *items_written = 0;
  <D.6048>:
  if (items_read != 0B) goto <D.6049>; else goto <D.6050>;
  <D.6049>:
  *items_read = i;
  <D.6050>:
  D.6028 = 0B;
  return D.6028;
  <D.6045>:
  D.6042 = (long unsigned int) n;
  outlen = D.6042 + outlen;
  i = i + 1;
  <D.5309>:
  if (i < len) goto <D.6051>; else goto <D.5310>;
  <D.6051>:
  i.38 = (long unsigned int) i;
  D.6032 = i.38 * 4;
  D.6033 = str + D.6032;
  D.6034 = *D.6033;
  if (D.6034 != 0) goto <D.5308>; else goto <D.5310>;
  <D.5310>:
  <D.6043>:
  len = i;
  D.6052 = outlen + 1;
  outbuf = monoeg_malloc (D.6052);
  outptr = outbuf;
  i = 0;
  goto <D.5312>;
  <D.5311>:
  i.38 = (long unsigned int) i;
  D.6032 = i.38 * 4;
  D.6033 = str + D.6032;
  D.6034 = *D.6033;
  D.6053 = monoeg_g_unichar_to_utf8 (D.6034, outptr);
  D.6054 = (sizetype) D.6053;
  outptr = outptr + D.6054;
  i = i + 1;
  <D.5312>:
  if (i < len) goto <D.5311>; else goto <D.5313>;
  <D.5313>:
  *outptr = 0;
  if (items_written != 0B) goto <D.6055>; else goto <D.6056>;
  <D.6055>:
  outlen.39 = (long int) outlen;
  *items_written = outlen.39;
  <D.6056>:
  if (items_read != 0B) goto <D.6058>; else goto <D.6059>;
  <D.6058>:
  *items_read = i;
  <D.6059>:
  D.6028 = outbuf;
  return D.6028;
}


monoeg_g_ucs4_to_utf16 (const gunichar * str, glong len, glong * items_read, glong * items_written, struct GError * * err)
{
  gunichar2 * D.6063;
  long unsigned int i.40;
  long unsigned int D.6067;
  const gunichar * D.6068;
  unsigned int D.6069;
  void * D.6072;
  long unsigned int D.6077;
  void * D.6081;
  long unsigned int D.6087;
  long unsigned int D.6088;
  int D.6089;
  long unsigned int D.6090;
  long unsigned int D.6091;
  long int outlen.41;
  gunichar2 * outbuf;
  gunichar2 * outptr;
  size_t outlen;
  glong i;
  int n;

  outlen = 0;
  if (str == 0B) goto <D.6061>; else goto <D.6062>;
  <D.6061>:
  monoeg_g_log (0B, 8, "%s:%d: assertion \'%s\' failed", "giconv.c", 1318, "str != NULL");
  D.6063 = 0B;
  return D.6063;
  <D.6062>:
  if (len < 0) goto <D.6064>; else goto <D.6065>;
  <D.6064>:
  i = 0;
  goto <D.5327>;
  <D.5326>:
  i.40 = (long unsigned int) i;
  D.6067 = i.40 * 4;
  D.6068 = str + D.6067;
  D.6069 = *D.6068;
  n = monoeg_unichar_to_utf16 (D.6069, 0B);
  if (n < 0) goto <D.6070>; else goto <D.6071>;
  <D.6070>:
  D.6072 = monoeg_g_convert_error_quark ();
  monoeg_g_set_error (err, D.6072, 1, "Illegal byte sequence encounted in the input.");
  if (items_written != 0B) goto <D.6073>; else goto <D.6074>;
  <D.6073>:
  *items_written = 0;
  <D.6074>:
  if (items_read != 0B) goto <D.6075>; else goto <D.6076>;
  <D.6075>:
  *items_read = i;
  <D.6076>:
  D.6063 = 0B;
  return D.6063;
  <D.6071>:
  D.6077 = (long unsigned int) n;
  outlen = D.6077 + outlen;
  i = i + 1;
  <D.5327>:
  i.40 = (long unsigned int) i;
  D.6067 = i.40 * 4;
  D.6068 = str + D.6067;
  D.6069 = *D.6068;
  if (D.6069 != 0) goto <D.5326>; else goto <D.5328>;
  <D.5328>:
  goto <D.6078>;
  <D.6065>:
  i = 0;
  goto <D.5330>;
  <D.5329>:
  i.40 = (long unsigned int) i;
  D.6067 = i.40 * 4;
  D.6068 = str + D.6067;
  D.6069 = *D.6068;
  n = monoeg_unichar_to_utf16 (D.6069, 0B);
  if (n < 0) goto <D.6079>; else goto <D.6080>;
  <D.6079>:
  D.6081 = monoeg_g_convert_error_quark ();
  monoeg_g_set_error (err, D.6081, 1, "Illegal byte sequence encounted in the input.");
  if (items_written != 0B) goto <D.6082>; else goto <D.6083>;
  <D.6082>:
  *items_written = 0;
  <D.6083>:
  if (items_read != 0B) goto <D.6084>; else goto <D.6085>;
  <D.6084>:
  *items_read = i;
  <D.6085>:
  D.6063 = 0B;
  return D.6063;
  <D.6080>:
  D.6077 = (long unsigned int) n;
  outlen = D.6077 + outlen;
  i = i + 1;
  <D.5330>:
  if (i < len) goto <D.6086>; else goto <D.5331>;
  <D.6086>:
  i.40 = (long unsigned int) i;
  D.6067 = i.40 * 4;
  D.6068 = str + D.6067;
  D.6069 = *D.6068;
  if (D.6069 != 0) goto <D.5329>; else goto <D.5331>;
  <D.5331>:
  <D.6078>:
  len = i;
  D.6087 = outlen + 1;
  D.6088 = D.6087 * 2;
  outbuf = monoeg_malloc (D.6088);
  outptr = outbuf;
  i = 0;
  goto <D.5333>;
  <D.5332>:
  i.40 = (long unsigned int) i;
  D.6067 = i.40 * 4;
  D.6068 = str + D.6067;
  D.6069 = *D.6068;
  D.6089 = monoeg_unichar_to_utf16 (D.6069, outptr);
  D.6090 = (long unsigned int) D.6089;
  D.6091 = D.6090 * 2;
  outptr = outptr + D.6091;
  i = i + 1;
  <D.5333>:
  if (i < len) goto <D.5332>; else goto <D.5334>;
  <D.5334>:
  *outptr = 0;
  if (items_written != 0B) goto <D.6092>; else goto <D.6093>;
  <D.6092>:
  outlen.41 = (long int) outlen;
  *items_written = outlen.41;
  <D.6093>:
  if (items_read != 0B) goto <D.6095>; else goto <D.6096>;
  <D.6095>:
  *items_read = i;
  <D.6096>:
  D.6063 = outbuf;
  return D.6063;
}