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

  error = oerror;
  if (0 != 0) goto <D.16904>; else goto <D.16905>;
  <D.16904>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mono-error.c", 47, "sizeof (MonoError) == sizeof (MonoErrorInternal)");
  <D.16905>:
  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.16906;
  const char * D.16909;
  short unsigned int D.16910;
  int D.16911;
  int D.16912;
  const char * D.16915;
  const char * D.16916;
  const char * D.16917;
  const char * D.16918;
  const char * D.16919;
  struct MonoErrorInternal * error;

  error = oerror;
  D.16906 = error->error_code;
  if (D.16906 == 0) goto <D.16907>; else goto <D.16908>;
  <D.16907>:
  return;
  <D.16908>:
  D.16909 = error->full_message;
  monoeg_g_free (D.16909);
  D.16910 = error->flags;
  D.16911 = (int) D.16910;
  D.16912 = D.16911 & 1;
  if (D.16912 == 0) goto <D.16913>; else goto <D.16914>;
  <D.16913>:
  return;
  <D.16914>:
  D.16915 = error->type_name;
  monoeg_g_free (D.16915);
  D.16916 = error->assembly_name;
  monoeg_g_free (D.16916);
  D.16917 = error->member_name;
  monoeg_g_free (D.16917);
  D.16918 = error->exception_name_space;
  monoeg_g_free (D.16918);
  D.16919 = error->exception_name;
  monoeg_g_free (D.16919);
}


mono_error_ok (struct MonoError * error)
{
  mono_bool D.16921;
  short unsigned int D.16922;
  _Bool D.16923;

  D.16922 = error->error_code;
  D.16923 = D.16922 == 0;
  D.16921 = (mono_bool) D.16923;
  return D.16921;
}


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

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


mono_error_get_message (struct MonoError * oerror)
{
  short unsigned int D.16927;
  const char * D.16930;
  const char * iftmp.0;
  const char * D.16932;
  struct MonoErrorInternal * error;

  error = oerror;
  D.16927 = error->error_code;
  if (D.16927 == 0) goto <D.16928>; else goto <D.16929>;
  <D.16928>:
  D.16930 = 0B;
  return D.16930;
  <D.16929>:
  D.16932 = error->full_message;
  if (D.16932 != 0B) goto <D.16933>; else goto <D.16934>;
  <D.16933>:
  iftmp.0 = error->full_message;
  goto <D.16935>;
  <D.16934>:
  iftmp.0 = &error->message;
  <D.16935>:
  D.16930 = iftmp.0;
  return D.16930;
}


mono_error_dup_strings (struct MonoError * oerror, gboolean dup_strings)
{
  short unsigned int D.16937;
  short unsigned int D.16938;
  const char * D.16941;
  gchar * D.16944;
  short unsigned int D.16947;
  const char * D.16948;
  gchar * D.16951;
  const char * D.16954;
  gchar * D.16957;
  const char * D.16960;
  gchar * D.16963;
  const char * D.16966;
  gchar * D.16969;
  struct MonoErrorInternal * error;

  error = oerror;
  D.16937 = error->flags;
  D.16938 = D.16937 | 1;
  error->flags = D.16938;
  if (dup_strings != 0) goto <D.16939>; else goto <D.16940>;
  <D.16939>:
  D.16941 = error->type_name;
  if (D.16941 != 0B) goto <D.16942>; else goto <D.16943>;
  <D.16942>:
  D.16941 = error->type_name;
  D.16944 = monoeg_strdup (D.16941);
  error->type_name = D.16944;
  D.16941 = error->type_name;
  if (D.16941 == 0B) goto <D.16945>; else goto <D.16946>;
  <D.16945>:
  D.16937 = error->flags;
  D.16947 = D.16937 | 2;
  error->flags = D.16947;
  <D.16946>:
  <D.16943>:
  D.16948 = error->assembly_name;
  if (D.16948 != 0B) goto <D.16949>; else goto <D.16950>;
  <D.16949>:
  D.16948 = error->assembly_name;
  D.16951 = monoeg_strdup (D.16948);
  error->assembly_name = D.16951;
  D.16948 = error->assembly_name;
  if (D.16948 == 0B) goto <D.16952>; else goto <D.16953>;
  <D.16952>:
  D.16937 = error->flags;
  D.16947 = D.16937 | 2;
  error->flags = D.16947;
  <D.16953>:
  <D.16950>:
  D.16954 = error->member_name;
  if (D.16954 != 0B) goto <D.16955>; else goto <D.16956>;
  <D.16955>:
  D.16954 = error->member_name;
  D.16957 = monoeg_strdup (D.16954);
  error->member_name = D.16957;
  D.16954 = error->member_name;
  if (D.16954 == 0B) goto <D.16958>; else goto <D.16959>;
  <D.16958>:
  D.16937 = error->flags;
  D.16947 = D.16937 | 2;
  error->flags = D.16947;
  <D.16959>:
  <D.16956>:
  D.16960 = error->exception_name_space;
  if (D.16960 != 0B) goto <D.16961>; else goto <D.16962>;
  <D.16961>:
  D.16960 = error->exception_name_space;
  D.16963 = monoeg_strdup (D.16960);
  error->exception_name_space = D.16963;
  D.16960 = error->exception_name_space;
  if (D.16960 == 0B) goto <D.16964>; else goto <D.16965>;
  <D.16964>:
  D.16937 = error->flags;
  D.16947 = D.16937 | 2;
  error->flags = D.16947;
  <D.16965>:
  <D.16962>:
  D.16966 = error->exception_name;
  if (D.16966 != 0B) goto <D.16967>; else goto <D.16968>;
  <D.16967>:
  D.16966 = error->exception_name;
  D.16969 = monoeg_strdup (D.16966);
  error->exception_name = D.16969;
  D.16966 = error->exception_name;
  if (D.16966 == 0B) goto <D.16970>; else goto <D.16971>;
  <D.16970>:
  D.16937 = error->flags;
  D.16947 = D.16937 | 2;
  error->flags = D.16947;
  <D.16971>:
  <D.16968>:
  <D.16940>:
}


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

  if (str != 0B) goto <D.16972>; else goto <D.16973>;
  <D.16972>:
  D.16974 = __strdup (str);
  return D.16974;
  <D.16973>:
  D.16974 = 0B;
  return D.16974;
}


