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

  error = oerror;
  if (0 != 0) goto <D.16518>; else goto <D.16519>;
  <D.16518>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mono-error.c", 47, "sizeof (MonoError) == sizeof (MonoErrorInternal)");
  <D.16519>:
  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.16520;
  const char * D.16523;
  short unsigned int D.16524;
  int D.16525;
  int D.16526;
  const char * D.16529;
  const char * D.16530;
  const char * D.16531;
  const char * D.16532;
  const char * D.16533;
  struct MonoErrorInternal * error;

  error = oerror;
  D.16520 = error->error_code;
  if (D.16520 == 0) goto <D.16521>; else goto <D.16522>;
  <D.16521>:
  return;
  <D.16522>:
  D.16523 = error->full_message;
  monoeg_g_free (D.16523);
  D.16524 = error->flags;
  D.16525 = (int) D.16524;
  D.16526 = D.16525 & 1;
  if (D.16526 == 0) goto <D.16527>; else goto <D.16528>;
  <D.16527>:
  return;
  <D.16528>:
  D.16529 = error->type_name;
  monoeg_g_free (D.16529);
  D.16530 = error->assembly_name;
  monoeg_g_free (D.16530);
  D.16531 = error->member_name;
  monoeg_g_free (D.16531);
  D.16532 = error->exception_name_space;
  monoeg_g_free (D.16532);
  D.16533 = error->exception_name;
  monoeg_g_free (D.16533);
}


mono_error_ok (struct MonoError * error)
{
  mono_bool D.16535;
  short unsigned int D.16536;
  _Bool D.16537;

  D.16536 = error->error_code;
  D.16537 = D.16536 == 0;
  D.16535 = (mono_bool) D.16537;
  return D.16535;
}


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

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


mono_error_get_message (struct MonoError * oerror)
{
  short unsigned int D.16541;
  const char * D.16544;
  const char * iftmp.0;
  const char * D.16546;
  struct MonoErrorInternal * error;

  error = oerror;
  D.16541 = error->error_code;
  if (D.16541 == 0) goto <D.16542>; else goto <D.16543>;
  <D.16542>:
  D.16544 = 0B;
  return D.16544;
  <D.16543>:
  D.16546 = error->full_message;
  if (D.16546 != 0B) goto <D.16547>; else goto <D.16548>;
  <D.16547>:
  iftmp.0 = error->full_message;
  goto <D.16549>;
  <D.16548>:
  iftmp.0 = &error->message;
  <D.16549>:
  D.16544 = iftmp.0;
  return D.16544;
}


__attribute__((visibility ("hidden")))
mono_error_dup_strings (struct MonoError * oerror, gboolean dup_strings)
{
  short unsigned int D.16551;
  short unsigned int D.16552;
  const char * D.16555;
  gchar * D.16558;
  short unsigned int D.16561;
  const char * D.16562;
  gchar * D.16565;
  const char * D.16568;
  gchar * D.16571;
  const char * D.16574;
  gchar * D.16577;
  const char * D.16580;
  gchar * D.16583;
  struct MonoErrorInternal * error;

  error = oerror;
  D.16551 = error->flags;
  D.16552 = D.16551 | 1;
  error->flags = D.16552;
  if (dup_strings != 0) goto <D.16553>; else goto <D.16554>;
  <D.16553>:
  D.16555 = error->type_name;
  if (D.16555 != 0B) goto <D.16556>; else goto <D.16557>;
  <D.16556>:
  D.16555 = error->type_name;
  D.16558 = monoeg_strdup (D.16555);
  error->type_name = D.16558;
  D.16555 = error->type_name;
  if (D.16555 == 0B) goto <D.16559>; else goto <D.16560>;
  <D.16559>:
  D.16551 = error->flags;
  D.16561 = D.16551 | 2;
  error->flags = D.16561;
  <D.16560>:
  <D.16557>:
  D.16562 = error->assembly_name;
  if (D.16562 != 0B) goto <D.16563>; else goto <D.16564>;
  <D.16563>:
  D.16562 = error->assembly_name;
  D.16565 = monoeg_strdup (D.16562);
  error->assembly_name = D.16565;
  D.16562 = error->assembly_name;
  if (D.16562 == 0B) goto <D.16566>; else goto <D.16567>;
  <D.16566>:
  D.16551 = error->flags;
  D.16561 = D.16551 | 2;
  error->flags = D.16561;
  <D.16567>:
  <D.16564>:
  D.16568 = error->member_name;
  if (D.16568 != 0B) goto <D.16569>; else goto <D.16570>;
  <D.16569>:
  D.16568 = error->member_name;
  D.16571 = monoeg_strdup (D.16568);
  error->member_name = D.16571;
  D.16568 = error->member_name;
  if (D.16568 == 0B) goto <D.16572>; else goto <D.16573>;
  <D.16572>:
  D.16551 = error->flags;
  D.16561 = D.16551 | 2;
  error->flags = D.16561;
  <D.16573>:
  <D.16570>:
  D.16574 = error->exception_name_space;
  if (D.16574 != 0B) goto <D.16575>; else goto <D.16576>;
  <D.16575>:
  D.16574 = error->exception_name_space;
  D.16577 = monoeg_strdup (D.16574);
  error->exception_name_space = D.16577;
  D.16574 = error->exception_name_space;
  if (D.16574 == 0B) goto <D.16578>; else goto <D.16579>;
  <D.16578>:
  D.16551 = error->flags;
  D.16561 = D.16551 | 2;
  error->flags = D.16561;
  <D.16579>:
  <D.16576>:
  D.16580 = error->exception_name;
  if (D.16580 != 0B) goto <D.16581>; else goto <D.16582>;
  <D.16581>:
  D.16580 = error->exception_name;
  D.16583 = monoeg_strdup (D.16580);
  error->exception_name = D.16583;
  D.16580 = error->exception_name;
  if (D.16580 == 0B) goto <D.16584>; else goto <D.16585>;
  <D.16584>:
  D.16551 = error->flags;
  D.16561 = D.16551 | 2;
  error->flags = D.16561;
  <D.16585>:
  <D.16582>:
  <D.16554>:
}


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

  if (str != 0B) goto <D.16586>; else goto <D.16587>;
  <D.16586>:
  D.16588 = __strdup (str);
  return D.16588;
  <D.16587>:
  D.16588 = 0B;
  return D.16588;
}


