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

  error = oerror;
  if (0 != 0) goto <D.15976>; else goto <D.15977>;
  <D.15976>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mono-error.c", 47, "sizeof (MonoError) == sizeof (MonoErrorInternal)");
  <D.15977>:
  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.15978;
  const char * D.15981;
  short unsigned int D.15982;
  int D.15983;
  int D.15984;
  const char * D.15987;
  const char * D.15988;
  const char * D.15989;
  const char * D.15990;
  const char * D.15991;
  struct MonoErrorInternal * error;

  error = oerror;
  D.15978 = error->error_code;
  if (D.15978 == 0) goto <D.15979>; else goto <D.15980>;
  <D.15979>:
  return;
  <D.15980>:
  D.15981 = error->full_message;
  monoeg_g_free (D.15981);
  D.15982 = error->flags;
  D.15983 = (int) D.15982;
  D.15984 = D.15983 & 1;
  if (D.15984 == 0) goto <D.15985>; else goto <D.15986>;
  <D.15985>:
  return;
  <D.15986>:
  D.15987 = error->type_name;
  monoeg_g_free (D.15987);
  D.15988 = error->assembly_name;
  monoeg_g_free (D.15988);
  D.15989 = error->member_name;
  monoeg_g_free (D.15989);
  D.15990 = error->exception_name_space;
  monoeg_g_free (D.15990);
  D.15991 = error->exception_name;
  monoeg_g_free (D.15991);
}


mono_error_ok (struct MonoError * error)
{
  mono_bool D.15993;
  short unsigned int D.15994;
  _Bool D.15995;

  D.15994 = error->error_code;
  D.15995 = D.15994 == 0;
  D.15993 = (mono_bool) D.15995;
  return D.15993;
}


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

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


mono_error_get_message (struct MonoError * oerror)
{
  short unsigned int D.15999;
  const char * D.16002;
  const char * iftmp.0;
  const char * D.16004;
  struct MonoErrorInternal * error;

  error = oerror;
  D.15999 = error->error_code;
  if (D.15999 == 0) goto <D.16000>; else goto <D.16001>;
  <D.16000>:
  D.16002 = 0B;
  return D.16002;
  <D.16001>:
  D.16004 = error->full_message;
  if (D.16004 != 0B) goto <D.16005>; else goto <D.16006>;
  <D.16005>:
  iftmp.0 = error->full_message;
  goto <D.16007>;
  <D.16006>:
  iftmp.0 = &error->message;
  <D.16007>:
  D.16002 = iftmp.0;
  return D.16002;
}


mono_error_dup_strings (struct MonoError * oerror, gboolean dup_strings)
{
  short unsigned int D.16009;
  short unsigned int D.16010;
  const char * D.16013;
  gchar * D.16016;
  short unsigned int D.16019;
  const char * D.16020;
  gchar * D.16023;
  const char * D.16026;
  gchar * D.16029;
  const char * D.16032;
  gchar * D.16035;
  const char * D.16038;
  gchar * D.16041;
  struct MonoErrorInternal * error;

  error = oerror;
  D.16009 = error->flags;
  D.16010 = D.16009 | 1;
  error->flags = D.16010;
  if (dup_strings != 0) goto <D.16011>; else goto <D.16012>;
  <D.16011>:
  D.16013 = error->type_name;
  if (D.16013 != 0B) goto <D.16014>; else goto <D.16015>;
  <D.16014>:
  D.16013 = error->type_name;
  D.16016 = monoeg_strdup (D.16013);
  error->type_name = D.16016;
  D.16013 = error->type_name;
  if (D.16013 == 0B) goto <D.16017>; else goto <D.16018>;
  <D.16017>:
  D.16009 = error->flags;
  D.16019 = D.16009 | 2;
  error->flags = D.16019;
  <D.16018>:
  <D.16015>:
  D.16020 = error->assembly_name;
  if (D.16020 != 0B) goto <D.16021>; else goto <D.16022>;
  <D.16021>:
  D.16020 = error->assembly_name;
  D.16023 = monoeg_strdup (D.16020);
  error->assembly_name = D.16023;
  D.16020 = error->assembly_name;
  if (D.16020 == 0B) goto <D.16024>; else goto <D.16025>;
  <D.16024>:
  D.16009 = error->flags;
  D.16019 = D.16009 | 2;
  error->flags = D.16019;
  <D.16025>:
  <D.16022>:
  D.16026 = error->member_name;
  if (D.16026 != 0B) goto <D.16027>; else goto <D.16028>;
  <D.16027>:
  D.16026 = error->member_name;
  D.16029 = monoeg_strdup (D.16026);
  error->member_name = D.16029;
  D.16026 = error->member_name;
  if (D.16026 == 0B) goto <D.16030>; else goto <D.16031>;
  <D.16030>:
  D.16009 = error->flags;
  D.16019 = D.16009 | 2;
  error->flags = D.16019;
  <D.16031>:
  <D.16028>:
  D.16032 = error->exception_name_space;
  if (D.16032 != 0B) goto <D.16033>; else goto <D.16034>;
  <D.16033>:
  D.16032 = error->exception_name_space;
  D.16035 = monoeg_strdup (D.16032);
  error->exception_name_space = D.16035;
  D.16032 = error->exception_name_space;
  if (D.16032 == 0B) goto <D.16036>; else goto <D.16037>;
  <D.16036>:
  D.16009 = error->flags;
  D.16019 = D.16009 | 2;
  error->flags = D.16019;
  <D.16037>:
  <D.16034>:
  D.16038 = error->exception_name;
  if (D.16038 != 0B) goto <D.16039>; else goto <D.16040>;
  <D.16039>:
  D.16038 = error->exception_name;
  D.16041 = monoeg_strdup (D.16038);
  error->exception_name = D.16041;
  D.16038 = error->exception_name;
  if (D.16038 == 0B) goto <D.16042>; else goto <D.16043>;
  <D.16042>:
  D.16009 = error->flags;
  D.16019 = D.16009 | 2;
  error->flags = D.16019;
  <D.16043>:
  <D.16040>:
  <D.16012>:
}


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

  if (str != 0B) goto <D.16044>; else goto <D.16045>;
  <D.16044>:
  D.16046 = __strdup (str);
  return D.16046;
  <D.16045>:
  D.16046 = 0B;
  return D.16046;
}


