mono_exception_from_name (struct MonoImage * image, const char * name_space, const char * name)
{
  struct MonoException * D.16545;
  struct MonoDomain * D.16546;

  D.16546 = mono_domain_get ();
  D.16545 = mono_exception_from_name_domain (D.16546, image, name_space, name);
  return D.16545;
}


mono_exception_from_name_domain (struct MonoDomain * domain, struct MonoImage * image, const char * name_space, const char * name)
{
  _Bool D.16548;
  long int D.16549;
  long int D.16550;
  struct MonoException * D.16557;
  struct MonoClass * klass;
  struct MonoObject * o;
  struct MonoDomain * caller_domain;

  caller_domain = mono_domain_get ();
  klass = mono_class_from_name (image, name_space, name);
  o = mono_object_new (domain, klass);
  D.16548 = o == 0B;
  D.16549 = (long int) D.16548;
  D.16550 = __builtin_expect (D.16549, 0);
  if (D.16550 != 0) goto <D.16551>; else goto <D.16552>;
  <D.16551>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "exception.c", 66, "o != NULL");
  <D.16552>:
  if (domain != caller_domain) goto <D.16553>; else goto <D.16554>;
  <D.16553>:
  mono_domain_set_internal (domain);
  <D.16554>:
  mono_runtime_object_init (o);
  if (domain != caller_domain) goto <D.16555>; else goto <D.16556>;
  <D.16555>:
  mono_domain_set_internal (caller_domain);
  <D.16556>:
  D.16557 = o;
  return D.16557;
}


mono_exception_from_token (struct MonoImage * image, guint32 token)
{
  struct MonoDomain * D.16559;
  _Bool D.16560;
  long int D.16561;
  long int D.16562;
  struct MonoException * D.16565;
  struct MonoClass * klass;
  struct MonoObject * o;

  klass = mono_class_get (image, token);
  D.16559 = mono_domain_get ();
  o = mono_object_new (D.16559, klass);
  D.16560 = o == 0B;
  D.16561 = (long int) D.16560;
  D.16562 = __builtin_expect (D.16561, 0);
  if (D.16562 != 0) goto <D.16563>; else goto <D.16564>;
  <D.16563>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "exception.c", 96, "o != NULL");
  <D.16564>:
  mono_runtime_object_init (o);
  D.16565 = o;
  return D.16565;
}


mono_exception_from_name_two_strings (struct MonoImage * image, const char * name_space, const char * name, struct MonoString * a1, struct MonoString * a2)
{
  struct MonoException * D.16567;
  struct MonoClass * klass;

  klass = mono_class_from_name (image, name_space, name);
  D.16567 = create_exception_two_strings (klass, a1, a2);
  return D.16567;
}


create_exception_two_strings (struct MonoClass * klass, struct MonoString * a1, struct MonoString * a2)
{
  const char * D.16571;
  int D.16572;
  short unsigned int D.16575;
  int D.16576;
  struct MonoType * D.16579;
  unsigned char D.16580;
  struct MonoType * D.16585;
  unsigned char D.16586;
  struct MonoException * D.16589;
  struct MonoDomain * domain;
  struct MonoMethod * method;
  struct MonoObject * o;
  int count;
  void * args[2];
  void * iter;
  struct MonoMethod * m;

  try
    {
      domain = mono_domain_get ();
      method = 0B;
      count = 1;
      if (a2 != 0B) goto <D.16569>; else goto <D.16570>;
      <D.16569>:
      count = count + 1;
      <D.16570>:
      o = mono_object_new (domain, klass);
      iter = 0B;
      goto <D.16338>;
      <D.16340>:
      {
        struct MonoMethodSignature * sig;

        D.16571 = mono_method_get_name (m);
        D.16572 = strcmp (".ctor", D.16571);
        if (D.16572 != 0) goto <D.16573>; else goto <D.16574>;
        <D.16573>:
        // predicted unlikely by continue predictor.
        goto <D.16338>;
        <D.16574>:
        sig = mono_method_signature (m);
        D.16575 = sig->param_count;
        D.16576 = (int) D.16575;
        if (D.16576 != count) goto <D.16577>; else goto <D.16578>;
        <D.16577>:
        // predicted unlikely by continue predictor.
        goto <D.16338>;
        <D.16578>:
        D.16579 = sig->params[0];
        D.16580 = D.16579->type;
        if (D.16580 != 14) goto <D.16581>; else goto <D.16582>;
        <D.16581>:
        // predicted unlikely by continue predictor.
        goto <D.16338>;
        <D.16582>:
        if (count == 2) goto <D.16583>; else goto <D.16584>;
        <D.16583>:
        D.16585 = sig->params[1];
        D.16586 = D.16585->type;
        if (D.16586 != 14) goto <D.16587>; else goto <D.16588>;
        <D.16587>:
        // predicted unlikely by continue predictor.
        goto <D.16338>;
        <D.16588>:
        <D.16584>:
        method = m;
        goto <D.16339>;
      }
      <D.16338>:
      m = mono_class_get_methods (klass, &iter);
      if (m != 0B) goto <D.16340>; else goto <D.16339>;
      <D.16339>:
      args[0] = a1;
      args[1] = a2;
      mono_runtime_invoke (method, o, &args, 0B);
      D.16589 = o;
      return D.16589;
    }
  finally
    {
      args = {CLOBBER};
      iter = {CLOBBER};
    }
}