__attribute__((visibility ("hidden")))
mono_error_set_error (struct MonoError * oerror, int error_code, const char * msg_format)
{
  short unsigned int D.16590;
  char[128] * D.16591;
  int D.16592;
  unsigned int D.16593;
  gchar * D.16596;
  const char * D.16597;
  short unsigned int D.16600;
  short unsigned int D.16601;
  struct MonoErrorInternal * error;

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

    try
      {
        __builtin_va_start (&args, 0);
        D.16591 = &error->message;
        D.16592 = vsnprintf (D.16591, 128, msg_format, &args);
        D.16593 = (unsigned int) D.16592;
        if (D.16593 > 127) goto <D.16594>; else goto <D.16595>;
        <D.16594>:
        __builtin_va_end (&args);
        __builtin_va_start (&args, 0);
        D.16596 = monoeg_g_strdup_vprintf (msg_format, &args);
        error->full_message = D.16596;
        D.16597 = error->full_message;
        if (D.16597 == 0B) goto <D.16598>; else goto <D.16599>;
        <D.16598>:
        D.16600 = error->flags;
        D.16601 = D.16600 | 2;
        error->flags = D.16601;
        <D.16599>:
        <D.16595>:
        __builtin_va_end (&args);
      }
    finally
      {
        args = {CLOBBER};
      }
  }
}


mono_error_prepare (struct MonoErrorInternal * error)
{
  short unsigned int D.16602;
  const char * D.16605;
  const char * D.16606;
  const char * D.16607;
  const char * D.16608;
  const char * D.16609;

  D.16602 = error->error_code;
  if (D.16602 != 0) goto <D.16603>; else goto <D.16604>;
  <D.16603>:
  return;
  <D.16604>:
  error->exception_name = 0B;
  D.16605 = error->exception_name;
  error->exception_name_space = D.16605;
  D.16606 = error->exception_name_space;
  error->full_message = D.16606;
  D.16607 = error->full_message;
  error->member_name = D.16607;
  D.16608 = error->member_name;
  error->assembly_name = D.16608;
  D.16609 = error->assembly_name;
  error->type_name = D.16609;
  error->klass = 0B;
  error->message[0] = 0;
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__, __leaf__, __nothrow__))
vsnprintf (char * restrict __s, size_t __n, const char * restrict __fmt, struct  * __ap)
{
  int D.16611;
  long unsigned int D.16612;

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


__attribute__((visibility ("hidden")))
mono_error_set_assembly_load (struct MonoError * oerror, const char * assembly_name, const char * msg_format)
{
  char[128] * D.16614;
  int D.16615;
  unsigned int D.16616;
  gchar * D.16619;
  const char * D.16620;
  short unsigned int D.16623;
  short unsigned int D.16624;
  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.16614 = &error->message;
        D.16615 = vsnprintf (D.16614, 128, msg_format, &args);
        D.16616 = (unsigned int) D.16615;
        if (D.16616 > 127) goto <D.16617>; else goto <D.16618>;
        <D.16617>:
        __builtin_va_end (&args);
        __builtin_va_start (&args, 0);
        D.16619 = monoeg_g_strdup_vprintf (msg_format, &args);
        error->full_message = D.16619;
        D.16620 = error->full_message;
        if (D.16620 == 0B) goto <D.16621>; else goto <D.16622>;
        <D.16621>:
        D.16623 = error->flags;
        D.16624 = D.16623 | 2;
        error->flags = D.16624;
        <D.16622>:
        <D.16618>:
        __builtin_va_end (&args);
      }
    finally
      {
        args = {CLOBBER};
      }
  }
}


mono_error_set_assembly_name (struct MonoError * oerror, const char * assembly_name)
{
  short unsigned int D.16625;
  _Bool D.16626;
  long int D.16627;
  long int D.16628;
  struct MonoErrorInternal * error;

  error = oerror;
  D.16625 = error->error_code;
  D.16626 = D.16625 == 0;
  D.16627 = (long int) D.16626;
  D.16628 = __builtin_expect (D.16627, 0);
  if (D.16628 != 0) goto <D.16629>; else goto <D.16630>;
  <D.16629>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mono-error.c", 140, "error->error_code != MONO_ERROR_NONE");
  <D.16630>:
  error->assembly_name = assembly_name;
}


__attribute__((visibility ("hidden")))
mono_error_set_type_load_class (struct MonoError * oerror, struct MonoClass * klass, const char * msg_format)
{
  char[128] * D.16631;
  int D.16632;
  unsigned int D.16633;
  gchar * D.16636;
  const char * D.16637;
  short unsigned int D.16640;
  short unsigned int D.16641;
  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.16631 = &error->message;
        D.16632 = vsnprintf (D.16631, 128, msg_format, &args);
        D.16633 = (unsigned int) D.16632;
        if (D.16633 > 127) goto <D.16634>; else goto <D.16635>;
        <D.16634>:
        __builtin_va_end (&args);
        __builtin_va_start (&args, 0);
        D.16636 = monoeg_g_strdup_vprintf (msg_format, &args);
        error->full_message = D.16636;
        D.16637 = error->full_message;
        if (D.16637 == 0B) goto <D.16638>; else goto <D.16639>;
        <D.16638>:
        D.16640 = error->flags;
        D.16641 = D.16640 | 2;
        error->flags = D.16641;
        <D.16639>:
        <D.16635>:
        __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;
}