mono_error_set_error (struct MonoError * oerror, int error_code, const char * msg_format)
{
  short unsigned int D.16048;
  char[128] * D.16049;
  void * args.1;
  int D.16051;
  unsigned int D.16052;
  gchar * D.16055;
  const char * D.16056;
  short unsigned int D.16059;
  short unsigned int D.16060;
  struct MonoErrorInternal * error;

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

    try
      {
        __builtin_va_start (&args, 0);
        D.16049 = &error->message;
        args.1 = args;
        D.16051 = vsnprintf (D.16049, 128, msg_format, args.1);
        D.16052 = (unsigned int) D.16051;
        if (D.16052 > 127) goto <D.16053>; else goto <D.16054>;
        <D.16053>:
        __builtin_va_end (&args);
        __builtin_va_start (&args, 0);
        args.1 = args;
        D.16055 = monoeg_g_strdup_vprintf (msg_format, args.1);
        error->full_message = D.16055;
        D.16056 = error->full_message;
        if (D.16056 == 0B) goto <D.16057>; else goto <D.16058>;
        <D.16057>:
        D.16059 = error->flags;
        D.16060 = D.16059 | 2;
        error->flags = D.16060;
        <D.16058>:
        <D.16054>:
        __builtin_va_end (&args);
      }
    finally
      {
        args = {CLOBBER};
      }
  }
}


mono_error_prepare (struct MonoErrorInternal * error)
{
  short unsigned int D.16061;
  const char * D.16064;
  const char * D.16065;
  const char * D.16066;
  const char * D.16067;
  const char * D.16068;

  D.16061 = error->error_code;
  if (D.16061 != 0) goto <D.16062>; else goto <D.16063>;
  <D.16062>:
  return;
  <D.16063>:
  error->exception_name = 0B;
  D.16064 = error->exception_name;
  error->exception_name_space = D.16064;
  D.16065 = error->exception_name_space;
  error->full_message = D.16065;
  D.16066 = error->full_message;
  error->member_name = D.16066;
  D.16067 = error->member_name;
  error->assembly_name = D.16067;
  D.16068 = error->assembly_name;
  error->type_name = D.16068;
  error->klass = 0B;
  error->message[0] = 0;
}


vsnprintf (char * restrict __s, size_t __n, const char * restrict __fmt, void * __ap)
{
  int D.16070;
  unsigned int D.16071;

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


mono_error_set_assembly_load (struct MonoError * oerror, const char * assembly_name, const char * msg_format)
{
  char[128] * D.16073;
  void * args.2;
  int D.16075;
  unsigned int D.16076;
  gchar * D.16079;
  const char * D.16080;
  short unsigned int D.16083;
  short unsigned int D.16084;
  struct MonoErrorInternal * error;

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

    try
      {
        __builtin_va_start (&args, 0);
        D.16073 = &error->message;
        args.2 = args;
        D.16075 = vsnprintf (D.16073, 128, msg_format, args.2);
        D.16076 = (unsigned int) D.16075;
        if (D.16076 > 127) goto <D.16077>; else goto <D.16078>;
        <D.16077>:
        __builtin_va_end (&args);
        __builtin_va_start (&args, 0);
        args.2 = args;
        D.16079 = monoeg_g_strdup_vprintf (msg_format, args.2);
        error->full_message = D.16079;
        D.16080 = error->full_message;
        if (D.16080 == 0B) goto <D.16081>; else goto <D.16082>;
        <D.16081>:
        D.16083 = error->flags;
        D.16084 = D.16083 | 2;
        error->flags = D.16084;
        <D.16082>:
        <D.16078>:
        __builtin_va_end (&args);
      }
    finally
      {
        args = {CLOBBER};
      }
  }
}


mono_error_set_assembly_name (struct MonoError * oerror, const char * assembly_name)
{
  short unsigned int D.16085;
  _Bool D.16086;
  long int D.16087;
  long int D.16088;
  struct MonoErrorInternal * error;

  error = oerror;
  D.16085 = error->error_code;
  D.16086 = D.16085 == 0;
  D.16087 = (long int) D.16086;
  D.16088 = __builtin_expect (D.16087, 0);
  if (D.16088 != 0) goto <D.16089>; else goto <D.16090>;
  <D.16089>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mono-error.c", 140, "error->error_code != MONO_ERROR_NONE");
  <D.16090>:
  error->assembly_name = assembly_name;
}


