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

  error = oerror;
  if (0 != 0) goto <D.18561>; else goto <D.18562>;
  <D.18561>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mono-error.c", 47, "sizeof (MonoError) == sizeof (MonoErrorInternal)");
  <D.18562>:
  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.18563;
  const char * D.18566;
  short unsigned int D.18567;
  int D.18568;
  int D.18569;
  const char * D.18572;
  const char * D.18573;
  const char * D.18574;
  const char * D.18575;
  const char * D.18576;
  struct MonoErrorInternal * error;

  error = oerror;
  D.18563 = error->error_code;
  if (D.18563 == 0) goto <D.18564>; else goto <D.18565>;
  <D.18564>:
  return;
  <D.18565>:
  D.18566 = error->full_message;
  monoeg_g_free (D.18566);
  D.18567 = error->flags;
  D.18568 = (int) D.18567;
  D.18569 = D.18568 & 1;
  if (D.18569 == 0) goto <D.18570>; else goto <D.18571>;
  <D.18570>:
  return;
  <D.18571>:
  D.18572 = error->type_name;
  monoeg_g_free (D.18572);
  D.18573 = error->assembly_name;
  monoeg_g_free (D.18573);
  D.18574 = error->member_name;
  monoeg_g_free (D.18574);
  D.18575 = error->exception_name_space;
  monoeg_g_free (D.18575);
  D.18576 = error->exception_name;
  monoeg_g_free (D.18576);
}


mono_error_ok (struct MonoError * error)
{
  mono_bool D.18578;
  short unsigned int D.18579;
  _Bool D.18580;

  D.18579 = error->error_code;
  D.18580 = D.18579 == 0;
  D.18578 = (mono_bool) D.18580;
  return D.18578;
}


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

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


mono_error_get_message (struct MonoError * oerror)
{
  short unsigned int D.18584;
  const char * D.18587;
  const char * iftmp.0;
  const char * D.18589;
  struct MonoErrorInternal * error;

  error = oerror;
  D.18584 = error->error_code;
  if (D.18584 == 0) goto <D.18585>; else goto <D.18586>;
  <D.18585>:
  D.18587 = 0B;
  return D.18587;
  <D.18586>:
  D.18589 = error->full_message;
  if (D.18589 != 0B) goto <D.18590>; else goto <D.18591>;
  <D.18590>:
  iftmp.0 = error->full_message;
  goto <D.18592>;
  <D.18591>:
  iftmp.0 = &error->message;
  <D.18592>:
  D.18587 = iftmp.0;
  return D.18587;
}


mono_error_dup_strings (struct MonoError * oerror, gboolean dup_strings)
{
  short unsigned int D.18594;
  short unsigned int D.18595;
  const char * D.18598;
  gchar * D.18601;
  short unsigned int D.18604;
  const char * D.18605;
  gchar * D.18608;
  const char * D.18611;
  gchar * D.18614;
  const char * D.18617;
  gchar * D.18620;
  const char * D.18623;
  gchar * D.18626;
  struct MonoErrorInternal * error;

  error = oerror;
  D.18594 = error->flags;
  D.18595 = D.18594 | 1;
  error->flags = D.18595;
  if (dup_strings != 0) goto <D.18596>; else goto <D.18597>;
  <D.18596>:
  D.18598 = error->type_name;
  if (D.18598 != 0B) goto <D.18599>; else goto <D.18600>;
  <D.18599>:
  D.18598 = error->type_name;
  D.18601 = monoeg_strdup (D.18598);
  error->type_name = D.18601;
  D.18598 = error->type_name;
  if (D.18598 == 0B) goto <D.18602>; else goto <D.18603>;
  <D.18602>:
  D.18594 = error->flags;
  D.18604 = D.18594 | 2;
  error->flags = D.18604;
  <D.18603>:
  <D.18600>:
  D.18605 = error->assembly_name;
  if (D.18605 != 0B) goto <D.18606>; else goto <D.18607>;
  <D.18606>:
  D.18605 = error->assembly_name;
  D.18608 = monoeg_strdup (D.18605);
  error->assembly_name = D.18608;
  D.18605 = error->assembly_name;
  if (D.18605 == 0B) goto <D.18609>; else goto <D.18610>;
  <D.18609>:
  D.18594 = error->flags;
  D.18604 = D.18594 | 2;
  error->flags = D.18604;
  <D.18610>:
  <D.18607>:
  D.18611 = error->member_name;
  if (D.18611 != 0B) goto <D.18612>; else goto <D.18613>;
  <D.18612>:
  D.18611 = error->member_name;
  D.18614 = monoeg_strdup (D.18611);
  error->member_name = D.18614;
  D.18611 = error->member_name;
  if (D.18611 == 0B) goto <D.18615>; else goto <D.18616>;
  <D.18615>:
  D.18594 = error->flags;
  D.18604 = D.18594 | 2;
  error->flags = D.18604;
  <D.18616>:
  <D.18613>:
  D.18617 = error->exception_name_space;
  if (D.18617 != 0B) goto <D.18618>; else goto <D.18619>;
  <D.18618>:
  D.18617 = error->exception_name_space;
  D.18620 = monoeg_strdup (D.18617);
  error->exception_name_space = D.18620;
  D.18617 = error->exception_name_space;
  if (D.18617 == 0B) goto <D.18621>; else goto <D.18622>;
  <D.18621>:
  D.18594 = error->flags;
  D.18604 = D.18594 | 2;
  error->flags = D.18604;
  <D.18622>:
  <D.18619>:
  D.18623 = error->exception_name;
  if (D.18623 != 0B) goto <D.18624>; else goto <D.18625>;
  <D.18624>:
  D.18623 = error->exception_name;
  D.18626 = monoeg_strdup (D.18623);
  error->exception_name = D.18626;
  D.18623 = error->exception_name;
  if (D.18623 == 0B) goto <D.18627>; else goto <D.18628>;
  <D.18627>:
  D.18594 = error->flags;
  D.18604 = D.18594 | 2;
  error->flags = D.18604;
  <D.18628>:
  <D.18625>:
  <D.18597>:
}


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

  if (str != 0B) goto <D.18629>; else goto <D.18630>;
  <D.18629>:
  D.18631 = __strdup (str);
  return D.18631;
  <D.18630>:
  D.18631 = 0B;
  return D.18631;
}


