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

  error = oerror;
  if (0 != 0) goto <D.16010>; else goto <D.16011>;
  <D.16010>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mono-error.c", 47, "sizeof (MonoError) == sizeof (MonoErrorInternal)");
  <D.16011>:
  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.16012;
  const char * D.16015;
  short unsigned int D.16016;
  int D.16017;
  int D.16018;
  const char * D.16021;
  const char * D.16022;
  const char * D.16023;
  const char * D.16024;
  const char * D.16025;
  struct MonoErrorInternal * error;

  error = oerror;
  D.16012 = error->error_code;
  if (D.16012 == 0) goto <D.16013>; else goto <D.16014>;
  <D.16013>:
  return;
  <D.16014>:
  D.16015 = error->full_message;
  monoeg_g_free (D.16015);
  D.16016 = error->flags;
  D.16017 = (int) D.16016;
  D.16018 = D.16017 & 1;
  if (D.16018 == 0) goto <D.16019>; else goto <D.16020>;
  <D.16019>:
  return;
  <D.16020>:
  D.16021 = error->type_name;
  monoeg_g_free (D.16021);
  D.16022 = error->assembly_name;
  monoeg_g_free (D.16022);
  D.16023 = error->member_name;
  monoeg_g_free (D.16023);
  D.16024 = error->exception_name_space;
  monoeg_g_free (D.16024);
  D.16025 = error->exception_name;
  monoeg_g_free (D.16025);
}


mono_error_ok (struct MonoError * error)
{
  mono_bool D.16027;
  short unsigned int D.16028;
  _Bool D.16029;

  D.16028 = error->error_code;
  D.16029 = D.16028 == 0;
  D.16027 = (mono_bool) D.16029;
  return D.16027;
}


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

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


mono_error_get_message (struct MonoError * oerror)
{
  short unsigned int D.16033;
  const char * D.16036;
  const char * iftmp.0;
  const char * D.16038;
  struct MonoErrorInternal * error;

  error = oerror;
  D.16033 = error->error_code;
  if (D.16033 == 0) goto <D.16034>; else goto <D.16035>;
  <D.16034>:
  D.16036 = 0B;
  return D.16036;
  <D.16035>:
  D.16038 = error->full_message;
  if (D.16038 != 0B) goto <D.16039>; else goto <D.16040>;
  <D.16039>:
  iftmp.0 = error->full_message;
  goto <D.16041>;
  <D.16040>:
  iftmp.0 = &error->message;
  <D.16041>:
  D.16036 = iftmp.0;
  return D.16036;
}


mono_error_dup_strings (struct MonoError * oerror, gboolean dup_strings)
{
  short unsigned int D.16043;
  short unsigned int D.16044;
  const char * D.16047;
  gchar * D.16050;
  short unsigned int D.16053;
  const char * D.16054;
  gchar * D.16057;
  const char * D.16060;
  gchar * D.16063;
  const char * D.16066;
  gchar * D.16069;
  const char * D.16072;
  gchar * D.16075;
  struct MonoErrorInternal * error;

  error = oerror;
  D.16043 = error->flags;
  D.16044 = D.16043 | 1;
  error->flags = D.16044;
  if (dup_strings != 0) goto <D.16045>; else goto <D.16046>;
  <D.16045>:
  D.16047 = error->type_name;
  if (D.16047 != 0B) goto <D.16048>; else goto <D.16049>;
  <D.16048>:
  D.16047 = error->type_name;
  D.16050 = monoeg_strdup (D.16047);
  error->type_name = D.16050;
  D.16047 = error->type_name;
  if (D.16047 == 0B) goto <D.16051>; else goto <D.16052>;
  <D.16051>:
  D.16043 = error->flags;
  D.16053 = D.16043 | 2;
  error->flags = D.16053;
  <D.16052>:
  <D.16049>:
  D.16054 = error->assembly_name;
  if (D.16054 != 0B) goto <D.16055>; else goto <D.16056>;
  <D.16055>:
  D.16054 = error->assembly_name;
  D.16057 = monoeg_strdup (D.16054);
  error->assembly_name = D.16057;
  D.16054 = error->assembly_name;
  if (D.16054 == 0B) goto <D.16058>; else goto <D.16059>;
  <D.16058>:
  D.16043 = error->flags;
  D.16053 = D.16043 | 2;
  error->flags = D.16053;
  <D.16059>:
  <D.16056>:
  D.16060 = error->member_name;
  if (D.16060 != 0B) goto <D.16061>; else goto <D.16062>;
  <D.16061>:
  D.16060 = error->member_name;
  D.16063 = monoeg_strdup (D.16060);
  error->member_name = D.16063;
  D.16060 = error->member_name;
  if (D.16060 == 0B) goto <D.16064>; else goto <D.16065>;
  <D.16064>:
  D.16043 = error->flags;
  D.16053 = D.16043 | 2;
  error->flags = D.16053;
  <D.16065>:
  <D.16062>:
  D.16066 = error->exception_name_space;
  if (D.16066 != 0B) goto <D.16067>; else goto <D.16068>;
  <D.16067>:
  D.16066 = error->exception_name_space;
  D.16069 = monoeg_strdup (D.16066);
  error->exception_name_space = D.16069;
  D.16066 = error->exception_name_space;
  if (D.16066 == 0B) goto <D.16070>; else goto <D.16071>;
  <D.16070>:
  D.16043 = error->flags;
  D.16053 = D.16043 | 2;
  error->flags = D.16053;
  <D.16071>:
  <D.16068>:
  D.16072 = error->exception_name;
  if (D.16072 != 0B) goto <D.16073>; else goto <D.16074>;
  <D.16073>:
  D.16072 = error->exception_name;
  D.16075 = monoeg_strdup (D.16072);
  error->exception_name = D.16075;
  D.16072 = error->exception_name;
  if (D.16072 == 0B) goto <D.16076>; else goto <D.16077>;
  <D.16076>:
  D.16043 = error->flags;
  D.16053 = D.16043 | 2;
  error->flags = D.16053;
  <D.16077>:
  <D.16074>:
  <D.16046>:
}


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

  if (str != 0B) goto <D.16078>; else goto <D.16079>;
  <D.16078>:
  D.16080 = __strdup (str);
  return D.16080;
  <D.16079>:
  D.16080 = 0B;
  return D.16080;
}


