compare_strings_utf8_pos (const gchar * expected, const gchar * actual, glong size)
{
  sizetype D.5282;
  const gchar * D.5283;
  char D.5284;
  const gchar * D.5285;
  char D.5286;
  glong D.5289;
  long int D.5290;
  int i;

  i = 0;
  goto <D.4953>;
  <D.4952>:
  D.5282 = (sizetype) i;
  D.5283 = expected + D.5282;
  D.5284 = *D.5283;
  D.5282 = (sizetype) i;
  D.5285 = actual + D.5282;
  D.5286 = *D.5285;
  if (D.5284 != D.5286) goto <D.5287>; else goto <D.5288>;
  <D.5287>:
  D.5289 = (glong) i;
  return D.5289;
  <D.5288>:
  i = i + 1;
  <D.4953>:
  D.5290 = (long int) i;
  if (D.5290 < size) goto <D.4952>; else goto <D.4954>;
  <D.4954>:
  D.5289 = -1;
  return D.5289;
}


compare_strings_utf8_RESULT (const gchar * expected, const gchar * actual, glong size)
{
  gchar * D.5294;
  glong ret;

  ret = compare_strings_utf8_pos (expected, actual, size);
  if (ret < 0) goto <D.5292>; else goto <D.5293>;
  <D.5292>:
  D.5294 = 0B;
  return D.5294;
  <D.5293>:
  D.5294 = FAILED ("Incorrect output: expected \'%s\' but was \'%s\', differ at %d\n", expected, actual, ret);
  return D.5294;
}


gchar_to_gunichar2 (gunichar2 * ret, const gchar * src)
{
  long unsigned int D.5296;
  long unsigned int D.5297;
  gunichar2 * D.5298;
  sizetype D.5299;
  const gchar * D.5300;
  char D.5301;
  short unsigned int D.5302;
  int i;

  i = 0;
  goto <D.4967>;
  <D.4966>:
  D.5296 = (long unsigned int) i;
  D.5297 = D.5296 * 2;
  D.5298 = ret + D.5297;
  D.5299 = (sizetype) i;
  D.5300 = src + D.5299;
  D.5301 = *D.5300;
  D.5302 = (short unsigned int) D.5301;
  *D.5298 = D.5302;
  i = i + 1;
  <D.4967>:
  D.5299 = (sizetype) i;
  D.5300 = src + D.5299;
  D.5301 = *D.5300;
  if (D.5301 != 0) goto <D.4966>; else goto <D.4968>;
  <D.4968>:
  D.5296 = (long unsigned int) i;
  D.5297 = D.5296 * 2;
  D.5298 = ret + D.5297;
  *D.5298 = 0;
}


compare_utf16_to_utf8_explicit (const gchar * expected, const gunichar2 * utf16, glong len_in, glong len_out, glong size_spec)
{
  struct GError * error.0;
  gchar * D.5306;
  int D.5307;
  gchar * D.5310;
  long int in_read.1;
  long int out_read.2;
  struct GError * error;
  gchar * ret;
  gchar * result;
  glong in_read;
  glong out_read;

  try
    {
      result = 0B;
      error = 0B;
      ret = monoeg_g_utf16_to_utf8 (utf16, size_spec, &in_read, &out_read, &error);
      error.0 = error;
      if (error.0 != 0B) goto <D.5304>; else goto <D.5305>;
      <D.5304>:
      error.0 = error;
      D.5306 = error.0->message;
      error.0 = error;
      D.5307 = error.0->code;
      result = FAILED ("The error is %d %s\n", D.5307, D.5306);
      error.0 = error;
      monoeg_g_error_free (error.0);
      if (ret != 0B) goto <D.5308>; else goto <D.5309>;
      <D.5308>:
      monoeg_g_free (ret);
      <D.5309>:
      D.5310 = result;
      return D.5310;
      <D.5305>:
      in_read.1 = in_read;
      if (in_read.1 != len_in) goto <D.5312>; else goto <D.5313>;
      <D.5312>:
      in_read.1 = in_read;
      result = FAILED ("Read size is incorrect: expected %d but was %d\n", len_in, in_read.1);
      goto <D.5314>;
      <D.5313>:
      out_read.2 = out_read;
      if (out_read.2 != len_out) goto <D.5316>; else goto <D.5317>;
      <D.5316>:
      out_read.2 = out_read;
      result = FAILED ("Converted size is incorrect: expected %d but was %d\n", len_out, out_read.2);
      goto <D.5318>;
      <D.5317>:
      result = compare_strings_utf8_RESULT (expected, ret, len_out);
      <D.5318>:
      <D.5314>:
      monoeg_g_free (ret);
      if (result != 0B) goto <D.5319>; else goto <D.5320>;
      <D.5319>:
      D.5310 = result;
      return D.5310;
      <D.5320>:
      D.5310 = 0B;
      return D.5310;
    }
  finally
    {
      error = {CLOBBER};
      in_read = {CLOBBER};
      out_read = {CLOBBER};
    }
}


compare_utf16_to_utf8 (const gchar * expected, const gunichar2 * utf16, glong len_in, glong len_out)
{
  gchar * D.5325;
  gchar * result;

  result = compare_utf16_to_utf8_explicit (expected, utf16, len_in, len_out, -1);
  if (result != 0B) goto <D.5323>; else goto <D.5324>;
  <D.5323>:
  D.5325 = result;
  return D.5325;
  <D.5324>:
  D.5325 = compare_utf16_to_utf8_explicit (expected, utf16, len_in, len_out, len_in);
  return D.5325;
}


test_utf16_to_utf8 ()
{
  gchar * D.5329;
  const gchar * src0;
  const gchar * src1;
  const gchar * src2;
  const gchar * src3;
  const gchar * src4;
  const gchar * src5;
  gunichar2 str0[1];
  gunichar2 str1[6];
  gunichar2 str2[3];
  gunichar2 str3[2];
  gunichar2 str4[2];
  gunichar2 str5[3];
  gchar * result;

  try
    {
      src0 = "";
      src1 = "ABCDE";
      src2 = "年\'";
      src3 = "Ａ";
      src4 = "ａ";
      src5 = "𐐀";
      str0[0] = 0;
      str2[0] = 24180;
      str2[1] = 39;
      str2[2] = 0;
      str3[0] = 65313;
      str3[1] = 0;
      str4[0] = 65345;
      str4[1] = 0;
      str5[0] = 55297;
      str5[1] = 56320;
      str5[2] = 0;
      gchar_to_gunichar2 (&str1, src1);
      result = compare_utf16_to_utf8 (src0, &str0, 0, 0);
      if (result != 0B) goto <D.5327>; else goto <D.5328>;
      <D.5327>:
      D.5329 = result;
      return D.5329;
      <D.5328>:
      result = compare_utf16_to_utf8 (src1, &str1, 5, 5);
      if (result != 0B) goto <D.5330>; else goto <D.5331>;
      <D.5330>:
      D.5329 = result;
      return D.5329;
      <D.5331>:
      result = compare_utf16_to_utf8 (src2, &str2, 2, 4);
      if (result != 0B) goto <D.5332>; else goto <D.5333>;
      <D.5332>:
      D.5329 = result;
      return D.5329;
      <D.5333>:
      result = compare_utf16_to_utf8 (src3, &str3, 1, 3);
      if (result != 0B) goto <D.5334>; else goto <D.5335>;
      <D.5334>:
      D.5329 = result;
      return D.5329;
      <D.5335>:
      result = compare_utf16_to_utf8 (src4, &str4, 1, 3);
      if (result != 0B) goto <D.5336>; else goto <D.5337>;
      <D.5336>:
      D.5329 = result;
      return D.5329;
      <D.5337>:
      result = compare_utf16_to_utf8 (src5, &str5, 2, 4);
      if (result != 0B) goto <D.5338>; else goto <D.5339>;
      <D.5338>:
      D.5329 = result;
      return D.5329;
      <D.5339>:
      D.5329 = 0B;
      return D.5329;
    }
  finally
    {
      str0 = {CLOBBER};
      str1 = {CLOBBER};
      str2 = {CLOBBER};
      str3 = {CLOBBER};
      str4 = {CLOBBER};
      str5 = {CLOBBER};
    }
}


compare_strings_utf16_pos (const gunichar2 * expected, const gunichar2 * actual, glong size)
{
  long unsigned int D.5342;
  long unsigned int D.5343;
  const gunichar2 * D.5344;
  short unsigned int D.5345;
  const gunichar2 * D.5346;
  short unsigned int D.5347;
  glong D.5350;
  long int D.5351;
  int i;

  i = 0;
  goto <D.5010>;
  <D.5009>:
  D.5342 = (long unsigned int) i;
  D.5343 = D.5342 * 2;
  D.5344 = expected + D.5343;
  D.5345 = *D.5344;
  D.5342 = (long unsigned int) i;
  D.5343 = D.5342 * 2;
  D.5346 = actual + D.5343;
  D.5347 = *D.5346;
  if (D.5345 != D.5347) goto <D.5348>; else goto <D.5349>;
  <D.5348>:
  D.5350 = (glong) i;
  return D.5350;
  <D.5349>:
  i = i + 1;
  <D.5010>:
  D.5351 = (long int) i;
  if (D.5351 < size) goto <D.5009>; else goto <D.5011>;
  <D.5011>:
  D.5350 = -1;
  return D.5350;
}