__attribute__((visibility ("hidden")))
mono_error_set_type_load_name (struct MonoError * oerror, const char * type_name, const char * assembly_name, const char * msg_format)
{
  char[128] * D.16642;
  int D.16643;
  unsigned int D.16644;
  gchar * D.16647;
  const char * D.16648;
  short unsigned int D.16651;
  short unsigned int D.16652;
  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.16642 = &error->message;
        D.16643 = vsnprintf (D.16642, 128, msg_format, &args);
        D.16644 = (unsigned int) D.16643;
        if (D.16644 > 127) goto <D.16645>; else goto <D.16646>;
        <D.16645>:
        __builtin_va_end (&args);
        __builtin_va_start (&args, 0);
        D.16647 = monoeg_g_strdup_vprintf (msg_format, &args);
        error->full_message = D.16647;
        D.16648 = error->full_message;
        if (D.16648 == 0B) goto <D.16649>; else goto <D.16650>;
        <D.16649>:
        D.16651 = error->flags;
        D.16652 = D.16651 | 2;
        error->flags = D.16652;
        <D.16650>:
        <D.16646>:
        __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;
}


__attribute__((visibility ("hidden")))
mono_error_set_method_load (struct MonoError * oerror, struct MonoClass * klass, const char * method_name, const char * msg_format)
{
  char[128] * D.16653;
  int D.16654;
  unsigned int D.16655;
  gchar * D.16658;
  const char * D.16659;
  short unsigned int D.16662;
  short unsigned int D.16663;
  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.16653 = &error->message;
        D.16654 = vsnprintf (D.16653, 128, msg_format, &args);
        D.16655 = (unsigned int) D.16654;
        if (D.16655 > 127) goto <D.16656>; else goto <D.16657>;
        <D.16656>:
        __builtin_va_end (&args);
        __builtin_va_start (&args, 0);
        D.16658 = monoeg_g_strdup_vprintf (msg_format, &args);
        error->full_message = D.16658;
        D.16659 = error->full_message;
        if (D.16659 == 0B) goto <D.16660>; else goto <D.16661>;
        <D.16660>:
        D.16662 = error->flags;
        D.16663 = D.16662 | 2;
        error->flags = D.16663;
        <D.16661>:
        <D.16657>:
        __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;
}


__attribute__((visibility ("hidden")))
mono_error_set_field_load (struct MonoError * oerror, struct MonoClass * klass, const char * field_name, const char * msg_format)
{
  char[128] * D.16664;
  int D.16665;
  unsigned int D.16666;
  gchar * D.16669;
  const char * D.16670;
  short unsigned int D.16673;
  short unsigned int D.16674;
  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.16664 = &error->message;
        D.16665 = vsnprintf (D.16664, 128, msg_format, &args);
        D.16666 = (unsigned int) D.16665;
        if (D.16666 > 127) goto <D.16667>; else goto <D.16668>;
        <D.16667>:
        __builtin_va_end (&args);
        __builtin_va_start (&args, 0);
        D.16669 = monoeg_g_strdup_vprintf (msg_format, &args);
        error->full_message = D.16669;
        D.16670 = error->full_message;
        if (D.16670 == 0B) goto <D.16671>; else goto <D.16672>;
        <D.16671>:
        D.16673 = error->flags;
        D.16674 = D.16673 | 2;
        error->flags = D.16674;
        <D.16672>:
        <D.16668>:
        __builtin_va_end (&args);
      }
    finally
      {
        args = {CLOBBER};
      }
  }
}


__attribute__((visibility ("hidden")))
mono_error_set_bad_image_name (struct MonoError * oerror, const char * assembly_name, const char * msg_format)
{
  char[128] * D.16675;
  int D.16676;
  unsigned int D.16677;
  gchar * D.16680;
  const char * D.16681;
  short unsigned int D.16684;
  short unsigned int D.16685;
  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.16675 = &error->message;
        D.16676 = vsnprintf (D.16675, 128, msg_format, &args);
        D.16677 = (unsigned int) D.16676;
        if (D.16677 > 127) goto <D.16678>; else goto <D.16679>;
        <D.16678>:
        __builtin_va_end (&args);
        __builtin_va_start (&args, 0);
        D.16680 = monoeg_g_strdup_vprintf (msg_format, &args);
        error->full_message = D.16680;
        D.16681 = error->full_message;
        if (D.16681 == 0B) goto <D.16682>; else goto <D.16683>;
        <D.16682>:
        D.16684 = error->flags;
        D.16685 = D.16684 | 2;
        error->flags = D.16685;
        <D.16683>:
        <D.16679>:
        __builtin_va_end (&args);
      }
    finally
      {
        args = {CLOBBER};
      }
  }
}


__attribute__((visibility ("hidden")))
mono_error_set_bad_image (struct MonoError * oerror, struct MonoImage * image, const char * msg_format)
{
  const char * iftmp.1;
  char[128] * D.16690;
  int D.16691;
  unsigned int D.16692;
  gchar * D.16695;
  const char * D.16696;
  short unsigned int D.16699;
  short unsigned int D.16700;
  struct MonoErrorInternal * error;

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

    try
      {
        __builtin_va_start (&args, 0);
        D.16690 = &error->message;
        D.16691 = vsnprintf (D.16690, 128, msg_format, &args);
        D.16692 = (unsigned int) D.16691;
        if (D.16692 > 127) goto <D.16693>; else goto <D.16694>;
        <D.16693>:
        __builtin_va_end (&args);
        __builtin_va_start (&args, 0);
        D.16695 = monoeg_g_strdup_vprintf (msg_format, &args);
        error->full_message = D.16695;
        D.16696 = error->full_message;
        if (D.16696 == 0B) goto <D.16697>; else goto <D.16698>;
        <D.16697>:
        D.16699 = error->flags;
        D.16700 = D.16699 | 2;
        error->flags = D.16700;
        <D.16698>:
        <D.16694>:
        __builtin_va_end (&args);
      }
    finally
      {
        args = {CLOBBER};
      }
  }
}


