mono_error_init_flags (struct MonoError * oerror, short unsigned int flags)
{
  struct MonoErrorInternal * error;

  error = oerror;
  if (0 != 0) goto <D.16374>; else goto <D.16375>;
  <D.16374>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mono-error.c", 47, "sizeof (MonoError) == sizeof (MonoErrorInternal)");
  <D.16375>:
  error->error_code = 0;
  error->flags = flags;
}


mono_error_init (struct MonoError * error)
{
  mono_error_init_flags (error, 0);
}


mono_error_cleanup (struct MonoError * oerror)
{
  short unsigned int D.16376;
  const char * D.16379;
  short unsigned int D.16380;
  int D.16381;
  int D.16382;
  const char * D.16385;
  const char * D.16386;
  const char * D.16387;
  const char * D.16388;
  const char * D.16389;
  struct MonoErrorInternal * error;

  error = oerror;
  D.16376 = error->error_code;
  if (D.16376 == 0) goto <D.16377>; else goto <D.16378>;
  <D.16377>:
  return;
  <D.16378>:
  D.16379 = error->full_message;
  monoeg_g_free (D.16379);
  D.16380 = error->flags;
  D.16381 = (int) D.16380;
  D.16382 = D.16381 & 1;
  if (D.16382 == 0) goto <D.16383>; else goto <D.16384>;
  <D.16383>:
  return;
  <D.16384>:
  D.16385 = error->type_name;
  monoeg_g_free (D.16385);
  D.16386 = error->assembly_name;
  monoeg_g_free (D.16386);
  D.16387 = error->member_name;
  monoeg_g_free (D.16387);
  D.16388 = error->exception_name_space;
  monoeg_g_free (D.16388);
  D.16389 = error->exception_name;
  monoeg_g_free (D.16389);
}


mono_error_ok (struct MonoError * error)
{
  mono_bool D.16391;
  short unsigned int D.16392;
  _Bool D.16393;

  D.16392 = error->error_code;
  D.16393 = D.16392 == 0;
  D.16391 = (mono_bool) D.16393;
  return D.16391;
}


mono_error_get_error_code (struct MonoError * error)
{
  short unsigned int D.16395;

  D.16395 = error->error_code;
  return D.16395;
}


mono_error_get_message (struct MonoError * oerror)
{
  short unsigned int D.16397;
  const char * D.16400;
  const char * iftmp.0;
  const char * D.16402;
  struct MonoErrorInternal * error;

  error = oerror;
  D.16397 = error->error_code;
  if (D.16397 == 0) goto <D.16398>; else goto <D.16399>;
  <D.16398>:
  D.16400 = 0B;
  return D.16400;
  <D.16399>:
  D.16402 = error->full_message;
  if (D.16402 != 0B) goto <D.16403>; else goto <D.16404>;
  <D.16403>:
  iftmp.0 = error->full_message;
  goto <D.16405>;
  <D.16404>:
  iftmp.0 = &error->message;
  <D.16405>:
  D.16400 = iftmp.0;
  return D.16400;
}


mono_error_dup_strings (struct MonoError * oerror, gboolean dup_strings)
{
  short unsigned int D.16407;
  short unsigned int D.16408;
  const char * D.16411;
  gchar * D.16414;
  short unsigned int D.16417;
  const char * D.16418;
  gchar * D.16421;
  const char * D.16424;
  gchar * D.16427;
  const char * D.16430;
  gchar * D.16433;
  const char * D.16436;
  gchar * D.16439;
  struct MonoErrorInternal * error;

  error = oerror;
  D.16407 = error->flags;
  D.16408 = D.16407 | 1;
  error->flags = D.16408;
  if (dup_strings != 0) goto <D.16409>; else goto <D.16410>;
  <D.16409>:
  D.16411 = error->type_name;
  if (D.16411 != 0B) goto <D.16412>; else goto <D.16413>;
  <D.16412>:
  D.16411 = error->type_name;
  D.16414 = monoeg_strdup (D.16411);
  error->type_name = D.16414;
  D.16411 = error->type_name;
  if (D.16411 == 0B) goto <D.16415>; else goto <D.16416>;
  <D.16415>:
  D.16407 = error->flags;
  D.16417 = D.16407 | 2;
  error->flags = D.16417;
  <D.16416>:
  <D.16413>:
  D.16418 = error->assembly_name;
  if (D.16418 != 0B) goto <D.16419>; else goto <D.16420>;
  <D.16419>:
  D.16418 = error->assembly_name;
  D.16421 = monoeg_strdup (D.16418);
  error->assembly_name = D.16421;
  D.16418 = error->assembly_name;
  if (D.16418 == 0B) goto <D.16422>; else goto <D.16423>;
  <D.16422>:
  D.16407 = error->flags;
  D.16417 = D.16407 | 2;
  error->flags = D.16417;
  <D.16423>:
  <D.16420>:
  D.16424 = error->member_name;
  if (D.16424 != 0B) goto <D.16425>; else goto <D.16426>;
  <D.16425>:
  D.16424 = error->member_name;
  D.16427 = monoeg_strdup (D.16424);
  error->member_name = D.16427;
  D.16424 = error->member_name;
  if (D.16424 == 0B) goto <D.16428>; else goto <D.16429>;
  <D.16428>:
  D.16407 = error->flags;
  D.16417 = D.16407 | 2;
  error->flags = D.16417;
  <D.16429>:
  <D.16426>:
  D.16430 = error->exception_name_space;
  if (D.16430 != 0B) goto <D.16431>; else goto <D.16432>;
  <D.16431>:
  D.16430 = error->exception_name_space;
  D.16433 = monoeg_strdup (D.16430);
  error->exception_name_space = D.16433;
  D.16430 = error->exception_name_space;
  if (D.16430 == 0B) goto <D.16434>; else goto <D.16435>;
  <D.16434>:
  D.16407 = error->flags;
  D.16417 = D.16407 | 2;
  error->flags = D.16417;
  <D.16435>:
  <D.16432>:
  D.16436 = error->exception_name;
  if (D.16436 != 0B) goto <D.16437>; else goto <D.16438>;
  <D.16437>:
  D.16436 = error->exception_name;
  D.16439 = monoeg_strdup (D.16436);
  error->exception_name = D.16439;
  D.16436 = error->exception_name;
  if (D.16436 == 0B) goto <D.16440>; else goto <D.16441>;
  <D.16440>:
  D.16407 = error->flags;
  D.16417 = D.16407 | 2;
  error->flags = D.16417;
  <D.16441>:
  <D.16438>:
  <D.16410>:
}