compare_strings_utf16_RESULT (const gunichar2 * expected, const gunichar2 * actual, glong size)
{
  gchar * D.5355;
  long unsigned int ret.3;
  long unsigned int D.5357;
  const gunichar2 * D.5358;
  short unsigned int D.5359;
  int D.5360;
  const gunichar2 * D.5361;
  short unsigned int D.5362;
  int D.5363;
  glong ret;

  ret = compare_strings_utf16_pos (expected, actual, size);
  if (ret < 0) goto <D.5353>; else goto <D.5354>;
  <D.5353>:
  D.5355 = 0B;
  return D.5355;
  <D.5354>:
  ret.3 = (long unsigned int) ret;
  D.5357 = ret.3 * 2;
  D.5358 = actual + D.5357;
  D.5359 = *D.5358;
  D.5360 = (int) D.5359;
  ret.3 = (long unsigned int) ret;
  D.5357 = ret.3 * 2;
  D.5361 = expected + D.5357;
  D.5362 = *D.5361;
  D.5363 = (int) D.5362;
  D.5355 = FAILED ("Incorrect output: expected \'%s\' but was \'%s\', differ at %d (\'%c\' x \'%c\')\n", expected, actual, ret, D.5363, D.5360);
  return D.5355;
}


compare_utf8_to_utf16_explicit (const gunichar2 * expected, const gchar * utf8, glong len_in, glong len_out, glong size_spec, gboolean include_nuls)
{
  struct GError * error.4;
  gchar * D.5371;
  int D.5372;
  gchar * D.5375;
  long int in_read.5;
  long int out_read.6;
  struct GError * error;
  gunichar2 * ret;
  gchar * result;
  glong in_read;
  glong out_read;

  try
    {
      result = 0B;
      error = 0B;
      if (include_nuls != 0) goto <D.5365>; else goto <D.5366>;
      <D.5365>:
      ret = eg_utf8_to_utf16_with_nuls (utf8, size_spec, &in_read, &out_read, &error);
      goto <D.5367>;
      <D.5366>:
      ret = monoeg_g_utf8_to_utf16 (utf8, size_spec, &in_read, &out_read, &error);
      <D.5367>:
      error.4 = error;
      if (error.4 != 0B) goto <D.5369>; else goto <D.5370>;
      <D.5369>:
      error.4 = error;
      D.5371 = error.4->message;
      error.4 = error;
      D.5372 = error.4->code;
      result = FAILED ("The error is %d %s\n", D.5372, D.5371);
      error.4 = error;
      monoeg_g_error_free (error.4);
      if (ret != 0B) goto <D.5373>; else goto <D.5374>;
      <D.5373>:
      monoeg_g_free (ret);
      <D.5374>:
      D.5375 = result;
      return D.5375;
      <D.5370>:
      in_read.5 = in_read;
      if (in_read.5 != len_in) goto <D.5377>; else goto <D.5378>;
      <D.5377>:
      in_read.5 = in_read;
      result = FAILED ("Read size is incorrect: expected %d but was %d\n", len_in, in_read.5);
      goto <D.5379>;
      <D.5378>:
      out_read.6 = out_read;
      if (out_read.6 != len_out) goto <D.5381>; else goto <D.5382>;
      <D.5381>:
      out_read.6 = out_read;
      result = FAILED ("Converted size is incorrect: expected %d but was %d\n", len_out, out_read.6);
      goto <D.5383>;
      <D.5382>:
      result = compare_strings_utf16_RESULT (expected, ret, len_out);
      <D.5383>:
      <D.5379>:
      monoeg_g_free (ret);
      if (result != 0B) goto <D.5384>; else goto <D.5385>;
      <D.5384>:
      D.5375 = result;
      return D.5375;
      <D.5385>:
      D.5375 = 0B;
      return D.5375;
    }
  finally
    {
      error = {CLOBBER};
      in_read = {CLOBBER};
      out_read = {CLOBBER};
    }
}


compare_utf8_to_utf16_general (const gunichar2 * expected, const gchar * utf8, glong len_in, glong len_out, gboolean include_nuls)
{
  gchar * D.5390;
  gchar * result;

  result = compare_utf8_to_utf16_explicit (expected, utf8, len_in, len_out, -1, include_nuls);
  if (result != 0B) goto <D.5388>; else goto <D.5389>;
  <D.5388>:
  D.5390 = result;
  return D.5390;
  <D.5389>:
  D.5390 = compare_utf8_to_utf16_explicit (expected, utf8, len_in, len_out, len_in, include_nuls);
  return D.5390;
}


compare_utf8_to_utf16 (const gunichar2 * expected, const gchar * utf8, glong len_in, glong len_out)
{
  gchar * D.5392;

  D.5392 = compare_utf8_to_utf16_general (expected, utf8, len_in, len_out, 0);
  return D.5392;
}


compare_utf8_to_utf16_with_nuls (const gunichar2 * expected, const gchar * utf8, glong len_in, glong len_out)
{
  gchar * D.5394;

  D.5394 = compare_utf8_to_utf16_explicit (expected, utf8, len_in, len_out, len_in, 1);
  return D.5394;
}


test_utf8_seq ()
{
  long unsigned int D.5396;
  long int D.5397;
  struct GError * error.7;
  gchar * D.5401;
  long int in_read.8;
  long int out_read.9;
  const gchar * src;
  glong in_read;
  glong out_read;
  struct GError * error;
  gunichar2 * dst;

  try
    {
      src = "年\'";
      error = 0B;
      D.5396 = strlen (src);
      D.5397 = (long int) D.5396;
      dst = monoeg_g_utf8_to_utf16 (src, D.5397, &in_read, &out_read, &error);
      error.7 = error;
      if (error.7 != 0B) goto <D.5399>; else goto <D.5400>;
      <D.5399>:
      error.7 = error;
      D.5401 = error.7->message;
      return D.5401;
      <D.5400>:
      in_read.8 = in_read;
      if (in_read.8 != 4) goto <D.5403>; else goto <D.5404>;
      <D.5403>:
      in_read.8 = in_read;
      D.5401 = FAILED ("in_read is expected to be 4 but was %d\n", in_read.8);
      return D.5401;
      <D.5404>:
      out_read.9 = out_read;
      if (out_read.9 != 2) goto <D.5406>; else goto <D.5407>;
      <D.5406>:
      out_read.9 = out_read;
      D.5401 = FAILED ("out_read is expected to be 2 but was %d\n", out_read.9);
      return D.5401;
      <D.5407>:
      monoeg_g_free (dst);
      D.5401 = 0B;
      return D.5401;
    }
  finally
    {
      in_read = {CLOBBER};
      out_read = {CLOBBER};
      error = {CLOBBER};
    }
}


test_utf8_to_utf16 ()
{
  gchar * D.5412;
  const gchar * src0;
  const gchar * src1;
  const gchar * src2;
  const gchar * src3;
  const gchar * src4;
  gunichar2 str0[1];
  gunichar2 str1[6];
  gunichar2 str2[3];
  gunichar2 str3[2];
  gunichar2 str4[2];
  gchar * result;

  try
    {
      src0 = "";
      src1 = "ABCDE";
      src2 = "年\'";
      src3 = "Ａ";
      src4 = "ａ";
      str0[0] = 0;
      str2[0] = 24180;
      str2[1] = 39;
      str2[2] = 0;
      str3[0] = 65313;
      str3[1] = 0;
      str4[0] = 65345;
      str4[1] = 0;
      gchar_to_gunichar2 (&str1, src1);
      result = compare_utf8_to_utf16 (&str0, src0, 0, 0);
      if (result != 0B) goto <D.5410>; else goto <D.5411>;
      <D.5410>:
      D.5412 = result;
      return D.5412;
      <D.5411>:
      result = compare_utf8_to_utf16 (&str1, src1, 5, 5);
      if (result != 0B) goto <D.5413>; else goto <D.5414>;
      <D.5413>:
      D.5412 = result;
      return D.5412;
      <D.5414>:
      result = compare_utf8_to_utf16 (&str2, src2, 4, 2);
      if (result != 0B) goto <D.5415>; else goto <D.5416>;
      <D.5415>:
      D.5412 = result;
      return D.5412;
      <D.5416>:
      result = compare_utf8_to_utf16 (&str3, src3, 3, 1);
      if (result != 0B) goto <D.5417>; else goto <D.5418>;
      <D.5417>:
      D.5412 = result;
      return D.5412;
      <D.5418>:
      result = compare_utf8_to_utf16 (&str4, src4, 3, 1);
      if (result != 0B) goto <D.5419>; else goto <D.5420>;
      <D.5419>:
      D.5412 = result;
      return D.5412;
      <D.5420>:
      D.5412 = 0B;
      return D.5412;
    }
  finally
    {
      str0 = {CLOBBER};
      str1 = {CLOBBER};
      str2 = {CLOBBER};
      str3 = {CLOBBER};
      str4 = {CLOBBER};
    }
}