__attribute__((__gnu_inline__, nothrow, leaf, pure))
strcmp (const char * __s1, const char * __s2)
{
  int iftmp.0;
  int iftmp.1;
  int D.16600;
  char * __p1;
  char * __p2;
  int __ret;

  __p1 = __s1;
  __p2 = __s2;
  __asm__ __volatile__("   slr   0,0
0: clst  %1,%2
   jo    0b
   ipm   %0
   srl   %0,28" : "=d" __ret, "=&a" __p1, "=&a" __p2 : "1" __p1, "2" __p2 : "0", "memory", "cc");
  if (__ret != 0) goto <D.16593>; else goto <D.16594>;
  <D.16593>:
  if (__ret == 1) goto <D.16596>; else goto <D.16597>;
  <D.16596>:
  iftmp.1 = -1;
  goto <D.16598>;
  <D.16597>:
  iftmp.1 = 1;
  <D.16598>:
  iftmp.0 = iftmp.1;
  goto <D.16599>;
  <D.16594>:
  iftmp.0 = 0;
  <D.16599>:
  __ret = iftmp.0;
  D.16600 = __ret;
  return D.16600;
}


mono_exception_from_name_msg (struct MonoImage * image, const char * name_space, const char * name, const char * msg)
{
  struct MonoString * * D.16604;
  struct MonoDomain * D.16605;
  struct MonoString * D.16606;
  struct MonoException * D.16607;
  struct MonoException * ex;

  ex = mono_exception_from_name (image, name_space, name);
  if (msg != 0B) goto <D.16602>; else goto <D.16603>;
  <D.16602>:
  D.16604 = &ex->message;
  D.16605 = mono_object_get_domain (ex);
  D.16606 = mono_string_new (D.16605, msg);
  mono_gc_wbarrier_set_field (ex, D.16604, D.16606);
  <D.16603>:
  D.16607 = ex;
  return D.16607;
}


mono_exception_from_token_two_strings (struct MonoImage * image, guint32 token, struct MonoString * a1, struct MonoString * a2)
{
  struct MonoException * D.16609;
  struct MonoClass * klass;

  klass = mono_class_get (image, token);
  D.16609 = create_exception_two_strings (klass, a1, a2);
  return D.16609;
}


mono_get_exception_divide_by_zero ()
{
  struct MonoException * D.16611;
  struct MonoImage * D.16612;

  D.16612 = mono_get_corlib ();
  D.16611 = mono_exception_from_name (D.16612, "System", "DivideByZeroException");
  return D.16611;
}


mono_get_exception_security ()
{
  struct MonoException * D.16614;
  struct MonoImage * D.16615;

  D.16615 = mono_get_corlib ();
  D.16614 = mono_exception_from_name (D.16615, "System.Security", "SecurityException");
  return D.16614;
}


mono_get_exception_thread_abort ()
{
  struct MonoException * D.16617;
  struct MonoImage * D.16618;

  D.16618 = mono_get_corlib ();
  D.16617 = mono_exception_from_name (D.16618, "System.Threading", "ThreadAbortException");
  return D.16617;
}


mono_get_exception_thread_interrupted ()
{
  struct MonoException * D.16620;
  struct MonoImage * D.16621;

  D.16621 = mono_get_corlib ();
  D.16620 = mono_exception_from_name (D.16621, "System.Threading", "ThreadInterruptedException");
  return D.16620;
}


mono_get_exception_arithmetic ()
{
  struct MonoException * D.16623;
  struct MonoImage * D.16624;

  D.16624 = mono_get_corlib ();
  D.16623 = mono_exception_from_name (D.16624, "System", "ArithmeticException");
  return D.16623;
}


mono_get_exception_overflow ()
{
  struct MonoException * D.16626;
  struct MonoImage * D.16627;

  D.16627 = mono_get_corlib ();
  D.16626 = mono_exception_from_name (D.16627, "System", "OverflowException");
  return D.16626;
}


mono_get_exception_null_reference ()
{
  struct MonoException * D.16629;
  struct MonoImage * D.16630;

  D.16630 = mono_get_corlib ();
  D.16629 = mono_exception_from_name (D.16630, "System", "NullReferenceException");
  return D.16629;
}


mono_get_exception_execution_engine (const char * msg)
{
  struct MonoException * D.16632;
  struct MonoImage * D.16633;

  D.16633 = mono_get_corlib ();
  D.16632 = mono_exception_from_name_msg (D.16633, "System", "ExecutionEngineException", msg);
  return D.16632;
}


mono_get_exception_serialization (const char * msg)
{
  struct MonoException * D.16635;
  struct MonoImage * D.16636;

  D.16636 = mono_get_corlib ();
  D.16635 = mono_exception_from_name_msg (D.16636, "System.Runtime.Serialization", "SerializationException", msg);
  return D.16635;
}


mono_get_exception_invalid_cast ()
{
  struct MonoException * D.16638;
  struct MonoImage * D.16639;

  D.16639 = mono_get_corlib ();
  D.16638 = mono_exception_from_name (D.16639, "System", "InvalidCastException");
  return D.16638;
}


mono_get_exception_invalid_operation (const char * msg)
{
  struct MonoException * D.16641;
  struct MonoImage * D.16642;

  D.16642 = mono_get_corlib ();
  D.16641 = mono_exception_from_name_msg (D.16642, "System", "InvalidOperationException", msg);
  return D.16641;
}


mono_get_exception_index_out_of_range ()
{
  struct MonoException * D.16644;
  struct MonoImage * D.16645;

  D.16645 = mono_get_corlib ();
  D.16644 = mono_exception_from_name (D.16645, "System", "IndexOutOfRangeException");
  return D.16644;
}


mono_get_exception_array_type_mismatch ()
{
  struct MonoException * D.16647;
  struct MonoImage * D.16648;

  D.16648 = mono_get_corlib ();
  D.16647 = mono_exception_from_name (D.16648, "System", "ArrayTypeMismatchException");
  return D.16647;
}


mono_get_exception_type_load (struct MonoString * class_name, char * assembly_name)
{
  struct MonoString * iftmp.2;
  struct MonoDomain * D.16653;
  struct MonoDomain * D.16655;
  struct MonoException * D.16656;
  struct MonoImage * D.16657;
  struct MonoString * s;

  if (assembly_name != 0B) goto <D.16651>; else goto <D.16652>;
  <D.16651>:
  D.16653 = mono_domain_get ();
  iftmp.2 = mono_string_new (D.16653, assembly_name);
  goto <D.16654>;
  <D.16652>:
  D.16655 = mono_domain_get ();
  iftmp.2 = mono_string_new (D.16655, "");
  <D.16654>:
  s = iftmp.2;
  D.16657 = mono_get_corlib ();
  D.16656 = mono_exception_from_name_two_strings (D.16657, "System", "TypeLoadException", class_name, s);
  return D.16656;
}


mono_get_exception_not_implemented (const char * msg)
{
  struct MonoException * D.16659;
  struct MonoImage * D.16660;

  D.16660 = mono_get_corlib ();
  D.16659 = mono_exception_from_name_msg (D.16660, "System", "NotImplementedException", msg);
  return D.16659;
}


mono_get_exception_not_supported (const char * msg)
{
  struct MonoException * D.16662;
  struct MonoImage * D.16663;

  D.16663 = mono_get_corlib ();
  D.16662 = mono_exception_from_name_msg (D.16663, "System", "NotSupportedException", msg);
  return D.16662;
}


mono_get_exception_missing_method (const char * class_name, const char * member_name)
{
  struct MonoDomain * D.16665;
  struct MonoDomain * D.16666;
  struct MonoException * D.16667;
  struct MonoImage * D.16668;
  struct MonoString * s1;
  struct MonoString * s2;

  D.16665 = mono_domain_get ();
  s1 = mono_string_new (D.16665, class_name);
  D.16666 = mono_domain_get ();
  s2 = mono_string_new (D.16666, member_name);
  D.16668 = mono_get_corlib ();
  D.16667 = mono_exception_from_name_two_strings (D.16668, "System", "MissingMethodException", s1, s2);
  return D.16667;
}


mono_get_exception_missing_field (const char * class_name, const char * member_name)
{
  struct MonoDomain * D.16670;
  struct MonoDomain * D.16671;
  struct MonoException * D.16672;
  struct MonoImage * D.16673;
  struct MonoString * s1;
  struct MonoString * s2;

  D.16670 = mono_domain_get ();
  s1 = mono_string_new (D.16670, class_name);
  D.16671 = mono_domain_get ();
  s2 = mono_string_new (D.16671, member_name);
  D.16673 = mono_get_corlib ();
  D.16672 = mono_exception_from_name_two_strings (D.16673, "System", "MissingFieldException", s1, s2);
  return D.16672;
}


mono_get_exception_argument_null (const char * arg)
{
  struct MonoImage * D.16675;
  struct MonoString * * D.16678;
  struct MonoDomain * D.16679;
  struct MonoString * D.16680;
  struct MonoException * D.16681;
  struct MonoException * ex;

  D.16675 = mono_get_corlib ();
  ex = mono_exception_from_name (D.16675, "System", "ArgumentNullException");
  if (arg != 0B) goto <D.16676>; else goto <D.16677>;
  <D.16676>:
  {
    struct MonoArgumentException * argex;

    argex = ex;
    D.16678 = &argex->param_name;
    D.16679 = mono_object_get_domain (ex);
    D.16680 = mono_string_new (D.16679, arg);
    mono_gc_wbarrier_set_field (argex, D.16678, D.16680);
  }
  <D.16677>:
  D.16681 = ex;
  return D.16681;
}


mono_get_exception_argument (const char * arg, const char * msg)
{
  struct MonoImage * D.16683;
  struct MonoString * * D.16686;
  struct MonoDomain * D.16687;
  struct MonoString * D.16688;
  struct MonoException * D.16689;
  struct MonoException * ex;

  D.16683 = mono_get_corlib ();
  ex = mono_exception_from_name_msg (D.16683, "System", "ArgumentException", msg);
  if (arg != 0B) goto <D.16684>; else goto <D.16685>;
  <D.16684>:
  {
    struct MonoArgumentException * argex;

    argex = ex;
    D.16686 = &argex->param_name;
    D.16687 = mono_object_get_domain (ex);
    D.16688 = mono_string_new (D.16687, arg);
    mono_gc_wbarrier_set_field (argex, D.16686, D.16688);
  }
  <D.16685>:
  D.16689 = ex;
  return D.16689;
}


mono_get_exception_argument_out_of_range (const char * arg)
{
  struct MonoImage * D.16691;
  struct MonoString * * D.16694;
  struct MonoDomain * D.16695;
  struct MonoString * D.16696;
  struct MonoException * D.16697;
  struct MonoException * ex;

  D.16691 = mono_get_corlib ();
  ex = mono_exception_from_name (D.16691, "System", "ArgumentOutOfRangeException");
  if (arg != 0B) goto <D.16692>; else goto <D.16693>;
  <D.16692>:
  {
    struct MonoArgumentException * argex;

    argex = ex;
    D.16694 = &argex->param_name;
    D.16695 = mono_object_get_domain (ex);
    D.16696 = mono_string_new (D.16695, arg);
    mono_gc_wbarrier_set_field (argex, D.16694, D.16696);
  }
  <D.16693>:
  D.16697 = ex;
  return D.16697;
}


mono_get_exception_thread_state (const char * msg)
{
  struct MonoException * D.16699;
  struct MonoImage * D.16700;

  D.16700 = mono_get_corlib ();
  D.16699 = mono_exception_from_name_msg (D.16700, "System.Threading", "ThreadStateException", msg);
  return D.16699;
}


mono_get_exception_io (const char * msg)
{
  struct MonoException * D.16702;
  struct MonoImage * D.16703;

  D.16703 = mono_get_corlib ();
  D.16702 = mono_exception_from_name_msg (D.16703, "System.IO", "IOException", msg);
  return D.16702;
}


mono_get_exception_file_not_found (struct MonoString * fname)
{
  struct MonoException * D.16705;
  struct MonoImage * D.16706;

  D.16706 = mono_get_corlib ();
  D.16705 = mono_exception_from_name_two_strings (D.16706, "System.IO", "FileNotFoundException", fname, fname);
  return D.16705;
}


mono_get_exception_file_not_found2 (const char * msg, struct MonoString * fname)
{
  struct MonoString * iftmp.3;
  struct MonoDomain * D.16711;
  struct MonoException * D.16713;
  struct MonoImage * D.16714;
  struct MonoString * s;

  if (msg != 0B) goto <D.16709>; else goto <D.16710>;
  <D.16709>:
  D.16711 = mono_domain_get ();
  iftmp.3 = mono_string_new (D.16711, msg);
  goto <D.16712>;
  <D.16710>:
  iftmp.3 = 0B;
  <D.16712>:
  s = iftmp.3;
  D.16714 = mono_get_corlib ();
  D.16713 = mono_exception_from_name_two_strings (D.16714, "System.IO", "FileNotFoundException", s, fname);
  return D.16713;
}


mono_get_exception_type_initialization (const gchar * type_name, struct MonoException * inner)
{
  struct MonoImage * D.16716;
  _Bool D.16717;
  long int D.16718;
  long int D.16719;
  const char * D.16722;
  int D.16723;
  short unsigned int D.16726;
  struct MonoType * D.16729;
  unsigned char D.16730;
  struct MonoType * D.16733;
  struct MonoClass * D.16734;
  struct MonoClass * D.16735;
  _Bool D.16737;
  long int D.16738;
  long int D.16739;
  struct MonoDomain * D.16742;
  struct MonoString * D.16743;
  struct MonoDomain * D.16744;
  struct MonoException * D.16745;
  struct MonoClass * klass;
  void * args[2];
  struct MonoObject * exc;
  struct MonoMethod * method;
  void * iter;

  try
    {
      D.16716 = mono_get_corlib ();
      klass = mono_class_from_name (D.16716, "System", "TypeInitializationException");
      D.16717 = klass == 0B;
      D.16718 = (long int) D.16717;
      D.16719 = __builtin_expect (D.16718, 0);
      if (D.16719 != 0) goto <D.16720>; else goto <D.16721>;
      <D.16720>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "exception.c", 573, "klass");
      <D.16721>:
      mono_class_init (klass);
      iter = 0B;
      goto <D.16457>;
      <D.16456>:
      D.16722 = mono_method_get_name (method);
      D.16723 = strcmp (".ctor", D.16722);
      if (D.16723 == 0) goto <D.16724>; else goto <D.16725>;
      <D.16724>:
      {
        struct MonoMethodSignature * sig;

        sig = mono_method_signature (method);
        D.16726 = sig->param_count;
        if (D.16726 == 2) goto <D.16727>; else goto <D.16728>;
        <D.16727>:
        D.16729 = sig->params[0];
        D.16730 = D.16729->type;
        if (D.16730 == 14) goto <D.16731>; else goto <D.16732>;
        <D.16731>:
        D.16733 = sig->params[1];
        D.16734 = mono_class_from_mono_type (D.16733);
        D.16735 = mono_defaults.exception_class;
        if (D.16734 == D.16735) goto <D.16455>; else goto <D.16736>;
        <D.16736>:
        <D.16732>:
        <D.16728>:
      }
      <D.16725>:
      method = 0B;
      <D.16457>:
      method = mono_class_get_methods (klass, &iter);
      if (method != 0B) goto <D.16456>; else goto <D.16455>;
      <D.16455>:
      D.16737 = method == 0B;
      D.16738 = (long int) D.16737;
      D.16739 = __builtin_expect (D.16738, 0);
      if (D.16739 != 0) goto <D.16740>; else goto <D.16741>;
      <D.16740>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "exception.c", 587, "method");
      <D.16741>:
      D.16742 = mono_domain_get ();
      D.16743 = mono_string_new (D.16742, type_name);
      args[0] = D.16743;
      args[1] = inner;
      D.16744 = mono_domain_get ();
      exc = mono_object_new (D.16744, klass);
      mono_runtime_invoke (method, exc, &args, 0B);
      D.16745 = exc;
      return D.16745;
    }
  finally
    {
      args = {CLOBBER};
      iter = {CLOBBER};
    }
}