mono_error_set_error (struct MonoError * oerror, int error_code, const char * msg_format)
{
  short unsigned int D.16082;
  char * args.1;
  char[128] * D.16084;
  int D.16085;
  unsigned int D.16086;
  gchar * D.16089;
  const char * D.16090;
  short unsigned int D.16093;
  short unsigned int D.16094;
  struct MonoErrorInternal * error;

  error = oerror;
  mono_error_prepare (error);
  D.16082 = (short unsigned int) error_code;
  error->error_code = D.16082;
  {
    char * args;

    try
      {
        __builtin_va_start (&args, 0);
        args.1 = args;
        D.16084 = &error->message;
        D.16085 = vsnprintf (D.16084, 128, msg_format, args.1);
        D.16086 = (unsigned int) D.16085;
        if (D.16086 > 127) goto <D.16087>; else goto <D.16088>;
        <D.16087>:
        __builtin_va_end (&args);
        __builtin_va_start (&args, 0);
        args.1 = args;
        D.16089 = monoeg_g_strdup_vprintf (msg_format, args.1);
        error->full_message = D.16089;
        D.16090 = error->full_message;
        if (D.16090 == 0B) goto <D.16091>; else goto <D.16092>;
        <D.16091>:
        D.16093 = error->flags;
        D.16094 = D.16093 | 2;
        error->flags = D.16094;
        <D.16092>:
        <D.16088>:
        __builtin_va_end (&args);
      }
    finally
      {
        args = {CLOBBER};
      }
  }
}


mono_error_prepare (struct MonoErrorInternal * error)
{
  short unsigned int D.16095;
  const char * D.16098;
  const char * D.16099;
  const char * D.16100;
  const char * D.16101;
  const char * D.16102;

  D.16095 = error->error_code;
  if (D.16095 != 0) goto <D.16096>; else goto <D.16097>;
  <D.16096>:
  return;
  <D.16097>:
  error->exception_name = 0B;
  D.16098 = error->exception_name;
  error->exception_name_space = D.16098;
  D.16099 = error->exception_name_space;
  error->full_message = D.16099;
  D.16100 = error->full_message;
  error->member_name = D.16100;
  D.16101 = error->member_name;
  error->assembly_name = D.16101;
  D.16102 = error->assembly_name;
  error->type_name = D.16102;
  error->klass = 0B;
  error->message[0] = 0;
}


vsnprintf (char * restrict __s, size_t __n, const char * restrict __fmt, char * __ap)
{
  int D.16104;
  unsigned int D.16105;

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


mono_error_set_assembly_load (struct MonoError * oerror, const char * assembly_name, const char * msg_format)
{
  char * args.2;
  char[128] * D.16108;
  int D.16109;
  unsigned int D.16110;
  gchar * D.16113;
  const char * D.16114;
  short unsigned int D.16117;
  short unsigned int D.16118;
  struct MonoErrorInternal * error;

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

    try
      {
        __builtin_va_start (&args, 0);
        args.2 = args;
        D.16108 = &error->message;
        D.16109 = vsnprintf (D.16108, 128, msg_format, args.2);
        D.16110 = (unsigned int) D.16109;
        if (D.16110 > 127) goto <D.16111>; else goto <D.16112>;
        <D.16111>:
        __builtin_va_end (&args);
        __builtin_va_start (&args, 0);
        args.2 = args;
        D.16113 = monoeg_g_strdup_vprintf (msg_format, args.2);
        error->full_message = D.16113;
        D.16114 = error->full_message;
        if (D.16114 == 0B) goto <D.16115>; else goto <D.16116>;
        <D.16115>:
        D.16117 = error->flags;
        D.16118 = D.16117 | 2;
        error->flags = D.16118;
        <D.16116>:
        <D.16112>:
        __builtin_va_end (&args);
      }
    finally
      {
        args = {CLOBBER};
      }
  }
}


mono_error_set_assembly_name (struct MonoError * oerror, const char * assembly_name)
{
  short unsigned int D.16119;
  _Bool D.16120;
  long int D.16121;
  long int D.16122;
  struct MonoErrorInternal * error;

  error = oerror;
  D.16119 = error->error_code;
  D.16120 = D.16119 == 0;
  D.16121 = (long int) D.16120;
  D.16122 = __builtin_expect (D.16121, 0);
  if (D.16122 != 0) goto <D.16123>; else goto <D.16124>;
  <D.16123>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mono-error.c", 140, "error->error_code != MONO_ERROR_NONE");
  <D.16124>:
  error->assembly_name = assembly_name;
}