__attribute__((visibility ("hidden")))
mono_error_set_generic_error (struct MonoError * oerror, const char * name_space, const char * name, const char * msg_format)
{
  char[128] * D.16701;
  int D.16702;
  unsigned int D.16703;
  gchar * D.16706;
  const char * D.16707;
  short unsigned int D.16710;
  short unsigned int D.16711;
  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.16701 = &error->message;
        D.16702 = vsnprintf (D.16701, 128, msg_format, &args);
        D.16703 = (unsigned int) D.16702;
        if (D.16703 > 127) goto <D.16704>; else goto <D.16705>;
        <D.16704>:
        __builtin_va_end (&args);
        __builtin_va_start (&args, 0);
        D.16706 = monoeg_g_strdup_vprintf (msg_format, &args);
        error->full_message = D.16706;
        D.16707 = error->full_message;
        if (D.16707 == 0B) goto <D.16708>; else goto <D.16709>;
        <D.16708>:
        D.16710 = error->flags;
        D.16711 = D.16710 | 2;
        error->flags = D.16711;
        <D.16709>:
        <D.16705>:
        __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;
}


__attribute__((visibility ("hidden")))
mono_error_set_from_loader_error (struct MonoError * oerror)
{
  unsigned char D.16714;
  int D.16715;
  char * D.16716;
  const char * D.16717;
  char[128] * D.16718;
  struct MonoClass * D.16719;
  char * D.16720;
  int D.16721;
  char * D.16725;
  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.16712>; else goto <D.16713>;
  <D.16712>:
  mono_error_set_generic_error (oerror, "System", "ExecutionEngineException", "Runtime tried to produce a mono-error from an empty loader-error");
  return;
  <D.16713>:
  D.16714 = loader_error->exception_type;
  D.16715 = (int) D.16714;
  switch (D.16715) <default: <D.16434>, case 0: <D.16418>, case 1: <D.16420>, case 2: <D.16421>, case 3: <D.16422>, case 4: <D.16423>, case 5: <D.16424>, case 6: <D.16425>, case 7: <D.16426>, case 8: <D.16427>, case 9: <D.16428>, case 10: <D.16429>, case 11: <D.16431>, case 12: <D.16432>, case 13: <D.16430>, case 14: <D.16433>>
  <D.16418>:
  mono_error_set_generic_error (oerror, "System", "ExecutionEngineException", "Runtime tried to produce a mono-error from a non-error loader-error");
  goto <D.16419>;
  <D.16420>:
  <D.16421>:
  mono_error_set_generic_error (oerror, "System.Security", "SecurityException", "Failed for unknown reasons.");
  goto <D.16419>;
  <D.16422>:
  mono_error_set_generic_error (oerror, "System", "InvalidProgramException", "Failed for unknown reasons.");
  goto <D.16419>;
  <D.16423>:
  mono_error_set_generic_error (oerror, "System.Security", "VerificationException", "Failed for unknown reasons.");
  goto <D.16419>;
  <D.16424>:
  error->error_code = 1;
  D.16716 = loader_error->class_name;
  mono_error_set_type_name (oerror, D.16716);
  D.16717 = loader_error->member_name;
  mono_error_set_member_name (oerror, D.16717);
  D.16718 = &error->message;
  monoeg_g_snprintf (D.16718, 128, "Failed for unknown reasons.");
  goto <D.16419>;
  <D.16425>:
  D.16719 = loader_error->klass;
  D.16717 = loader_error->member_name;
  mono_error_set_field_load (oerror, D.16719, D.16717, "Failed for unknown reasons.");
  goto <D.16419>;
  <D.16426>:
  D.16716 = loader_error->class_name;
  D.16720 = loader_error->assembly_name;
  mono_error_set_type_load_name (oerror, D.16716, D.16720, "Failed for unknown reasons.");
  goto <D.16419>;
  <D.16427>:
  D.16721 = loader_error->ref_only;
  if (D.16721 != 0) goto <D.16722>; else goto <D.16723>;
  <D.16722>:
  D.16720 = loader_error->assembly_name;
  mono_error_set_assembly_load (oerror, D.16720, "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.16724>;
  <D.16723>:
  D.16720 = loader_error->assembly_name;
  mono_error_set_assembly_load (oerror, D.16720, "Could not load file or assembly or one of its dependencies.");
  <D.16724>:
  goto <D.16419>;
  <D.16428>:
  mono_error_set_generic_error (oerror, "System", "MethodAccessException", "Failed for unknown reasons.");
  goto <D.16419>;
  <D.16429>:
  mono_error_set_generic_error (oerror, "System", "FieldAccessException", "Failed for unknown reasons.");
  goto <D.16419>;
  <D.16430>:
  <D.16431>:
  D.16714 = loader_error->exception_type;
  D.16715 = (int) D.16714;
  mono_error_set_generic_error (oerror, "System", "ExecutionEngineException", "Runtime tried to produce a mono-error from JIT internal error %d", D.16715);
  goto <D.16419>;
  <D.16432>:
  D.16725 = loader_error->msg;
  mono_error_set_bad_image_name (oerror, "<unknown>", "%s", D.16725);
  goto <D.16419>;
  <D.16433>:
  mono_error_set_out_of_memory (oerror, "Failed for unknown reasons.");
  goto <D.16419>;
  <D.16434>:
  D.16714 = loader_error->exception_type;
  D.16715 = (int) D.16714;
  mono_error_set_generic_error (oerror, "System", "ExecutionEngineException", "Runtime tried to produce an unknown loader-error %d", D.16715);
  goto <D.16419>;
  <D.16419>:
  mono_error_dup_strings (oerror, 1);
  mono_loader_clear_error ();
}


__attribute__((visibility ("hidden")))
mono_loader_set_error_from_mono_error (struct MonoError * oerror)
{
  short unsigned int D.16727;
  int D.16728;
  const char * D.16729;
  const char * D.16730;
  struct MonoClass * D.16731;
  const char * D.16732;
  const char * D.16733;
  const char * D.16734;
  const gchar * iftmp.2;
  const char * D.16736;
  gchar * D.16740;
  const char * iftmp.3;
  gchar * D.16745;
  struct MonoErrorInternal * error;

  error = oerror;
  D.16727 = error->error_code;
  D.16728 = (int) D.16727;
  switch (D.16728) <default: <D.16451>, case 1: <D.16445>, case 2: <D.16447>, case 3: <D.16448>, case 4: <D.16449>, case 5: <D.16450>>
  <D.16445>:
  D.16729 = get_type_name (error);
  D.16730 = error->member_name;
  mono_loader_set_error_method_load (D.16729, D.16730);
  goto <D.16446>;
  <D.16447>:
  D.16731 = error->klass;
  D.16730 = error->member_name;
  mono_loader_set_error_field_load (D.16731, D.16730);
  goto <D.16446>;
  <D.16448>:
  D.16732 = get_type_name (error);
  D.16733 = get_assembly_name (error);
  mono_loader_set_error_type_load (D.16732, D.16733);
  goto <D.16446>;
  <D.16449>:
  D.16734 = get_assembly_name (error);
  mono_loader_set_error_assembly_load (D.16734, 0);
  goto <D.16446>;
  <D.16450>:
  D.16736 = error->full_message;
  if (D.16736 != 0B) goto <D.16737>; else goto <D.16738>;
  <D.16737>:
  iftmp.2 = error->full_message;
  goto <D.16739>;
  <D.16738>:
  iftmp.2 = &error->message;
  <D.16739>:
  D.16740 = monoeg_strdup (iftmp.2);
  mono_loader_set_error_bad_image (D.16740);
  goto <D.16446>;
  <D.16451>:
  D.16736 = error->full_message;
  if (D.16736 != 0B) goto <D.16742>; else goto <D.16743>;
  <D.16742>:
  iftmp.3 = error->full_message;
  goto <D.16744>;
  <D.16743>:
  iftmp.3 = &error->message;
  <D.16744>:
  D.16745 = monoeg_g_strdup_printf ("Non translatable error: %s", iftmp.3);
  mono_loader_set_error_bad_image (D.16745);
  <D.16446>:
}


get_type_name (struct MonoErrorInternal * error)
{
  const char * D.16746;
  const char * D.16749;
  struct MonoClass * D.16750;

  D.16746 = error->type_name;
  if (D.16746 != 0B) goto <D.16747>; else goto <D.16748>;
  <D.16747>:
  D.16749 = error->type_name;
  return D.16749;
  <D.16748>:
  D.16750 = error->klass;
  if (D.16750 != 0B) goto <D.16751>; else goto <D.16752>;
  <D.16751>:
  D.16750 = error->klass;
  D.16749 = D.16750->name;
  return D.16749;
  <D.16752>:
  D.16749 = "<unknown type>";
  return D.16749;
}


get_assembly_name (struct MonoErrorInternal * error)
{
  const char * D.16754;
  const char * D.16757;
  struct MonoClass * D.16758;
  struct MonoImage * D.16761;

  D.16754 = error->assembly_name;
  if (D.16754 != 0B) goto <D.16755>; else goto <D.16756>;
  <D.16755>:
  D.16757 = error->assembly_name;
  return D.16757;
  <D.16756>:
  D.16758 = error->klass;
  if (D.16758 != 0B) goto <D.16759>; else goto <D.16760>;
  <D.16759>:
  D.16758 = error->klass;
  D.16761 = D.16758->image;
  if (D.16761 != 0B) goto <D.16762>; else goto <D.16763>;
  <D.16762>:
  D.16758 = error->klass;
  D.16761 = D.16758->image;
  D.16757 = D.16761->name;
  return D.16757;
  <D.16763>:
  <D.16760>:
  D.16757 = "<unknown assembly>";
  return D.16757;
}


__attribute__((visibility ("hidden")))
mono_error_set_out_of_memory (struct MonoError * oerror, const char * msg_format)
{
  char[128] * D.16765;
  struct MonoErrorInternal * error;
  struct  args[1];

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


__attribute__((visibility ("hidden")))
mono_error_set_argument (struct MonoError * oerror, const char * argument, const char * msg_format)
{
  char[128] * D.16766;
  int D.16767;
  unsigned int D.16768;
  gchar * D.16771;
  const char * D.16772;
  short unsigned int D.16775;
  short unsigned int D.16776;
  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.16766 = &error->message;
        D.16767 = vsnprintf (D.16766, 128, msg_format, &args);
        D.16768 = (unsigned int) D.16767;
        if (D.16768 > 127) goto <D.16769>; else goto <D.16770>;
        <D.16769>:
        __builtin_va_end (&args);
        __builtin_va_start (&args, 0);
        D.16771 = monoeg_g_strdup_vprintf (msg_format, &args);
        error->full_message = D.16771;
        D.16772 = error->full_message;
        if (D.16772 == 0B) goto <D.16773>; else goto <D.16774>;
        <D.16773>:
        D.16775 = error->flags;
        D.16776 = D.16775 | 2;
        error->flags = D.16776;
        <D.16774>:
        <D.16770>:
        __builtin_va_end (&args);
      }
    finally
      {
        args = {CLOBBER};
      }
  }
}