test_utf8_to_utf16_with_nuls ()
{
  gunichar2 * D.5423;
  gchar * D.5426;
  const gchar * src0;
  const gchar * src1;
  const gchar * src2;
  const gchar * src3;
  const gchar * src4;
  gunichar2 str0[1];
  gunichar2 str1[6];
  gunichar2 str2[3];
  gunichar2 str3[2];
  gunichar2 str4[2];
  gchar * result;

  try
    {
      src0 = "";
      src1 = "AB";
      src2 = "年\'";
      src3 = "Ａ";
      src4 = "ａ";
      str0[0] = 0;
      str1[0] = 65;
      str1[1] = 66;
      str1[2] = 0;
      str1[3] = 68;
      str1[4] = 69;
      str1[5] = 0;
      str2[0] = 24180;
      str2[1] = 39;
      str2[2] = 0;
      str3[0] = 65313;
      str3[1] = 0;
      str4[0] = 65345;
      str4[1] = 0;
      D.5423 = eg_utf8_to_utf16_with_nuls (src1, -1, 0B, 0B, 0B);
      if (D.5423 != 0B) goto <D.5424>; else goto <D.5425>;
      <D.5424>:
      D.5426 = FAILED ("explicit nulls must fail with -1 length\n");
      return D.5426;
      <D.5425>:
      result = compare_utf8_to_utf16_with_nuls (&str0, src0, 0, 0);
      if (result != 0B) goto <D.5427>; else goto <D.5428>;
      <D.5427>:
      D.5426 = result;
      return D.5426;
      <D.5428>:
      result = compare_utf8_to_utf16_with_nuls (&str1, src1, 5, 5);
      if (result != 0B) goto <D.5429>; else goto <D.5430>;
      <D.5429>:
      D.5426 = result;
      return D.5426;
      <D.5430>:
      result = compare_utf8_to_utf16_with_nuls (&str2, src2, 4, 2);
      if (result != 0B) goto <D.5431>; else goto <D.5432>;
      <D.5431>:
      D.5426 = result;
      return D.5426;
      <D.5432>:
      result = compare_utf8_to_utf16_with_nuls (&str3, src3, 3, 1);
      if (result != 0B) goto <D.5433>; else goto <D.5434>;
      <D.5433>:
      D.5426 = result;
      return D.5426;
      <D.5434>:
      result = compare_utf8_to_utf16_with_nuls (&str4, src4, 3, 1);
      if (result != 0B) goto <D.5435>; else goto <D.5436>;
      <D.5435>:
      D.5426 = result;
      return D.5426;
      <D.5436>:
      D.5426 = 0B;
      return D.5426;
    }
  finally
    {
      str0 = {CLOBBER};
      str1 = {CLOBBER};
      str2 = {CLOBBER};
      str3 = {CLOBBER};
      str4 = {CLOBBER};
    }
}


test_convert ()
{
  gchar * D.5443;
  const char * D.5444;
  long unsigned int D.5447;
  long unsigned int D.5448;
  struct convert_result_t * * D.5449;
  struct convert_result_t * D.5450;
  char * D.5451;
  struct GError * err.10;
  gchar * D.5453;
  long unsigned int D.5454;
  long unsigned int D.5455;
  struct convert_result_t * * D.5456;
  void * D.5457;
  struct convert_result_t * D.5458;
  char * content.11;
  long unsigned int length.12;
  const char * D.5461;
  long unsigned int D.5462;
  long int D.5463;
  char * D.5464;
  long unsigned int D.5467;
  long unsigned int D.5468;
  struct convert_result_t * * D.5469;
  struct convert_result_t * D.5470;
  char * D.5471;
  long unsigned int length.14;
  long unsigned int converted_length.13;
  char * D.5476;
  char D.5477;
  char * D.5478;
  char D.5479;
  int D.5482;
  int D.5483;
  static const char * charsets[5] = {(const char *) "UTF-8", (const char *) "UTF-16LE", (const char *) "UTF-16BE", (const char *) "UTF-32LE", (const char *) "UTF-32BE"};
  gsize length;
  gsize converted_length;
  gsize n;
  char * content;
  char * converted;
  char * path;
  struct convert_result_t * * expected;
  struct GError * err;
  const char * srcdir;
  gboolean loaded;
  guint i;
  guint j;
  guint k;
  char c;

  try
    {
      err = 0B;
      srcdir = getenv ("srcdir");
      if (srcdir == 0B) goto <D.5439>; else goto <D.5440>;
      <D.5439>:
      srcdir = getenv ("PWD");
      if (srcdir == 0B) goto <D.5441>; else goto <D.5442>;
      <D.5441>:
      D.5443 = FAILED ("srcdir not defined!");
      return D.5443;
      <D.5442>:
      <D.5440>:
      expected = monoeg_malloc (40);
      i = 0;
      goto <D.5109>;
      <D.5108>:
      D.5444 = charsets[i];
      path = monoeg_g_strdup_printf ("%s%c%s.txt", srcdir, 47, D.5444);
      loaded = monoeg_g_file_get_contents (path, &content, &length, &err);
      monoeg_g_free (path);
      if (loaded == 0) goto <D.5445>; else goto <D.5446>;
      <D.5445>:
      j = 0;
      goto <D.5106>;
      <D.5105>:
      D.5447 = (long unsigned int) j;
      D.5448 = D.5447 * 8;
      D.5449 = expected + D.5448;
      D.5450 = *D.5449;
      D.5451 = D.5450->content;
      monoeg_g_free (D.5451);
      D.5447 = (long unsigned int) j;
      D.5448 = D.5447 * 8;
      D.5449 = expected + D.5448;
      D.5450 = *D.5449;
      monoeg_g_free (D.5450);
      j = j + 1;
      <D.5106>:
      if (j < i) goto <D.5105>; else goto <D.5107>;
      <D.5107>:
      monoeg_g_free (expected);
      err.10 = err;
      D.5453 = err.10->message;
      D.5444 = charsets[i];
      D.5443 = FAILED ("Failed to load content for %s: %s", D.5444, D.5453);
      return D.5443;
      <D.5446>:
      D.5454 = (long unsigned int) i;
      D.5455 = D.5454 * 8;
      D.5456 = expected + D.5455;
      D.5457 = monoeg_malloc (16);
      *D.5456 = D.5457;
      D.5454 = (long unsigned int) i;
      D.5455 = D.5454 * 8;
      D.5456 = expected + D.5455;
      D.5458 = *D.5456;
      content.11 = content;
      D.5458->content = content.11;
      D.5454 = (long unsigned int) i;
      D.5455 = D.5454 * 8;
      D.5456 = expected + D.5455;
      D.5458 = *D.5456;
      length.12 = length;
      D.5458->length = length.12;
      i = i + 1;
      <D.5109>:
      if (i <= 4) goto <D.5108>; else goto <D.5110>;
      <D.5110>:
      i = 0;
      goto <D.5127>;
      <D.5126>:
      j = 0;
      goto <D.5124>;
      <D.5123>:
      D.5444 = charsets[i];
      D.5461 = charsets[j];
      D.5454 = (long unsigned int) i;
      D.5455 = D.5454 * 8;
      D.5456 = expected + D.5455;
      D.5458 = *D.5456;
      D.5462 = D.5458->length;
      D.5463 = (long int) D.5462;
      D.5454 = (long unsigned int) i;
      D.5455 = D.5454 * 8;
      D.5456 = expected + D.5455;
      D.5458 = *D.5456;
      D.5464 = D.5458->content;
      converted = monoeg_g_convert (D.5464, D.5463, D.5461, D.5444, 0B, &converted_length, 0B);
      if (converted == 0B) goto <D.5465>; else goto <D.5466>;
      <D.5465>:
      k = 0;
      goto <D.5112>;
      <D.5111>:
      D.5467 = (long unsigned int) k;
      D.5468 = D.5467 * 8;
      D.5469 = expected + D.5468;
      D.5470 = *D.5469;
      D.5471 = D.5470->content;
      monoeg_g_free (D.5471);
      D.5467 = (long unsigned int) k;
      D.5468 = D.5467 * 8;
      D.5469 = expected + D.5468;
      D.5470 = *D.5469;
      monoeg_g_free (D.5470);
      k = k + 1;
      <D.5112>:
      if (k <= 4) goto <D.5111>; else goto <D.5113>;
      <D.5113>:
      monoeg_g_free (expected);
      D.5461 = charsets[j];
      D.5444 = charsets[i];
      D.5443 = FAILED ("Failed to convert from %s to %s: NULL", D.5444, D.5461);
      return D.5443;
      <D.5466>:
      D.5447 = (long unsigned int) j;
      D.5448 = D.5447 * 8;
      D.5449 = expected + D.5448;
      D.5450 = *D.5449;
      length.14 = D.5450->length;
      converted_length.13 = converted_length;
      if (length.14 != converted_length.13) goto <D.5474>; else goto <D.5475>;
      <D.5474>:
      D.5447 = (long unsigned int) j;
      D.5448 = D.5447 * 8;
      D.5449 = expected + D.5448;
      D.5450 = *D.5449;
      length.14 = D.5450->length;
      length = length.14;
      k = 0;
      goto <D.5115>;
      <D.5114>:
      D.5467 = (long unsigned int) k;
      D.5468 = D.5467 * 8;
      D.5469 = expected + D.5468;
      D.5470 = *D.5469;
      D.5471 = D.5470->content;
      monoeg_g_free (D.5471);
      D.5467 = (long unsigned int) k;
      D.5468 = D.5467 * 8;
      D.5469 = expected + D.5468;
      D.5470 = *D.5469;
      monoeg_g_free (D.5470);
      k = k + 1;
      <D.5115>:
      if (k <= 4) goto <D.5114>; else goto <D.5116>;
      <D.5116>:
      monoeg_g_free (converted);
      monoeg_g_free (expected);
      converted_length.13 = converted_length;
      length.12 = length;
      D.5461 = charsets[j];
      D.5444 = charsets[i];
      D.5443 = FAILED ("Failed to convert from %s to %s: expected %u bytes, got %u", D.5444, D.5461, length.12, converted_length.13);
      return D.5443;
      <D.5475>:
      n = 0;
      goto <D.5121>;
      <D.5120>:
      D.5476 = converted + n;
      D.5477 = *D.5476;
      D.5447 = (long unsigned int) j;
      D.5448 = D.5447 * 8;
      D.5449 = expected + D.5448;
      D.5450 = *D.5449;
      D.5451 = D.5450->content;
      D.5478 = D.5451 + n;
      D.5479 = *D.5478;
      if (D.5477 != D.5479) goto <D.5480>; else goto <D.5481>;
      <D.5480>:
      D.5447 = (long unsigned int) j;
      D.5448 = D.5447 * 8;
      D.5449 = expected + D.5448;
      D.5450 = *D.5449;
      D.5451 = D.5450->content;
      D.5478 = D.5451 + n;
      c = *D.5478;
      k = 0;
      goto <D.5118>;
      <D.5117>:
      D.5467 = (long unsigned int) k;
      D.5468 = D.5467 * 8;
      D.5469 = expected + D.5468;
      D.5470 = *D.5469;
      D.5471 = D.5470->content;
      monoeg_g_free (D.5471);
      D.5467 = (long unsigned int) k;
      D.5468 = D.5467 * 8;
      D.5469 = expected + D.5468;
      D.5470 = *D.5469;
      monoeg_g_free (D.5470);
      k = k + 1;
      <D.5118>:
      if (k <= 4) goto <D.5117>; else goto <D.5119>;
      <D.5119>:
      monoeg_g_free (converted);
      monoeg_g_free (expected);
      D.5476 = converted + n;
      D.5477 = *D.5476;
      D.5482 = (int) D.5477;
      D.5483 = (int) c;
      D.5461 = charsets[j];
      D.5444 = charsets[i];
      D.5443 = FAILED ("Failed to convert from %s to %s: expected 0x%x at offset %u, got 0x%x", D.5444, D.5461, D.5483, n, D.5482);
      return D.5443;
      <D.5481>:
      n = n + 1;
      <D.5121>:
      converted_length.13 = converted_length;
      if (n < converted_length.13) goto <D.5120>; else goto <D.5122>;
      <D.5122>:
      monoeg_g_free (converted);
      j = j + 1;
      <D.5124>:
      if (j <= 4) goto <D.5123>; else goto <D.5125>;
      <D.5125>:
      i = i + 1;
      <D.5127>:
      if (i <= 4) goto <D.5126>; else goto <D.5128>;
      <D.5128>:
      k = 0;
      goto <D.5130>;
      <D.5129>:
      D.5467 = (long unsigned int) k;
      D.5468 = D.5467 * 8;
      D.5469 = expected + D.5468;
      D.5470 = *D.5469;
      D.5471 = D.5470->content;
      monoeg_g_free (D.5471);
      D.5467 = (long unsigned int) k;
      D.5468 = D.5467 * 8;
      D.5469 = expected + D.5468;
      D.5470 = *D.5469;
      monoeg_g_free (D.5470);
      k = k + 1;
      <D.5130>:
      if (k <= 4) goto <D.5129>; else goto <D.5131>;
      <D.5131>:
      monoeg_g_free (expected);
      D.5443 = 0B;
      return D.5443;
    }
  finally
    {
      length = {CLOBBER};
      converted_length = {CLOBBER};
      content = {CLOBBER};
      err = {CLOBBER};
    }
}