mono_error_set_error (struct MonoError * oerror, int error_code, const char * msg_format)
{
  short unsigned int D.16976;
  char[128] * D.16977;
  char * args.1;
  int D.16979;
  unsigned int D.16980;
  gchar * D.16983;
  const char * D.16984;
  short unsigned int D.16987;
  short unsigned int D.16988;
  struct MonoErrorInternal * error;

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

    try
      {
        __builtin_va_start (&args, 0);
        D.16977 = &error->message;
        args.1 = args;
        D.16979 = vsnprintf (D.16977, 128, msg_format, args.1);
        D.16980 = (unsigned int) D.16979;
        if (D.16980 > 127) goto <D.16981>; else goto <D.16982>;
        <D.16981>:
        __builtin_va_end (&args);
        __builtin_va_start (&args, 0);
        args.1 = args;
        D.16983 = monoeg_g_strdup_vprintf (msg_format, args.1);
        error->full_message = D.16983;
        D.16984 = error->full_message;
        if (D.16984 == 0B) goto <D.16985>; else goto <D.16986>;
        <D.16985>:
        D.16987 = error->flags;
        D.16988 = D.16987 | 2;
        error->flags = D.16988;
        <D.16986>:
        <D.16982>:
        __builtin_va_end (&args);
      }
    finally
      {
        args = {CLOBBER};
      }
  }
}


mono_error_prepare (struct MonoErrorInternal * error)
{
  short unsigned int D.16989;
  const char * D.16992;
  const char * D.16993;
  const char * D.16994;
  const char * D.16995;
  const char * D.16996;

  D.16989 = error->error_code;
  if (D.16989 != 0) goto <D.16990>; else goto <D.16991>;
  <D.16990>:
  return;
  <D.16991>:
  error->exception_name = 0B;
  D.16992 = error->exception_name;
  error->exception_name_space = D.16992;
  D.16993 = error->exception_name_space;
  error->full_message = D.16993;
  D.16994 = error->full_message;
  error->member_name = D.16994;
  D.16995 = error->member_name;
  error->assembly_name = D.16995;
  D.16996 = error->assembly_name;
  error->type_name = D.16996;
  error->klass = 0B;
  error->message[0] = 0;
}


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

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


mono_error_set_assembly_load (struct MonoError * oerror, const char * assembly_name, const char * msg_format)
{
  char[128] * D.17001;
  char * args.2;
  int D.17003;
  unsigned int D.17004;
  gchar * D.17007;
  const char * D.17008;
  short unsigned int D.17011;
  short unsigned int D.17012;
  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);
        D.17001 = &error->message;
        args.2 = args;
        D.17003 = vsnprintf (D.17001, 128, msg_format, args.2);
        D.17004 = (unsigned int) D.17003;
        if (D.17004 > 127) goto <D.17005>; else goto <D.17006>;
        <D.17005>:
        __builtin_va_end (&args);
        __builtin_va_start (&args, 0);
        args.2 = args;
        D.17007 = monoeg_g_strdup_vprintf (msg_format, args.2);
        error->full_message = D.17007;
        D.17008 = error->full_message;
        if (D.17008 == 0B) goto <D.17009>; else goto <D.17010>;
        <D.17009>:
        D.17011 = error->flags;
        D.17012 = D.17011 | 2;
        error->flags = D.17012;
        <D.17010>:
        <D.17006>:
        __builtin_va_end (&args);
      }
    finally
      {
        args = {CLOBBER};
      }
  }
}


mono_error_set_assembly_name (struct MonoError * oerror, const char * assembly_name)
{
  short unsigned int D.17013;
  _Bool D.17014;
  long int D.17015;
  long int D.17016;
  struct MonoErrorInternal * error;

  error = oerror;
  D.17013 = error->error_code;
  D.17014 = D.17013 == 0;
  D.17015 = (long int) D.17014;
  D.17016 = __builtin_expect (D.17015, 0);
  if (D.17016 != 0) goto <D.17017>; else goto <D.17018>;
  <D.17017>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mono-error.c", 140, "error->error_code != MONO_ERROR_NONE");
  <D.17018>:
  error->assembly_name = assembly_name;
}