__attribute__((visibility ("hidden")))
mono_error_set_not_verifiable (struct MonoError * oerror, struct MonoMethod * method, const char * msg_format)
{
  struct MonoClass * D.16777;
  char * D.16780;
  char[128] * D.16781;
  int D.16782;
  unsigned int D.16783;
  gchar * D.16786;
  const char * D.16787;
  short unsigned int D.16790;
  short unsigned int D.16791;
  struct MonoErrorInternal * error;

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

    try
      {
        __builtin_va_start (&args, 0);
        D.16781 = &error->message;
        D.16782 = vsnprintf (D.16781, 128, msg_format, &args);
        D.16783 = (unsigned int) D.16782;
        if (D.16783 > 127) goto <D.16784>; else goto <D.16785>;
        <D.16784>:
        __builtin_va_end (&args);
        __builtin_va_start (&args, 0);
        D.16786 = monoeg_g_strdup_vprintf (msg_format, &args);
        error->full_message = D.16786;
        D.16787 = error->full_message;
        if (D.16787 == 0B) goto <D.16788>; else goto <D.16789>;
        <D.16788>:
        D.16790 = error->flags;
        D.16791 = D.16790 | 2;
        error->flags = D.16791;
        <D.16789>:
        <D.16785>:
        __builtin_va_end (&args);
      }
    finally
      {
        args = {CLOBBER};
      }
  }
}