monoeg_strdup (const gchar * str)
{
  gchar * D.16444;

  if (str != 0B) goto <D.16442>; else goto <D.16443>;
  <D.16442>:
  D.16444 = __strdup (str);
  return D.16444;
  <D.16443>:
  D.16444 = 0B;
  return D.16444;
}


mono_error_set_error (struct MonoError * oerror, int error_code, const char * msg_format)
{
  short unsigned int D.16446;
  char[128] * D.16447;
  int D.16448;
  unsigned int D.16449;
  gchar * D.16452;
  const char * D.16453;
  short unsigned int D.16456;
  short unsigned int D.16457;
  struct MonoErrorInternal * error;

  error = oerror;
  mono_error_prepare (error);
  D.16446 = (short unsigned int) error_code;
  error->error_code = D.16446;
  {
    struct  args[1];

    try
      {
        __builtin_va_start (&args, 0);
        D.16447 = &error->message;
        D.16448 = vsnprintf (D.16447, 128, msg_format, &args);
        D.16449 = (unsigned int) D.16448;
        if (D.16449 > 127) goto <D.16450>; else goto <D.16451>;
        <D.16450>:
        __builtin_va_end (&args);
        __builtin_va_start (&args, 0);
        D.16452 = monoeg_g_strdup_vprintf (msg_format, &args);
        error->full_message = D.16452;
        D.16453 = error->full_message;
        if (D.16453 == 0B) goto <D.16454>; else goto <D.16455>;
        <D.16454>:
        D.16456 = error->flags;
        D.16457 = D.16456 | 2;
        error->flags = D.16457;
        <D.16455>:
        <D.16451>:
        __builtin_va_end (&args);
      }
    finally
      {
        args = {CLOBBER};
      }
  }
}


mono_error_prepare (struct MonoErrorInternal * error)
{
  short unsigned int D.16458;
  const char * D.16461;
  const char * D.16462;
  const char * D.16463;
  const char * D.16464;
  const char * D.16465;

  D.16458 = error->error_code;
  if (D.16458 != 0) goto <D.16459>; else goto <D.16460>;
  <D.16459>:
  return;
  <D.16460>:
  error->exception_name = 0B;
  D.16461 = error->exception_name;
  error->exception_name_space = D.16461;
  D.16462 = error->exception_name_space;
  error->full_message = D.16462;
  D.16463 = error->full_message;
  error->member_name = D.16463;
  D.16464 = error->member_name;
  error->assembly_name = D.16464;
  D.16465 = error->assembly_name;
  error->type_name = D.16465;
  error->klass = 0B;
  error->message[0] = 0;
}


vsnprintf (char * restrict __s, size_t __n, const char * restrict __fmt, struct  * __ap)
{
  int D.16467;
  long unsigned int D.16468;

  D.16468 = __builtin_object_size (__s, 1);
  D.16467 = __builtin___vsnprintf_chk (__s, __n, 1, D.16468, __fmt, __ap);
  return D.16467;
}


mono_error_set_assembly_load (struct MonoError * oerror, const char * assembly_name, const char * msg_format)
{
  char[128] * D.16470;
  int D.16471;
  unsigned int D.16472;
  gchar * D.16475;
  const char * D.16476;
  short unsigned int D.16479;
  short unsigned int D.16480;
  struct MonoErrorInternal * error;

  error = oerror;
  mono_error_prepare (error);
  error->error_code = 4;
  mono_error_set_assembly_name (oerror, assembly_name);
  {
    struct  args[1];

    try
      {
        __builtin_va_start (&args, 0);
        D.16470 = &error->message;
        D.16471 = vsnprintf (D.16470, 128, msg_format, &args);
        D.16472 = (unsigned int) D.16471;
        if (D.16472 > 127) goto <D.16473>; else goto <D.16474>;
        <D.16473>:
        __builtin_va_end (&args);
        __builtin_va_start (&args, 0);
        D.16475 = monoeg_g_strdup_vprintf (msg_format, &args);
        error->full_message = D.16475;
        D.16476 = error->full_message;
        if (D.16476 == 0B) goto <D.16477>; else goto <D.16478>;
        <D.16477>:
        D.16479 = error->flags;
        D.16480 = D.16479 | 2;
        error->flags = D.16480;
        <D.16478>:
        <D.16474>:
        __builtin_va_end (&args);
      }
    finally
      {
        args = {CLOBBER};
      }
  }
}


mono_error_set_assembly_name (struct MonoError * oerror, const char * assembly_name)
{
  short unsigned int D.16481;
  _Bool D.16482;
  long int D.16483;
  long int D.16484;
  struct MonoErrorInternal * error;

  error = oerror;
  D.16481 = error->error_code;
  D.16482 = D.16481 == 0;
  D.16483 = (long int) D.16482;
  D.16484 = __builtin_expect (D.16483, 0);
  if (D.16484 != 0) goto <D.16485>; else goto <D.16486>;
  <D.16485>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mono-error.c", 140, "error->error_code != MONO_ERROR_NONE");
  <D.16486>:
  error->assembly_name = assembly_name;
}


mono_error_set_type_load_class (struct MonoError * oerror, struct MonoClass * klass, const char * msg_format)
{
  char[128] * D.16487;
  int D.16488;
  unsigned int D.16489;
  gchar * D.16492;
  const char * D.16493;
  short unsigned int D.16496;
  short unsigned int D.16497;
  struct MonoErrorInternal * error;

  error = oerror;
  mono_error_prepare (error);
  error->error_code = 3;
  mono_error_set_class (oerror, klass);
  {
    struct  args[1];

    try
      {
        __builtin_va_start (&args, 0);
        D.16487 = &error->message;
        D.16488 = vsnprintf (D.16487, 128, msg_format, &args);
        D.16489 = (unsigned int) D.16488;
        if (D.16489 > 127) goto <D.16490>; else goto <D.16491>;
        <D.16490>:
        __builtin_va_end (&args);
        __builtin_va_start (&args, 0);
        D.16492 = monoeg_g_strdup_vprintf (msg_format, &args);
        error->full_message = D.16492;
        D.16493 = error->full_message;
        if (D.16493 == 0B) goto <D.16494>; else goto <D.16495>;
        <D.16494>:
        D.16496 = error->flags;
        D.16497 = D.16496 | 2;
        error->flags = D.16497;
        <D.16495>:
        <D.16491>:
        __builtin_va_end (&args);
      }
    finally
      {
        args = {CLOBBER};
      }
  }
}


mono_error_set_class (struct MonoError * oerror, struct MonoClass * klass)
{
  struct MonoErrorInternal * error;

  error = oerror;
  error->klass = klass;
}