test_xdigit ()
{
  char D.5486;
  unsigned int D.5487;
  int D.5488;
  int D.5489;
  gchar * D.5492;
  unsigned int i.15;
  static char test_chars[24] = {48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 97, 98, 99, 100, 101, 102, 103, 65, 66, 67, 68, 69, 70, 71};
  static gint32 test_values[24] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, -1, 10, 11, 12, 13, 14, 15, -1};
  int i;

  i = 0;
  i = 0;
  goto <D.5138>;
  <D.5137>:
  D.5486 = test_chars[i];
  D.5487 = (unsigned int) D.5486;
  D.5488 = monoeg_g_unichar_xdigit_value (D.5487);
  D.5489 = test_values[i];
  if (D.5488 != D.5489) goto <D.5490>; else goto <D.5491>;
  <D.5490>:
  D.5489 = test_values[i];
  D.5492 = FAILED ("Incorrect value %d at index %d", D.5489, i);
  return D.5492;
  <D.5491>:
  i = i + 1;
  <D.5138>:
  i.15 = (unsigned int) i;
  if (i.15 <= 23) goto <D.5137>; else goto <D.5139>;
  <D.5139>:
  D.5492 = 0B;
  return D.5492;
}


test_ucs4_to_utf16 ()
{
  struct GError * err.16;
  long int items_written.17;
  long int items_read.18;
  gchar * D.5500;
  gunichar * D.5511;
  long int D.5512;
  long int D.5513;
  long int D.5514;
  _Bool D.5515;
  int D.5516;
  long int D.5517;
  gunichar2 * D.5518;
  static gunichar str1[12] = {72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 0};
  static gunichar2 exp1[12] = {72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 0};
  static gunichar str2[3] = {104, 2147483648, 0};
  static gunichar2 exp2[2] = {104, 0};
  static gunichar str3[3] = {104, 55808, 0};
  static gunichar str4[3] = {104, 1114111, 0};
  static gunichar2 exp4[4] = {104, 56319, 57343, 0};
  static gunichar str5[7] = {55295, 55296, 57343, 57344, 1114112, 1114111, 0};
  static gunichar2 exp5[5] = {55295, 57344, 56319, 57343, 0};
  static gunichar str6[2] = {66560, 0};
  static gunichar2 exp6[3] = {55297, 56320, 0};
  static glong read_write[12] = {1, 1, 0, 0, 0, 0, 1, 1, 0, 0, 1, 2};
  gunichar2 * res;
  glong items_read;
  glong items_written;
  glong current_write_index;
  struct GError * err;
  gchar * check_result;
  glong i;

  try
    {
      err = 0B;
      res = monoeg_g_ucs4_to_utf16 (&str1, 12, &items_read, &items_written, &err);
      err.16 = err;
      items_written.17 = items_written;
      items_read.18 = items_read;
      check_result = ucs4_to_utf16_check_result (res, &exp1, items_read.18, 11, items_written.17, 11, err.16, 0);
      if (check_result != 0B) goto <D.5498>; else goto <D.5499>;
      <D.5498>:
      D.5500 = check_result;
      return D.5500;
      <D.5499>:
      monoeg_g_free (res);
      items_written = 0;
      items_written.17 = items_written;
      items_read = items_written.17;
      res = monoeg_g_ucs4_to_utf16 (&str2, 0, &items_read, &items_written, &err);
      err.16 = err;
      items_written.17 = items_written;
      items_read.18 = items_read;
      check_result = ucs4_to_utf16_check_result (res, &exp2, items_read.18, 0, items_written.17, 0, err.16, 0);
      if (check_result != 0B) goto <D.5501>; else goto <D.5502>;
      <D.5501>:
      D.5500 = check_result;
      return D.5500;
      <D.5502>:
      monoeg_g_free (res);
      items_written = 0;
      items_written.17 = items_written;
      items_read = items_written.17;
      res = monoeg_g_ucs4_to_utf16 (&str2, 1, &items_read, &items_written, &err);
      err.16 = err;
      items_written.17 = items_written;
      items_read.18 = items_read;
      check_result = ucs4_to_utf16_check_result (res, &exp2, items_read.18, 1, items_written.17, 1, err.16, 0);
      if (check_result != 0B) goto <D.5503>; else goto <D.5504>;
      <D.5503>:
      D.5500 = check_result;
      return D.5500;
      <D.5504>:
      monoeg_g_free (res);
      items_written = 0;
      items_written.17 = items_written;
      items_read = items_written.17;
      res = monoeg_g_ucs4_to_utf16 (&str2, 2, &items_read, &items_written, &err);
      err.16 = err;
      items_written.17 = items_written;
      items_read.18 = items_read;
      check_result = ucs4_to_utf16_check_result (res, 0B, items_read.18, 1, items_written.17, 0, err.16, 1);
      monoeg_g_free (res);
      if (check_result != 0B) goto <D.5505>; else goto <D.5506>;
      <D.5505>:
      D.5500 = check_result;
      return D.5500;
      <D.5506>:
      items_written = 0;
      items_written.17 = items_written;
      items_read = items_written.17;
      err = 0B;
      res = monoeg_g_ucs4_to_utf16 (&str3, 2, &items_read, &items_written, &err);
      err.16 = err;
      items_written.17 = items_written;
      items_read.18 = items_read;
      check_result = ucs4_to_utf16_check_result (res, 0B, items_read.18, 1, items_written.17, 0, err.16, 1);
      if (check_result != 0B) goto <D.5507>; else goto <D.5508>;
      <D.5507>:
      D.5500 = check_result;
      return D.5500;
      <D.5508>:
      monoeg_g_free (res);
      items_written = 0;
      items_written.17 = items_written;
      items_read = items_written.17;
      err = 0B;
      res = monoeg_g_ucs4_to_utf16 (&str4, 5, &items_read, &items_written, &err);
      err.16 = err;
      items_written.17 = items_written;
      items_read.18 = items_read;
      check_result = ucs4_to_utf16_check_result (res, &exp4, items_read.18, 2, items_written.17, 3, err.16, 0);
      if (check_result != 0B) goto <D.5509>; else goto <D.5510>;
      <D.5509>:
      D.5500 = check_result;
      return D.5500;
      <D.5510>:
      monoeg_g_free (res);
      current_write_index = 0;
      i = 0;
      goto <D.5176>;
      <D.5175>:
      items_written = 0;
      items_written.17 = items_written;
      items_read = items_written.17;
      err = 0B;
      D.5511 = &str5[i];
      res = monoeg_g_ucs4_to_utf16 (D.5511, 1, &items_read, &items_written, &err);
      D.5512 = i * 2;
      D.5513 = D.5512 + 1;
      D.5514 = read_write[D.5513];
      D.5515 = D.5514 == 0;
      D.5516 = (int) D.5515;
      err.16 = err;
      D.5512 = i * 2;
      D.5513 = D.5512 + 1;
      D.5514 = read_write[D.5513];
      items_written.17 = items_written;
      D.5512 = i * 2;
      D.5517 = read_write[D.5512];
      items_read.18 = items_read;
      D.5518 = &exp5[current_write_index];
      check_result = ucs4_to_utf16_check_result (res, D.5518, items_read.18, D.5517, items_written.17, D.5514, err.16, D.5516);
      if (check_result != 0B) goto <D.5519>; else goto <D.5520>;
      <D.5519>:
      D.5500 = check_result;
      return D.5500;
      <D.5520>:
      monoeg_g_free (res);
      items_written.17 = items_written;
      current_write_index = current_write_index + items_written.17;
      i = i + 1;
      <D.5176>:
      if (i <= 5) goto <D.5175>; else goto <D.5177>;
      <D.5177>:
      items_written = 0;
      items_written.17 = items_written;
      items_read = items_written.17;
      err = 0B;
      res = monoeg_g_ucs4_to_utf16 (&str6, 1, &items_read, &items_written, &err);
      err.16 = err;
      items_written.17 = items_written;
      items_read.18 = items_read;
      check_result = ucs4_to_utf16_check_result (res, &exp6, items_read.18, 1, items_written.17, 2, err.16, 0);
      if (check_result != 0B) goto <D.5521>; else goto <D.5522>;
      <D.5521>:
      D.5500 = check_result;
      return D.5500;
      <D.5522>:
      monoeg_g_free (res);
      D.5500 = 0B;
      return D.5500;
    }
  finally
    {
      items_read = {CLOBBER};
      items_written = {CLOBBER};
      err = {CLOBBER};
    }
}