__attribute__((visibility ("hidden")))
mono_error_prepare_exception (struct MonoError * oerror, struct MonoError * error_out)
{
  short unsigned int D.16792;
  int D.16793;
  struct MonoException * D.16794;
  const char * D.16798;
  struct MonoClass * D.16800;
  const char * D.16801;
  int D.16803;
  struct MonoImage * D.16807;
  const char * iftmp.4;
  const char * D.16811;
  int D.16820;
  const char * iftmp.5;
  const char * D.16834;
  int D.16835;
  struct MonoImage * D.16841;
  const char * iftmp.6;
  const char * iftmp.7;
  struct MonoImage * D.16862;
  struct MonoImage * D.16867;
  const char * iftmp.8;
  const char * iftmp.9;
  const char * iftmp.10;
  const char * iftmp.11;
  const char * D.16894;
  const char * D.16896;
  const char * iftmp.12;
  int D.16901;
  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.16792 = error->error_code;
  D.16793 = (int) D.16792;
  switch (D.16793) <default: <D.16510>, case 0: <D.16497>, case 1: <D.16498>, case 2: <D.16500>, case 3: <D.16501>, case 4: <D.16502>, case 5: <D.16503>, case 6: <D.16504>, case 7: <D.16505>, case 8: <D.16506>, case 9: <D.16509>>
  <D.16497>:
  D.16794 = 0B;
  return D.16794;
  <D.16498>:
  D.16798 = error->type_name;
  if (D.16798 != 0B) goto <D.16795>; else goto <D.16799>;
  <D.16799>:
  D.16800 = error->klass;
  if (D.16800 != 0B) goto <D.16795>; else goto <D.16796>;
  <D.16795>:
  D.16801 = error->member_name;
  if (D.16801 != 0B) goto <D.16802>; else goto <D.16796>;
  <D.16802>:
  type_name = get_type_name_as_mono_string (error, domain, error_out);
  D.16803 = mono_error_ok (error_out);
  if (D.16803 == 0) goto <D.16499>; else goto <D.16804>;
  <D.16804>:
  D.16801 = error->member_name;
  method_name = mono_string_new (domain, D.16801);
  if (method_name == 0B) goto <D.16805>; else goto <D.16806>;
  <D.16805>:
  mono_error_set_out_of_memory (error_out, "Could not allocate method name");
  goto <D.16499>;
  <D.16806>:
  D.16807 = mono_defaults.corlib;
  exception = mono_exception_from_name_two_strings (D.16807, "System", "MissingMethodException", type_name, method_name);
  if (exception != 0B) goto <D.16808>; else goto <D.16809>;
  <D.16808>:
  set_message_on_exception (exception, error, error_out);
  <D.16809>:
  goto <D.16797>;
  <D.16796>:
  D.16807 = mono_defaults.corlib;
  D.16811 = error->full_message;
  if (D.16811 != 0B) goto <D.16812>; else goto <D.16813>;
  <D.16812>:
  iftmp.4 = error->full_message;
  goto <D.16814>;
  <D.16813>:
  iftmp.4 = &error->message;
  <D.16814>:
  exception = mono_exception_from_name_msg (D.16807, "System", "MissingMethodException", iftmp.4);
  <D.16797>:
  goto <D.16499>;
  <D.16500>:
  D.16798 = error->type_name;
  if (D.16798 != 0B) goto <D.16815>; else goto <D.16818>;
  <D.16818>:
  D.16800 = error->klass;
  if (D.16800 != 0B) goto <D.16815>; else goto <D.16816>;
  <D.16815>:
  D.16801 = error->member_name;
  if (D.16801 != 0B) goto <D.16819>; else goto <D.16816>;
  <D.16819>:
  type_name = get_type_name_as_mono_string (error, domain, error_out);
  D.16820 = mono_error_ok (error_out);
  if (D.16820 == 0) goto <D.16499>; else goto <D.16821>;
  <D.16821>:
  D.16801 = error->member_name;
  field_name = mono_string_new (domain, D.16801);
  if (field_name == 0B) goto <D.16822>; else goto <D.16823>;
  <D.16822>:
  mono_error_set_out_of_memory (error_out, "Could not allocate field name");
  goto <D.16499>;
  <D.16823>:
  D.16807 = mono_defaults.corlib;
  exception = mono_exception_from_name_two_strings (D.16807, "System", "MissingFieldException", type_name, field_name);
  if (exception != 0B) goto <D.16824>; else goto <D.16825>;
  <D.16824>:
  set_message_on_exception (exception, error, error_out);
  <D.16825>:
  goto <D.16817>;
  <D.16816>:
  D.16807 = mono_defaults.corlib;
  D.16811 = error->full_message;
  if (D.16811 != 0B) goto <D.16827>; else goto <D.16828>;
  <D.16827>:
  iftmp.5 = error->full_message;
  goto <D.16829>;
  <D.16828>:
  iftmp.5 = &error->message;
  <D.16829>:
  exception = mono_exception_from_name_msg (D.16807, "System", "MissingFieldException", iftmp.5);
  <D.16817>:
  goto <D.16499>;
  <D.16501>:
  D.16798 = error->type_name;
  if (D.16798 != 0B) goto <D.16830>; else goto <D.16833>;
  <D.16833>:
  D.16834 = error->assembly_name;
  if (D.16834 != 0B) goto <D.16830>; else goto <D.16831>;
  <D.16830>:
  type_name = get_type_name_as_mono_string (error, domain, error_out);
  D.16835 = mono_error_ok (error_out);
  if (D.16835 == 0) goto <D.16499>; else goto <D.16836>;
  <D.16836>:
  D.16834 = error->assembly_name;
  if (D.16834 != 0B) goto <D.16837>; else goto <D.16838>;
  <D.16837>:
  D.16834 = error->assembly_name;
  assembly_name = mono_string_new (domain, D.16834);
  if (assembly_name == 0B) goto <D.16839>; else goto <D.16840>;
  <D.16839>:
  mono_error_set_out_of_memory (error_out, "Could not allocate assembly name");
  goto <D.16499>;
  <D.16840>:
  <D.16838>:
  D.16841 = mono_get_corlib ();
  exception = mono_exception_from_name_two_strings (D.16841, "System", "TypeLoadException", type_name, assembly_name);
  if (exception != 0B) goto <D.16842>; else goto <D.16843>;
  <D.16842>:
  set_message_on_exception (exception, error, error_out);
  <D.16843>:
  goto <D.16832>;
  <D.16831>:
  D.16807 = mono_defaults.corlib;
  D.16811 = error->full_message;
  if (D.16811 != 0B) goto <D.16845>; else goto <D.16846>;
  <D.16845>:
  iftmp.6 = error->full_message;
  goto <D.16847>;
  <D.16846>:
  iftmp.6 = &error->message;
  <D.16847>:
  exception = mono_exception_from_name_msg (D.16807, "System", "TypeLoadException", iftmp.6);
  <D.16832>:
  goto <D.16499>;
  <D.16502>:
  <D.16503>:
  D.16834 = error->assembly_name;
  if (D.16834 != 0B) goto <D.16848>; else goto <D.16849>;
  <D.16848>:
  D.16811 = error->full_message;
  if (D.16811 != 0B) goto <D.16851>; else goto <D.16852>;
  <D.16851>:
  iftmp.7 = error->full_message;
  goto <D.16853>;
  <D.16852>:
  iftmp.7 = &error->message;
  <D.16853>:
  msg = mono_string_new (domain, iftmp.7);
  if (msg == 0B) goto <D.16854>; else goto <D.16855>;
  <D.16854>:
  mono_error_set_out_of_memory (error_out, "Could not allocate message");
  goto <D.16499>;
  <D.16855>:
  D.16834 = error->assembly_name;
  if (D.16834 != 0B) goto <D.16856>; else goto <D.16857>;
  <D.16856>:
  D.16834 = error->assembly_name;
  assembly_name = mono_string_new (domain, D.16834);
  if (assembly_name == 0B) goto <D.16858>; else goto <D.16859>;
  <D.16858>:
  mono_error_set_out_of_memory (error_out, "Could not allocate assembly name");
  goto <D.16499>;
  <D.16859>:
  <D.16857>:
  D.16792 = error->error_code;
  if (D.16792 == 4) goto <D.16860>; else goto <D.16861>;
  <D.16860>:
  D.16862 = mono_get_corlib ();
  exception = mono_exception_from_name_two_strings (D.16862, "System.IO", "FileNotFoundException", msg, assembly_name);
  goto <D.16863>;
  <D.16861>:
  D.16807 = mono_defaults.corlib;
  exception = mono_exception_from_name_two_strings (D.16807, "System", "BadImageFormatException", msg, assembly_name);
  <D.16863>:
  goto <D.16864>;
  <D.16849>:
  D.16792 = error->error_code;
  if (D.16792 == 4) goto <D.16865>; else goto <D.16866>;
  <D.16865>:
  D.16867 = mono_get_corlib ();
  D.16811 = error->full_message;
  if (D.16811 != 0B) goto <D.16869>; else goto <D.16870>;
  <D.16869>:
  iftmp.8 = error->full_message;
  goto <D.16871>;
  <D.16870>:
  iftmp.8 = &error->message;
  <D.16871>:
  exception = mono_exception_from_name_msg (D.16867, "System.IO", "FileNotFoundException", iftmp.8);
  goto <D.16872>;
  <D.16866>:
  D.16807 = mono_defaults.corlib;
  D.16811 = error->full_message;
  if (D.16811 != 0B) goto <D.16874>; else goto <D.16875>;
  <D.16874>:
  iftmp.9 = error->full_message;
  goto <D.16876>;
  <D.16875>:
  iftmp.9 = &error->message;
  <D.16876>:
  exception = mono_exception_from_name_msg (D.16807, "System", "BadImageFormatException", iftmp.9);
  <D.16872>:
  <D.16864>:
  goto <D.16499>;
  <D.16504>:
  exception = mono_get_exception_out_of_memory ();
  goto <D.16499>;
  <D.16505>:
  D.16798 = error->type_name;
  D.16811 = error->full_message;
  if (D.16811 != 0B) goto <D.16878>; else goto <D.16879>;
  <D.16878>:
  iftmp.10 = error->full_message;
  goto <D.16880>;
  <D.16879>:
  iftmp.10 = &error->message;
  <D.16880>:
  exception = mono_get_exception_argument (D.16798, iftmp.10);
  goto <D.16499>;
  <D.16506>:
  {
    char * type_name;
    char * message;

    type_name = 0B;
    D.16800 = error->klass;
    if (D.16800 != 0B) goto <D.16881>; else goto <D.16882>;
    <D.16881>:
    D.16800 = error->klass;
    type_name = mono_type_get_full_name (D.16800);
    if (type_name == 0B) goto <D.16883>; else goto <D.16884>;
    <D.16883>:
    mono_error_set_out_of_memory (error_out, "Could not allocate message");
    goto <D.16499>;
    <D.16884>:
    <D.16882>:
    D.16801 = error->member_name;
    D.16811 = error->full_message;
    if (D.16811 != 0B) goto <D.16886>; else goto <D.16887>;
    <D.16886>:
    iftmp.11 = error->full_message;
    goto <D.16888>;
    <D.16887>:
    iftmp.11 = &error->message;
    <D.16888>:
    message = monoeg_g_strdup_printf ("Error in %s:%s %s", type_name, D.16801, iftmp.11);
    if (message == 0B) goto <D.16889>; else goto <D.16890>;
    <D.16889>:
    monoeg_g_free (type_name);
    mono_error_set_out_of_memory (error_out, "Could not allocate message");
    goto <D.16499>;
    <D.16890>:
    D.16807 = mono_defaults.corlib;
    exception = mono_exception_from_name_msg (D.16807, "System.Security", "VerificationException", message);
    monoeg_g_free (message);
    monoeg_g_free (type_name);
    goto <D.16499>;
  }
  <D.16509>:
  D.16894 = error->exception_name_space;
  if (D.16894 == 0B) goto <D.16891>; else goto <D.16895>;
  <D.16895>:
  D.16896 = error->exception_name;
  if (D.16896 == 0B) goto <D.16891>; else goto <D.16892>;
  <D.16891>:
  mono_error_set_generic_error (error_out, "System", "ExecutionEngineException", "MonoError with generic error but no exception name was supplied");
  goto <D.16893>;
  <D.16892>:
  D.16807 = mono_defaults.corlib;
  D.16894 = error->exception_name_space;
  D.16896 = error->exception_name;
  D.16811 = error->full_message;
  if (D.16811 != 0B) goto <D.16898>; else goto <D.16899>;
  <D.16898>:
  iftmp.12 = error->full_message;
  goto <D.16900>;
  <D.16899>:
  iftmp.12 = &error->message;
  <D.16900>:
  exception = mono_exception_from_name_msg (D.16807, D.16894, D.16896, iftmp.12);
  <D.16893>:
  goto <D.16499>;
  <D.16510>:
  D.16792 = error->error_code;
  D.16793 = (int) D.16792;
  mono_error_set_generic_error (error_out, "System", "ExecutionEngineException", "Invalid error-code %d", D.16793);
  <D.16499>:
  D.16901 = mono_error_ok (error_out);
  if (D.16901 == 0) goto <D.16902>; else goto <D.16903>;
  <D.16902>:
  D.16794 = 0B;
  return D.16794;
  <D.16903>:
  if (exception == 0B) goto <D.16904>; else goto <D.16905>;
  <D.16904>:
  mono_error_set_out_of_memory (error_out, "Could not allocate exception object");
  <D.16905>:
  D.16794 = exception;
  return D.16794;
}