mono_error_set_type_load_name (struct MonoError * oerror, const char * type_name, const char * assembly_name, const char * msg_format)
{
  char[128] * D.16498;
  int D.16499;
  unsigned int D.16500;
  gchar * D.16503;
  const char * D.16504;
  short unsigned int D.16507;
  short unsigned int D.16508;
  struct MonoErrorInternal * error;

  error = oerror;
  mono_error_prepare (error);
  error->error_code = 3;
  mono_error_set_type_name (oerror, type_name);
  mono_error_set_assembly_name (oerror, assembly_name);
  {
    struct  args[1];

    try
      {
        __builtin_va_start (&args, 0);
        D.16498 = &error->message;
        D.16499 = vsnprintf (D.16498, 128, msg_format, &args);
        D.16500 = (unsigned int) D.16499;
        if (D.16500 > 127) goto <D.16501>; else goto <D.16502>;
        <D.16501>:
        __builtin_va_end (&args);
        __builtin_va_start (&args, 0);
        D.16503 = monoeg_g_strdup_vprintf (msg_format, &args);
        error->full_message = D.16503;
        D.16504 = error->full_message;
        if (D.16504 == 0B) goto <D.16505>; else goto <D.16506>;
        <D.16505>:
        D.16507 = error->flags;
        D.16508 = D.16507 | 2;
        error->flags = D.16508;
        <D.16506>:
        <D.16502>:
        __builtin_va_end (&args);
      }
    finally
      {
        args = {CLOBBER};
      }
  }
}


mono_error_set_type_name (struct MonoError * oerror, const char * type_name)
{
  struct MonoErrorInternal * error;

  error = oerror;
  error->type_name = type_name;
}


mono_error_set_method_load (struct MonoError * oerror, struct MonoClass * klass, const char * method_name, const char * msg_format)
{
  char[128] * D.16509;
  int D.16510;
  unsigned int D.16511;
  gchar * D.16514;
  const char * D.16515;
  short unsigned int D.16518;
  short unsigned int D.16519;
  struct MonoErrorInternal * error;

  error = oerror;
  mono_error_prepare (error);
  error->error_code = 1;
  mono_error_set_class (oerror, klass);
  mono_error_set_member_name (oerror, method_name);
  {
    struct  args[1];

    try
      {
        __builtin_va_start (&args, 0);
        D.16509 = &error->message;
        D.16510 = vsnprintf (D.16509, 128, msg_format, &args);
        D.16511 = (unsigned int) D.16510;
        if (D.16511 > 127) goto <D.16512>; else goto <D.16513>;
        <D.16512>:
        __builtin_va_end (&args);
        __builtin_va_start (&args, 0);
        D.16514 = monoeg_g_strdup_vprintf (msg_format, &args);
        error->full_message = D.16514;
        D.16515 = error->full_message;
        if (D.16515 == 0B) goto <D.16516>; else goto <D.16517>;
        <D.16516>:
        D.16518 = error->flags;
        D.16519 = D.16518 | 2;
        error->flags = D.16519;
        <D.16517>:
        <D.16513>:
        __builtin_va_end (&args);
      }
    finally
      {
        args = {CLOBBER};
      }
  }
}


mono_error_set_member_name (struct MonoError * oerror, const char * member_name)
{
  struct MonoErrorInternal * error;

  error = oerror;
  error->member_name = member_name;
}


mono_error_set_field_load (struct MonoError * oerror, struct MonoClass * klass, const char * field_name, const char * msg_format)
{
  char[128] * D.16520;
  int D.16521;
  unsigned int D.16522;
  gchar * D.16525;
  const char * D.16526;
  short unsigned int D.16529;
  short unsigned int D.16530;
  struct MonoErrorInternal * error;

  error = oerror;
  mono_error_prepare (error);
  error->error_code = 2;
  mono_error_set_class (oerror, klass);
  mono_error_set_member_name (oerror, field_name);
  {
    struct  args[1];

    try
      {
        __builtin_va_start (&args, 0);
        D.16520 = &error->message;
        D.16521 = vsnprintf (D.16520, 128, msg_format, &args);
        D.16522 = (unsigned int) D.16521;
        if (D.16522 > 127) goto <D.16523>; else goto <D.16524>;
        <D.16523>:
        __builtin_va_end (&args);
        __builtin_va_start (&args, 0);
        D.16525 = monoeg_g_strdup_vprintf (msg_format, &args);
        error->full_message = D.16525;
        D.16526 = error->full_message;
        if (D.16526 == 0B) goto <D.16527>; else goto <D.16528>;
        <D.16527>:
        D.16529 = error->flags;
        D.16530 = D.16529 | 2;
        error->flags = D.16530;
        <D.16528>:
        <D.16524>:
        __builtin_va_end (&args);
      }
    finally
      {
        args = {CLOBBER};
      }
  }
}


mono_error_set_bad_image_name (struct MonoError * oerror, const char * assembly_name, const char * msg_format)
{
  char[128] * D.16531;
  int D.16532;
  unsigned int D.16533;
  gchar * D.16536;
  const char * D.16537;
  short unsigned int D.16540;
  short unsigned int D.16541;
  struct MonoErrorInternal * error;

  error = oerror;
  mono_error_prepare (error);
  error->error_code = 5;
  mono_error_set_assembly_name (oerror, assembly_name);
  {
    struct  args[1];

    try
      {
        __builtin_va_start (&args, 0);
        D.16531 = &error->message;
        D.16532 = vsnprintf (D.16531, 128, msg_format, &args);
        D.16533 = (unsigned int) D.16532;
        if (D.16533 > 127) goto <D.16534>; else goto <D.16535>;
        <D.16534>:
        __builtin_va_end (&args);
        __builtin_va_start (&args, 0);
        D.16536 = monoeg_g_strdup_vprintf (msg_format, &args);
        error->full_message = D.16536;
        D.16537 = error->full_message;
        if (D.16537 == 0B) goto <D.16538>; else goto <D.16539>;
        <D.16538>:
        D.16540 = error->flags;
        D.16541 = D.16540 | 2;
        error->flags = D.16541;
        <D.16539>:
        <D.16535>:
        __builtin_va_end (&args);
      }
    finally
      {
        args = {CLOBBER};
      }
  }
}