mono_error_set_error (struct MonoError * oerror, int error_code, const char * msg_format)
{
  short unsigned int D.18633;
  char[128] * D.18634;
  int D.18635;
  unsigned int D.18636;
  gchar * D.18639;
  const char * D.18640;
  short unsigned int D.18643;
  short unsigned int D.18644;
  struct MonoErrorInternal * error;

  error = oerror;
  mono_error_prepare (error);
  D.18633 = (short unsigned int) error_code;
  error->error_code = D.18633;
  {
    struct va_list args;

    try
      {
        __builtin_va_start (&args, 0);
        D.18634 = &error->message;
        D.18635 = vsnprintf (D.18634, 128, msg_format, args);
        D.18636 = (unsigned int) D.18635;
        if (D.18636 > 127) goto <D.18637>; else goto <D.18638>;
        <D.18637>:
        __builtin_va_end (&args);
        __builtin_va_start (&args, 0);
        D.18639 = monoeg_g_strdup_vprintf (msg_format, args);
        error->full_message = D.18639;
        D.18640 = error->full_message;
        if (D.18640 == 0B) goto <D.18641>; else goto <D.18642>;
        <D.18641>:
        D.18643 = error->flags;
        D.18644 = D.18643 | 2;
        error->flags = D.18644;
        <D.18642>:
        <D.18638>:
        __builtin_va_end (&args);
      }
    finally
      {
        args = {CLOBBER};
      }
  }
}


mono_error_prepare (struct MonoErrorInternal * error)
{
  short unsigned int D.18645;
  const char * D.18648;
  const char * D.18649;
  const char * D.18650;
  const char * D.18651;
  const char * D.18652;

  D.18645 = error->error_code;
  if (D.18645 != 0) goto <D.18646>; else goto <D.18647>;
  <D.18646>:
  return;
  <D.18647>:
  error->exception_name = 0B;
  D.18648 = error->exception_name;
  error->exception_name_space = D.18648;
  D.18649 = error->exception_name_space;
  error->full_message = D.18649;
  D.18650 = error->full_message;
  error->member_name = D.18650;
  D.18651 = error->member_name;
  error->assembly_name = D.18651;
  D.18652 = error->assembly_name;
  error->type_name = D.18652;
  error->klass = 0B;
  error->message[0] = 0;
}


vsnprintf (char * restrict __s, size_t __n, const char * restrict __fmt, struct __gnuc_va_list __ap)
{
  int D.18654;
  unsigned int D.18655;

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


mono_error_set_assembly_load (struct MonoError * oerror, const char * assembly_name, const char * msg_format)
{
  char[128] * D.18657;
  int D.18658;
  unsigned int D.18659;
  gchar * D.18662;
  const char * D.18663;
  short unsigned int D.18666;
  short unsigned int D.18667;
  struct MonoErrorInternal * error;

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

    try
      {
        __builtin_va_start (&args, 0);
        D.18657 = &error->message;
        D.18658 = vsnprintf (D.18657, 128, msg_format, args);
        D.18659 = (unsigned int) D.18658;
        if (D.18659 > 127) goto <D.18660>; else goto <D.18661>;
        <D.18660>:
        __builtin_va_end (&args);
        __builtin_va_start (&args, 0);
        D.18662 = monoeg_g_strdup_vprintf (msg_format, args);
        error->full_message = D.18662;
        D.18663 = error->full_message;
        if (D.18663 == 0B) goto <D.18664>; else goto <D.18665>;
        <D.18664>:
        D.18666 = error->flags;
        D.18667 = D.18666 | 2;
        error->flags = D.18667;
        <D.18665>:
        <D.18661>:
        __builtin_va_end (&args);
      }
    finally
      {
        args = {CLOBBER};
      }
  }
}


mono_error_set_assembly_name (struct MonoError * oerror, const char * assembly_name)
{
  short unsigned int D.18668;
  _Bool D.18669;
  long int D.18670;
  long int D.18671;
  struct MonoErrorInternal * error;

  error = oerror;
  D.18668 = error->error_code;
  D.18669 = D.18668 == 0;
  D.18670 = (long int) D.18669;
  D.18671 = __builtin_expect (D.18670, 0);
  if (D.18671 != 0) goto <D.18672>; else goto <D.18673>;
  <D.18672>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mono-error.c", 140, "error->error_code != MONO_ERROR_NONE");
  <D.18673>:
  error->assembly_name = assembly_name;
}