mono_error_set_type_load_class (struct MonoError * oerror, struct MonoClass * klass, const char * msg_format)
{
  char * args.3;
  char[128] * D.16126;
  int D.16127;
  unsigned int D.16128;
  gchar * D.16131;
  const char * D.16132;
  short unsigned int D.16135;
  short unsigned int D.16136;
  struct MonoErrorInternal * error;

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

    try
      {
        __builtin_va_start (&args, 0);
        args.3 = args;
        D.16126 = &error->message;
        D.16127 = vsnprintf (D.16126, 128, msg_format, args.3);
        D.16128 = (unsigned int) D.16127;
        if (D.16128 > 127) goto <D.16129>; else goto <D.16130>;
        <D.16129>:
        __builtin_va_end (&args);
        __builtin_va_start (&args, 0);
        args.3 = args;
        D.16131 = monoeg_g_strdup_vprintf (msg_format, args.3);
        error->full_message = D.16131;
        D.16132 = error->full_message;
        if (D.16132 == 0B) goto <D.16133>; else goto <D.16134>;
        <D.16133>:
        D.16135 = error->flags;
        D.16136 = D.16135 | 2;
        error->flags = D.16136;
        <D.16134>:
        <D.16130>:
        __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 * args.4;
  char[128] * D.16138;
  int D.16139;
  unsigned int D.16140;
  gchar * D.16143;
  const char * D.16144;
  short unsigned int D.16147;
  short unsigned int D.16148;
  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);
  {
    char * args;

    try
      {
        __builtin_va_start (&args, 0);
        args.4 = args;
        D.16138 = &error->message;
        D.16139 = vsnprintf (D.16138, 128, msg_format, args.4);
        D.16140 = (unsigned int) D.16139;
        if (D.16140 > 127) goto <D.16141>; else goto <D.16142>;
        <D.16141>:
        __builtin_va_end (&args);
        __builtin_va_start (&args, 0);
        args.4 = args;
        D.16143 = monoeg_g_strdup_vprintf (msg_format, args.4);
        error->full_message = D.16143;
        D.16144 = error->full_message;
        if (D.16144 == 0B) goto <D.16145>; else goto <D.16146>;
        <D.16145>:
        D.16147 = error->flags;
        D.16148 = D.16147 | 2;
        error->flags = D.16148;
        <D.16146>:
        <D.16142>:
        __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 * args.5;
  char[128] * D.16150;
  int D.16151;
  unsigned int D.16152;
  gchar * D.16155;
  const char * D.16156;
  short unsigned int D.16159;
  short unsigned int D.16160;
  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);
  {
    char * args;

    try
      {
        __builtin_va_start (&args, 0);
        args.5 = args;
        D.16150 = &error->message;
        D.16151 = vsnprintf (D.16150, 128, msg_format, args.5);
        D.16152 = (unsigned int) D.16151;
        if (D.16152 > 127) goto <D.16153>; else goto <D.16154>;
        <D.16153>:
        __builtin_va_end (&args);
        __builtin_va_start (&args, 0);
        args.5 = args;
        D.16155 = monoeg_g_strdup_vprintf (msg_format, args.5);
        error->full_message = D.16155;
        D.16156 = error->full_message;
        if (D.16156 == 0B) goto <D.16157>; else goto <D.16158>;
        <D.16157>:
        D.16159 = error->flags;
        D.16160 = D.16159 | 2;
        error->flags = D.16160;
        <D.16158>:
        <D.16154>:
        __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 * args.6;
  char[128] * D.16162;
  int D.16163;
  unsigned int D.16164;
  gchar * D.16167;
  const char * D.16168;
  short unsigned int D.16171;
  short unsigned int D.16172;
  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);
  {
    char * args;

    try
      {
        __builtin_va_start (&args, 0);
        args.6 = args;
        D.16162 = &error->message;
        D.16163 = vsnprintf (D.16162, 128, msg_format, args.6);
        D.16164 = (unsigned int) D.16163;
        if (D.16164 > 127) goto <D.16165>; else goto <D.16166>;
        <D.16165>:
        __builtin_va_end (&args);
        __builtin_va_start (&args, 0);
        args.6 = args;
        D.16167 = monoeg_g_strdup_vprintf (msg_format, args.6);
        error->full_message = D.16167;
        D.16168 = error->full_message;
        if (D.16168 == 0B) goto <D.16169>; else goto <D.16170>;
        <D.16169>:
        D.16171 = error->flags;
        D.16172 = D.16171 | 2;
        error->flags = D.16172;
        <D.16170>:
        <D.16166>:
        __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 * args.7;
  char[128] * D.16174;
  int D.16175;
  unsigned int D.16176;
  gchar * D.16179;
  const char * D.16180;
  short unsigned int D.16183;
  short unsigned int D.16184;
  struct MonoErrorInternal * error;

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

    try
      {
        __builtin_va_start (&args, 0);
        args.7 = args;
        D.16174 = &error->message;
        D.16175 = vsnprintf (D.16174, 128, msg_format, args.7);
        D.16176 = (unsigned int) D.16175;
        if (D.16176 > 127) goto <D.16177>; else goto <D.16178>;
        <D.16177>:
        __builtin_va_end (&args);
        __builtin_va_start (&args, 0);
        args.7 = args;
        D.16179 = monoeg_g_strdup_vprintf (msg_format, args.7);
        error->full_message = D.16179;
        D.16180 = error->full_message;
        if (D.16180 == 0B) goto <D.16181>; else goto <D.16182>;
        <D.16181>:
        D.16183 = error->flags;
        D.16184 = D.16183 | 2;
        error->flags = D.16184;
        <D.16182>:
        <D.16178>:
        __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.8;
  char * args.9;
  char[128] * D.16190;
  int D.16191;
  unsigned int D.16192;
  gchar * D.16195;
  const char * D.16196;
  short unsigned int D.16199;
  short unsigned int D.16200;
  struct MonoErrorInternal * error;

  error = oerror;
  mono_error_prepare (error);
  error->error_code = 5;
  if (image != 0B) goto <D.16186>; else goto <D.16187>;
  <D.16186>:
  iftmp.8 = mono_image_get_name (image);
  goto <D.16188>;
  <D.16187>:
  iftmp.8 = "<no_image>";
  <D.16188>:
  error->assembly_name = iftmp.8;
  {
    char * args;

    try
      {
        __builtin_va_start (&args, 0);
        args.9 = args;
        D.16190 = &error->message;
        D.16191 = vsnprintf (D.16190, 128, msg_format, args.9);
        D.16192 = (unsigned int) D.16191;
        if (D.16192 > 127) goto <D.16193>; else goto <D.16194>;
        <D.16193>:
        __builtin_va_end (&args);
        __builtin_va_start (&args, 0);
        args.9 = args;
        D.16195 = monoeg_g_strdup_vprintf (msg_format, args.9);
        error->full_message = D.16195;
        D.16196 = error->full_message;
        if (D.16196 == 0B) goto <D.16197>; else goto <D.16198>;
        <D.16197>:
        D.16199 = error->flags;
        D.16200 = D.16199 | 2;
        error->flags = D.16200;
        <D.16198>:
        <D.16194>:
        __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 * args.10;
  char[128] * D.16202;
  int D.16203;
  unsigned int D.16204;
  gchar * D.16207;
  const char * D.16208;
  short unsigned int D.16211;
  short unsigned int D.16212;
  struct MonoErrorInternal * error;

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

    try
      {
        __builtin_va_start (&args, 0);
        args.10 = args;
        D.16202 = &error->message;
        D.16203 = vsnprintf (D.16202, 128, msg_format, args.10);
        D.16204 = (unsigned int) D.16203;
        if (D.16204 > 127) goto <D.16205>; else goto <D.16206>;
        <D.16205>:
        __builtin_va_end (&args);
        __builtin_va_start (&args, 0);
        args.10 = args;
        D.16207 = monoeg_g_strdup_vprintf (msg_format, args.10);
        error->full_message = D.16207;
        D.16208 = error->full_message;
        if (D.16208 == 0B) goto <D.16209>; else goto <D.16210>;
        <D.16209>:
        D.16211 = error->flags;
        D.16212 = D.16211 | 2;
        error->flags = D.16212;
        <D.16210>:
        <D.16206>:
        __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.16215;
  int D.16216;
  char * D.16217;
  const char * D.16218;
  char[128] * D.16219;
  struct MonoClass * D.16220;
  char * D.16221;
  int D.16222;
  char * D.16226;
  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.16213>; else goto <D.16214>;
  <D.16213>:
  mono_error_set_generic_error (oerror, "System", "ExecutionEngineException", "Runtime tried to produce a mono-error from an empty loader-error");
  return;
  <D.16214>:
  D.16215 = loader_error->exception_type;
  D.16216 = (int) D.16215;
  switch (D.16216) <default: <D.15926>, case 0: <D.15910>, case 1: <D.15912>, case 2: <D.15913>, case 3: <D.15914>, case 4: <D.15915>, case 5: <D.15916>, case 6: <D.15917>, case 7: <D.15918>, case 8: <D.15919>, case 9: <D.15920>, case 10: <D.15921>, case 11: <D.15923>, case 12: <D.15924>, case 13: <D.15922>, case 14: <D.15925>>
  <D.15910>:
  mono_error_set_generic_error (oerror, "System", "ExecutionEngineException", "Runtime tried to produce a mono-error from a non-error loader-error");
  goto <D.15911>;
  <D.15912>:
  <D.15913>:
  mono_error_set_generic_error (oerror, "System.Security", "SecurityException", "Failed for unknown reasons.");
  goto <D.15911>;
  <D.15914>:
  mono_error_set_generic_error (oerror, "System", "InvalidProgramException", "Failed for unknown reasons.");
  goto <D.15911>;
  <D.15915>:
  mono_error_set_generic_error (oerror, "System.Security", "VerificationException", "Failed for unknown reasons.");
  goto <D.15911>;
  <D.15916>:
  error->error_code = 1;
  D.16217 = loader_error->class_name;
  mono_error_set_type_name (oerror, D.16217);
  D.16218 = loader_error->member_name;
  mono_error_set_member_name (oerror, D.16218);
  D.16219 = &error->message;
  monoeg_g_snprintf (D.16219, 128, "Failed for unknown reasons.");
  goto <D.15911>;
  <D.15917>:
  D.16218 = loader_error->member_name;
  D.16220 = loader_error->klass;
  mono_error_set_field_load (oerror, D.16220, D.16218, "Failed for unknown reasons.");
  goto <D.15911>;
  <D.15918>:
  D.16221 = loader_error->assembly_name;
  D.16217 = loader_error->class_name;
  mono_error_set_type_load_name (oerror, D.16217, D.16221, "Failed for unknown reasons.");
  goto <D.15911>;
  <D.15919>:
  D.16222 = loader_error->ref_only;
  if (D.16222 != 0) goto <D.16223>; else goto <D.16224>;
  <D.16223>:
  D.16221 = loader_error->assembly_name;
  mono_error_set_assembly_load (oerror, D.16221, "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.16225>;
  <D.16224>:
  D.16221 = loader_error->assembly_name;
  mono_error_set_assembly_load (oerror, D.16221, "Could not load file or assembly or one of its dependencies.");
  <D.16225>:
  goto <D.15911>;
  <D.15920>:
  mono_error_set_generic_error (oerror, "System", "MethodAccessException", "Failed for unknown reasons.");
  goto <D.15911>;
  <D.15921>:
  mono_error_set_generic_error (oerror, "System", "FieldAccessException", "Failed for unknown reasons.");
  goto <D.15911>;
  <D.15922>:
  <D.15923>:
  D.16215 = loader_error->exception_type;
  D.16216 = (int) D.16215;
  mono_error_set_generic_error (oerror, "System", "ExecutionEngineException", "Runtime tried to produce a mono-error from JIT internal error %d", D.16216);
  goto <D.15911>;
  <D.15924>:
  D.16226 = loader_error->msg;
  mono_error_set_bad_image_name (oerror, "<unknown>", "%s", D.16226);
  goto <D.15911>;
  <D.15925>:
  mono_error_set_out_of_memory (oerror, "Failed for unknown reasons.");
  goto <D.15911>;
  <D.15926>:
  D.16215 = loader_error->exception_type;
  D.16216 = (int) D.16215;
  mono_error_set_generic_error (oerror, "System", "ExecutionEngineException", "Runtime tried to produce an unknown loader-error %d", D.16216);
  goto <D.15911>;
  <D.15911>:
  mono_error_dup_strings (oerror, 1);
  mono_loader_clear_error ();
}


mono_loader_set_error_from_mono_error (struct MonoError * oerror)
{
  short unsigned int D.16228;
  int D.16229;
  const char * D.16230;
  const char * D.16231;
  struct MonoClass * D.16232;
  const char * D.16233;
  const char * D.16234;
  const char * D.16235;
  const gchar * iftmp.11;
  const char * D.16237;
  gchar * D.16241;
  const char * iftmp.12;
  gchar * D.16246;
  struct MonoErrorInternal * error;

  error = oerror;
  D.16228 = error->error_code;
  D.16229 = (int) D.16228;
  switch (D.16229) <default: <D.15943>, case 1: <D.15937>, case 2: <D.15939>, case 3: <D.15940>, case 4: <D.15941>, case 5: <D.15942>>
  <D.15937>:
  D.16230 = error->member_name;
  D.16231 = get_type_name (error);
  mono_loader_set_error_method_load (D.16231, D.16230);
  goto <D.15938>;
  <D.15939>:
  D.16230 = error->member_name;
  D.16232 = error->klass;
  mono_loader_set_error_field_load (D.16232, D.16230);
  goto <D.15938>;
  <D.15940>:
  D.16233 = get_assembly_name (error);
  D.16234 = get_type_name (error);
  mono_loader_set_error_type_load (D.16234, D.16233);
  goto <D.15938>;
  <D.15941>:
  D.16235 = get_assembly_name (error);
  mono_loader_set_error_assembly_load (D.16235, 0);
  goto <D.15938>;
  <D.15942>:
  D.16237 = error->full_message;
  if (D.16237 != 0B) goto <D.16238>; else goto <D.16239>;
  <D.16238>:
  iftmp.11 = error->full_message;
  goto <D.16240>;
  <D.16239>:
  iftmp.11 = &error->message;
  <D.16240>:
  D.16241 = monoeg_strdup (iftmp.11);
  mono_loader_set_error_bad_image (D.16241);
  goto <D.15938>;
  <D.15943>:
  D.16237 = error->full_message;
  if (D.16237 != 0B) goto <D.16243>; else goto <D.16244>;
  <D.16243>:
  iftmp.12 = error->full_message;
  goto <D.16245>;
  <D.16244>:
  iftmp.12 = &error->message;
  <D.16245>:
  D.16246 = monoeg_g_strdup_printf ("Non translatable error: %s", iftmp.12);
  mono_loader_set_error_bad_image (D.16246);
  <D.15938>:
}


get_type_name (struct MonoErrorInternal * error)
{
  const char * D.16247;
  const char * D.16250;
  struct MonoClass * D.16251;

  D.16247 = error->type_name;
  if (D.16247 != 0B) goto <D.16248>; else goto <D.16249>;
  <D.16248>:
  D.16250 = error->type_name;
  return D.16250;
  <D.16249>:
  D.16251 = error->klass;
  if (D.16251 != 0B) goto <D.16252>; else goto <D.16253>;
  <D.16252>:
  D.16251 = error->klass;
  D.16250 = D.16251->name;
  return D.16250;
  <D.16253>:
  D.16250 = "<unknown type>";
  return D.16250;
}


get_assembly_name (struct MonoErrorInternal * error)
{
  const char * D.16255;
  const char * D.16258;
  struct MonoClass * D.16259;
  struct MonoImage * D.16262;

  D.16255 = error->assembly_name;
  if (D.16255 != 0B) goto <D.16256>; else goto <D.16257>;
  <D.16256>:
  D.16258 = error->assembly_name;
  return D.16258;
  <D.16257>:
  D.16259 = error->klass;
  if (D.16259 != 0B) goto <D.16260>; else goto <D.16261>;
  <D.16260>:
  D.16259 = error->klass;
  D.16262 = D.16259->image;
  if (D.16262 != 0B) goto <D.16263>; else goto <D.16264>;
  <D.16263>:
  D.16259 = error->klass;
  D.16262 = D.16259->image;
  D.16258 = D.16262->name;
  return D.16258;
  <D.16264>:
  <D.16261>:
  D.16258 = "<unknown assembly>";
  return D.16258;
}


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

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


mono_error_set_argument (struct MonoError * oerror, const char * argument, const char * msg_format)
{
  char * args.14;
  char[128] * D.16269;
  int D.16270;
  unsigned int D.16271;
  gchar * D.16274;
  const char * D.16275;
  short unsigned int D.16278;
  short unsigned int D.16279;
  struct MonoErrorInternal * error;

  error = oerror;
  mono_error_prepare (error);
  error->error_code = 7;
  error->type_name = argument;
  {
    char * args;

    try
      {
        __builtin_va_start (&args, 0);
        args.14 = args;
        D.16269 = &error->message;
        D.16270 = vsnprintf (D.16269, 128, msg_format, args.14);
        D.16271 = (unsigned int) D.16270;
        if (D.16271 > 127) goto <D.16272>; else goto <D.16273>;
        <D.16272>:
        __builtin_va_end (&args);
        __builtin_va_start (&args, 0);
        args.14 = args;
        D.16274 = monoeg_g_strdup_vprintf (msg_format, args.14);
        error->full_message = D.16274;
        D.16275 = error->full_message;
        if (D.16275 == 0B) goto <D.16276>; else goto <D.16277>;
        <D.16276>:
        D.16278 = error->flags;
        D.16279 = D.16278 | 2;
        error->flags = D.16279;
        <D.16277>:
        <D.16273>:
        __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.16280;
  char * D.16283;
  char * args.15;
  char[128] * D.16285;
  int D.16286;
  unsigned int D.16287;
  gchar * D.16290;
  const char * D.16291;
  short unsigned int D.16294;
  short unsigned int D.16295;
  struct MonoErrorInternal * error;

  error = oerror;
  mono_error_prepare (error);
  error->error_code = 8;
  D.16280 = method->klass;
  mono_error_set_class (oerror, D.16280);
  if (method != 0B) goto <D.16281>; else goto <D.16282>;
  <D.16281>:
  D.16283 = mono_method_full_name (method, 1);
  mono_error_set_member_name (oerror, D.16283);
  <D.16282>:
  {
    char * args;

    try
      {
        __builtin_va_start (&args, 0);
        args.15 = args;
        D.16285 = &error->message;
        D.16286 = vsnprintf (D.16285, 128, msg_format, args.15);
        D.16287 = (unsigned int) D.16286;
        if (D.16287 > 127) goto <D.16288>; else goto <D.16289>;
        <D.16288>:
        __builtin_va_end (&args);
        __builtin_va_start (&args, 0);
        args.15 = args;
        D.16290 = monoeg_g_strdup_vprintf (msg_format, args.15);
        error->full_message = D.16290;
        D.16291 = error->full_message;
        if (D.16291 == 0B) goto <D.16292>; else goto <D.16293>;
        <D.16292>:
        D.16294 = error->flags;
        D.16295 = D.16294 | 2;
        error->flags = D.16295;
        <D.16293>:
        <D.16289>:
        __builtin_va_end (&args);
      }
    finally
      {
        args = {CLOBBER};
      }
  }
}


mono_error_prepare_exception (struct MonoError * oerror, struct MonoError * error_out)
{
  short unsigned int D.16296;
  int D.16297;
  struct MonoException * D.16298;
  const char * D.16302;
  struct MonoClass * D.16304;
  const char * D.16305;
  int D.16307;
  struct MonoImage * D.16311;
  const char * iftmp.16;
  const char * D.16315;
  int D.16324;
  const char * iftmp.17;
  const char * D.16338;
  int D.16339;
  struct MonoImage * D.16345;
  const char * iftmp.18;
  const char * iftmp.19;
  struct MonoImage * D.16366;
  const char * iftmp.20;
  struct MonoImage * D.16375;
  const char * iftmp.21;
  const char * iftmp.22;
  const char * iftmp.23;
  const char * D.16398;
  const char * D.16400;
  const char * iftmp.24;
  int D.16405;
  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.16296 = error->error_code;
  D.16297 = (int) D.16296;
  switch (D.16297) <default: <D.16002>, case 0: <D.15989>, case 1: <D.15990>, case 2: <D.15992>, case 3: <D.15993>, case 4: <D.15994>, case 5: <D.15995>, case 6: <D.15996>, case 7: <D.15997>, case 8: <D.15998>, case 9: <D.16001>>
  <D.15989>:
  D.16298 = 0B;
  return D.16298;
  <D.15990>:
  D.16302 = error->type_name;
  if (D.16302 != 0B) goto <D.16299>; else goto <D.16303>;
  <D.16303>:
  D.16304 = error->klass;
  if (D.16304 != 0B) goto <D.16299>; else goto <D.16300>;
  <D.16299>:
  D.16305 = error->member_name;
  if (D.16305 != 0B) goto <D.16306>; else goto <D.16300>;
  <D.16306>:
  type_name = get_type_name_as_mono_string (error, domain, error_out);
  D.16307 = mono_error_ok (error_out);
  if (D.16307 == 0) goto <D.15991>; else goto <D.16308>;
  <D.16308>:
  D.16305 = error->member_name;
  method_name = mono_string_new (domain, D.16305);
  if (method_name == 0B) goto <D.16309>; else goto <D.16310>;
  <D.16309>:
  mono_error_set_out_of_memory (error_out, "Could not allocate method name");
  goto <D.15991>;
  <D.16310>:
  D.16311 = mono_defaults.corlib;
  exception = mono_exception_from_name_two_strings (D.16311, "System", "MissingMethodException", type_name, method_name);
  if (exception != 0B) goto <D.16312>; else goto <D.16313>;
  <D.16312>:
  set_message_on_exception (exception, error, error_out);
  <D.16313>:
  goto <D.16301>;
  <D.16300>:
  D.16315 = error->full_message;
  if (D.16315 != 0B) goto <D.16316>; else goto <D.16317>;
  <D.16316>:
  iftmp.16 = error->full_message;
  goto <D.16318>;
  <D.16317>:
  iftmp.16 = &error->message;
  <D.16318>:
  D.16311 = mono_defaults.corlib;
  exception = mono_exception_from_name_msg (D.16311, "System", "MissingMethodException", iftmp.16);
  <D.16301>:
  goto <D.15991>;
  <D.15992>:
  D.16302 = error->type_name;
  if (D.16302 != 0B) goto <D.16319>; else goto <D.16322>;
  <D.16322>:
  D.16304 = error->klass;
  if (D.16304 != 0B) goto <D.16319>; else goto <D.16320>;
  <D.16319>:
  D.16305 = error->member_name;
  if (D.16305 != 0B) goto <D.16323>; else goto <D.16320>;
  <D.16323>:
  type_name = get_type_name_as_mono_string (error, domain, error_out);
  D.16324 = mono_error_ok (error_out);
  if (D.16324 == 0) goto <D.15991>; else goto <D.16325>;
  <D.16325>:
  D.16305 = error->member_name;
  field_name = mono_string_new (domain, D.16305);
  if (field_name == 0B) goto <D.16326>; else goto <D.16327>;
  <D.16326>:
  mono_error_set_out_of_memory (error_out, "Could not allocate field name");
  goto <D.15991>;
  <D.16327>:
  D.16311 = mono_defaults.corlib;
  exception = mono_exception_from_name_two_strings (D.16311, "System", "MissingFieldException", type_name, field_name);
  if (exception != 0B) goto <D.16328>; else goto <D.16329>;
  <D.16328>:
  set_message_on_exception (exception, error, error_out);
  <D.16329>:
  goto <D.16321>;
  <D.16320>:
  D.16315 = error->full_message;
  if (D.16315 != 0B) goto <D.16331>; else goto <D.16332>;
  <D.16331>:
  iftmp.17 = error->full_message;
  goto <D.16333>;
  <D.16332>:
  iftmp.17 = &error->message;
  <D.16333>:
  D.16311 = mono_defaults.corlib;
  exception = mono_exception_from_name_msg (D.16311, "System", "MissingFieldException", iftmp.17);
  <D.16321>:
  goto <D.15991>;
  <D.15993>:
  D.16302 = error->type_name;
  if (D.16302 != 0B) goto <D.16334>; else goto <D.16337>;
  <D.16337>:
  D.16338 = error->assembly_name;
  if (D.16338 != 0B) goto <D.16334>; else goto <D.16335>;
  <D.16334>:
  type_name = get_type_name_as_mono_string (error, domain, error_out);
  D.16339 = mono_error_ok (error_out);
  if (D.16339 == 0) goto <D.15991>; else goto <D.16340>;
  <D.16340>:
  D.16338 = error->assembly_name;
  if (D.16338 != 0B) goto <D.16341>; else goto <D.16342>;
  <D.16341>:
  D.16338 = error->assembly_name;
  assembly_name = mono_string_new (domain, D.16338);
  if (assembly_name == 0B) goto <D.16343>; else goto <D.16344>;
  <D.16343>:
  mono_error_set_out_of_memory (error_out, "Could not allocate assembly name");
  goto <D.15991>;
  <D.16344>:
  <D.16342>:
  D.16345 = mono_get_corlib ();
  exception = mono_exception_from_name_two_strings (D.16345, "System", "TypeLoadException", type_name, assembly_name);
  if (exception != 0B) goto <D.16346>; else goto <D.16347>;
  <D.16346>:
  set_message_on_exception (exception, error, error_out);
  <D.16347>:
  goto <D.16336>;
  <D.16335>:
  D.16315 = error->full_message;
  if (D.16315 != 0B) goto <D.16349>; else goto <D.16350>;
  <D.16349>:
  iftmp.18 = error->full_message;
  goto <D.16351>;
  <D.16350>:
  iftmp.18 = &error->message;
  <D.16351>:
  D.16311 = mono_defaults.corlib;
  exception = mono_exception_from_name_msg (D.16311, "System", "TypeLoadException", iftmp.18);
  <D.16336>:
  goto <D.15991>;
  <D.15994>:
  <D.15995>:
  D.16338 = error->assembly_name;
  if (D.16338 != 0B) goto <D.16352>; else goto <D.16353>;
  <D.16352>:
  D.16315 = error->full_message;
  if (D.16315 != 0B) goto <D.16355>; else goto <D.16356>;
  <D.16355>:
  iftmp.19 = error->full_message;
  goto <D.16357>;
  <D.16356>:
  iftmp.19 = &error->message;
  <D.16357>:
  msg = mono_string_new (domain, iftmp.19);
  if (msg == 0B) goto <D.16358>; else goto <D.16359>;
  <D.16358>:
  mono_error_set_out_of_memory (error_out, "Could not allocate message");
  goto <D.15991>;
  <D.16359>:
  D.16338 = error->assembly_name;
  if (D.16338 != 0B) goto <D.16360>; else goto <D.16361>;
  <D.16360>:
  D.16338 = error->assembly_name;
  assembly_name = mono_string_new (domain, D.16338);
  if (assembly_name == 0B) goto <D.16362>; else goto <D.16363>;
  <D.16362>:
  mono_error_set_out_of_memory (error_out, "Could not allocate assembly name");
  goto <D.15991>;
  <D.16363>:
  <D.16361>:
  D.16296 = error->error_code;
  if (D.16296 == 4) goto <D.16364>; else goto <D.16365>;
  <D.16364>:
  D.16366 = mono_get_corlib ();
  exception = mono_exception_from_name_two_strings (D.16366, "System.IO", "FileNotFoundException", msg, assembly_name);
  goto <D.16367>;
  <D.16365>:
  D.16311 = mono_defaults.corlib;
  exception = mono_exception_from_name_two_strings (D.16311, "System", "BadImageFormatException", msg, assembly_name);
  <D.16367>:
  goto <D.16368>;
  <D.16353>:
  D.16296 = error->error_code;
  if (D.16296 == 4) goto <D.16369>; else goto <D.16370>;
  <D.16369>:
  D.16315 = error->full_message;
  if (D.16315 != 0B) goto <D.16372>; else goto <D.16373>;
  <D.16372>:
  iftmp.20 = error->full_message;
  goto <D.16374>;
  <D.16373>:
  iftmp.20 = &error->message;
  <D.16374>:
  D.16375 = mono_get_corlib ();
  exception = mono_exception_from_name_msg (D.16375, "System.IO", "FileNotFoundException", iftmp.20);
  goto <D.16376>;
  <D.16370>:
  D.16315 = error->full_message;
  if (D.16315 != 0B) goto <D.16378>; else goto <D.16379>;
  <D.16378>:
  iftmp.21 = error->full_message;
  goto <D.16380>;
  <D.16379>:
  iftmp.21 = &error->message;
  <D.16380>:
  D.16311 = mono_defaults.corlib;
  exception = mono_exception_from_name_msg (D.16311, "System", "BadImageFormatException", iftmp.21);
  <D.16376>:
  <D.16368>:
  goto <D.15991>;
  <D.15996>:
  exception = mono_get_exception_out_of_memory ();
  goto <D.15991>;
  <D.15997>:
  D.16315 = error->full_message;
  if (D.16315 != 0B) goto <D.16382>; else goto <D.16383>;
  <D.16382>:
  iftmp.22 = error->full_message;
  goto <D.16384>;
  <D.16383>:
  iftmp.22 = &error->message;
  <D.16384>:
  D.16302 = error->type_name;
  exception = mono_get_exception_argument (D.16302, iftmp.22);
  goto <D.15991>;
  <D.15998>:
  {
    char * type_name;
    char * message;

    type_name = 0B;
    D.16304 = error->klass;
    if (D.16304 != 0B) goto <D.16385>; else goto <D.16386>;
    <D.16385>:
    D.16304 = error->klass;
    type_name = mono_type_get_full_name (D.16304);
    if (type_name == 0B) goto <D.16387>; else goto <D.16388>;
    <D.16387>:
    mono_error_set_out_of_memory (error_out, "Could not allocate message");
    goto <D.15991>;
    <D.16388>:
    <D.16386>:
    D.16315 = error->full_message;
    if (D.16315 != 0B) goto <D.16390>; else goto <D.16391>;
    <D.16390>:
    iftmp.23 = error->full_message;
    goto <D.16392>;
    <D.16391>:
    iftmp.23 = &error->message;
    <D.16392>:
    D.16305 = error->member_name;
    message = monoeg_g_strdup_printf ("Error in %s:%s %s", type_name, D.16305, iftmp.23);
    if (message == 0B) goto <D.16393>; else goto <D.16394>;
    <D.16393>:
    monoeg_g_free (type_name);
    mono_error_set_out_of_memory (error_out, "Could not allocate message");
    goto <D.15991>;
    <D.16394>:
    D.16311 = mono_defaults.corlib;
    exception = mono_exception_from_name_msg (D.16311, "System.Security", "VerificationException", message);
    monoeg_g_free (message);
    monoeg_g_free (type_name);
    goto <D.15991>;
  }
  <D.16001>:
  D.16398 = error->exception_name_space;
  if (D.16398 == 0B) goto <D.16395>; else goto <D.16399>;
  <D.16399>:
  D.16400 = error->exception_name;
  if (D.16400 == 0B) goto <D.16395>; else goto <D.16396>;
  <D.16395>:
  mono_error_set_generic_error (error_out, "System", "ExecutionEngineException", "MonoError with generic error but no exception name was supplied");
  goto <D.16397>;
  <D.16396>:
  D.16315 = error->full_message;
  if (D.16315 != 0B) goto <D.16402>; else goto <D.16403>;
  <D.16402>:
  iftmp.24 = error->full_message;
  goto <D.16404>;
  <D.16403>:
  iftmp.24 = &error->message;
  <D.16404>:
  D.16400 = error->exception_name;
  D.16398 = error->exception_name_space;
  D.16311 = mono_defaults.corlib;
  exception = mono_exception_from_name_msg (D.16311, D.16398, D.16400, iftmp.24);
  <D.16397>:
  goto <D.15991>;
  <D.16002>:
  D.16296 = error->error_code;
  D.16297 = (int) D.16296;
  mono_error_set_generic_error (error_out, "System", "ExecutionEngineException", "Invalid error-code %d", D.16297);
  <D.15991>:
  D.16405 = mono_error_ok (error_out);
  if (D.16405 == 0) goto <D.16406>; else goto <D.16407>;
  <D.16406>:
  D.16298 = 0B;
  return D.16298;
  <D.16407>:
  if (exception == 0B) goto <D.16408>; else goto <D.16409>;
  <D.16408>:
  mono_error_set_out_of_memory (error_out, "Could not allocate exception object");
  <D.16409>:
  D.16298 = exception;
  return D.16298;
}


get_type_name_as_mono_string (struct MonoErrorInternal * error, struct MonoDomain * domain, struct MonoError * error_out)
{
  const char * D.16411;
  struct MonoClass * D.16415;
  struct MonoType * D.16418;
  struct MonoString * D.16423;
  struct MonoString * res;

  res = 0B;
  D.16411 = error->type_name;
  if (D.16411 != 0B) goto <D.16412>; else goto <D.16413>;
  <D.16412>:
  D.16411 = error->type_name;
  res = mono_string_new (domain, D.16411);
  goto <D.16414>;
  <D.16413>:
  D.16415 = error->klass;
  if (D.16415 != 0B) goto <D.16416>; else goto <D.16417>;
  <D.16416>:
  {
    char * name;

    D.16415 = error->klass;
    D.16418 = &D.16415->byval_arg;
    name = mono_type_full_name (D.16418);
    if (name != 0B) goto <D.16419>; else goto <D.16420>;
    <D.16419>:
    res = mono_string_new (domain, name);
    monoeg_g_free (name);
    <D.16420>:
  }
  <D.16417>:
  <D.16414>:
  if (res == 0B) goto <D.16421>; else goto <D.16422>;
  <D.16421>:
  mono_error_set_out_of_memory (error_out, "Could not allocate type name");
  <D.16422>:
  D.16423 = res;
  return D.16423;
}


set_message_on_exception (struct MonoException * exception, struct MonoErrorInternal * error, struct MonoError * error_out)
{
  const char * iftmp.25;
  const char * D.16426;
  struct MonoDomain * D.16430;
  struct MonoString * * D.16433;
  struct MonoString * msg;

  D.16426 = error->full_message;
  if (D.16426 != 0B) goto <D.16427>; else goto <D.16428>;
  <D.16427>:
  iftmp.25 = error->full_message;
  goto <D.16429>;
  <D.16428>:
  iftmp.25 = &error->message;
  <D.16429>:
  D.16430 = mono_domain_get ();
  msg = mono_string_new (D.16430, iftmp.25);
  if (msg != 0B) goto <D.16431>; else goto <D.16432>;
  <D.16431>:
  D.16433 = &exception->message;
  mono_gc_wbarrier_set_field (exception, D.16433, msg);
  goto <D.16434>;
  <D.16432>:
  mono_error_set_out_of_memory (error_out, "Could not allocate exception object");
  <D.16434>:
}


mono_error_raise_exception (struct MonoError * target_error)
{
  int D.16435;
  int D.16438;
  int D.16441;
  _Bool D.16442;
  long int D.16443;
  long int D.16444;
  struct MonoError error;
  struct MonoException * ex;

  try
    {
      D.16435 = mono_error_ok (target_error);
      if (D.16435 != 0) goto <D.16436>; else goto <D.16437>;
      <D.16436>:
      return;
      <D.16437>:
      ex = mono_error_prepare_exception (target_error, &error);
      D.16438 = mono_error_ok (&error);
      if (D.16438 == 0) goto <D.16439>; else goto <D.16440>;
      <D.16439>:
      {
        struct MonoError second_chance;

        try
          {
            ex = mono_error_prepare_exception (&error, &second_chance);
            D.16441 = mono_error_ok (&second_chance);
            D.16442 = D.16441 == 0;
            D.16443 = (long int) D.16442;
            D.16444 = __builtin_expect (D.16443, 0);
            if (D.16444 != 0) goto <D.16445>; else goto <D.16446>;
            <D.16445>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mono-error.c", 646, "mono_error_ok (&second_chance)");
            <D.16446>:
            mono_error_cleanup (&error);
          }
        finally
          {
            second_chance = {CLOBBER};
          }
      }
      <D.16440>:
      mono_error_cleanup (target_error);
      mono_raise_exception (ex);
    }
  finally
    {
      error = {CLOBBER};
    }
}