mono_error_set_bad_image (struct MonoError * oerror, struct MonoImage * image, const char * msg_format)
{
  const char * iftmp.1;
  char[128] * D.16546;
  int D.16547;
  unsigned int D.16548;
  gchar * D.16551;
  const char * D.16552;
  short unsigned int D.16555;
  short unsigned int D.16556;
  struct MonoErrorInternal * error;

  error = oerror;
  mono_error_prepare (error);
  error->error_code = 5;
  if (image != 0B) goto <D.16543>; else goto <D.16544>;
  <D.16543>:
  iftmp.1 = mono_image_get_name (image);
  goto <D.16545>;
  <D.16544>:
  iftmp.1 = "<no_image>";
  <D.16545>:
  error->assembly_name = iftmp.1;
  {
    struct  args[1];

    try
      {
        __builtin_va_start (&args, 0);
        D.16546 = &error->message;
        D.16547 = vsnprintf (D.16546, 128, msg_format, &args);
        D.16548 = (unsigned int) D.16547;
        if (D.16548 > 127) goto <D.16549>; else goto <D.16550>;
        <D.16549>:
        __builtin_va_end (&args);
        __builtin_va_start (&args, 0);
        D.16551 = monoeg_g_strdup_vprintf (msg_format, &args);
        error->full_message = D.16551;
        D.16552 = error->full_message;
        if (D.16552 == 0B) goto <D.16553>; else goto <D.16554>;
        <D.16553>:
        D.16555 = error->flags;
        D.16556 = D.16555 | 2;
        error->flags = D.16556;
        <D.16554>:
        <D.16550>:
        __builtin_va_end (&args);
      }
    finally
      {
        args = {CLOBBER};
      }
  }
}


mono_error_set_generic_error (struct MonoError * oerror, const char * name_space, const char * name, const char * msg_format)
{
  char[128] * D.16557;
  int D.16558;
  unsigned int D.16559;
  gchar * D.16562;
  const char * D.16563;
  short unsigned int D.16566;
  short unsigned int D.16567;
  struct MonoErrorInternal * error;

  error = oerror;
  mono_error_prepare (error);
  error->error_code = 9;
  mono_error_set_corlib_exception (oerror, name_space, name);
  {
    struct  args[1];

    try
      {
        __builtin_va_start (&args, 0);
        D.16557 = &error->message;
        D.16558 = vsnprintf (D.16557, 128, msg_format, &args);
        D.16559 = (unsigned int) D.16558;
        if (D.16559 > 127) goto <D.16560>; else goto <D.16561>;
        <D.16560>:
        __builtin_va_end (&args);
        __builtin_va_start (&args, 0);
        D.16562 = monoeg_g_strdup_vprintf (msg_format, &args);
        error->full_message = D.16562;
        D.16563 = error->full_message;
        if (D.16563 == 0B) goto <D.16564>; else goto <D.16565>;
        <D.16564>:
        D.16566 = error->flags;
        D.16567 = D.16566 | 2;
        error->flags = D.16567;
        <D.16565>:
        <D.16561>:
        __builtin_va_end (&args);
      }
    finally
      {
        args = {CLOBBER};
      }
  }
}


mono_error_set_corlib_exception (struct MonoError * oerror, const char * name_space, const char * name)
{
  struct MonoErrorInternal * error;

  error = oerror;
  error->exception_name_space = name_space;
  error->exception_name = name;
}


mono_error_set_from_loader_error (struct MonoError * oerror)
{
  unsigned char D.16570;
  int D.16571;
  char * D.16572;
  const char * D.16573;
  char[128] * D.16574;
  struct MonoClass * D.16575;
  char * D.16576;
  int D.16577;
  char * D.16581;
  struct MonoLoaderError * loader_error;
  struct MonoErrorInternal * error;

  loader_error = mono_loader_get_last_error ();
  error = oerror;
  mono_error_prepare (error);
  if (loader_error == 0B) goto <D.16568>; else goto <D.16569>;
  <D.16568>:
  mono_error_set_generic_error (oerror, "System", "ExecutionEngineException", "Runtime tried to produce a mono-error from an empty loader-error");
  return;
  <D.16569>:
  D.16570 = loader_error->exception_type;
  D.16571 = (int) D.16570;
  switch (D.16571) <default: <D.16290>, case 0: <D.16274>, case 1: <D.16276>, case 2: <D.16277>, case 3: <D.16278>, case 4: <D.16279>, case 5: <D.16280>, case 6: <D.16281>, case 7: <D.16282>, case 8: <D.16283>, case 9: <D.16284>, case 10: <D.16285>, case 11: <D.16287>, case 12: <D.16288>, case 13: <D.16286>, case 14: <D.16289>>
  <D.16274>:
  mono_error_set_generic_error (oerror, "System", "ExecutionEngineException", "Runtime tried to produce a mono-error from a non-error loader-error");
  goto <D.16275>;
  <D.16276>:
  <D.16277>:
  mono_error_set_generic_error (oerror, "System.Security", "SecurityException", "Failed for unknown reasons.");
  goto <D.16275>;
  <D.16278>:
  mono_error_set_generic_error (oerror, "System", "InvalidProgramException", "Failed for unknown reasons.");
  goto <D.16275>;
  <D.16279>:
  mono_error_set_generic_error (oerror, "System.Security", "VerificationException", "Failed for unknown reasons.");
  goto <D.16275>;
  <D.16280>:
  error->error_code = 1;
  D.16572 = loader_error->class_name;
  mono_error_set_type_name (oerror, D.16572);
  D.16573 = loader_error->member_name;
  mono_error_set_member_name (oerror, D.16573);
  D.16574 = &error->message;
  monoeg_g_snprintf (D.16574, 128, "Failed for unknown reasons.");
  goto <D.16275>;
  <D.16281>:
  D.16573 = loader_error->member_name;
  D.16575 = loader_error->klass;
  mono_error_set_field_load (oerror, D.16575, D.16573, "Failed for unknown reasons.");
  goto <D.16275>;
  <D.16282>:
  D.16576 = loader_error->assembly_name;
  D.16572 = loader_error->class_name;
  mono_error_set_type_load_name (oerror, D.16572, D.16576, "Failed for unknown reasons.");
  goto <D.16275>;
  <D.16283>:
  D.16577 = loader_error->ref_only;
  if (D.16577 != 0) goto <D.16578>; else goto <D.16579>;
  <D.16578>:
  D.16576 = loader_error->assembly_name;
  mono_error_set_assembly_load (oerror, D.16576, "Cannot resolve dependency to assembly because it has not been preloaded. When using the ReflectionOnly APIs, dependent assemblies must be pre-loaded or loaded on demand through the ReflectionOnlyAssemblyResolve event.");
  goto <D.16580>;
  <D.16579>:
  D.16576 = loader_error->assembly_name;
  mono_error_set_assembly_load (oerror, D.16576, "Could not load file or assembly or one of its dependencies.");
  <D.16580>:
  goto <D.16275>;
  <D.16284>:
  mono_error_set_generic_error (oerror, "System", "MethodAccessException", "Failed for unknown reasons.");
  goto <D.16275>;
  <D.16285>:
  mono_error_set_generic_error (oerror, "System", "FieldAccessException", "Failed for unknown reasons.");
  goto <D.16275>;
  <D.16286>:
  <D.16287>:
  D.16570 = loader_error->exception_type;
  D.16571 = (int) D.16570;
  mono_error_set_generic_error (oerror, "System", "ExecutionEngineException", "Runtime tried to produce a mono-error from JIT internal error %d", D.16571);
  goto <D.16275>;
  <D.16288>:
  D.16581 = loader_error->msg;
  mono_error_set_bad_image_name (oerror, "<unknown>", "%s", D.16581);
  goto <D.16275>;
  <D.16289>:
  mono_error_set_out_of_memory (oerror, "Failed for unknown reasons.");
  goto <D.16275>;
  <D.16290>:
  D.16570 = loader_error->exception_type;
  D.16571 = (int) D.16570;
  mono_error_set_generic_error (oerror, "System", "ExecutionEngineException", "Runtime tried to produce an unknown loader-error %d", D.16571);
  goto <D.16275>;
  <D.16275>:
  mono_error_dup_strings (oerror, 1);
  mono_loader_clear_error ();
}