get_type_name_as_mono_string (struct MonoErrorInternal * error, struct MonoDomain * domain, struct MonoError * error_out)
{
  const char * D.16907;
  struct MonoClass * D.16911;
  struct MonoType * D.16914;
  struct MonoString * D.16919;
  struct MonoString * res;

  res = 0B;
  D.16907 = error->type_name;
  if (D.16907 != 0B) goto <D.16908>; else goto <D.16909>;
  <D.16908>:
  D.16907 = error->type_name;
  res = mono_string_new (domain, D.16907);
  goto <D.16910>;
  <D.16909>:
  D.16911 = error->klass;
  if (D.16911 != 0B) goto <D.16912>; else goto <D.16913>;
  <D.16912>:
  {
    char * name;

    D.16911 = error->klass;
    D.16914 = &D.16911->byval_arg;
    name = mono_type_full_name (D.16914);
    if (name != 0B) goto <D.16915>; else goto <D.16916>;
    <D.16915>:
    res = mono_string_new (domain, name);
    monoeg_g_free (name);
    <D.16916>:
  }
  <D.16913>:
  <D.16910>:
  if (res == 0B) goto <D.16917>; else goto <D.16918>;
  <D.16917>:
  mono_error_set_out_of_memory (error_out, "Could not allocate type name");
  <D.16918>:
  D.16919 = res;
  return D.16919;
}