mono_get_exception_synchronization_lock (const char * msg)
{
  struct MonoException * D.16748;
  struct MonoImage * D.16749;

  D.16749 = mono_get_corlib ();
  D.16748 = mono_exception_from_name_msg (D.16749, "System.Threading", "SynchronizationLockException", msg);
  return D.16748;
}


mono_get_exception_cannot_unload_appdomain (const char * msg)
{
  struct MonoException * D.16751;
  struct MonoImage * D.16752;

  D.16752 = mono_get_corlib ();
  D.16751 = mono_exception_from_name_msg (D.16752, "System", "CannotUnloadAppDomainException", msg);
  return D.16751;
}


mono_get_exception_appdomain_unloaded ()
{
  struct MonoException * D.16754;
  struct MonoImage * D.16755;

  D.16755 = mono_get_corlib ();
  D.16754 = mono_exception_from_name (D.16755, "System", "AppDomainUnloadedException");
  return D.16754;
}


mono_get_exception_bad_image_format (const char * msg)
{
  struct MonoException * D.16757;
  struct MonoImage * D.16758;

  D.16758 = mono_get_corlib ();
  D.16757 = mono_exception_from_name_msg (D.16758, "System", "BadImageFormatException", msg);
  return D.16757;
}


mono_get_exception_bad_image_format2 (const char * msg, struct MonoString * fname)
{
  struct MonoString * iftmp.4;
  struct MonoDomain * D.16763;
  struct MonoException * D.16765;
  struct MonoImage * D.16766;
  struct MonoString * s;

  if (msg != 0B) goto <D.16761>; else goto <D.16762>;
  <D.16761>:
  D.16763 = mono_domain_get ();
  iftmp.4 = mono_string_new (D.16763, msg);
  goto <D.16764>;
  <D.16762>:
  iftmp.4 = 0B;
  <D.16764>:
  s = iftmp.4;
  D.16766 = mono_get_corlib ();
  D.16765 = mono_exception_from_name_two_strings (D.16766, "System", "BadImageFormatException", s, fname);
  return D.16765;
}