mono_loader_set_error_from_mono_error (struct MonoError * oerror)
{
  short unsigned int D.16583;
  int D.16584;
  const char * D.16585;
  const char * D.16586;
  struct MonoClass * D.16587;
  const char * D.16588;
  const char * D.16589;
  const char * D.16590;
  const gchar * iftmp.2;
  const char * D.16592;
  gchar * D.16596;
  const char * iftmp.3;
  gchar * D.16601;
  struct MonoErrorInternal * error;

  error = oerror;
  D.16583 = error->error_code;
  D.16584 = (int) D.16583;
  switch (D.16584) <default: <D.16307>, case 1: <D.16301>, case 2: <D.16303>, case 3: <D.16304>, case 4: <D.16305>, case 5: <D.16306>>
  <D.16301>:
  D.16585 = error->member_name;
  D.16586 = get_type_name (error);
  mono_loader_set_error_method_load (D.16586, D.16585);
  goto <D.16302>;
  <D.16303>:
  D.16585 = error->member_name;
  D.16587 = error->klass;
  mono_loader_set_error_field_load (D.16587, D.16585);
  goto <D.16302>;
  <D.16304>:
  D.16588 = get_assembly_name (error);
  D.16589 = get_type_name (error);
  mono_loader_set_error_type_load (D.16589, D.16588);
  goto <D.16302>;
  <D.16305>:
  D.16590 = get_assembly_name (error);
  mono_loader_set_error_assembly_load (D.16590, 0);
  goto <D.16302>;
  <D.16306>:
  D.16592 = error->full_message;
  if (D.16592 != 0B) goto <D.16593>; else goto <D.16594>;
  <D.16593>:
  iftmp.2 = error->full_message;
  goto <D.16595>;
  <D.16594>:
  iftmp.2 = &error->message;
  <D.16595>:
  D.16596 = monoeg_strdup (iftmp.2);
  mono_loader_set_error_bad_image (D.16596);
  goto <D.16302>;
  <D.16307>:
  D.16592 = error->full_message;
  if (D.16592 != 0B) goto <D.16598>; else goto <D.16599>;
  <D.16598>:
  iftmp.3 = error->full_message;
  goto <D.16600>;
  <D.16599>:
  iftmp.3 = &error->message;
  <D.16600>:
  D.16601 = monoeg_g_strdup_printf ("Non translatable error: %s", iftmp.3);
  mono_loader_set_error_bad_image (D.16601);
  <D.16302>:
}


get_type_name (struct MonoErrorInternal * error)
{
  const char * D.16602;
  const char * D.16605;
  struct MonoClass * D.16606;

  D.16602 = error->type_name;
  if (D.16602 != 0B) goto <D.16603>; else goto <D.16604>;
  <D.16603>:
  D.16605 = error->type_name;
  return D.16605;
  <D.16604>:
  D.16606 = error->klass;
  if (D.16606 != 0B) goto <D.16607>; else goto <D.16608>;
  <D.16607>:
  D.16606 = error->klass;
  D.16605 = D.16606->name;
  return D.16605;
  <D.16608>:
  D.16605 = "<unknown type>";
  return D.16605;
}


get_assembly_name (struct MonoErrorInternal * error)
{
  const char * D.16610;
  const char * D.16613;
  struct MonoClass * D.16614;
  struct MonoImage * D.16617;

  D.16610 = error->assembly_name;
  if (D.16610 != 0B) goto <D.16611>; else goto <D.16612>;
  <D.16611>:
  D.16613 = error->assembly_name;
  return D.16613;
  <D.16612>:
  D.16614 = error->klass;
  if (D.16614 != 0B) goto <D.16615>; else goto <D.16616>;
  <D.16615>:
  D.16614 = error->klass;
  D.16617 = D.16614->image;
  if (D.16617 != 0B) goto <D.16618>; else goto <D.16619>;
  <D.16618>:
  D.16614 = error->klass;
  D.16617 = D.16614->image;
  D.16613 = D.16617->name;
  return D.16613;
  <D.16619>:
  <D.16616>:
  D.16613 = "<unknown assembly>";
  return D.16613;
}


mono_error_set_out_of_memory (struct MonoError * oerror, const char * msg_format)
{
  char[128] * D.16621;
  struct MonoErrorInternal * error;
  struct  args[1];

  try
    {
      error = oerror;
      mono_error_prepare (error);
      error->error_code = 6;
      __builtin_va_start (&args, 0);
      D.16621 = &error->message;
      vsnprintf (D.16621, 128, msg_format, &args);
      __builtin_va_end (&args);
    }
  finally
    {
      args = {CLOBBER};
    }
}


mono_error_set_argument (struct MonoError * oerror, const char * argument, const char * msg_format)
{
  char[128] * D.16622;
  int D.16623;
  unsigned int D.16624;
  gchar * D.16627;
  const char * D.16628;
  short unsigned int D.16631;
  short unsigned int D.16632;
  struct MonoErrorInternal * error;

  error = oerror;
  mono_error_prepare (error);
  error->error_code = 7;
  error->type_name = argument;
  {
    struct  args[1];

    try
      {
        __builtin_va_start (&args, 0);
        D.16622 = &error->message;
        D.16623 = vsnprintf (D.16622, 128, msg_format, &args);
        D.16624 = (unsigned int) D.16623;
        if (D.16624 > 127) goto <D.16625>; else goto <D.16626>;
        <D.16625>:
        __builtin_va_end (&args);
        __builtin_va_start (&args, 0);
        D.16627 = monoeg_g_strdup_vprintf (msg_format, &args);
        error->full_message = D.16627;
        D.16628 = error->full_message;
        if (D.16628 == 0B) goto <D.16629>; else goto <D.16630>;
        <D.16629>:
        D.16631 = error->flags;
        D.16632 = D.16631 | 2;
        error->flags = D.16632;
        <D.16630>:
        <D.16626>:
        __builtin_va_end (&args);
      }
    finally
      {
        args = {CLOBBER};
      }
  }
}