mono_error_set_type_load_class (struct MonoError * oerror, struct MonoClass * klass, const char * msg_format)
{
  char[128] * D.17019;
  char * args.3;
  int D.17021;
  unsigned int D.17022;
  gchar * D.17025;
  const char * D.17026;
  short unsigned int D.17029;
  short unsigned int D.17030;
  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);
        D.17019 = &error->message;
        args.3 = args;
        D.17021 = vsnprintf (D.17019, 128, msg_format, args.3);
        D.17022 = (unsigned int) D.17021;
        if (D.17022 > 127) goto <D.17023>; else goto <D.17024>;
        <D.17023>:
        __builtin_va_end (&args);
        __builtin_va_start (&args, 0);
        args.3 = args;
        D.17025 = monoeg_g_strdup_vprintf (msg_format, args.3);
        error->full_message = D.17025;
        D.17026 = error->full_message;
        if (D.17026 == 0B) goto <D.17027>; else goto <D.17028>;
        <D.17027>:
        D.17029 = error->flags;
        D.17030 = D.17029 | 2;
        error->flags = D.17030;
        <D.17028>:
        <D.17024>:
        __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.17031;
  char * args.4;
  int D.17033;
  unsigned int D.17034;
  gchar * D.17037;
  const char * D.17038;
  short unsigned int D.17041;
  short unsigned int D.17042;
  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);
        D.17031 = &error->message;
        args.4 = args;
        D.17033 = vsnprintf (D.17031, 128, msg_format, args.4);
        D.17034 = (unsigned int) D.17033;
        if (D.17034 > 127) goto <D.17035>; else goto <D.17036>;
        <D.17035>:
        __builtin_va_end (&args);
        __builtin_va_start (&args, 0);
        args.4 = args;
        D.17037 = monoeg_g_strdup_vprintf (msg_format, args.4);
        error->full_message = D.17037;
        D.17038 = error->full_message;
        if (D.17038 == 0B) goto <D.17039>; else goto <D.17040>;
        <D.17039>:
        D.17041 = error->flags;
        D.17042 = D.17041 | 2;
        error->flags = D.17042;
        <D.17040>:
        <D.17036>:
        __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.17043;
  char * args.5;
  int D.17045;
  unsigned int D.17046;
  gchar * D.17049;
  const char * D.17050;
  short unsigned int D.17053;
  short unsigned int D.17054;
  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);
        D.17043 = &error->message;
        args.5 = args;
        D.17045 = vsnprintf (D.17043, 128, msg_format, args.5);
        D.17046 = (unsigned int) D.17045;
        if (D.17046 > 127) goto <D.17047>; else goto <D.17048>;
        <D.17047>:
        __builtin_va_end (&args);
        __builtin_va_start (&args, 0);
        args.5 = args;
        D.17049 = monoeg_g_strdup_vprintf (msg_format, args.5);
        error->full_message = D.17049;
        D.17050 = error->full_message;
        if (D.17050 == 0B) goto <D.17051>; else goto <D.17052>;
        <D.17051>:
        D.17053 = error->flags;
        D.17054 = D.17053 | 2;
        error->flags = D.17054;
        <D.17052>:
        <D.17048>:
        __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.17055;
  char * args.6;
  int D.17057;
  unsigned int D.17058;
  gchar * D.17061;
  const char * D.17062;
  short unsigned int D.17065;
  short unsigned int D.17066;
  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);
        D.17055 = &error->message;
        args.6 = args;
        D.17057 = vsnprintf (D.17055, 128, msg_format, args.6);
        D.17058 = (unsigned int) D.17057;
        if (D.17058 > 127) goto <D.17059>; else goto <D.17060>;
        <D.17059>:
        __builtin_va_end (&args);
        __builtin_va_start (&args, 0);
        args.6 = args;
        D.17061 = monoeg_g_strdup_vprintf (msg_format, args.6);
        error->full_message = D.17061;
        D.17062 = error->full_message;
        if (D.17062 == 0B) goto <D.17063>; else goto <D.17064>;
        <D.17063>:
        D.17065 = error->flags;
        D.17066 = D.17065 | 2;
        error->flags = D.17066;
        <D.17064>:
        <D.17060>:
        __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.17067;
  char * args.7;
  int D.17069;
  unsigned int D.17070;
  gchar * D.17073;
  const char * D.17074;
  short unsigned int D.17077;
  short unsigned int D.17078;
  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);
        D.17067 = &error->message;
        args.7 = args;
        D.17069 = vsnprintf (D.17067, 128, msg_format, args.7);
        D.17070 = (unsigned int) D.17069;
        if (D.17070 > 127) goto <D.17071>; else goto <D.17072>;
        <D.17071>:
        __builtin_va_end (&args);
        __builtin_va_start (&args, 0);
        args.7 = args;
        D.17073 = monoeg_g_strdup_vprintf (msg_format, args.7);
        error->full_message = D.17073;
        D.17074 = error->full_message;
        if (D.17074 == 0B) goto <D.17075>; else goto <D.17076>;
        <D.17075>:
        D.17077 = error->flags;
        D.17078 = D.17077 | 2;
        error->flags = D.17078;
        <D.17076>:
        <D.17072>:
        __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.17083;
  char * args.9;
  int D.17085;
  unsigned int D.17086;
  gchar * D.17089;
  const char * D.17090;
  short unsigned int D.17093;
  short unsigned int D.17094;
  struct MonoErrorInternal * error;

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

    try
      {
        __builtin_va_start (&args, 0);
        D.17083 = &error->message;
        args.9 = args;
        D.17085 = vsnprintf (D.17083, 128, msg_format, args.9);
        D.17086 = (unsigned int) D.17085;
        if (D.17086 > 127) goto <D.17087>; else goto <D.17088>;
        <D.17087>:
        __builtin_va_end (&args);
        __builtin_va_start (&args, 0);
        args.9 = args;
        D.17089 = monoeg_g_strdup_vprintf (msg_format, args.9);
        error->full_message = D.17089;
        D.17090 = error->full_message;
        if (D.17090 == 0B) goto <D.17091>; else goto <D.17092>;
        <D.17091>:
        D.17093 = error->flags;
        D.17094 = D.17093 | 2;
        error->flags = D.17094;
        <D.17092>:
        <D.17088>:
        __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.17095;
  char * args.10;
  int D.17097;
  unsigned int D.17098;
  gchar * D.17101;
  const char * D.17102;
  short unsigned int D.17105;
  short unsigned int D.17106;
  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);
        D.17095 = &error->message;
        args.10 = args;
        D.17097 = vsnprintf (D.17095, 128, msg_format, args.10);
        D.17098 = (unsigned int) D.17097;
        if (D.17098 > 127) goto <D.17099>; else goto <D.17100>;
        <D.17099>:
        __builtin_va_end (&args);
        __builtin_va_start (&args, 0);
        args.10 = args;
        D.17101 = monoeg_g_strdup_vprintf (msg_format, args.10);
        error->full_message = D.17101;
        D.17102 = error->full_message;
        if (D.17102 == 0B) goto <D.17103>; else goto <D.17104>;
        <D.17103>:
        D.17105 = error->flags;
        D.17106 = D.17105 | 2;
        error->flags = D.17106;
        <D.17104>:
        <D.17100>:
        __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.17109;
  int D.17110;
  char * D.17111;
  const char * D.17112;
  char[128] * D.17113;
  struct MonoClass * D.17114;
  char * D.17115;
  int D.17116;
  char * D.17120;
  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.17107>; else goto <D.17108>;
  <D.17107>:
  mono_error_set_generic_error (oerror, "System", "ExecutionEngineException", "Runtime tried to produce a mono-error from an empty loader-error");
  return;
  <D.17108>:
  D.17109 = loader_error->exception_type;
  D.17110 = (int) D.17109;
  switch (D.17110) <default: <D.16820>, case 0: <D.16804>, case 1: <D.16806>, case 2: <D.16807>, case 3: <D.16808>, case 4: <D.16809>, case 5: <D.16810>, case 6: <D.16811>, case 7: <D.16812>, case 8: <D.16813>, case 9: <D.16814>, case 10: <D.16815>, case 11: <D.16817>, case 12: <D.16818>, case 13: <D.16816>, case 14: <D.16819>>
  <D.16804>:
  mono_error_set_generic_error (oerror, "System", "ExecutionEngineException", "Runtime tried to produce a mono-error from a non-error loader-error");
  goto <D.16805>;
  <D.16806>:
  <D.16807>:
  mono_error_set_generic_error (oerror, "System.Security", "SecurityException", "Failed for unknown reasons.");
  goto <D.16805>;
  <D.16808>:
  mono_error_set_generic_error (oerror, "System", "InvalidProgramException", "Failed for unknown reasons.");
  goto <D.16805>;
  <D.16809>:
  mono_error_set_generic_error (oerror, "System.Security", "VerificationException", "Failed for unknown reasons.");
  goto <D.16805>;
  <D.16810>:
  error->error_code = 1;
  D.17111 = loader_error->class_name;
  mono_error_set_type_name (oerror, D.17111);
  D.17112 = loader_error->member_name;
  mono_error_set_member_name (oerror, D.17112);
  D.17113 = &error->message;
  monoeg_g_snprintf (D.17113, 128, "Failed for unknown reasons.");
  goto <D.16805>;
  <D.16811>:
  D.17114 = loader_error->klass;
  D.17112 = loader_error->member_name;
  mono_error_set_field_load (oerror, D.17114, D.17112, "Failed for unknown reasons.");
  goto <D.16805>;
  <D.16812>:
  D.17111 = loader_error->class_name;
  D.17115 = loader_error->assembly_name;
  mono_error_set_type_load_name (oerror, D.17111, D.17115, "Failed for unknown reasons.");
  goto <D.16805>;
  <D.16813>:
  D.17116 = loader_error->ref_only;
  if (D.17116 != 0) goto <D.17117>; else goto <D.17118>;
  <D.17117>:
  D.17115 = loader_error->assembly_name;
  mono_error_set_assembly_load (oerror, D.17115, "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.17119>;
  <D.17118>:
  D.17115 = loader_error->assembly_name;
  mono_error_set_assembly_load (oerror, D.17115, "Could not load file or assembly or one of its dependencies.");
  <D.17119>:
  goto <D.16805>;
  <D.16814>:
  mono_error_set_generic_error (oerror, "System", "MethodAccessException", "Failed for unknown reasons.");
  goto <D.16805>;
  <D.16815>:
  mono_error_set_generic_error (oerror, "System", "FieldAccessException", "Failed for unknown reasons.");
  goto <D.16805>;
  <D.16816>:
  <D.16817>:
  D.17109 = loader_error->exception_type;
  D.17110 = (int) D.17109;
  mono_error_set_generic_error (oerror, "System", "ExecutionEngineException", "Runtime tried to produce a mono-error from JIT internal error %d", D.17110);
  goto <D.16805>;
  <D.16818>:
  D.17120 = loader_error->msg;
  mono_error_set_bad_image_name (oerror, "<unknown>", "%s", D.17120);
  goto <D.16805>;
  <D.16819>:
  mono_error_set_out_of_memory (oerror, "Failed for unknown reasons.");
  goto <D.16805>;
  <D.16820>:
  D.17109 = loader_error->exception_type;
  D.17110 = (int) D.17109;
  mono_error_set_generic_error (oerror, "System", "ExecutionEngineException", "Runtime tried to produce an unknown loader-error %d", D.17110);
  goto <D.16805>;
  <D.16805>:
  mono_error_dup_strings (oerror, 1);
  mono_loader_clear_error ();
}