mono_error_set_type_load_class (struct MonoError * oerror, struct MonoClass * klass, const char * msg_format)
{
  char[128] * D.18674;
  int D.18675;
  unsigned int D.18676;
  gchar * D.18679;
  const char * D.18680;
  short unsigned int D.18683;
  short unsigned int D.18684;
  struct MonoErrorInternal * error;

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

    try
      {
        __builtin_va_start (&args, 0);
        D.18674 = &error->message;
        D.18675 = vsnprintf (D.18674, 128, msg_format, args);
        D.18676 = (unsigned int) D.18675;
        if (D.18676 > 127) goto <D.18677>; else goto <D.18678>;
        <D.18677>:
        __builtin_va_end (&args);
        __builtin_va_start (&args, 0);
        D.18679 = monoeg_g_strdup_vprintf (msg_format, args);
        error->full_message = D.18679;
        D.18680 = error->full_message;
        if (D.18680 == 0B) goto <D.18681>; else goto <D.18682>;
        <D.18681>:
        D.18683 = error->flags;
        D.18684 = D.18683 | 2;
        error->flags = D.18684;
        <D.18682>:
        <D.18678>:
        __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.18685;
  int D.18686;
  unsigned int D.18687;
  gchar * D.18690;
  const char * D.18691;
  short unsigned int D.18694;
  short unsigned int D.18695;
  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 va_list args;

    try
      {
        __builtin_va_start (&args, 0);
        D.18685 = &error->message;
        D.18686 = vsnprintf (D.18685, 128, msg_format, args);
        D.18687 = (unsigned int) D.18686;
        if (D.18687 > 127) goto <D.18688>; else goto <D.18689>;
        <D.18688>:
        __builtin_va_end (&args);
        __builtin_va_start (&args, 0);
        D.18690 = monoeg_g_strdup_vprintf (msg_format, args);
        error->full_message = D.18690;
        D.18691 = error->full_message;
        if (D.18691 == 0B) goto <D.18692>; else goto <D.18693>;
        <D.18692>:
        D.18694 = error->flags;
        D.18695 = D.18694 | 2;
        error->flags = D.18695;
        <D.18693>:
        <D.18689>:
        __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.18696;
  int D.18697;
  unsigned int D.18698;
  gchar * D.18701;
  const char * D.18702;
  short unsigned int D.18705;
  short unsigned int D.18706;
  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 va_list args;

    try
      {
        __builtin_va_start (&args, 0);
        D.18696 = &error->message;
        D.18697 = vsnprintf (D.18696, 128, msg_format, args);
        D.18698 = (unsigned int) D.18697;
        if (D.18698 > 127) goto <D.18699>; else goto <D.18700>;
        <D.18699>:
        __builtin_va_end (&args);
        __builtin_va_start (&args, 0);
        D.18701 = monoeg_g_strdup_vprintf (msg_format, args);
        error->full_message = D.18701;
        D.18702 = error->full_message;
        if (D.18702 == 0B) goto <D.18703>; else goto <D.18704>;
        <D.18703>:
        D.18705 = error->flags;
        D.18706 = D.18705 | 2;
        error->flags = D.18706;
        <D.18704>:
        <D.18700>:
        __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.18707;
  int D.18708;
  unsigned int D.18709;
  gchar * D.18712;
  const char * D.18713;
  short unsigned int D.18716;
  short unsigned int D.18717;
  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 va_list args;

    try
      {
        __builtin_va_start (&args, 0);
        D.18707 = &error->message;
        D.18708 = vsnprintf (D.18707, 128, msg_format, args);
        D.18709 = (unsigned int) D.18708;
        if (D.18709 > 127) goto <D.18710>; else goto <D.18711>;
        <D.18710>:
        __builtin_va_end (&args);
        __builtin_va_start (&args, 0);
        D.18712 = monoeg_g_strdup_vprintf (msg_format, args);
        error->full_message = D.18712;
        D.18713 = error->full_message;
        if (D.18713 == 0B) goto <D.18714>; else goto <D.18715>;
        <D.18714>:
        D.18716 = error->flags;
        D.18717 = D.18716 | 2;
        error->flags = D.18717;
        <D.18715>:
        <D.18711>:
        __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.18718;
  int D.18719;
  unsigned int D.18720;
  gchar * D.18723;
  const char * D.18724;
  short unsigned int D.18727;
  short unsigned int D.18728;
  struct MonoErrorInternal * error;

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

    try
      {
        __builtin_va_start (&args, 0);
        D.18718 = &error->message;
        D.18719 = vsnprintf (D.18718, 128, msg_format, args);
        D.18720 = (unsigned int) D.18719;
        if (D.18720 > 127) goto <D.18721>; else goto <D.18722>;
        <D.18721>:
        __builtin_va_end (&args);
        __builtin_va_start (&args, 0);
        D.18723 = monoeg_g_strdup_vprintf (msg_format, args);
        error->full_message = D.18723;
        D.18724 = error->full_message;
        if (D.18724 == 0B) goto <D.18725>; else goto <D.18726>;
        <D.18725>:
        D.18727 = error->flags;
        D.18728 = D.18727 | 2;
        error->flags = D.18728;
        <D.18726>:
        <D.18722>:
        __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.18733;
  int D.18734;
  unsigned int D.18735;
  gchar * D.18738;
  const char * D.18739;
  short unsigned int D.18742;
  short unsigned int D.18743;
  struct MonoErrorInternal * error;

  error = oerror;
  mono_error_prepare (error);
  error->error_code = 5;
  if (image != 0B) goto <D.18730>; else goto <D.18731>;
  <D.18730>:
  iftmp.1 = mono_image_get_name (image);
  goto <D.18732>;
  <D.18731>:
  iftmp.1 = "<no_image>";
  <D.18732>:
  error->assembly_name = iftmp.1;
  {
    struct va_list args;

    try
      {
        __builtin_va_start (&args, 0);
        D.18733 = &error->message;
        D.18734 = vsnprintf (D.18733, 128, msg_format, args);
        D.18735 = (unsigned int) D.18734;
        if (D.18735 > 127) goto <D.18736>; else goto <D.18737>;
        <D.18736>:
        __builtin_va_end (&args);
        __builtin_va_start (&args, 0);
        D.18738 = monoeg_g_strdup_vprintf (msg_format, args);
        error->full_message = D.18738;
        D.18739 = error->full_message;
        if (D.18739 == 0B) goto <D.18740>; else goto <D.18741>;
        <D.18740>:
        D.18742 = error->flags;
        D.18743 = D.18742 | 2;
        error->flags = D.18743;
        <D.18741>:
        <D.18737>:
        __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.18744;
  int D.18745;
  unsigned int D.18746;
  gchar * D.18749;
  const char * D.18750;
  short unsigned int D.18753;
  short unsigned int D.18754;
  struct MonoErrorInternal * error;

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

    try
      {
        __builtin_va_start (&args, 0);
        D.18744 = &error->message;
        D.18745 = vsnprintf (D.18744, 128, msg_format, args);
        D.18746 = (unsigned int) D.18745;
        if (D.18746 > 127) goto <D.18747>; else goto <D.18748>;
        <D.18747>:
        __builtin_va_end (&args);
        __builtin_va_start (&args, 0);
        D.18749 = monoeg_g_strdup_vprintf (msg_format, args);
        error->full_message = D.18749;
        D.18750 = error->full_message;
        if (D.18750 == 0B) goto <D.18751>; else goto <D.18752>;
        <D.18751>:
        D.18753 = error->flags;
        D.18754 = D.18753 | 2;
        error->flags = D.18754;
        <D.18752>:
        <D.18748>:
        __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.18757;
  int D.18758;
  char * D.18759;
  const char * D.18760;
  char[128] * D.18761;
  struct MonoClass * D.18762;
  char * D.18763;
  int D.18764;
  char * D.18768;
  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.18755>; else goto <D.18756>;
  <D.18755>:
  mono_error_set_generic_error (oerror, "System", "ExecutionEngineException", "Runtime tried to produce a mono-error from an empty loader-error");
  return;
  <D.18756>:
  D.18757 = loader_error->exception_type;
  D.18758 = (int) D.18757;
  switch (D.18758) <default: <D.18475>, case 0: <D.18459>, case 1: <D.18461>, case 2: <D.18462>, case 3: <D.18463>, case 4: <D.18464>, case 5: <D.18465>, case 6: <D.18466>, case 7: <D.18467>, case 8: <D.18468>, case 9: <D.18469>, case 10: <D.18470>, case 11: <D.18472>, case 12: <D.18473>, case 13: <D.18471>, case 14: <D.18474>>
  <D.18459>:
  mono_error_set_generic_error (oerror, "System", "ExecutionEngineException", "Runtime tried to produce a mono-error from a non-error loader-error");
  goto <D.18460>;
  <D.18461>:
  <D.18462>:
  mono_error_set_generic_error (oerror, "System.Security", "SecurityException", "Failed for unknown reasons.");
  goto <D.18460>;
  <D.18463>:
  mono_error_set_generic_error (oerror, "System", "InvalidProgramException", "Failed for unknown reasons.");
  goto <D.18460>;
  <D.18464>:
  mono_error_set_generic_error (oerror, "System.Security", "VerificationException", "Failed for unknown reasons.");
  goto <D.18460>;
  <D.18465>:
  error->error_code = 1;
  D.18759 = loader_error->class_name;
  mono_error_set_type_name (oerror, D.18759);
  D.18760 = loader_error->member_name;
  mono_error_set_member_name (oerror, D.18760);
  D.18761 = &error->message;
  monoeg_g_snprintf (D.18761, 128, "Failed for unknown reasons.");
  goto <D.18460>;
  <D.18466>:
  D.18762 = loader_error->klass;
  D.18760 = loader_error->member_name;
  mono_error_set_field_load (oerror, D.18762, D.18760, "Failed for unknown reasons.");
  goto <D.18460>;
  <D.18467>:
  D.18759 = loader_error->class_name;
  D.18763 = loader_error->assembly_name;
  mono_error_set_type_load_name (oerror, D.18759, D.18763, "Failed for unknown reasons.");
  goto <D.18460>;
  <D.18468>:
  D.18764 = loader_error->ref_only;
  if (D.18764 != 0) goto <D.18765>; else goto <D.18766>;
  <D.18765>:
  D.18763 = loader_error->assembly_name;
  mono_error_set_assembly_load (oerror, D.18763, "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.18767>;
  <D.18766>:
  D.18763 = loader_error->assembly_name;
  mono_error_set_assembly_load (oerror, D.18763, "Could not load file or assembly or one of its dependencies.");
  <D.18767>:
  goto <D.18460>;
  <D.18469>:
  mono_error_set_generic_error (oerror, "System", "MethodAccessException", "Failed for unknown reasons.");
  goto <D.18460>;
  <D.18470>:
  mono_error_set_generic_error (oerror, "System", "FieldAccessException", "Failed for unknown reasons.");
  goto <D.18460>;
  <D.18471>:
  <D.18472>:
  D.18757 = loader_error->exception_type;
  D.18758 = (int) D.18757;
  mono_error_set_generic_error (oerror, "System", "ExecutionEngineException", "Runtime tried to produce a mono-error from JIT internal error %d", D.18758);
  goto <D.18460>;
  <D.18473>:
  D.18768 = loader_error->msg;
  mono_error_set_bad_image_name (oerror, "<unknown>", "%s", D.18768);
  goto <D.18460>;
  <D.18474>:
  mono_error_set_out_of_memory (oerror, "Failed for unknown reasons.");
  goto <D.18460>;
  <D.18475>:
  D.18757 = loader_error->exception_type;
  D.18758 = (int) D.18757;
  mono_error_set_generic_error (oerror, "System", "ExecutionEngineException", "Runtime tried to produce an unknown loader-error %d", D.18758);
  goto <D.18460>;
  <D.18460>:
  mono_error_dup_strings (oerror, 1);
  mono_loader_clear_error ();
}


mono_loader_set_error_from_mono_error (struct MonoError * oerror)
{
  short unsigned int D.18770;
  int D.18771;
  const char * D.18772;
  const char * D.18773;
  struct MonoClass * D.18774;
  const char * D.18775;
  const char * D.18776;
  const char * D.18777;
  const gchar * iftmp.2;
  const char * D.18779;
  gchar * D.18783;
  const char * iftmp.3;
  gchar * D.18788;
  struct MonoErrorInternal * error;

  error = oerror;
  D.18770 = error->error_code;
  D.18771 = (int) D.18770;
  switch (D.18771) <default: <D.18492>, case 1: <D.18486>, case 2: <D.18488>, case 3: <D.18489>, case 4: <D.18490>, case 5: <D.18491>>
  <D.18486>:
  D.18772 = get_type_name (error);
  D.18773 = error->member_name;
  mono_loader_set_error_method_load (D.18772, D.18773);
  goto <D.18487>;
  <D.18488>:
  D.18774 = error->klass;
  D.18773 = error->member_name;
  mono_loader_set_error_field_load (D.18774, D.18773);
  goto <D.18487>;
  <D.18489>:
  D.18775 = get_type_name (error);
  D.18776 = get_assembly_name (error);
  mono_loader_set_error_type_load (D.18775, D.18776);
  goto <D.18487>;
  <D.18490>:
  D.18777 = get_assembly_name (error);
  mono_loader_set_error_assembly_load (D.18777, 0);
  goto <D.18487>;
  <D.18491>:
  D.18779 = error->full_message;
  if (D.18779 != 0B) goto <D.18780>; else goto <D.18781>;
  <D.18780>:
  iftmp.2 = error->full_message;
  goto <D.18782>;
  <D.18781>:
  iftmp.2 = &error->message;
  <D.18782>:
  D.18783 = monoeg_strdup (iftmp.2);
  mono_loader_set_error_bad_image (D.18783);
  goto <D.18487>;
  <D.18492>:
  D.18779 = error->full_message;
  if (D.18779 != 0B) goto <D.18785>; else goto <D.18786>;
  <D.18785>:
  iftmp.3 = error->full_message;
  goto <D.18787>;
  <D.18786>:
  iftmp.3 = &error->message;
  <D.18787>:
  D.18788 = monoeg_g_strdup_printf ("Non translatable error: %s", iftmp.3);
  mono_loader_set_error_bad_image (D.18788);
  <D.18487>:
}


get_type_name (struct MonoErrorInternal * error)
{
  const char * D.18789;
  const char * D.18792;
  struct MonoClass * D.18793;

  D.18789 = error->type_name;
  if (D.18789 != 0B) goto <D.18790>; else goto <D.18791>;
  <D.18790>:
  D.18792 = error->type_name;
  return D.18792;
  <D.18791>:
  D.18793 = error->klass;
  if (D.18793 != 0B) goto <D.18794>; else goto <D.18795>;
  <D.18794>:
  D.18793 = error->klass;
  D.18792 = D.18793->name;
  return D.18792;
  <D.18795>:
  D.18792 = "<unknown type>";
  return D.18792;
}


get_assembly_name (struct MonoErrorInternal * error)
{
  const char * D.18797;
  const char * D.18800;
  struct MonoClass * D.18801;
  struct MonoImage * D.18804;

  D.18797 = error->assembly_name;
  if (D.18797 != 0B) goto <D.18798>; else goto <D.18799>;
  <D.18798>:
  D.18800 = error->assembly_name;
  return D.18800;
  <D.18799>:
  D.18801 = error->klass;
  if (D.18801 != 0B) goto <D.18802>; else goto <D.18803>;
  <D.18802>:
  D.18801 = error->klass;
  D.18804 = D.18801->image;
  if (D.18804 != 0B) goto <D.18805>; else goto <D.18806>;
  <D.18805>:
  D.18801 = error->klass;
  D.18804 = D.18801->image;
  D.18800 = D.18804->name;
  return D.18800;
  <D.18806>:
  <D.18803>:
  D.18800 = "<unknown assembly>";
  return D.18800;
}


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

  try
    {
      error = oerror;
      mono_error_prepare (error);
      error->error_code = 6;
      __builtin_va_start (&args, 0);
      D.18808 = &error->message;
      vsnprintf (D.18808, 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.18809;
  int D.18810;
  unsigned int D.18811;
  gchar * D.18814;
  const char * D.18815;
  short unsigned int D.18818;
  short unsigned int D.18819;
  struct MonoErrorInternal * error;

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

    try
      {
        __builtin_va_start (&args, 0);
        D.18809 = &error->message;
        D.18810 = vsnprintf (D.18809, 128, msg_format, args);
        D.18811 = (unsigned int) D.18810;
        if (D.18811 > 127) goto <D.18812>; else goto <D.18813>;
        <D.18812>:
        __builtin_va_end (&args);
        __builtin_va_start (&args, 0);
        D.18814 = monoeg_g_strdup_vprintf (msg_format, args);
        error->full_message = D.18814;
        D.18815 = error->full_message;
        if (D.18815 == 0B) goto <D.18816>; else goto <D.18817>;
        <D.18816>:
        D.18818 = error->flags;
        D.18819 = D.18818 | 2;
        error->flags = D.18819;
        <D.18817>:
        <D.18813>:
        __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.18820;
  char * D.18823;
  char[128] * D.18824;
  int D.18825;
  unsigned int D.18826;
  gchar * D.18829;
  const char * D.18830;
  short unsigned int D.18833;
  short unsigned int D.18834;
  struct MonoErrorInternal * error;

  error = oerror;
  mono_error_prepare (error);
  error->error_code = 8;
  D.18820 = method->klass;
  mono_error_set_class (oerror, D.18820);
  if (method != 0B) goto <D.18821>; else goto <D.18822>;
  <D.18821>:
  D.18823 = mono_method_full_name (method, 1);
  mono_error_set_member_name (oerror, D.18823);
  <D.18822>:
  {
    struct va_list args;

    try
      {
        __builtin_va_start (&args, 0);
        D.18824 = &error->message;
        D.18825 = vsnprintf (D.18824, 128, msg_format, args);
        D.18826 = (unsigned int) D.18825;
        if (D.18826 > 127) goto <D.18827>; else goto <D.18828>;
        <D.18827>:
        __builtin_va_end (&args);
        __builtin_va_start (&args, 0);
        D.18829 = monoeg_g_strdup_vprintf (msg_format, args);
        error->full_message = D.18829;
        D.18830 = error->full_message;
        if (D.18830 == 0B) goto <D.18831>; else goto <D.18832>;
        <D.18831>:
        D.18833 = error->flags;
        D.18834 = D.18833 | 2;
        error->flags = D.18834;
        <D.18832>:
        <D.18828>:
        __builtin_va_end (&args);
      }
    finally
      {
        args = {CLOBBER};
      }
  }
}


mono_error_prepare_exception (struct MonoError * oerror, struct MonoError * error_out)
{
  short unsigned int D.18835;
  int D.18836;
  struct MonoException * D.18837;
  const char * D.18841;
  struct MonoClass * D.18843;
  const char * D.18844;
  int D.18846;
  struct MonoImage * D.18850;
  const char * iftmp.4;
  const char * D.18854;
  int D.18863;
  const char * iftmp.5;
  const char * D.18877;
  int D.18878;
  struct MonoImage * D.18884;
  const char * iftmp.6;
  const char * iftmp.7;
  struct MonoImage * D.18905;
  struct MonoImage * D.18910;
  const char * iftmp.8;
  const char * iftmp.9;
  const char * iftmp.10;
  const char * iftmp.11;
  const char * D.18937;
  const char * D.18939;
  const char * iftmp.12;
  int D.18944;
  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.18835 = error->error_code;
  D.18836 = (int) D.18835;
  switch (D.18836) <default: <D.18551>, case 0: <D.18538>, case 1: <D.18539>, case 2: <D.18541>, case 3: <D.18542>, case 4: <D.18543>, case 5: <D.18544>, case 6: <D.18545>, case 7: <D.18546>, case 8: <D.18547>, case 9: <D.18550>>
  <D.18538>:
  D.18837 = 0B;
  return D.18837;
  <D.18539>:
  D.18841 = error->type_name;
  if (D.18841 != 0B) goto <D.18838>; else goto <D.18842>;
  <D.18842>:
  D.18843 = error->klass;
  if (D.18843 != 0B) goto <D.18838>; else goto <D.18839>;
  <D.18838>:
  D.18844 = error->member_name;
  if (D.18844 != 0B) goto <D.18845>; else goto <D.18839>;
  <D.18845>:
  type_name = get_type_name_as_mono_string (error, domain, error_out);
  D.18846 = mono_error_ok (error_out);
  if (D.18846 == 0) goto <D.18540>; else goto <D.18847>;
  <D.18847>:
  D.18844 = error->member_name;
  method_name = mono_string_new (domain, D.18844);
  if (method_name == 0B) goto <D.18848>; else goto <D.18849>;
  <D.18848>:
  mono_error_set_out_of_memory (error_out, "Could not allocate method name");
  goto <D.18540>;
  <D.18849>:
  D.18850 = mono_defaults.corlib;
  exception = mono_exception_from_name_two_strings (D.18850, "System", "MissingMethodException", type_name, method_name);
  if (exception != 0B) goto <D.18851>; else goto <D.18852>;
  <D.18851>:
  set_message_on_exception (exception, error, error_out);
  <D.18852>:
  goto <D.18840>;
  <D.18839>:
  D.18850 = mono_defaults.corlib;
  D.18854 = error->full_message;
  if (D.18854 != 0B) goto <D.18855>; else goto <D.18856>;
  <D.18855>:
  iftmp.4 = error->full_message;
  goto <D.18857>;
  <D.18856>:
  iftmp.4 = &error->message;
  <D.18857>:
  exception = mono_exception_from_name_msg (D.18850, "System", "MissingMethodException", iftmp.4);
  <D.18840>:
  goto <D.18540>;
  <D.18541>:
  D.18841 = error->type_name;
  if (D.18841 != 0B) goto <D.18858>; else goto <D.18861>;
  <D.18861>:
  D.18843 = error->klass;
  if (D.18843 != 0B) goto <D.18858>; else goto <D.18859>;
  <D.18858>:
  D.18844 = error->member_name;
  if (D.18844 != 0B) goto <D.18862>; else goto <D.18859>;
  <D.18862>:
  type_name = get_type_name_as_mono_string (error, domain, error_out);
  D.18863 = mono_error_ok (error_out);
  if (D.18863 == 0) goto <D.18540>; else goto <D.18864>;
  <D.18864>:
  D.18844 = error->member_name;
  field_name = mono_string_new (domain, D.18844);
  if (field_name == 0B) goto <D.18865>; else goto <D.18866>;
  <D.18865>:
  mono_error_set_out_of_memory (error_out, "Could not allocate field name");
  goto <D.18540>;
  <D.18866>:
  D.18850 = mono_defaults.corlib;
  exception = mono_exception_from_name_two_strings (D.18850, "System", "MissingFieldException", type_name, field_name);
  if (exception != 0B) goto <D.18867>; else goto <D.18868>;
  <D.18867>:
  set_message_on_exception (exception, error, error_out);
  <D.18868>:
  goto <D.18860>;
  <D.18859>:
  D.18850 = mono_defaults.corlib;
  D.18854 = error->full_message;
  if (D.18854 != 0B) goto <D.18870>; else goto <D.18871>;
  <D.18870>:
  iftmp.5 = error->full_message;
  goto <D.18872>;
  <D.18871>:
  iftmp.5 = &error->message;
  <D.18872>:
  exception = mono_exception_from_name_msg (D.18850, "System", "MissingFieldException", iftmp.5);
  <D.18860>:
  goto <D.18540>;
  <D.18542>:
  D.18841 = error->type_name;
  if (D.18841 != 0B) goto <D.18873>; else goto <D.18876>;
  <D.18876>:
  D.18877 = error->assembly_name;
  if (D.18877 != 0B) goto <D.18873>; else goto <D.18874>;
  <D.18873>:
  type_name = get_type_name_as_mono_string (error, domain, error_out);
  D.18878 = mono_error_ok (error_out);
  if (D.18878 == 0) goto <D.18540>; else goto <D.18879>;
  <D.18879>:
  D.18877 = error->assembly_name;
  if (D.18877 != 0B) goto <D.18880>; else goto <D.18881>;
  <D.18880>:
  D.18877 = error->assembly_name;
  assembly_name = mono_string_new (domain, D.18877);
  if (assembly_name == 0B) goto <D.18882>; else goto <D.18883>;
  <D.18882>:
  mono_error_set_out_of_memory (error_out, "Could not allocate assembly name");
  goto <D.18540>;
  <D.18883>:
  <D.18881>:
  D.18884 = mono_get_corlib ();
  exception = mono_exception_from_name_two_strings (D.18884, "System", "TypeLoadException", type_name, assembly_name);
  if (exception != 0B) goto <D.18885>; else goto <D.18886>;
  <D.18885>:
  set_message_on_exception (exception, error, error_out);
  <D.18886>:
  goto <D.18875>;
  <D.18874>:
  D.18850 = mono_defaults.corlib;
  D.18854 = error->full_message;
  if (D.18854 != 0B) goto <D.18888>; else goto <D.18889>;
  <D.18888>:
  iftmp.6 = error->full_message;
  goto <D.18890>;
  <D.18889>:
  iftmp.6 = &error->message;
  <D.18890>:
  exception = mono_exception_from_name_msg (D.18850, "System", "TypeLoadException", iftmp.6);
  <D.18875>:
  goto <D.18540>;
  <D.18543>:
  <D.18544>:
  D.18877 = error->assembly_name;
  if (D.18877 != 0B) goto <D.18891>; else goto <D.18892>;
  <D.18891>:
  D.18854 = error->full_message;
  if (D.18854 != 0B) goto <D.18894>; else goto <D.18895>;
  <D.18894>:
  iftmp.7 = error->full_message;
  goto <D.18896>;
  <D.18895>:
  iftmp.7 = &error->message;
  <D.18896>:
  msg = mono_string_new (domain, iftmp.7);
  if (msg == 0B) goto <D.18897>; else goto <D.18898>;
  <D.18897>:
  mono_error_set_out_of_memory (error_out, "Could not allocate message");
  goto <D.18540>;
  <D.18898>:
  D.18877 = error->assembly_name;
  if (D.18877 != 0B) goto <D.18899>; else goto <D.18900>;
  <D.18899>:
  D.18877 = error->assembly_name;
  assembly_name = mono_string_new (domain, D.18877);
  if (assembly_name == 0B) goto <D.18901>; else goto <D.18902>;
  <D.18901>:
  mono_error_set_out_of_memory (error_out, "Could not allocate assembly name");
  goto <D.18540>;
  <D.18902>:
  <D.18900>:
  D.18835 = error->error_code;
  if (D.18835 == 4) goto <D.18903>; else goto <D.18904>;
  <D.18903>:
  D.18905 = mono_get_corlib ();
  exception = mono_exception_from_name_two_strings (D.18905, "System.IO", "FileNotFoundException", msg, assembly_name);
  goto <D.18906>;
  <D.18904>:
  D.18850 = mono_defaults.corlib;
  exception = mono_exception_from_name_two_strings (D.18850, "System", "BadImageFormatException", msg, assembly_name);
  <D.18906>:
  goto <D.18907>;
  <D.18892>:
  D.18835 = error->error_code;
  if (D.18835 == 4) goto <D.18908>; else goto <D.18909>;
  <D.18908>:
  D.18910 = mono_get_corlib ();
  D.18854 = error->full_message;
  if (D.18854 != 0B) goto <D.18912>; else goto <D.18913>;
  <D.18912>:
  iftmp.8 = error->full_message;
  goto <D.18914>;
  <D.18913>:
  iftmp.8 = &error->message;
  <D.18914>:
  exception = mono_exception_from_name_msg (D.18910, "System.IO", "FileNotFoundException", iftmp.8);
  goto <D.18915>;
  <D.18909>:
  D.18850 = mono_defaults.corlib;
  D.18854 = error->full_message;
  if (D.18854 != 0B) goto <D.18917>; else goto <D.18918>;
  <D.18917>:
  iftmp.9 = error->full_message;
  goto <D.18919>;
  <D.18918>:
  iftmp.9 = &error->message;
  <D.18919>:
  exception = mono_exception_from_name_msg (D.18850, "System", "BadImageFormatException", iftmp.9);
  <D.18915>:
  <D.18907>:
  goto <D.18540>;
  <D.18545>:
  exception = mono_get_exception_out_of_memory ();
  goto <D.18540>;
  <D.18546>:
  D.18841 = error->type_name;
  D.18854 = error->full_message;
  if (D.18854 != 0B) goto <D.18921>; else goto <D.18922>;
  <D.18921>:
  iftmp.10 = error->full_message;
  goto <D.18923>;
  <D.18922>:
  iftmp.10 = &error->message;
  <D.18923>:
  exception = mono_get_exception_argument (D.18841, iftmp.10);
  goto <D.18540>;
  <D.18547>:
  {
    char * type_name;
    char * message;

    type_name = 0B;
    D.18843 = error->klass;
    if (D.18843 != 0B) goto <D.18924>; else goto <D.18925>;
    <D.18924>:
    D.18843 = error->klass;
    type_name = mono_type_get_full_name (D.18843);
    if (type_name == 0B) goto <D.18926>; else goto <D.18927>;
    <D.18926>:
    mono_error_set_out_of_memory (error_out, "Could not allocate message");
    goto <D.18540>;
    <D.18927>:
    <D.18925>:
    D.18844 = error->member_name;
    D.18854 = error->full_message;
    if (D.18854 != 0B) goto <D.18929>; else goto <D.18930>;
    <D.18929>:
    iftmp.11 = error->full_message;
    goto <D.18931>;
    <D.18930>:
    iftmp.11 = &error->message;
    <D.18931>:
    message = monoeg_g_strdup_printf ("Error in %s:%s %s", type_name, D.18844, iftmp.11);
    if (message == 0B) goto <D.18932>; else goto <D.18933>;
    <D.18932>:
    monoeg_g_free (type_name);
    mono_error_set_out_of_memory (error_out, "Could not allocate message");
    goto <D.18540>;
    <D.18933>:
    D.18850 = mono_defaults.corlib;
    exception = mono_exception_from_name_msg (D.18850, "System.Security", "VerificationException", message);
    monoeg_g_free (message);
    monoeg_g_free (type_name);
    goto <D.18540>;
  }
  <D.18550>:
  D.18937 = error->exception_name_space;
  if (D.18937 == 0B) goto <D.18934>; else goto <D.18938>;
  <D.18938>:
  D.18939 = error->exception_name;
  if (D.18939 == 0B) goto <D.18934>; else goto <D.18935>;
  <D.18934>:
  mono_error_set_generic_error (error_out, "System", "ExecutionEngineException", "MonoError with generic error but no exception name was supplied");
  goto <D.18936>;
  <D.18935>:
  D.18850 = mono_defaults.corlib;
  D.18937 = error->exception_name_space;
  D.18939 = error->exception_name;
  D.18854 = error->full_message;
  if (D.18854 != 0B) goto <D.18941>; else goto <D.18942>;
  <D.18941>:
  iftmp.12 = error->full_message;
  goto <D.18943>;
  <D.18942>:
  iftmp.12 = &error->message;
  <D.18943>:
  exception = mono_exception_from_name_msg (D.18850, D.18937, D.18939, iftmp.12);
  <D.18936>:
  goto <D.18540>;
  <D.18551>:
  D.18835 = error->error_code;
  D.18836 = (int) D.18835;
  mono_error_set_generic_error (error_out, "System", "ExecutionEngineException", "Invalid error-code %d", D.18836);
  <D.18540>:
  D.18944 = mono_error_ok (error_out);
  if (D.18944 == 0) goto <D.18945>; else goto <D.18946>;
  <D.18945>:
  D.18837 = 0B;
  return D.18837;
  <D.18946>:
  if (exception == 0B) goto <D.18947>; else goto <D.18948>;
  <D.18947>:
  mono_error_set_out_of_memory (error_out, "Could not allocate exception object");
  <D.18948>:
  D.18837 = exception;
  return D.18837;
}


get_type_name_as_mono_string (struct MonoErrorInternal * error, struct MonoDomain * domain, struct MonoError * error_out)
{
  const char * D.18950;
  struct MonoClass * D.18954;
  struct MonoType * D.18957;
  struct MonoString * D.18962;
  struct MonoString * res;

  res = 0B;
  D.18950 = error->type_name;
  if (D.18950 != 0B) goto <D.18951>; else goto <D.18952>;
  <D.18951>:
  D.18950 = error->type_name;
  res = mono_string_new (domain, D.18950);
  goto <D.18953>;
  <D.18952>:
  D.18954 = error->klass;
  if (D.18954 != 0B) goto <D.18955>; else goto <D.18956>;
  <D.18955>:
  {
    char * name;

    D.18954 = error->klass;
    D.18957 = &D.18954->byval_arg;
    name = mono_type_full_name (D.18957);
    if (name != 0B) goto <D.18958>; else goto <D.18959>;
    <D.18958>:
    res = mono_string_new (domain, name);
    monoeg_g_free (name);
    <D.18959>:
  }
  <D.18956>:
  <D.18953>:
  if (res == 0B) goto <D.18960>; else goto <D.18961>;
  <D.18960>:
  mono_error_set_out_of_memory (error_out, "Could not allocate type name");
  <D.18961>:
  D.18962 = res;
  return D.18962;
}


set_message_on_exception (struct MonoException * exception, struct MonoErrorInternal * error, struct MonoError * error_out)
{
  struct MonoDomain * D.18964;
  const char * iftmp.13;
  const char * D.18966;
  struct MonoString * * D.18972;
  struct MonoString * msg;

  D.18964 = mono_domain_get ();
  D.18966 = error->full_message;
  if (D.18966 != 0B) goto <D.18967>; else goto <D.18968>;
  <D.18967>:
  iftmp.13 = error->full_message;
  goto <D.18969>;
  <D.18968>:
  iftmp.13 = &error->message;
  <D.18969>:
  msg = mono_string_new (D.18964, iftmp.13);
  if (msg != 0B) goto <D.18970>; else goto <D.18971>;
  <D.18970>:
  D.18972 = &exception->message;
  mono_gc_wbarrier_set_field (exception, D.18972, msg);
  goto <D.18973>;
  <D.18971>:
  mono_error_set_out_of_memory (error_out, "Could not allocate exception object");
  <D.18973>:
}


mono_error_raise_exception (struct MonoError * target_error)
{
  int D.18974;
  int D.18977;
  int D.18980;
  _Bool D.18981;
  long int D.18982;
  long int D.18983;
  struct MonoError error;
  struct MonoException * ex;

  try
    {
      D.18974 = mono_error_ok (target_error);
      if (D.18974 != 0) goto <D.18975>; else goto <D.18976>;
      <D.18975>:
      return;
      <D.18976>:
      ex = mono_error_prepare_exception (target_error, &error);
      D.18977 = mono_error_ok (&error);
      if (D.18977 == 0) goto <D.18978>; else goto <D.18979>;
      <D.18978>:
      {
        struct MonoError second_chance;

        try
          {
            ex = mono_error_prepare_exception (&error, &second_chance);
            D.18980 = mono_error_ok (&second_chance);
            D.18981 = D.18980 == 0;
            D.18982 = (long int) D.18981;
            D.18983 = __builtin_expect (D.18982, 0);
            if (D.18983 != 0) goto <D.18984>; else goto <D.18985>;
            <D.18984>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mono-error.c", 646, "mono_error_ok (&second_chance)");
            <D.18985>:
            mono_error_cleanup (&error);
          }
        finally
          {
            second_chance = {CLOBBER};
          }
      }
      <D.18979>:
      mono_error_cleanup (target_error);
      mono_raise_exception (ex);
    }
  finally
    {
      error = {CLOBBER};
    }
}