mono_error_set_not_verifiable (struct MonoError * oerror, struct MonoMethod * method, const char * msg_format)
{
  struct MonoClass * D.16633;
  char * D.16636;
  char[128] * D.16637;
  int D.16638;
  unsigned int D.16639;
  gchar * D.16642;
  const char * D.16643;
  short unsigned int D.16646;
  short unsigned int D.16647;
  struct MonoErrorInternal * error;

  error = oerror;
  mono_error_prepare (error);
  error->error_code = 8;
  D.16633 = method->klass;
  mono_error_set_class (oerror, D.16633);
  if (method != 0B) goto <D.16634>; else goto <D.16635>;
  <D.16634>:
  D.16636 = mono_method_full_name (method, 1);
  mono_error_set_member_name (oerror, D.16636);
  <D.16635>:
  {
    struct  args[1];

    try
      {
        __builtin_va_start (&args, 0);
        D.16637 = &error->message;
        D.16638 = vsnprintf (D.16637, 128, msg_format, &args);
        D.16639 = (unsigned int) D.16638;
        if (D.16639 > 127) goto <D.16640>; else goto <D.16641>;
        <D.16640>:
        __builtin_va_end (&args);
        __builtin_va_start (&args, 0);
        D.16642 = monoeg_g_strdup_vprintf (msg_format, &args);
        error->full_message = D.16642;
        D.16643 = error->full_message;
        if (D.16643 == 0B) goto <D.16644>; else goto <D.16645>;
        <D.16644>:
        D.16646 = error->flags;
        D.16647 = D.16646 | 2;
        error->flags = D.16647;
        <D.16645>:
        <D.16641>:
        __builtin_va_end (&args);
      }
    finally
      {
        args = {CLOBBER};
      }
  }
}