mono_loader_set_error_from_mono_error (struct MonoError * oerror)
{
  short unsigned int D.17122;
  int D.17123;
  const char * D.17124;
  const char * D.17125;
  struct MonoClass * D.17126;
  const char * D.17127;
  const char * D.17128;
  const char * D.17129;
  const gchar * iftmp.11;
  const char * D.17131;
  gchar * D.17135;
  const char * iftmp.12;
  gchar * D.17140;
  struct MonoErrorInternal * error;

  error = oerror;
  D.17122 = error->error_code;
  D.17123 = (int) D.17122;
  switch (D.17123) <default: <D.16837>, case 1: <D.16831>, case 2: <D.16833>, case 3: <D.16834>, case 4: <D.16835>, case 5: <D.16836>>
  <D.16831>:
  D.17124 = get_type_name (error);
  D.17125 = error->member_name;
  mono_loader_set_error_method_load (D.17124, D.17125);
  goto <D.16832>;
  <D.16833>:
  D.17126 = error->klass;
  D.17125 = error->member_name;
  mono_loader_set_error_field_load (D.17126, D.17125);
  goto <D.16832>;
  <D.16834>:
  D.17127 = get_type_name (error);
  D.17128 = get_assembly_name (error);
  mono_loader_set_error_type_load (D.17127, D.17128);
  goto <D.16832>;
  <D.16835>:
  D.17129 = get_assembly_name (error);
  mono_loader_set_error_assembly_load (D.17129, 0);
  goto <D.16832>;
  <D.16836>:
  D.17131 = error->full_message;
  if (D.17131 != 0B) goto <D.17132>; else goto <D.17133>;
  <D.17132>:
  iftmp.11 = error->full_message;
  goto <D.17134>;
  <D.17133>:
  iftmp.11 = &error->message;
  <D.17134>:
  D.17135 = monoeg_strdup (iftmp.11);
  mono_loader_set_error_bad_image (D.17135);
  goto <D.16832>;
  <D.16837>:
  D.17131 = error->full_message;
  if (D.17131 != 0B) goto <D.17137>; else goto <D.17138>;
  <D.17137>:
  iftmp.12 = error->full_message;
  goto <D.17139>;
  <D.17138>:
  iftmp.12 = &error->message;
  <D.17139>:
  D.17140 = monoeg_g_strdup_printf ("Non translatable error: %s", iftmp.12);
  mono_loader_set_error_bad_image (D.17140);
  <D.16832>:
}