ucs4_to_utf16_check_result (const gunichar2 * result_str, const gunichar2 * expected_str, glong result_items_read, glong expected_items_read, glong result_items_written, glong expected_items_written, struct GError * result_error, gboolean expect_error)
{
  gchar * D.5527;
  _Bool D.5530;
  _Bool D.5531;
  _Bool D.5532;
  _Bool D.5535;
  _Bool D.5536;
  _Bool D.5537;
  _Bool D.5540;
  _Bool D.5541;
  _Bool D.5544;
  _Bool D.5545;
  long unsigned int i.19;
  long unsigned int D.5549;
  const gunichar2 * D.5550;
  short unsigned int D.5551;
  const gunichar2 * D.5552;
  short unsigned int D.5553;
  int D.5556;
  long unsigned int expected_items_written.20;
  long unsigned int D.5560;
  const gunichar2 * D.5561;
  short unsigned int D.5562;
  glong i;

  if (result_items_read != expected_items_read) goto <D.5525>; else goto <D.5526>;
  <D.5525>:
  D.5527 = FAILED ("Incorrect number of items read; expected %d, got %d", expected_items_read, result_items_read);
  return D.5527;
  <D.5526>:
  if (result_items_written != expected_items_written) goto <D.5528>; else goto <D.5529>;
  <D.5528>:
  D.5527 = FAILED ("Incorrect number of items written; expected %d, got %d", expected_items_written, result_items_written);
  return D.5527;
  <D.5529>:
  D.5530 = result_error != 0B;
  D.5531 = expect_error == 0;
  D.5532 = D.5530 & D.5531;
  if (D.5532 != 0) goto <D.5533>; else goto <D.5534>;
  <D.5533>:
  D.5527 = FAILED ("There should not be an error code.");
  return D.5527;
  <D.5534>:
  D.5535 = result_error == 0B;
  D.5536 = expect_error != 0;
  D.5537 = D.5535 & D.5536;
  if (D.5537 != 0) goto <D.5538>; else goto <D.5539>;
  <D.5538>:
  D.5527 = FAILED ("Unexpected error object.");
  return D.5527;
  <D.5539>:
  D.5536 = expect_error != 0;
  D.5540 = result_str != 0B;
  D.5541 = D.5536 & D.5540;
  if (D.5541 != 0) goto <D.5542>; else goto <D.5543>;
  <D.5542>:
  D.5527 = FAILED ("NULL should be returned when an error occurs.");
  return D.5527;
  <D.5543>:
  D.5531 = expect_error == 0;
  D.5544 = result_str == 0B;
  D.5545 = D.5531 & D.5544;
  if (D.5545 != 0) goto <D.5546>; else goto <D.5547>;
  <D.5546>:
  D.5527 = FAILED ("When no error occurs NULL should not be returned.");
  return D.5527;
  <D.5547>:
  i = 0;
  goto <D.5152>;
  <D.5151>:
  i.19 = (long unsigned int) i;
  D.5549 = i.19 * 2;
  D.5550 = result_str + D.5549;
  D.5551 = *D.5550;
  i.19 = (long unsigned int) i;
  D.5549 = i.19 * 2;
  D.5552 = expected_str + D.5549;
  D.5553 = *D.5552;
  if (D.5551 != D.5553) goto <D.5554>; else goto <D.5555>;
  <D.5554>:
  i.19 = (long unsigned int) i;
  D.5549 = i.19 * 2;
  D.5550 = result_str + D.5549;
  D.5551 = *D.5550;
  D.5556 = (int) D.5551;
  D.5527 = FAILED ("Incorrect value %d at index %d", D.5556, i);
  return D.5527;
  <D.5555>:
  i = i + 1;
  <D.5152>:
  if (i < expected_items_written) goto <D.5151>; else goto <D.5153>;
  <D.5153>:
  if (result_str != 0B) goto <D.5557>; else goto <D.5558>;
  <D.5557>:
  expected_items_written.20 = (long unsigned int) expected_items_written;
  D.5560 = expected_items_written.20 * 2;
  D.5561 = result_str + D.5560;
  D.5562 = *D.5561;
  if (D.5562 != 0) goto <D.5563>; else goto <D.5564>;
  <D.5563>:
  D.5527 = FAILED ("Null termination not found at the end of the string.");
  return D.5527;
  <D.5564>:
  <D.5558>:
  D.5527 = 0B;
  return D.5527;
}