mono_error_prepare_exception (struct MonoError * oerror, struct MonoError * error_out)
{
  short unsigned int D.16648;
  int D.16649;
  struct MonoException * D.16650;
  const char * D.16654;
  struct MonoClass * D.16656;
  const char * D.16657;
  int D.16659;
  struct MonoImage * D.16663;
  const char * iftmp.4;
  const char * D.16667;
  int D.16676;
  const char * iftmp.5;
  const char * D.16690;
  int D.16691;
  struct MonoImage * D.16697;
  const char * iftmp.6;
  const char * iftmp.7;
  struct MonoImage * D.16718;
  const char * iftmp.8;
  struct MonoImage * D.16727;
  const char * iftmp.9;
  const char * iftmp.10;
  const char * iftmp.11;
  const char * D.16750;
  const char * D.16752;
  const char * iftmp.12;
  int D.16757;
  struct MonoErrorInternal * error;
  struct MonoException * exception;
  struct MonoString * assembly_name;
  struct MonoString * type_name;
  struct MonoString * method_name;
  struct MonoString * field_name;
  struct MonoString * msg;
  struct MonoDomain * domain;

  error = oerror;
  exception = 0B;
  assembly_name = 0B;
  type_name = 0B;
  method_name = 0B;
  field_name = 0B;
  msg = 0B;
  domain = mono_domain_get ();
  mono_error_init (error_out);
  D.16648 = error->error_code;
  D.16649 = (int) D.16648;
  switch (D.16649) <default: <D.16366>, case 0: <D.16353>, case 1: <D.16354>, case 2: <D.16356>, case 3: <D.16357>, case 4: <D.16358>, case 5: <D.16359>, case 6: <D.16360>, case 7: <D.16361>, case 8: <D.16362>, case 9: <D.16365>>
  <D.16353>:
  D.16650 = 0B;
  return D.16650;
  <D.16354>:
  D.16654 = error->type_name;
  if (D.16654 != 0B) goto <D.16651>; else goto <D.16655>;
  <D.16655>:
  D.16656 = error->klass;
  if (D.16656 != 0B) goto <D.16651>; else goto <D.16652>;
  <D.16651>:
  D.16657 = error->member_name;
  if (D.16657 != 0B) goto <D.16658>; else goto <D.16652>;
  <D.16658>:
  type_name = get_type_name_as_mono_string (error, domain, error_out);
  D.16659 = mono_error_ok (error_out);
  if (D.16659 == 0) goto <D.16355>; else goto <D.16660>;
  <D.16660>:
  D.16657 = error->member_name;
  method_name = mono_string_new (domain, D.16657);
  if (method_name == 0B) goto <D.16661>; else goto <D.16662>;
  <D.16661>:
  mono_error_set_out_of_memory (error_out, "Could not allocate method name");
  goto <D.16355>;
  <D.16662>:
  D.16663 = mono_defaults.corlib;
  exception = mono_exception_from_name_two_strings (D.16663, "System", "MissingMethodException", type_name, method_name);
  if (exception != 0B) goto <D.16664>; else goto <D.16665>;
  <D.16664>:
  set_message_on_exception (exception, error, error_out);
  <D.16665>:
  goto <D.16653>;
  <D.16652>:
  D.16667 = error->full_message;
  if (D.16667 != 0B) goto <D.16668>; else goto <D.16669>;
  <D.16668>:
  iftmp.4 = error->full_message;
  goto <D.16670>;
  <D.16669>:
  iftmp.4 = &error->message;
  <D.16670>:
  D.16663 = mono_defaults.corlib;
  exception = mono_exception_from_name_msg (D.16663, "System", "MissingMethodException", iftmp.4);
  <D.16653>:
  goto <D.16355>;
  <D.16356>:
  D.16654 = error->type_name;
  if (D.16654 != 0B) goto <D.16671>; else goto <D.16674>;
  <D.16674>:
  D.16656 = error->klass;
  if (D.16656 != 0B) goto <D.16671>; else goto <D.16672>;
  <D.16671>:
  D.16657 = error->member_name;
  if (D.16657 != 0B) goto <D.16675>; else goto <D.16672>;
  <D.16675>:
  type_name = get_type_name_as_mono_string (error, domain, error_out);
  D.16676 = mono_error_ok (error_out);
  if (D.16676 == 0) goto <D.16355>; else goto <D.16677>;
  <D.16677>:
  D.16657 = error->member_name;
  field_name = mono_string_new (domain, D.16657);
  if (field_name == 0B) goto <D.16678>; else goto <D.16679>;
  <D.16678>:
  mono_error_set_out_of_memory (error_out, "Could not allocate field name");
  goto <D.16355>;
  <D.16679>:
  D.16663 = mono_defaults.corlib;
  exception = mono_exception_from_name_two_strings (D.16663, "System", "MissingFieldException", type_name, field_name);
  if (exception != 0B) goto <D.16680>; else goto <D.16681>;
  <D.16680>:
  set_message_on_exception (exception, error, error_out);
  <D.16681>:
  goto <D.16673>;
  <D.16672>:
  D.16667 = error->full_message;
  if (D.16667 != 0B) goto <D.16683>; else goto <D.16684>;
  <D.16683>:
  iftmp.5 = error->full_message;
  goto <D.16685>;
  <D.16684>:
  iftmp.5 = &error->message;
  <D.16685>:
  D.16663 = mono_defaults.corlib;
  exception = mono_exception_from_name_msg (D.16663, "System", "MissingFieldException", iftmp.5);
  <D.16673>:
  goto <D.16355>;
  <D.16357>:
  D.16654 = error->type_name;
  if (D.16654 != 0B) goto <D.16686>; else goto <D.16689>;
  <D.16689>:
  D.16690 = error->assembly_name;
  if (D.16690 != 0B) goto <D.16686>; else goto <D.16687>;
  <D.16686>:
  type_name = get_type_name_as_mono_string (error, domain, error_out);
  D.16691 = mono_error_ok (error_out);
  if (D.16691 == 0) goto <D.16355>; else goto <D.16692>;
  <D.16692>:
  D.16690 = error->assembly_name;
  if (D.16690 != 0B) goto <D.16693>; else goto <D.16694>;
  <D.16693>:
  D.16690 = error->assembly_name;
  assembly_name = mono_string_new (domain, D.16690);
  if (assembly_name == 0B) goto <D.16695>; else goto <D.16696>;
  <D.16695>:
  mono_error_set_out_of_memory (error_out, "Could not allocate assembly name");
  goto <D.16355>;
  <D.16696>:
  <D.16694>:
  D.16697 = mono_get_corlib ();
  exception = mono_exception_from_name_two_strings (D.16697, "System", "TypeLoadException", type_name, assembly_name);
  if (exception != 0B) goto <D.16698>; else goto <D.16699>;
  <D.16698>:
  set_message_on_exception (exception, error, error_out);
  <D.16699>:
  goto <D.16688>;
  <D.16687>:
  D.16667 = error->full_message;
  if (D.16667 != 0B) goto <D.16701>; else goto <D.16702>;
  <D.16701>:
  iftmp.6 = error->full_message;
  goto <D.16703>;
  <D.16702>:
  iftmp.6 = &error->message;
  <D.16703>:
  D.16663 = mono_defaults.corlib;
  exception = mono_exception_from_name_msg (D.16663, "System", "TypeLoadException", iftmp.6);
  <D.16688>:
  goto <D.16355>;
  <D.16358>:
  <D.16359>:
  D.16690 = error->assembly_name;
  if (D.16690 != 0B) goto <D.16704>; else goto <D.16705>;
  <D.16704>:
  D.16667 = error->full_message;
  if (D.16667 != 0B) goto <D.16707>; else goto <D.16708>;
  <D.16707>:
  iftmp.7 = error->full_message;
  goto <D.16709>;
  <D.16708>:
  iftmp.7 = &error->message;
  <D.16709>:
  msg = mono_string_new (domain, iftmp.7);
  if (msg == 0B) goto <D.16710>; else goto <D.16711>;
  <D.16710>:
  mono_error_set_out_of_memory (error_out, "Could not allocate message");
  goto <D.16355>;
  <D.16711>:
  D.16690 = error->assembly_name;
  if (D.16690 != 0B) goto <D.16712>; else goto <D.16713>;
  <D.16712>:
  D.16690 = error->assembly_name;
  assembly_name = mono_string_new (domain, D.16690);
  if (assembly_name == 0B) goto <D.16714>; else goto <D.16715>;
  <D.16714>:
  mono_error_set_out_of_memory (error_out, "Could not allocate assembly name");
  goto <D.16355>;
  <D.16715>:
  <D.16713>:
  D.16648 = error->error_code;
  if (D.16648 == 4) goto <D.16716>; else goto <D.16717>;
  <D.16716>:
  D.16718 = mono_get_corlib ();
  exception = mono_exception_from_name_two_strings (D.16718, "System.IO", "FileNotFoundException", msg, assembly_name);
  goto <D.16719>;
  <D.16717>:
  D.16663 = mono_defaults.corlib;
  exception = mono_exception_from_name_two_strings (D.16663, "System", "BadImageFormatException", msg, assembly_name);
  <D.16719>:
  goto <D.16720>;
  <D.16705>:
  D.16648 = error->error_code;
  if (D.16648 == 4) goto <D.16721>; else goto <D.16722>;
  <D.16721>:
  D.16667 = error->full_message;
  if (D.16667 != 0B) goto <D.16724>; else goto <D.16725>;
  <D.16724>:
  iftmp.8 = error->full_message;
  goto <D.16726>;
  <D.16725>:
  iftmp.8 = &error->message;
  <D.16726>:
  D.16727 = mono_get_corlib ();
  exception = mono_exception_from_name_msg (D.16727, "System.IO", "FileNotFoundException", iftmp.8);
  goto <D.16728>;
  <D.16722>:
  D.16667 = error->full_message;
  if (D.16667 != 0B) goto <D.16730>; else goto <D.16731>;
  <D.16730>:
  iftmp.9 = error->full_message;
  goto <D.16732>;
  <D.16731>:
  iftmp.9 = &error->message;
  <D.16732>:
  D.16663 = mono_defaults.corlib;
  exception = mono_exception_from_name_msg (D.16663, "System", "BadImageFormatException", iftmp.9);
  <D.16728>:
  <D.16720>:
  goto <D.16355>;
  <D.16360>:
  exception = mono_get_exception_out_of_memory ();
  goto <D.16355>;
  <D.16361>:
  D.16667 = error->full_message;
  if (D.16667 != 0B) goto <D.16734>; else goto <D.16735>;
  <D.16734>:
  iftmp.10 = error->full_message;
  goto <D.16736>;
  <D.16735>:
  iftmp.10 = &error->message;
  <D.16736>:
  D.16654 = error->type_name;
  exception = mono_get_exception_argument (D.16654, iftmp.10);
  goto <D.16355>;
  <D.16362>:
  {
    char * type_name;
    char * message;

    type_name = 0B;
    D.16656 = error->klass;
    if (D.16656 != 0B) goto <D.16737>; else goto <D.16738>;
    <D.16737>:
    D.16656 = error->klass;
    type_name = mono_type_get_full_name (D.16656);
    if (type_name == 0B) goto <D.16739>; else goto <D.16740>;
    <D.16739>:
    mono_error_set_out_of_memory (error_out, "Could not allocate message");
    goto <D.16355>;
    <D.16740>:
    <D.16738>:
    D.16667 = error->full_message;
    if (D.16667 != 0B) goto <D.16742>; else goto <D.16743>;
    <D.16742>:
    iftmp.11 = error->full_message;
    goto <D.16744>;
    <D.16743>:
    iftmp.11 = &error->message;
    <D.16744>:
    D.16657 = error->member_name;
    message = monoeg_g_strdup_printf ("Error in %s:%s %s", type_name, D.16657, iftmp.11);
    if (message == 0B) goto <D.16745>; else goto <D.16746>;
    <D.16745>:
    monoeg_g_free (type_name);
    mono_error_set_out_of_memory (error_out, "Could not allocate message");
    goto <D.16355>;
    <D.16746>:
    D.16663 = mono_defaults.corlib;
    exception = mono_exception_from_name_msg (D.16663, "System.Security", "VerificationException", message);
    monoeg_g_free (message);
    monoeg_g_free (type_name);
    goto <D.16355>;
  }
  <D.16365>:
  D.16750 = error->exception_name_space;
  if (D.16750 == 0B) goto <D.16747>; else goto <D.16751>;
  <D.16751>:
  D.16752 = error->exception_name;
  if (D.16752 == 0B) goto <D.16747>; else goto <D.16748>;
  <D.16747>:
  mono_error_set_generic_error (error_out, "System", "ExecutionEngineException", "MonoError with generic error but no exception name was supplied");
  goto <D.16749>;
  <D.16748>:
  D.16667 = error->full_message;
  if (D.16667 != 0B) goto <D.16754>; else goto <D.16755>;
  <D.16754>:
  iftmp.12 = error->full_message;
  goto <D.16756>;
  <D.16755>:
  iftmp.12 = &error->message;
  <D.16756>:
  D.16752 = error->exception_name;
  D.16750 = error->exception_name_space;
  D.16663 = mono_defaults.corlib;
  exception = mono_exception_from_name_msg (D.16663, D.16750, D.16752, iftmp.12);
  <D.16749>:
  goto <D.16355>;
  <D.16366>:
  D.16648 = error->error_code;
  D.16649 = (int) D.16648;
  mono_error_set_generic_error (error_out, "System", "ExecutionEngineException", "Invalid error-code %d", D.16649);
  <D.16355>:
  D.16757 = mono_error_ok (error_out);
  if (D.16757 == 0) goto <D.16758>; else goto <D.16759>;
  <D.16758>:
  D.16650 = 0B;
  return D.16650;
  <D.16759>:
  if (exception == 0B) goto <D.16760>; else goto <D.16761>;
  <D.16760>:
  mono_error_set_out_of_memory (error_out, "Could not allocate exception object");
  <D.16761>:
  D.16650 = exception;
  return D.16650;
}