mono_get_exception_stack_overflow ()
{
  struct MonoException * D.16768;
  struct MonoImage * D.16769;

  D.16769 = mono_get_corlib ();
  D.16768 = mono_exception_from_name (D.16769, "System", "StackOverflowException");
  return D.16768;
}


mono_get_exception_out_of_memory ()
{
  struct MonoException * D.16771;
  struct MonoImage * D.16772;

  D.16772 = mono_get_corlib ();
  D.16771 = mono_exception_from_name (D.16772, "System", "OutOfMemoryException");
  return D.16771;
}


mono_get_exception_field_access ()
{
  struct MonoException * D.16774;
  struct MonoImage * D.16775;

  D.16775 = mono_get_corlib ();
  D.16774 = mono_exception_from_name (D.16775, "System", "FieldAccessException");
  return D.16774;
}


__attribute__((visibility ("hidden")))
mono_get_exception_field_access_msg (const char * msg)
{
  struct MonoException * D.16777;
  struct MonoImage * D.16778;

  D.16778 = mono_get_corlib ();
  D.16777 = mono_exception_from_name_msg (D.16778, "System", "FieldAccessException", msg);
  return D.16777;
}


mono_get_exception_method_access ()
{
  struct MonoException * D.16780;
  struct MonoImage * D.16781;

  D.16781 = mono_get_corlib ();
  D.16780 = mono_exception_from_name (D.16781, "System", "MethodAccessException");
  return D.16780;
}