get_type_name (struct MonoErrorInternal * error)
{
  const char * D.17141;
  const char * D.17144;
  struct MonoClass * D.17145;

  D.17141 = error->type_name;
  if (D.17141 != 0B) goto <D.17142>; else goto <D.17143>;
  <D.17142>:
  D.17144 = error->type_name;
  return D.17144;
  <D.17143>:
  D.17145 = error->klass;
  if (D.17145 != 0B) goto <D.17146>; else goto <D.17147>;
  <D.17146>:
  D.17145 = error->klass;
  D.17144 = D.17145->name;
  return D.17144;
  <D.17147>:
  D.17144 = "<unknown type>";
  return D.17144;
}


get_assembly_name (struct MonoErrorInternal * error)
{
  const char * D.17149;
  const char * D.17152;
  struct MonoClass * D.17153;
  struct MonoImage * D.17156;

  D.17149 = error->assembly_name;
  if (D.17149 != 0B) goto <D.17150>; else goto <D.17151>;
  <D.17150>:
  D.17152 = error->assembly_name;
  return D.17152;
  <D.17151>:
  D.17153 = error->klass;
  if (D.17153 != 0B) goto <D.17154>; else goto <D.17155>;
  <D.17154>:
  D.17153 = error->klass;
  D.17156 = D.17153->image;
  if (D.17156 != 0B) goto <D.17157>; else goto <D.17158>;
  <D.17157>:
  D.17153 = error->klass;
  D.17156 = D.17153->image;
  D.17152 = D.17156->name;
  return D.17152;
  <D.17158>:
  <D.17155>:
  D.17152 = "<unknown assembly>";
  return D.17152;
}


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

  try
    {
      error = oerror;
      mono_error_prepare (error);
      error->error_code = 6;
      __builtin_va_start (&args, 0);
      D.17160 = &error->message;
      args.13 = args;
      vsnprintf (D.17160, 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.17162;
  char * args.14;
  int D.17164;
  unsigned int D.17165;
  gchar * D.17168;
  const char * D.17169;
  short unsigned int D.17172;
  short unsigned int D.17173;
  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);
        D.17162 = &error->message;
        args.14 = args;
        D.17164 = vsnprintf (D.17162, 128, msg_format, args.14);
        D.17165 = (unsigned int) D.17164;
        if (D.17165 > 127) goto <D.17166>; else goto <D.17167>;
        <D.17166>:
        __builtin_va_end (&args);
        __builtin_va_start (&args, 0);
        args.14 = args;
        D.17168 = monoeg_g_strdup_vprintf (msg_format, args.14);
        error->full_message = D.17168;
        D.17169 = error->full_message;
        if (D.17169 == 0B) goto <D.17170>; else goto <D.17171>;
        <D.17170>:
        D.17172 = error->flags;
        D.17173 = D.17172 | 2;
        error->flags = D.17173;
        <D.17171>:
        <D.17167>:
        __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.17174;
  char * D.17177;
  char[128] * D.17178;
  char * args.15;
  int D.17180;
  unsigned int D.17181;
  gchar * D.17184;
  const char * D.17185;
  short unsigned int D.17188;
  short unsigned int D.17189;
  struct MonoErrorInternal * error;

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

    try
      {
        __builtin_va_start (&args, 0);
        D.17178 = &error->message;
        args.15 = args;
        D.17180 = vsnprintf (D.17178, 128, msg_format, args.15);
        D.17181 = (unsigned int) D.17180;
        if (D.17181 > 127) goto <D.17182>; else goto <D.17183>;
        <D.17182>:
        __builtin_va_end (&args);
        __builtin_va_start (&args, 0);
        args.15 = args;
        D.17184 = monoeg_g_strdup_vprintf (msg_format, args.15);
        error->full_message = D.17184;
        D.17185 = error->full_message;
        if (D.17185 == 0B) goto <D.17186>; else goto <D.17187>;
        <D.17186>:
        D.17188 = error->flags;
        D.17189 = D.17188 | 2;
        error->flags = D.17189;
        <D.17187>:
        <D.17183>:
        __builtin_va_end (&args);
      }
    finally
      {
        args = {CLOBBER};
      }
  }
}