test_utf16_to_ucs4 ()
{
  struct GError * err.21;
  long int items_written.22;
  long int items_read.23;
  gchar * D.5571;
  long int D.5586;
  long int D.5587;
  gunichar2 * D.5588;
  long int D.5589;
  long int D.5590;
  _Bool D.5591;
  int D.5592;
  long int D.5593;
  long int D.5594;
  gunichar * D.5595;
  static gunichar2 str1[12] = {72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 0};
  static gunichar exp1[12] = {72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 0};
  static gunichar2 str2[7] = {72, 55296, 56321, 55296, 56319, 108, 0};
  static gunichar exp2[3] = {72, 65537, 0};
  static gunichar2 str3[4] = {72, 56320, 108, 0};
  static gunichar exp3[2] = {72, 0};
  static gunichar2 str4[20] = {56320, 57343, 3583, 55296, 56319, 55296, 56320, 55296, 57343, 55296, 57344, 56319, 56319, 56319, 56320, 56319, 57343, 56319, 57344, 0};
  static gunichar exp4[6] = {3583, 65536, 66559, 1113088, 1114111, 0};
  static gunichar2 str5[3] = {55297, 56320, 0};
  static gunichar exp5[2] = {66560, 0};
  static glong read_write[33] = {1, 0, 0, 1, 0, 0, 1, 1, 1, 2, 1, 0, 2, 2, 1, 2, 2, 1, 2, 1, 0, 2, 1, 0, 2, 2, 1, 2, 2, 1, 2, 1, 0};
  gunichar * res;
  glong items_read;
  glong items_written;
  glong current_read_index;
  glong current_write_index;
  struct GError * err;
  gchar * check_result;
  glong i;

  try
    {
      err = 0B;
      res = monoeg_g_utf16_to_ucs4 (&str1, 12, &items_read, &items_written, &err);
      err.21 = err;
      items_written.22 = items_written;
      items_read.23 = items_read;
      check_result = utf16_to_ucs4_check_result (res, &exp1, items_read.23, 11, items_written.22, 11, err.21, 0);
      if (check_result != 0B) goto <D.5569>; else goto <D.5570>;
      <D.5569>:
      D.5571 = check_result;
      return D.5571;
      <D.5570>:
      monoeg_g_free (res);
      items_written = 0;
      items_written.22 = items_written;
      items_read = items_written.22;
      res = monoeg_g_utf16_to_ucs4 (&str2, 0, &items_read, &items_written, &err);
      err.21 = err;
      items_written.22 = items_written;
      items_read.23 = items_read;
      check_result = utf16_to_ucs4_check_result (res, &exp2, items_read.23, 0, items_written.22, 0, err.21, 0);
      if (check_result != 0B) goto <D.5572>; else goto <D.5573>;
      <D.5572>:
      D.5571 = check_result;
      return D.5571;
      <D.5573>:
      monoeg_g_free (res);
      items_written = 0;
      items_written.22 = items_written;
      items_read = items_written.22;
      res = monoeg_g_utf16_to_ucs4 (&str2, 1, &items_read, &items_written, &err);
      err.21 = err;
      items_written.22 = items_written;
      items_read.23 = items_read;
      check_result = utf16_to_ucs4_check_result (res, &exp2, items_read.23, 1, items_written.22, 1, err.21, 0);
      if (check_result != 0B) goto <D.5574>; else goto <D.5575>;
      <D.5574>:
      D.5571 = check_result;
      return D.5571;
      <D.5575>:
      monoeg_g_free (res);
      items_written = 0;
      items_written.22 = items_written;
      items_read = items_written.22;
      res = monoeg_g_utf16_to_ucs4 (&str2, 2, &items_read, &items_written, &err);
      err.21 = err;
      items_written.22 = items_written;
      items_read.23 = items_read;
      check_result = utf16_to_ucs4_check_result (res, &exp2, items_read.23, 1, items_written.22, 1, err.21, 0);
      if (check_result != 0B) goto <D.5576>; else goto <D.5577>;
      <D.5576>:
      D.5571 = check_result;
      return D.5571;
      <D.5577>:
      monoeg_g_free (res);
      items_written = 0;
      items_written.22 = items_written;
      items_read = items_written.22;
      res = monoeg_g_utf16_to_ucs4 (&str2, 3, &items_read, &items_written, &err);
      err.21 = err;
      items_written.22 = items_written;
      items_read.23 = items_read;
      check_result = utf16_to_ucs4_check_result (res, &exp2, items_read.23, 3, items_written.22, 2, err.21, 0);
      if (check_result != 0B) goto <D.5578>; else goto <D.5579>;
      <D.5578>:
      D.5571 = check_result;
      return D.5571;
      <D.5579>:
      monoeg_g_free (res);
      items_written = 0;
      items_written.22 = items_written;
      items_read = items_written.22;
      res = monoeg_g_utf16_to_ucs4 (&str2, 4, &items_read, &items_written, &err);
      err.21 = err;
      items_written.22 = items_written;
      items_read.23 = items_read;
      check_result = utf16_to_ucs4_check_result (res, &exp2, items_read.23, 3, items_written.22, 2, err.21, 0);
      if (check_result != 0B) goto <D.5580>; else goto <D.5581>;
      <D.5580>:
      D.5571 = check_result;
      return D.5571;
      <D.5581>:
      monoeg_g_free (res);
      items_written = 0;
      items_written.22 = items_written;
      items_read = items_written.22;
      res = monoeg_g_utf16_to_ucs4 (&str2, 5, &items_read, &items_written, &err);
      err.21 = err;
      items_written.22 = items_written;
      items_read.23 = items_read;
      check_result = utf16_to_ucs4_check_result (res, &exp2, items_read.23, 4, items_written.22, 0, err.21, 1);
      if (check_result != 0B) goto <D.5582>; else goto <D.5583>;
      <D.5582>:
      D.5571 = check_result;
      return D.5571;
      <D.5583>:
      monoeg_g_free (res);
      items_written = 0;
      items_written.22 = items_written;
      items_read = items_written.22;
      err = 0B;
      res = monoeg_g_utf16_to_ucs4 (&str3, 5, &items_read, &items_written, &err);
      err.21 = err;
      items_written.22 = items_written;
      items_read.23 = items_read;
      check_result = utf16_to_ucs4_check_result (res, &exp3, items_read.23, 1, items_written.22, 0, err.21, 1);
      if (check_result != 0B) goto <D.5584>; else goto <D.5585>;
      <D.5584>:
      D.5571 = check_result;
      return D.5571;
      <D.5585>:
      monoeg_g_free (res);
      current_write_index = 0;
      current_read_index = current_write_index;
      i = 0;
      goto <D.5214>;
      <D.5213>:
      items_written = 0;
      items_written.22 = items_written;
      items_read = items_written.22;
      err = 0B;
      D.5586 = i * 3;
      D.5587 = read_write[D.5586];
      D.5588 = &str4[current_read_index];
      res = monoeg_g_utf16_to_ucs4 (D.5588, D.5587, &items_read, &items_written, &err);
      D.5586 = i * 3;
      D.5589 = D.5586 + 2;
      D.5590 = read_write[D.5589];
      D.5591 = D.5590 == 0;
      D.5592 = (int) D.5591;
      err.21 = err;
      D.5586 = i * 3;
      D.5589 = D.5586 + 2;
      D.5590 = read_write[D.5589];
      items_written.22 = items_written;
      D.5586 = i * 3;
      D.5593 = D.5586 + 1;
      D.5594 = read_write[D.5593];
      items_read.23 = items_read;
      D.5595 = &exp4[current_write_index];
      check_result = utf16_to_ucs4_check_result (res, D.5595, items_read.23, D.5594, items_written.22, D.5590, err.21, D.5592);
      if (check_result != 0B) goto <D.5596>; else goto <D.5597>;
      <D.5596>:
      D.5571 = check_result;
      return D.5571;
      <D.5597>:
      monoeg_g_free (res);
      D.5586 = i * 3;
      D.5587 = read_write[D.5586];
      current_read_index = D.5587 + current_read_index;
      items_written.22 = items_written;
      current_write_index = current_write_index + items_written.22;
      i = i + 1;
      <D.5214>:
      if (i <= 10) goto <D.5213>; else goto <D.5215>;
      <D.5215>:
      items_written = 0;
      items_written.22 = items_written;
      items_read = items_written.22;
      err = 0B;
      res = monoeg_g_utf16_to_ucs4 (&str5, 2, &items_read, &items_written, &err);
      err.21 = err;
      items_written.22 = items_written;
      items_read.23 = items_read;
      check_result = utf16_to_ucs4_check_result (res, &exp5, items_read.23, 2, items_written.22, 1, err.21, 0);
      if (check_result != 0B) goto <D.5598>; else goto <D.5599>;
      <D.5598>:
      D.5571 = check_result;
      return D.5571;
      <D.5599>:
      monoeg_g_free (res);
      D.5571 = 0B;
      return D.5571;
    }
  finally
    {
      items_read = {CLOBBER};
      items_written = {CLOBBER};
      err = {CLOBBER};
    }
}


utf16_to_ucs4_check_result (const gunichar * result_str, const gunichar * expected_str, glong result_items_read, glong expected_items_read, glong result_items_written, glong expected_items_written, struct GError * result_error, gboolean expect_error)
{
  gchar * D.5604;
  _Bool D.5607;
  _Bool D.5608;
  _Bool D.5609;
  _Bool D.5612;
  _Bool D.5613;
  _Bool D.5614;
  _Bool D.5617;
  _Bool D.5618;
  _Bool D.5621;
  _Bool D.5622;
  long unsigned int i.24;
  long unsigned int D.5626;
  const gunichar * D.5627;
  unsigned int D.5628;
  const gunichar * D.5629;
  unsigned int D.5630;
  long unsigned int expected_items_written.25;
  long unsigned int D.5636;
  const gunichar * D.5637;
  unsigned int D.5638;
  glong i;

  if (result_items_read != expected_items_read) goto <D.5602>; else goto <D.5603>;
  <D.5602>:
  D.5604 = FAILED ("Incorrect number of items read; expected %d, got %d", expected_items_read, result_items_read);
  return D.5604;
  <D.5603>:
  if (result_items_written != expected_items_written) goto <D.5605>; else goto <D.5606>;
  <D.5605>:
  D.5604 = FAILED ("Incorrect number of items written; expected %d, got %d", expected_items_written, result_items_written);
  return D.5604;
  <D.5606>:
  D.5607 = result_error != 0B;
  D.5608 = expect_error == 0;
  D.5609 = D.5607 & D.5608;
  if (D.5609 != 0) goto <D.5610>; else goto <D.5611>;
  <D.5610>:
  D.5604 = FAILED ("There should not be an error code.");
  return D.5604;
  <D.5611>:
  D.5612 = result_error == 0B;
  D.5613 = expect_error != 0;
  D.5614 = D.5612 & D.5613;
  if (D.5614 != 0) goto <D.5615>; else goto <D.5616>;
  <D.5615>:
  D.5604 = FAILED ("Unexpected error object.");
  return D.5604;
  <D.5616>:
  D.5613 = expect_error != 0;
  D.5617 = result_str != 0B;
  D.5618 = D.5613 & D.5617;
  if (D.5618 != 0) goto <D.5619>; else goto <D.5620>;
  <D.5619>:
  D.5604 = FAILED ("NULL should be returned when an error occurs.");
  return D.5604;
  <D.5620>:
  D.5608 = expect_error == 0;
  D.5621 = result_str == 0B;
  D.5622 = D.5608 & D.5621;
  if (D.5622 != 0) goto <D.5623>; else goto <D.5624>;
  <D.5623>:
  D.5604 = FAILED ("When no error occurs NULL should not be returned.");
  return D.5604;
  <D.5624>:
  i = 0;
  goto <D.5190>;
  <D.5189>:
  i.24 = (long unsigned int) i;
  D.5626 = i.24 * 4;
  D.5627 = result_str + D.5626;
  D.5628 = *D.5627;
  i.24 = (long unsigned int) i;
  D.5626 = i.24 * 4;
  D.5629 = expected_str + D.5626;
  D.5630 = *D.5629;
  if (D.5628 != D.5630) goto <D.5631>; else goto <D.5632>;
  <D.5631>:
  i.24 = (long unsigned int) i;
  D.5626 = i.24 * 4;
  D.5627 = result_str + D.5626;
  D.5628 = *D.5627;
  D.5604 = FAILED ("Incorrect value %d at index %d", D.5628, i);
  return D.5604;
  <D.5632>:
  i = i + 1;
  <D.5190>:
  if (i < expected_items_written) goto <D.5189>; else goto <D.5191>;
  <D.5191>:
  if (result_str != 0B) goto <D.5633>; else goto <D.5634>;
  <D.5633>:
  expected_items_written.25 = (long unsigned int) expected_items_written;
  D.5636 = expected_items_written.25 * 4;
  D.5637 = result_str + D.5636;
  D.5638 = *D.5637;
  if (D.5638 != 0) goto <D.5639>; else goto <D.5640>;
  <D.5639>:
  D.5604 = FAILED ("Null termination not found at the end of the string.");
  return D.5604;
  <D.5640>:
  <D.5634>:
  D.5604 = 0B;
  return D.5604;
}