__attribute__((visibility ("hidden")))
mono_get_exception_method_access_msg (const char * msg)
{
  struct MonoException * D.16783;
  struct MonoImage * D.16784;

  D.16784 = mono_get_corlib ();
  D.16783 = mono_exception_from_name_msg (D.16784, "System", "MethodAccessException", msg);
  return D.16783;
}


mono_get_exception_reflection_type_load (struct MonoArray * types, struct MonoArray * exceptions)
{
  struct MonoImage * D.16786;
  _Bool D.16787;
  long int D.16788;
  long int D.16789;
  const char * D.16792;
  int D.16793;
  short unsigned int D.16796;
  struct MonoType * D.16799;
  unsigned char D.16800;
  struct MonoType * D.16803;
  unsigned char D.16804;
  _Bool D.16806;
  long int D.16807;
  long int D.16808;
  struct MonoDomain * D.16811;
  struct MonoException * D.16812;
  struct MonoClass * klass;
  void * args[2];
  struct MonoObject * exc;
  struct MonoMethod * method;
  void * iter;

  try
    {
      D.16786 = mono_get_corlib ();
      klass = mono_class_from_name (D.16786, "System.Reflection", "ReflectionTypeLoadException");
      D.16787 = klass == 0B;
      D.16788 = (long int) D.16787;
      D.16789 = __builtin_expect (D.16788, 0);
      if (D.16789 != 0) goto <D.16790>; else goto <D.16791>;
      <D.16790>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "exception.c", 746, "klass");
      <D.16791>:
      mono_class_init (klass);
      iter = 0B;
      goto <D.16505>;
      <D.16504>:
      D.16792 = mono_method_get_name (method);
      D.16793 = strcmp (".ctor", D.16792);
      if (D.16793 == 0) goto <D.16794>; else goto <D.16795>;
      <D.16794>:
      {
        struct MonoMethodSignature * sig;

        sig = mono_method_signature (method);
        D.16796 = sig->param_count;
        if (D.16796 == 2) goto <D.16797>; else goto <D.16798>;
        <D.16797>:
        D.16799 = sig->params[0];
        D.16800 = D.16799->type;
        if (D.16800 == 29) goto <D.16801>; else goto <D.16802>;
        <D.16801>:
        D.16803 = sig->params[1];
        D.16804 = D.16803->type;
        if (D.16804 == 29) goto <D.16503>; else goto <D.16805>;
        <D.16805>:
        <D.16802>:
        <D.16798>:
      }
      <D.16795>:
      method = 0B;
      <D.16505>:
      method = mono_class_get_methods (klass, &iter);
      if (method != 0B) goto <D.16504>; else goto <D.16503>;
      <D.16503>:
      D.16806 = method == 0B;
      D.16807 = (long int) D.16806;
      D.16808 = __builtin_expect (D.16807, 0);
      if (D.16808 != 0) goto <D.16809>; else goto <D.16810>;
      <D.16809>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "exception.c", 760, "method");
      <D.16810>:
      args[0] = types;
      args[1] = exceptions;
      D.16811 = mono_domain_get ();
      exc = mono_object_new (D.16811, klass);
      mono_runtime_invoke (method, exc, &args, 0B);
      D.16812 = exc;
      return D.16812;
    }
  finally
    {
      args = {CLOBBER};
      iter = {CLOBBER};
    }
}