mono_error_prepare_exception (struct MonoError * oerror, struct MonoError * error_out)
{
  short unsigned int D.17190;
  int D.17191;
  struct MonoException * D.17192;
  const char * D.17196;
  struct MonoClass * D.17198;
  const char * D.17199;
  int D.17201;
  struct MonoImage * D.17205;
  const char * iftmp.16;
  const char * D.17209;
  int D.17218;
  const char * iftmp.17;
  const char * D.17232;
  int D.17233;
  struct MonoImage * D.17239;
  const char * iftmp.18;
  const char * iftmp.19;
  struct MonoImage * D.17260;
  struct MonoImage * D.17265;
  const char * iftmp.20;
  const char * iftmp.21;
  const char * iftmp.22;
  const char * iftmp.23;
  const char * D.17292;
  const char * D.17294;
  const char * iftmp.24;
  int D.17299;
  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.17190 = error->error_code;
  D.17191 = (int) D.17190;
  switch (D.17191) <default: <D.16896>, case 0: <D.16883>, case 1: <D.16884>, case 2: <D.16886>, case 3: <D.16887>, case 4: <D.16888>, case 5: <D.16889>, case 6: <D.16890>, case 7: <D.16891>, case 8: <D.16892>, case 9: <D.16895>>
  <D.16883>:
  D.17192 = 0B;
  return D.17192;
  <D.16884>:
  D.17196 = error->type_name;
  if (D.17196 != 0B) goto <D.17193>; else goto <D.17197>;
  <D.17197>:
  D.17198 = error->klass;
  if (D.17198 != 0B) goto <D.17193>; else goto <D.17194>;
  <D.17193>:
  D.17199 = error->member_name;
  if (D.17199 != 0B) goto <D.17200>; else goto <D.17194>;
  <D.17200>:
  type_name = get_type_name_as_mono_string (error, domain, error_out);
  D.17201 = mono_error_ok (error_out);
  if (D.17201 == 0) goto <D.16885>; else goto <D.17202>;
  <D.17202>:
  D.17199 = error->member_name;
  method_name = mono_string_new (domain, D.17199);
  if (method_name == 0B) goto <D.17203>; else goto <D.17204>;
  <D.17203>:
  mono_error_set_out_of_memory (error_out, "Could not allocate method name");
  goto <D.16885>;
  <D.17204>:
  D.17205 = mono_defaults.corlib;
  exception = mono_exception_from_name_two_strings (D.17205, "System", "MissingMethodException", type_name, method_name);
  if (exception != 0B) goto <D.17206>; else goto <D.17207>;
  <D.17206>:
  set_message_on_exception (exception, error, error_out);
  <D.17207>:
  goto <D.17195>;
  <D.17194>:
  D.17205 = mono_defaults.corlib;
  D.17209 = error->full_message;
  if (D.17209 != 0B) goto <D.17210>; else goto <D.17211>;
  <D.17210>:
  iftmp.16 = error->full_message;
  goto <D.17212>;
  <D.17211>:
  iftmp.16 = &error->message;
  <D.17212>:
  exception = mono_exception_from_name_msg (D.17205, "System", "MissingMethodException", iftmp.16);
  <D.17195>:
  goto <D.16885>;
  <D.16886>:
  D.17196 = error->type_name;
  if (D.17196 != 0B) goto <D.17213>; else goto <D.17216>;
  <D.17216>:
  D.17198 = error->klass;
  if (D.17198 != 0B) goto <D.17213>; else goto <D.17214>;
  <D.17213>:
  D.17199 = error->member_name;
  if (D.17199 != 0B) goto <D.17217>; else goto <D.17214>;
  <D.17217>:
  type_name = get_type_name_as_mono_string (error, domain, error_out);
  D.17218 = mono_error_ok (error_out);
  if (D.17218 == 0) goto <D.16885>; else goto <D.17219>;
  <D.17219>:
  D.17199 = error->member_name;
  field_name = mono_string_new (domain, D.17199);
  if (field_name == 0B) goto <D.17220>; else goto <D.17221>;
  <D.17220>:
  mono_error_set_out_of_memory (error_out, "Could not allocate field name");
  goto <D.16885>;
  <D.17221>:
  D.17205 = mono_defaults.corlib;
  exception = mono_exception_from_name_two_strings (D.17205, "System", "MissingFieldException", type_name, field_name);
  if (exception != 0B) goto <D.17222>; else goto <D.17223>;
  <D.17222>:
  set_message_on_exception (exception, error, error_out);
  <D.17223>:
  goto <D.17215>;
  <D.17214>:
  D.17205 = mono_defaults.corlib;
  D.17209 = error->full_message;
  if (D.17209 != 0B) goto <D.17225>; else goto <D.17226>;
  <D.17225>:
  iftmp.17 = error->full_message;
  goto <D.17227>;
  <D.17226>:
  iftmp.17 = &error->message;
  <D.17227>:
  exception = mono_exception_from_name_msg (D.17205, "System", "MissingFieldException", iftmp.17);
  <D.17215>:
  goto <D.16885>;
  <D.16887>:
  D.17196 = error->type_name;
  if (D.17196 != 0B) goto <D.17228>; else goto <D.17231>;
  <D.17231>:
  D.17232 = error->assembly_name;
  if (D.17232 != 0B) goto <D.17228>; else goto <D.17229>;
  <D.17228>:
  type_name = get_type_name_as_mono_string (error, domain, error_out);
  D.17233 = mono_error_ok (error_out);
  if (D.17233 == 0) goto <D.16885>; else goto <D.17234>;
  <D.17234>:
  D.17232 = error->assembly_name;
  if (D.17232 != 0B) goto <D.17235>; else goto <D.17236>;
  <D.17235>:
  D.17232 = error->assembly_name;
  assembly_name = mono_string_new (domain, D.17232);
  if (assembly_name == 0B) goto <D.17237>; else goto <D.17238>;
  <D.17237>:
  mono_error_set_out_of_memory (error_out, "Could not allocate assembly name");
  goto <D.16885>;
  <D.17238>:
  <D.17236>:
  D.17239 = mono_get_corlib ();
  exception = mono_exception_from_name_two_strings (D.17239, "System", "TypeLoadException", type_name, assembly_name);
  if (exception != 0B) goto <D.17240>; else goto <D.17241>;
  <D.17240>:
  set_message_on_exception (exception, error, error_out);
  <D.17241>:
  goto <D.17230>;
  <D.17229>:
  D.17205 = mono_defaults.corlib;
  D.17209 = error->full_message;
  if (D.17209 != 0B) goto <D.17243>; else goto <D.17244>;
  <D.17243>:
  iftmp.18 = error->full_message;
  goto <D.17245>;
  <D.17244>:
  iftmp.18 = &error->message;
  <D.17245>:
  exception = mono_exception_from_name_msg (D.17205, "System", "TypeLoadException", iftmp.18);
  <D.17230>:
  goto <D.16885>;
  <D.16888>:
  <D.16889>:
  D.17232 = error->assembly_name;
  if (D.17232 != 0B) goto <D.17246>; else goto <D.17247>;
  <D.17246>:
  D.17209 = error->full_message;
  if (D.17209 != 0B) goto <D.17249>; else goto <D.17250>;
  <D.17249>:
  iftmp.19 = error->full_message;
  goto <D.17251>;
  <D.17250>:
  iftmp.19 = &error->message;
  <D.17251>:
  msg = mono_string_new (domain, iftmp.19);
  if (msg == 0B) goto <D.17252>; else goto <D.17253>;
  <D.17252>:
  mono_error_set_out_of_memory (error_out, "Could not allocate message");
  goto <D.16885>;
  <D.17253>:
  D.17232 = error->assembly_name;
  if (D.17232 != 0B) goto <D.17254>; else goto <D.17255>;
  <D.17254>:
  D.17232 = error->assembly_name;
  assembly_name = mono_string_new (domain, D.17232);
  if (assembly_name == 0B) goto <D.17256>; else goto <D.17257>;
  <D.17256>:
  mono_error_set_out_of_memory (error_out, "Could not allocate assembly name");
  goto <D.16885>;
  <D.17257>:
  <D.17255>:
  D.17190 = error->error_code;
  if (D.17190 == 4) goto <D.17258>; else goto <D.17259>;
  <D.17258>:
  D.17260 = mono_get_corlib ();
  exception = mono_exception_from_name_two_strings (D.17260, "System.IO", "FileNotFoundException", msg, assembly_name);
  goto <D.17261>;
  <D.17259>:
  D.17205 = mono_defaults.corlib;
  exception = mono_exception_from_name_two_strings (D.17205, "System", "BadImageFormatException", msg, assembly_name);
  <D.17261>:
  goto <D.17262>;
  <D.17247>:
  D.17190 = error->error_code;
  if (D.17190 == 4) goto <D.17263>; else goto <D.17264>;
  <D.17263>:
  D.17265 = mono_get_corlib ();
  D.17209 = error->full_message;
  if (D.17209 != 0B) goto <D.17267>; else goto <D.17268>;
  <D.17267>:
  iftmp.20 = error->full_message;
  goto <D.17269>;
  <D.17268>:
  iftmp.20 = &error->message;
  <D.17269>:
  exception = mono_exception_from_name_msg (D.17265, "System.IO", "FileNotFoundException", iftmp.20);
  goto <D.17270>;
  <D.17264>:
  D.17205 = mono_defaults.corlib;
  D.17209 = error->full_message;
  if (D.17209 != 0B) goto <D.17272>; else goto <D.17273>;
  <D.17272>:
  iftmp.21 = error->full_message;
  goto <D.17274>;
  <D.17273>:
  iftmp.21 = &error->message;
  <D.17274>:
  exception = mono_exception_from_name_msg (D.17205, "System", "BadImageFormatException", iftmp.21);
  <D.17270>:
  <D.17262>:
  goto <D.16885>;
  <D.16890>:
  exception = mono_get_exception_out_of_memory ();
  goto <D.16885>;
  <D.16891>:
  D.17196 = error->type_name;
  D.17209 = error->full_message;
  if (D.17209 != 0B) goto <D.17276>; else goto <D.17277>;
  <D.17276>:
  iftmp.22 = error->full_message;
  goto <D.17278>;
  <D.17277>:
  iftmp.22 = &error->message;
  <D.17278>:
  exception = mono_get_exception_argument (D.17196, iftmp.22);
  goto <D.16885>;
  <D.16892>:
  {
    char * type_name;
    char * message;

    type_name = 0B;
    D.17198 = error->klass;
    if (D.17198 != 0B) goto <D.17279>; else goto <D.17280>;
    <D.17279>:
    D.17198 = error->klass;
    type_name = mono_type_get_full_name (D.17198);
    if (type_name == 0B) goto <D.17281>; else goto <D.17282>;
    <D.17281>:
    mono_error_set_out_of_memory (error_out, "Could not allocate message");
    goto <D.16885>;
    <D.17282>:
    <D.17280>:
    D.17199 = error->member_name;
    D.17209 = error->full_message;
    if (D.17209 != 0B) goto <D.17284>; else goto <D.17285>;
    <D.17284>:
    iftmp.23 = error->full_message;
    goto <D.17286>;
    <D.17285>:
    iftmp.23 = &error->message;
    <D.17286>:
    message = monoeg_g_strdup_printf ("Error in %s:%s %s", type_name, D.17199, iftmp.23);
    if (message == 0B) goto <D.17287>; else goto <D.17288>;
    <D.17287>:
    monoeg_g_free (type_name);
    mono_error_set_out_of_memory (error_out, "Could not allocate message");
    goto <D.16885>;
    <D.17288>:
    D.17205 = mono_defaults.corlib;
    exception = mono_exception_from_name_msg (D.17205, "System.Security", "VerificationException", message);
    monoeg_g_free (message);
    monoeg_g_free (type_name);
    goto <D.16885>;
  }
  <D.16895>:
  D.17292 = error->exception_name_space;
  if (D.17292 == 0B) goto <D.17289>; else goto <D.17293>;
  <D.17293>:
  D.17294 = error->exception_name;
  if (D.17294 == 0B) goto <D.17289>; else goto <D.17290>;
  <D.17289>:
  mono_error_set_generic_error (error_out, "System", "ExecutionEngineException", "MonoError with generic error but no exception name was supplied");
  goto <D.17291>;
  <D.17290>:
  D.17205 = mono_defaults.corlib;
  D.17292 = error->exception_name_space;
  D.17294 = error->exception_name;
  D.17209 = error->full_message;
  if (D.17209 != 0B) goto <D.17296>; else goto <D.17297>;
  <D.17296>:
  iftmp.24 = error->full_message;
  goto <D.17298>;
  <D.17297>:
  iftmp.24 = &error->message;
  <D.17298>:
  exception = mono_exception_from_name_msg (D.17205, D.17292, D.17294, iftmp.24);
  <D.17291>:
  goto <D.16885>;
  <D.16896>:
  D.17190 = error->error_code;
  D.17191 = (int) D.17190;
  mono_error_set_generic_error (error_out, "System", "ExecutionEngineException", "Invalid error-code %d", D.17191);
  <D.16885>:
  D.17299 = mono_error_ok (error_out);
  if (D.17299 == 0) goto <D.17300>; else goto <D.17301>;
  <D.17300>:
  D.17192 = 0B;
  return D.17192;
  <D.17301>:
  if (exception == 0B) goto <D.17302>; else goto <D.17303>;
  <D.17302>:
  mono_error_set_out_of_memory (error_out, "Could not allocate exception object");
  <D.17303>:
  D.17192 = exception;
  return D.17192;
}