test_utf8_strlen ()
{
  gchar * D.5644;
  gchar word1[12];
  gchar word2[12];
  gchar word3[6];
  gchar word4[9];
  glong len;

  try
    {
      word1[0] = -62;
      word1[1] = -126;
      word1[2] = 69;
      word1[3] = -31;
      word1[4] = -127;
      word1[5] = -125;
      word1[6] = 88;
      word1[7] = -15;
      word1[8] = -126;
      word1[9] = -126;
      word1[10] = -126;
      word1[11] = 0;
      word2[0] = -15;
      word2[1] = -126;
      word2[2] = -126;
      word2[3] = -126;
      word2[4] = -62;
      word2[5] = -126;
      word2[6] = 69;
      word2[7] = -31;
      word2[8] = -127;
      word2[9] = -125;
      word2[10] = 88;
      word2[11] = 0;
      word3[0] = 104;
      word3[1] = 101;
      word3[2] = -62;
      word3[3] = -126;
      word3[4] = 69;
      word3[5] = 0;
      word4[0] = 98;
      word4[1] = -62;
      word4[2] = -126;
      word4[3] = 69;
      word4[4] = -31;
      word4[5] = -127;
      word4[6] = -125;
      word4[7] = 88;
      word4[8] = 0;
      len = 0;
      len = monoeg_g_utf8_strlen (&word1, -1);
      if (len != 5) goto <D.5642>; else goto <D.5643>;
      <D.5642>:
      D.5644 = FAILED ("Word1 expected length of 5, but was %i", len);
      return D.5644;
      <D.5643>:
      len = monoeg_g_utf8_strlen (&word1, 1);
      if (len != 0) goto <D.5645>; else goto <D.5646>;
      <D.5645>:
      D.5644 = FAILED ("Word1, max = 1, expected length of 0, but was %i", len);
      return D.5644;
      <D.5646>:
      len = monoeg_g_utf8_strlen (&word1, 2);
      if (len != 1) goto <D.5647>; else goto <D.5648>;
      <D.5647>:
      D.5644 = FAILED ("Word1, max = 1, expected length of 1, but was %i", len);
      return D.5644;
      <D.5648>:
      len = monoeg_g_utf8_strlen (&word1, 3);
      if (len != 2) goto <D.5649>; else goto <D.5650>;
      <D.5649>:
      D.5644 = FAILED ("Word1, max = 2, expected length of 2, but was %i", len);
      return D.5644;
      <D.5650>:
      len = monoeg_g_utf8_strlen (&word2, -1);
      if (len != 5) goto <D.5651>; else goto <D.5652>;
      <D.5651>:
      D.5644 = FAILED ("Word2 expected length of 5, but was %i", len);
      return D.5644;
      <D.5652>:
      len = monoeg_g_utf8_strlen (&word3, -1);
      if (len != 4) goto <D.5653>; else goto <D.5654>;
      <D.5653>:
      D.5644 = FAILED ("Word3 expected length of 4, but was %i", len);
      return D.5644;
      <D.5654>:
      len = monoeg_g_utf8_strlen (&word4, -1);
      if (len != 5) goto <D.5655>; else goto <D.5656>;
      <D.5655>:
      D.5644 = FAILED ("Word4 expected length of 5, but was %i", len);
      return D.5644;
      <D.5656>:
      len = monoeg_g_utf8_strlen (0B, 0);
      if (len != 0) goto <D.5657>; else goto <D.5658>;
      <D.5657>:
      D.5644 = FAILED ("Expected passing null to result in a length of 0");
      return D.5644;
      <D.5658>:
      D.5644 = 0B;
      return D.5644;
    }
  finally
    {
      word1 = {CLOBBER};
      word2 = {CLOBBER};
      word3 = {CLOBBER};
      word4 = {CLOBBER};
    }
}


test_utf8_get_char ()
{
  gchar * D.5663;
  gchar word1[12];
  gunichar value;

  try
    {
      word1[0] = -62;
      word1[1] = -126;
      word1[2] = 69;
      word1[3] = -31;
      word1[4] = -127;
      word1[5] = -125;
      word1[6] = 88;
      word1[7] = -15;
      word1[8] = -126;
      word1[9] = -126;
      word1[10] = -126;
      word1[11] = 0;
      value = monoeg_g_utf8_get_char (&word1[0]);
      if (value != 130) goto <D.5661>; else goto <D.5662>;
      <D.5661>:
      D.5663 = FAILED ("Expected value of 0x82, but was %x", value);
      return D.5663;
      <D.5662>:
      value = monoeg_g_utf8_get_char (&word1[2]);
      if (value != 69) goto <D.5664>; else goto <D.5665>;
      <D.5664>:
      D.5663 = FAILED ("Expected value of 0x45, but was %x", value);
      return D.5663;
      <D.5665>:
      value = monoeg_g_utf8_get_char (&word1[3]);
      if (value != 4163) goto <D.5666>; else goto <D.5667>;
      <D.5666>:
      D.5663 = FAILED ("Expected value of 0x1043, but was %x", value);
      return D.5663;
      <D.5667>:
      value = monoeg_g_utf8_get_char (&word1[6]);
      if (value != 88) goto <D.5668>; else goto <D.5669>;
      <D.5668>:
      D.5663 = FAILED ("Expected value of 0x58, but was %x", value);
      return D.5663;
      <D.5669>:
      value = monoeg_g_utf8_get_char (&word1[7]);
      if (value != 270466) goto <D.5670>; else goto <D.5671>;
      <D.5670>:
      D.5663 = FAILED ("Expected value of 0x42082, but was %x", value);
      return D.5663;
      <D.5671>:
      D.5663 = 0B;
      return D.5663;
    }
  finally
    {
      word1 = {CLOBBER};
    }
}


test_utf8_next_char ()
{
  gchar * D.5676;
  char D.5677;
  char D.5678;
  unsigned char D.5681;
  int D.5682;
  unsigned char D.5683;
  sizetype D.5684;
  char D.5687;
  gchar word1[12];
  gchar word2[12];
  gchar word1ExpectedValues[5];
  gchar word2ExpectedValues[5];
  gchar * ptr;
  gint count;

  try
    {
      word1[0] = -62;
      word1[1] = -126;
      word1[2] = 69;
      word1[3] = -31;
      word1[4] = -127;
      word1[5] = -125;
      word1[6] = 88;
      word1[7] = -15;
      word1[8] = -126;
      word1[9] = -126;
      word1[10] = -126;
      word1[11] = 0;
      word2[0] = -15;
      word2[1] = -126;
      word2[2] = -126;
      word2[3] = -126;
      word2[4] = -62;
      word2[5] = -126;
      word2[6] = 69;
      word2[7] = -31;
      word2[8] = -127;
      word2[9] = -125;
      word2[10] = 88;
      word2[11] = 0;
      word1ExpectedValues[0] = -62;
      word1ExpectedValues[1] = 69;
      word1ExpectedValues[2] = -31;
      word1ExpectedValues[3] = 88;
      word1ExpectedValues[4] = -15;
      word2ExpectedValues[0] = -15;
      word2ExpectedValues[1] = -62;
      word2ExpectedValues[2] = 69;
      word2ExpectedValues[3] = -31;
      word2ExpectedValues[4] = 88;
      ptr = &word1;
      count = 0;
      goto <D.5236>;
      <D.5235>:
      if (count > 4) goto <D.5674>; else goto <D.5675>;
      <D.5674>:
      D.5676 = FAILED ("Word1 has gone past its expected length");
      return D.5676;
      <D.5675>:
      D.5677 = *ptr;
      D.5678 = word1ExpectedValues[count];
      if (D.5677 != D.5678) goto <D.5679>; else goto <D.5680>;
      <D.5679>:
      D.5676 = FAILED ("Word1 has an incorrect next_char at index %i", count);
      return D.5676;
      <D.5680>:
      D.5677 = *ptr;
      D.5681 = (unsigned char) D.5677;
      D.5682 = (int) D.5681;
      D.5683 = g_utf8_jump_table[D.5682];
      D.5684 = (sizetype) D.5683;
      ptr = ptr + D.5684;
      count = count + 1;
      <D.5236>:
      D.5677 = *ptr;
      if (D.5677 != 0) goto <D.5235>; else goto <D.5237>;
      <D.5237>:
      count = 0;
      ptr = &word2;
      goto <D.5239>;
      <D.5238>:
      if (count > 4) goto <D.5685>; else goto <D.5686>;
      <D.5685>:
      D.5676 = FAILED ("Word2 has gone past its expected length");
      return D.5676;
      <D.5686>:
      D.5677 = *ptr;
      D.5687 = word2ExpectedValues[count];
      if (D.5677 != D.5687) goto <D.5688>; else goto <D.5689>;
      <D.5688>:
      D.5676 = FAILED ("Word2 has an incorrect next_char at index %i", count);
      return D.5676;
      <D.5689>:
      D.5677 = *ptr;
      D.5681 = (unsigned char) D.5677;
      D.5682 = (int) D.5681;
      D.5683 = g_utf8_jump_table[D.5682];
      D.5684 = (sizetype) D.5683;
      ptr = ptr + D.5684;
      count = count + 1;
      <D.5239>:
      D.5677 = *ptr;
      if (D.5677 != 0) goto <D.5238>; else goto <D.5240>;
      <D.5240>:
      D.5676 = 0B;
      return D.5676;
    }
  finally
    {
      word1 = {CLOBBER};
      word2 = {CLOBBER};
      word1ExpectedValues = {CLOBBER};
      word2ExpectedValues = {CLOBBER};
    }
}