mono_get_exception_runtime_wrapped (struct MonoObject * wrapped_exception)
{
  struct MonoImage * D.16815;
  struct MonoObject * * D.16816;
  struct MonoException * D.16817;
  struct MonoRuntimeWrappedException * ex;

  D.16815 = mono_get_corlib ();
  ex = mono_exception_from_name (D.16815, "System.Runtime.CompilerServices", "RuntimeWrappedException");
  D.16816 = &ex->wrapped_exception;
  mono_gc_wbarrier_set_field (ex, D.16816, wrapped_exception);
  D.16817 = ex;
  return D.16817;
}


__attribute__((visibility ("hidden")))
mono_exception_get_managed_backtrace (struct MonoException * exc)
{
  struct MonoRuntimeExceptionHandlingCallbacks * D.16819;
  gboolean (*<T2710>) (struct MonoException *, gboolean (*MonoInternalExceptionFrameWalk) (struct MonoMethod *, void *, size_t, gboolean, void *), void *) D.16820;
  int D.16821;
  char * D.16824;
  struct GString * text;

  text = monoeg_g_string_new_len (0B, 20);
  D.16819 = mono_get_eh_callbacks ();
  D.16820 = D.16819->mono_exception_walk_trace;
  D.16821 = D.16820 (exc, append_frame_and_continue, text);
  if (D.16821 == 0) goto <D.16822>; else goto <D.16823>;
  <D.16822>:
  monoeg_g_string_append (text, "managed backtrace not available\n");
  <D.16823>:
  D.16824 = monoeg_g_string_free (text, 0);
  return D.16824;
}