mono_error_set_type_load_class (struct MonoError * oerror, struct MonoClass * klass, const char * msg_format)
{
  char[128] * D.16091;
  void * args.3;
  int D.16093;
  unsigned int D.16094;
  gchar * D.16097;
  const char * D.16098;
  short unsigned int D.16101;
  short unsigned int D.16102;
  struct MonoErrorInternal * error;

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

    try
      {
        __builtin_va_start (&args, 0);
        D.16091 = &error->message;
        args.3 = args;
        D.16093 = vsnprintf (D.16091, 128, msg_format, args.3);
        D.16094 = (unsigned int) D.16093;
        if (D.16094 > 127) goto <D.16095>; else goto <D.16096>;
        <D.16095>:
        __builtin_va_end (&args);
        __builtin_va_start (&args, 0);
        args.3 = args;
        D.16097 = monoeg_g_strdup_vprintf (msg_format, args.3);
        error->full_message = D.16097;
        D.16098 = error->full_message;
        if (D.16098 == 0B) goto <D.16099>; else goto <D.16100>;
        <D.16099>:
        D.16101 = error->flags;
        D.16102 = D.16101 | 2;
        error->flags = D.16102;
        <D.16100>:
        <D.16096>:
        __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.16103;
  void * args.4;
  int D.16105;
  unsigned int D.16106;
  gchar * D.16109;
  const char * D.16110;
  short unsigned int D.16113;
  short unsigned int D.16114;
  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);
  {
    void * args;

    try
      {
        __builtin_va_start (&args, 0);
        D.16103 = &error->message;
        args.4 = args;
        D.16105 = vsnprintf (D.16103, 128, msg_format, args.4);
        D.16106 = (unsigned int) D.16105;
        if (D.16106 > 127) goto <D.16107>; else goto <D.16108>;
        <D.16107>:
        __builtin_va_end (&args);
        __builtin_va_start (&args, 0);
        args.4 = args;
        D.16109 = monoeg_g_strdup_vprintf (msg_format, args.4);
        error->full_message = D.16109;
        D.16110 = error->full_message;
        if (D.16110 == 0B) goto <D.16111>; else goto <D.16112>;
        <D.16111>:
        D.16113 = error->flags;
        D.16114 = D.16113 | 2;
        error->flags = D.16114;
        <D.16112>:
        <D.16108>:
        __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.16115;
  void * args.5;
  int D.16117;
  unsigned int D.16118;
  gchar * D.16121;
  const char * D.16122;
  short unsigned int D.16125;
  short unsigned int D.16126;
  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);
  {
    void * args;

    try
      {
        __builtin_va_start (&args, 0);
        D.16115 = &error->message;
        args.5 = args;
        D.16117 = vsnprintf (D.16115, 128, msg_format, args.5);
        D.16118 = (unsigned int) D.16117;
        if (D.16118 > 127) goto <D.16119>; else goto <D.16120>;
        <D.16119>:
        __builtin_va_end (&args);
        __builtin_va_start (&args, 0);
        args.5 = args;
        D.16121 = monoeg_g_strdup_vprintf (msg_format, args.5);
        error->full_message = D.16121;
        D.16122 = error->full_message;
        if (D.16122 == 0B) goto <D.16123>; else goto <D.16124>;
        <D.16123>:
        D.16125 = error->flags;
        D.16126 = D.16125 | 2;
        error->flags = D.16126;
        <D.16124>:
        <D.16120>:
        __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.16127;
  void * args.6;
  int D.16129;
  unsigned int D.16130;
  gchar * D.16133;
  const char * D.16134;
  short unsigned int D.16137;
  short unsigned int D.16138;
  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);
  {
    void * args;

    try
      {
        __builtin_va_start (&args, 0);
        D.16127 = &error->message;
        args.6 = args;
        D.16129 = vsnprintf (D.16127, 128, msg_format, args.6);
        D.16130 = (unsigned int) D.16129;
        if (D.16130 > 127) goto <D.16131>; else goto <D.16132>;
        <D.16131>:
        __builtin_va_end (&args);
        __builtin_va_start (&args, 0);
        args.6 = args;
        D.16133 = monoeg_g_strdup_vprintf (msg_format, args.6);
        error->full_message = D.16133;
        D.16134 = error->full_message;
        if (D.16134 == 0B) goto <D.16135>; else goto <D.16136>;
        <D.16135>:
        D.16137 = error->flags;
        D.16138 = D.16137 | 2;
        error->flags = D.16138;
        <D.16136>:
        <D.16132>:
        __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.16139;
  void * args.7;
  int D.16141;
  unsigned int D.16142;
  gchar * D.16145;
  const char * D.16146;
  short unsigned int D.16149;
  short unsigned int D.16150;
  struct MonoErrorInternal * error;

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

    try
      {
        __builtin_va_start (&args, 0);
        D.16139 = &error->message;
        args.7 = args;
        D.16141 = vsnprintf (D.16139, 128, msg_format, args.7);
        D.16142 = (unsigned int) D.16141;
        if (D.16142 > 127) goto <D.16143>; else goto <D.16144>;
        <D.16143>:
        __builtin_va_end (&args);
        __builtin_va_start (&args, 0);
        args.7 = args;
        D.16145 = monoeg_g_strdup_vprintf (msg_format, args.7);
        error->full_message = D.16145;
        D.16146 = error->full_message;
        if (D.16146 == 0B) goto <D.16147>; else goto <D.16148>;
        <D.16147>:
        D.16149 = error->flags;
        D.16150 = D.16149 | 2;
        error->flags = D.16150;
        <D.16148>:
        <D.16144>:
        __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[128] * D.16155;
  void * args.9;
  int D.16157;
  unsigned int D.16158;
  gchar * D.16161;
  const char * D.16162;
  short unsigned int D.16165;
  short unsigned int D.16166;
  struct MonoErrorInternal * error;

  error = oerror;
  mono_error_prepare (error);
  error->error_code = 5;
  if (image != 0B) goto <D.16152>; else goto <D.16153>;
  <D.16152>:
  iftmp.8 = mono_image_get_name (image);
  goto <D.16154>;
  <D.16153>:
  iftmp.8 = "<no_image>";
  <D.16154>:
  error->assembly_name = iftmp.8;
  {
    void * args;

    try
      {
        __builtin_va_start (&args, 0);
        D.16155 = &error->message;
        args.9 = args;
        D.16157 = vsnprintf (D.16155, 128, msg_format, args.9);
        D.16158 = (unsigned int) D.16157;
        if (D.16158 > 127) goto <D.16159>; else goto <D.16160>;
        <D.16159>:
        __builtin_va_end (&args);
        __builtin_va_start (&args, 0);
        args.9 = args;
        D.16161 = monoeg_g_strdup_vprintf (msg_format, args.9);
        error->full_message = D.16161;
        D.16162 = error->full_message;
        if (D.16162 == 0B) goto <D.16163>; else goto <D.16164>;
        <D.16163>:
        D.16165 = error->flags;
        D.16166 = D.16165 | 2;
        error->flags = D.16166;
        <D.16164>:
        <D.16160>:
        __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.16167;
  void * args.10;
  int D.16169;
  unsigned int D.16170;
  gchar * D.16173;
  const char * D.16174;
  short unsigned int D.16177;
  short unsigned int D.16178;
  struct MonoErrorInternal * error;

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

    try
      {
        __builtin_va_start (&args, 0);
        D.16167 = &error->message;
        args.10 = args;
        D.16169 = vsnprintf (D.16167, 128, msg_format, args.10);
        D.16170 = (unsigned int) D.16169;
        if (D.16170 > 127) goto <D.16171>; else goto <D.16172>;
        <D.16171>:
        __builtin_va_end (&args);
        __builtin_va_start (&args, 0);
        args.10 = args;
        D.16173 = monoeg_g_strdup_vprintf (msg_format, args.10);
        error->full_message = D.16173;
        D.16174 = error->full_message;
        if (D.16174 == 0B) goto <D.16175>; else goto <D.16176>;
        <D.16175>:
        D.16177 = error->flags;
        D.16178 = D.16177 | 2;
        error->flags = D.16178;
        <D.16176>:
        <D.16172>:
        __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.16181;
  int D.16182;
  char * D.16183;
  const char * D.16184;
  char[128] * D.16185;
  struct MonoClass * D.16186;
  char * D.16187;
  int D.16188;
  char * D.16192;
  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.16179>; else goto <D.16180>;
  <D.16179>:
  mono_error_set_generic_error (oerror, "System", "ExecutionEngineException", "Runtime tried to produce a mono-error from an empty loader-error");
  return;
  <D.16180>:
  D.16181 = loader_error->exception_type;
  D.16182 = (int) D.16181;
  switch (D.16182) <default: <D.15892>, case 0: <D.15876>, case 1: <D.15878>, case 2: <D.15879>, case 3: <D.15880>, case 4: <D.15881>, case 5: <D.15882>, case 6: <D.15883>, case 7: <D.15884>, case 8: <D.15885>, case 9: <D.15886>, case 10: <D.15887>, case 11: <D.15889>, case 12: <D.15890>, case 13: <D.15888>, case 14: <D.15891>>
  <D.15876>:
  mono_error_set_generic_error (oerror, "System", "ExecutionEngineException", "Runtime tried to produce a mono-error from a non-error loader-error");
  goto <D.15877>;
  <D.15878>:
  <D.15879>:
  mono_error_set_generic_error (oerror, "System.Security", "SecurityException", "Failed for unknown reasons.");
  goto <D.15877>;
  <D.15880>:
  mono_error_set_generic_error (oerror, "System", "InvalidProgramException", "Failed for unknown reasons.");
  goto <D.15877>;
  <D.15881>:
  mono_error_set_generic_error (oerror, "System.Security", "VerificationException", "Failed for unknown reasons.");
  goto <D.15877>;
  <D.15882>:
  error->error_code = 1;
  D.16183 = loader_error->class_name;
  mono_error_set_type_name (oerror, D.16183);
  D.16184 = loader_error->member_name;
  mono_error_set_member_name (oerror, D.16184);
  D.16185 = &error->message;
  monoeg_g_snprintf (D.16185, 128, "Failed for unknown reasons.");
  goto <D.15877>;
  <D.15883>:
  D.16186 = loader_error->klass;
  D.16184 = loader_error->member_name;
  mono_error_set_field_load (oerror, D.16186, D.16184, "Failed for unknown reasons.");
  goto <D.15877>;
  <D.15884>:
  D.16183 = loader_error->class_name;
  D.16187 = loader_error->assembly_name;
  mono_error_set_type_load_name (oerror, D.16183, D.16187, "Failed for unknown reasons.");
  goto <D.15877>;
  <D.15885>:
  D.16188 = loader_error->ref_only;
  if (D.16188 != 0) goto <D.16189>; else goto <D.16190>;
  <D.16189>:
  D.16187 = loader_error->assembly_name;
  mono_error_set_assembly_load (oerror, D.16187, "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.16191>;
  <D.16190>:
  D.16187 = loader_error->assembly_name;
  mono_error_set_assembly_load (oerror, D.16187, "Could not load file or assembly or one of its dependencies.");
  <D.16191>:
  goto <D.15877>;
  <D.15886>:
  mono_error_set_generic_error (oerror, "System", "MethodAccessException", "Failed for unknown reasons.");
  goto <D.15877>;
  <D.15887>:
  mono_error_set_generic_error (oerror, "System", "FieldAccessException", "Failed for unknown reasons.");
  goto <D.15877>;
  <D.15888>:
  <D.15889>:
  D.16181 = loader_error->exception_type;
  D.16182 = (int) D.16181;
  mono_error_set_generic_error (oerror, "System", "ExecutionEngineException", "Runtime tried to produce a mono-error from JIT internal error %d", D.16182);
  goto <D.15877>;
  <D.15890>:
  D.16192 = loader_error->msg;
  mono_error_set_bad_image_name (oerror, "<unknown>", "%s", D.16192);
  goto <D.15877>;
  <D.15891>:
  mono_error_set_out_of_memory (oerror, "Failed for unknown reasons.");
  goto <D.15877>;
  <D.15892>:
  D.16181 = loader_error->exception_type;
  D.16182 = (int) D.16181;
  mono_error_set_generic_error (oerror, "System", "ExecutionEngineException", "Runtime tried to produce an unknown loader-error %d", D.16182);
  goto <D.15877>;
  <D.15877>:
  mono_error_dup_strings (oerror, 1);
  mono_loader_clear_error ();
}


mono_loader_set_error_from_mono_error (struct MonoError * oerror)
{
  short unsigned int D.16194;
  int D.16195;
  const char * D.16196;
  const char * D.16197;
  struct MonoClass * D.16198;
  const char * D.16199;
  const char * D.16200;
  const char * D.16201;
  const gchar * iftmp.11;
  const char * D.16203;
  gchar * D.16207;
  const char * iftmp.12;
  gchar * D.16212;
  struct MonoErrorInternal * error;

  error = oerror;
  D.16194 = error->error_code;
  D.16195 = (int) D.16194;
  switch (D.16195) <default: <D.15909>, case 1: <D.15903>, case 2: <D.15905>, case 3: <D.15906>, case 4: <D.15907>, case 5: <D.15908>>
  <D.15903>:
  D.16196 = get_type_name (error);
  D.16197 = error->member_name;
  mono_loader_set_error_method_load (D.16196, D.16197);
  goto <D.15904>;
  <D.15905>:
  D.16198 = error->klass;
  D.16197 = error->member_name;
  mono_loader_set_error_field_load (D.16198, D.16197);
  goto <D.15904>;
  <D.15906>:
  D.16199 = get_type_name (error);
  D.16200 = get_assembly_name (error);
  mono_loader_set_error_type_load (D.16199, D.16200);
  goto <D.15904>;
  <D.15907>:
  D.16201 = get_assembly_name (error);
  mono_loader_set_error_assembly_load (D.16201, 0);
  goto <D.15904>;
  <D.15908>:
  D.16203 = error->full_message;
  if (D.16203 != 0B) goto <D.16204>; else goto <D.16205>;
  <D.16204>:
  iftmp.11 = error->full_message;
  goto <D.16206>;
  <D.16205>:
  iftmp.11 = &error->message;
  <D.16206>:
  D.16207 = monoeg_strdup (iftmp.11);
  mono_loader_set_error_bad_image (D.16207);
  goto <D.15904>;
  <D.15909>:
  D.16203 = error->full_message;
  if (D.16203 != 0B) goto <D.16209>; else goto <D.16210>;
  <D.16209>:
  iftmp.12 = error->full_message;
  goto <D.16211>;
  <D.16210>:
  iftmp.12 = &error->message;
  <D.16211>:
  D.16212 = monoeg_g_strdup_printf ("Non translatable error: %s", iftmp.12);
  mono_loader_set_error_bad_image (D.16212);
  <D.15904>:
}


get_type_name (struct MonoErrorInternal * error)
{
  const char * D.16213;
  const char * D.16216;
  struct MonoClass * D.16217;

  D.16213 = error->type_name;
  if (D.16213 != 0B) goto <D.16214>; else goto <D.16215>;
  <D.16214>:
  D.16216 = error->type_name;
  return D.16216;
  <D.16215>:
  D.16217 = error->klass;
  if (D.16217 != 0B) goto <D.16218>; else goto <D.16219>;
  <D.16218>:
  D.16217 = error->klass;
  D.16216 = D.16217->name;
  return D.16216;
  <D.16219>:
  D.16216 = "<unknown type>";
  return D.16216;
}


get_assembly_name (struct MonoErrorInternal * error)
{
  const char * D.16221;
  const char * D.16224;
  struct MonoClass * D.16225;
  struct MonoImage * D.16228;

  D.16221 = error->assembly_name;
  if (D.16221 != 0B) goto <D.16222>; else goto <D.16223>;
  <D.16222>:
  D.16224 = error->assembly_name;
  return D.16224;
  <D.16223>:
  D.16225 = error->klass;
  if (D.16225 != 0B) goto <D.16226>; else goto <D.16227>;
  <D.16226>:
  D.16225 = error->klass;
  D.16228 = D.16225->image;
  if (D.16228 != 0B) goto <D.16229>; else goto <D.16230>;
  <D.16229>:
  D.16225 = error->klass;
  D.16228 = D.16225->image;
  D.16224 = D.16228->name;
  return D.16224;
  <D.16230>:
  <D.16227>:
  D.16224 = "<unknown assembly>";
  return D.16224;
}


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

  try
    {
      error = oerror;
      mono_error_prepare (error);
      error->error_code = 6;
      __builtin_va_start (&args, 0);
      D.16232 = &error->message;
      args.13 = args;
      vsnprintf (D.16232, 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[128] * D.16234;
  void * args.14;
  int D.16236;
  unsigned int D.16237;
  gchar * D.16240;
  const char * D.16241;
  short unsigned int D.16244;
  short unsigned int D.16245;
  struct MonoErrorInternal * error;

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

    try
      {
        __builtin_va_start (&args, 0);
        D.16234 = &error->message;
        args.14 = args;
        D.16236 = vsnprintf (D.16234, 128, msg_format, args.14);
        D.16237 = (unsigned int) D.16236;
        if (D.16237 > 127) goto <D.16238>; else goto <D.16239>;
        <D.16238>:
        __builtin_va_end (&args);
        __builtin_va_start (&args, 0);
        args.14 = args;
        D.16240 = monoeg_g_strdup_vprintf (msg_format, args.14);
        error->full_message = D.16240;
        D.16241 = error->full_message;
        if (D.16241 == 0B) goto <D.16242>; else goto <D.16243>;
        <D.16242>:
        D.16244 = error->flags;
        D.16245 = D.16244 | 2;
        error->flags = D.16245;
        <D.16243>:
        <D.16239>:
        __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.16246;
  char * D.16249;
  char[128] * D.16250;
  void * args.15;
  int D.16252;
  unsigned int D.16253;
  gchar * D.16256;
  const char * D.16257;
  short unsigned int D.16260;
  short unsigned int D.16261;
  struct MonoErrorInternal * error;

  error = oerror;
  mono_error_prepare (error);
  error->error_code = 8;
  D.16246 = method->klass;
  mono_error_set_class (oerror, D.16246);
  if (method != 0B) goto <D.16247>; else goto <D.16248>;
  <D.16247>:
  D.16249 = mono_method_full_name (method, 1);
  mono_error_set_member_name (oerror, D.16249);
  <D.16248>:
  {
    void * args;

    try
      {
        __builtin_va_start (&args, 0);
        D.16250 = &error->message;
        args.15 = args;
        D.16252 = vsnprintf (D.16250, 128, msg_format, args.15);
        D.16253 = (unsigned int) D.16252;
        if (D.16253 > 127) goto <D.16254>; else goto <D.16255>;
        <D.16254>:
        __builtin_va_end (&args);
        __builtin_va_start (&args, 0);
        args.15 = args;
        D.16256 = monoeg_g_strdup_vprintf (msg_format, args.15);
        error->full_message = D.16256;
        D.16257 = error->full_message;
        if (D.16257 == 0B) goto <D.16258>; else goto <D.16259>;
        <D.16258>:
        D.16260 = error->flags;
        D.16261 = D.16260 | 2;
        error->flags = D.16261;
        <D.16259>:
        <D.16255>:
        __builtin_va_end (&args);
      }
    finally
      {
        args = {CLOBBER};
      }
  }
}


mono_error_prepare_exception (struct MonoError * oerror, struct MonoError * error_out)
{
  short unsigned int D.16262;
  int D.16263;
  struct MonoException * D.16264;
  const char * D.16268;
  struct MonoClass * D.16270;
  const char * D.16271;
  int D.16273;
  struct MonoImage * D.16277;
  const char * iftmp.16;
  const char * D.16281;
  int D.16290;
  const char * iftmp.17;
  const char * D.16304;
  int D.16305;
  struct MonoImage * D.16311;
  const char * iftmp.18;
  const char * iftmp.19;
  struct MonoImage * D.16332;
  struct MonoImage * D.16337;
  const char * iftmp.20;
  const char * iftmp.21;
  const char * iftmp.22;
  const char * iftmp.23;
  const char * D.16364;
  const char * D.16366;
  const char * iftmp.24;
  int D.16371;
  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.16262 = error->error_code;
  D.16263 = (int) D.16262;
  switch (D.16263) <default: <D.15968>, case 0: <D.15955>, case 1: <D.15956>, case 2: <D.15958>, case 3: <D.15959>, case 4: <D.15960>, case 5: <D.15961>, case 6: <D.15962>, case 7: <D.15963>, case 8: <D.15964>, case 9: <D.15967>>
  <D.15955>:
  D.16264 = 0B;
  return D.16264;
  <D.15956>:
  D.16268 = error->type_name;
  if (D.16268 != 0B) goto <D.16265>; else goto <D.16269>;
  <D.16269>:
  D.16270 = error->klass;
  if (D.16270 != 0B) goto <D.16265>; else goto <D.16266>;
  <D.16265>:
  D.16271 = error->member_name;
  if (D.16271 != 0B) goto <D.16272>; else goto <D.16266>;
  <D.16272>:
  type_name = get_type_name_as_mono_string (error, domain, error_out);
  D.16273 = mono_error_ok (error_out);
  if (D.16273 == 0) goto <D.15957>; else goto <D.16274>;
  <D.16274>:
  D.16271 = error->member_name;
  method_name = mono_string_new (domain, D.16271);
  if (method_name == 0B) goto <D.16275>; else goto <D.16276>;
  <D.16275>:
  mono_error_set_out_of_memory (error_out, "Could not allocate method name");
  goto <D.15957>;
  <D.16276>:
  D.16277 = mono_defaults.corlib;
  exception = mono_exception_from_name_two_strings (D.16277, "System", "MissingMethodException", type_name, method_name);
  if (exception != 0B) goto <D.16278>; else goto <D.16279>;
  <D.16278>:
  set_message_on_exception (exception, error, error_out);
  <D.16279>:
  goto <D.16267>;
  <D.16266>:
  D.16277 = mono_defaults.corlib;
  D.16281 = error->full_message;
  if (D.16281 != 0B) goto <D.16282>; else goto <D.16283>;
  <D.16282>:
  iftmp.16 = error->full_message;
  goto <D.16284>;
  <D.16283>:
  iftmp.16 = &error->message;
  <D.16284>:
  exception = mono_exception_from_name_msg (D.16277, "System", "MissingMethodException", iftmp.16);
  <D.16267>:
  goto <D.15957>;
  <D.15958>:
  D.16268 = error->type_name;
  if (D.16268 != 0B) goto <D.16285>; else goto <D.16288>;
  <D.16288>:
  D.16270 = error->klass;
  if (D.16270 != 0B) goto <D.16285>; else goto <D.16286>;
  <D.16285>:
  D.16271 = error->member_name;
  if (D.16271 != 0B) goto <D.16289>; else goto <D.16286>;
  <D.16289>:
  type_name = get_type_name_as_mono_string (error, domain, error_out);
  D.16290 = mono_error_ok (error_out);
  if (D.16290 == 0) goto <D.15957>; else goto <D.16291>;
  <D.16291>:
  D.16271 = error->member_name;
  field_name = mono_string_new (domain, D.16271);
  if (field_name == 0B) goto <D.16292>; else goto <D.16293>;
  <D.16292>:
  mono_error_set_out_of_memory (error_out, "Could not allocate field name");
  goto <D.15957>;
  <D.16293>:
  D.16277 = mono_defaults.corlib;
  exception = mono_exception_from_name_two_strings (D.16277, "System", "MissingFieldException", type_name, field_name);
  if (exception != 0B) goto <D.16294>; else goto <D.16295>;
  <D.16294>:
  set_message_on_exception (exception, error, error_out);
  <D.16295>:
  goto <D.16287>;
  <D.16286>:
  D.16277 = mono_defaults.corlib;
  D.16281 = error->full_message;
  if (D.16281 != 0B) goto <D.16297>; else goto <D.16298>;
  <D.16297>:
  iftmp.17 = error->full_message;
  goto <D.16299>;
  <D.16298>:
  iftmp.17 = &error->message;
  <D.16299>:
  exception = mono_exception_from_name_msg (D.16277, "System", "MissingFieldException", iftmp.17);
  <D.16287>:
  goto <D.15957>;
  <D.15959>:
  D.16268 = error->type_name;
  if (D.16268 != 0B) goto <D.16300>; else goto <D.16303>;
  <D.16303>:
  D.16304 = error->assembly_name;
  if (D.16304 != 0B) goto <D.16300>; else goto <D.16301>;
  <D.16300>:
  type_name = get_type_name_as_mono_string (error, domain, error_out);
  D.16305 = mono_error_ok (error_out);
  if (D.16305 == 0) goto <D.15957>; else goto <D.16306>;
  <D.16306>:
  D.16304 = error->assembly_name;
  if (D.16304 != 0B) goto <D.16307>; else goto <D.16308>;
  <D.16307>:
  D.16304 = error->assembly_name;
  assembly_name = mono_string_new (domain, D.16304);
  if (assembly_name == 0B) goto <D.16309>; else goto <D.16310>;
  <D.16309>:
  mono_error_set_out_of_memory (error_out, "Could not allocate assembly name");
  goto <D.15957>;
  <D.16310>:
  <D.16308>:
  D.16311 = mono_get_corlib ();
  exception = mono_exception_from_name_two_strings (D.16311, "System", "TypeLoadException", type_name, assembly_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.16302>;
  <D.16301>:
  D.16277 = mono_defaults.corlib;
  D.16281 = error->full_message;
  if (D.16281 != 0B) goto <D.16315>; else goto <D.16316>;
  <D.16315>:
  iftmp.18 = error->full_message;
  goto <D.16317>;
  <D.16316>:
  iftmp.18 = &error->message;
  <D.16317>:
  exception = mono_exception_from_name_msg (D.16277, "System", "TypeLoadException", iftmp.18);
  <D.16302>:
  goto <D.15957>;
  <D.15960>:
  <D.15961>:
  D.16304 = error->assembly_name;
  if (D.16304 != 0B) goto <D.16318>; else goto <D.16319>;
  <D.16318>:
  D.16281 = error->full_message;
  if (D.16281 != 0B) goto <D.16321>; else goto <D.16322>;
  <D.16321>:
  iftmp.19 = error->full_message;
  goto <D.16323>;
  <D.16322>:
  iftmp.19 = &error->message;
  <D.16323>:
  msg = mono_string_new (domain, iftmp.19);
  if (msg == 0B) goto <D.16324>; else goto <D.16325>;
  <D.16324>:
  mono_error_set_out_of_memory (error_out, "Could not allocate message");
  goto <D.15957>;
  <D.16325>:
  D.16304 = error->assembly_name;
  if (D.16304 != 0B) goto <D.16326>; else goto <D.16327>;
  <D.16326>:
  D.16304 = error->assembly_name;
  assembly_name = mono_string_new (domain, D.16304);
  if (assembly_name == 0B) goto <D.16328>; else goto <D.16329>;
  <D.16328>:
  mono_error_set_out_of_memory (error_out, "Could not allocate assembly name");
  goto <D.15957>;
  <D.16329>:
  <D.16327>:
  D.16262 = error->error_code;
  if (D.16262 == 4) goto <D.16330>; else goto <D.16331>;
  <D.16330>:
  D.16332 = mono_get_corlib ();
  exception = mono_exception_from_name_two_strings (D.16332, "System.IO", "FileNotFoundException", msg, assembly_name);
  goto <D.16333>;
  <D.16331>:
  D.16277 = mono_defaults.corlib;
  exception = mono_exception_from_name_two_strings (D.16277, "System", "BadImageFormatException", msg, assembly_name);
  <D.16333>:
  goto <D.16334>;
  <D.16319>:
  D.16262 = error->error_code;
  if (D.16262 == 4) goto <D.16335>; else goto <D.16336>;
  <D.16335>:
  D.16337 = mono_get_corlib ();
  D.16281 = error->full_message;
  if (D.16281 != 0B) goto <D.16339>; else goto <D.16340>;
  <D.16339>:
  iftmp.20 = error->full_message;
  goto <D.16341>;
  <D.16340>:
  iftmp.20 = &error->message;
  <D.16341>:
  exception = mono_exception_from_name_msg (D.16337, "System.IO", "FileNotFoundException", iftmp.20);
  goto <D.16342>;
  <D.16336>:
  D.16277 = mono_defaults.corlib;
  D.16281 = error->full_message;
  if (D.16281 != 0B) goto <D.16344>; else goto <D.16345>;
  <D.16344>:
  iftmp.21 = error->full_message;
  goto <D.16346>;
  <D.16345>:
  iftmp.21 = &error->message;
  <D.16346>:
  exception = mono_exception_from_name_msg (D.16277, "System", "BadImageFormatException", iftmp.21);
  <D.16342>:
  <D.16334>:
  goto <D.15957>;
  <D.15962>:
  exception = mono_get_exception_out_of_memory ();
  goto <D.15957>;
  <D.15963>:
  D.16268 = error->type_name;
  D.16281 = error->full_message;
  if (D.16281 != 0B) goto <D.16348>; else goto <D.16349>;
  <D.16348>:
  iftmp.22 = error->full_message;
  goto <D.16350>;
  <D.16349>:
  iftmp.22 = &error->message;
  <D.16350>:
  exception = mono_get_exception_argument (D.16268, iftmp.22);
  goto <D.15957>;
  <D.15964>:
  {
    char * type_name;
    char * message;

    type_name = 0B;
    D.16270 = error->klass;
    if (D.16270 != 0B) goto <D.16351>; else goto <D.16352>;
    <D.16351>:
    D.16270 = error->klass;
    type_name = mono_type_get_full_name (D.16270);
    if (type_name == 0B) goto <D.16353>; else goto <D.16354>;
    <D.16353>:
    mono_error_set_out_of_memory (error_out, "Could not allocate message");
    goto <D.15957>;
    <D.16354>:
    <D.16352>:
    D.16271 = error->member_name;
    D.16281 = error->full_message;
    if (D.16281 != 0B) goto <D.16356>; else goto <D.16357>;
    <D.16356>:
    iftmp.23 = error->full_message;
    goto <D.16358>;
    <D.16357>:
    iftmp.23 = &error->message;
    <D.16358>:
    message = monoeg_g_strdup_printf ("Error in %s:%s %s", type_name, D.16271, iftmp.23);
    if (message == 0B) goto <D.16359>; else goto <D.16360>;
    <D.16359>:
    monoeg_g_free (type_name);
    mono_error_set_out_of_memory (error_out, "Could not allocate message");
    goto <D.15957>;
    <D.16360>:
    D.16277 = mono_defaults.corlib;
    exception = mono_exception_from_name_msg (D.16277, "System.Security", "VerificationException", message);
    monoeg_g_free (message);
    monoeg_g_free (type_name);
    goto <D.15957>;
  }
  <D.15967>:
  D.16364 = error->exception_name_space;
  if (D.16364 == 0B) goto <D.16361>; else goto <D.16365>;
  <D.16365>:
  D.16366 = error->exception_name;
  if (D.16366 == 0B) goto <D.16361>; else goto <D.16362>;
  <D.16361>:
  mono_error_set_generic_error (error_out, "System", "ExecutionEngineException", "MonoError with generic error but no exception name was supplied");
  goto <D.16363>;
  <D.16362>:
  D.16277 = mono_defaults.corlib;
  D.16364 = error->exception_name_space;
  D.16366 = error->exception_name;
  D.16281 = error->full_message;
  if (D.16281 != 0B) goto <D.16368>; else goto <D.16369>;
  <D.16368>:
  iftmp.24 = error->full_message;
  goto <D.16370>;
  <D.16369>:
  iftmp.24 = &error->message;
  <D.16370>:
  exception = mono_exception_from_name_msg (D.16277, D.16364, D.16366, iftmp.24);
  <D.16363>:
  goto <D.15957>;
  <D.15968>:
  D.16262 = error->error_code;
  D.16263 = (int) D.16262;
  mono_error_set_generic_error (error_out, "System", "ExecutionEngineException", "Invalid error-code %d", D.16263);
  <D.15957>:
  D.16371 = mono_error_ok (error_out);
  if (D.16371 == 0) goto <D.16372>; else goto <D.16373>;
  <D.16372>:
  D.16264 = 0B;
  return D.16264;
  <D.16373>:
  if (exception == 0B) goto <D.16374>; else goto <D.16375>;
  <D.16374>:
  mono_error_set_out_of_memory (error_out, "Could not allocate exception object");
  <D.16375>:
  D.16264 = exception;
  return D.16264;
}


get_type_name_as_mono_string (struct MonoErrorInternal * error, struct MonoDomain * domain, struct MonoError * error_out)
{
  const char * D.16377;
  struct MonoClass * D.16381;
  struct MonoType * D.16384;
  struct MonoString * D.16389;
  struct MonoString * res;

  res = 0B;
  D.16377 = error->type_name;
  if (D.16377 != 0B) goto <D.16378>; else goto <D.16379>;
  <D.16378>:
  D.16377 = error->type_name;
  res = mono_string_new (domain, D.16377);
  goto <D.16380>;
  <D.16379>:
  D.16381 = error->klass;
  if (D.16381 != 0B) goto <D.16382>; else goto <D.16383>;
  <D.16382>:
  {
    char * name;

    D.16381 = error->klass;
    D.16384 = &D.16381->byval_arg;
    name = mono_type_full_name (D.16384);
    if (name != 0B) goto <D.16385>; else goto <D.16386>;
    <D.16385>:
    res = mono_string_new (domain, name);
    monoeg_g_free (name);
    <D.16386>:
  }
  <D.16383>:
  <D.16380>:
  if (res == 0B) goto <D.16387>; else goto <D.16388>;
  <D.16387>:
  mono_error_set_out_of_memory (error_out, "Could not allocate type name");
  <D.16388>:
  D.16389 = res;
  return D.16389;
}


set_message_on_exception (struct MonoException * exception, struct MonoErrorInternal * error, struct MonoError * error_out)
{
  struct MonoDomain * D.16391;
  const char * iftmp.25;
  const char * D.16393;
  struct MonoString * * D.16399;
  struct MonoString * msg;

  D.16391 = mono_domain_get ();
  D.16393 = error->full_message;
  if (D.16393 != 0B) goto <D.16394>; else goto <D.16395>;
  <D.16394>:
  iftmp.25 = error->full_message;
  goto <D.16396>;
  <D.16395>:
  iftmp.25 = &error->message;
  <D.16396>:
  msg = mono_string_new (D.16391, iftmp.25);
  if (msg != 0B) goto <D.16397>; else goto <D.16398>;
  <D.16397>:
  D.16399 = &exception->message;
  mono_gc_wbarrier_set_field (exception, D.16399, msg);
  goto <D.16400>;
  <D.16398>:
  mono_error_set_out_of_memory (error_out, "Could not allocate exception object");
  <D.16400>:
}


mono_error_raise_exception (struct MonoError * target_error)
{
  int D.16401;
  int D.16404;
  int D.16407;
  _Bool D.16408;
  long int D.16409;
  long int D.16410;
  struct MonoError error;
  struct MonoException * ex;

  try
    {
      D.16401 = mono_error_ok (target_error);
      if (D.16401 != 0) goto <D.16402>; else goto <D.16403>;
      <D.16402>:
      return;
      <D.16403>:
      ex = mono_error_prepare_exception (target_error, &error);
      D.16404 = mono_error_ok (&error);
      if (D.16404 == 0) goto <D.16405>; else goto <D.16406>;
      <D.16405>:
      {
        struct MonoError second_chance;

        try
          {
            ex = mono_error_prepare_exception (&error, &second_chance);
            D.16407 = mono_error_ok (&second_chance);
            D.16408 = D.16407 == 0;
            D.16409 = (long int) D.16408;
            D.16410 = __builtin_expect (D.16409, 0);
            if (D.16410 != 0) goto <D.16411>; else goto <D.16412>;
            <D.16411>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mono-error.c", 646, "mono_error_ok (&second_chance)");
            <D.16412>:
            mono_error_cleanup (&error);
          }
        finally
          {
            second_chance = {CLOBBER};
          }
      }
      <D.16406>:
      mono_error_cleanup (target_error);
      mono_raise_exception (ex);
    }
  finally
    {
      error = {CLOBBER};
    }
}