test_utf8_validate ()
{
  gchar * D.5694;
  const gchar * end.26;
  gchar invalidWord1[5];
  gchar invalidWord2[4];
  gchar invalidWord3[7];
  gchar validWord1[5];
  gchar validWord2[12];
  const gchar * end;
  gboolean retVal;

  try
    {
      invalidWord1[0] = -61;
      invalidWord1[1] = -126;
      invalidWord1[2] = -63;
      invalidWord1[3] = -112;
      invalidWord1[4] = 0;
      invalidWord2[0] = -63;
      invalidWord2[1] = -119;
      invalidWord2[2] = 96;
      invalidWord2[3] = 0;
      invalidWord3[0] = -62;
      invalidWord3[1] = 69;
      invalidWord3[2] = -31;
      invalidWord3[3] = -127;
      invalidWord3[4] = -125;
      invalidWord3[5] = 88;
      invalidWord3[6] = 0;
      validWord1[0] = -62;
      validWord1[1] = -126;
      validWord1[2] = -61;
      validWord1[3] = -96;
      validWord1[4] = 0;
      validWord2[0] = -62;
      validWord2[1] = -126;
      validWord2[2] = 69;
      validWord2[3] = -31;
      validWord2[4] = -127;
      validWord2[5] = -125;
      validWord2[6] = 88;
      validWord2[7] = -15;
      validWord2[8] = -126;
      validWord2[9] = -126;
      validWord2[10] = -126;
      validWord2[11] = 0;
      retVal = monoeg_g_utf8_validate (&invalidWord1, -1, &end);
      if (retVal != 0) goto <D.5692>; else goto <D.5693>;
      <D.5692>:
      D.5694 = FAILED ("Expected invalidWord1 to be invalid");
      return D.5694;
      <D.5693>:
      end.26 = end;
      if (&invalidWord1[2] != end.26) goto <D.5696>; else goto <D.5697>;
      <D.5696>:
      D.5694 = FAILED ("Expected end parameter to be pointing to invalidWord1[2]");
      return D.5694;
      <D.5697>:
      end = 0B;
      retVal = monoeg_g_utf8_validate (&invalidWord2, -1, &end);
      if (retVal != 0) goto <D.5698>; else goto <D.5699>;
      <D.5698>:
      D.5694 = FAILED ("Expected invalidWord2 to be invalid");
      return D.5694;
      <D.5699>:
      end.26 = end;
      if (&invalidWord2[0] != end.26) goto <D.5700>; else goto <D.5701>;
      <D.5700>:
      D.5694 = FAILED ("Expected end parameter to be pointing to invalidWord2[0]");
      return D.5694;
      <D.5701>:
      end = 0B;
      retVal = monoeg_g_utf8_validate (&invalidWord3, -1, &end);
      if (retVal != 0) goto <D.5702>; else goto <D.5703>;
      <D.5702>:
      D.5694 = FAILED ("Expected invalidWord3 to be invalid");
      return D.5694;
      <D.5703>:
      end.26 = end;
      if (&invalidWord3[0] != end.26) goto <D.5704>; else goto <D.5705>;
      <D.5704>:
      D.5694 = FAILED ("Expected end parameter to be pointing to invalidWord3[1]");
      return D.5694;
      <D.5705>:
      end = 0B;
      retVal = monoeg_g_utf8_validate (&validWord1, -1, &end);
      if (retVal != 1) goto <D.5706>; else goto <D.5707>;
      <D.5706>:
      D.5694 = FAILED ("Expected validWord1 to be valid");
      return D.5694;
      <D.5707>:
      end.26 = end;
      if (&validWord1[4] != end.26) goto <D.5708>; else goto <D.5709>;
      <D.5708>:
      D.5694 = FAILED ("Expected end parameter to be pointing to validWord1[4]");
      return D.5694;
      <D.5709>:
      end = 0B;
      retVal = monoeg_g_utf8_validate (&validWord2, -1, &end);
      if (retVal != 1) goto <D.5710>; else goto <D.5711>;
      <D.5710>:
      D.5694 = FAILED ("Expected validWord2 to be valid");
      return D.5694;
      <D.5711>:
      end.26 = end;
      if (&validWord2[11] != end.26) goto <D.5712>; else goto <D.5713>;
      <D.5712>:
      D.5694 = FAILED ("Expected end parameter to be pointing to validWord2[11]");
      return D.5694;
      <D.5713>:
      D.5694 = 0B;
      return D.5694;
    }
  finally
    {
      invalidWord1 = {CLOBBER};
      invalidWord2 = {CLOBBER};
      invalidWord3 = {CLOBBER};
      validWord1 = {CLOBBER};
      validWord2 = {CLOBBER};
      end = {CLOBBER};
    }
}


utf8_byteslen (const gchar * src)
{
  sizetype D.5716;
  const gchar * D.5717;
  char D.5718;
  glong D.5721;
  int i;

  i = 0;
  <D.5254>:
  D.5716 = (sizetype) i;
  D.5717 = src + D.5716;
  D.5718 = *D.5717;
  if (D.5718 == 0) goto <D.5719>; else goto <D.5720>;
  <D.5719>:
  D.5721 = (glong) i;
  return D.5721;
  <D.5720>:
  i = i + 1;
  goto <D.5254>;
}


test_utf8_strcase_each (const gchar * src, const gchar * expected, gboolean strup)
{
  gchar * iftmp.27;
  long int D.5727;
  gchar * D.5728;
  gchar * tmp;
  glong len;
  glong len2;
  gchar * r;

  len = utf8_byteslen (src);
  if (strup != 0) goto <D.5724>; else goto <D.5725>;
  <D.5724>:
  iftmp.27 = monoeg_g_utf8_strup (src, len);
  goto <D.5726>;
  <D.5725>:
  iftmp.27 = monoeg_g_utf8_strdown (src, len);
  <D.5726>:
  tmp = iftmp.27;
  len2 = utf8_byteslen (tmp);
  D.5727 = MAX_EXPR <len, len2>;
  r = compare_strings_utf8_RESULT (expected, tmp, D.5727);
  monoeg_g_free (tmp);
  D.5728 = r;
  return D.5728;
}


test_utf8_strup_each (const gchar * src, const gchar * expected)
{
  gchar * D.5730;

  D.5730 = test_utf8_strcase_each (src, expected, 1);
  return D.5730;
}


test_utf8_strdown_each (const gchar * src, const gchar * expected)
{
  gchar * D.5732;

  D.5732 = test_utf8_strcase_each (src, expected, 0);
  return D.5732;
}


test_utf8_strup ()
{
  gchar * D.5736;
  gchar * r;

  r = test_utf8_strup_each ("aBc", "ABC");
  if (r != 0B) goto <D.5734>; else goto <D.5735>;
  <D.5734>:
  D.5736 = r;
  return D.5736;
  <D.5735>:
  r = test_utf8_strup_each ("x86-64", "X86-64");
  if (r != 0B) goto <D.5737>; else goto <D.5738>;
  <D.5737>:
  D.5736 = r;
  return D.5736;
  <D.5738>:
  r = test_utf8_strup_each ("αΒ", "ΑΒ");
  if (r != 0B) goto <D.5739>; else goto <D.5740>;
  <D.5739>:
  D.5736 = r;
  return D.5736;
  <D.5740>:
  r = test_utf8_strup_each ("Ａ", "Ａ");
  if (r != 0B) goto <D.5741>; else goto <D.5742>;
  <D.5741>:
  D.5736 = r;
  return D.5736;
  <D.5742>:
  r = test_utf8_strup_each ("ａ", "Ａ");
  if (r != 0B) goto <D.5743>; else goto <D.5744>;
  <D.5743>:
  D.5736 = r;
  return D.5736;
  <D.5744>:
  r = test_utf8_strup_each ("𐐨", "𐐀");
  if (r != 0B) goto <D.5745>; else goto <D.5746>;
  <D.5745>:
  D.5736 = r;
  return D.5736;
  <D.5746>:
  D.5736 = 0B;
  return D.5736;
}


test_utf8_strdown ()
{
  gchar * D.5750;
  gchar * r;

  r = test_utf8_strdown_each ("aBc", "abc");
  if (r != 0B) goto <D.5748>; else goto <D.5749>;
  <D.5748>:
  D.5750 = r;
  return D.5750;
  <D.5749>:
  r = test_utf8_strdown_each ("X86-64", "x86-64");
  if (r != 0B) goto <D.5751>; else goto <D.5752>;
  <D.5751>:
  D.5750 = r;
  return D.5750;
  <D.5752>:
  r = test_utf8_strdown_each ("Αβ", "αβ");
  if (r != 0B) goto <D.5753>; else goto <D.5754>;
  <D.5753>:
  D.5750 = r;
  return D.5750;
  <D.5754>:
  D.5750 = 0B;
  return D.5750;
}


utf8_tests_init ()
{
  struct Test * D.5756;

  D.5756 = &utf8_tests;
  return D.5756;
}