set_message_on_exception (struct MonoException * exception, struct MonoErrorInternal * error, struct MonoError * error_out)
{
  struct MonoDomain * D.16921;
  const char * iftmp.13;
  const char * D.16923;
  struct MonoString * * D.16929;
  struct MonoString * msg;

  D.16921 = mono_domain_get ();
  D.16923 = error->full_message;
  if (D.16923 != 0B) goto <D.16924>; else goto <D.16925>;
  <D.16924>:
  iftmp.13 = error->full_message;
  goto <D.16926>;
  <D.16925>:
  iftmp.13 = &error->message;
  <D.16926>:
  msg = mono_string_new (D.16921, iftmp.13);
  if (msg != 0B) goto <D.16927>; else goto <D.16928>;
  <D.16927>:
  D.16929 = &exception->message;
  mono_gc_wbarrier_set_field (exception, D.16929, msg);
  goto <D.16930>;
  <D.16928>:
  mono_error_set_out_of_memory (error_out, "Could not allocate exception object");
  <D.16930>:
}


__attribute__((visibility ("hidden")))
mono_error_raise_exception (struct MonoError * target_error)
{
  int D.16931;
  int D.16934;
  int D.16937;
  _Bool D.16938;
  long int D.16939;
  long int D.16940;
  struct MonoError error;
  struct MonoException * ex;

  try
    {
      D.16931 = mono_error_ok (target_error);
      if (D.16931 != 0) goto <D.16932>; else goto <D.16933>;
      <D.16932>:
      return;
      <D.16933>:
      ex = mono_error_prepare_exception (target_error, &error);
      D.16934 = mono_error_ok (&error);
      if (D.16934 == 0) goto <D.16935>; else goto <D.16936>;
      <D.16935>:
      {
        struct MonoError second_chance;

        try
          {
            ex = mono_error_prepare_exception (&error, &second_chance);
            D.16937 = mono_error_ok (&second_chance);
            D.16938 = D.16937 == 0;
            D.16939 = (long int) D.16938;
            D.16940 = __builtin_expect (D.16939, 0);
            if (D.16940 != 0) goto <D.16941>; else goto <D.16942>;
            <D.16941>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mono-error.c", 646, "mono_error_ok (&second_chance)");
            <D.16942>:
            mono_error_cleanup (&error);
          }
        finally
          {
            second_chance = {CLOBBER};
          }
      }
      <D.16936>:
      mono_error_cleanup (target_error);
      mono_raise_exception (ex);
    }
  finally
    {
      error = {CLOBBER};
    }
}