append_frame_and_continue (struct MonoMethod * method, void * ip, size_t native_offset, gboolean managed, void * user_data)
{
  unsigned int D.16828;
  gboolean D.16830;
  struct MonoDomain * domain;
  struct GString * text;

  domain = mono_domain_get ();
  text = user_data;
  if (method != 0B) goto <D.16826>; else goto <D.16827>;
  <D.16826>:
  {
    char * msg;

    D.16828 = (unsigned int) native_offset;
    msg = mono_debug_print_stack_frame (method, D.16828, domain);
    monoeg_g_string_append_printf (text, "%s\n", msg);
    monoeg_g_free (msg);
  }
  goto <D.16829>;
  <D.16827>:
  monoeg_g_string_append_printf (text, "<unknown native frame 0x%x>\n", ip);
  <D.16829>:
  D.16830 = 0;
  return D.16830;
}


__attribute__((visibility ("hidden")))
mono_exception_get_native_backtrace (struct MonoException * exc)
{
  char * D.16834;
  long unsigned int D.16835;
  int D.16836;
  long int D.16837;
  char * D.16838;
  long unsigned int D.16839;
  char * D.16840;
  struct MonoDomain * D.16841;
  struct MonoMethod * D.16844;
  long int ip.5;
  void * D.16846;
  long int D.16847;
  long int D.16848;
  unsigned int D.16849;
  long unsigned int D.16851;
  long unsigned int D.16852;
  char * * D.16853;
  char * D.16854;
  struct MonoDomain * domain;
  struct MonoArray * arr;
  int i;
  int len;
  struct GString * text;
  char * * messages;

  arr = exc->native_trace_ips;
  if (arr == 0B) goto <D.16832>; else goto <D.16833>;
  <D.16832>:
  D.16834 = monoeg_strdup ("");
  return D.16834;
  <D.16833>:
  domain = mono_domain_get ();
  D.16835 = mono_array_length (arr);
  len = (int) D.16835;
  D.16836 = len * 20;
  D.16837 = (long int) D.16836;
  text = monoeg_g_string_new_len (0B, D.16837);
  D.16838 = mono_array_addr_with_size (arr, 8, 0);
  messages = backtrace_symbols (D.16838, len);
  i = 0;
  goto <D.16537>;
  <D.16536>:
  {
    void * ip;
    struct MonoJitInfo * ji;

    D.16839 = (long unsigned int) i;
    D.16840 = mono_array_addr_with_size (arr, 8, D.16839);
    ip = MEM[(void * *)D.16840];
    D.16841 = mono_domain_get ();
    ji = mono_jit_info_table_find (D.16841, ip);
    if (ji != 0B) goto <D.16842>; else goto <D.16843>;
    <D.16842>:
    {
      char * msg;

      D.16844 = mono_jit_info_get_method (ji);
      ip.5 = (long int) ip;
      D.16846 = ji->code_start;
      D.16847 = (long int) D.16846;
      D.16848 = ip.5 - D.16847;
      D.16849 = (unsigned int) D.16848;
      msg = mono_debug_print_stack_frame (D.16844, D.16849, domain);
      monoeg_g_string_append_printf (text, "%s\n", msg);
      monoeg_g_free (msg);
    }
    goto <D.16850>;
    <D.16843>:
    D.16851 = (long unsigned int) i;
    D.16852 = D.16851 * 8;
    D.16853 = messages + D.16852;
    D.16854 = *D.16853;
    monoeg_g_string_append_printf (text, "%s\n", D.16854);
    <D.16850>:
  }
  i = i + 1;
  <D.16537>:
  if (i < len) goto <D.16536>; else goto <D.16538>;
  <D.16538>:
  free (messages);
  D.16834 = monoeg_g_string_free (text, 0);
  return D.16834;
}


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

  if (str != 0B) goto <D.16856>; else goto <D.16857>;
  <D.16856>:
  D.16858 = __strdup (str);
  return D.16858;
  <D.16857>:
  D.16858 = 0B;
  return D.16858;
}


__attribute__((visibility ("hidden")))
ves_icall_Mono_Runtime_GetNativeStackTrace (struct MonoException * exc)
{
  struct MonoException * D.16862;
  struct MonoDomain * D.16863;
  struct MonoString * D.16864;
  char * trace;
  struct MonoString * res;

  if (exc == 0B) goto <D.16860>; else goto <D.16861>;
  <D.16860>:
  D.16862 = mono_get_exception_argument_null ("exception");
  mono_raise_exception (D.16862);
  <D.16861>:
  trace = mono_exception_get_native_backtrace (exc);
  D.16863 = mono_domain_get ();
  res = mono_string_new (D.16863, trace);
  monoeg_g_free (trace);
  D.16864 = res;
  return D.16864;
}