get_type_name_as_mono_string (struct MonoErrorInternal * error, struct MonoDomain * domain, struct MonoError * error_out)
{
  const char * D.17305;
  struct MonoClass * D.17309;
  struct MonoType * D.17312;
  struct MonoString * D.17317;
  struct MonoString * res;

  res = 0B;
  D.17305 = error->type_name;
  if (D.17305 != 0B) goto <D.17306>; else goto <D.17307>;
  <D.17306>:
  D.17305 = error->type_name;
  res = mono_string_new (domain, D.17305);
  goto <D.17308>;
  <D.17307>:
  D.17309 = error->klass;
  if (D.17309 != 0B) goto <D.17310>; else goto <D.17311>;
  <D.17310>:
  {
    char * name;

    D.17309 = error->klass;
    D.17312 = &D.17309->byval_arg;
    name = mono_type_full_name (D.17312);
    if (name != 0B) goto <D.17313>; else goto <D.17314>;
    <D.17313>:
    res = mono_string_new (domain, name);
    monoeg_g_free (name);
    <D.17314>:
  }
  <D.17311>:
  <D.17308>:
  if (res == 0B) goto <D.17315>; else goto <D.17316>;
  <D.17315>:
  mono_error_set_out_of_memory (error_out, "Could not allocate type name");
  <D.17316>:
  D.17317 = res;
  return D.17317;
}