get_type_name_as_mono_string (struct MonoErrorInternal * error, struct MonoDomain * domain, struct MonoError * error_out)
{
  const char * D.16763;
  struct MonoClass * D.16767;
  struct MonoType * D.16770;
  struct MonoString * D.16775;
  struct MonoString * res;

  res = 0B;
  D.16763 = error->type_name;
  if (D.16763 != 0B) goto <D.16764>; else goto <D.16765>;
  <D.16764>:
  D.16763 = error->type_name;
  res = mono_string_new (domain, D.16763);
  goto <D.16766>;
  <D.16765>:
  D.16767 = error->klass;
  if (D.16767 != 0B) goto <D.16768>; else goto <D.16769>;
  <D.16768>:
  {
    char * name;

    D.16767 = error->klass;
    D.16770 = &D.16767->byval_arg;
    name = mono_type_full_name (D.16770);
    if (name != 0B) goto <D.16771>; else goto <D.16772>;
    <D.16771>:
    res = mono_string_new (domain, name);
    monoeg_g_free (name);
    <D.16772>:
  }
  <D.16769>:
  <D.16766>:
  if (res == 0B) goto <D.16773>; else goto <D.16774>;
  <D.16773>:
  mono_error_set_out_of_memory (error_out, "Could not allocate type name");
  <D.16774>:
  D.16775 = res;
  return D.16775;
}


set_message_on_exception (struct MonoException * exception, struct MonoErrorInternal * error, struct MonoError * error_out)
{
  const char * iftmp.13;
  const char * D.16778;
  struct MonoDomain * D.16782;
  struct MonoString * * D.16785;
  struct MonoString * msg;

  D.16778 = error->full_message;
  if (D.16778 != 0B) goto <D.16779>; else goto <D.16780>;
  <D.16779>:
  iftmp.13 = error->full_message;
  goto <D.16781>;
  <D.16780>:
  iftmp.13 = &error->message;
  <D.16781>:
  D.16782 = mono_domain_get ();
  msg = mono_string_new (D.16782, iftmp.13);
  if (msg != 0B) goto <D.16783>; else goto <D.16784>;
  <D.16783>:
  D.16785 = &exception->message;
  mono_gc_wbarrier_set_field (exception, D.16785, msg);
  goto <D.16786>;
  <D.16784>:
  mono_error_set_out_of_memory (error_out, "Could not allocate exception object");
  <D.16786>:
}


mono_error_raise_exception (struct MonoError * target_error)
{
  int D.16787;
  int D.16790;
  int D.16793;
  _Bool D.16794;
  long int D.16795;
  long int D.16796;
  struct MonoError error;
  struct MonoException * ex;

  try
    {
      D.16787 = mono_error_ok (target_error);
      if (D.16787 != 0) goto <D.16788>; else goto <D.16789>;
      <D.16788>:
      return;
      <D.16789>:
      ex = mono_error_prepare_exception (target_error, &error);
      D.16790 = mono_error_ok (&error);
      if (D.16790 == 0) goto <D.16791>; else goto <D.16792>;
      <D.16791>:
      {
        struct MonoError second_chance;

        try
          {
            ex = mono_error_prepare_exception (&error, &second_chance);
            D.16793 = mono_error_ok (&second_chance);
            D.16794 = D.16793 == 0;
            D.16795 = (long int) D.16794;
            D.16796 = __builtin_expect (D.16795, 0);
            if (D.16796 != 0) goto <D.16797>; else goto <D.16798>;
            <D.16797>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mono-error.c", 646, "mono_error_ok (&second_chance)");
            <D.16798>:
            mono_error_cleanup (&error);
          }
        finally
          {
            second_chance = {CLOBBER};
          }
      }
      <D.16792>:
      mono_error_cleanup (target_error);
      mono_raise_exception (ex);
    }
  finally
    {
      error = {CLOBBER};
    }
}