set_message_on_exception (struct MonoException * exception, struct MonoErrorInternal * error, struct MonoError * error_out)
{
  struct MonoDomain * D.17319;
  const char * iftmp.25;
  const char * D.17321;
  struct MonoString * * D.17327;
  struct MonoString * msg;

  D.17319 = mono_domain_get ();
  D.17321 = error->full_message;
  if (D.17321 != 0B) goto <D.17322>; else goto <D.17323>;
  <D.17322>:
  iftmp.25 = error->full_message;
  goto <D.17324>;
  <D.17323>:
  iftmp.25 = &error->message;
  <D.17324>:
  msg = mono_string_new (D.17319, iftmp.25);
  if (msg != 0B) goto <D.17325>; else goto <D.17326>;
  <D.17325>:
  D.17327 = &exception->message;
  mono_gc_wbarrier_set_field (exception, D.17327, msg);
  goto <D.17328>;
  <D.17326>:
  mono_error_set_out_of_memory (error_out, "Could not allocate exception object");
  <D.17328>:
}


mono_error_raise_exception (struct MonoError * target_error)
{
  int D.17329;
  int D.17332;
  int D.17335;
  _Bool D.17336;
  long int D.17337;
  long int D.17338;
  struct MonoError error;
  struct MonoException * ex;

  try
    {
      D.17329 = mono_error_ok (target_error);
      if (D.17329 != 0) goto <D.17330>; else goto <D.17331>;
      <D.17330>:
      return;
      <D.17331>:
      ex = mono_error_prepare_exception (target_error, &error);
      D.17332 = mono_error_ok (&error);
      if (D.17332 == 0) goto <D.17333>; else goto <D.17334>;
      <D.17333>:
      {
        struct MonoError second_chance;

        try
          {
            ex = mono_error_prepare_exception (&error, &second_chance);
            D.17335 = mono_error_ok (&second_chance);
            D.17336 = D.17335 == 0;
            D.17337 = (long int) D.17336;
            D.17338 = __builtin_expect (D.17337, 0);
            if (D.17338 != 0) goto <D.17339>; else goto <D.17340>;
            <D.17339>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mono-error.c", 646, "mono_error_ok (&second_chance)");
            <D.17340>:
            mono_error_cleanup (&error);
          }
        finally
          {
            second_chance = {CLOBBER};
          }
      }
      <D.17334>:
      mono_error_cleanup (target_error);
      mono_raise_exception (ex);
    }
  finally
    {
      error = {CLOBBER};
    }
}