__attribute__((visibility ("hidden")))
mono_signature_no_pinvoke (struct MonoMethod * method)
{
  long unsigned int D.21891;
  long unsigned int D.21892;
  struct MonoClass * D.21895;
  struct MonoImage * D.21896;
  struct MonoMethodSignature * D.21897;
  struct MonoMethodSignature * sig;

  sig = mono_method_signature (method);
  D.21891 = BIT_FIELD_REF <*sig, 64, 64>;
  D.21892 = D.21891 & 128;
  if (D.21892 != 0) goto <D.21893>; else goto <D.21894>;
  <D.21893>:
  D.21895 = method->klass;
  D.21896 = D.21895->image;
  sig = signature_dup (D.21896, sig);
  sig->pinvoke = 0;
  <D.21894>:
  D.21897 = sig;
  return D.21897;
}


signature_dup (struct MonoImage * image, struct MonoMethodSignature * sig)
{
  short unsigned int D.21899;
  unsigned int D.21900;
  long unsigned int D.21901;
  long unsigned int D.21902;
  unsigned int D.21903;
  unsigned int D.21904;
  long unsigned int D.21905;
  struct MonoMethodSignature * D.21906;
  struct MonoMethodSignature * res;
  int sigsize;

  D.21899 = sig->param_count;
  D.21900 = (unsigned int) D.21899;
  res = mono_metadata_signature_alloc (image, D.21900);
  D.21899 = sig->param_count;
  D.21901 = (long unsigned int) D.21899;
  D.21902 = D.21901 + 2;
  D.21903 = (unsigned int) D.21902;
  D.21904 = D.21903 * 8;
  sigsize = (int) D.21904;
  D.21905 = (long unsigned int) sigsize;
  memcpy (res, sig, D.21905);
  D.21906 = res;
  return D.21906;
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__, __nothrow__, __leaf__))
memcpy (void * restrict __dest, const void * restrict __src, size_t __len)
{
  void * D.21908;
  long unsigned int D.21909;

  D.21909 = __builtin_object_size (__dest, 0);
  D.21908 = __builtin___memcpy_chk (__dest, __src, __len, D.21909);
  return D.21908;
}


__attribute__((visibility ("hidden")))
mono_marshal_init_tls ()
{
  mono_native_tls_alloc (&last_error_tls_id, 0B);
  mono_native_tls_alloc (&load_type_info_tls_id, 0B);
}


mono_native_tls_alloc (pthread_key_t * key, void * destructor)
{
  int D.21911;
  void (*<Tc6>) (void *) destructor.0;
  int D.21913;
  _Bool D.21914;

  destructor.0 = (void (*<Tc6>) (void *)) destructor;
  D.21913 = pthread_key_create (key, destructor.0);
  D.21914 = D.21913 == 0;
  D.21911 = (int) D.21914;
  return D.21911;
}


__attribute__((visibility ("hidden")))
mono_marshal_init ()
{
  int module_initialized.1;
  static gboolean module_initialized = 0;

  module_initialized.1 = module_initialized;
  if (module_initialized.1 == 0) goto <D.21917>; else goto <D.21918>;
  <D.21917>:
  module_initialized = 1;
  InitializeCriticalSection (&marshal_mutex);
  marshal_mutex_initialized = 1;
  register_icall (ves_icall_System_Threading_Thread_ResetAbort, "ves_icall_System_Threading_Thread_ResetAbort", "void", 1);
  register_icall (mono_marshal_string_to_utf16, "mono_marshal_string_to_utf16", "ptr obj", 0);
  register_icall (mono_marshal_string_to_utf16_copy, "mono_marshal_string_to_utf16_copy", "ptr obj", 0);
  register_icall (mono_string_to_utf16, "mono_string_to_utf16", "ptr obj", 0);
  register_icall (mono_string_from_utf16, "mono_string_from_utf16", "obj ptr", 0);
  register_icall (mono_string_from_byvalwstr, "mono_string_from_byvalwstr", "obj ptr int", 0);
  register_icall (mono_string_new_wrapper, "mono_string_new_wrapper", "obj ptr", 0);
  register_icall (mono_string_new_len_wrapper, "mono_string_new_len_wrapper", "obj ptr int", 0);
  register_icall (mono_string_to_utf8, "mono_string_to_utf8", "ptr obj", 0);
  register_icall (mono_string_to_lpstr, "mono_string_to_lpstr", "ptr obj", 0);
  register_icall (mono_string_to_ansibstr, "mono_string_to_ansibstr", "ptr object", 0);
  register_icall (mono_string_builder_to_utf8, "mono_string_builder_to_utf8", "ptr object", 0);
  register_icall (mono_string_builder_to_utf16, "mono_string_builder_to_utf16", "ptr object", 0);
  register_icall (mono_array_to_savearray, "mono_array_to_savearray", "ptr object", 0);
  register_icall (mono_array_to_lparray, "mono_array_to_lparray", "ptr object", 0);
  register_icall (mono_free_lparray, "mono_free_lparray", "void object ptr", 0);
  register_icall (mono_byvalarray_to_array, "mono_byvalarray_to_array", "void object ptr ptr int32", 0);
  register_icall (mono_byvalarray_to_byte_array, "mono_byvalarray_to_byte_array", "void object ptr int32", 0);
  register_icall (mono_array_to_byvalarray, "mono_array_to_byvalarray", "void ptr object ptr int32", 0);
  register_icall (mono_array_to_byte_byvalarray, "mono_array_to_byte_byvalarray", "void ptr object int32", 0);
  register_icall (mono_delegate_to_ftnptr, "mono_delegate_to_ftnptr", "ptr object", 0);
  register_icall (mono_ftnptr_to_delegate, "mono_ftnptr_to_delegate", "object ptr ptr", 0);
  register_icall (mono_marshal_asany, "mono_marshal_asany", "ptr object int32 int32", 0);
  register_icall (mono_marshal_free_asany, "mono_marshal_free_asany", "void object ptr int32 int32", 0);
  register_icall (mono_marshal_alloc, "mono_marshal_alloc", "ptr int32", 0);
  register_icall (mono_marshal_free, "mono_marshal_free", "void ptr", 0);
  register_icall (mono_marshal_set_last_error, "mono_marshal_set_last_error", "void", 0);
  register_icall (mono_marshal_set_last_error_windows, "mono_marshal_set_last_error_windows", "void int32", 0);
  register_icall (mono_string_utf8_to_builder, "mono_string_utf8_to_builder", "void ptr ptr", 0);
  register_icall (mono_string_utf8_to_builder2, "mono_string_utf8_to_builder2", "object ptr", 0);
  register_icall (mono_string_utf16_to_builder, "mono_string_utf16_to_builder", "void ptr ptr", 0);
  register_icall (mono_string_utf16_to_builder2, "mono_string_utf16_to_builder2", "object ptr", 0);
  register_icall (mono_marshal_free_array, "mono_marshal_free_array", "void ptr int32", 0);
  register_icall (mono_string_to_byvalstr, "mono_string_to_byvalstr", "void ptr ptr int32", 0);
  register_icall (mono_string_to_byvalwstr, "mono_string_to_byvalwstr", "void ptr ptr int32", 0);
  register_icall (monoeg_g_free, "g_free", "void ptr", 0);
  register_icall (mono_object_isinst, "mono_object_isinst", "object object ptr", 0);
  register_icall (mono_struct_delete_old, "mono_struct_delete_old", "void ptr ptr", 0);
  register_icall (mono_delegate_begin_invoke, "mono_delegate_begin_invoke", "object object ptr", 0);
  register_icall (mono_delegate_end_invoke, "mono_delegate_end_invoke", "object object ptr", 0);
  register_icall (mono_marshal_xdomain_copy_value, "mono_marshal_xdomain_copy_value", "object object", 0);
  register_icall (mono_marshal_xdomain_copy_out_value, "mono_marshal_xdomain_copy_out_value", "void object object", 0);
  register_icall (mono_marshal_set_domain_by_id, "mono_marshal_set_domain_by_id", "int32 int32 int32", 0);
  register_icall (mono_marshal_check_domain_image, "mono_marshal_check_domain_image", "int32 int32 ptr", 0);
  register_icall (mono_compile_method, "mono_compile_method", "ptr ptr", 0);
  register_icall (mono_context_get, "mono_context_get", "object", 0);
  register_icall (mono_context_set, "mono_context_set", "void object", 0);
  register_icall (type_from_handle, "type_from_handle", "object ptr", 0);
  register_icall (mono_gc_wbarrier_generic_nostore, "wb_generic", "void ptr", 0);
  register_icall (mono_gchandle_get_target, "mono_gchandle_get_target", "object int32", 1);
  register_icall (mono_remoting_wrapper, "mono_remoting_wrapper", "object ptr ptr", 0);
  register_icall (mono_upgrade_remote_class_wrapper, "mono_upgrade_remote_class_wrapper", "void object object", 0);
  mono_cominterop_init ();
  <D.21918>:
}


mono_remoting_wrapper (struct MonoMethod * method, void * * params)
{
  void * D.21919;
  _Bool D.21920;
  long int D.21921;
  long int D.21922;
  struct MonoVTable * D.21925;
  struct MonoClass * D.21926;
  struct MonoClass * D.21927;
  _Bool D.21928;
  long int D.21929;
  long int D.21930;
  struct MonoRemoteClass * D.21933;
  struct MonoClass * D.21934;
  long unsigned int D.21935;
  long unsigned int D.21936;
  struct MonoRealProxy * D.21939;
  struct MonoObject * D.21940;
  struct MonoAppContext * D.21941;
  short unsigned int D.21944;
  long unsigned int D.21945;
  long unsigned int D.21946;
  struct MonoType * D.21947;
  long unsigned int D.21948;
  long unsigned int D.21949;
  long unsigned int D.21952;
  long unsigned int D.21953;
  long unsigned int D.21956;
  long unsigned int D.21957;
  void * * D.21958;
  void * * D.21959;
  void * D.21960;
  void * D.21961;
  struct MonoClass * D.21963;
  int D.21964;
  struct MonoObject * D.21967;
  void * * D.21970;
  struct MonoObject * D.21971;
  void * iftmp.2;
  struct MonoClass * D.21973;
  long unsigned int D.21974;
  long unsigned int D.21975;
  struct MonoObject * exc.3;
  struct MonoArray * out_args.4;
  struct MonoMethodMessage * msg;
  struct MonoTransparentProxy * this;
  struct MonoObject * res;
  struct MonoObject * exc;
  struct MonoArray * out_args;

  try
    {
      D.21919 = *params;
      this = MEM[(struct MonoTransparentProxy * *)D.21919];
      D.21920 = this == 0B;
      D.21921 = (long int) D.21920;
      D.21922 = __builtin_expect (D.21921, 0);
      if (D.21922 != 0) goto <D.21923>; else goto <D.21924>;
      <D.21923>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 3124, "this");
      <D.21924>:
      D.21925 = MEM[(struct MonoObject *)this].vtable;
      D.21926 = D.21925->klass;
      D.21927 = mono_defaults.transparent_proxy_class;
      D.21928 = D.21926 != D.21927;
      D.21929 = (long int) D.21928;
      D.21930 = __builtin_expect (D.21929, 0);
      if (D.21930 != 0) goto <D.21931>; else goto <D.21932>;
      <D.21931>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 3125, "((MonoObject *)this)->vtable->klass == mono_defaults.transparent_proxy_class");
      <D.21932>:
      params = params + 8;
      D.21933 = this->remote_class;
      D.21934 = D.21933->proxy_class;
      D.21935 = BIT_FIELD_REF <*D.21934, 64, 256>;
      D.21936 = D.21935 & 1099511627776;
      if (D.21936 != 0) goto <D.21937>; else goto <D.21938>;
      <D.21937>:
      D.21939 = this->rp;
      D.21940 = D.21939->context;
      D.21941 = mono_context_get ();
      if (D.21940 == D.21941) goto <D.21942>; else goto <D.21943>;
      <D.21942>:
      {
        int i;
        struct MonoMethodSignature * sig;
        int count;
        void * * mparams;

        sig = mono_method_signature (method);
        D.21944 = sig->param_count;
        count = (int) D.21944;
        D.21945 = (long unsigned int) count;
        D.21946 = D.21945 * 8;
        mparams = __builtin_alloca (D.21946);
        i = 0;
        goto <D.19744>;
        <D.19743>:
        {
          struct MonoClass * class;

          D.21947 = sig->params[i];
          class = mono_class_from_mono_type (D.21947);
          D.21948 = BIT_FIELD_REF <*class, 64, 256>;
          D.21949 = D.21948 & 1152921504606846976;
          if (D.21949 != 0) goto <D.21950>; else goto <D.21951>;
          <D.21950>:
          D.21947 = sig->params[i];
          D.21952 = BIT_FIELD_REF <*D.21947, 64, 64>;
          D.21953 = D.21952 & 8589934592;
          if (D.21953 != 0) goto <D.21954>; else goto <D.21955>;
          <D.21954>:
          D.21956 = (long unsigned int) i;
          D.21957 = D.21956 * 8;
          D.21958 = mparams + D.21957;
          D.21956 = (long unsigned int) i;
          D.21957 = D.21956 * 8;
          D.21959 = params + D.21957;
          D.21960 = *D.21959;
          D.21961 = MEM[(void * *)D.21960];
          *D.21958 = D.21961;
          goto <D.21962>;
          <D.21955>:
          D.21947 = sig->params[i];
          D.21963 = mono_class_from_mono_type (D.21947);
          D.21964 = mono_class_is_nullable (D.21963);
          if (D.21964 != 0) goto <D.21965>; else goto <D.21966>;
          <D.21965>:
          D.21956 = (long unsigned int) i;
          D.21957 = D.21956 * 8;
          D.21958 = mparams + D.21957;
          D.21956 = (long unsigned int) i;
          D.21957 = D.21956 * 8;
          D.21959 = params + D.21957;
          D.21960 = *D.21959;
          D.21967 = mono_nullable_box (D.21960, class);
          *D.21958 = D.21967;
          goto <D.21968>;
          <D.21966>:
          D.21956 = (long unsigned int) i;
          D.21957 = D.21956 * 8;
          D.21958 = mparams + D.21957;
          D.21956 = (long unsigned int) i;
          D.21957 = D.21956 * 8;
          D.21959 = params + D.21957;
          D.21960 = *D.21959;
          *D.21958 = D.21960;
          <D.21968>:
          <D.21962>:
          goto <D.21969>;
          <D.21951>:
          D.21956 = (long unsigned int) i;
          D.21957 = D.21956 * 8;
          D.21958 = mparams + D.21957;
          D.21956 = (long unsigned int) i;
          D.21957 = D.21956 * 8;
          D.21959 = params + D.21957;
          D.21960 = *D.21959;
          D.21970 = MEM[(void * * *)D.21960];
          *D.21958 = D.21970;
          <D.21969>:
        }
        i = i + 1;
        <D.19744>:
        if (i < count) goto <D.19743>; else goto <D.19745>;
        <D.19745>:
        D.21973 = method->klass;
        D.21974 = BIT_FIELD_REF <*D.21973, 64, 256>;
        D.21975 = D.21974 & 1152921504606846976;
        if (D.21975 != 0) goto <D.21976>; else goto <D.21977>;
        <D.21976>:
        iftmp.2 = mono_object_unbox (this);
        goto <D.21978>;
        <D.21977>:
        iftmp.2 = this;
        <D.21978>:
        D.21971 = mono_runtime_invoke (method, iftmp.2, mparams, 0B);
        return D.21971;
      }
      <D.21943>:
      <D.21938>:
      msg = mono_method_call_message_new (method, params, 0B, 0B, 0B);
      D.21939 = this->rp;
      res = mono_remoting_invoke (D.21939, msg, &exc, &out_args);
      exc.3 = exc;
      if (exc.3 != 0B) goto <D.21980>; else goto <D.21981>;
      <D.21980>:
      exc.3 = exc;
      mono_raise_exception (exc.3);
      <D.21981>:
      out_args.4 = out_args;
      mono_method_return_message_restore (method, params, out_args.4);
      D.21971 = res;
      return D.21971;
    }
  finally
    {
      exc = {CLOBBER};
      out_args = {CLOBBER};
    }
}


type_from_handle (struct MonoType * handle)
{
  struct MonoReflectionType * D.21985;
  struct MonoDomain * domain;
  struct MonoClass * klass;

  domain = mono_domain_get ();
  klass = mono_class_from_mono_type (handle);
  mono_class_init (klass);
  D.21985 = mono_type_get_object (domain, handle);
  return D.21985;
}


mono_marshal_check_domain_image (gint32 domain_id, struct MonoImage * image)
{
  gboolean D.21989;
  union mono_mutex_t * D.21990;
  _Bool D.21993;
  long int D.21994;
  long int D.21995;
  struct MonoImage * D.21998;
  _Bool D.22002;
  long int D.22003;
  long int D.22004;
  _Bool D.22007;
  struct MonoAssembly * ass;
  struct GSList * tmp;
  struct MonoDomain * domain;

  domain = mono_domain_get_by_id (domain_id);
  if (domain == 0B) goto <D.21987>; else goto <D.21988>;
  <D.21987>:
  D.21989 = 0;
  return D.21989;
  <D.21988>:
  {
    int ret;

    D.21990 = &domain->assemblies_lock.mutex;
    ret = pthread_mutex_lock (D.21990);
    if (ret != 0) goto <D.21991>; else goto <D.21992>;
    <D.21991>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.21992>:
    D.21993 = ret != 0;
    D.21994 = (long int) D.21993;
    D.21995 = __builtin_expect (D.21994, 0);
    if (D.21995 != 0) goto <D.21996>; else goto <D.21997>;
    <D.21996>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 3452, "ret == 0");
    <D.21997>:
  }
  tmp = domain->domain_assemblies;
  goto <D.19857>;
  <D.19856>:
  ass = tmp->data;
  D.21998 = ass->image;
  if (D.21998 == image) goto <D.19855>; else goto <D.21999>;
  <D.21999>:
  tmp = tmp->next;
  <D.19857>:
  if (tmp != 0B) goto <D.19856>; else goto <D.19855>;
  <D.19855>:
  {
    int ret;

    D.21990 = &domain->assemblies_lock.mutex;
    ret = pthread_mutex_unlock (D.21990);
    if (ret != 0) goto <D.22000>; else goto <D.22001>;
    <D.22000>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.22001>:
    D.22002 = ret != 0;
    D.22003 = (long int) D.22002;
    D.22004 = __builtin_expect (D.22003, 0);
    if (D.22004 != 0) goto <D.22005>; else goto <D.22006>;
    <D.22005>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 3458, "ret == 0");
    <D.22006>:
  }
  D.22007 = tmp != 0B;
  D.21989 = (gboolean) D.22007;
  return D.21989;
}


mono_marshal_set_domain_by_id (gint32 id, MonoBoolean push)
{
  int D.22012;
  struct MonoException * D.22013;
  gint32 D.22017;
  struct MonoDomain * current_domain;
  struct MonoDomain * domain;

  current_domain = mono_domain_get ();
  domain = mono_domain_get_by_id (id);
  if (domain == 0B) goto <D.22009>; else goto <D.22011>;
  <D.22011>:
  D.22012 = mono_domain_set (domain, 0);
  if (D.22012 == 0) goto <D.22009>; else goto <D.22010>;
  <D.22009>:
  D.22013 = mono_get_exception_appdomain_unloaded ();
  mono_raise_exception (D.22013);
  <D.22010>:
  if (push != 0) goto <D.22014>; else goto <D.22015>;
  <D.22014>:
  mono_thread_push_appdomain_ref (domain);
  goto <D.22016>;
  <D.22015>:
  mono_thread_pop_appdomain_ref ();
  <D.22016>:
  D.22017 = current_domain->domain_id;
  return D.22017;
}


mono_marshal_xdomain_copy_out_value (struct MonoObject * src, struct MonoObject * dst)
{
  struct MonoVTable * D.22022;
  struct MonoClass * D.22023;
  struct MonoVTable * D.22024;
  struct MonoClass * D.22025;
  _Bool D.22026;
  long int D.22027;
  long int D.22028;
  unsigned char D.22031;
  int D.22032;
  struct MonoClass * D.22033;
  struct MonoType * D.22034;
  <unnamed type> D.22035;
  long unsigned int D.22040;
  long unsigned int D.22041;
  char * D.22042;
  struct MonoObject * D.22043;
  struct MonoClass * D.22046;
  struct MonoString * * D.22049;
  struct MonoDomain * D.22050;
  struct MonoString * D.22051;
  mono_unichar2 * D.22052;
  int D.22053;
  struct MonoString * D.22054;
  int D.22055;

  if (src == 0B) goto <D.22019>; else goto <D.22021>;
  <D.22021>:
  if (dst == 0B) goto <D.22019>; else goto <D.22020>;
  <D.22019>:
  return;
  <D.22020>:
  D.22022 = src->vtable;
  D.22023 = D.22022->klass;
  D.22024 = dst->vtable;
  D.22025 = D.22024->klass;
  D.22026 = D.22023 != D.22025;
  D.22027 = (long int) D.22026;
  D.22028 = __builtin_expect (D.22027, 0);
  if (D.22028 != 0) goto <D.22029>; else goto <D.22030>;
  <D.22029>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 3340, "mono_object_class (src) == mono_object_class (dst)");
  <D.22030>:
  D.22022 = src->vtable;
  D.22023 = D.22022->klass;
  D.22031 = D.22023->byval_arg.type;
  D.22032 = (int) D.22031;
  switch (D.22032) <default: <D.22045>, case 20: <D.19811>, case 29: <D.19812>>
  <D.19811>:
  <D.19812>:
  {
    int mt;

    D.22022 = src->vtable;
    D.22023 = D.22022->klass;
    D.22033 = D.22023->element_class;
    D.22034 = &D.22033->byval_arg;
    D.22035 = mono_get_xdomain_marshal_type (D.22034);
    mt = (int) D.22035;
    if (mt == 3) goto <D.22036>; else goto <D.22037>;
    <D.22036>:
    return;
    <D.22037>:
    if (mt == 1) goto <D.22038>; else goto <D.22039>;
    <D.22038>:
    {
      int i;
      int len;

      D.22040 = mono_array_length (dst);
      len = (int) D.22040;
      i = 0;
      goto <D.19819>;
      <D.19818>:
      {
        struct MonoObject * item;

        D.22041 = (long unsigned int) i;
        D.22042 = mono_array_addr_with_size (src, 8, D.22041);
        item = MEM[(void * *)D.22042];
        {
          void * * __p;

          D.22041 = (long unsigned int) i;
          __p = mono_array_addr_with_size (dst, 8, D.22041);
          D.22043 = mono_marshal_xdomain_copy_value (item);
          mono_gc_wbarrier_set_arrayref (dst, __p, D.22043);
        }
      }
      i = i + 1;
      <D.19819>:
      if (i < len) goto <D.19818>; else goto <D.19820>;
      <D.19820>:
    }
    goto <D.22044>;
    <D.22039>:
    mono_array_full_copy (src, dst);
    <D.22044>:
    return;
  }
  <D.22045>:
  D.22022 = src->vtable;
  D.22023 = D.22022->klass;
  D.22046 = mono_defaults.stringbuilder_class;
  if (D.22023 == D.22046) goto <D.22047>; else goto <D.22048>;
  <D.22047>:
  {
    struct MonoStringBuilder * src_sb;
    struct MonoStringBuilder * dst_sb;

    src_sb = src;
    dst_sb = dst;
    D.22049 = &dst_sb->str;
    D.22024 = dst->vtable;
    D.22050 = D.22024->domain;
    D.22051 = src_sb->str;
    D.22052 = mono_string_chars (D.22051);
    D.22051 = src_sb->str;
    D.22053 = mono_string_length (D.22051);
    D.22054 = mono_string_new_utf16 (D.22050, D.22052, D.22053);
    mono_gc_wbarrier_set_field (dst_sb, D.22049, D.22054);
    dst_sb->cached_str = 0B;
    D.22055 = src_sb->length;
    dst_sb->length = D.22055;
  }
  <D.22048>:
}


mono_get_xdomain_marshal_type (struct MonoType * t)
{
  unsigned char D.22057;
  int D.22058;
  MonoXDomainMarshalType D.22059;
  struct MonoClass * D.22060;
  struct MonoType * D.22061;
  <unnamed type> D.22062;

  D.22057 = t->type;
  D.22058 = (int) D.22057;
  switch (D.22058) <default: <D.22065>, case 1: <D.19757>, case 2: <D.19760>, case 3: <D.19763>, case 4: <D.19759>, case 5: <D.19758>, case 6: <D.19762>, case 7: <D.19761>, case 8: <D.19765>, case 9: <D.19764>, case 10: <D.19766>, case 11: <D.19767>, case 12: <D.19768>, case 13: <D.19769>, case 14: <D.19770>, case 20: <D.19771>, case 29: <D.19772>>
  <D.19757>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "marshal.c", 3240);
  <D.19758>:
  <D.19759>:
  <D.19760>:
  <D.19761>:
  <D.19762>:
  <D.19763>:
  <D.19764>:
  <D.19765>:
  <D.19766>:
  <D.19767>:
  <D.19768>:
  <D.19769>:
  D.22059 = 0;
  return D.22059;
  <D.19770>:
  D.22059 = 1;
  return D.22059;
  <D.19771>:
  <D.19772>:
  {
    struct MonoClass * elem_class;

    D.22060 = mono_class_from_mono_type (t);
    elem_class = D.22060->element_class;
    D.22061 = &elem_class->byval_arg;
    D.22062 = mono_get_xdomain_marshal_type (D.22061);
    if (D.22062 != 3) goto <D.22063>; else goto <D.22064>;
    <D.22063>:
    D.22059 = 1;
    return D.22059;
    <D.22064>:
    goto <D.19774>;
  }
  <D.22065>:
  <D.19774>:
  D.22059 = 3;
  return D.22059;
}


mono_delegate_end_invoke (struct MonoDelegate * delegate, void * * params)
{
  _Bool D.22067;
  long int D.22068;
  long int D.22069;
  struct MonoReflectionMethod * D.22072;
  struct MonoMethod * D.22075;
  _Bool D.22076;
  long int D.22077;
  long int D.22078;
  struct MonoReflectionMethod * * D.22081;
  struct MonoReflectionMethod * D.22082;
  struct MonoMethod * D.22086;
  struct MonoVTable * D.22087;
  _Bool D.22088;
  long int D.22089;
  long int D.22090;
  struct MonoArray * D.22093;
  short unsigned int D.22094;
  int D.22095;
  int D.22096;
  long unsigned int D.22097;
  char * D.22098;
  struct MonoImage * D.22101;
  struct MonoException * D.22102;
  struct MonoObject * D.22103;
  struct MonoObject * D.22104;
  struct MonoException * D.22107;
  struct MonoObject * D.22110;
  struct MonoVTable * D.22112;
  struct MonoClass * D.22113;
  struct MonoClass * D.22114;
  struct MonoClass * D.22116;
  struct MonoAsyncResult * * D.22117;
  struct MonoRealProxy * D.22118;
  struct MonoObject * exc.5;
  struct MonoString * D.22122;
  struct MonoString * * D.22125;
  struct MonoString * D.22126;
  struct MonoArray * out_args.6;
  struct MonoDomain * domain;
  struct MonoAsyncResult * ares;
  struct MonoMethod * method;
  struct MonoMethodSignature * sig;
  struct MonoMethodMessage * msg;
  struct MonoObject * res;
  struct MonoObject * exc;
  struct MonoArray * out_args;
  struct MonoClass * klass;

  try
    {
      domain = mono_domain_get ();
      method = 0B;
      D.22067 = delegate == 0B;
      D.22068 = (long int) D.22067;
      D.22069 = __builtin_expect (D.22068, 0);
      if (D.22069 != 0) goto <D.22070>; else goto <D.22071>;
      <D.22070>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 2908, "delegate");
      <D.22071>:
      D.22072 = delegate->method_info;
      if (D.22072 == 0B) goto <D.22073>; else goto <D.22074>;
      <D.22073>:
      D.22075 = delegate->method;
      D.22076 = D.22075 == 0B;
      D.22077 = (long int) D.22076;
      D.22078 = __builtin_expect (D.22077, 0);
      if (D.22078 != 0) goto <D.22079>; else goto <D.22080>;
      <D.22079>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 2911, "delegate->method");
      <D.22080>:
      D.22081 = &delegate->method_info;
      D.22075 = delegate->method;
      D.22082 = mono_method_get_object (domain, D.22075, 0B);
      mono_gc_wbarrier_set_field (delegate, D.22081, D.22082);
      <D.22074>:
      D.22072 = delegate->method_info;
      if (D.22072 == 0B) goto <D.22083>; else goto <D.22085>;
      <D.22085>:
      D.22072 = delegate->method_info;
      D.22086 = D.22072->method;
      if (D.22086 == 0B) goto <D.22083>; else goto <D.22084>;
      <D.22083>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "marshal.c", 2916);
      <D.22084>:
      D.22087 = delegate->object.vtable;
      klass = D.22087->klass;
      method = mono_class_get_method_from_name (klass, "EndInvoke", -1);
      D.22088 = method == 0B;
      D.22089 = (long int) D.22088;
      D.22090 = __builtin_expect (D.22089, 0);
      if (D.22090 != 0) goto <D.22091>; else goto <D.22092>;
      <D.22091>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 2921, "method != NULL");
      <D.22092>:
      sig = mono_signature_no_pinvoke (method);
      msg = mono_method_call_message_new (method, params, 0B, 0B, 0B);
      D.22093 = msg->args;
      D.22094 = sig->param_count;
      D.22095 = (int) D.22094;
      D.22096 = D.22095 + -1;
      D.22097 = (long unsigned int) D.22096;
      D.22098 = mono_array_addr_with_size (D.22093, 8, D.22097);
      ares = MEM[(void * *)D.22098];
      if (ares == 0B) goto <D.22099>; else goto <D.22100>;
      <D.22099>:
      D.22101 = mono_defaults.corlib;
      D.22102 = mono_exception_from_name_msg (D.22101, "System.Runtime.Remoting", "RemotingException", "The async result object is null or of an unexpected type.");
      mono_raise_exception (D.22102);
      D.22103 = 0B;
      return D.22103;
      <D.22100>:
      D.22104 = ares->async_delegate;
      if (D.22104 != delegate) goto <D.22105>; else goto <D.22106>;
      <D.22105>:
      D.22107 = mono_get_exception_invalid_operation ("The IAsyncResult object provided does not match this delegate.");
      mono_raise_exception (D.22107);
      D.22103 = 0B;
      return D.22103;
      <D.22106>:
      D.22110 = delegate->target;
      if (D.22110 != 0B) goto <D.22111>; else goto <D.22108>;
      <D.22111>:
      D.22110 = delegate->target;
      D.22112 = D.22110->vtable;
      D.22113 = D.22112->klass;
      D.22114 = mono_defaults.transparent_proxy_class;
      if (D.22113 == D.22114) goto <D.22115>; else goto <D.22108>;
      <D.22115>:
      {
        struct MonoTransparentProxy * tp;

        tp = delegate->target;
        D.22116 = mono_defaults.mono_method_message_class;
        msg = mono_object_new (domain, D.22116);
        D.22072 = delegate->method_info;
        mono_message_init (domain, msg, D.22072, 0B);
        msg->call_type = 2;
        D.22117 = &msg->async_result;
        mono_gc_wbarrier_set_field (msg, D.22117, ares);
        D.22118 = tp->rp;
        res = mono_remoting_invoke (D.22118, msg, &exc, &out_args);
      }
      goto <D.22109>;
      <D.22108>:
      res = mono_thread_pool_finish (ares, &out_args, &exc);
      <D.22109>:
      exc.5 = exc;
      if (exc.5 != 0B) goto <D.22120>; else goto <D.22121>;
      <D.22120>:
      exc.5 = exc;
      D.22122 = MEM[(struct MonoException *)exc.5].stack_trace;
      if (D.22122 != 0B) goto <D.22123>; else goto <D.22124>;
      <D.22123>:
      {
        char * strace;
        char * tmp;

        exc.5 = exc;
        D.22122 = MEM[(struct MonoException *)exc.5].stack_trace;
        strace = mono_string_to_utf8 (D.22122);
        tmp = monoeg_g_strdup_printf ("%s\nException Rethrown at:\n", strace);
        monoeg_g_free (strace);
        exc.5 = exc;
        exc.5 = exc;
        D.22125 = &MEM[(struct MonoException *)exc.5].stack_trace;
        D.22126 = mono_string_new (domain, tmp);
        mono_gc_wbarrier_set_field (exc.5, D.22125, D.22126);
        monoeg_g_free (tmp);
      }
      <D.22124>:
      exc.5 = exc;
      mono_raise_exception (exc.5);
      <D.22121>:
      out_args.6 = out_args;
      mono_method_return_message_restore (method, params, out_args.6);
      D.22103 = res;
      return D.22103;
    }
  finally
    {
      exc = {CLOBBER};
      out_args = {CLOBBER};
    }
}


mono_delegate_begin_invoke (struct MonoDelegate * delegate, void * * params)
{
  _Bool D.22130;
  long int D.22131;
  long int D.22132;
  struct MonoMulticastDelegate * D.22135;
  struct MonoException * D.22138;
  struct MonoObject * D.22139;
  struct MonoVTable * D.22142;
  struct MonoClass * D.22143;
  struct MonoClass * D.22144;
  struct MonoRemoteClass * D.22149;
  struct MonoClass * D.22150;
  long unsigned int D.22151;
  long unsigned int D.22152;
  struct MonoRealProxy * D.22154;
  struct MonoObject * D.22155;
  struct MonoAppContext * D.22156;
  struct MonoMethod * D.22157;
  struct MonoDomain * D.22158;
  struct MonoObject * state.7;
  struct MonoObject * * D.22160;
  struct MonoObject * * D.22161;
  struct MonoDelegate * async_callback.8;
  struct MonoAsyncResult * * D.22163;
  struct MonoObject * exc.9;
  struct MonoAsyncResult * D.22167;
  struct MonoVTable * D.22168;
  _Bool D.22171;
  long int D.22172;
  long int D.22173;
  struct MonoClass * D.22176;
  struct MonoMethodMessage * msg;
  struct MonoDelegate * async_callback;
  struct MonoMulticastDelegate * mcast_delegate;
  struct MonoObject * state;
  struct MonoMethod * im;
  struct MonoClass * klass;
  struct MonoMethod * method;
  struct MonoMethod * method2;

  try
    {
      method = 0B;
      method2 = 0B;
      D.22130 = delegate == 0B;
      D.22131 = (long int) D.22130;
      D.22132 = __builtin_expect (D.22131, 0);
      if (D.22132 != 0) goto <D.22133>; else goto <D.22134>;
      <D.22133>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 2147, "delegate");
      <D.22134>:
      mcast_delegate = delegate;
      D.22135 = mcast_delegate->prev;
      if (D.22135 != 0B) goto <D.22136>; else goto <D.22137>;
      <D.22136>:
      D.22138 = mono_get_exception_argument (0B, "The delegate must have only one target");
      mono_raise_exception (D.22138);
      <D.22137>:
      D.22139 = delegate->target;
      if (D.22139 != 0B) goto <D.22140>; else goto <D.22141>;
      <D.22140>:
      D.22139 = delegate->target;
      D.22142 = D.22139->vtable;
      D.22143 = D.22142->klass;
      D.22144 = mono_defaults.transparent_proxy_class;
      if (D.22143 == D.22144) goto <D.22145>; else goto <D.22146>;
      <D.22145>:
      {
        struct MonoTransparentProxy * tp;

        tp = delegate->target;
        D.22149 = tp->remote_class;
        D.22150 = D.22149->proxy_class;
        D.22151 = BIT_FIELD_REF <*D.22150, 64, 256>;
        D.22152 = D.22151 & 1099511627776;
        if (D.22152 == 0) goto <D.22147>; else goto <D.22153>;
        <D.22153>:
        D.22154 = tp->rp;
        D.22155 = D.22154->context;
        D.22156 = mono_context_get ();
        if (D.22155 != D.22156) goto <D.22147>; else goto <D.22148>;
        <D.22147>:
        {
          struct MonoAsyncResult * ares;
          struct MonoObject * exc;
          struct MonoArray * out_args;

          try
            {
              method = delegate->method;
              D.22157 = mono_marshal_method_from_wrapper (method);
              msg = mono_method_call_message_new (D.22157, params, 0B, &async_callback, &state);
              D.22158 = mono_domain_get ();
              state.7 = state;
              ares = mono_async_result_new (D.22158, 0B, state.7, 0B, 0B);
              D.22160 = &ares->async_delegate;
              mono_gc_wbarrier_set_field (ares, D.22160, delegate);
              D.22161 = &ares->async_callback;
              async_callback.8 = async_callback;
              mono_gc_wbarrier_set_field (ares, D.22161, async_callback.8);
              D.22163 = &msg->async_result;
              mono_gc_wbarrier_set_field (msg, D.22163, ares);
              msg->call_type = 1;
              exc = 0B;
              D.22154 = tp->rp;
              mono_remoting_invoke (D.22154, msg, &exc, &out_args);
              exc.9 = exc;
              if (exc.9 != 0B) goto <D.22165>; else goto <D.22166>;
              <D.22165>:
              exc.9 = exc;
              mono_raise_exception (exc.9);
              <D.22166>:
              D.22167 = ares;
              return D.22167;
            }
          finally
            {
              exc = {CLOBBER};
              out_args = {CLOBBER};
            }
        }
        <D.22148>:
      }
      <D.22146>:
      <D.22141>:
      D.22168 = delegate->object.vtable;
      klass = D.22168->klass;
      method = mono_get_delegate_invoke (klass);
      method2 = mono_class_get_method_from_name (klass, "BeginInvoke", -1);
      if (method2 != 0B) goto <D.22169>; else goto <D.22170>;
      <D.22169>:
      method = method2;
      <D.22170>:
      D.22171 = method == 0B;
      D.22172 = (long int) D.22171;
      D.22173 = __builtin_expect (D.22172, 0);
      if (D.22173 != 0) goto <D.22174>; else goto <D.22175>;
      <D.22174>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 2188, "method != NULL");
      <D.22175>:
      D.22176 = method->klass;
      im = mono_get_delegate_invoke (D.22176);
      msg = mono_method_call_message_new (method, params, im, &async_callback, &state);
      async_callback.8 = async_callback;
      state.7 = state;
      D.22167 = mono_thread_pool_add (delegate, msg, async_callback.8, state.7);
      return D.22167;
    }
  finally
    {
      async_callback = {CLOBBER};
      state = {CLOBBER};
    }
}


mono_struct_delete_old (struct MonoClass * klass, char * ptr)
{
  struct MonoClassField * D.22180;
  short unsigned int D.22181;
  int D.22182;
  int D.22183;
  struct MonoMarshalSpec * D.22186;
  <unnamed-unsigned:1> D.22187;
  int D.22188;
  unsigned int D.22189;
  sizetype D.22190;
  <unnamed type> conv.10;
  int D.22192;
  struct MonoClass * D.22195;
  void * D.22196;
  unsigned int D.22197;
  unsigned int i.11;
  struct MonoMarshalType * info;
  int i;

  info = mono_marshal_load_type_info (klass);
  i = 0;
  goto <D.21578>;
  <D.21577>:
  {
    MonoMarshalNative ntype;
    MonoMarshalConv conv;
    struct MonoType * ftype;
    char * cpos;

    try
      {
        D.22180 = info->fields[i].field;
        ftype = D.22180->type;
        D.22181 = ftype->attrs;
        D.22182 = (int) D.22181;
        D.22183 = D.22182 & 16;
        if (D.22183 != 0) goto <D.22184>; else goto <D.22185>;
        <D.22184>:
        // predicted unlikely by continue predictor.
        goto <D.21567>;
        <D.22185>:
        D.22186 = info->fields[i].mspec;
        D.22187 = klass->unicode;
        D.22188 = (int) D.22187;
        ntype = mono_type_to_unmanaged (ftype, D.22186, 1, D.22188, &conv);
        D.22189 = info->fields[i].offset;
        D.22190 = (sizetype) D.22189;
        cpos = ptr + D.22190;
        conv.10 = conv;
        switch (conv.10) <default: <D.21576>, case 0: <D.21568>, case 3: <D.21573>, case 4: <D.21572>, case 7: <D.21570>, case 9: <D.21571>, case 10: <D.21574>, case 11: <D.21575>>
        <D.21568>:
        D.22192 = mono_type_is_struct (ftype);
        if (D.22192 != 0) goto <D.22193>; else goto <D.22194>;
        <D.22193>:
        D.22195 = ftype->data.klass;
        mono_struct_delete_old (D.22195, cpos);
        // predicted unlikely by continue predictor.
        goto <D.21567>;
        <D.22194>:
        goto <D.21569>;
        <D.21570>:
        goto <D.21569>;
        <D.21571>:
        <D.21572>:
        <D.21573>:
        <D.21574>:
        <D.21575>:
        D.22196 = MEM[(void * *)cpos];
        mono_marshal_free (D.22196);
        goto <D.21569>;
        <D.21576>:
        // predicted unlikely by continue predictor.
        goto <D.21567>;
        <D.21569>:
      }
    finally
      {
        conv = {CLOBBER};
      }
  }
  <D.21567>:
  i = i + 1;
  <D.21578>:
  D.22197 = info->num_fields;
  i.11 = (unsigned int) i;
  if (D.22197 > i.11) goto <D.21577>; else goto <D.21579>;
  <D.21579>:
}


mono_string_utf16_to_builder2 (gunichar2 * text)
{
  struct MonoStringBuilder * D.22204;
  struct MonoClass * string_builder_class.12;
  struct MonoImage * D.22208;
  struct MonoClass * string_builder_class.13;
  _Bool D.22210;
  long int D.22211;
  long int D.22212;
  struct MonoMethod * sb_ctor.14;
  struct MonoMethod * sb_ctor.15;
  _Bool D.22217;
  long int D.22218;
  long int D.22219;
  int len.16;
  int len.17;
  long unsigned int D.22224;
  long unsigned int D.22225;
  gunichar2 * D.22226;
  short unsigned int D.22227;
  struct MonoDomain * D.22228;
  _Bool D.22229;
  long int D.22230;
  long int D.22231;
  struct MonoObject * exc.18;
  _Bool D.22235;
  long int D.22236;
  long int D.22237;
  struct MonoString * D.22240;
  mono_unichar2 * D.22241;
  int D.22242;
  long unsigned int D.22243;
  int len;
  struct MonoStringBuilder * sb;
  static struct MonoClass * string_builder_class;
  static struct MonoMethod * sb_ctor;
  void * args[1];
  struct MonoObject * exc;

  try
    {
      if (text == 0B) goto <D.22202>; else goto <D.22203>;
      <D.22202>:
      D.22204 = 0B;
      return D.22204;
      <D.22203>:
      string_builder_class.12 = string_builder_class;
      if (string_builder_class.12 == 0B) goto <D.22206>; else goto <D.22207>;
      <D.22206>:
      {
        struct MonoMethodDesc * desc;

        D.22208 = mono_defaults.corlib;
        string_builder_class.13 = mono_class_from_name (D.22208, "System.Text", "StringBuilder");
        string_builder_class = string_builder_class.13;
        string_builder_class.12 = string_builder_class;
        D.22210 = string_builder_class.12 == 0B;
        D.22211 = (long int) D.22210;
        D.22212 = __builtin_expect (D.22211, 0);
        if (D.22212 != 0) goto <D.22213>; else goto <D.22214>;
        <D.22213>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 846, "string_builder_class");
        <D.22214>:
        desc = mono_method_desc_new (":.ctor(int)", 0);
        string_builder_class.12 = string_builder_class;
        sb_ctor.14 = mono_method_desc_search_in_class (desc, string_builder_class.12);
        sb_ctor = sb_ctor.14;
        sb_ctor.15 = sb_ctor;
        D.22217 = sb_ctor.15 == 0B;
        D.22218 = (long int) D.22217;
        D.22219 = __builtin_expect (D.22218, 0);
        if (D.22219 != 0) goto <D.22220>; else goto <D.22221>;
        <D.22220>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 849, "sb_ctor");
        <D.22221>:
        mono_method_desc_free (desc);
      }
      <D.22207>:
      len = 0;
      goto <D.19093>;
      <D.19092>:
      len.16 = len;
      len.17 = len.16 + 1;
      len = len.17;
      <D.19093>:
      len.16 = len;
      D.22224 = (long unsigned int) len.16;
      D.22225 = D.22224 * 2;
      D.22226 = text + D.22225;
      D.22227 = *D.22226;
      if (D.22227 != 0) goto <D.19092>; else goto <D.19094>;
      <D.19094>:
      D.22228 = mono_domain_get ();
      string_builder_class.12 = string_builder_class;
      sb = mono_object_new (D.22228, string_builder_class.12);
      D.22229 = sb == 0B;
      D.22230 = (long int) D.22229;
      D.22231 = __builtin_expect (D.22230, 0);
      if (D.22231 != 0) goto <D.22232>; else goto <D.22233>;
      <D.22232>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 857, "sb");
      <D.22233>:
      args[0] = &len;
      sb_ctor.15 = sb_ctor;
      mono_runtime_invoke (sb_ctor.15, sb, &args, &exc);
      exc.18 = exc;
      D.22235 = exc.18 != 0B;
      D.22236 = (long int) D.22235;
      D.22237 = __builtin_expect (D.22236, 0);
      if (D.22237 != 0) goto <D.22238>; else goto <D.22239>;
      <D.22238>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 860, "!exc");
      <D.22239>:
      len.16 = len;
      sb->length = len.16;
      D.22240 = sb->str;
      D.22241 = mono_string_chars (D.22240);
      len.16 = len;
      D.22242 = len.16 * 2;
      D.22243 = (long unsigned int) D.22242;
      memcpy (D.22241, text, D.22243);
      D.22204 = sb;
      return D.22204;
    }
  finally
    {
      len = {CLOBBER};
      args = {CLOBBER};
      exc = {CLOBBER};
    }
}


mono_string_utf8_to_builder2 (char * text)
{
  struct MonoStringBuilder * D.22248;
  struct MonoClass * string_builder_class.19;
  struct MonoImage * D.22252;
  struct MonoClass * string_builder_class.20;
  _Bool D.22254;
  long int D.22255;
  long int D.22256;
  struct MonoMethod * sb_ctor.21;
  struct MonoMethod * sb_ctor.22;
  _Bool D.22261;
  long int D.22262;
  long int D.22263;
  long unsigned int D.22266;
  int l.23;
  struct MonoDomain * D.22268;
  _Bool D.22269;
  long int D.22270;
  long int D.22271;
  struct MonoObject * exc.24;
  _Bool D.22275;
  long int D.22276;
  long int D.22277;
  int l;
  struct MonoStringBuilder * sb;
  static struct MonoClass * string_builder_class;
  static struct MonoMethod * sb_ctor;
  void * args[1];
  struct MonoObject * exc;

  try
    {
      if (text == 0B) goto <D.22246>; else goto <D.22247>;
      <D.22246>:
      D.22248 = 0B;
      return D.22248;
      <D.22247>:
      string_builder_class.19 = string_builder_class;
      if (string_builder_class.19 == 0B) goto <D.22250>; else goto <D.22251>;
      <D.22250>:
      {
        struct MonoMethodDesc * desc;

        D.22252 = mono_defaults.corlib;
        string_builder_class.20 = mono_class_from_name (D.22252, "System.Text", "StringBuilder");
        string_builder_class = string_builder_class.20;
        string_builder_class.19 = string_builder_class;
        D.22254 = string_builder_class.19 == 0B;
        D.22255 = (long int) D.22254;
        D.22256 = __builtin_expect (D.22255, 0);
        if (D.22256 != 0) goto <D.22257>; else goto <D.22258>;
        <D.22257>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 789, "string_builder_class");
        <D.22258>:
        desc = mono_method_desc_new (":.ctor(int)", 0);
        string_builder_class.19 = string_builder_class;
        sb_ctor.21 = mono_method_desc_search_in_class (desc, string_builder_class.19);
        sb_ctor = sb_ctor.21;
        sb_ctor.22 = sb_ctor;
        D.22261 = sb_ctor.22 == 0B;
        D.22262 = (long int) D.22261;
        D.22263 = __builtin_expect (D.22262, 0);
        if (D.22263 != 0) goto <D.22264>; else goto <D.22265>;
        <D.22264>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 792, "sb_ctor");
        <D.22265>:
        mono_method_desc_free (desc);
      }
      <D.22251>:
      D.22266 = __strlen_g (text);
      l.23 = (int) D.22266;
      l = l.23;
      D.22268 = mono_domain_get ();
      string_builder_class.19 = string_builder_class;
      sb = mono_object_new (D.22268, string_builder_class.19);
      D.22269 = sb == 0B;
      D.22270 = (long int) D.22269;
      D.22271 = __builtin_expect (D.22270, 0);
      if (D.22271 != 0) goto <D.22272>; else goto <D.22273>;
      <D.22272>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 799, "sb");
      <D.22273>:
      args[0] = &l;
      sb_ctor.22 = sb_ctor;
      mono_runtime_invoke (sb_ctor.22, sb, &args, &exc);
      exc.24 = exc;
      D.22275 = exc.24 != 0B;
      D.22276 = (long int) D.22275;
      D.22277 = __builtin_expect (D.22276, 0);
      if (D.22277 != 0) goto <D.22278>; else goto <D.22279>;
      <D.22278>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 802, "!exc");
      <D.22279>:
      mono_string_utf8_to_builder (sb, text);
      D.22248 = sb;
      return D.22248;
    }
  finally
    {
      l = {CLOBBER};
      args = {CLOBBER};
      exc = {CLOBBER};
    }
}


__attribute__((__gnu_inline__))
__strlen_g (const char * __str)
{
  size_t D.22282;
  long int __ptr.25;
  long int __str.26;
  long int D.22285;
  char * __ptr;
  char * __tmp;

  __ptr = 0B;
  __tmp = __str;
  __asm__ __volatile__("   la    0,0
0: srst  %0,%1
   jo    0b
" : "=&a" __ptr, "=&a" __tmp : "0" __ptr, "1" __tmp : "0", "memory", "cc");
  __ptr.25 = (long int) __ptr;
  __str.26 = (long int) __str;
  D.22285 = __ptr.25 - __str.26;
  D.22282 = (size_t) D.22285;
  return D.22282;
}


mono_marshal_set_last_error_windows (int error)
{

}


mono_array_to_byte_byvalarray (void * native_arr, struct MonoArray * arr, guint32 elnum)
{
  struct MonoClass * D.22287;

  D.22287 = mono_defaults.byte_class;
  mono_array_to_byvalarray (native_arr, arr, D.22287, elnum);
}


mono_array_to_byvalarray (void * native_arr, struct MonoArray * arr, struct MonoClass * elclass, guint32 elnum)
{
  struct MonoVTable * D.22288;
  struct MonoClass * D.22289;
  struct MonoClass * D.22290;
  struct MonoClass * D.22291;
  _Bool D.22292;
  long int D.22293;
  long int D.22294;
  struct MonoClass * D.22297;
  char * D.22300;
  long unsigned int D.22301;
  long int D.22302;
  struct GError * error.27;
  gchar * D.22306;
  size_t iftmp.28;
  long unsigned int D.22308;
  long unsigned int D.22309;

  D.22288 = arr->obj.vtable;
  D.22289 = D.22288->klass;
  D.22290 = D.22289->element_class;
  D.22291 = mono_defaults.char_class;
  D.22292 = D.22290 != D.22291;
  D.22293 = (long int) D.22292;
  D.22294 = __builtin_expect (D.22293, 0);
  if (D.22294 != 0) goto <D.22295>; else goto <D.22296>;
  <D.22295>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 715, "arr->obj.vtable->klass->element_class == mono_defaults.char_class");
  <D.22296>:
  D.22297 = mono_defaults.byte_class;
  if (D.22297 == elclass) goto <D.22298>; else goto <D.22299>;
  <D.22298>:
  {
    char * as;
    struct GError * error;

    try
      {
        error = 0B;
        D.22300 = mono_array_addr_with_size (arr, 2, 0);
        D.22301 = mono_array_length (arr);
        D.22302 = (long int) D.22301;
        as = monoeg_g_utf16_to_utf8 (D.22300, D.22302, 0B, 0B, &error);
        error.27 = error;
        if (error.27 != 0B) goto <D.22304>; else goto <D.22305>;
        <D.22304>:
        {
          struct MonoException * exc;

          error.27 = error;
          D.22306 = error.27->message;
          exc = mono_get_exception_argument ("string", D.22306);
          error.27 = error;
          monoeg_g_error_free (error.27);
          mono_raise_exception (exc);
        }
        <D.22305>:
        D.22308 = __strlen_g (as);
        D.22309 = (long unsigned int) elnum;
        if (D.22308 < D.22309) goto <D.22310>; else goto <D.22311>;
        <D.22310>:
        iftmp.28 = __strlen_g (as);
        goto <D.22312>;
        <D.22311>:
        iftmp.28 = (size_t) elnum;
        <D.22312>:
        memcpy (native_arr, as, iftmp.28);
        monoeg_g_free (as);
      }
    finally
      {
        error = {CLOBBER};
      }
  }
  goto <D.22313>;
  <D.22299>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "marshal.c", 731);
  <D.22313>:
}


mono_byvalarray_to_byte_array (struct MonoArray * arr, void * native_arr, guint32 elnum)
{
  struct MonoClass * D.22314;

  D.22314 = mono_defaults.byte_class;
  mono_byvalarray_to_array (arr, native_arr, D.22314, elnum);
}


mono_byvalarray_to_array (struct MonoArray * arr, void * native_arr, struct MonoClass * elclass, guint32 elnum)
{
  struct MonoVTable * D.22315;
  struct MonoClass * D.22316;
  struct MonoClass * D.22317;
  struct MonoClass * D.22318;
  _Bool D.22319;
  long int D.22320;
  long int D.22321;
  struct MonoClass * D.22324;
  long int D.22327;
  struct GError * error.29;
  char * D.22331;
  long int items_written.30;
  long unsigned int items_written.31;
  long unsigned int D.22334;

  D.22315 = arr->obj.vtable;
  D.22316 = D.22315->klass;
  D.22317 = D.22316->element_class;
  D.22318 = mono_defaults.char_class;
  D.22319 = D.22317 != D.22318;
  D.22320 = (long int) D.22319;
  D.22321 = __builtin_expect (D.22320, 0);
  if (D.22321 != 0) goto <D.22322>; else goto <D.22323>;
  <D.22322>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 686, "arr->obj.vtable->klass->element_class == mono_defaults.char_class");
  <D.22323>:
  D.22324 = mono_defaults.byte_class;
  if (D.22324 == elclass) goto <D.22325>; else goto <D.22326>;
  <D.22325>:
  {
    struct GError * error;
    guint16 * ut;
    glong items_written;

    try
      {
        error = 0B;
        D.22327 = (long int) elnum;
        ut = monoeg_g_utf8_to_utf16 (native_arr, D.22327, 0B, &items_written, &error);
        error.29 = error;
        if (error.29 == 0B) goto <D.22329>; else goto <D.22330>;
        <D.22329>:
        D.22331 = mono_array_addr_with_size (arr, 2, 0);
        items_written.30 = items_written;
        items_written.31 = (long unsigned int) items_written.30;
        D.22334 = items_written.31 * 2;
        memcpy (D.22331, ut, D.22334);
        monoeg_g_free (ut);
        goto <D.22335>;
        <D.22330>:
        error.29 = error;
        monoeg_g_error_free (error.29);
        <D.22335>:
      }
    finally
      {
        error = {CLOBBER};
        items_written = {CLOBBER};
      }
  }
  goto <D.22336>;
  <D.22326>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "marshal.c", 703);
  <D.22336>:
}


mono_string_to_lpstr (struct MonoString * s)
{
  void * D.22337;

  D.22337 = mono_string_to_utf8 (s);
  return D.22337;
}


mono_string_new_len_wrapper (const char * text, guint length)
{
  struct MonoString * D.22339;
  struct MonoDomain * D.22340;

  D.22340 = mono_domain_get ();
  D.22339 = mono_string_new_len (D.22340, text, length);
  return D.22339;
}


mono_string_from_byvalwstr (gunichar2 * data, int max_len)
{
  struct MonoString * D.22344;
  long unsigned int D.22345;
  long unsigned int D.22346;
  gunichar2 * D.22347;
  short unsigned int D.22348;
  int D.22349;
  struct MonoDomain * domain;
  int len;

  domain = mono_domain_get ();
  len = 0;
  if (data == 0B) goto <D.22342>; else goto <D.22343>;
  <D.22342>:
  D.22344 = 0B;
  return D.22344;
  <D.22343>:
  goto <D.18977>;
  <D.18976>:
  len = len + 1;
  <D.18977>:
  D.22345 = (long unsigned int) len;
  D.22346 = D.22345 * 2;
  D.22347 = data + D.22346;
  D.22348 = *D.22347;
  if (D.22348 != 0) goto <D.18976>; else goto <D.18978>;
  <D.18978>:
  D.22349 = MIN_EXPR <max_len, len>;
  D.22344 = mono_string_new_utf16 (domain, data, D.22349);
  return D.22344;
}


mono_marshal_string_to_utf16_copy (struct MonoString * s)
{
  void * D.22353;
  int D.22354;
  int D.22355;
  int D.22356;
  long unsigned int D.22357;
  mono_unichar2 * D.22358;
  int D.22359;
  int D.22360;
  long unsigned int D.22361;
  int D.22362;
  long unsigned int D.22363;
  long unsigned int D.22364;
  gunichar2 * D.22365;

  if (s == 0B) goto <D.22351>; else goto <D.22352>;
  <D.22351>:
  D.22353 = 0B;
  return D.22353;
  <D.22352>:
  {
    gunichar2 * res;

    D.22354 = mono_string_length (s);
    D.22355 = D.22354 + 1;
    D.22356 = D.22355 * 2;
    D.22357 = (long unsigned int) D.22356;
    res = mono_marshal_alloc (D.22357);
    D.22358 = mono_string_chars (s);
    D.22359 = mono_string_length (s);
    D.22360 = D.22359 * 2;
    D.22361 = (long unsigned int) D.22360;
    memcpy (res, D.22358, D.22361);
    D.22362 = mono_string_length (s);
    D.22363 = (long unsigned int) D.22362;
    D.22364 = D.22363 * 2;
    D.22365 = res + D.22364;
    *D.22365 = 0;
    D.22353 = res;
    return D.22353;
  }
}


register_icall (void * func, const char * name, const char * sigstr, gboolean save)
{
  struct MonoMethodSignature * sig;

  sig = mono_create_icall_signature (sigstr);
  mono_register_jit_icall (func, name, sig, save);
}


__attribute__((visibility ("hidden")))
mono_marshal_cleanup ()
{
  unsigned int load_type_info_tls_id.32;
  unsigned int last_error_tls_id.33;

  mono_cominterop_cleanup ();
  load_type_info_tls_id.32 = load_type_info_tls_id;
  mono_native_tls_free (load_type_info_tls_id.32);
  last_error_tls_id.33 = last_error_tls_id;
  mono_native_tls_free (last_error_tls_id.33);
  DeleteCriticalSection (&marshal_mutex);
  marshal_mutex_initialized = 0;
}


mono_native_tls_free (pthread_key_t key)
{
  pthread_key_delete (key);
}


__attribute__((visibility ("hidden")))
mono_delegate_to_ftnptr (struct MonoDelegate * delegate)
{
  void * D.22371;
  void * D.22372;
  struct MonoVTable * D.22375;
  long unsigned int D.22376;
  long unsigned int D.22377;
  _Bool D.22378;
  long int D.22379;
  long int D.22380;
  struct MonoMethodSignature * D.22383;
  long unsigned int D.22384;
  long unsigned int D.22385;
  const char * exc_class.34;
  _Bool D.22391;
  long int D.22392;
  long int D.22393;
  struct MonoImage * D.22396;
  const char * exc_arg.35;
  struct MonoException * D.22398;
  struct MonoObject * D.22399;
  void * D.22402;
  struct MonoMethod * method;
  struct MonoMethod * wrapper;
  struct MonoClass * klass;
  uint32_t target_handle;

  target_handle = 0;
  if (delegate == 0B) goto <D.22369>; else goto <D.22370>;
  <D.22369>:
  D.22371 = 0B;
  return D.22371;
  <D.22370>:
  D.22372 = delegate->delegate_trampoline;
  if (D.22372 != 0B) goto <D.22373>; else goto <D.22374>;
  <D.22373>:
  D.22371 = delegate->delegate_trampoline;
  return D.22371;
  <D.22374>:
  D.22375 = MEM[(struct MonoObject *)delegate].vtable;
  klass = D.22375->klass;
  D.22376 = BIT_FIELD_REF <*klass, 64, 256>;
  D.22377 = D.22376 & 549755813888;
  D.22378 = D.22377 == 0;
  D.22379 = (long int) D.22378;
  D.22380 = __builtin_expect (D.22379, 0);
  if (D.22380 != 0) goto <D.22381>; else goto <D.22382>;
  <D.22381>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 352, "klass->delegate");
  <D.22382>:
  method = delegate->method;
  D.22383 = mono_method_signature (method);
  D.22384 = BIT_FIELD_REF <*D.22383, 64, 64>;
  D.22385 = D.22384 & 128;
  if (D.22385 != 0) goto <D.22386>; else goto <D.22387>;
  <D.22386>:
  {
    const char * exc_class;
    const char * exc_arg;
    void * ftnptr;

    try
      {
        ftnptr = mono_lookup_pinvoke_call (method, &exc_class, &exc_arg);
        if (ftnptr == 0B) goto <D.22388>; else goto <D.22389>;
        <D.22388>:
        exc_class.34 = exc_class;
        D.22391 = exc_class.34 == 0B;
        D.22392 = (long int) D.22391;
        D.22393 = __builtin_expect (D.22392, 0);
        if (D.22393 != 0) goto <D.22394>; else goto <D.22395>;
        <D.22394>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 362, "exc_class");
        <D.22395>:
        D.22396 = mono_defaults.corlib;
        exc_class.34 = exc_class;
        exc_arg.35 = exc_arg;
        D.22398 = mono_exception_from_name_msg (D.22396, "System", exc_class.34, exc_arg.35);
        mono_raise_exception (D.22398);
        <D.22389>:
        D.22371 = ftnptr;
        return D.22371;
      }
    finally
      {
        exc_class = {CLOBBER};
        exc_arg = {CLOBBER};
      }
  }
  <D.22387>:
  D.22399 = delegate->target;
  if (D.22399 != 0B) goto <D.22400>; else goto <D.22401>;
  <D.22400>:
  D.22399 = delegate->target;
  target_handle = mono_gchandle_new_weakref (D.22399, 0);
  <D.22401>:
  wrapper = mono_marshal_get_managed_wrapper (method, klass, target_handle);
  D.22402 = mono_compile_method (wrapper);
  delegate->delegate_trampoline = D.22402;
  delegate_hash_table_add (delegate);
  mono_object_register_finalizer (delegate);
  D.22371 = delegate->delegate_trampoline;
  return D.22371;
}


delegate_hash_table_add (struct MonoDelegate * d)
{
  _Bool D.22407;
  long int D.22408;
  long int D.22409;
  struct GHashTable * delegate_hash_table.36;
  struct GHashTable * D.22415;
  int D.22416;
  void * D.22419;
  void * D.22420;
  long int D.22421;
  long unsigned int D.22422;
  void * D.22423;
  _Bool D.22429;
  long int D.22430;
  long int D.22431;
  guint32 gchandle;
  guint32 old_gchandle;

  {
    int ret;

    ret = pthread_mutex_lock (&marshal_mutex.mutex);
    if (ret != 0) goto <D.22405>; else goto <D.22406>;
    <D.22405>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.22406>:
    D.22407 = ret != 0;
    D.22408 = (long int) D.22407;
    D.22409 = __builtin_expect (D.22408, 0);
    if (D.22409 != 0) goto <D.22410>; else goto <D.22411>;
    <D.22410>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 420, "ret == 0");
    <D.22411>:
  }
  delegate_hash_table.36 = delegate_hash_table;
  if (delegate_hash_table.36 == 0B) goto <D.22413>; else goto <D.22414>;
  <D.22413>:
  D.22415 = delegate_hash_table_new ();
  delegate_hash_table = D.22415;
  <D.22414>:
  D.22416 = mono_gc_is_moving ();
  if (D.22416 != 0) goto <D.22417>; else goto <D.22418>;
  <D.22417>:
  gchandle = mono_gchandle_new_weakref (d, 0);
  delegate_hash_table.36 = delegate_hash_table;
  D.22419 = d->delegate_trampoline;
  D.22420 = monoeg_g_hash_table_lookup (delegate_hash_table.36, D.22419);
  D.22421 = (long int) D.22420;
  old_gchandle = (guint32) D.22421;
  delegate_hash_table.36 = delegate_hash_table;
  D.22419 = d->delegate_trampoline;
  D.22422 = (long unsigned int) gchandle;
  D.22423 = (void *) D.22422;
  monoeg_g_hash_table_insert_replace (delegate_hash_table.36, D.22419, D.22423, 0);
  if (old_gchandle != 0) goto <D.22424>; else goto <D.22425>;
  <D.22424>:
  mono_gchandle_free (old_gchandle);
  <D.22425>:
  goto <D.22426>;
  <D.22418>:
  delegate_hash_table.36 = delegate_hash_table;
  D.22419 = d->delegate_trampoline;
  monoeg_g_hash_table_insert_replace (delegate_hash_table.36, D.22419, d, 0);
  <D.22426>:
  {
    int ret;

    ret = pthread_mutex_unlock (&marshal_mutex.mutex);
    if (ret != 0) goto <D.22427>; else goto <D.22428>;
    <D.22427>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.22428>:
    D.22429 = ret != 0;
    D.22430 = (long int) D.22429;
    D.22431 = __builtin_expect (D.22430, 0);
    if (D.22431 != 0) goto <D.22432>; else goto <D.22433>;
    <D.22432>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 432, "ret == 0");
    <D.22433>:
  }
}


delegate_hash_table_new ()
{
  struct GHashTable * D.22434;

  D.22434 = monoeg_g_hash_table_new (0B, 0B);
  return D.22434;
}


__attribute__((visibility ("hidden")))
mono_marshal_use_aot_wrappers (gboolean use)
{
  use_aot_wrappers = use;
}


__attribute__((visibility ("hidden")))
mono_ftnptr_to_delegate (struct MonoClass * klass, void * ftn)
{
  void * ftn.37;
  struct MonoDelegate * D.22439;
  _Bool D.22442;
  long int D.22443;
  long int D.22444;
  struct GHashTable * delegate_hash_table.38;
  struct GHashTable * D.22450;
  int D.22451;
  void * D.22454;
  long int D.22455;
  _Bool D.22458;
  long int D.22459;
  long int D.22460;
  _Bool D.22469;
  long int D.22470;
  long int D.22471;
  int use_aot_wrappers.39;
  struct MonoDomain * D.22479;
  struct MonoClass * D.22480;
  struct MonoMethodSignature * D.22482;
  short unsigned int D.22483;
  int D.22484;
  int D.22485;
  long unsigned int D.22486;
  long unsigned int D.22487;
  struct MonoMethodSignature * D.22488;
  struct MonoImage * D.22489;
  struct MonoMethodSignature * D.22490;
  short unsigned int D.22491;
  long unsigned int D.22492;
  long unsigned int D.22493;
  struct MonoMarshalSpec * * D.22494;
  struct MonoMarshalSpec * D.22495;
  struct MonoDomain * D.22498;
  void * D.22499;
  struct MonoVTable * D.22500;
  struct MonoDomain * D.22501;
  struct MonoDomain * D.22502;
  struct MonoException * D.22505;
  guint32 gchandle;
  struct MonoDelegate * d;

  ftn.37 = ftn;
  if (ftn.37 == 0B) goto <D.22437>; else goto <D.22438>;
  <D.22437>:
  D.22439 = 0B;
  return D.22439;
  <D.22438>:
  {
    int ret;

    ret = pthread_mutex_lock (&marshal_mutex.mutex);
    if (ret != 0) goto <D.22440>; else goto <D.22441>;
    <D.22440>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.22441>:
    D.22442 = ret != 0;
    D.22443 = (long int) D.22442;
    D.22444 = __builtin_expect (D.22443, 0);
    if (D.22444 != 0) goto <D.22445>; else goto <D.22446>;
    <D.22445>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 483, "ret == 0");
    <D.22446>:
  }
  delegate_hash_table.38 = delegate_hash_table;
  if (delegate_hash_table.38 == 0B) goto <D.22448>; else goto <D.22449>;
  <D.22448>:
  D.22450 = delegate_hash_table_new ();
  delegate_hash_table = D.22450;
  <D.22449>:
  D.22451 = mono_gc_is_moving ();
  if (D.22451 != 0) goto <D.22452>; else goto <D.22453>;
  <D.22452>:
  delegate_hash_table.38 = delegate_hash_table;
  ftn.37 = ftn;
  D.22454 = monoeg_g_hash_table_lookup (delegate_hash_table.38, ftn.37);
  D.22455 = (long int) D.22454;
  gchandle = (guint32) D.22455;
  {
    int ret;

    ret = pthread_mutex_unlock (&marshal_mutex.mutex);
    if (ret != 0) goto <D.22456>; else goto <D.22457>;
    <D.22456>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.22457>:
    D.22458 = ret != 0;
    D.22459 = (long int) D.22458;
    D.22460 = __builtin_expect (D.22459, 0);
    if (D.22460 != 0) goto <D.22461>; else goto <D.22462>;
    <D.22461>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 489, "ret == 0");
    <D.22462>:
  }
  if (gchandle != 0) goto <D.22463>; else goto <D.22464>;
  <D.22463>:
  d = mono_gchandle_get_target (gchandle);
  goto <D.22465>;
  <D.22464>:
  d = 0B;
  <D.22465>:
  goto <D.22466>;
  <D.22453>:
  delegate_hash_table.38 = delegate_hash_table;
  ftn.37 = ftn;
  d = monoeg_g_hash_table_lookup (delegate_hash_table.38, ftn.37);
  {
    int ret;

    ret = pthread_mutex_unlock (&marshal_mutex.mutex);
    if (ret != 0) goto <D.22467>; else goto <D.22468>;
    <D.22467>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.22468>:
    D.22469 = ret != 0;
    D.22470 = (long int) D.22469;
    D.22471 = __builtin_expect (D.22470, 0);
    if (D.22471 != 0) goto <D.22472>; else goto <D.22473>;
    <D.22472>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 496, "ret == 0");
    <D.22473>:
  }
  <D.22466>:
  if (d == 0B) goto <D.22474>; else goto <D.22475>;
  <D.22474>:
  {
    struct MonoMethodSignature * sig;
    struct MonoMethod * wrapper;
    struct MonoMarshalSpec * * mspecs;
    struct MonoMethod * invoke;
    struct MonoMethodPInvoke piinfo;
    struct MonoObject * this;
    int i;

    try
      {
        invoke = mono_get_delegate_invoke (klass);
        use_aot_wrappers.39 = use_aot_wrappers;
        if (use_aot_wrappers.39 != 0) goto <D.22477>; else goto <D.22478>;
        <D.22477>:
        wrapper = mono_marshal_get_native_func_wrapper_aot (klass);
        D.22479 = mono_domain_get ();
        D.22480 = mono_defaults.int_class;
        this = mono_value_box (D.22479, D.22480, &ftn);
        goto <D.22481>;
        <D.22478>:
        memset (&piinfo, 0, 56);
        parse_unmanaged_function_pointer_attr (klass, &piinfo);
        D.22482 = mono_method_signature (invoke);
        D.22483 = D.22482->param_count;
        D.22484 = (int) D.22483;
        D.22485 = D.22484 + 1;
        D.22486 = (long unsigned int) D.22485;
        D.22487 = D.22486 * 8;
        mspecs = monoeg_malloc0 (D.22487);
        mono_method_get_marshal_info (invoke, mspecs);
        D.22488 = mono_method_signature (invoke);
        sig = mono_metadata_signature_dup (D.22488);
        sig->hasthis = 0;
        D.22489 = klass->image;
        ftn.37 = ftn;
        wrapper = mono_marshal_get_native_func_wrapper (D.22489, sig, &piinfo, mspecs, ftn.37);
        this = 0B;
        D.22490 = mono_method_signature (invoke);
        D.22491 = D.22490->param_count;
        i = (int) D.22491;
        goto <D.18960>;
        <D.18959>:
        D.22492 = (long unsigned int) i;
        D.22493 = D.22492 * 8;
        D.22494 = mspecs + D.22493;
        D.22495 = *D.22494;
        if (D.22495 != 0B) goto <D.22496>; else goto <D.22497>;
        <D.22496>:
        D.22492 = (long unsigned int) i;
        D.22493 = D.22492 * 8;
        D.22494 = mspecs + D.22493;
        D.22495 = *D.22494;
        mono_metadata_free_marshal_spec (D.22495);
        <D.22497>:
        i = i + -1;
        <D.18960>:
        if (i >= 0) goto <D.18959>; else goto <D.18961>;
        <D.18961>:
        monoeg_g_free (mspecs);
        monoeg_g_free (sig);
        <D.22481>:
        D.22498 = mono_domain_get ();
        d = mono_object_new (D.22498, klass);
        D.22499 = mono_compile_method (wrapper);
        mono_delegate_ctor_with_method (d, this, D.22499, wrapper);
      }
    finally
      {
        piinfo = {CLOBBER};
      }
  }
  <D.22475>:
  D.22500 = d->object.vtable;
  D.22501 = D.22500->domain;
  D.22502 = mono_domain_get ();
  if (D.22501 != D.22502) goto <D.22503>; else goto <D.22504>;
  <D.22503>:
  D.22505 = mono_get_exception_not_supported ("Delegates cannot be marshalled from native code into a domain other than their home domain");
  mono_raise_exception (D.22505);
  <D.22504>:
  D.22439 = d;
  return D.22439;
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__, __nothrow__, __leaf__))
memset (void * __dest, int __ch, size_t __len)
{
  void * D.22507;
  long unsigned int D.22508;

  D.22508 = __builtin_object_size (__dest, 0);
  D.22507 = __builtin___memset_chk (__dest, __ch, __len, D.22508);
  return D.22507;
}


parse_unmanaged_function_pointer_attr (struct MonoClass * klass, struct MonoMethodPInvoke * piinfo)
{
  struct MonoClass * UnmanagedFunctionPointerAttribute.40;
  struct MonoImage * D.22513;
  struct MonoClass * UnmanagedFunctionPointerAttribute.41;
  int D.22519;
  int D.22524;
  int D.22525;
  signed short D.22526;
  signed short iftmp.42;
  int D.22528;
  int D.22531;
  unsigned short D.22532;
  unsigned short D.22533;
  signed short D.22535;
  unsigned char D.22536;
  signed short D.22537;
  signed short D.22538;
  short unsigned int D.22539;
  int D.22540;
  static struct MonoClass * UnmanagedFunctionPointerAttribute;
  struct MonoCustomAttrInfo * cinfo;
  struct MonoReflectionUnmanagedFunctionPointerAttribute * attr;

  UnmanagedFunctionPointerAttribute.40 = UnmanagedFunctionPointerAttribute;
  if (UnmanagedFunctionPointerAttribute.40 == 0B) goto <D.22511>; else goto <D.22512>;
  <D.22511>:
  D.22513 = mono_defaults.corlib;
  UnmanagedFunctionPointerAttribute.41 = mono_class_from_name (D.22513, "System.Runtime.InteropServices", "UnmanagedFunctionPointerAttribute");
  UnmanagedFunctionPointerAttribute = UnmanagedFunctionPointerAttribute.41;
  <D.22512>:
  UnmanagedFunctionPointerAttribute.40 = UnmanagedFunctionPointerAttribute;
  if (UnmanagedFunctionPointerAttribute.40 != 0B) goto <D.22515>; else goto <D.22516>;
  <D.22515>:
  cinfo = mono_custom_attrs_from_class (klass);
  if (cinfo != 0B) goto <D.22517>; else goto <D.22518>;
  <D.22517>:
  D.22519 = mono_runtime_get_no_exec ();
  if (D.22519 == 0) goto <D.22520>; else goto <D.22521>;
  <D.22520>:
  UnmanagedFunctionPointerAttribute.40 = UnmanagedFunctionPointerAttribute;
  attr = mono_custom_attrs_get_attr (cinfo, UnmanagedFunctionPointerAttribute.40);
  if (attr != 0B) goto <D.22522>; else goto <D.22523>;
  <D.22522>:
  D.22524 = attr->call_conv;
  D.22525 = D.22524 << 8;
  D.22526 = (signed short) D.22525;
  D.22528 = attr->charset;
  if (D.22528 != 0) goto <D.22529>; else goto <D.22530>;
  <D.22529>:
  D.22528 = attr->charset;
  D.22531 = D.22528 + -1;
  D.22532 = (unsigned short) D.22531;
  D.22533 = D.22532 * 2;
  iftmp.42 = (signed short) D.22533;
  goto <D.22534>;
  <D.22530>:
  iftmp.42 = 1;
  <D.22534>:
  D.22535 = D.22526 | iftmp.42;
  D.22536 = attr->set_last_error;
  D.22537 = (signed short) D.22536;
  D.22538 = D.22535 | D.22537;
  D.22539 = (short unsigned int) D.22538;
  piinfo->piflags = D.22539;
  <D.22523>:
  D.22540 = cinfo->cached;
  if (D.22540 == 0) goto <D.22541>; else goto <D.22542>;
  <D.22541>:
  mono_custom_attrs_free (cinfo);
  <D.22542>:
  <D.22521>:
  <D.22518>:
  <D.22516>:
}


__attribute__((visibility ("hidden")))
mono_delegate_free_ftnptr (struct MonoDelegate * delegate)
{
  void * * D.22543;
  struct MonoObject * D.22544;
  struct MonoDomain * D.22549;
  void * D.22550;
  _Bool D.22551;
  long int D.22552;
  long int D.22553;
  void * * D.22556;
  void * D.22557;
  long int D.22558;
  struct MonoVTable * D.22561;
  struct MonoDomain * D.22562;
  struct MonoJitInfo * ji;
  void * ptr;

  delegate_hash_table_remove (delegate);
  D.22543 = &delegate->delegate_trampoline;
  ptr = InterlockedExchangePointer (D.22543, 0B);
  D.22544 = delegate->target;
  if (D.22544 == 0B) goto <D.22545>; else goto <D.22546>;
  <D.22545>:
  return;
  <D.22546>:
  if (ptr != 0B) goto <D.22547>; else goto <D.22548>;
  <D.22547>:
  {
    uint32_t gchandle;
    void * * method_data;
    struct MonoMethod * method;

    D.22549 = mono_domain_get ();
    D.22550 = mono_get_addr_from_ftnptr (ptr);
    ji = mono_jit_info_table_find (D.22549, D.22550);
    D.22551 = ji == 0B;
    D.22552 = (long int) D.22551;
    D.22553 = __builtin_expect (D.22552, 0);
    if (D.22553 != 0) goto <D.22554>; else goto <D.22555>;
    <D.22554>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 562, "ji");
    <D.22555>:
    method = mono_jit_info_get_method (ji);
    method_data = MEM[(struct MonoMethodWrapper *)method].method_data;
    D.22556 = method_data + 16;
    D.22557 = *D.22556;
    D.22558 = (long int) D.22557;
    gchandle = (uint32_t) D.22558;
    if (gchandle != 0) goto <D.22559>; else goto <D.22560>;
    <D.22559>:
    mono_gchandle_free (gchandle);
    <D.22560>:
    D.22561 = MEM[(struct MonoObject *)delegate].vtable;
    D.22562 = D.22561->domain;
    mono_runtime_free_method (D.22562, method);
  }
  <D.22548>:
}


delegate_hash_table_remove (struct MonoDelegate * d)
{
  _Bool D.22566;
  long int D.22567;
  long int D.22568;
  struct GHashTable * delegate_hash_table.43;
  struct GHashTable * D.22574;
  int D.22575;
  void * D.22578;
  void * D.22579;
  long int D.22580;
  _Bool D.22583;
  long int D.22584;
  long int D.22585;
  int D.22588;
  guint32 gchandle;

  gchandle = 0;
  {
    int ret;

    ret = pthread_mutex_lock (&marshal_mutex.mutex);
    if (ret != 0) goto <D.22564>; else goto <D.22565>;
    <D.22564>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.22565>:
    D.22566 = ret != 0;
    D.22567 = (long int) D.22566;
    D.22568 = __builtin_expect (D.22567, 0);
    if (D.22568 != 0) goto <D.22569>; else goto <D.22570>;
    <D.22569>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 403, "ret == 0");
    <D.22570>:
  }
  delegate_hash_table.43 = delegate_hash_table;
  if (delegate_hash_table.43 == 0B) goto <D.22572>; else goto <D.22573>;
  <D.22572>:
  D.22574 = delegate_hash_table_new ();
  delegate_hash_table = D.22574;
  <D.22573>:
  D.22575 = mono_gc_is_moving ();
  if (D.22575 != 0) goto <D.22576>; else goto <D.22577>;
  <D.22576>:
  delegate_hash_table.43 = delegate_hash_table;
  D.22578 = d->delegate_trampoline;
  D.22579 = monoeg_g_hash_table_lookup (delegate_hash_table.43, D.22578);
  D.22580 = (long int) D.22579;
  gchandle = (guint32) D.22580;
  <D.22577>:
  delegate_hash_table.43 = delegate_hash_table;
  D.22578 = d->delegate_trampoline;
  monoeg_g_hash_table_remove (delegate_hash_table.43, D.22578);
  {
    int ret;

    ret = pthread_mutex_unlock (&marshal_mutex.mutex);
    if (ret != 0) goto <D.22581>; else goto <D.22582>;
    <D.22581>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.22582>:
    D.22583 = ret != 0;
    D.22584 = (long int) D.22583;
    D.22585 = __builtin_expect (D.22584, 0);
    if (D.22585 != 0) goto <D.22586>; else goto <D.22587>;
    <D.22586>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 409, "ret == 0");
    <D.22587>:
  }
  D.22588 = mono_gc_is_moving ();
  if (D.22588 != 0) goto <D.22589>; else goto <D.22590>;
  <D.22589>:
  mono_gchandle_free (gchandle);
  <D.22590>:
}


InterlockedExchangePointer (void * volatile * val, void * new_val)
{
  long unsigned int old_val.44;
  long unsigned int new_val.45;
  long unsigned int D.22593;
  void * D.22594;
  void * D.22595;
  void * old_val;

  <D.18374>:
  old_val = *val;
  old_val.44 = (long unsigned int) old_val;
  new_val.45 = (long unsigned int) new_val;
  D.22593 = __sync_val_compare_and_swap_8 (val, old_val.44, new_val.45);
  D.22594 = (void *) D.22593;
  if (D.22594 != old_val) goto <D.18374>; else goto <D.18375>;
  <D.18375>:
  D.22595 = old_val;
  return D.22595;
}


__attribute__((visibility ("hidden")))
mono_array_to_savearray (struct MonoArray * array)
{
  void * D.22599;

  if (array == 0B) goto <D.22597>; else goto <D.22598>;
  <D.22597>:
  D.22599 = 0B;
  return D.22599;
  <D.22598>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "marshal.c", 597);
  D.22599 = 0B;
  return D.22599;
}


__attribute__((visibility ("hidden")))
mono_array_to_lparray (struct MonoArray * array)
{
  void * D.22603;
  struct MonoVTable * D.22604;
  struct MonoClass * D.22605;
  unsigned char D.22606;
  int D.22607;
  unsigned int D.22608;
  long unsigned int D.22609;
  long unsigned int D.22610;
  long unsigned int D.22611;
  long unsigned int D.22612;
  void * * D.22613;
  double[0:] * D.22614;
  void * * D.22615;
  void * D.22616;
  void * D.22617;
  void * * nativeArray;
  int nativeArraySize;
  int i;
  struct MonoClass * klass;

  nativeArray = 0B;
  nativeArraySize = 0;
  i = 0;
  if (array == 0B) goto <D.22601>; else goto <D.22602>;
  <D.22601>:
  D.22603 = 0B;
  return D.22603;
  <D.22602>:
  D.22604 = array->obj.vtable;
  klass = D.22604->klass;
  D.22605 = klass->element_class;
  D.22606 = D.22605->byval_arg.type;
  D.22607 = (int) D.22606;
  switch (D.22607) <default: <D.19016>, case 1: <D.18989>, case 2: <D.18995>, case 3: <D.18998>, case 4: <D.18996>, case 5: <D.18994>, case 6: <D.18999>, case 7: <D.18997>, case 8: <D.19002>, case 9: <D.19003>, case 10: <D.19005>, case 11: <D.19004>, case 12: <D.19006>, case 13: <D.19007>, case 14: <D.19015>, case 15: <D.19009>, case 17: <D.19008>, case 18: <D.18990>, case 20: <D.19013>, case 21: <D.19011>, case 24: <D.19000>, case 25: <D.19001>, case 28: <D.19012>, case 29: <D.19014>>
  <D.18989>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "marshal.c", 620);
  <D.18990>:
  D.22608 = array->max_length;
  nativeArraySize = (int) D.22608;
  D.22609 = (long unsigned int) nativeArraySize;
  D.22610 = D.22609 * 8;
  nativeArray = malloc (D.22610);
  i = 0;
  goto <D.18992>;
  <D.18991>:
  D.22611 = (long unsigned int) i;
  D.22612 = D.22611 * 8;
  D.22613 = nativeArray + D.22612;
  D.22614 = &array->vector;
  D.22611 = (long unsigned int) i;
  D.22612 = D.22611 * 8;
  D.22615 = D.22614 + D.22612;
  D.22616 = *D.22615;
  D.22617 = ves_icall_System_Runtime_InteropServices_Marshal_GetIUnknownForObjectInternal (D.22616);
  *D.22613 = D.22617;
  i = i + 1;
  <D.18992>:
  if (i < nativeArraySize) goto <D.18991>; else goto <D.18993>;
  <D.18993>:
  D.22603 = nativeArray;
  return D.22603;
  <D.18994>:
  <D.18995>:
  <D.18996>:
  <D.18997>:
  <D.18998>:
  <D.18999>:
  <D.19000>:
  <D.19001>:
  <D.19002>:
  <D.19003>:
  <D.19004>:
  <D.19005>:
  <D.19006>:
  <D.19007>:
  <D.19008>:
  <D.19009>:
  goto <D.19010>;
  <D.19011>:
  <D.19012>:
  <D.19013>:
  <D.19014>:
  <D.19015>:
  <D.19016>:
  D.22605 = klass->element_class;
  D.22606 = D.22605->byval_arg.type;
  D.22607 = (int) D.22606;
  monoeg_g_log (0B, 16, "type 0x%x not handled", D.22607);
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "marshal.c", 653);
  <D.19010>:
  D.22603 = &array->vector;
  return D.22603;
}


__attribute__((visibility ("hidden")))
mono_free_lparray (struct MonoArray * array, void * * nativeArray)
{
  struct MonoVTable * D.22624;
  struct MonoClass * D.22625;
  unsigned char D.22626;
  int D.22627;
  long unsigned int D.22628;
  long unsigned int D.22629;
  void * * D.22630;
  void * D.22631;
  unsigned int D.22632;
  unsigned int i.46;
  struct MonoClass * klass;
  int i;

  i = 0;
  if (array == 0B) goto <D.22620>; else goto <D.22621>;
  <D.22620>:
  return;
  <D.22621>:
  if (nativeArray == 0B) goto <D.22622>; else goto <D.22623>;
  <D.22622>:
  return;
  <D.22623>:
  D.22624 = array->obj.vtable;
  klass = D.22624->klass;
  D.22625 = klass->element_class;
  D.22626 = D.22625->byval_arg.type;
  D.22627 = (int) D.22626;
  switch (D.22627) <default: <D.22634>, case 18: <D.19023>>
  <D.19023>:
  i = 0;
  goto <D.19025>;
  <D.19024>:
  D.22628 = (long unsigned int) i;
  D.22629 = D.22628 * 8;
  D.22630 = nativeArray + D.22629;
  D.22631 = *D.22630;
  mono_marshal_free_ccw (D.22631);
  i = i + 1;
  <D.19025>:
  D.22632 = array->max_length;
  i.46 = (unsigned int) i;
  if (D.22632 > i.46) goto <D.19024>; else goto <D.19026>;
  <D.19026>:
  free (nativeArray);
  goto <D.19027>;
  <D.22634>:
  <D.19027>:
}


__attribute__((visibility ("hidden")))
mono_string_utf8_to_builder (struct MonoStringBuilder * sb, char * text)
{
  long unsigned int D.22639;
  long int D.22640;
  glong iftmp.47;
  struct MonoString * D.22642;
  int D.22645;
  long int items_written.48;
  glong iftmp.49;
  struct GError * error.50;
  struct MonoString * D.22660;
  struct MonoString * * D.22661;
  struct MonoDomain * D.22662;
  int D.22663;
  struct MonoString * D.22664;
  mono_unichar2 * D.22665;
  long int D.22666;
  long unsigned int D.22667;
  int D.22668;
  struct GError * error;
  guint16 * ut;
  glong items_written;
  int l;

  try
    {
      error = 0B;
      if (sb == 0B) goto <D.22636>; else goto <D.22638>;
      <D.22638>:
      if (text == 0B) goto <D.22636>; else goto <D.22637>;
      <D.22636>:
      return;
      <D.22637>:
      D.22639 = __strlen_g (text);
      l = (int) D.22639;
      D.22640 = (long int) l;
      ut = monoeg_g_utf8_to_utf16 (text, D.22640, 0B, &items_written, &error);
      D.22642 = sb->str;
      if (D.22642 != 0B) goto <D.22643>; else goto <D.22644>;
      <D.22643>:
      D.22642 = sb->str;
      D.22645 = D.22642->length;
      iftmp.47 = (glong) D.22645;
      goto <D.22646>;
      <D.22644>:
      iftmp.47 = 16;
      <D.22646>:
      items_written.48 = items_written;
      if (iftmp.47 < items_written.48) goto <D.22648>; else goto <D.22649>;
      <D.22648>:
      D.22642 = sb->str;
      if (D.22642 != 0B) goto <D.22651>; else goto <D.22652>;
      <D.22651>:
      D.22642 = sb->str;
      D.22645 = D.22642->length;
      iftmp.49 = (glong) D.22645;
      goto <D.22653>;
      <D.22652>:
      iftmp.49 = 16;
      <D.22653>:
      items_written = iftmp.49;
      <D.22649>:
      error.50 = error;
      if (error.50 == 0B) goto <D.22655>; else goto <D.22656>;
      <D.22655>:
      D.22642 = sb->str;
      if (D.22642 == 0B) goto <D.22657>; else goto <D.22659>;
      <D.22659>:
      D.22642 = sb->str;
      D.22660 = sb->cached_str;
      if (D.22642 == D.22660) goto <D.22657>; else goto <D.22658>;
      <D.22657>:
      D.22661 = &sb->str;
      D.22662 = mono_domain_get ();
      items_written.48 = items_written;
      D.22663 = (int) items_written.48;
      D.22664 = mono_string_new_size (D.22662, D.22663);
      mono_gc_wbarrier_set_field (sb, D.22661, D.22664);
      <D.22658>:
      D.22642 = sb->str;
      D.22665 = mono_string_chars (D.22642);
      items_written.48 = items_written;
      D.22666 = items_written.48 * 2;
      D.22667 = (long unsigned int) D.22666;
      memcpy (D.22665, ut, D.22667);
      items_written.48 = items_written;
      D.22668 = (int) items_written.48;
      sb->length = D.22668;
      sb->cached_str = 0B;
      goto <D.22669>;
      <D.22656>:
      error.50 = error;
      monoeg_g_error_free (error.50);
      <D.22669>:
      monoeg_g_free (ut);
    }
  finally
    {
      error = {CLOBBER};
      items_written = {CLOBBER};
    }
}


__attribute__((visibility ("hidden")))
mono_string_utf16_to_builder (struct MonoStringBuilder * sb, gunichar2 * text)
{
  struct MonoString * D.22676;
  mono_unichar2 * D.22677;
  _Bool D.22678;
  long int D.22679;
  long int D.22680;
  long unsigned int D.22683;
  long unsigned int D.22684;
  gunichar2 * D.22685;
  short unsigned int D.22686;
  int len.51;
  guint32 len;

  if (sb == 0B) goto <D.22673>; else goto <D.22675>;
  <D.22675>:
  if (text == 0B) goto <D.22673>; else goto <D.22674>;
  <D.22673>:
  return;
  <D.22674>:
  D.22676 = sb->str;
  D.22677 = mono_string_chars (D.22676);
  D.22678 = D.22677 != text;
  D.22679 = (long int) D.22678;
  D.22680 = __builtin_expect (D.22679, 0);
  if (D.22680 != 0) goto <D.22681>; else goto <D.22682>;
  <D.22681>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 821, "mono_string_chars (sb->str) == text");
  <D.22682>:
  len = 0;
  goto <D.19080>;
  <D.19079>:
  len = len + 1;
  <D.19080>:
  D.22683 = (long unsigned int) len;
  D.22684 = D.22683 * 2;
  D.22685 = text + D.22684;
  D.22686 = *D.22685;
  if (D.22686 != 0) goto <D.19079>; else goto <D.19081>;
  <D.19081>:
  len.51 = (int) len;
  sb->length = len.51;
}


__attribute__((visibility ("hidden")))
mono_string_builder_to_utf8 (struct MonoStringBuilder * sb)
{
  void * D.22691;
  struct MonoString * D.22692;
  struct MonoString * D.22693;
  int D.22696;
  struct MonoString * * D.22699;
  struct MonoDomain * D.22700;
  struct MonoString * D.22701;
  mono_unichar2 * D.22702;
  int D.22703;
  long int D.22704;
  struct GError * error.52;
  struct MonoException * D.22708;
  gulong iftmp.53;
  int D.22713;
  int D.22715;
  long unsigned int D.22716;
  struct GError * error;
  gchar * tmp;
  gchar * res;

  try
    {
      error = 0B;
      res = 0B;
      if (sb == 0B) goto <D.22689>; else goto <D.22690>;
      <D.22689>:
      D.22691 = 0B;
      return D.22691;
      <D.22690>:
      D.22692 = sb->str;
      D.22693 = sb->cached_str;
      if (D.22692 == D.22693) goto <D.22694>; else goto <D.22695>;
      <D.22694>:
      D.22692 = sb->str;
      D.22696 = D.22692->length;
      if (D.22696 == 0) goto <D.22697>; else goto <D.22698>;
      <D.22697>:
      D.22699 = &sb->str;
      D.22700 = mono_domain_get ();
      D.22701 = mono_string_new_size (D.22700, 16);
      mono_gc_wbarrier_set_field (sb, D.22699, D.22701);
      sb->cached_str = 0B;
      <D.22698>:
      <D.22695>:
      D.22692 = sb->str;
      D.22702 = mono_string_chars (D.22692);
      D.22703 = sb->length;
      D.22704 = (long int) D.22703;
      tmp = monoeg_g_utf16_to_utf8 (D.22702, D.22704, 0B, 0B, &error);
      error.52 = error;
      if (error.52 != 0B) goto <D.22706>; else goto <D.22707>;
      <D.22706>:
      error.52 = error;
      monoeg_g_error_free (error.52);
      D.22708 = mono_get_exception_execution_engine ("Failed to convert StringBuilder from utf16 to utf8");
      mono_raise_exception (D.22708);
      goto <D.22709>;
      <D.22707>:
      D.22692 = sb->str;
      if (D.22692 != 0B) goto <D.22711>; else goto <D.22712>;
      <D.22711>:
      D.22692 = sb->str;
      D.22696 = D.22692->length;
      D.22713 = D.22696 + 1;
      iftmp.53 = (gulong) D.22713;
      goto <D.22714>;
      <D.22712>:
      iftmp.53 = 17;
      <D.22714>:
      res = mono_marshal_alloc (iftmp.53);
      D.22703 = sb->length;
      D.22715 = D.22703 + 1;
      D.22716 = (long unsigned int) D.22715;
      memcpy (res, tmp, D.22716);
      monoeg_g_free (tmp);
      <D.22709>:
      D.22691 = res;
      return D.22691;
    }
  finally
    {
      error = {CLOBBER};
    }
}


__attribute__((visibility ("hidden")))
mono_string_builder_to_utf16 (struct MonoStringBuilder * sb)
{
  void * D.22721;
  struct MonoString * D.22722;
  _Bool D.22723;
  long int D.22724;
  long int D.22725;
  struct MonoString * D.22728;
  int D.22731;
  struct MonoString * * D.22734;
  struct MonoDomain * D.22735;
  struct MonoString * D.22736;
  struct MonoDomain * D.22738;
  mono_unichar2 * D.22739;
  int iftmp.54;
  struct MonoString * D.22744;
  int D.22745;
  mono_unichar2 * D.22748;

  if (sb == 0B) goto <D.22719>; else goto <D.22720>;
  <D.22719>:
  D.22721 = 0B;
  return D.22721;
  <D.22720>:
  D.22722 = sb->str;
  D.22723 = D.22722 == 0B;
  D.22724 = (long int) D.22723;
  D.22725 = __builtin_expect (D.22724, 0);
  if (D.22725 != 0) goto <D.22726>; else goto <D.22727>;
  <D.22726>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 925, "sb->str");
  <D.22727>:
  D.22722 = sb->str;
  D.22728 = sb->cached_str;
  if (D.22722 == D.22728) goto <D.22729>; else goto <D.22730>;
  <D.22729>:
  D.22722 = sb->str;
  D.22731 = D.22722->length;
  if (D.22731 == 0) goto <D.22732>; else goto <D.22733>;
  <D.22732>:
  D.22734 = &sb->str;
  D.22735 = mono_domain_get ();
  D.22736 = mono_string_new_size (D.22735, 16);
  mono_gc_wbarrier_set_field (sb, D.22734, D.22736);
  goto <D.22737>;
  <D.22733>:
  D.22734 = &sb->str;
  D.22738 = mono_domain_get ();
  D.22722 = sb->str;
  D.22739 = mono_string_chars (D.22722);
  D.22722 = sb->str;
  if (D.22722 != 0B) goto <D.22741>; else goto <D.22742>;
  <D.22741>:
  D.22722 = sb->str;
  iftmp.54 = D.22722->length;
  goto <D.22743>;
  <D.22742>:
  iftmp.54 = 16;
  <D.22743>:
  D.22744 = mono_string_new_utf16 (D.22738, D.22739, iftmp.54);
  mono_gc_wbarrier_set_field (sb, D.22734, D.22744);
  <D.22737>:
  sb->cached_str = 0B;
  <D.22730>:
  D.22745 = sb->length;
  if (D.22745 == 0) goto <D.22746>; else goto <D.22747>;
  <D.22746>:
  D.22722 = sb->str;
  D.22748 = mono_string_chars (D.22722);
  *D.22748 = 0;
  <D.22747>:
  D.22722 = sb->str;
  D.22721 = mono_string_chars (D.22722);
  return D.22721;
}


__attribute__((visibility ("hidden")))
mono_string_to_ansibstr (struct MonoString * string_obj)
{
  void * D.22750;

  monoeg_g_log (0B, 4, "UnmanagedMarshal.BStr is not implemented.");
  <D.19110>:
  goto <D.19110>;
  D.22750 = 0B;
  return D.22750;
}


__attribute__((visibility ("hidden")))
mono_string_to_byvalstr (void * dst, struct MonoString * src, int size)
{
  _Bool D.22752;
  long int D.22753;
  long int D.22754;
  _Bool D.22757;
  long int D.22758;
  long int D.22759;
  long unsigned int D.22762;
  int iftmp.55;
  long unsigned int D.22766;
  long unsigned int D.22769;
  long unsigned int D.22773;
  char * s;
  int len;

  D.22752 = dst == 0B;
  D.22753 = (long int) D.22752;
  D.22754 = __builtin_expect (D.22753, 0);
  if (D.22754 != 0) goto <D.22755>; else goto <D.22756>;
  <D.22755>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 1006, "dst != NULL");
  <D.22756>:
  D.22757 = size <= 0;
  D.22758 = (long int) D.22757;
  D.22759 = __builtin_expect (D.22758, 0);
  if (D.22759 != 0) goto <D.22760>; else goto <D.22761>;
  <D.22760>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 1007, "size > 0");
  <D.22761>:
  D.22762 = (long unsigned int) size;
  memset (dst, 0, D.22762);
  if (src == 0B) goto <D.22763>; else goto <D.22764>;
  <D.22763>:
  return;
  <D.22764>:
  s = mono_string_to_utf8 (src);
  D.22762 = (long unsigned int) size;
  D.22766 = __strlen_g (s);
  if (D.22762 >= D.22766) goto <D.22767>; else goto <D.22768>;
  <D.22767>:
  D.22769 = __strlen_g (s);
  iftmp.55 = (int) D.22769;
  goto <D.22770>;
  <D.22768>:
  iftmp.55 = size;
  <D.22770>:
  len = iftmp.55;
  if (len >= size) goto <D.22771>; else goto <D.22772>;
  <D.22771>:
  len = len + -1;
  <D.22772>:
  D.22773 = (long unsigned int) len;
  memcpy (dst, s, D.22773);
  monoeg_g_free (s);
}


__attribute__((visibility ("hidden")))
mono_string_to_byvalwstr (void * dst, struct MonoString * src, int size)
{
  _Bool D.22775;
  long int D.22776;
  long int D.22777;
  _Bool D.22780;
  long int D.22781;
  long int D.22782;
  int D.22787;
  long unsigned int D.22788;
  int iftmp.56;
  int D.22790;
  mono_unichar2 * D.22794;
  int D.22795;
  long unsigned int D.22798;
  long unsigned int D.22799;
  gunichar2 * D.22800;
  int len;

  D.22775 = dst == 0B;
  D.22776 = (long int) D.22775;
  D.22777 = __builtin_expect (D.22776, 0);
  if (D.22777 != 0) goto <D.22778>; else goto <D.22779>;
  <D.22778>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 1036, "dst != NULL");
  <D.22779>:
  D.22780 = size <= 1;
  D.22781 = (long int) D.22780;
  D.22782 = __builtin_expect (D.22781, 0);
  if (D.22782 != 0) goto <D.22783>; else goto <D.22784>;
  <D.22783>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 1037, "size > 1");
  <D.22784>:
  if (src == 0B) goto <D.22785>; else goto <D.22786>;
  <D.22785>:
  D.22787 = size * 2;
  D.22788 = (long unsigned int) D.22787;
  memset (dst, 0, D.22788);
  return;
  <D.22786>:
  D.22790 = mono_string_length (src);
  if (D.22790 <= size) goto <D.22791>; else goto <D.22792>;
  <D.22791>:
  iftmp.56 = mono_string_length (src);
  goto <D.22793>;
  <D.22792>:
  iftmp.56 = size;
  <D.22793>:
  len = iftmp.56;
  D.22794 = mono_string_chars (src);
  D.22787 = size * 2;
  D.22788 = (long unsigned int) D.22787;
  memcpy (dst, D.22794, D.22788);
  D.22795 = mono_string_length (src);
  if (D.22795 >= size) goto <D.22796>; else goto <D.22797>;
  <D.22796>:
  len = len + -1;
  <D.22797>:
  D.22798 = (long unsigned int) len;
  D.22799 = D.22798 * 2;
  D.22800 = dst + D.22799;
  *D.22800 = 0;
}


__attribute__((visibility ("hidden")))
mono_type_to_ldind (struct MonoType * type)
{
  long unsigned int D.22802;
  long unsigned int D.22803;
  guint D.22806;
  unsigned char D.22807;
  int D.22808;
  struct MonoClass * D.22809;
  long unsigned int D.22810;
  long unsigned int D.22811;
  struct MonoGenericClass * D.22814;
  struct MonoClass * D.22815;
  void handle_enum = <<< error >>>;

  D.22802 = BIT_FIELD_REF <*type, 64, 64>;
  D.22803 = D.22802 & 8589934592;
  if (D.22803 != 0) goto <D.22804>; else goto <D.22805>;
  <D.22804>:
  D.22806 = 77;
  return D.22806;
  <D.22805>:
  handle_enum:
  D.22807 = type->type;
  D.22808 = (int) D.22807;
  switch (D.22808) <default: <D.19178>, case 2: <D.19156>, case 3: <D.19159>, case 4: <D.19154>, case 5: <D.19155>, case 6: <D.19157>, case 7: <D.19158>, case 8: <D.19160>, case 9: <D.19161>, case 10: <D.19171>, case 11: <D.19172>, case 12: <D.19173>, case 13: <D.19174>, case 14: <D.19167>, case 15: <D.19164>, case 17: <D.19175>, case 18: <D.19166>, case 20: <D.19170>, case 21: <D.19177>, case 22: <D.19176>, case 24: <D.19162>, case 25: <D.19163>, case 27: <D.19165>, case 28: <D.19168>, case 29: <D.19169>>
  <D.19154>:
  D.22806 = 70;
  return D.22806;
  <D.19155>:
  <D.19156>:
  D.22806 = 71;
  return D.22806;
  <D.19157>:
  D.22806 = 72;
  return D.22806;
  <D.19158>:
  <D.19159>:
  D.22806 = 73;
  return D.22806;
  <D.19160>:
  D.22806 = 74;
  return D.22806;
  <D.19161>:
  D.22806 = 75;
  return D.22806;
  <D.19162>:
  <D.19163>:
  <D.19164>:
  <D.19165>:
  D.22806 = 77;
  return D.22806;
  <D.19166>:
  <D.19167>:
  <D.19168>:
  <D.19169>:
  <D.19170>:
  D.22806 = 80;
  return D.22806;
  <D.19171>:
  <D.19172>:
  D.22806 = 76;
  return D.22806;
  <D.19173>:
  D.22806 = 78;
  return D.22806;
  <D.19174>:
  D.22806 = 79;
  return D.22806;
  <D.19175>:
  D.22809 = type->data.klass;
  D.22810 = BIT_FIELD_REF <*D.22809, 64, 256>;
  D.22811 = D.22810 & 576460752303423488;
  if (D.22811 != 0) goto <D.22812>; else goto <D.22813>;
  <D.22812>:
  D.22809 = type->data.klass;
  type = mono_class_enum_basetype (D.22809);
  goto handle_enum;
  <D.22813>:
  D.22806 = 113;
  return D.22806;
  <D.19176>:
  D.22806 = 113;
  return D.22806;
  <D.19177>:
  D.22814 = type->data.generic_class;
  D.22815 = D.22814->container_class;
  type = &D.22815->byval_arg;
  goto handle_enum;
  <D.19178>:
  D.22807 = type->type;
  D.22808 = (int) D.22807;
  monoeg_g_log (0B, 4, "unknown type 0x%02x in type_to_ldind", D.22808);
  <D.19179>:
  goto <D.19179>;
  D.22806 = 4294967295;
  return D.22806;
}


__attribute__((visibility ("hidden")))
mono_type_to_stind (struct MonoType * type)
{
  long unsigned int D.22817;
  long unsigned int D.22818;
  guint D.22821;
  unsigned char D.22822;
  int D.22823;
  struct MonoClass * D.22824;
  long unsigned int D.22825;
  long unsigned int D.22826;
  struct MonoGenericClass * D.22829;
  struct MonoClass * D.22830;
  void handle_enum = <<< error >>>;

  D.22817 = BIT_FIELD_REF <*type, 64, 64>;
  D.22818 = D.22817 & 8589934592;
  if (D.22818 != 0) goto <D.22819>; else goto <D.22820>;
  <D.22819>:
  D.22821 = 223;
  return D.22821;
  <D.22820>:
  handle_enum:
  D.22822 = type->type;
  D.22823 = (int) D.22822;
  switch (D.22823) <default: <D.19208>, case 2: <D.19186>, case 3: <D.19189>, case 4: <D.19184>, case 5: <D.19185>, case 6: <D.19187>, case 7: <D.19188>, case 8: <D.19190>, case 9: <D.19191>, case 10: <D.19201>, case 11: <D.19202>, case 12: <D.19203>, case 13: <D.19204>, case 14: <D.19197>, case 15: <D.19194>, case 17: <D.19205>, case 18: <D.19196>, case 20: <D.19200>, case 21: <D.19207>, case 22: <D.19206>, case 24: <D.19192>, case 25: <D.19193>, case 27: <D.19195>, case 28: <D.19198>, case 29: <D.19199>>
  <D.19184>:
  <D.19185>:
  <D.19186>:
  D.22821 = 82;
  return D.22821;
  <D.19187>:
  <D.19188>:
  <D.19189>:
  D.22821 = 83;
  return D.22821;
  <D.19190>:
  <D.19191>:
  D.22821 = 84;
  return D.22821;
  <D.19192>:
  <D.19193>:
  <D.19194>:
  <D.19195>:
  D.22821 = 223;
  return D.22821;
  <D.19196>:
  <D.19197>:
  <D.19198>:
  <D.19199>:
  <D.19200>:
  D.22821 = 81;
  return D.22821;
  <D.19201>:
  <D.19202>:
  D.22821 = 85;
  return D.22821;
  <D.19203>:
  D.22821 = 86;
  return D.22821;
  <D.19204>:
  D.22821 = 87;
  return D.22821;
  <D.19205>:
  D.22824 = type->data.klass;
  D.22825 = BIT_FIELD_REF <*D.22824, 64, 256>;
  D.22826 = D.22825 & 576460752303423488;
  if (D.22826 != 0) goto <D.22827>; else goto <D.22828>;
  <D.22827>:
  D.22824 = type->data.klass;
  type = mono_class_enum_basetype (D.22824);
  goto handle_enum;
  <D.22828>:
  D.22821 = 129;
  return D.22821;
  <D.19206>:
  D.22821 = 129;
  return D.22821;
  <D.19207>:
  D.22829 = type->data.generic_class;
  D.22830 = D.22829->container_class;
  type = &D.22830->byval_arg;
  goto handle_enum;
  <D.19208>:
  D.22822 = type->type;
  D.22823 = (int) D.22822;
  monoeg_g_log (0B, 4, "unknown type 0x%02x in type_to_stind", D.22823);
  <D.19209>:
  goto <D.19209>;
  D.22821 = 4294967295;
  return D.22821;
}


__attribute__((visibility ("hidden")))
mono_marshal_emit_thread_interrupt_checkpoint (struct MonoMethodBuilder * mb)
{
  emit_thread_interrupt_checkpoint (mb);
}


emit_thread_interrupt_checkpoint (struct MonoMethodBuilder * mb)
{
  char * D.22832;
  char * D.22833;

  D.22832 = mb->name;
  D.22833 = strstr (D.22832, "mono_thread_interruption_checkpoint");
  if (D.22833 != 0B) goto <D.22834>; else goto <D.22835>;
  <D.22834>:
  return;
  <D.22835>:
  emit_thread_interrupt_checkpoint_call (mb, mono_thread_interruption_checkpoint);
}


emit_thread_interrupt_checkpoint_call (struct MonoMethodBuilder * mb, void * checkpoint_func)
{
  gint32 * D.22837;
  unsigned int D.22838;
  unsigned int pos_noabort.57;
  int pos_noabort;

  D.22837 = mono_thread_interruption_request_flag ();
  mono_mb_emit_ptr (mb, D.22837);
  mono_mb_emit_byte (mb, 75);
  D.22838 = mono_mb_emit_branch (mb, 57);
  pos_noabort = (int) D.22838;
  mono_mb_emit_byte (mb, 240);
  mono_mb_emit_byte (mb, 12);
  mono_mb_emit_icall (mb, checkpoint_func);
  pos_noabort.57 = (unsigned int) pos_noabort;
  mono_mb_patch_branch (mb, pos_noabort.57);
}


__attribute__((visibility ("hidden")))
mono_marshal_get_cache (struct GHashTable * * var, guint (*GHashFunc) (const void *) hash_func, gint (*GCompareFunc) (const void *, const void *) equal_func)
{
  struct GHashTable * D.22840;

  D.22840 = get_cache (var, hash_func, equal_func);
  return D.22840;
}


get_cache (struct GHashTable * * var, guint (*GHashFunc) (const void *) hash_func, gint (*GCompareFunc) (const void *, const void *) equal_func)
{
  struct GHashTable * D.22842;
  _Bool D.22847;
  long int D.22848;
  long int D.22849;
  _Bool D.22856;
  long int D.22857;
  long int D.22858;
  struct GHashTable * D.22861;

  D.22842 = *var;
  if (D.22842 == 0B) goto <D.22843>; else goto <D.22844>;
  <D.22843>:
  {
    int ret;

    ret = pthread_mutex_lock (&marshal_mutex.mutex);
    if (ret != 0) goto <D.22845>; else goto <D.22846>;
    <D.22845>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.22846>:
    D.22847 = ret != 0;
    D.22848 = (long int) D.22847;
    D.22849 = __builtin_expect (D.22848, 0);
    if (D.22849 != 0) goto <D.22850>; else goto <D.22851>;
    <D.22850>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 2432, "ret == 0");
    <D.22851>:
  }
  D.22842 = *var;
  if (D.22842 == 0B) goto <D.22852>; else goto <D.22853>;
  <D.22852>:
  {
    struct GHashTable * cache;

    cache = monoeg_g_hash_table_new (hash_func, equal_func);
    mono_memory_barrier ();
    *var = cache;
  }
  <D.22853>:
  {
    int ret;

    ret = pthread_mutex_unlock (&marshal_mutex.mutex);
    if (ret != 0) goto <D.22854>; else goto <D.22855>;
    <D.22854>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.22855>:
    D.22856 = ret != 0;
    D.22857 = (long int) D.22856;
    D.22858 = __builtin_expect (D.22857, 0);
    if (D.22858 != 0) goto <D.22859>; else goto <D.22860>;
    <D.22859>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 2439, "ret == 0");
    <D.22860>:
  }
  <D.22844>:
  D.22861 = *var;
  return D.22861;
}


mono_memory_barrier ()
{
  __sync_synchronize ();
}


__attribute__((visibility ("hidden")))
mono_marshal_find_in_cache (struct GHashTable * cache, void * key)
{
  _Bool D.22865;
  long int D.22866;
  long int D.22867;
  _Bool D.22872;
  long int D.22873;
  long int D.22874;
  struct MonoMethod * D.22877;
  struct MonoMethod * res;

  {
    int ret;

    ret = pthread_mutex_lock (&marshal_mutex.mutex);
    if (ret != 0) goto <D.22863>; else goto <D.22864>;
    <D.22863>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.22864>:
    D.22865 = ret != 0;
    D.22866 = (long int) D.22865;
    D.22867 = __builtin_expect (D.22866, 0);
    if (D.22867 != 0) goto <D.22868>; else goto <D.22869>;
    <D.22868>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 2471, "ret == 0");
    <D.22869>:
  }
  res = monoeg_g_hash_table_lookup (cache, key);
  {
    int ret;

    ret = pthread_mutex_unlock (&marshal_mutex.mutex);
    if (ret != 0) goto <D.22870>; else goto <D.22871>;
    <D.22870>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.22871>:
    D.22872 = ret != 0;
    D.22873 = (long int) D.22872;
    D.22874 = __builtin_expect (D.22873, 0);
    if (D.22874 != 0) goto <D.22875>; else goto <D.22876>;
    <D.22875>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 2473, "ret == 0");
    <D.22876>:
  }
  D.22877 = res;
  return D.22877;
}


__attribute__((visibility ("hidden")))
mono_mb_create_and_cache (struct GHashTable * cache, void * key, struct MonoMethodBuilder * mb, struct MonoMethodSignature * sig, int max_stack)
{
  _Bool D.22881;
  long int D.22882;
  long int D.22883;
  _Bool D.22888;
  long int D.22889;
  long int D.22890;
  _Bool D.22897;
  long int D.22898;
  long int D.22899;
  _Bool D.22906;
  long int D.22907;
  long int D.22908;
  _Bool D.22914;
  long int D.22915;
  long int D.22916;
  struct MonoMethod * D.22919;
  struct MonoMethod * res;

  {
    int ret;

    ret = pthread_mutex_lock (&marshal_mutex.mutex);
    if (ret != 0) goto <D.22879>; else goto <D.22880>;
    <D.22879>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.22880>:
    D.22881 = ret != 0;
    D.22882 = (long int) D.22881;
    D.22883 = __builtin_expect (D.22882, 0);
    if (D.22883 != 0) goto <D.22884>; else goto <D.22885>;
    <D.22884>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 2485, "ret == 0");
    <D.22885>:
  }
  res = monoeg_g_hash_table_lookup (cache, key);
  {
    int ret;

    ret = pthread_mutex_unlock (&marshal_mutex.mutex);
    if (ret != 0) goto <D.22886>; else goto <D.22887>;
    <D.22886>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.22887>:
    D.22888 = ret != 0;
    D.22889 = (long int) D.22888;
    D.22890 = __builtin_expect (D.22889, 0);
    if (D.22890 != 0) goto <D.22891>; else goto <D.22892>;
    <D.22891>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 2487, "ret == 0");
    <D.22892>:
  }
  if (res == 0B) goto <D.22893>; else goto <D.22894>;
  <D.22893>:
  {
    struct MonoMethod * newm;

    newm = mono_mb_create_method (mb, sig, max_stack);
    {
      int ret;

      ret = pthread_mutex_lock (&marshal_mutex.mutex);
      if (ret != 0) goto <D.22895>; else goto <D.22896>;
      <D.22895>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
      <D.22896>:
      D.22897 = ret != 0;
      D.22898 = (long int) D.22897;
      D.22899 = __builtin_expect (D.22898, 0);
      if (D.22899 != 0) goto <D.22900>; else goto <D.22901>;
      <D.22900>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 2491, "ret == 0");
      <D.22901>:
    }
    res = monoeg_g_hash_table_lookup (cache, key);
    if (res == 0B) goto <D.22902>; else goto <D.22903>;
    <D.22902>:
    res = newm;
    monoeg_g_hash_table_insert_replace (cache, key, res, 0);
    mono_marshal_set_wrapper_info (res, key);
    {
      int ret;

      ret = pthread_mutex_unlock (&marshal_mutex.mutex);
      if (ret != 0) goto <D.22904>; else goto <D.22905>;
      <D.22904>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
      <D.22905>:
      D.22906 = ret != 0;
      D.22907 = (long int) D.22906;
      D.22908 = __builtin_expect (D.22907, 0);
      if (D.22908 != 0) goto <D.22909>; else goto <D.22910>;
      <D.22909>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 2497, "ret == 0");
      <D.22910>:
    }
    goto <D.22911>;
    <D.22903>:
    {
      int ret;

      ret = pthread_mutex_unlock (&marshal_mutex.mutex);
      if (ret != 0) goto <D.22912>; else goto <D.22913>;
      <D.22912>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
      <D.22913>:
      D.22914 = ret != 0;
      D.22915 = (long int) D.22914;
      D.22916 = __builtin_expect (D.22915, 0);
      if (D.22916 != 0) goto <D.22917>; else goto <D.22918>;
      <D.22917>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 2499, "ret == 0");
      <D.22918>:
    }
    mono_free_method (newm);
    <D.22911>:
  }
  <D.22894>:
  D.22919 = res;
  return D.22919;
}


__attribute__((visibility ("hidden")))
mono_marshal_method_from_wrapper (struct MonoMethod * wrapper)
{
  <unnamed-unsigned:5> D.22921;
  struct MonoMethod * D.22925;
  long unsigned int D.22928;
  long unsigned int D.22929;
  struct MonoGenericContext * D.22932;
  <unnamed type> D.22936;
  unsigned int D.22940;
  void * res;
  int wrapper_type;
  struct WrapperInfo * info;

  D.22921 = wrapper->wrapper_type;
  wrapper_type = (int) D.22921;
  if (wrapper_type == 0) goto <D.22922>; else goto <D.22924>;
  <D.22924>:
  if (wrapper_type == 17) goto <D.22922>; else goto <D.22923>;
  <D.22922>:
  D.22925 = wrapper;
  return D.22925;
  <D.22923>:
  switch (wrapper_type) <default: <D.19592>, case 4: <D.19591>, case 6: <D.19590>, case 8: <D.19585>, case 9: <D.19586>, case 10: <D.19587>, case 16: <D.19588>, case 22: <D.19589>>
  <D.19585>:
  <D.19586>:
  <D.19587>:
  <D.19588>:
  <D.19589>:
  res = mono_marshal_get_wrapper_info (wrapper);
  if (res == 0B) goto <D.22926>; else goto <D.22927>;
  <D.22926>:
  D.22925 = wrapper;
  return D.22925;
  <D.22927>:
  D.22928 = BIT_FIELD_REF <*wrapper, 64, 256>;
  D.22929 = D.22928 & 2251799813685248;
  if (D.22929 != 0) goto <D.22930>; else goto <D.22931>;
  <D.22930>:
  D.22932 = mono_method_get_context (wrapper);
  D.22925 = mono_class_inflate_generic_method (res, D.22932);
  return D.22925;
  <D.22931>:
  D.22925 = res;
  return D.22925;
  <D.19590>:
  info = mono_marshal_get_wrapper_info (wrapper);
  if (info != 0B) goto <D.22935>; else goto <D.22933>;
  <D.22935>:
  D.22936 = info->subtype;
  if (D.22936 == 0) goto <D.22934>; else goto <D.22937>;
  <D.22937>:
  D.22936 = info->subtype;
  if (D.22936 == 16) goto <D.22934>; else goto <D.22933>;
  <D.22934>:
  D.22925 = info->d.managed_to_native.method;
  return D.22925;
  <D.22933>:
  D.22925 = 0B;
  return D.22925;
  <D.19591>:
  info = mono_marshal_get_wrapper_info (wrapper);
  if (info != 0B) goto <D.22939>; else goto <D.22938>;
  <D.22939>:
  D.22936 = info->subtype;
  D.22940 = D.22936 + 4294967283;
  if (D.22940 <= 1) goto <D.22941>; else goto <D.22938>;
  <D.22941>:
  D.22925 = info->d.runtime_invoke.method;
  return D.22925;
  <D.22938>:
  D.22925 = 0B;
  return D.22925;
  <D.19592>:
  D.22925 = 0B;
  return D.22925;
}


__attribute__((visibility ("hidden")))
mono_marshal_get_wrapper_info (struct MonoMethod * wrapper)
{
  long unsigned int D.22943;
  long unsigned int D.22944;
  _Bool D.22945;
  long int D.22946;
  long int D.22947;
  void * D.22950;

  D.22943 = BIT_FIELD_REF <*wrapper, 64, 256>;
  D.22944 = D.22943 & 4467570830351532032;
  D.22945 = D.22944 == 0;
  D.22946 = (long int) D.22945;
  D.22947 = __builtin_expect (D.22946, 0);
  if (D.22947 != 0) goto <D.22948>; else goto <D.22949>;
  <D.22948>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 2634, "wrapper->wrapper_type");
  <D.22949>:
  D.22950 = mono_method_get_wrapper_data (wrapper, 1);
  return D.22950;
}


__attribute__((visibility ("hidden")))
mono_marshal_set_wrapper_info (struct MonoMethod * method, void * data)
{
  long unsigned int D.22954;
  long unsigned int D.22955;
  void * * D.22957;
  void * * datav;

  D.22954 = BIT_FIELD_REF <*method, 64, 256>;
  D.22955 = D.22954 & 4467570830351532032;
  if (D.22955 == 0) goto <D.22952>; else goto <D.22956>;
  <D.22956>:
  D.22954 = BIT_FIELD_REF <*method, 64, 256>;
  D.22955 = D.22954 & 4467570830351532032;
  if (D.22955 == 2449958197289549824) goto <D.22952>; else goto <D.22953>;
  <D.22952>:
  return;
  <D.22953>:
  datav = MEM[(struct MonoMethodWrapper *)method].method_data;
  D.22957 = datav + 8;
  *D.22957 = data;
}


__attribute__((visibility ("hidden")))
mono_marshal_get_delegate_begin_invoke (struct MonoMethod * method)
{
  int iftmp.58;
  struct MonoClass * D.22964;
  struct MonoClass * D.22965;
  struct MonoClass * D.22966;
  const char * D.22968;
  int D.22969;
  _Bool D.22970;
  long int D.22971;
  long int D.22972;
  long unsigned int D.22975;
  long unsigned int D.22976;
  struct MonoImage * D.22981;
  struct GHashTable * * D.22982;
  struct MonoMethod * D.22985;
  struct GHashTable * * D.22987;
  long unsigned int D.22990;
  long unsigned int D.22991;
  _Bool D.22992;
  long int D.22993;
  long int D.22994;
  struct MonoClass * D.23000;
  unsigned int params_var.59;
  short unsigned int D.23004;
  int D.23005;
  int D.23006;
  struct MonoMethodSignature * sig;
  struct MonoMethodBuilder * mb;
  struct MonoMethod * res;
  struct GHashTable * cache;
  int params_var;
  char * name;
  struct MonoGenericContext * ctx;
  struct MonoMethod * orig_method;

  ctx = 0B;
  orig_method = 0B;
  if (method == 0B) goto <D.22960>; else goto <D.22963>;
  <D.22963>:
  D.22964 = method->klass;
  D.22965 = D.22964->parent;
  D.22966 = mono_defaults.multicastdelegate_class;
  if (D.22965 != D.22966) goto <D.22960>; else goto <D.22967>;
  <D.22967>:
  D.22968 = method->name;
  D.22969 = strcmp (D.22968, "BeginInvoke");
  if (D.22969 != 0) goto <D.22960>; else goto <D.22961>;
  <D.22960>:
  iftmp.58 = 1;
  goto <D.22962>;
  <D.22961>:
  iftmp.58 = 0;
  <D.22962>:
  D.22970 = iftmp.58 != 0;
  D.22971 = (long int) D.22970;
  D.22972 = __builtin_expect (D.22971, 0);
  if (D.22972 != 0) goto <D.22973>; else goto <D.22974>;
  <D.22973>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 2837, "method && method->klass->parent == mono_defaults.multicastdelegate_class && !strcmp (method->name, \"BeginInvoke\")");
  <D.22974>:
  D.22975 = BIT_FIELD_REF <*method, 64, 256>;
  D.22976 = D.22975 & 2251799813685248;
  if (D.22976 != 0) goto <D.22977>; else goto <D.22978>;
  <D.22977>:
  orig_method = method;
  ctx = &MEM[(struct MonoMethodInflated *)method].context;
  method = MEM[(struct MonoMethodInflated *)method].declaring;
  <D.22978>:
  sig = mono_signature_no_pinvoke (method);
  if (ctx != 0B) goto <D.22979>; else goto <D.22980>;
  <D.22979>:
  D.22964 = method->klass;
  D.22981 = D.22964->image;
  D.22982 = &D.22981->delegate_begin_invoke_generic_cache;
  cache = get_cache (D.22982, mono_aligned_addr_hash, 0B);
  res = check_generic_delegate_wrapper_cache (cache, orig_method, method, ctx);
  if (res != 0B) goto <D.22983>; else goto <D.22984>;
  <D.22983>:
  D.22985 = res;
  return D.22985;
  <D.22984>:
  goto <D.22986>;
  <D.22980>:
  D.22964 = method->klass;
  D.22981 = D.22964->image;
  D.22987 = &D.22981->delegate_begin_invoke_cache;
  cache = get_cache (D.22987, mono_signature_hash, mono_metadata_signature_equal);
  res = mono_marshal_find_in_cache (cache, sig);
  if (res != 0B) goto <D.22988>; else goto <D.22989>;
  <D.22988>:
  D.22985 = res;
  return D.22985;
  <D.22989>:
  <D.22986>:
  D.22990 = BIT_FIELD_REF <*sig, 64, 64>;
  D.22991 = D.22990 & 512;
  D.22992 = D.22991 == 0;
  D.22993 = (long int) D.22992;
  D.22994 = __builtin_expect (D.22993, 0);
  if (D.22994 != 0) goto <D.22995>; else goto <D.22996>;
  <D.22995>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 2866, "sig->hasthis");
  <D.22996>:
  name = mono_signature_to_name (sig, "begin_invoke");
  if (ctx != 0B) goto <D.22997>; else goto <D.22998>;
  <D.22997>:
  D.22964 = method->klass;
  mb = mono_mb_new (D.22964, name, 2);
  goto <D.22999>;
  <D.22998>:
  D.22964 = method->klass;
  D.22981 = D.22964->image;
  D.23000 = get_wrapper_target_class (D.22981);
  mb = mono_mb_new (D.23000, name, 2);
  <D.22999>:
  monoeg_g_free (name);
  params_var = mono_mb_emit_save_args (mb, sig, 0);
  mono_mb_emit_ldarg (mb, 0);
  params_var.59 = (unsigned int) params_var;
  mono_mb_emit_ldloc (mb, params_var.59);
  mono_mb_emit_icall (mb, mono_delegate_begin_invoke);
  mono_mb_emit_byte (mb, 42);
  if (ctx != 0B) goto <D.23002>; else goto <D.23003>;
  <D.23002>:
  {
    struct MonoMethod * def;

    D.22964 = method->klass;
    D.23004 = sig->param_count;
    D.23005 = (int) D.23004;
    D.23006 = D.23005 + 16;
    def = mono_mb_create_and_cache (cache, D.22964, mb, sig, D.23006);
    res = cache_generic_delegate_wrapper (cache, orig_method, def, ctx);
  }
  goto <D.23007>;
  <D.23003>:
  D.23004 = sig->param_count;
  D.23005 = (int) D.23004;
  D.23006 = D.23005 + 16;
  res = mono_mb_create_and_cache (cache, sig, mb, sig, D.23006);
  <D.23007>:
  mono_mb_free (mb);
  D.22985 = res;
  return D.22985;
}


__attribute__((__gnu_inline__, nothrow, leaf, pure))
strcmp (const char * __s1, const char * __s2)
{
  int iftmp.60;
  int iftmp.61;
  int D.23017;
  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.23010>; else goto <D.23011>;
  <D.23010>:
  if (__ret == 1) goto <D.23013>; else goto <D.23014>;
  <D.23013>:
  iftmp.61 = -1;
  goto <D.23015>;
  <D.23014>:
  iftmp.61 = 1;
  <D.23015>:
  iftmp.60 = iftmp.61;
  goto <D.23016>;
  <D.23011>:
  iftmp.60 = 0;
  <D.23016>:
  __ret = iftmp.60;
  D.23017 = __ret;
  return D.23017;
}


check_generic_delegate_wrapper_cache (struct GHashTable * cache, struct MonoMethod * orig_method, struct MonoMethod * def_method, struct MonoGenericContext * ctx)
{
  struct MonoClass * D.23019;
  struct MonoMethod * D.23022;
  struct MonoClass * D.23023;
  _Bool D.23028;
  long int D.23029;
  long int D.23030;
  _Bool D.23037;
  long int D.23038;
  long int D.23039;
  struct MonoMethod * res;
  struct MonoMethod * inst;
  struct MonoMethod * def;

  D.23019 = orig_method->klass;
  res = mono_marshal_find_in_cache (cache, D.23019);
  if (res != 0B) goto <D.23020>; else goto <D.23021>;
  <D.23020>:
  D.23022 = res;
  return D.23022;
  <D.23021>:
  D.23023 = def_method->klass;
  def = mono_marshal_find_in_cache (cache, D.23023);
  if (def != 0B) goto <D.23024>; else goto <D.23025>;
  <D.23024>:
  inst = mono_class_inflate_generic_method (def, ctx);
  mono_memory_barrier ();
  {
    int ret;

    ret = pthread_mutex_lock (&marshal_mutex.mutex);
    if (ret != 0) goto <D.23026>; else goto <D.23027>;
    <D.23026>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.23027>:
    D.23028 = ret != 0;
    D.23029 = (long int) D.23028;
    D.23030 = __builtin_expect (D.23029, 0);
    if (D.23030 != 0) goto <D.23031>; else goto <D.23032>;
    <D.23031>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 2792, "ret == 0");
    <D.23032>:
  }
  D.23019 = orig_method->klass;
  res = monoeg_g_hash_table_lookup (cache, D.23019);
  if (res == 0B) goto <D.23033>; else goto <D.23034>;
  <D.23033>:
  D.23019 = orig_method->klass;
  monoeg_g_hash_table_insert_replace (cache, D.23019, inst, 0);
  res = inst;
  <D.23034>:
  {
    int ret;

    ret = pthread_mutex_unlock (&marshal_mutex.mutex);
    if (ret != 0) goto <D.23035>; else goto <D.23036>;
    <D.23035>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.23036>:
    D.23037 = ret != 0;
    D.23038 = (long int) D.23037;
    D.23039 = __builtin_expect (D.23038, 0);
    if (D.23039 != 0) goto <D.23040>; else goto <D.23041>;
    <D.23040>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 2798, "ret == 0");
    <D.23041>:
  }
  D.23022 = res;
  return D.23022;
  <D.23025>:
  D.23022 = 0B;
  return D.23022;
}


mono_signature_to_name (struct MonoMethodSignature * sig, const char * prefix)
{
  struct MonoType * D.23045;
  long unsigned int D.23046;
  long unsigned int D.23047;
  struct MonoType * D.23050;
  short unsigned int D.23051;
  int D.23052;
  char * D.23053;
  int i;
  char * result;
  struct GString * res;

  res = monoeg_g_string_new ("");
  if (prefix != 0B) goto <D.23043>; else goto <D.23044>;
  <D.23043>:
  monoeg_g_string_append (res, prefix);
  monoeg_g_string_append_c (res, 95);
  <D.23044>:
  D.23045 = sig->ret;
  mono_type_get_desc (res, D.23045, 0);
  D.23046 = BIT_FIELD_REF <*sig, 64, 64>;
  D.23047 = D.23046 & 512;
  if (D.23047 != 0) goto <D.23048>; else goto <D.23049>;
  <D.23048>:
  monoeg_g_string_append (res, "__this__");
  <D.23049>:
  i = 0;
  goto <D.19436>;
  <D.19435>:
  monoeg_g_string_append_c (res, 95);
  D.23050 = sig->params[i];
  mono_type_get_desc (res, D.23050, 0);
  i = i + 1;
  <D.19436>:
  D.23051 = sig->param_count;
  D.23052 = (int) D.23051;
  if (D.23052 > i) goto <D.19435>; else goto <D.19437>;
  <D.19437>:
  result = res->str;
  monoeg_g_string_free (res, 0);
  D.23053 = result;
  return D.23053;
}


get_wrapper_target_class (struct MonoImage * image)
{
  long unsigned int D.23055;
  long unsigned int D.23056;
  _Bool D.23060;
  long int D.23061;
  long int D.23062;
  struct MonoClass * D.23065;
  struct MonoClass * klass;

  D.23055 = BIT_FIELD_REF <*image, 64, 192>;
  D.23056 = D.23055 & 268435456;
  if (D.23056 != 0) goto <D.23057>; else goto <D.23058>;
  <D.23057>:
  klass = MEM[(struct MonoDynamicImage *)image].wrappers_type;
  goto <D.23059>;
  <D.23058>:
  klass = mono_class_get (image, 33554433);
  <D.23059>:
  D.23060 = klass == 0B;
  D.23061 = (long int) D.23060;
  D.23062 = __builtin_expect (D.23061, 0);
  if (D.23062 != 0) goto <D.23063>; else goto <D.23064>;
  <D.23063>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 2695, "klass");
  <D.23064>:
  D.23065 = klass;
  return D.23065;
}


mono_mb_emit_save_args (struct MonoMethodBuilder * mb, struct MonoMethodSignature * sig, gboolean save_this)
{
  struct MonoClass * D.23067;
  struct MonoType * D.23068;
  short unsigned int D.23069;
  int D.23070;
  int D.23071;
  unsigned int D.23072;
  unsigned int D.23073;
  int D.23074;
  unsigned int params_var.62;
  unsigned int tmp_var.63;
  long unsigned int D.23079;
  long unsigned int D.23080;
  short unsigned int D.23085;
  <unnamed-unsigned:1> D.23086;
  int D.23087;
  int D.23088;
  unsigned int D.23089;
  int D.23090;
  int D.23093;
  int i;
  int params_var;
  int tmp_var;

  D.23067 = mono_defaults.int_class;
  D.23068 = &D.23067->byval_arg;
  params_var = mono_mb_add_local (mb, D.23068);
  D.23067 = mono_defaults.int_class;
  D.23068 = &D.23067->byval_arg;
  tmp_var = mono_mb_add_local (mb, D.23068);
  D.23069 = sig->param_count;
  D.23070 = (int) D.23069;
  D.23071 = D.23070 + 1;
  D.23072 = (unsigned int) D.23071;
  D.23073 = D.23072 * 8;
  D.23074 = (int) D.23073;
  mono_mb_emit_icon (mb, D.23074);
  mono_mb_emit_byte (mb, 254);
  mono_mb_emit_byte (mb, 15);
  params_var.62 = (unsigned int) params_var;
  mono_mb_emit_stloc (mb, params_var.62);
  params_var.62 = (unsigned int) params_var;
  mono_mb_emit_ldloc (mb, params_var.62);
  tmp_var.63 = (unsigned int) tmp_var;
  mono_mb_emit_stloc (mb, tmp_var.63);
  if (save_this != 0) goto <D.23077>; else goto <D.23078>;
  <D.23077>:
  D.23079 = BIT_FIELD_REF <*sig, 64, 64>;
  D.23080 = D.23079 & 512;
  if (D.23080 != 0) goto <D.23081>; else goto <D.23082>;
  <D.23081>:
  tmp_var.63 = (unsigned int) tmp_var;
  mono_mb_emit_ldloc (mb, tmp_var.63);
  mono_mb_emit_ldarg_addr (mb, 0);
  mono_mb_emit_byte (mb, 223);
  D.23069 = sig->param_count;
  if (D.23069 != 0) goto <D.23083>; else goto <D.23084>;
  <D.23083>:
  D.23085 = (short unsigned int) tmp_var;
  mono_mb_emit_add_to_local (mb, D.23085, 8);
  <D.23084>:
  <D.23082>:
  <D.23078>:
  i = 0;
  goto <D.19426>;
  <D.19425>:
  tmp_var.63 = (unsigned int) tmp_var;
  mono_mb_emit_ldloc (mb, tmp_var.63);
  D.23086 = sig->hasthis;
  D.23087 = (int) D.23086;
  D.23088 = D.23087 + i;
  D.23089 = (unsigned int) D.23088;
  mono_mb_emit_ldarg_addr (mb, D.23089);
  mono_mb_emit_byte (mb, 223);
  D.23069 = sig->param_count;
  D.23070 = (int) D.23069;
  D.23090 = D.23070 + -1;
  if (D.23090 > i) goto <D.23091>; else goto <D.23092>;
  <D.23091>:
  D.23085 = (short unsigned int) tmp_var;
  mono_mb_emit_add_to_local (mb, D.23085, 8);
  <D.23092>:
  i = i + 1;
  <D.19426>:
  D.23069 = sig->param_count;
  D.23070 = (int) D.23069;
  if (D.23070 > i) goto <D.19425>; else goto <D.19427>;
  <D.19427>:
  D.23093 = params_var;
  return D.23093;
}


cache_generic_delegate_wrapper (struct GHashTable * cache, struct MonoMethod * orig_method, struct MonoMethod * def, struct MonoGenericContext * ctx)
{
  _Bool D.23097;
  long int D.23098;
  long int D.23099;
  struct MonoClass * D.23102;
  _Bool D.23107;
  long int D.23108;
  long int D.23109;
  struct MonoMethod * D.23112;
  struct MonoMethod * inst;
  struct MonoMethod * res;

  inst = mono_class_inflate_generic_method (def, ctx);
  mono_memory_barrier ();
  {
    int ret;

    ret = pthread_mutex_lock (&marshal_mutex.mutex);
    if (ret != 0) goto <D.23095>; else goto <D.23096>;
    <D.23095>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.23096>:
    D.23097 = ret != 0;
    D.23098 = (long int) D.23097;
    D.23099 = __builtin_expect (D.23098, 0);
    if (D.23099 != 0) goto <D.23100>; else goto <D.23101>;
    <D.23100>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 2814, "ret == 0");
    <D.23101>:
  }
  D.23102 = orig_method->klass;
  res = monoeg_g_hash_table_lookup (cache, D.23102);
  if (res == 0B) goto <D.23103>; else goto <D.23104>;
  <D.23103>:
  D.23102 = orig_method->klass;
  monoeg_g_hash_table_insert_replace (cache, D.23102, inst, 0);
  res = inst;
  <D.23104>:
  {
    int ret;

    ret = pthread_mutex_unlock (&marshal_mutex.mutex);
    if (ret != 0) goto <D.23105>; else goto <D.23106>;
    <D.23105>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.23106>:
    D.23107 = ret != 0;
    D.23108 = (long int) D.23107;
    D.23109 = __builtin_expect (D.23108, 0);
    if (D.23109 != 0) goto <D.23110>; else goto <D.23111>;
    <D.23110>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 2820, "ret == 0");
    <D.23111>:
  }
  D.23112 = res;
  return D.23112;
}


__attribute__((visibility ("hidden")))
mono_marshal_get_delegate_end_invoke (struct MonoMethod * method)
{
  int iftmp.64;
  struct MonoClass * D.23119;
  struct MonoClass * D.23120;
  struct MonoClass * D.23121;
  const char * D.23123;
  int D.23124;
  _Bool D.23125;
  long int D.23126;
  long int D.23127;
  long unsigned int D.23130;
  long unsigned int D.23131;
  struct MonoImage * D.23136;
  struct GHashTable * * D.23137;
  struct MonoMethod * D.23140;
  struct GHashTable * * D.23142;
  long unsigned int D.23145;
  long unsigned int D.23146;
  _Bool D.23147;
  long int D.23148;
  long int D.23149;
  struct MonoClass * D.23155;
  unsigned int params_var.65;
  struct MonoType * D.23157;
  unsigned char D.23158;
  short unsigned int D.23164;
  int D.23165;
  int D.23166;
  struct MonoMethodSignature * sig;
  struct MonoMethodBuilder * mb;
  struct MonoMethod * res;
  struct GHashTable * cache;
  int params_var;
  char * name;
  struct MonoGenericContext * ctx;
  struct MonoMethod * orig_method;

  ctx = 0B;
  orig_method = 0B;
  if (method == 0B) goto <D.23115>; else goto <D.23118>;
  <D.23118>:
  D.23119 = method->klass;
  D.23120 = D.23119->parent;
  D.23121 = mono_defaults.multicastdelegate_class;
  if (D.23120 != D.23121) goto <D.23115>; else goto <D.23122>;
  <D.23122>:
  D.23123 = method->name;
  D.23124 = strcmp (D.23123, "EndInvoke");
  if (D.23124 != 0) goto <D.23115>; else goto <D.23116>;
  <D.23115>:
  iftmp.64 = 1;
  goto <D.23117>;
  <D.23116>:
  iftmp.64 = 0;
  <D.23117>:
  D.23125 = iftmp.64 != 0;
  D.23126 = (long int) D.23125;
  D.23127 = __builtin_expect (D.23126, 0);
  if (D.23127 != 0) goto <D.23128>; else goto <D.23129>;
  <D.23128>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 3047, "method && method->klass->parent == mono_defaults.multicastdelegate_class && !strcmp (method->name, \"EndInvoke\")");
  <D.23129>:
  D.23130 = BIT_FIELD_REF <*method, 64, 256>;
  D.23131 = D.23130 & 2251799813685248;
  if (D.23131 != 0) goto <D.23132>; else goto <D.23133>;
  <D.23132>:
  orig_method = method;
  ctx = &MEM[(struct MonoMethodInflated *)method].context;
  method = MEM[(struct MonoMethodInflated *)method].declaring;
  <D.23133>:
  sig = mono_signature_no_pinvoke (method);
  if (ctx != 0B) goto <D.23134>; else goto <D.23135>;
  <D.23134>:
  D.23119 = method->klass;
  D.23136 = D.23119->image;
  D.23137 = &D.23136->delegate_end_invoke_generic_cache;
  cache = get_cache (D.23137, mono_aligned_addr_hash, 0B);
  res = check_generic_delegate_wrapper_cache (cache, orig_method, method, ctx);
  if (res != 0B) goto <D.23138>; else goto <D.23139>;
  <D.23138>:
  D.23140 = res;
  return D.23140;
  <D.23139>:
  goto <D.23141>;
  <D.23135>:
  D.23119 = method->klass;
  D.23136 = D.23119->image;
  D.23142 = &D.23136->delegate_end_invoke_cache;
  cache = get_cache (D.23142, mono_signature_hash, mono_metadata_signature_equal);
  res = mono_marshal_find_in_cache (cache, sig);
  if (res != 0B) goto <D.23143>; else goto <D.23144>;
  <D.23143>:
  D.23140 = res;
  return D.23140;
  <D.23144>:
  <D.23141>:
  D.23145 = BIT_FIELD_REF <*sig, 64, 64>;
  D.23146 = D.23145 & 512;
  D.23147 = D.23146 == 0;
  D.23148 = (long int) D.23147;
  D.23149 = __builtin_expect (D.23148, 0);
  if (D.23149 != 0) goto <D.23150>; else goto <D.23151>;
  <D.23150>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 3076, "sig->hasthis");
  <D.23151>:
  name = mono_signature_to_name (sig, "end_invoke");
  if (ctx != 0B) goto <D.23152>; else goto <D.23153>;
  <D.23152>:
  D.23119 = method->klass;
  mb = mono_mb_new (D.23119, name, 3);
  goto <D.23154>;
  <D.23153>:
  D.23119 = method->klass;
  D.23136 = D.23119->image;
  D.23155 = get_wrapper_target_class (D.23136);
  mb = mono_mb_new (D.23155, name, 3);
  <D.23154>:
  monoeg_g_free (name);
  params_var = mono_mb_emit_save_args (mb, sig, 0);
  mono_mb_emit_ldarg (mb, 0);
  params_var.65 = (unsigned int) params_var;
  mono_mb_emit_ldloc (mb, params_var.65);
  mono_mb_emit_icall (mb, mono_delegate_end_invoke);
  D.23157 = sig->ret;
  D.23158 = D.23157->type;
  if (D.23158 == 1) goto <D.23159>; else goto <D.23160>;
  <D.23159>:
  mono_mb_emit_byte (mb, 38);
  mono_mb_emit_byte (mb, 42);
  goto <D.23161>;
  <D.23160>:
  D.23157 = sig->ret;
  mono_mb_emit_restore_result (mb, D.23157);
  <D.23161>:
  if (ctx != 0B) goto <D.23162>; else goto <D.23163>;
  <D.23162>:
  {
    struct MonoMethod * def;

    D.23119 = method->klass;
    D.23164 = sig->param_count;
    D.23165 = (int) D.23164;
    D.23166 = D.23165 + 16;
    def = mono_mb_create_and_cache (cache, D.23119, mb, sig, D.23166);
    res = cache_generic_delegate_wrapper (cache, orig_method, def, ctx);
  }
  goto <D.23167>;
  <D.23163>:
  D.23164 = sig->param_count;
  D.23165 = (int) D.23164;
  D.23166 = D.23165 + 16;
  res = mono_mb_create_and_cache (cache, sig, mb, sig, D.23166);
  <D.23167>:
  mono_mb_free (mb);
  D.23140 = res;
  return D.23140;
}


mono_mb_emit_restore_result (struct MonoMethodBuilder * mb, struct MonoType * return_type)
{
  long unsigned int D.23169;
  long unsigned int D.23170;
  struct MonoClass * D.23173;
  unsigned char D.23174;
  int D.23175;
  struct MonoClass * D.23176;
  unsigned int D.23177;
  unsigned char D.23178;
  int D.23179;
  unsigned char D.23181;
  int D.23182;
  struct MonoType * t;

  t = mono_type_get_underlying_type (return_type);
  D.23169 = BIT_FIELD_REF <*return_type, 64, 64>;
  D.23170 = D.23169 & 8589934592;
  if (D.23170 != 0) goto <D.23171>; else goto <D.23172>;
  <D.23171>:
  D.23173 = mono_defaults.int_class;
  return_type = &D.23173->byval_arg;
  <D.23172>:
  D.23174 = t->type;
  D.23175 = (int) D.23174;
  switch (D.23175) <default: <D.19716>, case 1: <D.19688>, case 2: <D.19697>, case 3: <D.19700>, case 4: <D.19698>, case 5: <D.19696>, case 6: <D.19701>, case 7: <D.19699>, case 8: <D.19704>, case 9: <D.19705>, case 10: <D.19707>, case 11: <D.19706>, case 12: <D.19708>, case 13: <D.19709>, case 14: <D.19690>, case 15: <D.19689>, case 17: <D.19711>, case 18: <D.19691>, case 19: <D.19713>, case 20: <D.19693>, case 21: <D.19710>, case 24: <D.19702>, case 25: <D.19703>, case 28: <D.19692>, case 29: <D.19694>, case 30: <D.19714>>
  <D.19688>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "marshal.c", 2981);
  <D.19689>:
  <D.19690>:
  <D.19691>:
  <D.19692>:
  <D.19693>:
  <D.19694>:
  goto <D.19695>;
  <D.19696>:
  <D.19697>:
  <D.19698>:
  <D.19699>:
  <D.19700>:
  <D.19701>:
  <D.19702>:
  <D.19703>:
  <D.19704>:
  <D.19705>:
  <D.19706>:
  <D.19707>:
  <D.19708>:
  <D.19709>:
  D.23176 = mono_class_from_mono_type (return_type);
  mono_mb_emit_op (mb, 121, D.23176);
  D.23177 = mono_type_to_ldind (return_type);
  D.23178 = (unsigned char) D.23177;
  mono_mb_emit_byte (mb, D.23178);
  goto <D.19695>;
  <D.19710>:
  D.23179 = mono_type_generic_inst_is_valuetype (t);
  if (D.23179 == 0) goto <D.19695>; else goto <D.23180>;
  <D.23180>:
  <D.19711>:
  {
    struct MonoClass * klass;

    klass = mono_class_from_mono_type (return_type);
    mono_mb_emit_op (mb, 121, klass);
    mono_mb_emit_op (mb, 113, klass);
    goto <D.19695>;
  }
  <D.19713>:
  <D.19714>:
  {
    struct MonoClass * klass;

    klass = mono_class_from_mono_type (return_type);
    mono_mb_emit_op (mb, 165, klass);
    goto <D.19695>;
  }
  <D.19716>:
  D.23181 = return_type->type;
  D.23182 = (int) D.23181;
  monoeg_g_log (0B, 16, "type 0x%x not handled", D.23182);
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "marshal.c", 3026);
  <D.19695>:
  mono_mb_emit_byte (mb, 42);
}


__attribute__((visibility ("hidden")))
mono_marshal_get_remoting_invoke (struct MonoMethod * method)
{
  _Bool D.23184;
  long int D.23185;
  long int D.23186;
  long unsigned int D.23191;
  long unsigned int D.23192;
  struct MonoMethod * D.23194;
  struct MonoClass * D.23197;
  long unsigned int D.23198;
  long unsigned int D.23199;
  struct MonoClass * D.23201;
  struct MonoDomain * D.23202;
  _Bool D.23203;
  long int D.23204;
  long int D.23205;
  long unsigned int D.23208;
  long unsigned int D.23209;
  long unsigned int D.23212;
  long unsigned int D.23213;
  const char * D.23218;
  struct MonoMethod * D.23219;
  unsigned int params_var.66;
  struct MonoType * D.23221;
  unsigned char D.23222;
  short unsigned int D.23226;
  int D.23227;
  int D.23228;
  struct MonoMethodSignature * sig;
  struct MonoMethodBuilder * mb;
  struct MonoMethod * res;
  int params_var;

  D.23184 = method == 0B;
  D.23185 = (long int) D.23184;
  D.23186 = __builtin_expect (D.23185, 0);
  if (D.23186 != 0) goto <D.23187>; else goto <D.23188>;
  <D.23187>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 3177, "method");
  <D.23188>:
  D.23191 = BIT_FIELD_REF <*method, 64, 256>;
  D.23192 = D.23191 & 4467570830351532032;
  if (D.23192 == 1152921504606846976) goto <D.23189>; else goto <D.23193>;
  <D.23193>:
  D.23191 = BIT_FIELD_REF <*method, 64, 256>;
  D.23192 = D.23191 & 4467570830351532032;
  if (D.23192 == 1441151880758558720) goto <D.23189>; else goto <D.23190>;
  <D.23189>:
  D.23194 = method;
  return D.23194;
  <D.23190>:
  D.23197 = method->klass;
  D.23198 = BIT_FIELD_REF <*D.23197, 64, 256>;
  D.23199 = D.23198 & 8589934592;
  if (D.23199 != 0) goto <D.23195>; else goto <D.23200>;
  <D.23200>:
  D.23197 = method->klass;
  D.23201 = mono_class_get_com_object_class ();
  if (D.23197 == D.23201) goto <D.23195>; else goto <D.23196>;
  <D.23195>:
  {
    struct MonoVTable * vtable;

    D.23202 = mono_domain_get ();
    D.23197 = method->klass;
    vtable = mono_class_vtable (D.23202, D.23197);
    D.23203 = vtable == 0B;
    D.23204 = (long int) D.23203;
    D.23205 = __builtin_expect (D.23204, 0);
    if (D.23205 != 0) goto <D.23206>; else goto <D.23207>;
    <D.23206>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 3186, "vtable");
    <D.23207>:
    D.23208 = BIT_FIELD_REF <*vtable, 64, 320>;
    D.23209 = D.23208 & 549755813888;
    if (D.23209 == 0) goto <D.23210>; else goto <D.23211>;
    <D.23210>:
    D.23194 = mono_cominterop_get_invoke (method);
    return D.23194;
    <D.23211>:
  }
  <D.23196>:
  sig = mono_signature_no_pinvoke (method);
  D.23212 = BIT_FIELD_REF <*sig, 64, 64>;
  D.23213 = D.23212 & 512;
  if (D.23213 == 0) goto <D.23214>; else goto <D.23215>;
  <D.23214>:
  D.23194 = method;
  return D.23194;
  <D.23215>:
  res = mono_marshal_remoting_find_in_cache (method, 8);
  if (res != 0B) goto <D.23216>; else goto <D.23217>;
  <D.23216>:
  D.23194 = res;
  return D.23194;
  <D.23217>:
  D.23197 = method->klass;
  D.23218 = method->name;
  mb = mono_mb_new (D.23197, D.23218, 8);
  D.23219 = mb->method;
  D.23219->save_lmf = 1;
  params_var = mono_mb_emit_save_args (mb, sig, 1);
  mono_mb_emit_ptr (mb, method);
  params_var.66 = (unsigned int) params_var;
  mono_mb_emit_ldloc (mb, params_var.66);
  mono_mb_emit_icall (mb, mono_remoting_wrapper);
  emit_thread_interrupt_checkpoint (mb);
  D.23221 = sig->ret;
  D.23222 = D.23221->type;
  if (D.23222 == 1) goto <D.23223>; else goto <D.23224>;
  <D.23223>:
  mono_mb_emit_byte (mb, 38);
  mono_mb_emit_byte (mb, 42);
  goto <D.23225>;
  <D.23224>:
  D.23221 = sig->ret;
  mono_mb_emit_restore_result (mb, D.23221);
  <D.23225>:
  D.23226 = sig->param_count;
  D.23227 = (int) D.23226;
  D.23228 = D.23227 + 16;
  res = mono_remoting_mb_create_and_cache (method, mb, sig, D.23228);
  mono_mb_free (mb);
  D.23194 = res;
  return D.23194;
}


mono_marshal_remoting_find_in_cache (struct MonoMethod * method, int wrapper_type)
{
  _Bool D.23232;
  long int D.23233;
  long int D.23234;
  struct MonoClass * D.23237;
  struct MonoImage * D.23238;
  struct GHashTable * D.23239;
  _Bool D.23248;
  long int D.23249;
  long int D.23250;
  struct MonoMethod * D.23253;
  struct MonoMethod * res;
  struct MonoRemotingMethods * wrps;

  res = 0B;
  {
    int ret;

    ret = pthread_mutex_lock (&marshal_mutex.mutex);
    if (ret != 0) goto <D.23230>; else goto <D.23231>;
    <D.23230>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.23231>:
    D.23232 = ret != 0;
    D.23233 = (long int) D.23232;
    D.23234 = __builtin_expect (D.23233, 0);
    if (D.23234 != 0) goto <D.23235>; else goto <D.23236>;
    <D.23235>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 2514, "ret == 0");
    <D.23236>:
  }
  D.23237 = method->klass;
  D.23238 = D.23237->image;
  D.23239 = D.23238->remoting_invoke_cache;
  if (D.23239 != 0B) goto <D.23240>; else goto <D.23241>;
  <D.23240>:
  D.23237 = method->klass;
  D.23238 = D.23237->image;
  D.23239 = D.23238->remoting_invoke_cache;
  wrps = monoeg_g_hash_table_lookup (D.23239, method);
  goto <D.23242>;
  <D.23241>:
  wrps = 0B;
  <D.23242>:
  if (wrps != 0B) goto <D.23243>; else goto <D.23244>;
  <D.23243>:
  switch (wrapper_type) <default: <D.23245>, case 8: <D.19552>, case 9: <D.19554>, case 10: <D.19555>, case 11: <D.19556>>
  <D.19552>:
  res = wrps->invoke;
  goto <D.19553>;
  <D.19554>:
  res = wrps->invoke_with_check;
  goto <D.19553>;
  <D.19555>:
  res = wrps->xdomain_invoke;
  goto <D.19553>;
  <D.19556>:
  res = wrps->xdomain_dispatch;
  goto <D.19553>;
  <D.23245>:
  <D.19553>:
  <D.23244>:
  {
    int ret;

    ret = pthread_mutex_unlock (&marshal_mutex.mutex);
    if (ret != 0) goto <D.23246>; else goto <D.23247>;
    <D.23246>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.23247>:
    D.23248 = ret != 0;
    D.23249 = (long int) D.23248;
    D.23250 = __builtin_expect (D.23249, 0);
    if (D.23250 != 0) goto <D.23251>; else goto <D.23252>;
    <D.23251>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 2533, "ret == 0");
    <D.23252>:
  }
  D.23253 = res;
  return D.23253;
}


mono_remoting_mb_create_and_cache (struct MonoMethod * key, struct MonoMethodBuilder * mb, struct MonoMethodSignature * sig, int max_stack)
{
  struct MonoClass * D.23255;
  struct MonoImage * D.23256;
  struct GHashTable * * D.23257;
  _Bool D.23260;
  long int D.23261;
  long int D.23262;
  struct MonoMethod * D.23267;
  <unnamed-unsigned:5> D.23268;
  int D.23269;
  _Bool D.23272;
  long int D.23273;
  long int D.23274;
  struct MonoMethod * D.23277;
  _Bool D.23282;
  long int D.23283;
  long int D.23284;
  _Bool D.23291;
  long int D.23292;
  long int D.23293;
  _Bool D.23299;
  long int D.23300;
  long int D.23301;
  struct MonoMethod * D.23304;
  struct MonoMethod * * res;
  struct MonoRemotingMethods * wrps;
  struct GHashTable * cache;

  res = 0B;
  D.23255 = key->klass;
  D.23256 = D.23255->image;
  D.23257 = &D.23256->remoting_invoke_cache;
  cache = get_cache_full (D.23257, mono_aligned_addr_hash, 0B, 0B, monoeg_g_free);
  {
    int ret;

    ret = pthread_mutex_lock (&marshal_mutex.mutex);
    if (ret != 0) goto <D.23258>; else goto <D.23259>;
    <D.23258>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.23259>:
    D.23260 = ret != 0;
    D.23261 = (long int) D.23260;
    D.23262 = __builtin_expect (D.23261, 0);
    if (D.23262 != 0) goto <D.23263>; else goto <D.23264>;
    <D.23263>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 2546, "ret == 0");
    <D.23264>:
  }
  wrps = monoeg_g_hash_table_lookup (cache, key);
  if (wrps == 0B) goto <D.23265>; else goto <D.23266>;
  <D.23265>:
  wrps = monoeg_malloc0 (32);
  monoeg_g_hash_table_insert_replace (cache, key, wrps, 0);
  <D.23266>:
  D.23267 = mb->method;
  D.23268 = D.23267->wrapper_type;
  D.23269 = (int) D.23268;
  switch (D.23269) <default: <D.19573>, case 8: <D.19568>, case 9: <D.19570>, case 10: <D.19571>, case 11: <D.19572>>
  <D.19568>:
  res = &wrps->invoke;
  goto <D.19569>;
  <D.19570>:
  res = &wrps->invoke_with_check;
  goto <D.19569>;
  <D.19571>:
  res = &wrps->xdomain_invoke;
  goto <D.19569>;
  <D.19572>:
  res = &wrps->xdomain_dispatch;
  goto <D.19569>;
  <D.19573>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "marshal.c", 2558);
  <D.19569>:
  {
    int ret;

    ret = pthread_mutex_unlock (&marshal_mutex.mutex);
    if (ret != 0) goto <D.23270>; else goto <D.23271>;
    <D.23270>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.23271>:
    D.23272 = ret != 0;
    D.23273 = (long int) D.23272;
    D.23274 = __builtin_expect (D.23273, 0);
    if (D.23274 != 0) goto <D.23275>; else goto <D.23276>;
    <D.23275>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 2560, "ret == 0");
    <D.23276>:
  }
  D.23277 = *res;
  if (D.23277 == 0B) goto <D.23278>; else goto <D.23279>;
  <D.23278>:
  {
    struct MonoMethod * newm;

    newm = mono_mb_create_method (mb, sig, max_stack);
    {
      int ret;

      ret = pthread_mutex_lock (&marshal_mutex.mutex);
      if (ret != 0) goto <D.23280>; else goto <D.23281>;
      <D.23280>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
      <D.23281>:
      D.23282 = ret != 0;
      D.23283 = (long int) D.23282;
      D.23284 = __builtin_expect (D.23283, 0);
      if (D.23284 != 0) goto <D.23285>; else goto <D.23286>;
      <D.23285>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 2566, "ret == 0");
      <D.23286>:
    }
    D.23277 = *res;
    if (D.23277 == 0B) goto <D.23287>; else goto <D.23288>;
    <D.23287>:
    *res = newm;
    D.23277 = *res;
    mono_marshal_set_wrapper_info (D.23277, key);
    {
      int ret;

      ret = pthread_mutex_unlock (&marshal_mutex.mutex);
      if (ret != 0) goto <D.23289>; else goto <D.23290>;
      <D.23289>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
      <D.23290>:
      D.23291 = ret != 0;
      D.23292 = (long int) D.23291;
      D.23293 = __builtin_expect (D.23292, 0);
      if (D.23293 != 0) goto <D.23294>; else goto <D.23295>;
      <D.23294>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 2570, "ret == 0");
      <D.23295>:
    }
    goto <D.23296>;
    <D.23288>:
    {
      int ret;

      ret = pthread_mutex_unlock (&marshal_mutex.mutex);
      if (ret != 0) goto <D.23297>; else goto <D.23298>;
      <D.23297>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
      <D.23298>:
      D.23299 = ret != 0;
      D.23300 = (long int) D.23299;
      D.23301 = __builtin_expect (D.23300, 0);
      if (D.23301 != 0) goto <D.23302>; else goto <D.23303>;
      <D.23302>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 2572, "ret == 0");
      <D.23303>:
    }
    mono_free_method (newm);
    <D.23296>:
  }
  <D.23279>:
  D.23304 = *res;
  return D.23304;
}


get_cache_full (struct GHashTable * * var, guint (*GHashFunc) (const void *) hash_func, gint (*GCompareFunc) (const void *, const void *) equal_func, void (*GDestroyNotify) (void *) key_destroy_func, void (*GDestroyNotify) (void *) value_destroy_func)
{
  struct GHashTable * D.23306;
  _Bool D.23311;
  long int D.23312;
  long int D.23313;
  _Bool D.23320;
  long int D.23321;
  long int D.23322;
  struct GHashTable * D.23325;

  D.23306 = *var;
  if (D.23306 == 0B) goto <D.23307>; else goto <D.23308>;
  <D.23307>:
  {
    int ret;

    ret = pthread_mutex_lock (&marshal_mutex.mutex);
    if (ret != 0) goto <D.23309>; else goto <D.23310>;
    <D.23309>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.23310>:
    D.23311 = ret != 0;
    D.23312 = (long int) D.23311;
    D.23313 = __builtin_expect (D.23312, 0);
    if (D.23313 != 0) goto <D.23314>; else goto <D.23315>;
    <D.23314>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 2448, "ret == 0");
    <D.23315>:
  }
  D.23306 = *var;
  if (D.23306 == 0B) goto <D.23316>; else goto <D.23317>;
  <D.23316>:
  {
    struct GHashTable * cache;

    cache = monoeg_g_hash_table_new_full (hash_func, equal_func, key_destroy_func, value_destroy_func);
    mono_memory_barrier ();
    *var = cache;
  }
  <D.23317>:
  {
    int ret;

    ret = pthread_mutex_unlock (&marshal_mutex.mutex);
    if (ret != 0) goto <D.23318>; else goto <D.23319>;
    <D.23318>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.23319>:
    D.23320 = ret != 0;
    D.23321 = (long int) D.23320;
    D.23322 = __builtin_expect (D.23321, 0);
    if (D.23322 != 0) goto <D.23323>; else goto <D.23324>;
    <D.23323>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 2455, "ret == 0");
    <D.23324>:
  }
  <D.23308>:
  D.23325 = *var;
  return D.23325;
}


__attribute__((visibility ("hidden")))
mono_marshal_xdomain_copy_value (struct MonoObject * val)
{
  struct MonoObject * D.23329;
  struct MonoVTable * D.23330;
  struct MonoClass * D.23331;
  unsigned char D.23332;
  int D.23333;
  void * D.23334;
  mono_unichar2 * D.23335;
  int D.23336;
  struct MonoClass * D.23337;
  struct MonoType * D.23338;
  long unsigned int D.23343;
  long unsigned int D.23344;
  char * D.23345;
  struct MonoObject * D.23346;
  struct MonoClass * D.23348;
  struct MonoString * * D.23351;
  struct MonoString * D.23352;
  mono_unichar2 * D.23353;
  int D.23354;
  struct MonoString * D.23355;
  int D.23356;
  struct MonoDomain * domain;

  if (val == 0B) goto <D.23327>; else goto <D.23328>;
  <D.23327>:
  D.23329 = 0B;
  return D.23329;
  <D.23328>:
  domain = mono_domain_get ();
  D.23330 = val->vtable;
  D.23331 = D.23330->klass;
  D.23332 = D.23331->byval_arg.type;
  D.23333 = (int) D.23332;
  switch (D.23333) <default: <D.23347>, case 1: <D.19779>, case 2: <D.19782>, case 3: <D.19785>, case 4: <D.19781>, case 5: <D.19780>, case 6: <D.19784>, case 7: <D.19783>, case 8: <D.19787>, case 9: <D.19786>, case 10: <D.19788>, case 11: <D.19789>, case 12: <D.19790>, case 13: <D.19791>, case 14: <D.19792>, case 20: <D.19794>, case 29: <D.19795>>
  <D.19779>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "marshal.c", 3283);
  <D.19780>:
  <D.19781>:
  <D.19782>:
  <D.19783>:
  <D.19784>:
  <D.19785>:
  <D.19786>:
  <D.19787>:
  <D.19788>:
  <D.19789>:
  <D.19790>:
  <D.19791>:
  D.23330 = val->vtable;
  D.23331 = D.23330->klass;
  D.23334 = val + 16;
  D.23329 = mono_value_box (domain, D.23331, D.23334);
  return D.23329;
  <D.19792>:
  {
    struct MonoString * str;

    str = val;
    D.23335 = mono_string_chars (str);
    D.23336 = mono_string_length (str);
    D.23329 = mono_string_new_utf16 (domain, D.23335, D.23336);
    return D.23329;
  }
  <D.19794>:
  <D.19795>:
  {
    struct MonoArray * acopy;
    MonoXDomainMarshalType mt;

    D.23330 = val->vtable;
    D.23331 = D.23330->klass;
    D.23337 = D.23331->element_class;
    D.23338 = &D.23337->byval_arg;
    mt = mono_get_xdomain_marshal_type (D.23338);
    if (mt == 3) goto <D.23339>; else goto <D.23340>;
    <D.23339>:
    D.23329 = 0B;
    return D.23329;
    <D.23340>:
    acopy = mono_array_clone_in_domain (domain, val);
    if (mt == 1) goto <D.23341>; else goto <D.23342>;
    <D.23341>:
    {
      int i;
      int len;

      D.23343 = mono_array_length (acopy);
      len = (int) D.23343;
      i = 0;
      goto <D.19803>;
      <D.19802>:
      {
        struct MonoObject * item;

        D.23344 = (long unsigned int) i;
        D.23345 = mono_array_addr_with_size (acopy, 8, D.23344);
        item = MEM[(void * *)D.23345];
        {
          void * * __p;

          D.23344 = (long unsigned int) i;
          __p = mono_array_addr_with_size (acopy, 8, D.23344);
          D.23346 = mono_marshal_xdomain_copy_value (item);
          mono_gc_wbarrier_set_arrayref (acopy, __p, D.23346);
        }
      }
      i = i + 1;
      <D.19803>:
      if (i < len) goto <D.19802>; else goto <D.19804>;
      <D.19804>:
    }
    <D.23342>:
    D.23329 = acopy;
    return D.23329;
  }
  <D.23347>:
  D.23330 = val->vtable;
  D.23331 = D.23330->klass;
  D.23348 = mono_defaults.stringbuilder_class;
  if (D.23331 == D.23348) goto <D.23349>; else goto <D.23350>;
  <D.23349>:
  {
    struct MonoStringBuilder * oldsb;
    struct MonoStringBuilder * newsb;

    oldsb = val;
    D.23348 = mono_defaults.stringbuilder_class;
    newsb = mono_object_new (domain, D.23348);
    D.23351 = &newsb->str;
    D.23352 = oldsb->str;
    D.23353 = mono_string_chars (D.23352);
    D.23352 = oldsb->str;
    D.23354 = mono_string_length (D.23352);
    D.23355 = mono_string_new_utf16 (domain, D.23353, D.23354);
    mono_gc_wbarrier_set_field (newsb, D.23351, D.23355);
    D.23356 = oldsb->length;
    newsb->length = D.23356;
    newsb->max_capacity = 2147483647;
    D.23329 = newsb;
    return D.23329;
  }
  <D.23350>:
  D.23329 = 0B;
  return D.23329;
}


__attribute__((visibility ("hidden")))
mono_marshal_get_xappdomain_invoke (struct MonoMethod * method)
{
  _Bool D.23358;
  long int D.23359;
  long int D.23360;
  long unsigned int D.23365;
  long unsigned int D.23366;
  struct MonoMethod * D.23368;
  struct MonoMethodSignature * D.23369;
  long unsigned int D.23370;
  long unsigned int D.23371;
  int D.23374;
  struct MonoClass * D.23379;
  const char * D.23380;
  struct MonoMethod * D.23381;
  short unsigned int D.23382;
  long unsigned int D.23383;
  long unsigned int D.23384;
  <unnamed type> D.23385;
  short unsigned int D.23388;
  int D.23389;
  int D.23390;
  long unsigned int D.23393;
  long unsigned int D.23394;
  long unsigned int D.23400;
  long unsigned int D.23401;
  int * D.23402;
  int D.23403;
  struct MonoType * D.23404;
  unsigned char D.23405;
  <unnamed type> D.23408;
  _Bool D.23409;
  struct MonoClass * D.23412;
  struct MonoType * D.23413;
  struct MonoClass * byte_array_class.67;
  struct MonoType * D.23415;
  struct MonoClass * D.23418;
  struct MonoType * D.23419;
  unsigned int loc_context.68;
  struct MonoMethod * method_needs_context_sink.69;
  unsigned int D.23422;
  unsigned int loc_real_proxy.70;
  unsigned int loc_domainid.71;
  struct MonoImage * D.23425;
  unsigned int D.23426;
  unsigned int pos.72;
  int D.23428;
  unsigned int D.23429;
  struct MonoMethod * D.23430;
  unsigned int pos_dispatch.73;
  int iftmp.74;
  int D.23439;
  struct MonoType * D.23442;
  long unsigned int D.23443;
  long unsigned int D.23444;
  long unsigned int D.23447;
  long unsigned int D.23448;
  unsigned int loc_array.75;
  struct MonoMethod * method_rs_serialize.76;
  unsigned int loc_serialized_data.77;
  unsigned int loc_old_domainid.78;
  unsigned int loc_serialized_exc.79;
  struct MonoType * D.23462;
  unsigned int copy_local.80;
  struct MonoMethodSignature * D.23465;
  unsigned int loc_return.81;
  unsigned int D.23469;
  struct MonoMethod * method_rs_deserialize.82;
  struct MonoClass * D.23471;
  struct MonoMethod * method_exc_fixexc.83;
  unsigned int pos_noex.84;
  int j.85;
  int D.23478;
  unsigned int D.23479;
  struct MonoClass * D.23480;
  long unsigned int D.23487;
  long unsigned int D.23488;
  long unsigned int D.23496;
  long unsigned int D.23497;
  unsigned int D.23509;
  int D.23514;
  struct MonoMethodSignature * sig;
  struct MonoMethodBuilder * mb;
  struct MonoMethod * res;
  int i;
  int j;
  int complex_count;
  int complex_out_count;
  int copy_locals_base;
  int * marshal_types;
  struct MonoClass * ret_class;
  struct MonoMethod * xdomain_method;
  int ret_marshal_type;
  int loc_array;
  int loc_serialized_data;
  int loc_real_proxy;
  int loc_old_domainid;
  int loc_domainid;
  int loc_return;
  int loc_serialized_exc;
  int loc_context;
  int pos;
  int pos_dispatch;
  int pos_noex;
  gboolean copy_return;

  ret_class = 0B;
  ret_marshal_type = 0;
  loc_array = 0;
  loc_serialized_data = -1;
  loc_return = 0;
  loc_serialized_exc = 0;
  copy_return = 0;
  D.23358 = method == 0B;
  D.23359 = (long int) D.23358;
  D.23360 = __builtin_expect (D.23359, 0);
  if (D.23360 != 0) goto <D.23361>; else goto <D.23362>;
  <D.23361>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 3744, "method");
  <D.23362>:
  D.23365 = BIT_FIELD_REF <*method, 64, 256>;
  D.23366 = D.23365 & 4467570830351532032;
  if (D.23366 == 1152921504606846976) goto <D.23363>; else goto <D.23367>;
  <D.23367>:
  D.23365 = BIT_FIELD_REF <*method, 64, 256>;
  D.23366 = D.23365 & 4467570830351532032;
  if (D.23366 == 1441151880758558720) goto <D.23363>; else goto <D.23364>;
  <D.23363>:
  D.23368 = method;
  return D.23368;
  <D.23364>:
  D.23369 = mono_method_signature (method);
  D.23370 = BIT_FIELD_REF <*D.23369, 64, 64>;
  D.23371 = D.23370 & 512;
  if (D.23371 == 0) goto <D.23372>; else goto <D.23373>;
  <D.23372>:
  D.23368 = method;
  return D.23368;
  <D.23373>:
  D.23374 = mono_marshal_supports_fast_xdomain (method);
  if (D.23374 == 0) goto <D.23375>; else goto <D.23376>;
  <D.23375>:
  D.23368 = mono_marshal_get_remoting_invoke (method);
  return D.23368;
  <D.23376>:
  mono_remoting_marshal_init ();
  res = mono_marshal_remoting_find_in_cache (method, 10);
  if (res != 0B) goto <D.23377>; else goto <D.23378>;
  <D.23377>:
  D.23368 = res;
  return D.23368;
  <D.23378>:
  sig = mono_signature_no_pinvoke (method);
  D.23379 = method->klass;
  D.23380 = method->name;
  mb = mono_mb_new (D.23379, D.23380, 10);
  D.23381 = mb->method;
  D.23381->save_lmf = 1;
  D.23382 = sig->param_count;
  D.23383 = (long unsigned int) D.23382;
  D.23384 = D.23383 * 4;
  marshal_types = __builtin_alloca (D.23384);
  complex_out_count = 0;
  complex_count = complex_out_count;
  i = 0;
  goto <D.19934>;
  <D.19933>:
  {
    struct MonoType * ptype;
    int mt;

    ptype = sig->params[i];
    D.23385 = mono_get_xdomain_marshal_type (ptype);
    mt = (int) D.23385;
    D.23388 = ptype->attrs;
    D.23389 = (int) D.23388;
    D.23390 = D.23389 & 2;
    if (D.23390 != 0) goto <D.23391>; else goto <D.23386>;
    <D.23391>:
    if (mt == 1) goto <D.23392>; else goto <D.23386>;
    <D.23392>:
    D.23393 = BIT_FIELD_REF <*ptype, 64, 64>;
    D.23394 = D.23393 & 8589934592;
    if (D.23394 == 0) goto <D.23395>; else goto <D.23386>;
    <D.23395>:
    mt = 2;
    goto <D.23387>;
    <D.23386>:
    if (mt == 3) goto <D.23396>; else goto <D.23397>;
    <D.23396>:
    complex_count = complex_count + 1;
    D.23393 = BIT_FIELD_REF <*ptype, 64, 64>;
    D.23394 = D.23393 & 8589934592;
    if (D.23394 != 0) goto <D.23398>; else goto <D.23399>;
    <D.23398>:
    complex_out_count = complex_out_count + 1;
    <D.23399>:
    <D.23397>:
    <D.23387>:
    D.23400 = (long unsigned int) i;
    D.23401 = D.23400 * 4;
    D.23402 = marshal_types + D.23401;
    *D.23402 = mt;
  }
  i = i + 1;
  <D.19934>:
  D.23382 = sig->param_count;
  D.23403 = (int) D.23382;
  if (D.23403 > i) goto <D.19933>; else goto <D.19935>;
  <D.19935>:
  D.23404 = sig->ret;
  D.23405 = D.23404->type;
  if (D.23405 != 1) goto <D.23406>; else goto <D.23407>;
  <D.23406>:
  D.23404 = sig->ret;
  D.23408 = mono_get_xdomain_marshal_type (D.23404);
  ret_marshal_type = (int) D.23408;
  D.23404 = sig->ret;
  ret_class = mono_class_from_mono_type (D.23404);
  D.23409 = ret_marshal_type != 3;
  copy_return = (gboolean) D.23409;
  <D.23407>:
  if (complex_count > 0) goto <D.23410>; else goto <D.23411>;
  <D.23410>:
  D.23412 = mono_defaults.object_class;
  D.23413 = &D.23412->byval_arg;
  loc_array = mono_mb_add_local (mb, D.23413);
  <D.23411>:
  byte_array_class.67 = byte_array_class;
  D.23415 = &byte_array_class.67->byval_arg;
  loc_serialized_data = mono_mb_add_local (mb, D.23415);
  D.23412 = mono_defaults.object_class;
  D.23413 = &D.23412->byval_arg;
  loc_real_proxy = mono_mb_add_local (mb, D.23413);
  if (copy_return != 0) goto <D.23416>; else goto <D.23417>;
  <D.23416>:
  D.23404 = sig->ret;
  loc_return = mono_mb_add_local (mb, D.23404);
  <D.23417>:
  D.23418 = mono_defaults.int32_class;
  D.23419 = &D.23418->byval_arg;
  loc_old_domainid = mono_mb_add_local (mb, D.23419);
  D.23418 = mono_defaults.int32_class;
  D.23419 = &D.23418->byval_arg;
  loc_domainid = mono_mb_add_local (mb, D.23419);
  byte_array_class.67 = byte_array_class;
  D.23415 = &byte_array_class.67->byval_arg;
  loc_serialized_exc = mono_mb_add_local (mb, D.23415);
  D.23412 = mono_defaults.object_class;
  D.23413 = &D.23412->byval_arg;
  loc_context = mono_mb_add_local (mb, D.23413);
  mono_mb_emit_icall (mb, mono_context_get);
  mono_mb_emit_byte (mb, 37);
  loc_context.68 = (unsigned int) loc_context;
  mono_mb_emit_stloc (mb, loc_context.68);
  method_needs_context_sink.69 = method_needs_context_sink;
  mono_mb_emit_managed_call (mb, method_needs_context_sink.69, 0B);
  D.23422 = mono_mb_emit_short_branch (mb, 45);
  pos = (int) D.23422;
  mono_mb_emit_ldarg (mb, 0);
  mono_mb_emit_ldflda (mb, 16);
  mono_mb_emit_byte (mb, 80);
  mono_mb_emit_byte (mb, 37);
  loc_real_proxy.70 = (unsigned int) loc_real_proxy;
  mono_mb_emit_stloc (mb, loc_real_proxy.70);
  mono_mb_emit_ldflda (mb, 40);
  mono_mb_emit_byte (mb, 74);
  loc_domainid.71 = (unsigned int) loc_domainid;
  mono_mb_emit_stloc (mb, loc_domainid.71);
  loc_domainid.71 = (unsigned int) loc_domainid;
  mono_mb_emit_ldloc (mb, loc_domainid.71);
  D.23379 = method->klass;
  D.23425 = D.23379->image;
  mono_mb_emit_ptr (mb, D.23425);
  mono_mb_emit_icall (mb, mono_marshal_check_domain_image);
  D.23426 = mono_mb_emit_short_branch (mb, 45);
  pos_dispatch = (int) D.23426;
  pos.72 = (unsigned int) pos;
  mono_mb_patch_short_branch (mb, pos.72);
  mono_mb_emit_ldarg (mb, 0);
  i = 0;
  goto <D.19937>;
  <D.19936>:
  D.23428 = i + 1;
  D.23429 = (unsigned int) D.23428;
  mono_mb_emit_ldarg (mb, D.23429);
  i = i + 1;
  <D.19937>:
  D.23382 = sig->param_count;
  D.23403 = (int) D.23382;
  if (D.23403 > i) goto <D.19936>; else goto <D.19938>;
  <D.19938>:
  D.23430 = mono_marshal_get_remoting_invoke (method);
  mono_mb_emit_managed_call (mb, D.23430, 0B);
  mono_mb_emit_byte (mb, 42);
  pos_dispatch.73 = (unsigned int) pos_dispatch;
  mono_mb_patch_short_branch (mb, pos_dispatch.73);
  if (complex_count > 0) goto <D.23432>; else goto <D.23433>;
  <D.23432>:
  if (ret_marshal_type == 3) goto <D.23437>; else goto <D.23435>;
  <D.23437>:
  if (complex_out_count > 0) goto <D.23438>; else goto <D.23435>;
  <D.23438>:
  iftmp.74 = complex_count + 1;
  goto <D.23436>;
  <D.23435>:
  iftmp.74 = complex_count;
  <D.23436>:
  mono_mb_emit_icon (mb, iftmp.74);
  D.23412 = mono_defaults.object_class;
  mono_mb_emit_op (mb, 141, D.23412);
  j = 0;
  i = 0;
  goto <D.19942>;
  <D.19941>:
  {
    struct MonoClass * pclass;

    D.23400 = (long unsigned int) i;
    D.23401 = D.23400 * 4;
    D.23402 = marshal_types + D.23401;
    D.23439 = *D.23402;
    if (D.23439 != 3) goto <D.23440>; else goto <D.23441>;
    <D.23440>:
    // predicted unlikely by continue predictor.
    goto <D.19940>;
    <D.23441>:
    D.23442 = sig->params[i];
    pclass = mono_class_from_mono_type (D.23442);
    mono_mb_emit_byte (mb, 37);
    mono_mb_emit_icon (mb, j);
    D.23428 = i + 1;
    D.23429 = (unsigned int) D.23428;
    mono_mb_emit_ldarg (mb, D.23429);
    D.23442 = sig->params[i];
    D.23443 = BIT_FIELD_REF <*D.23442, 64, 64>;
    D.23444 = D.23443 & 8589934592;
    if (D.23444 != 0) goto <D.23445>; else goto <D.23446>;
    <D.23445>:
    D.23447 = BIT_FIELD_REF <*pclass, 64, 256>;
    D.23448 = D.23447 & 1152921504606846976;
    if (D.23448 != 0) goto <D.23449>; else goto <D.23450>;
    <D.23449>:
    mono_mb_emit_op (mb, 113, pclass);
    goto <D.23451>;
    <D.23450>:
    mono_mb_emit_byte (mb, 80);
    <D.23451>:
    <D.23446>:
    D.23447 = BIT_FIELD_REF <*pclass, 64, 256>;
    D.23448 = D.23447 & 1152921504606846976;
    if (D.23448 != 0) goto <D.23452>; else goto <D.23453>;
    <D.23452>:
    mono_mb_emit_op (mb, 140, pclass);
    <D.23453>:
    mono_mb_emit_byte (mb, 162);
    j = j + 1;
  }
  <D.19940>:
  i = i + 1;
  <D.19942>:
  D.23382 = sig->param_count;
  D.23403 = (int) D.23382;
  if (D.23403 > i) goto <D.19941>; else goto <D.19943>;
  <D.19943>:
  loc_array.75 = (unsigned int) loc_array;
  mono_mb_emit_stloc (mb, loc_array.75);
  loc_array.75 = (unsigned int) loc_array;
  mono_mb_emit_ldloc (mb, loc_array.75);
  method_rs_serialize.76 = method_rs_serialize;
  mono_mb_emit_managed_call (mb, method_rs_serialize.76, 0B);
  loc_serialized_data.77 = (unsigned int) loc_serialized_data;
  mono_mb_emit_stloc (mb, loc_serialized_data.77);
  goto <D.23457>;
  <D.23433>:
  mono_mb_emit_byte (mb, 20);
  method_rs_serialize.76 = method_rs_serialize;
  mono_mb_emit_managed_call (mb, method_rs_serialize.76, 0B);
  loc_serialized_data.77 = (unsigned int) loc_serialized_data;
  mono_mb_emit_stloc (mb, loc_serialized_data.77);
  <D.23457>:
  loc_domainid.71 = (unsigned int) loc_domainid;
  mono_mb_emit_ldloc (mb, loc_domainid.71);
  mono_mb_emit_byte (mb, 23);
  mono_marshal_emit_switch_domain (mb);
  loc_old_domainid.78 = (unsigned int) loc_old_domainid;
  mono_mb_emit_stloc (mb, loc_old_domainid.78);
  loc_real_proxy.70 = (unsigned int) loc_real_proxy;
  mono_mb_emit_ldloc (mb, loc_real_proxy.70);
  loc_serialized_data.77 = (unsigned int) loc_serialized_data;
  mono_mb_emit_ldloc_addr (mb, loc_serialized_data.77);
  loc_serialized_exc.79 = (unsigned int) loc_serialized_exc;
  mono_mb_emit_ldloc_addr (mb, loc_serialized_exc.79);
  copy_locals_base = mb->locals;
  i = 0;
  goto <D.19953>;
  <D.19952>:
  D.23400 = (long unsigned int) i;
  D.23401 = D.23400 * 4;
  D.23402 = marshal_types + D.23401;
  D.23439 = *D.23402;
  switch (D.23439) <default: <D.23464>, case 0: <D.19951>, case 1: <D.19946>, case 2: <D.19950>, case 3: <D.19944>>
  <D.19944>:
  // predicted unlikely by continue predictor.
  goto <D.19945>;
  <D.19946>:
  D.23428 = i + 1;
  D.23429 = (unsigned int) D.23428;
  mono_mb_emit_ldarg (mb, D.23429);
  D.23442 = sig->params[i];
  D.23443 = BIT_FIELD_REF <*D.23442, 64, 64>;
  D.23444 = D.23443 & 8589934592;
  if (D.23444 != 0) goto <D.23460>; else goto <D.23461>;
  <D.23460>:
  {
    struct MonoClass * pclass;
    int copy_local;

    D.23442 = sig->params[i];
    pclass = mono_class_from_mono_type (D.23442);
    D.23462 = &pclass->byval_arg;
    copy_local = mono_mb_add_local (mb, D.23462);
    mono_mb_emit_byte (mb, 80);
    copy_local.80 = (unsigned int) copy_local;
    mono_mb_emit_stloc (mb, copy_local.80);
    copy_local.80 = (unsigned int) copy_local;
    mono_mb_emit_ldloc_addr (mb, copy_local.80);
  }
  <D.23461>:
  goto <D.19949>;
  <D.19950>:
  <D.19951>:
  D.23428 = i + 1;
  D.23429 = (unsigned int) D.23428;
  mono_mb_emit_ldarg (mb, D.23429);
  goto <D.19949>;
  <D.23464>:
  <D.19949>:
  <D.19945>:
  i = i + 1;
  <D.19953>:
  D.23382 = sig->param_count;
  D.23403 = (int) D.23382;
  if (D.23403 > i) goto <D.19952>; else goto <D.19954>;
  <D.19954>:
  xdomain_method = mono_marshal_get_xappdomain_dispatch (method, marshal_types, complex_count, complex_out_count, ret_marshal_type);
  mono_marshal_emit_load_domain_method (mb, xdomain_method);
  D.23465 = mono_method_signature (xdomain_method);
  mono_mb_emit_calli (mb, D.23465);
  if (copy_return != 0) goto <D.23466>; else goto <D.23467>;
  <D.23466>:
  loc_return.81 = (unsigned int) loc_return;
  mono_mb_emit_stloc (mb, loc_return.81);
  <D.23467>:
  loc_old_domainid.78 = (unsigned int) loc_old_domainid;
  mono_mb_emit_ldloc (mb, loc_old_domainid.78);
  mono_mb_emit_byte (mb, 22);
  mono_marshal_emit_switch_domain (mb);
  mono_mb_emit_byte (mb, 38);
  loc_context.68 = (unsigned int) loc_context;
  mono_mb_emit_ldloc (mb, loc_context.68);
  mono_mb_emit_icall (mb, mono_context_set);
  loc_serialized_exc.79 = (unsigned int) loc_serialized_exc;
  mono_mb_emit_ldloc (mb, loc_serialized_exc.79);
  D.23469 = mono_mb_emit_short_branch (mb, 44);
  pos_noex = (int) D.23469;
  loc_serialized_exc.79 = (unsigned int) loc_serialized_exc;
  mono_mb_emit_ldloc (mb, loc_serialized_exc.79);
  byte_array_class.67 = byte_array_class;
  mono_marshal_emit_xdomain_copy_value (mb, byte_array_class.67);
  method_rs_deserialize.82 = method_rs_deserialize;
  mono_mb_emit_managed_call (mb, method_rs_deserialize.82, 0B);
  D.23471 = mono_defaults.exception_class;
  mono_mb_emit_op (mb, 116, D.23471);
  method_exc_fixexc.83 = method_exc_fixexc;
  mono_mb_emit_managed_call (mb, method_exc_fixexc.83, 0B);
  mono_mb_emit_byte (mb, 122);
  pos_noex.84 = (unsigned int) pos_noex;
  mono_mb_patch_short_branch (mb, pos_noex.84);
  j = 0;
  i = 0;
  goto <D.19957>;
  <D.19956>:
  D.23442 = sig->params[i];
  D.23443 = BIT_FIELD_REF <*D.23442, 64, 64>;
  D.23444 = D.23443 & 8589934592;
  if (D.23444 == 0) goto <D.23474>; else goto <D.23476>;
  <D.23476>:
  D.23400 = (long unsigned int) i;
  D.23401 = D.23400 * 4;
  D.23402 = marshal_types + D.23401;
  D.23439 = *D.23402;
  if (D.23439 != 1) goto <D.23474>; else goto <D.23475>;
  <D.23474>:
  // predicted unlikely by continue predictor.
  goto <D.19955>;
  <D.23475>:
  D.23428 = i + 1;
  D.23429 = (unsigned int) D.23428;
  mono_mb_emit_ldarg (mb, D.23429);
  j.85 = j;
  j = j.85 + 1;
  D.23478 = j.85 + copy_locals_base;
  D.23479 = (unsigned int) D.23478;
  mono_mb_emit_ldloc (mb, D.23479);
  D.23442 = sig->params[i];
  D.23480 = mono_class_from_mono_type (D.23442);
  mono_marshal_emit_xdomain_copy_value (mb, D.23480);
  mono_mb_emit_byte (mb, 81);
  <D.19955>:
  i = i + 1;
  <D.19957>:
  D.23382 = sig->param_count;
  D.23403 = (int) D.23382;
  if (D.23403 > i) goto <D.19956>; else goto <D.19958>;
  <D.19958>:
  if (complex_out_count > 0) goto <D.23481>; else goto <D.23482>;
  <D.23481>:
  loc_serialized_data.77 = (unsigned int) loc_serialized_data;
  mono_mb_emit_ldloc (mb, loc_serialized_data.77);
  byte_array_class.67 = byte_array_class;
  mono_marshal_emit_xdomain_copy_value (mb, byte_array_class.67);
  method_rs_deserialize.82 = method_rs_deserialize;
  mono_mb_emit_managed_call (mb, method_rs_deserialize.82, 0B);
  loc_array.75 = (unsigned int) loc_array;
  mono_mb_emit_stloc (mb, loc_array.75);
  j = 0;
  i = 0;
  goto <D.19962>;
  <D.19961>:
  D.23400 = (long unsigned int) i;
  D.23401 = D.23400 * 4;
  D.23402 = marshal_types + D.23401;
  D.23439 = *D.23402;
  if (D.23439 != 3) goto <D.23483>; else goto <D.23484>;
  <D.23483>:
  // predicted unlikely by continue predictor.
  goto <D.19959>;
  <D.23484>:
  D.23442 = sig->params[i];
  D.23443 = BIT_FIELD_REF <*D.23442, 64, 64>;
  D.23444 = D.23443 & 8589934592;
  if (D.23444 != 0) goto <D.23485>; else goto <D.23486>;
  <D.23485>:
  {
    struct MonoClass * pclass;

    D.23442 = sig->params[i];
    pclass = mono_class_from_mono_type (D.23442);
    D.23428 = i + 1;
    D.23429 = (unsigned int) D.23428;
    mono_mb_emit_ldarg (mb, D.23429);
    loc_array.75 = (unsigned int) loc_array;
    mono_mb_emit_ldloc (mb, loc_array.75);
    mono_mb_emit_icon (mb, j);
    mono_mb_emit_byte (mb, 154);
    D.23487 = BIT_FIELD_REF <*pclass, 64, 256>;
    D.23488 = D.23487 & 1152921504606846976;
    if (D.23488 != 0) goto <D.23489>; else goto <D.23490>;
    <D.23489>:
    mono_mb_emit_op (mb, 121, pclass);
    mono_mb_emit_op (mb, 113, pclass);
    mono_mb_emit_op (mb, 129, pclass);
    goto <D.23491>;
    <D.23490>:
    D.23412 = mono_defaults.object_class;
    if (D.23412 != pclass) goto <D.23492>; else goto <D.23493>;
    <D.23492>:
    mono_mb_emit_op (mb, 116, pclass);
    <D.23493>:
    mono_mb_emit_byte (mb, 81);
    <D.23491>:
  }
  <D.23486>:
  j = j + 1;
  <D.19959>:
  i = i + 1;
  <D.19962>:
  D.23382 = sig->param_count;
  D.23403 = (int) D.23382;
  if (D.23403 > i) goto <D.19961>; else goto <D.19963>;
  <D.19963>:
  if (ret_marshal_type == 3) goto <D.23494>; else goto <D.23495>;
  <D.23494>:
  loc_array.75 = (unsigned int) loc_array;
  mono_mb_emit_ldloc (mb, loc_array.75);
  mono_mb_emit_icon (mb, complex_count);
  mono_mb_emit_byte (mb, 154);
  D.23496 = BIT_FIELD_REF <*ret_class, 64, 256>;
  D.23497 = D.23496 & 1152921504606846976;
  if (D.23497 != 0) goto <D.23498>; else goto <D.23499>;
  <D.23498>:
  mono_mb_emit_op (mb, 121, ret_class);
  mono_mb_emit_op (mb, 113, ret_class);
  <D.23499>:
  <D.23495>:
  goto <D.23500>;
  <D.23482>:
  if (ret_marshal_type == 3) goto <D.23501>; else goto <D.23502>;
  <D.23501>:
  loc_serialized_data.77 = (unsigned int) loc_serialized_data;
  mono_mb_emit_ldloc (mb, loc_serialized_data.77);
  byte_array_class.67 = byte_array_class;
  mono_marshal_emit_xdomain_copy_value (mb, byte_array_class.67);
  method_rs_deserialize.82 = method_rs_deserialize;
  mono_mb_emit_managed_call (mb, method_rs_deserialize.82, 0B);
  D.23496 = BIT_FIELD_REF <*ret_class, 64, 256>;
  D.23497 = D.23496 & 1152921504606846976;
  if (D.23497 != 0) goto <D.23503>; else goto <D.23504>;
  <D.23503>:
  mono_mb_emit_op (mb, 121, ret_class);
  mono_mb_emit_op (mb, 113, ret_class);
  goto <D.23505>;
  <D.23504>:
  D.23412 = mono_defaults.object_class;
  if (D.23412 != ret_class) goto <D.23506>; else goto <D.23507>;
  <D.23506>:
  mono_mb_emit_op (mb, 116, ret_class);
  <D.23507>:
  <D.23505>:
  goto <D.23508>;
  <D.23502>:
  loc_serialized_data.77 = (unsigned int) loc_serialized_data;
  mono_mb_emit_ldloc (mb, loc_serialized_data.77);
  mono_mb_emit_byte (mb, 37);
  D.23509 = mono_mb_emit_short_branch (mb, 44);
  pos = (int) D.23509;
  byte_array_class.67 = byte_array_class;
  mono_marshal_emit_xdomain_copy_value (mb, byte_array_class.67);
  pos.72 = (unsigned int) pos;
  mono_mb_patch_short_branch (mb, pos.72);
  method_rs_deserialize.82 = method_rs_deserialize;
  mono_mb_emit_managed_call (mb, method_rs_deserialize.82, 0B);
  mono_mb_emit_byte (mb, 38);
  <D.23508>:
  <D.23500>:
  if (copy_return != 0) goto <D.23510>; else goto <D.23511>;
  <D.23510>:
  loc_return.81 = (unsigned int) loc_return;
  mono_mb_emit_ldloc (mb, loc_return.81);
  if (ret_marshal_type == 1) goto <D.23512>; else goto <D.23513>;
  <D.23512>:
  mono_marshal_emit_xdomain_copy_value (mb, ret_class);
  <D.23513>:
  <D.23511>:
  mono_mb_emit_byte (mb, 42);
  D.23382 = sig->param_count;
  D.23403 = (int) D.23382;
  D.23514 = D.23403 + 16;
  res = mono_remoting_mb_create_and_cache (method, mb, sig, D.23514);
  mono_mb_free (mb);
  D.23368 = res;
  return D.23368;
}


mono_marshal_supports_fast_xdomain (struct MonoMethod * method)
{
  gboolean D.23516;
  int iftmp.86;
  struct MonoClass * D.23521;
  long unsigned int D.23522;
  long unsigned int D.23523;
  short unsigned int D.23525;
  int D.23526;
  int D.23527;
  const char * D.23529;
  int D.23530;

  D.23521 = method->klass;
  D.23522 = BIT_FIELD_REF <*D.23521, 64, 256>;
  D.23523 = D.23522 & 1099511627776;
  if (D.23523 == 0) goto <D.23524>; else goto <D.23518>;
  <D.23524>:
  D.23525 = method->flags;
  D.23526 = (int) D.23525;
  D.23527 = D.23526 & 2048;
  if (D.23527 == 0) goto <D.23519>; else goto <D.23528>;
  <D.23528>:
  D.23529 = method->name;
  D.23530 = strcmp (".ctor", D.23529);
  if (D.23530 != 0) goto <D.23519>; else goto <D.23518>;
  <D.23519>:
  iftmp.86 = 1;
  goto <D.23520>;
  <D.23518>:
  iftmp.86 = 0;
  <D.23520>:
  D.23516 = iftmp.86;
  return D.23516;
}


mono_remoting_marshal_init ()
{
  int module_initialized.87;
  struct MonoImage * D.23535;
  struct MonoMethod * D.23536;
  struct MonoMethod * D.23537;
  struct MonoMethod * D.23538;
  struct MonoMethod * D.23539;
  struct MonoMethod * D.23540;
  struct MonoClass * D.23541;
  struct MonoClass * D.23542;
  struct MonoMethod * D.23543;
  struct MonoMethod * D.23544;
  struct MonoClass * klass;
  static gboolean module_initialized = 0;

  module_initialized.87 = module_initialized;
  if (module_initialized.87 == 0) goto <D.23533>; else goto <D.23534>;
  <D.23533>:
  D.23535 = mono_defaults.corlib;
  klass = mono_class_from_name (D.23535, "System.Runtime.Remoting", "RemotingServices");
  D.23536 = mono_class_get_method_from_name (klass, "SerializeCallData", -1);
  method_rs_serialize = D.23536;
  D.23537 = mono_class_get_method_from_name (klass, "DeserializeCallData", -1);
  method_rs_deserialize = D.23537;
  D.23538 = mono_class_get_method_from_name (klass, "SerializeExceptionData", -1);
  method_rs_serialize_exc = D.23538;
  klass = mono_defaults.real_proxy_class;
  D.23539 = mono_class_get_method_from_name (klass, "GetAppDomainTarget", -1);
  method_rs_appdomain_target = D.23539;
  klass = mono_defaults.exception_class;
  D.23540 = mono_class_get_method_from_name (klass, "FixRemotingException", -1);
  method_exc_fixexc = D.23540;
  D.23541 = mono_defaults.byte_class;
  D.23542 = mono_array_class_get (D.23541, 1);
  byte_array_class = D.23542;
  D.23535 = mono_defaults.corlib;
  klass = mono_class_from_name (D.23535, "System.Runtime.Remoting.Messaging", "CallContext");
  D.23543 = mono_class_get_method_from_name (klass, "SetCurrentCallContext", -1);
  method_set_call_context = D.23543;
  D.23535 = mono_defaults.corlib;
  klass = mono_class_from_name (D.23535, "System.Runtime.Remoting.Contexts", "Context");
  D.23544 = mono_class_get_method_from_name (klass, "get_NeedsContextSink", -1);
  method_needs_context_sink = D.23544;
  module_initialized = 1;
  <D.23534>:
}


mono_marshal_get_xappdomain_dispatch (struct MonoMethod * method, int * marshal_types, int complex_count, int complex_out_count, int ret_marshal_type)
{
  struct MonoMethod * D.23547;
  int iftmp.88;
  struct MonoType * D.23551;
  unsigned char D.23552;
  struct MonoImage * D.23555;
  short unsigned int D.23556;
  int D.23557;
  int D.23558;
  int D.23559;
  unsigned int D.23560;
  int j.89;
  struct MonoClass * D.23562;
  struct MonoType * D.23563;
  int j.90;
  struct MonoClass * byte_array_class.91;
  struct MonoType * D.23566;
  int j.92;
  long unsigned int D.23568;
  long unsigned int D.23569;
  int * D.23570;
  int D.23571;
  int j.93;
  struct MonoType * D.23575;
  struct MonoClass * D.23579;
  struct MonoType * D.23580;
  struct MonoClass * D.23581;
  const char * D.23582;
  struct MonoMethod * D.23583;
  struct MonoType * D.23584;
  struct MonoImage * D.23589;
  int D.23590;
  unsigned int D.23591;
  struct MonoMethod * method_set_call_context.94;
  unsigned int D.23593;
  struct MonoMethod * method_rs_deserialize.95;
  unsigned int loc_array.96;
  unsigned int pos.97;
  struct MonoMethod * method_rs_appdomain_target.98;
  int j.99;
  long unsigned int D.23602;
  long unsigned int D.23603;
  long unsigned int D.23606;
  long unsigned int D.23607;
  struct MonoType * D.23617;
  int param_index.100;
  unsigned int param_index.101;
  unsigned int copy_local.102;
  unsigned int param_index.103;
  int param_index.104;
  unsigned int param_index.105;
  unsigned int loc_return.106;
  int j.107;
  int D.23636;
  unsigned int D.23637;
  struct MonoClass * D.23638;
  long unsigned int D.23643;
  long unsigned int D.23644;
  _Bool D.23649;
  long int D.23650;
  long int D.23651;
  long unsigned int D.23654;
  long unsigned int D.23655;
  struct MonoMethod * method_rs_serialize.108;
  unsigned int D.23665;
  int D.23666;
  unsigned int D.23667;
  unsigned int D.23668;
  unsigned int D.23669;
  int D.23670;
  unsigned int D.23671;
  struct MonoMethod * method_rs_serialize_exc.109;
  unsigned int loc_serialized_exc.110;
  int D.23674;
  unsigned int D.23675;
  unsigned int D.23676;
  unsigned int D.23677;
  unsigned int pos_leave.111;
  short unsigned int D.23681;
  int D.23682;
  int D.23683;
  struct MonoMethodSignature * sig;
  struct MonoMethodSignature * csig;
  struct MonoMethodBuilder * mb;
  struct MonoMethod * res;
  int i;
  int j;
  int param_index;
  int copy_locals_base;
  struct MonoClass * ret_class;
  int loc_array;
  int loc_return;
  int loc_serialized_exc;
  struct MonoExceptionClause * main_clause;
  int pos;
  int pos_leave;
  gboolean copy_return;

  ret_class = 0B;
  loc_array = 0;
  loc_return = 0;
  loc_serialized_exc = 0;
  res = mono_marshal_remoting_find_in_cache (method, 11);
  if (res != 0B) goto <D.23545>; else goto <D.23546>;
  <D.23545>:
  D.23547 = res;
  return D.23547;
  <D.23546>:
  sig = mono_method_signature (method);
  D.23551 = sig->ret;
  D.23552 = D.23551->type;
  if (D.23552 != 1) goto <D.23553>; else goto <D.23549>;
  <D.23553>:
  if (ret_marshal_type != 3) goto <D.23554>; else goto <D.23549>;
  <D.23554>:
  iftmp.88 = 1;
  goto <D.23550>;
  <D.23549>:
  iftmp.88 = 0;
  <D.23550>:
  copy_return = iftmp.88;
  j = 0;
  D.23555 = mono_defaults.corlib;
  D.23556 = sig->param_count;
  D.23557 = (int) D.23556;
  D.23558 = D.23557 + 3;
  D.23559 = D.23558 - complex_count;
  D.23560 = (unsigned int) D.23559;
  csig = mono_metadata_signature_alloc (D.23555, D.23560);
  j.89 = j;
  j = j.89 + 1;
  D.23562 = mono_defaults.object_class;
  D.23563 = &D.23562->byval_arg;
  csig->params[j.89] = D.23563;
  j.90 = j;
  j = j.90 + 1;
  byte_array_class.91 = byte_array_class;
  D.23566 = &byte_array_class.91->this_arg;
  csig->params[j.90] = D.23566;
  j.92 = j;
  j = j.92 + 1;
  byte_array_class.91 = byte_array_class;
  D.23566 = &byte_array_class.91->this_arg;
  csig->params[j.92] = D.23566;
  i = 0;
  goto <D.19883>;
  <D.19882>:
  D.23568 = (long unsigned int) i;
  D.23569 = D.23568 * 4;
  D.23570 = marshal_types + D.23569;
  D.23571 = *D.23570;
  if (D.23571 != 3) goto <D.23572>; else goto <D.23573>;
  <D.23572>:
  j.93 = j;
  j = j.93 + 1;
  D.23575 = sig->params[i];
  csig->params[j.93] = D.23575;
  <D.23573>:
  i = i + 1;
  <D.19883>:
  D.23556 = sig->param_count;
  D.23557 = (int) D.23556;
  if (D.23557 > i) goto <D.19882>; else goto <D.19884>;
  <D.19884>:
  if (copy_return != 0) goto <D.23576>; else goto <D.23577>;
  <D.23576>:
  D.23551 = sig->ret;
  csig->ret = D.23551;
  goto <D.23578>;
  <D.23577>:
  D.23579 = mono_defaults.void_class;
  D.23580 = &D.23579->byval_arg;
  csig->ret = D.23580;
  <D.23578>:
  csig->pinvoke = 1;
  csig->hasthis = 0;
  D.23581 = method->klass;
  D.23582 = method->name;
  mb = mono_mb_new (D.23581, D.23582, 11);
  D.23583 = mb->method;
  D.23583->save_lmf = 1;
  byte_array_class.91 = byte_array_class;
  D.23584 = &byte_array_class.91->byval_arg;
  loc_serialized_exc = mono_mb_add_local (mb, D.23584);
  if (complex_count > 0) goto <D.23585>; else goto <D.23586>;
  <D.23585>:
  D.23562 = mono_defaults.object_class;
  D.23563 = &D.23562->byval_arg;
  loc_array = mono_mb_add_local (mb, D.23563);
  <D.23586>:
  D.23551 = sig->ret;
  D.23552 = D.23551->type;
  if (D.23552 != 1) goto <D.23587>; else goto <D.23588>;
  <D.23587>:
  D.23551 = sig->ret;
  loc_return = mono_mb_add_local (mb, D.23551);
  D.23551 = sig->ret;
  ret_class = mono_class_from_mono_type (D.23551);
  <D.23588>:
  D.23581 = method->klass;
  D.23589 = D.23581->image;
  main_clause = mono_image_alloc0 (D.23589, 32);
  D.23590 = mono_mb_get_label (mb);
  D.23591 = (unsigned int) D.23590;
  main_clause->try_offset = D.23591;
  mono_mb_emit_byte (mb, 20);
  method_set_call_context.94 = method_set_call_context;
  mono_mb_emit_managed_call (mb, method_set_call_context.94, 0B);
  mono_mb_emit_byte (mb, 38);
  mono_mb_emit_ldarg (mb, 1);
  mono_mb_emit_byte (mb, 80);
  mono_mb_emit_byte (mb, 37);
  D.23593 = mono_mb_emit_short_branch (mb, 44);
  pos = (int) D.23593;
  byte_array_class.91 = byte_array_class;
  mono_marshal_emit_xdomain_copy_value (mb, byte_array_class.91);
  method_rs_deserialize.95 = method_rs_deserialize;
  mono_mb_emit_managed_call (mb, method_rs_deserialize.95, 0B);
  if (complex_count > 0) goto <D.23595>; else goto <D.23596>;
  <D.23595>:
  loc_array.96 = (unsigned int) loc_array;
  mono_mb_emit_stloc (mb, loc_array.96);
  goto <D.23598>;
  <D.23596>:
  mono_mb_emit_byte (mb, 38);
  <D.23598>:
  pos.97 = (unsigned int) pos;
  mono_mb_patch_short_branch (mb, pos.97);
  mono_mb_emit_ldarg (mb, 0);
  method_rs_appdomain_target.98 = method_rs_appdomain_target;
  mono_mb_emit_managed_call (mb, method_rs_appdomain_target.98, 0B);
  copy_locals_base = mb->locals;
  param_index = 3;
  j = 0;
  i = 0;
  goto <D.19894>;
  <D.19893>:
  {
    struct MonoType * pt;
    struct MonoClass * pclass;

    pt = sig->params[i];
    pclass = mono_class_from_mono_type (pt);
    D.23568 = (long unsigned int) i;
    D.23569 = D.23568 * 4;
    D.23570 = marshal_types + D.23569;
    D.23571 = *D.23570;
    switch (D.23571) <default: <D.23627>, case 0: <D.19892>, case 1: <D.19891>, case 2: <D.19889>, case 3: <D.19887>>
    <D.19887>:
    loc_array.96 = (unsigned int) loc_array;
    mono_mb_emit_ldloc (mb, loc_array.96);
    j.99 = j;
    j = j.99 + 1;
    mono_mb_emit_icon (mb, j.99);
    D.23602 = BIT_FIELD_REF <*pt, 64, 64>;
    D.23603 = D.23602 & 8589934592;
    if (D.23603 != 0) goto <D.23604>; else goto <D.23605>;
    <D.23604>:
    D.23606 = BIT_FIELD_REF <*pclass, 64, 256>;
    D.23607 = D.23606 & 1152921504606846976;
    if (D.23607 != 0) goto <D.23608>; else goto <D.23609>;
    <D.23608>:
    mono_mb_emit_byte (mb, 154);
    mono_mb_emit_op (mb, 121, pclass);
    goto <D.23610>;
    <D.23609>:
    mono_mb_emit_op (mb, 143, pclass);
    <D.23610>:
    goto <D.23611>;
    <D.23605>:
    D.23606 = BIT_FIELD_REF <*pclass, 64, 256>;
    D.23607 = D.23606 & 1152921504606846976;
    if (D.23607 != 0) goto <D.23612>; else goto <D.23613>;
    <D.23612>:
    mono_mb_emit_byte (mb, 154);
    mono_mb_emit_op (mb, 121, pclass);
    mono_mb_emit_op (mb, 113, pclass);
    goto <D.23614>;
    <D.23613>:
    mono_mb_emit_byte (mb, 154);
    D.23562 = mono_defaults.object_class;
    if (D.23562 != pclass) goto <D.23615>; else goto <D.23616>;
    <D.23615>:
    mono_mb_emit_op (mb, 116, pclass);
    <D.23616>:
    <D.23614>:
    <D.23611>:
    goto <D.19888>;
    <D.19889>:
    {
      int copy_local;

      D.23617 = &pclass->byval_arg;
      copy_local = mono_mb_add_local (mb, D.23617);
      param_index.100 = param_index;
      param_index = param_index.100 + 1;
      param_index.101 = (unsigned int) param_index.100;
      mono_mb_emit_ldarg (mb, param_index.101);
      mono_marshal_emit_xdomain_copy_value (mb, pclass);
      mono_mb_emit_byte (mb, 37);
      copy_local.102 = (unsigned int) copy_local;
      mono_mb_emit_stloc (mb, copy_local.102);
      goto <D.19888>;
    }
    <D.19891>:
    param_index.103 = (unsigned int) param_index;
    mono_mb_emit_ldarg (mb, param_index.103);
    D.23602 = BIT_FIELD_REF <*pt, 64, 64>;
    D.23603 = D.23602 & 8589934592;
    if (D.23603 != 0) goto <D.23622>; else goto <D.23623>;
    <D.23622>:
    mono_mb_emit_byte (mb, 37);
    mono_mb_emit_byte (mb, 37);
    mono_mb_emit_byte (mb, 80);
    mono_marshal_emit_xdomain_copy_value (mb, pclass);
    mono_mb_emit_byte (mb, 81);
    goto <D.23624>;
    <D.23623>:
    mono_marshal_emit_xdomain_copy_value (mb, pclass);
    <D.23624>:
    param_index = param_index + 1;
    goto <D.19888>;
    <D.19892>:
    param_index.104 = param_index;
    param_index = param_index.104 + 1;
    param_index.105 = (unsigned int) param_index.104;
    mono_mb_emit_ldarg (mb, param_index.105);
    goto <D.19888>;
    <D.23627>:
    <D.19888>:
  }
  i = i + 1;
  <D.19894>:
  D.23556 = sig->param_count;
  D.23557 = (int) D.23556;
  if (D.23557 > i) goto <D.19893>; else goto <D.19895>;
  <D.19895>:
  emit_thread_force_interrupt_checkpoint (mb);
  mono_mb_emit_op (mb, 111, method);
  D.23551 = sig->ret;
  D.23552 = D.23551->type;
  if (D.23552 != 1) goto <D.23628>; else goto <D.23629>;
  <D.23628>:
  loc_return.106 = (unsigned int) loc_return;
  mono_mb_emit_stloc (mb, loc_return.106);
  <D.23629>:
  j = 0;
  param_index = 3;
  i = 0;
  goto <D.19898>;
  <D.19897>:
  D.23568 = (long unsigned int) i;
  D.23569 = D.23568 * 4;
  D.23570 = marshal_types + D.23569;
  D.23571 = *D.23570;
  if (D.23571 == 3) goto <D.23631>; else goto <D.23632>;
  <D.23631>:
  // predicted unlikely by continue predictor.
  goto <D.19896>;
  <D.23632>:
  D.23568 = (long unsigned int) i;
  D.23569 = D.23568 * 4;
  D.23570 = marshal_types + D.23569;
  D.23571 = *D.23570;
  if (D.23571 == 2) goto <D.23633>; else goto <D.23634>;
  <D.23633>:
  j.107 = j;
  j = j.107 + 1;
  D.23636 = j.107 + copy_locals_base;
  D.23637 = (unsigned int) D.23636;
  mono_mb_emit_ldloc (mb, D.23637);
  param_index.103 = (unsigned int) param_index;
  mono_mb_emit_ldarg (mb, param_index.103);
  D.23575 = sig->params[i];
  D.23638 = mono_class_from_mono_type (D.23575);
  mono_marshal_emit_xdomain_copy_out_value (mb, D.23638);
  <D.23634>:
  param_index = param_index + 1;
  <D.19896>:
  i = i + 1;
  <D.19898>:
  D.23556 = sig->param_count;
  D.23557 = (int) D.23556;
  if (D.23557 > i) goto <D.19897>; else goto <D.19899>;
  <D.19899>:
  if (complex_out_count > 0) goto <D.23639>; else goto <D.23640>;
  <D.23639>:
  j = 0;
  i = 0;
  goto <D.19902>;
  <D.19901>:
  D.23568 = (long unsigned int) i;
  D.23569 = D.23568 * 4;
  D.23570 = marshal_types + D.23569;
  D.23571 = *D.23570;
  if (D.23571 != 3) goto <D.23641>; else goto <D.23642>;
  <D.23641>:
  // predicted unlikely by continue predictor.
  goto <D.19900>;
  <D.23642>:
  D.23575 = sig->params[i];
  D.23643 = BIT_FIELD_REF <*D.23575, 64, 64>;
  D.23644 = D.23643 & 8589934592;
  if (D.23644 == 0) goto <D.23645>; else goto <D.23646>;
  <D.23645>:
  loc_array.96 = (unsigned int) loc_array;
  mono_mb_emit_ldloc (mb, loc_array.96);
  mono_mb_emit_icon (mb, j);
  mono_mb_emit_byte (mb, 20);
  mono_mb_emit_byte (mb, 162);
  <D.23646>:
  j = j + 1;
  <D.19900>:
  i = i + 1;
  <D.19902>:
  D.23556 = sig->param_count;
  D.23557 = (int) D.23556;
  if (D.23557 > i) goto <D.19901>; else goto <D.19903>;
  <D.19903>:
  if (ret_marshal_type == 3) goto <D.23647>; else goto <D.23648>;
  <D.23647>:
  loc_array.96 = (unsigned int) loc_array;
  mono_mb_emit_ldloc (mb, loc_array.96);
  mono_mb_emit_icon (mb, complex_count);
  loc_return.106 = (unsigned int) loc_return;
  mono_mb_emit_ldloc (mb, loc_return.106);
  D.23649 = ret_class == 0B;
  D.23650 = (long int) D.23649;
  D.23651 = __builtin_expect (D.23650, 0);
  if (D.23651 != 0) goto <D.23652>; else goto <D.23653>;
  <D.23652>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 3660, "ret_class");
  <D.23653>:
  D.23654 = BIT_FIELD_REF <*ret_class, 64, 256>;
  D.23655 = D.23654 & 1152921504606846976;
  if (D.23655 != 0) goto <D.23656>; else goto <D.23657>;
  <D.23656>:
  mono_mb_emit_op (mb, 140, ret_class);
  <D.23657>:
  mono_mb_emit_byte (mb, 162);
  <D.23648>:
  mono_mb_emit_ldarg (mb, 1);
  loc_array.96 = (unsigned int) loc_array;
  mono_mb_emit_ldloc (mb, loc_array.96);
  method_rs_serialize.108 = method_rs_serialize;
  mono_mb_emit_managed_call (mb, method_rs_serialize.108, 0B);
  mono_mb_emit_byte (mb, 81);
  goto <D.23659>;
  <D.23640>:
  if (ret_marshal_type == 3) goto <D.23660>; else goto <D.23661>;
  <D.23660>:
  mono_mb_emit_ldarg (mb, 1);
  loc_return.106 = (unsigned int) loc_return;
  mono_mb_emit_ldloc (mb, loc_return.106);
  D.23654 = BIT_FIELD_REF <*ret_class, 64, 256>;
  D.23655 = D.23654 & 1152921504606846976;
  if (D.23655 != 0) goto <D.23662>; else goto <D.23663>;
  <D.23662>:
  mono_mb_emit_op (mb, 140, ret_class);
  <D.23663>:
  method_rs_serialize.108 = method_rs_serialize;
  mono_mb_emit_managed_call (mb, method_rs_serialize.108, 0B);
  mono_mb_emit_byte (mb, 81);
  goto <D.23664>;
  <D.23661>:
  mono_mb_emit_ldarg (mb, 1);
  mono_mb_emit_byte (mb, 20);
  method_rs_serialize.108 = method_rs_serialize;
  mono_mb_emit_managed_call (mb, method_rs_serialize.108, 0B);
  mono_mb_emit_byte (mb, 81);
  <D.23664>:
  <D.23659>:
  mono_mb_emit_ldarg (mb, 2);
  mono_mb_emit_byte (mb, 20);
  mono_mb_emit_byte (mb, 81);
  D.23665 = mono_mb_emit_branch (mb, 221);
  pos_leave = (int) D.23665;
  main_clause->flags = 0;
  D.23666 = mono_mb_get_pos (mb);
  D.23667 = (unsigned int) D.23666;
  D.23668 = main_clause->try_offset;
  D.23669 = D.23667 - D.23668;
  main_clause->try_len = D.23669;
  D.23562 = mono_defaults.object_class;
  main_clause->data.catch_class = D.23562;
  D.23670 = mono_mb_get_label (mb);
  D.23671 = (unsigned int) D.23670;
  main_clause->handler_offset = D.23671;
  method_rs_serialize_exc.109 = method_rs_serialize_exc;
  mono_mb_emit_managed_call (mb, method_rs_serialize_exc.109, 0B);
  loc_serialized_exc.110 = (unsigned int) loc_serialized_exc;
  mono_mb_emit_stloc (mb, loc_serialized_exc.110);
  mono_mb_emit_ldarg (mb, 2);
  loc_serialized_exc.110 = (unsigned int) loc_serialized_exc;
  mono_mb_emit_ldloc (mb, loc_serialized_exc.110);
  mono_mb_emit_byte (mb, 81);
  mono_mb_emit_branch (mb, 221);
  D.23674 = mono_mb_get_pos (mb);
  D.23675 = (unsigned int) D.23674;
  D.23676 = main_clause->handler_offset;
  D.23677 = D.23675 - D.23676;
  main_clause->handler_len = D.23677;
  pos_leave.111 = (unsigned int) pos_leave;
  mono_mb_patch_branch (mb, pos_leave.111);
  if (copy_return != 0) goto <D.23679>; else goto <D.23680>;
  <D.23679>:
  loc_return.106 = (unsigned int) loc_return;
  mono_mb_emit_ldloc (mb, loc_return.106);
  <D.23680>:
  mono_mb_emit_byte (mb, 42);
  mono_mb_set_clauses (mb, 1, main_clause);
  D.23681 = csig->param_count;
  D.23682 = (int) D.23681;
  D.23683 = D.23682 + 16;
  res = mono_remoting_mb_create_and_cache (method, mb, csig, D.23683);
  mono_mb_free (mb);
  D.23547 = res;
  return D.23547;
}


emit_thread_force_interrupt_checkpoint (struct MonoMethodBuilder * mb)
{
  emit_thread_interrupt_checkpoint_call (mb, mono_thread_force_interruption_checkpoint);
}


mono_marshal_emit_xdomain_copy_out_value (struct MonoMethodBuilder * mb, struct MonoClass * pclass)
{
  mono_mb_emit_icall (mb, mono_marshal_xdomain_copy_out_value);
}


mono_marshal_emit_load_domain_method (struct MonoMethodBuilder * mb, struct MonoMethod * method)
{
  mono_mb_emit_ptr (mb, method);
  mono_mb_emit_icall (mb, mono_compile_method);
}


mono_marshal_emit_switch_domain (struct MonoMethodBuilder * mb)
{
  mono_mb_emit_icall (mb, mono_marshal_set_domain_by_id);
}


mono_marshal_emit_xdomain_copy_value (struct MonoMethodBuilder * mb, struct MonoClass * pclass)
{
  mono_mb_emit_icall (mb, mono_marshal_xdomain_copy_value);
  mono_mb_emit_op (mb, 116, pclass);
}


__attribute__((visibility ("hidden")))
mono_marshal_get_remoting_invoke_for_target (struct MonoMethod * method, MonoRemotingTarget target_type)
{
  struct MonoMethod * D.23687;

  if (target_type == 1) goto <D.23685>; else goto <D.23686>;
  <D.23685>:
  D.23687 = mono_marshal_get_xappdomain_invoke (method);
  return D.23687;
  <D.23686>:
  if (target_type == 2) goto <D.23688>; else goto <D.23689>;
  <D.23688>:
  D.23687 = mono_cominterop_get_invoke (method);
  return D.23687;
  <D.23689>:
  D.23687 = mono_marshal_get_remoting_invoke (method);
  return D.23687;
  D.23687 = 0B;
  return D.23687;
}


__attribute__((visibility ("hidden")))
mono_marshal_get_remoting_invoke_with_check (struct MonoMethod * method)
{
  _Bool D.23691;
  long int D.23692;
  long int D.23693;
  long unsigned int D.23696;
  long unsigned int D.23697;
  struct MonoMethod * D.23700;
  struct MonoMethodSignature * D.23701;
  long unsigned int D.23702;
  long unsigned int D.23703;
  _Bool D.23704;
  long int D.23705;
  long int D.23706;
  struct MonoClass * D.23711;
  const char * D.23712;
  unsigned int i.112;
  short unsigned int D.23714;
  int D.23715;
  int D.23716;
  struct MonoMethodSignature * D.23719;
  unsigned int pos_rem.113;
  struct MonoMethodSignature * D.23721;
  unsigned int pos.114;
  struct MonoMethodSignature * D.23723;
  int D.23724;
  struct MonoMethodSignature * sig;
  struct MonoMethodBuilder * mb;
  struct MonoMethod * res;
  struct MonoMethod * native;
  int i;
  int pos;
  int pos_rem;

  D.23691 = method == 0B;
  D.23692 = (long int) D.23691;
  D.23693 = __builtin_expect (D.23692, 0);
  if (D.23693 != 0) goto <D.23694>; else goto <D.23695>;
  <D.23694>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 4087, "method");
  <D.23695>:
  D.23696 = BIT_FIELD_REF <*method, 64, 256>;
  D.23697 = D.23696 & 4467570830351532032;
  if (D.23697 == 1297036692682702848) goto <D.23698>; else goto <D.23699>;
  <D.23698>:
  D.23700 = method;
  return D.23700;
  <D.23699>:
  D.23701 = mono_method_signature (method);
  D.23702 = BIT_FIELD_REF <*D.23701, 64, 64>;
  D.23703 = D.23702 & 512;
  D.23704 = D.23703 == 0;
  D.23705 = (long int) D.23704;
  D.23706 = __builtin_expect (D.23705, 0);
  if (D.23706 != 0) goto <D.23707>; else goto <D.23708>;
  <D.23707>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 4093, "mono_method_signature (method)->hasthis");
  <D.23708>:
  res = mono_marshal_remoting_find_in_cache (method, 9);
  if (res != 0B) goto <D.23709>; else goto <D.23710>;
  <D.23709>:
  D.23700 = res;
  return D.23700;
  <D.23710>:
  sig = mono_signature_no_pinvoke (method);
  D.23711 = method->klass;
  D.23712 = method->name;
  mb = mono_mb_new (D.23711, D.23712, 9);
  i = 0;
  goto <D.19983>;
  <D.19982>:
  i.112 = (unsigned int) i;
  mono_mb_emit_ldarg (mb, i.112);
  i = i + 1;
  <D.19983>:
  D.23714 = sig->param_count;
  D.23715 = (int) D.23714;
  if (D.23715 >= i) goto <D.19982>; else goto <D.19984>;
  <D.19984>:
  mono_mb_emit_ldarg (mb, 0);
  pos = mono_mb_emit_proxy_check (mb, 64);
  D.23716 = mono_marshal_supports_fast_xdomain (method);
  if (D.23716 != 0) goto <D.23717>; else goto <D.23718>;
  <D.23717>:
  mono_mb_emit_ldarg (mb, 0);
  pos_rem = mono_mb_emit_xdomain_check (mb, 59);
  native = mono_marshal_get_xappdomain_invoke (method);
  D.23719 = mono_method_signature (native);
  mono_mb_emit_managed_call (mb, native, D.23719);
  mono_mb_emit_byte (mb, 42);
  pos_rem.113 = (unsigned int) pos_rem;
  mono_mb_patch_branch (mb, pos_rem.113);
  <D.23718>:
  native = mono_marshal_get_remoting_invoke (method);
  D.23721 = mono_method_signature (native);
  mono_mb_emit_managed_call (mb, native, D.23721);
  mono_mb_emit_byte (mb, 42);
  pos.114 = (unsigned int) pos;
  mono_mb_patch_branch (mb, pos.114);
  D.23723 = mono_method_signature (method);
  mono_mb_emit_managed_call (mb, method, D.23723);
  mono_mb_emit_byte (mb, 42);
  D.23714 = sig->param_count;
  D.23715 = (int) D.23714;
  D.23724 = D.23715 + 16;
  res = mono_remoting_mb_create_and_cache (method, mb, sig, D.23724);
  mono_mb_free (mb);
  D.23700 = res;
  return D.23700;
}


mono_mb_emit_proxy_check (struct MonoMethodBuilder * mb, int branch_code)
{
  struct MonoClass * D.23726;
  unsigned int D.23727;
  int D.23728;
  unsigned char D.23729;
  unsigned int D.23730;
  int D.23731;
  int pos;

  mono_mb_emit_ldflda (mb, 0);
  mono_mb_emit_byte (mb, 77);
  mono_mb_emit_icon (mb, 0);
  mono_mb_emit_byte (mb, 88);
  mono_mb_emit_byte (mb, 77);
  mono_mb_emit_byte (mb, 240);
  mono_mb_emit_byte (mb, 11);
  D.23726 = mono_defaults.transparent_proxy_class;
  D.23727 = mono_mb_add_data (mb, D.23726);
  D.23728 = (int) D.23727;
  mono_mb_emit_i4 (mb, D.23728);
  D.23729 = (unsigned char) branch_code;
  D.23730 = mono_mb_emit_branch (mb, D.23729);
  pos = (int) D.23730;
  D.23731 = pos;
  return D.23731;
}


mono_mb_emit_xdomain_check (struct MonoMethodBuilder * mb, int branch_code)
{
  unsigned char D.23733;
  unsigned int D.23734;
  int D.23735;
  int pos;

  mono_mb_emit_ldflda (mb, 16);
  mono_mb_emit_byte (mb, 80);
  mono_mb_emit_ldflda (mb, 40);
  mono_mb_emit_byte (mb, 74);
  mono_mb_emit_icon (mb, -1);
  D.23733 = (unsigned char) branch_code;
  D.23734 = mono_mb_emit_branch (mb, D.23733);
  pos = (int) D.23734;
  D.23735 = pos;
  return D.23735;
}


__attribute__((visibility ("hidden")))
mono_marshal_get_delegate_invoke (struct MonoMethod * method, struct MonoDelegate * del)
{
  struct MonoObject * D.23739;
  struct MonoMethod * D.23742;
  struct MonoMethodSignature * D.23745;
  long unsigned int D.23746;
  long unsigned int D.23747;
  long unsigned int D.23750;
  long unsigned int D.23751;
  struct MonoMethodSignature * D.23754;
  long unsigned int D.23755;
  long unsigned int D.23756;
  _Bool D.23757;
  long int D.23758;
  long int D.23759;
  struct MonoType * D.23762;
  struct MonoGenericContext * D.23763;
  int iftmp.115;
  struct MonoClass * D.23770;
  struct MonoClass * D.23771;
  struct MonoClass * D.23772;
  const char * D.23774;
  int D.23775;
  _Bool D.23776;
  long int D.23777;
  long int D.23778;
  short unsigned int D.23783;
  struct MonoMethodSignature * D.23784;
  short unsigned int D.23785;
  _Bool D.23786;
  struct MonoMethodSignature * D.23791;
  short unsigned int D.23792;
  int D.23793;
  int D.23794;
  int D.23795;
  short unsigned int D.23798;
  int D.23799;
  int D.23800;
  _Bool D.23803;
  long int D.23804;
  long int D.23805;
  long unsigned int D.23808;
  long unsigned int D.23809;
  _Bool D.23818;
  long int D.23819;
  long int D.23820;
  struct MonoImage * D.23825;
  struct GHashTable * * D.23826;
  struct MonoMethod * D.23829;
  struct GHashTable * * D.23833;
  _Bool D.23841;
  long int D.23842;
  long int D.23843;
  struct GHashTable * D.23846;
  struct GHashTable * D.23849;
  _Bool D.23852;
  long int D.23853;
  long int D.23854;
  struct GHashTable * * D.23860;
  struct MonoClass * D.23871;
  struct MonoClass * D.23872;
  struct MonoType * D.23873;
  long unsigned int D.23874;
  long unsigned int D.23875;
  _Bool D.23876;
  long int D.23877;
  long int D.23878;
  unsigned int local_prev.116;
  unsigned int D.23882;
  int D.23883;
  unsigned int D.23884;
  struct MonoGenericContext * D.23887;
  struct MonoMethod * D.23888;
  struct MonoType * D.23890;
  unsigned char D.23891;
  unsigned int pos0.117;
  unsigned int local_target.118;
  unsigned int D.23898;
  struct MonoType * D.23910;
  int D.23911;
  struct MonoClass * D.23914;
  int D.23917;
  _Bool D.23926;
  long int D.23927;
  long int D.23928;
  struct MonoClass * D.23935;
  struct MonoImage * D.23936;
  struct MonoMethodSignature * D.23937;
  struct MonoMethodSignature * D.23938;
  _Bool D.23941;
  long int D.23942;
  long int D.23943;
  _Bool D.23949;
  long int D.23950;
  long int D.23951;
  struct MonoMethodSignature * sig;
  struct MonoMethodSignature * static_sig;
  struct MonoMethodSignature * invoke_sig;
  int i;
  struct MonoMethodBuilder * mb;
  struct MonoMethod * res;
  struct MonoMethod * newm;
  struct GHashTable * cache;
  struct SignatureMethodPair key;
  struct SignatureMethodPair * new_key;
  int local_prev;
  int local_target;
  int pos0;
  char * name;
  struct MonoMethod * target_method;
  struct MonoClass * target_class;
  gboolean callvirt;
  gboolean closed_over_null;
  gboolean static_method_with_first_arg_bound;
  struct MonoGenericContext * ctx;
  struct MonoGenericContainer * container;
  struct MonoMethod * orig_method;
  struct WrapperInfo * info;

  try
    {
      target_method = 0B;
      target_class = 0B;
      callvirt = 0;
      closed_over_null = 0;
      static_method_with_first_arg_bound = 0;
      ctx = 0B;
      container = 0B;
      orig_method = 0B;
      if (del != 0B) goto <D.23737>; else goto <D.23738>;
      <D.23737>:
      D.23739 = del->target;
      if (D.23739 == 0B) goto <D.23740>; else goto <D.23741>;
      <D.23740>:
      D.23742 = del->method;
      if (D.23742 != 0B) goto <D.23743>; else goto <D.23744>;
      <D.23743>:
      D.23742 = del->method;
      D.23745 = mono_method_signature (D.23742);
      D.23746 = BIT_FIELD_REF <*D.23745, 64, 64>;
      D.23747 = D.23746 & 512;
      if (D.23747 != 0) goto <D.23748>; else goto <D.23749>;
      <D.23748>:
      callvirt = 1;
      target_method = del->method;
      D.23750 = BIT_FIELD_REF <*target_method, 64, 256>;
      D.23751 = D.23750 & 2251799813685248;
      if (D.23751 != 0) goto <D.23752>; else goto <D.23753>;
      <D.23752>:
      {
        struct MonoType * target_type;

        D.23754 = method->signature;
        D.23755 = BIT_FIELD_REF <*D.23754, 64, 64>;
        D.23756 = D.23755 & 512;
        D.23757 = D.23756 == 0;
        D.23758 = (long int) D.23757;
        D.23759 = __builtin_expect (D.23758, 0);
        if (D.23759 != 0) goto <D.23760>; else goto <D.23761>;
        <D.23760>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 4211, "method->signature->hasthis");
        <D.23761>:
        D.23754 = method->signature;
        D.23762 = D.23754->params[0];
        D.23763 = mono_method_get_context (method);
        target_type = mono_class_inflate_generic_type (D.23762, D.23763);
        target_class = mono_class_from_mono_type (target_type);
      }
      goto <D.23764>;
      <D.23753>:
      D.23742 = del->method;
      target_class = D.23742->klass;
      <D.23764>:
      <D.23749>:
      <D.23744>:
      <D.23741>:
      <D.23738>:
      if (method == 0B) goto <D.23766>; else goto <D.23769>;
      <D.23769>:
      D.23770 = method->klass;
      D.23771 = D.23770->parent;
      D.23772 = mono_defaults.multicastdelegate_class;
      if (D.23771 != D.23772) goto <D.23766>; else goto <D.23773>;
      <D.23773>:
      D.23774 = method->name;
      D.23775 = strcmp (D.23774, "Invoke");
      if (D.23775 != 0) goto <D.23766>; else goto <D.23767>;
      <D.23766>:
      iftmp.115 = 1;
      goto <D.23768>;
      <D.23767>:
      iftmp.115 = 0;
      <D.23768>:
      D.23776 = iftmp.115 != 0;
      D.23777 = (long int) D.23776;
      D.23778 = __builtin_expect (D.23777, 0);
      if (D.23778 != 0) goto <D.23779>; else goto <D.23780>;
      <D.23779>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 4221, "method && method->klass->parent == mono_defaults.multicastdelegate_class && !strcmp (method->name, \"Invoke\")");
      <D.23780>:
      sig = mono_signature_no_pinvoke (method);
      invoke_sig = sig;
      if (callvirt != 0) goto <D.23781>; else goto <D.23782>;
      <D.23781>:
      D.23783 = sig->param_count;
      D.23742 = del->method;
      D.23784 = mono_method_signature (D.23742);
      D.23785 = D.23784->param_count;
      D.23786 = D.23783 == D.23785;
      closed_over_null = (gboolean) D.23786;
      <D.23782>:
      if (del != 0B) goto <D.23787>; else goto <D.23788>;
      <D.23787>:
      D.23742 = del->method;
      if (D.23742 != 0B) goto <D.23789>; else goto <D.23790>;
      <D.23789>:
      D.23742 = del->method;
      D.23791 = mono_method_signature (D.23742);
      D.23792 = D.23791->param_count;
      D.23793 = (int) D.23792;
      D.23783 = sig->param_count;
      D.23794 = (int) D.23783;
      D.23795 = D.23794 + 1;
      if (D.23793 == D.23795) goto <D.23796>; else goto <D.23797>;
      <D.23796>:
      D.23742 = del->method;
      D.23798 = D.23742->flags;
      D.23799 = (int) D.23798;
      D.23800 = D.23799 & 16;
      if (D.23800 != 0) goto <D.23801>; else goto <D.23802>;
      <D.23801>:
      D.23803 = callvirt != 0;
      D.23804 = (long int) D.23803;
      D.23805 = __builtin_expect (D.23804, 0);
      if (D.23805 != 0) goto <D.23806>; else goto <D.23807>;
      <D.23806>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 4229, "!callvirt");
      <D.23807>:
      D.23742 = del->method;
      invoke_sig = mono_method_signature (D.23742);
      target_method = 0B;
      static_method_with_first_arg_bound = 1;
      <D.23802>:
      <D.23797>:
      <D.23790>:
      <D.23788>:
      D.23808 = BIT_FIELD_REF <*method, 64, 256>;
      D.23809 = D.23808 & 2251799813685248;
      if (D.23809 != 0) goto <D.23810>; else goto <D.23811>;
      <D.23810>:
      if (callvirt == 0) goto <D.23812>; else goto <D.23813>;
      <D.23812>:
      if (static_method_with_first_arg_bound == 0) goto <D.23814>; else goto <D.23815>;
      <D.23814>:
      orig_method = method;
      ctx = &MEM[(struct MonoMethodInflated *)method].context;
      method = MEM[(struct MonoMethodInflated *)method].declaring;
      container = mono_method_get_generic_container (method);
      if (container == 0B) goto <D.23816>; else goto <D.23817>;
      <D.23816>:
      D.23770 = method->klass;
      container = D.23770->generic_container;
      <D.23817>:
      D.23818 = container == 0B;
      D.23819 = (long int) D.23818;
      D.23820 = __builtin_expect (D.23819, 0);
      if (D.23820 != 0) goto <D.23821>; else goto <D.23822>;
      <D.23821>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 4246, "container");
      <D.23822>:
      sig = mono_signature_no_pinvoke (method);
      invoke_sig = sig;
      <D.23815>:
      <D.23813>:
      <D.23811>:
      if (ctx != 0B) goto <D.23823>; else goto <D.23824>;
      <D.23823>:
      D.23770 = method->klass;
      D.23825 = D.23770->image;
      D.23826 = &D.23825->delegate_invoke_generic_cache;
      cache = get_cache (D.23826, mono_aligned_addr_hash, 0B);
      res = check_generic_delegate_wrapper_cache (cache, orig_method, method, ctx);
      if (res != 0B) goto <D.23827>; else goto <D.23828>;
      <D.23827>:
      D.23829 = res;
      return D.23829;
      <D.23828>:
      goto <D.23830>;
      <D.23824>:
      if (static_method_with_first_arg_bound != 0) goto <D.23831>; else goto <D.23832>;
      <D.23831>:
      D.23770 = method->klass;
      D.23825 = D.23770->image;
      D.23833 = &D.23825->delegate_bound_static_invoke_cache;
      cache = get_cache (D.23833, mono_signature_hash, mono_metadata_signature_equal);
      res = mono_marshal_find_in_cache (cache, invoke_sig);
      if (res != 0B) goto <D.23834>; else goto <D.23835>;
      <D.23834>:
      D.23829 = res;
      return D.23829;
      <D.23835>:
      goto <D.23836>;
      <D.23832>:
      if (callvirt != 0) goto <D.23837>; else goto <D.23838>;
      <D.23837>:
      {
        struct GHashTable * * cache_ptr;

        D.23770 = method->klass;
        D.23825 = D.23770->image;
        cache_ptr = &D.23825->delegate_abstract_invoke_cache;
        {
          int ret;

          ret = pthread_mutex_lock (&marshal_mutex.mutex);
          if (ret != 0) goto <D.23839>; else goto <D.23840>;
          <D.23839>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.23840>:
          D.23841 = ret != 0;
          D.23842 = (long int) D.23841;
          D.23843 = __builtin_expect (D.23842, 0);
          if (D.23843 != 0) goto <D.23844>; else goto <D.23845>;
          <D.23844>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 4275, "ret == 0");
          <D.23845>:
        }
        D.23846 = *cache_ptr;
        if (D.23846 == 0B) goto <D.23847>; else goto <D.23848>;
        <D.23847>:
        D.23849 = monoeg_g_hash_table_new_full (signature_method_pair_hash, signature_method_pair_equal, free_signature_method_pair, 0B);
        *cache_ptr = D.23849;
        <D.23848>:
        cache = *cache_ptr;
        key.sig = invoke_sig;
        key.method = target_method;
        res = monoeg_g_hash_table_lookup (cache, &key);
        {
          int ret;

          ret = pthread_mutex_unlock (&marshal_mutex.mutex);
          if (ret != 0) goto <D.23850>; else goto <D.23851>;
          <D.23850>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.23851>:
          D.23852 = ret != 0;
          D.23853 = (long int) D.23852;
          D.23854 = __builtin_expect (D.23853, 0);
          if (D.23854 != 0) goto <D.23855>; else goto <D.23856>;
          <D.23855>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 4282, "ret == 0");
          <D.23856>:
        }
        if (res != 0B) goto <D.23857>; else goto <D.23858>;
        <D.23857>:
        D.23829 = res;
        return D.23829;
        <D.23858>:
      }
      goto <D.23859>;
      <D.23838>:
      D.23770 = method->klass;
      D.23825 = D.23770->image;
      D.23860 = &D.23825->delegate_invoke_cache;
      cache = get_cache (D.23860, mono_signature_hash, mono_metadata_signature_equal);
      res = mono_marshal_find_in_cache (cache, sig);
      if (res != 0B) goto <D.23861>; else goto <D.23862>;
      <D.23861>:
      D.23829 = res;
      return D.23829;
      <D.23862>:
      <D.23859>:
      <D.23836>:
      <D.23830>:
      D.23770 = method->klass;
      D.23825 = D.23770->image;
      static_sig = signature_dup (D.23825, sig);
      static_sig->hasthis = 0;
      if (static_method_with_first_arg_bound == 0) goto <D.23863>; else goto <D.23864>;
      <D.23863>:
      invoke_sig = static_sig;
      <D.23864>:
      if (static_method_with_first_arg_bound != 0) goto <D.23865>; else goto <D.23866>;
      <D.23865>:
      name = mono_signature_to_name (invoke_sig, "invoke_bound_");
      goto <D.23867>;
      <D.23866>:
      name = mono_signature_to_name (sig, "invoke");
      <D.23867>:
      if (ctx != 0B) goto <D.23868>; else goto <D.23869>;
      <D.23868>:
      D.23770 = method->klass;
      mb = mono_mb_new (D.23770, name, 1);
      goto <D.23870>;
      <D.23869>:
      D.23770 = method->klass;
      D.23825 = D.23770->image;
      D.23871 = get_wrapper_target_class (D.23825);
      mb = mono_mb_new (D.23871, name, 1);
      <D.23870>:
      monoeg_g_free (name);
      D.23872 = mono_defaults.object_class;
      D.23873 = &D.23872->byval_arg;
      local_target = mono_mb_add_local (mb, D.23873);
      D.23872 = mono_defaults.object_class;
      D.23873 = &D.23872->byval_arg;
      local_prev = mono_mb_add_local (mb, D.23873);
      D.23874 = BIT_FIELD_REF <*sig, 64, 64>;
      D.23875 = D.23874 & 512;
      D.23876 = D.23875 == 0;
      D.23877 = (long int) D.23876;
      D.23878 = __builtin_expect (D.23877, 0);
      if (D.23878 != 0) goto <D.23879>; else goto <D.23880>;
      <D.23879>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 4314, "sig->hasthis");
      <D.23880>:
      emit_thread_interrupt_checkpoint (mb);
      mono_mb_emit_ldarg (mb, 0);
      mono_mb_emit_ldflda (mb, 88);
      mono_mb_emit_byte (mb, 80);
      local_prev.116 = (unsigned int) local_prev;
      mono_mb_emit_stloc (mb, local_prev.116);
      local_prev.116 = (unsigned int) local_prev;
      mono_mb_emit_ldloc (mb, local_prev.116);
      D.23882 = mono_mb_emit_branch (mb, 57);
      pos0 = (int) D.23882;
      mono_mb_emit_byte (mb, 240);
      mono_mb_emit_byte (mb, 12);
      local_prev.116 = (unsigned int) local_prev;
      mono_mb_emit_ldloc (mb, local_prev.116);
      i = 0;
      goto <D.20039>;
      <D.20038>:
      D.23883 = i + 1;
      D.23884 = (unsigned int) D.23883;
      mono_mb_emit_ldarg (mb, D.23884);
      i = i + 1;
      <D.20039>:
      D.23783 = sig->param_count;
      D.23794 = (int) D.23783;
      if (D.23794 > i) goto <D.20038>; else goto <D.20040>;
      <D.20040>:
      if (ctx != 0B) goto <D.23885>; else goto <D.23886>;
      <D.23885>:
      D.23887 = &container->context;
      D.23888 = mono_class_inflate_generic_method (method, D.23887);
      mono_mb_emit_op (mb, 111, D.23888);
      goto <D.23889>;
      <D.23886>:
      mono_mb_emit_op (mb, 111, method);
      <D.23889>:
      D.23890 = sig->ret;
      D.23891 = D.23890->type;
      if (D.23891 != 1) goto <D.23892>; else goto <D.23893>;
      <D.23892>:
      mono_mb_emit_byte (mb, 38);
      <D.23893>:
      pos0.117 = (unsigned int) pos0;
      mono_mb_patch_branch (mb, pos0.117);
      mono_mb_emit_ldarg (mb, 0);
      mono_mb_emit_ldflda (mb, 32);
      mono_mb_emit_byte (mb, 80);
      local_target.118 = (unsigned int) local_target;
      mono_mb_emit_stloc (mb, local_target.118);
      if (static_method_with_first_arg_bound == 0) goto <D.23896>; else goto <D.23897>;
      <D.23896>:
      local_target.118 = (unsigned int) local_target;
      mono_mb_emit_ldloc (mb, local_target.118);
      D.23898 = mono_mb_emit_branch (mb, 57);
      pos0 = (int) D.23898;
      if (callvirt != 0) goto <D.23899>; else goto <D.23900>;
      <D.23899>:
      mono_mb_emit_exception_full (mb, "System", "NotImplementedException", "");
      goto <D.23901>;
      <D.23900>:
      local_target.118 = (unsigned int) local_target;
      mono_mb_emit_ldloc (mb, local_target.118);
      i = 0;
      goto <D.20042>;
      <D.20041>:
      D.23883 = i + 1;
      D.23884 = (unsigned int) D.23883;
      mono_mb_emit_ldarg (mb, D.23884);
      i = i + 1;
      <D.20042>:
      D.23783 = sig->param_count;
      D.23794 = (int) D.23783;
      if (D.23794 > i) goto <D.20041>; else goto <D.20043>;
      <D.20043>:
      mono_mb_emit_ldarg (mb, 0);
      mono_mb_emit_ldflda (mb, 16);
      mono_mb_emit_byte (mb, 77);
      mono_mb_emit_op (mb, 41, sig);
      mono_mb_emit_byte (mb, 42);
      <D.23901>:
      pos0.117 = (unsigned int) pos0;
      mono_mb_patch_branch (mb, pos0.117);
      <D.23897>:
      if (callvirt != 0) goto <D.23902>; else goto <D.23903>;
      <D.23902>:
      if (closed_over_null == 0) goto <D.23904>; else goto <D.23905>;
      <D.23904>:
      mono_mb_emit_ldarg (mb, 1);
      mono_mb_emit_op (mb, 116, target_class);
      i = 1;
      goto <D.20045>;
      <D.20044>:
      D.23883 = i + 1;
      D.23884 = (unsigned int) D.23883;
      mono_mb_emit_ldarg (mb, D.23884);
      i = i + 1;
      <D.20045>:
      D.23783 = sig->param_count;
      D.23794 = (int) D.23783;
      if (D.23794 > i) goto <D.20044>; else goto <D.20046>;
      <D.20046>:
      mono_mb_emit_op (mb, 111, target_method);
      goto <D.23906>;
      <D.23905>:
      mono_mb_emit_byte (mb, 20);
      i = 0;
      goto <D.20048>;
      <D.20047>:
      D.23883 = i + 1;
      D.23884 = (unsigned int) D.23883;
      mono_mb_emit_ldarg (mb, D.23884);
      i = i + 1;
      <D.20048>:
      D.23783 = sig->param_count;
      D.23794 = (int) D.23783;
      if (D.23794 > i) goto <D.20047>; else goto <D.20049>;
      <D.20049>:
      mono_mb_emit_op (mb, 40, target_method);
      <D.23906>:
      goto <D.23907>;
      <D.23903>:
      if (static_method_with_first_arg_bound != 0) goto <D.23908>; else goto <D.23909>;
      <D.23908>:
      local_target.118 = (unsigned int) local_target;
      mono_mb_emit_ldloc (mb, local_target.118);
      D.23910 = invoke_sig->params[0];
      D.23911 = mono_type_is_reference (D.23910);
      if (D.23911 == 0) goto <D.23912>; else goto <D.23913>;
      <D.23912>:
      D.23910 = invoke_sig->params[0];
      D.23914 = mono_class_from_mono_type (D.23910);
      mono_mb_emit_op (mb, 165, D.23914);
      <D.23913>:
      <D.23909>:
      i = 0;
      goto <D.20051>;
      <D.20050>:
      D.23883 = i + 1;
      D.23884 = (unsigned int) D.23883;
      mono_mb_emit_ldarg (mb, D.23884);
      i = i + 1;
      <D.20051>:
      D.23783 = sig->param_count;
      D.23794 = (int) D.23783;
      if (D.23794 > i) goto <D.20050>; else goto <D.20052>;
      <D.20052>:
      mono_mb_emit_ldarg (mb, 0);
      mono_mb_emit_ldflda (mb, 16);
      mono_mb_emit_byte (mb, 77);
      mono_mb_emit_op (mb, 41, invoke_sig);
      <D.23907>:
      mono_mb_emit_byte (mb, 42);
      mb->skip_visibility = 1;
      if (ctx != 0B) goto <D.23915>; else goto <D.23916>;
      <D.23915>:
      {
        struct MonoMethod * def;

        D.23770 = method->klass;
        D.23783 = sig->param_count;
        D.23794 = (int) D.23783;
        D.23917 = D.23794 + 16;
        def = mono_mb_create_and_cache (cache, D.23770, mb, sig, D.23917);
        res = cache_generic_delegate_wrapper (cache, orig_method, def, ctx);
      }
      goto <D.23918>;
      <D.23916>:
      if (static_method_with_first_arg_bound != 0) goto <D.23919>; else goto <D.23920>;
      <D.23919>:
      D.23783 = sig->param_count;
      D.23794 = (int) D.23783;
      D.23917 = D.23794 + 16;
      res = mono_mb_create_and_cache (cache, invoke_sig, mb, sig, D.23917);
      info = mono_wrapper_info_create (res, 23);
      mono_marshal_set_wrapper_info (res, info);
      goto <D.23921>;
      <D.23920>:
      if (callvirt != 0) goto <D.23922>; else goto <D.23923>;
      <D.23922>:
      D.23783 = sig->param_count;
      D.23794 = (int) D.23783;
      D.23917 = D.23794 + 16;
      newm = mono_mb_create_method (mb, sig, D.23917);
      mono_memory_barrier ();
      {
        int ret;

        ret = pthread_mutex_lock (&marshal_mutex.mutex);
        if (ret != 0) goto <D.23924>; else goto <D.23925>;
        <D.23924>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.23925>:
        D.23926 = ret != 0;
        D.23927 = (long int) D.23926;
        D.23928 = __builtin_expect (D.23927, 0);
        if (D.23928 != 0) goto <D.23929>; else goto <D.23930>;
        <D.23929>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 4432, "ret == 0");
        <D.23930>:
      }
      res = monoeg_g_hash_table_lookup (cache, &key);
      if (res == 0B) goto <D.23931>; else goto <D.23932>;
      <D.23931>:
      res = newm;
      new_key = monoeg_malloc0 (16);
      *new_key = key;
      if (static_method_with_first_arg_bound != 0) goto <D.23933>; else goto <D.23934>;
      <D.23933>:
      D.23742 = del->method;
      D.23935 = D.23742->klass;
      D.23936 = D.23935->image;
      D.23937 = key.sig;
      D.23938 = signature_dup (D.23936, D.23937);
      new_key->sig = D.23938;
      <D.23934>:
      monoeg_g_hash_table_insert_replace (cache, new_key, res, 0);
      info = mono_wrapper_info_create (res, 22);
      mono_marshal_set_wrapper_info (res, info);
      {
        int ret;

        ret = pthread_mutex_unlock (&marshal_mutex.mutex);
        if (ret != 0) goto <D.23939>; else goto <D.23940>;
        <D.23939>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.23940>:
        D.23941 = ret != 0;
        D.23942 = (long int) D.23941;
        D.23943 = __builtin_expect (D.23942, 0);
        if (D.23943 != 0) goto <D.23944>; else goto <D.23945>;
        <D.23944>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 4445, "ret == 0");
        <D.23945>:
      }
      goto <D.23946>;
      <D.23932>:
      {
        int ret;

        ret = pthread_mutex_unlock (&marshal_mutex.mutex);
        if (ret != 0) goto <D.23947>; else goto <D.23948>;
        <D.23947>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.23948>:
        D.23949 = ret != 0;
        D.23950 = (long int) D.23949;
        D.23951 = __builtin_expect (D.23950, 0);
        if (D.23951 != 0) goto <D.23952>; else goto <D.23953>;
        <D.23952>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 4447, "ret == 0");
        <D.23953>:
      }
      mono_free_method (newm);
      <D.23946>:
      goto <D.23954>;
      <D.23923>:
      D.23783 = sig->param_count;
      D.23794 = (int) D.23783;
      D.23917 = D.23794 + 16;
      res = mono_mb_create_and_cache (cache, sig, mb, sig, D.23917);
      info = mono_wrapper_info_create (res, 0);
      mono_marshal_set_wrapper_info (res, info);
      <D.23954>:
      <D.23921>:
      <D.23918>:
      mono_mb_free (mb);
      D.23829 = res;
      return D.23829;
    }
  finally
    {
      key = {CLOBBER};
    }
}


free_signature_method_pair (struct SignatureMethodPair * pair)
{
  monoeg_g_free (pair);
}


signature_method_pair_equal (struct SignatureMethodPair * pair1, struct SignatureMethodPair * pair2)
{
  gboolean D.23957;
  int iftmp.119;
  struct MonoMethodSignature * D.23961;
  struct MonoMethodSignature * D.23962;
  int D.23963;
  struct MonoMethod * D.23965;
  struct MonoMethod * D.23966;

  D.23961 = pair1->sig;
  D.23962 = pair2->sig;
  D.23963 = mono_metadata_signature_equal (D.23961, D.23962);
  if (D.23963 != 0) goto <D.23964>; else goto <D.23959>;
  <D.23964>:
  D.23965 = pair1->method;
  D.23966 = pair2->method;
  if (D.23965 == D.23966) goto <D.23967>; else goto <D.23959>;
  <D.23967>:
  iftmp.119 = 1;
  goto <D.23960>;
  <D.23959>:
  iftmp.119 = 0;
  <D.23960>:
  D.23957 = iftmp.119;
  return D.23957;
}


signature_method_pair_hash (const void * data)
{
  guint D.23969;
  struct MonoMethodSignature * D.23970;
  unsigned int D.23971;
  struct MonoMethod * D.23972;
  unsigned int D.23973;
  struct SignatureMethodPair * pair;

  pair = data;
  D.23970 = pair->sig;
  D.23971 = mono_signature_hash (D.23970);
  D.23972 = pair->method;
  D.23973 = mono_aligned_addr_hash (D.23972);
  D.23969 = D.23971 ^ D.23973;
  return D.23969;
}


mono_wrapper_info_create (struct MonoMethod * wrapper, WrapperSubtype subtype)
{
  struct MonoClass * D.23975;
  struct MonoImage * D.23976;
  struct WrapperInfo * D.23977;
  struct WrapperInfo * info;

  D.23975 = wrapper->klass;
  D.23976 = D.23975->image;
  info = mono_image_alloc0 (D.23976, 24);
  info->subtype = subtype;
  D.23977 = info;
  return D.23977;
}


__attribute__((visibility ("hidden")))
mono_marshal_get_string_ctor_signature (struct MonoMethod * method)
{
  struct MonoMethodSignature * D.23979;
  struct MonoMethodSignature * D.23982;
  struct MonoMethodSignature * sig;

  D.23979 = mono_method_signature (method);
  sig = lookup_string_ctor_signature (D.23979);
  if (sig == 0B) goto <D.23980>; else goto <D.23981>;
  <D.23980>:
  sig = add_string_ctor_signature (method);
  <D.23981>:
  D.23982 = sig;
  return D.23982;
}


lookup_string_ctor_signature (struct MonoMethodSignature * sig)
{
  _Bool D.23986;
  long int D.23987;
  long int D.23988;
  struct MonoMethodSignature * D.23991;
  int D.23992;
  _Bool D.23997;
  long int D.23998;
  long int D.23999;
  struct MonoMethodSignature * D.24002;
  struct MonoMethodSignature * callsig;
  struct CtorSigPair * cs;
  struct GSList * item;

  {
    int ret;

    ret = pthread_mutex_lock (&marshal_mutex.mutex);
    if (ret != 0) goto <D.23984>; else goto <D.23985>;
    <D.23984>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.23985>:
    D.23986 = ret != 0;
    D.23987 = (long int) D.23986;
    D.23988 = __builtin_expect (D.23987, 0);
    if (D.23988 != 0) goto <D.23989>; else goto <D.23990>;
    <D.23989>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 4498, "ret == 0");
    <D.23990>:
  }
  callsig = 0B;
  item = strsig_list;
  goto <D.20081>;
  <D.20080>:
  cs = item->data;
  D.23991 = cs->ctor_sig;
  D.23992 = mono_metadata_signature_equal (sig, D.23991);
  if (D.23992 != 0) goto <D.23993>; else goto <D.23994>;
  <D.23993>:
  callsig = cs->sig;
  goto <D.20079>;
  <D.23994>:
  item = item->next;
  <D.20081>:
  if (item != 0B) goto <D.20080>; else goto <D.20079>;
  <D.20079>:
  {
    int ret;

    ret = pthread_mutex_unlock (&marshal_mutex.mutex);
    if (ret != 0) goto <D.23995>; else goto <D.23996>;
    <D.23995>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.23996>:
    D.23997 = ret != 0;
    D.23998 = (long int) D.23997;
    D.23999 = __builtin_expect (D.23998, 0);
    if (D.23999 != 0) goto <D.24000>; else goto <D.24001>;
    <D.24000>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 4510, "ret == 0");
    <D.24001>:
  }
  D.24002 = callsig;
  return D.24002;
}


add_string_ctor_signature (struct MonoMethod * method)
{
  struct MonoClass * D.24004;
  struct MonoImage * D.24005;
  struct MonoMethodSignature * D.24006;
  struct MonoClass * D.24007;
  struct MonoType * D.24008;
  struct MonoMethodSignature * D.24009;
  _Bool D.24012;
  long int D.24013;
  long int D.24014;
  struct GSList * strsig_list.120;
  struct GSList * D.24018;
  _Bool D.24021;
  long int D.24022;
  long int D.24023;
  struct MonoMethodSignature * D.24026;
  struct MonoMethodSignature * callsig;
  struct CtorSigPair * cs;

  D.24004 = method->klass;
  D.24005 = D.24004->image;
  D.24006 = mono_method_signature (method);
  callsig = signature_dup (D.24005, D.24006);
  D.24007 = mono_defaults.string_class;
  D.24008 = &D.24007->byval_arg;
  callsig->ret = D.24008;
  cs = monoeg_malloc (16);
  cs->sig = callsig;
  D.24009 = mono_method_signature (method);
  cs->ctor_sig = D.24009;
  {
    int ret;

    ret = pthread_mutex_lock (&marshal_mutex.mutex);
    if (ret != 0) goto <D.24010>; else goto <D.24011>;
    <D.24010>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.24011>:
    D.24012 = ret != 0;
    D.24013 = (long int) D.24012;
    D.24014 = __builtin_expect (D.24013, 0);
    if (D.24014 != 0) goto <D.24015>; else goto <D.24016>;
    <D.24015>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 4526, "ret == 0");
    <D.24016>:
  }
  strsig_list.120 = strsig_list;
  D.24018 = monoeg_g_slist_prepend (strsig_list.120, cs);
  strsig_list = D.24018;
  {
    int ret;

    ret = pthread_mutex_unlock (&marshal_mutex.mutex);
    if (ret != 0) goto <D.24019>; else goto <D.24020>;
    <D.24019>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.24020>:
    D.24021 = ret != 0;
    D.24022 = (long int) D.24021;
    D.24023 = __builtin_expect (D.24022, 0);
    if (D.24023 != 0) goto <D.24024>; else goto <D.24025>;
    <D.24024>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 4528, "ret == 0");
    <D.24025>:
  }
  D.24026 = callsig;
  return D.24026;
}


__attribute__((visibility ("hidden")))
mono_marshal_get_runtime_invoke (struct MonoMethod * method, gboolean virtual)
{
  _Bool D.24028;
  long int D.24029;
  long int D.24030;
  struct MonoMethodSignature * cctor_signature.121;
  struct MonoImage * D.24036;
  struct MonoMethodSignature * cctor_signature.122;
  struct MonoClass * D.24038;
  struct MonoType * D.24039;
  struct MonoMethodSignature * finalize_signature.123;
  struct MonoMethodSignature * finalize_signature.124;
  struct MonoClass * D.24048;
  struct MonoImage * D.24049;
  struct GHashTable * * D.24050;
  struct GHashTable * * D.24052;
  struct MonoMethod * D.24055;
  unsigned char D.24056;
  short unsigned int D.24059;
  unsigned int D.24060;
  unsigned int D.24061;
  long unsigned int D.24064;
  long unsigned int D.24065;
  struct MonoMethodSignature * D.24068;
  long unsigned int D.24072;
  struct MonoMethodSignature * D.24075;
  int D.24077;
  int D.24081;
  long unsigned int D.24089;
  long unsigned int D.24090;
  struct MonoMethodSignature * D.24092;
  long unsigned int D.24093;
  long unsigned int D.24094;
  struct MonoImage * D.24096;
  struct GHashTable * * D.24097;
  struct GHashTable * * D.24098;
  _Bool D.24101;
  long int D.24102;
  long int D.24103;
  _Bool D.24108;
  long int D.24109;
  long int D.24110;
  struct MonoClass * D.24115;
  struct MonoType * D.24116;
  struct MonoMethodSignature * D.24120;
  long unsigned int D.24121;
  long unsigned int D.24122;
  struct MonoType * D.24124;
  struct MonoType * D.24125;
  struct MonoClass * D.24126;
  struct MonoType * D.24127;
  const char * iftmp.125;
  short unsigned int D.24134;
  int D.24135;
  int D.24136;
  WrapperSubtype iftmp.126;
  _Bool D.24144;
  long int D.24145;
  long int D.24146;
  _Bool D.24151;
  long int D.24152;
  long int D.24153;
  _Bool D.24160;
  long int D.24161;
  long int D.24162;
  struct GHashTable * D.24167;
  _Bool D.24171;
  long int D.24172;
  long int D.24173;
  struct MonoMethodSignature * sig;
  struct MonoMethodSignature * csig;
  struct MonoMethodSignature * callsig;
  struct MonoMethodBuilder * mb;
  struct GHashTable * cache;
  struct MonoClass * target_klass;
  struct MonoMethod * res;
  static struct MonoMethodSignature * cctor_signature = 0B;
  static struct MonoMethodSignature * finalize_signature = 0B;
  char * name;
  const char * param_names[16];
  gboolean need_direct_wrapper;
  struct WrapperInfo * info;

  try
    {
      cache = 0B;
      res = 0B;
      need_direct_wrapper = 0;
      D.24028 = method == 0B;
      D.24029 = (long int) D.24028;
      D.24030 = __builtin_expect (D.24029, 0);
      if (D.24030 != 0) goto <D.24031>; else goto <D.24032>;
      <D.24031>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 4932, "method");
      <D.24032>:
      cctor_signature.121 = cctor_signature;
      if (cctor_signature.121 == 0B) goto <D.24034>; else goto <D.24035>;
      <D.24034>:
      D.24036 = mono_defaults.corlib;
      cctor_signature.122 = mono_metadata_signature_alloc (D.24036, 0);
      cctor_signature = cctor_signature.122;
      cctor_signature.121 = cctor_signature;
      D.24038 = mono_defaults.void_class;
      D.24039 = &D.24038->byval_arg;
      cctor_signature.121->ret = D.24039;
      <D.24035>:
      finalize_signature.123 = finalize_signature;
      if (finalize_signature.123 == 0B) goto <D.24041>; else goto <D.24042>;
      <D.24041>:
      D.24036 = mono_defaults.corlib;
      finalize_signature.124 = mono_metadata_signature_alloc (D.24036, 0);
      finalize_signature = finalize_signature.124;
      finalize_signature.123 = finalize_signature;
      D.24038 = mono_defaults.void_class;
      D.24039 = &D.24038->byval_arg;
      finalize_signature.123->ret = D.24039;
      finalize_signature.123 = finalize_signature;
      finalize_signature.123->hasthis = 1;
      <D.24042>:
      if (virtual != 0) goto <D.24044>; else goto <D.24045>;
      <D.24044>:
      need_direct_wrapper = 1;
      <D.24045>:
      if (virtual != 0) goto <D.24046>; else goto <D.24047>;
      <D.24046>:
      D.24048 = method->klass;
      D.24049 = D.24048->image;
      D.24050 = &D.24049->runtime_invoke_vcall_cache;
      cache = get_cache (D.24050, mono_aligned_addr_hash, 0B);
      goto <D.24051>;
      <D.24047>:
      D.24048 = method->klass;
      D.24049 = D.24048->image;
      D.24052 = &D.24049->runtime_invoke_direct_cache;
      cache = get_cache (D.24052, mono_aligned_addr_hash, 0B);
      <D.24051>:
      res = mono_marshal_find_in_cache (cache, method);
      if (res != 0B) goto <D.24053>; else goto <D.24054>;
      <D.24053>:
      D.24055 = res;
      return D.24055;
      <D.24054>:
      D.24048 = method->klass;
      D.24056 = D.24048->rank;
      if (D.24056 != 0) goto <D.24057>; else goto <D.24058>;
      <D.24057>:
      D.24059 = method->iflags;
      D.24060 = (unsigned int) D.24059;
      D.24061 = D.24060 & 4097;
      if (D.24061 == 4097) goto <D.24062>; else goto <D.24063>;
      <D.24062>:
      need_direct_wrapper = 1;
      <D.24063>:
      <D.24058>:
      D.24064 = BIT_FIELD_REF <*method, 64, 256>;
      D.24065 = D.24064 & 72057594037927936;
      if (D.24065 != 0) goto <D.24066>; else goto <D.24067>;
      <D.24066>:
      D.24068 = mono_method_signature (method);
      callsig = lookup_string_ctor_signature (D.24068);
      if (callsig == 0B) goto <D.24069>; else goto <D.24070>;
      <D.24069>:
      callsig = add_string_ctor_signature (method);
      <D.24070>:
      need_direct_wrapper = 1;
      goto <D.24071>;
      <D.24067>:
      D.24064 = BIT_FIELD_REF <*method, 64, 256>;
      D.24072 = D.24064 & 18014398509481984;
      if (D.24072 != 0) goto <D.24073>; else goto <D.24074>;
      <D.24073>:
      D.24048 = method->klass;
      D.24049 = D.24048->image;
      D.24075 = mono_method_signature (method);
      callsig = signature_dup (D.24049, D.24075);
      goto <D.24076>;
      <D.24074>:
      callsig = mono_method_signature (method);
      <D.24076>:
      <D.24071>:
      D.24048 = method->klass;
      D.24049 = D.24048->image;
      target_klass = get_wrapper_target_class (D.24049);
      cctor_signature.121 = cctor_signature;
      D.24077 = mono_metadata_signature_equal (callsig, cctor_signature.121);
      if (D.24077 != 0) goto <D.24078>; else goto <D.24079>;
      <D.24078>:
      callsig = cctor_signature;
      target_klass = mono_defaults.object_class;
      goto <D.24080>;
      <D.24079>:
      finalize_signature.123 = finalize_signature;
      D.24081 = mono_metadata_signature_equal (callsig, finalize_signature.123);
      if (D.24081 != 0) goto <D.24082>; else goto <D.24083>;
      <D.24082>:
      callsig = finalize_signature;
      target_klass = mono_defaults.object_class;
      <D.24083>:
      <D.24080>:
      if (need_direct_wrapper != 0) goto <D.24084>; else goto <D.24085>;
      <D.24084>:
      goto <D.24086>;
      <D.24085>:
      {
        struct MonoMethodSignature * tmp_sig;

        callsig = mono_marshal_get_runtime_invoke_sig (callsig);
        D.24048 = method->klass;
        D.24089 = BIT_FIELD_REF <*D.24048, 64, 256>;
        D.24090 = D.24089 & 1152921504606846976;
        if (D.24090 != 0) goto <D.24091>; else goto <D.24087>;
        <D.24091>:
        D.24092 = mono_method_signature (method);
        D.24093 = BIT_FIELD_REF <*D.24092, 64, 64>;
        D.24094 = D.24093 & 512;
        if (D.24094 != 0) goto <D.24095>; else goto <D.24087>;
        <D.24095>:
        D.24096 = target_klass->image;
        D.24097 = &D.24096->runtime_invoke_vtype_cache;
        cache = get_cache (D.24097, mono_signature_hash, runtime_invoke_signature_equal);
        goto <D.24088>;
        <D.24087>:
        D.24096 = target_klass->image;
        D.24098 = &D.24096->runtime_invoke_cache;
        cache = get_cache (D.24098, mono_signature_hash, runtime_invoke_signature_equal);
        <D.24088>:
        {
          int ret;

          ret = pthread_mutex_lock (&marshal_mutex.mutex);
          if (ret != 0) goto <D.24099>; else goto <D.24100>;
          <D.24099>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.24100>:
          D.24101 = ret != 0;
          D.24102 = (long int) D.24101;
          D.24103 = __builtin_expect (D.24102, 0);
          if (D.24103 != 0) goto <D.24104>; else goto <D.24105>;
          <D.24104>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 5010, "ret == 0");
          <D.24105>:
        }
        res = monoeg_g_hash_table_lookup (cache, callsig);
        {
          int ret;

          ret = pthread_mutex_unlock (&marshal_mutex.mutex);
          if (ret != 0) goto <D.24106>; else goto <D.24107>;
          <D.24106>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.24107>:
          D.24108 = ret != 0;
          D.24109 = (long int) D.24108;
          D.24110 = __builtin_expect (D.24109, 0);
          if (D.24110 != 0) goto <D.24111>; else goto <D.24112>;
          <D.24111>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 5012, "ret == 0");
          <D.24112>:
        }
        if (res != 0B) goto <D.24113>; else goto <D.24114>;
        <D.24113>:
        monoeg_g_free (callsig);
        D.24055 = res;
        return D.24055;
        <D.24114>:
        tmp_sig = callsig;
        D.24096 = target_klass->image;
        callsig = mono_metadata_signature_dup_full (D.24096, callsig);
        monoeg_g_free (tmp_sig);
      }
      <D.24086>:
      sig = mono_method_signature (method);
      D.24096 = target_klass->image;
      csig = mono_metadata_signature_alloc (D.24096, 4);
      D.24115 = mono_defaults.object_class;
      D.24116 = &D.24115->byval_arg;
      csig->ret = D.24116;
      D.24048 = method->klass;
      D.24089 = BIT_FIELD_REF <*D.24048, 64, 256>;
      D.24090 = D.24089 & 1152921504606846976;
      if (D.24090 != 0) goto <D.24119>; else goto <D.24117>;
      <D.24119>:
      D.24120 = mono_method_signature (method);
      D.24121 = BIT_FIELD_REF <*D.24120, 64, 64>;
      D.24122 = D.24121 & 512;
      if (D.24122 != 0) goto <D.24123>; else goto <D.24117>;
      <D.24123>:
      D.24048 = method->klass;
      D.24124 = &D.24048->this_arg;
      D.24125 = get_runtime_invoke_type (D.24124, 0);
      csig->params[0] = D.24125;
      goto <D.24118>;
      <D.24117>:
      D.24115 = mono_defaults.object_class;
      D.24116 = &D.24115->byval_arg;
      csig->params[0] = D.24116;
      <D.24118>:
      D.24126 = mono_defaults.int_class;
      D.24127 = &D.24126->byval_arg;
      csig->params[1] = D.24127;
      D.24126 = mono_defaults.int_class;
      D.24127 = &D.24126->byval_arg;
      csig->params[2] = D.24127;
      D.24126 = mono_defaults.int_class;
      D.24127 = &D.24126->byval_arg;
      csig->params[3] = D.24127;
      csig->pinvoke = 1;
      if (virtual != 0) goto <D.24129>; else goto <D.24130>;
      <D.24129>:
      iftmp.125 = "runtime_invoke_virtual";
      goto <D.24131>;
      <D.24130>:
      iftmp.125 = "runtime_invoke";
      <D.24131>:
      name = mono_signature_to_name (callsig, iftmp.125);
      mb = mono_mb_new (target_klass, name, 4);
      monoeg_g_free (name);
      param_names[0] = "this";
      param_names[1] = "params";
      param_names[2] = "exc";
      param_names[3] = "method";
      mono_mb_set_param_names (mb, &param_names);
      emit_runtime_invoke_body (mb, target_klass, method, sig, callsig, virtual, need_direct_wrapper);
      if (need_direct_wrapper != 0) goto <D.24132>; else goto <D.24133>;
      <D.24132>:
      mb->skip_visibility = 1;
      D.24134 = sig->param_count;
      D.24135 = (int) D.24134;
      D.24136 = D.24135 + 16;
      res = mono_mb_create_and_cache (cache, method, mb, csig, D.24136);
      if (virtual != 0) goto <D.24138>; else goto <D.24139>;
      <D.24138>:
      iftmp.126 = 14;
      goto <D.24140>;
      <D.24139>:
      iftmp.126 = 13;
      <D.24140>:
      info = mono_wrapper_info_create (res, iftmp.126);
      info->d.runtime_invoke.method = method;
      mono_marshal_set_wrapper_info (res, info);
      goto <D.24141>;
      <D.24133>:
      {
        int ret;

        ret = pthread_mutex_lock (&marshal_mutex.mutex);
        if (ret != 0) goto <D.24142>; else goto <D.24143>;
        <D.24142>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.24143>:
        D.24144 = ret != 0;
        D.24145 = (long int) D.24144;
        D.24146 = __builtin_expect (D.24145, 0);
        if (D.24146 != 0) goto <D.24147>; else goto <D.24148>;
        <D.24147>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 5067, "ret == 0");
        <D.24148>:
      }
      res = monoeg_g_hash_table_lookup (cache, callsig);
      {
        int ret;

        ret = pthread_mutex_unlock (&marshal_mutex.mutex);
        if (ret != 0) goto <D.24149>; else goto <D.24150>;
        <D.24149>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.24150>:
        D.24151 = ret != 0;
        D.24152 = (long int) D.24151;
        D.24153 = __builtin_expect (D.24152, 0);
        if (D.24153 != 0) goto <D.24154>; else goto <D.24155>;
        <D.24154>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 5069, "ret == 0");
        <D.24155>:
      }
      if (res == 0B) goto <D.24156>; else goto <D.24157>;
      <D.24156>:
      {
        struct MonoMethod * newm;

        D.24134 = sig->param_count;
        D.24135 = (int) D.24134;
        D.24136 = D.24135 + 16;
        newm = mono_mb_create_method (mb, csig, D.24136);
        {
          int ret;

          ret = pthread_mutex_lock (&marshal_mutex.mutex);
          if (ret != 0) goto <D.24158>; else goto <D.24159>;
          <D.24158>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
          <D.24159>:
          D.24160 = ret != 0;
          D.24161 = (long int) D.24160;
          D.24162 = __builtin_expect (D.24161, 0);
          if (D.24162 != 0) goto <D.24163>; else goto <D.24164>;
          <D.24163>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 5076, "ret == 0");
          <D.24164>:
        }
        res = monoeg_g_hash_table_lookup (cache, callsig);
        if (res == 0B) goto <D.24165>; else goto <D.24166>;
        <D.24165>:
        res = newm;
        monoeg_g_hash_table_insert_replace (cache, callsig, res, 0);
        D.24048 = method->klass;
        D.24049 = D.24048->image;
        D.24167 = D.24049->runtime_invoke_direct_cache;
        monoeg_g_hash_table_insert_replace (D.24167, method, res, 0);
        info = mono_wrapper_info_create (res, 11);
        info->d.runtime_invoke.sig = callsig;
        mono_marshal_set_wrapper_info (res, info);
        goto <D.24168>;
        <D.24166>:
        mono_free_method (newm);
        <D.24168>:
        {
          int ret;

          ret = pthread_mutex_unlock (&marshal_mutex.mutex);
          if (ret != 0) goto <D.24169>; else goto <D.24170>;
          <D.24169>:
          monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
          <D.24170>:
          D.24171 = ret != 0;
          D.24172 = (long int) D.24171;
          D.24173 = __builtin_expect (D.24172, 0);
          if (D.24173 != 0) goto <D.24174>; else goto <D.24175>;
          <D.24174>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 5089, "ret == 0");
          <D.24175>:
        }
      }
      <D.24157>:
      <D.24141>:
      mono_mb_free (mb);
      D.24055 = res;
      return D.24055;
    }
  finally
    {
      param_names = {CLOBBER};
    }
}


runtime_invoke_signature_equal (struct MonoMethodSignature * sig1, struct MonoMethodSignature * sig2)
{
  struct MonoType * D.24180;
  struct MonoType * D.24181;
  int D.24183;
  int D.24185;
  int D.24186;
  gboolean D.24188;

  D.24180 = sig1->ret;
  D.24181 = sig2->ret;
  if (D.24180 != D.24181) goto <D.24182>; else goto <D.24178>;
  <D.24182>:
  D.24180 = sig1->ret;
  D.24183 = mono_type_is_reference (D.24180);
  if (D.24183 == 0) goto <D.24179>; else goto <D.24184>;
  <D.24184>:
  D.24181 = sig2->ret;
  D.24185 = mono_type_is_reference (D.24181);
  if (D.24185 == 0) goto <D.24179>; else goto <D.24178>;
  <D.24179>:
  D.24180 = sig1->ret;
  D.24181 = sig2->ret;
  D.24186 = mono_metadata_type_equal (D.24180, D.24181);
  if (D.24186 == 0) goto <D.24187>; else goto <D.24178>;
  <D.24187>:
  D.24188 = 0;
  return D.24188;
  <D.24178>:
  D.24188 = mono_metadata_signature_equal (sig1, sig2);
  return D.24188;
}


mono_marshal_get_runtime_invoke_sig (struct MonoMethodSignature * sig)
{
  struct MonoType * D.24190;
  struct MonoType * D.24191;
  struct MonoType * D.24192;
  struct MonoType * D.24193;
  short unsigned int D.24194;
  int D.24195;
  struct MonoMethodSignature * D.24196;
  struct MonoMethodSignature * res;
  int i;

  res = mono_metadata_signature_dup (sig);
  D.24190 = sig->ret;
  D.24191 = get_runtime_invoke_type (D.24190, 1);
  res->ret = D.24191;
  i = 0;
  goto <D.20112>;
  <D.20111>:
  D.24192 = sig->params[i];
  D.24193 = get_runtime_invoke_type (D.24192, 0);
  res->params[i] = D.24193;
  i = i + 1;
  <D.20112>:
  D.24194 = res->param_count;
  D.24195 = (int) D.24194;
  if (D.24195 > i) goto <D.20111>; else goto <D.20113>;
  <D.20113>:
  D.24196 = res;
  return D.24196;
}


get_runtime_invoke_type (struct MonoType * t, gboolean ret)
{
  long unsigned int D.24198;
  long unsigned int D.24199;
  unsigned char D.24202;
  struct MonoClass * D.24205;
  int D.24206;
  struct MonoType * D.24209;
  struct MonoClass * D.24210;
  int D.24211;
  struct MonoClass * D.24214;
  int D.24217;
  struct MonoClass * D.24218;
  struct MonoClass * D.24219;
  struct MonoClass * D.24220;
  struct MonoClass * D.24221;
  long unsigned int D.24222;
  long unsigned int D.24223;
  void handle_enum = <<< error >>>;

  D.24198 = BIT_FIELD_REF <*t, 64, 64>;
  D.24199 = D.24198 & 8589934592;
  if (D.24199 != 0) goto <D.24200>; else goto <D.24201>;
  <D.24200>:
  D.24202 = t->type;
  if (D.24202 == 21) goto <D.24203>; else goto <D.24204>;
  <D.24203>:
  D.24205 = mono_class_from_mono_type (t);
  D.24206 = mono_class_is_nullable (D.24205);
  if (D.24206 != 0) goto <D.24207>; else goto <D.24208>;
  <D.24207>:
  D.24209 = t;
  return D.24209;
  <D.24208>:
  <D.24204>:
  D.24210 = mono_defaults.int_class;
  D.24209 = &D.24210->this_arg;
  return D.24209;
  <D.24201>:
  D.24211 = mono_type_is_reference (t);
  if (D.24211 != 0) goto <D.24212>; else goto <D.24213>;
  <D.24212>:
  D.24214 = mono_defaults.object_class;
  D.24209 = &D.24214->byval_arg;
  return D.24209;
  <D.24213>:
  if (ret != 0) goto <D.24215>; else goto <D.24216>;
  <D.24215>:
  D.24209 = t;
  return D.24209;
  <D.24216>:
  handle_enum:
  D.24202 = t->type;
  D.24217 = (int) D.24202;
  switch (D.24217) <default: <D.20105>, case 2: <D.20100>, case 3: <D.20101>, case 11: <D.20099>, case 15: <D.20103>, case 17: <D.20104>, case 25: <D.20102>>
  <D.20099>:
  D.24218 = mono_defaults.int64_class;
  D.24209 = &D.24218->byval_arg;
  return D.24209;
  <D.20100>:
  D.24219 = mono_defaults.byte_class;
  D.24209 = &D.24219->byval_arg;
  return D.24209;
  <D.20101>:
  D.24220 = mono_defaults.uint16_class;
  D.24209 = &D.24220->byval_arg;
  return D.24209;
  <D.20102>:
  <D.20103>:
  D.24210 = mono_defaults.int_class;
  D.24209 = &D.24210->byval_arg;
  return D.24209;
  <D.20104>:
  D.24221 = t->data.klass;
  D.24222 = BIT_FIELD_REF <*D.24221, 64, 256>;
  D.24223 = D.24222 & 576460752303423488;
  if (D.24223 != 0) goto <D.24224>; else goto <D.24225>;
  <D.24224>:
  D.24221 = t->data.klass;
  t = mono_class_enum_basetype (D.24221);
  goto handle_enum;
  <D.24225>:
  D.24209 = t;
  return D.24209;
  <D.20105>:
  D.24209 = t;
  return D.24209;
}


emit_runtime_invoke_body (struct MonoMethodBuilder * mb, struct MonoClass * target_klass, struct MonoMethod * method, struct MonoMethodSignature * sig, struct MonoMethodSignature * callsig, gboolean virtual, gboolean need_direct_wrapper)
{
  struct MonoClass * D.24227;
  struct MonoType * D.24228;
  unsigned int D.24229;
  int D.24230;
  int D.24231;
  unsigned int D.24232;
  int D.24233;
  struct MonoImage * D.24234;
  struct MonoClass * D.24235;
  int D.24236;
  unsigned int D.24237;
  int D.24238;
  int D.24239;
  unsigned int D.24240;
  int D.24241;
  unsigned int D.24242;
  unsigned int loc_exc.127;
  int D.24244;
  unsigned int D.24245;
  unsigned int D.24246;
  unsigned int D.24247;
  int D.24248;
  unsigned int D.24249;
  unsigned int loc_res.128;
  int D.24251;
  unsigned int D.24252;
  gint32 labels[16];
  struct MonoExceptionClause * clause;
  int loc_res;
  int loc_exc;

  try
    {
      D.24227 = mono_defaults.object_class;
      D.24228 = &D.24227->byval_arg;
      loc_res = mono_mb_add_local (mb, D.24228);
      D.24227 = mono_defaults.object_class;
      D.24228 = &D.24227->byval_arg;
      loc_exc = mono_mb_add_local (mb, D.24228);
      mono_mb_emit_byte (mb, 4);
      D.24229 = mono_mb_emit_branch (mb, 57);
      D.24230 = (int) D.24229;
      labels[0] = D.24230;
      D.24231 = mono_mb_get_label (mb);
      labels[1] = D.24231;
      emit_thread_force_interrupt_checkpoint (mb);
      emit_invoke_call (mb, method, sig, callsig, loc_res, virtual, need_direct_wrapper);
      D.24232 = mono_mb_emit_branch (mb, 221);
      D.24233 = (int) D.24232;
      labels[2] = D.24233;
      D.24234 = target_klass->image;
      clause = mono_image_alloc0 (D.24234, 32);
      clause->flags = 0;
      D.24235 = mono_defaults.exception_class;
      clause->data.catch_class = D.24235;
      D.24236 = labels[1];
      D.24237 = (unsigned int) D.24236;
      clause->try_offset = D.24237;
      D.24238 = mono_mb_get_label (mb);
      D.24236 = labels[1];
      D.24239 = D.24238 - D.24236;
      D.24240 = (unsigned int) D.24239;
      clause->try_len = D.24240;
      D.24241 = mono_mb_get_label (mb);
      D.24242 = (unsigned int) D.24241;
      clause->handler_offset = D.24242;
      loc_exc.127 = (unsigned int) loc_exc;
      mono_mb_emit_stloc (mb, loc_exc.127);
      mono_mb_emit_byte (mb, 4);
      loc_exc.127 = (unsigned int) loc_exc;
      mono_mb_emit_ldloc (mb, loc_exc.127);
      mono_mb_emit_byte (mb, 81);
      mono_mb_emit_branch (mb, 221);
      D.24244 = mono_mb_get_pos (mb);
      D.24245 = (unsigned int) D.24244;
      D.24246 = clause->handler_offset;
      D.24247 = D.24245 - D.24246;
      clause->handler_len = D.24247;
      mono_mb_set_clauses (mb, 1, clause);
      D.24248 = labels[2];
      D.24249 = (unsigned int) D.24248;
      mono_mb_patch_branch (mb, D.24249);
      loc_res.128 = (unsigned int) loc_res;
      mono_mb_emit_ldloc (mb, loc_res.128);
      mono_mb_emit_byte (mb, 42);
      D.24251 = labels[0];
      D.24252 = (unsigned int) D.24251;
      mono_mb_patch_branch (mb, D.24252);
      emit_thread_force_interrupt_checkpoint (mb);
      emit_invoke_call (mb, method, sig, callsig, loc_res, virtual, need_direct_wrapper);
      mono_mb_emit_ldloc (mb, 0);
      mono_mb_emit_byte (mb, 42);
    }
  finally
    {
      labels = {CLOBBER};
    }
}


emit_invoke_call (struct MonoMethodBuilder * mb, struct MonoMethod * method, struct MonoMethodSignature * sig, struct MonoMethodSignature * callsig, int loc_res, gboolean virtual, gboolean need_direct_wrapper)
{
  struct MonoString * string_dummy.129;
  void * D.24258;
  struct MonoString * string_dummy.130;
  long unsigned int D.24262;
  long unsigned int D.24263;
  _Bool D.24264;
  long int D.24265;
  long int D.24266;
  short unsigned int D.24269;
  int D.24270;
  int D.24271;
  _Bool D.24272;
  long int D.24273;
  long int D.24274;
  long unsigned int D.24279;
  long unsigned int D.24280;
  int D.24283;
  short unsigned int D.24288;
  long unsigned int D.24289;
  long unsigned int D.24290;
  unsigned int i.131;
  unsigned int D.24294;
  int D.24295;
  long unsigned int D.24296;
  long unsigned int D.24297;
  unsigned char D.24300;
  struct MonoClass * D.24303;
  int D.24304;
  long unsigned int D.24307;
  long unsigned int D.24308;
  int * D.24309;
  struct MonoClass * D.24310;
  struct MonoType * D.24311;
  int D.24312;
  struct MonoClass * D.24313;
  int D.24314;
  unsigned int D.24315;
  struct MonoType * D.24316;
  unsigned char D.24317;
  unsigned int D.24318;
  unsigned char D.24319;
  unsigned int D.24320;
  unsigned char D.24321;
  int D.24322;
  unsigned int D.24325;
  unsigned char D.24326;
  struct MonoClass * D.24329;
  long unsigned int D.24330;
  long unsigned int D.24331;
  struct MonoType * D.24334;
  unsigned char D.24335;
  struct MonoClass * D.24336;
  int D.24337;
  struct MonoClass * D.24340;
  struct MonoClass * D.24341;
  struct MonoClass * D.24343;
  int D.24344;
  struct MonoType * D.24351;
  long unsigned int D.24352;
  long unsigned int D.24353;
  unsigned char D.24356;
  int D.24357;
  struct MonoClass * D.24360;
  struct MonoClass * D.24361;
  unsigned int loc_res.132;
  long unsigned int D.24365;
  long unsigned int D.24366;
  struct MonoClass * D.24369;
  int D.24370;
  struct MonoClass * D.24373;
  static struct MonoString * string_dummy = 0B;
  int i;
  int * tmp_nullable_locals;
  gboolean void_ret;
  void handle_enum = <<< error >>>;

  void_ret = 0;
  string_dummy.129 = string_dummy;
  if (string_dummy.129 == 0B) goto <D.24254>; else goto <D.24255>;
  <D.24254>:
  if (0 != 0) goto <D.24256>; else goto <D.24257>;
  <D.24256>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 4644, "sizeof (string_dummy) == sizeof (MonoObject*)");
  <D.24257>:
  D.24258 = mono_gc_make_root_descr_all_refs (1);
  mono_gc_register_root (&string_dummy, 8, D.24258);
  string_dummy.130 = mono_string_new_wrapper ("dummy");
  string_dummy = string_dummy.130;
  <D.24255>:
  if (virtual != 0) goto <D.24260>; else goto <D.24261>;
  <D.24260>:
  D.24262 = BIT_FIELD_REF <*sig, 64, 64>;
  D.24263 = D.24262 & 512;
  D.24264 = D.24263 == 0;
  D.24265 = (long int) D.24264;
  D.24266 = __builtin_expect (D.24265, 0);
  if (D.24266 != 0) goto <D.24267>; else goto <D.24268>;
  <D.24267>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 4649, "sig->hasthis");
  <D.24268>:
  D.24269 = method->flags;
  D.24270 = (int) D.24269;
  D.24271 = D.24270 & 64;
  D.24272 = D.24271 == 0;
  D.24273 = (long int) D.24272;
  D.24274 = __builtin_expect (D.24273, 0);
  if (D.24274 != 0) goto <D.24275>; else goto <D.24276>;
  <D.24275>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 4650, "method->flags & METHOD_ATTRIBUTE_VIRTUAL");
  <D.24276>:
  <D.24261>:
  D.24262 = BIT_FIELD_REF <*sig, 64, 64>;
  D.24263 = D.24262 & 512;
  if (D.24263 != 0) goto <D.24277>; else goto <D.24278>;
  <D.24277>:
  D.24279 = BIT_FIELD_REF <*method, 64, 256>;
  D.24280 = D.24279 & 72057594037927936;
  if (D.24280 != 0) goto <D.24281>; else goto <D.24282>;
  <D.24281>:
  D.24283 = mono_gc_is_moving ();
  if (D.24283 != 0) goto <D.24284>; else goto <D.24285>;
  <D.24284>:
  mono_mb_emit_ptr (mb, &string_dummy);
  mono_mb_emit_byte (mb, 80);
  goto <D.24286>;
  <D.24285>:
  string_dummy.129 = string_dummy;
  mono_mb_emit_ptr (mb, string_dummy.129);
  <D.24286>:
  goto <D.24287>;
  <D.24282>:
  mono_mb_emit_ldarg (mb, 0);
  <D.24287>:
  <D.24278>:
  D.24288 = sig->param_count;
  D.24289 = (long unsigned int) D.24288;
  D.24290 = D.24289 * 4;
  tmp_nullable_locals = monoeg_malloc0 (D.24290);
  i = 0;
  goto <D.20160>;
  <D.20159>:
  {
    struct MonoType * t;
    int type;

    t = sig->params[i];
    mono_mb_emit_ldarg (mb, 1);
    if (i != 0) goto <D.24291>; else goto <D.24292>;
    <D.24291>:
    i.131 = (unsigned int) i;
    D.24294 = i.131 * 8;
    D.24295 = (int) D.24294;
    mono_mb_emit_icon (mb, D.24295);
    mono_mb_emit_byte (mb, 88);
    <D.24292>:
    D.24296 = BIT_FIELD_REF <*t, 64, 64>;
    D.24297 = D.24296 & 8589934592;
    if (D.24297 != 0) goto <D.24298>; else goto <D.24299>;
    <D.24298>:
    mono_mb_emit_byte (mb, 77);
    D.24300 = t->type;
    if (D.24300 == 21) goto <D.24301>; else goto <D.24302>;
    <D.24301>:
    D.24303 = mono_class_from_mono_type (t);
    D.24304 = mono_class_is_nullable (D.24303);
    if (D.24304 != 0) goto <D.24305>; else goto <D.24306>;
    <D.24305>:
    D.24307 = (long unsigned int) i;
    D.24308 = D.24307 * 4;
    D.24309 = tmp_nullable_locals + D.24308;
    D.24310 = mono_class_from_mono_type (t);
    D.24311 = &D.24310->byval_arg;
    D.24312 = mono_mb_add_local (mb, D.24311);
    *D.24309 = D.24312;
    D.24313 = mono_class_from_mono_type (t);
    mono_mb_emit_op (mb, 165, D.24313);
    D.24307 = (long unsigned int) i;
    D.24308 = D.24307 * 4;
    D.24309 = tmp_nullable_locals + D.24308;
    D.24314 = *D.24309;
    D.24315 = (unsigned int) D.24314;
    mono_mb_emit_stloc (mb, D.24315);
    D.24307 = (long unsigned int) i;
    D.24308 = D.24307 * 4;
    D.24309 = tmp_nullable_locals + D.24308;
    D.24314 = *D.24309;
    D.24315 = (unsigned int) D.24314;
    mono_mb_emit_ldloc_addr (mb, D.24315);
    <D.24306>:
    <D.24302>:
    // predicted unlikely by continue predictor.
    goto <D.20133>;
    <D.24299>:
    D.24316 = sig->params[i];
    D.24317 = D.24316->type;
    type = (int) D.24317;
    handle_enum:
    switch (type) <default: <D.20158>, case 2: <D.20136>, case 3: <D.20140>, case 4: <D.20135>, case 5: <D.20137>, case 6: <D.20138>, case 7: <D.20139>, case 8: <D.20143>, case 9: <D.20144>, case 10: <D.20147>, case 11: <D.20148>, case 12: <D.20145>, case 13: <D.20146>, case 14: <D.20150>, case 15: <D.20153>, case 17: <D.20157>, case 18: <D.20151>, case 20: <D.20152>, case 21: <D.20156>, case 24: <D.20141>, case 25: <D.20142>, case 28: <D.20155>, case 29: <D.20154>>
    <D.20135>:
    <D.20136>:
    <D.20137>:
    <D.20138>:
    <D.20139>:
    <D.20140>:
    <D.20141>:
    <D.20142>:
    <D.20143>:
    <D.20144>:
    <D.20145>:
    <D.20146>:
    <D.20147>:
    <D.20148>:
    mono_mb_emit_byte (mb, 77);
    D.24316 = sig->params[i];
    D.24318 = mono_type_to_ldind (D.24316);
    D.24319 = (unsigned char) D.24318;
    mono_mb_emit_byte (mb, D.24319);
    goto <D.20149>;
    <D.20150>:
    <D.20151>:
    <D.20152>:
    <D.20153>:
    <D.20154>:
    <D.20155>:
    D.24316 = sig->params[i];
    D.24320 = mono_type_to_ldind (D.24316);
    D.24321 = (unsigned char) D.24320;
    mono_mb_emit_byte (mb, D.24321);
    goto <D.20149>;
    <D.20156>:
    D.24316 = sig->params[i];
    D.24322 = mono_type_generic_inst_is_valuetype (D.24316);
    if (D.24322 == 0) goto <D.24323>; else goto <D.24324>;
    <D.24323>:
    D.24316 = sig->params[i];
    D.24325 = mono_type_to_ldind (D.24316);
    D.24326 = (unsigned char) D.24325;
    mono_mb_emit_byte (mb, D.24326);
    goto <D.20149>;
    <D.24324>:
    <D.20157>:
    if (type == 17) goto <D.24327>; else goto <D.24328>;
    <D.24327>:
    D.24329 = t->data.klass;
    D.24330 = BIT_FIELD_REF <*D.24329, 64, 256>;
    D.24331 = D.24330 & 576460752303423488;
    if (D.24331 != 0) goto <D.24332>; else goto <D.24333>;
    <D.24332>:
    D.24329 = t->data.klass;
    D.24334 = mono_class_enum_basetype (D.24329);
    D.24335 = D.24334->type;
    type = (int) D.24335;
    goto handle_enum;
    <D.24333>:
    <D.24328>:
    mono_mb_emit_byte (mb, 77);
    D.24316 = sig->params[i];
    D.24336 = mono_class_from_mono_type (D.24316);
    D.24337 = mono_class_is_nullable (D.24336);
    if (D.24337 != 0) goto <D.24338>; else goto <D.24339>;
    <D.24338>:
    D.24316 = sig->params[i];
    D.24340 = mono_class_from_mono_type (D.24316);
    mono_mb_emit_op (mb, 121, D.24340);
    D.24316 = sig->params[i];
    D.24341 = mono_class_from_mono_type (D.24316);
    mono_mb_emit_op (mb, 113, D.24341);
    goto <D.24342>;
    <D.24339>:
    D.24316 = sig->params[i];
    D.24343 = mono_class_from_mono_type (D.24316);
    mono_mb_emit_op (mb, 113, D.24343);
    <D.24342>:
    goto <D.20149>;
    <D.20158>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "marshal.c", 4744);
    <D.20149>:
  }
  <D.20133>:
  i = i + 1;
  <D.20160>:
  D.24288 = sig->param_count;
  D.24344 = (int) D.24288;
  if (D.24344 > i) goto <D.20159>; else goto <D.20161>;
  <D.20161>:
  if (virtual != 0) goto <D.24345>; else goto <D.24346>;
  <D.24345>:
  mono_mb_emit_op (mb, 111, method);
  goto <D.24347>;
  <D.24346>:
  if (need_direct_wrapper != 0) goto <D.24348>; else goto <D.24349>;
  <D.24348>:
  mono_mb_emit_op (mb, 40, method);
  goto <D.24350>;
  <D.24349>:
  mono_mb_emit_ldarg (mb, 3);
  mono_mb_emit_calli (mb, callsig);
  <D.24350>:
  <D.24347>:
  D.24351 = sig->ret;
  D.24352 = BIT_FIELD_REF <*D.24351, 64, 64>;
  D.24353 = D.24352 & 8589934592;
  if (D.24353 != 0) goto <D.24354>; else goto <D.24355>;
  <D.24354>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "marshal.c", 4759);
  <D.24355>:
  D.24351 = sig->ret;
  D.24356 = D.24351->type;
  D.24357 = (int) D.24356;
  switch (D.24357) <default: <D.20187>, case 1: <D.20162>, case 2: <D.20164>, case 3: <D.20165>, case 4: <D.20166>, case 5: <D.20167>, case 6: <D.20168>, case 7: <D.20169>, case 8: <D.20170>, case 9: <D.20171>, case 10: <D.20176>, case 11: <D.20177>, case 12: <D.20174>, case 13: <D.20175>, case 14: <D.20181>, case 15: <D.20186>, case 17: <D.20178>, case 18: <D.20182>, case 20: <D.20183>, case 21: <D.20180>, case 22: <D.20179>, case 24: <D.20172>, case 25: <D.20173>, case 28: <D.20185>, case 29: <D.20184>>
  <D.20162>:
  D.24279 = BIT_FIELD_REF <*method, 64, 256>;
  D.24280 = D.24279 & 72057594037927936;
  if (D.24280 == 0) goto <D.24358>; else goto <D.24359>;
  <D.24358>:
  void_ret = 1;
  <D.24359>:
  goto <D.20163>;
  <D.20164>:
  <D.20165>:
  <D.20166>:
  <D.20167>:
  <D.20168>:
  <D.20169>:
  <D.20170>:
  <D.20171>:
  <D.20172>:
  <D.20173>:
  <D.20174>:
  <D.20175>:
  <D.20176>:
  <D.20177>:
  <D.20178>:
  <D.20179>:
  <D.20180>:
  D.24351 = sig->ret;
  D.24360 = mono_class_from_mono_type (D.24351);
  mono_mb_emit_op (mb, 140, D.24360);
  goto <D.20163>;
  <D.20181>:
  <D.20182>:
  <D.20183>:
  <D.20184>:
  <D.20185>:
  goto <D.20163>;
  <D.20186>:
  D.24361 = mono_defaults.int_class;
  mono_mb_emit_op (mb, 140, D.24361);
  goto <D.20163>;
  <D.20187>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "marshal.c", 4799);
  <D.20163>:
  if (void_ret == 0) goto <D.24362>; else goto <D.24363>;
  <D.24362>:
  loc_res.132 = (unsigned int) loc_res;
  mono_mb_emit_stloc (mb, loc_res.132);
  <D.24363>:
  i = 0;
  goto <D.20190>;
  <D.20189>:
  {
    struct MonoType * t;

    t = sig->params[i];
    D.24365 = BIT_FIELD_REF <*t, 64, 64>;
    D.24366 = D.24365 & 280384055017472;
    if (D.24366 == 23098334117888) goto <D.24367>; else goto <D.24368>;
    <D.24367>:
    D.24369 = mono_class_from_mono_type (t);
    D.24370 = mono_class_is_nullable (D.24369);
    if (D.24370 != 0) goto <D.24371>; else goto <D.24372>;
    <D.24371>:
    mono_mb_emit_ldarg (mb, 1);
    i.131 = (unsigned int) i;
    D.24294 = i.131 * 8;
    D.24295 = (int) D.24294;
    mono_mb_emit_icon (mb, D.24295);
    mono_mb_emit_byte (mb, 88);
    D.24307 = (long unsigned int) i;
    D.24308 = D.24307 * 4;
    D.24309 = tmp_nullable_locals + D.24308;
    D.24314 = *D.24309;
    D.24315 = (unsigned int) D.24314;
    mono_mb_emit_ldloc (mb, D.24315);
    D.24373 = mono_class_from_mono_type (t);
    mono_mb_emit_op (mb, 140, D.24373);
    mono_mb_emit_byte (mb, 81);
    <D.24372>:
    <D.24368>:
  }
  i = i + 1;
  <D.20190>:
  D.24288 = sig->param_count;
  D.24344 = (int) D.24288;
  if (D.24344 > i) goto <D.20189>; else goto <D.20191>;
  <D.20191>:
  monoeg_g_free (tmp_nullable_locals);
}


__attribute__((visibility ("hidden")))
mono_marshal_get_runtime_invoke_dynamic ()
{
  struct MonoMethod * method.133;
  struct MonoMethod * D.24378;
  struct MonoImage * D.24379;
  struct MonoClass * D.24380;
  struct MonoType * D.24381;
  struct MonoClass * D.24382;
  struct MonoType * D.24383;
  struct MonoClass * D.24384;
  struct MonoType * D.24385;
  unsigned int D.24386;
  int D.24387;
  unsigned int D.24388;
  int D.24389;
  unsigned int D.24390;
  int D.24391;
  unsigned int D.24392;
  struct MonoClass * D.24393;
  unsigned int D.24394;
  unsigned int posna.134;
  int D.24396;
  unsigned int D.24397;
  unsigned int D.24398;
  unsigned int D.24399;
  unsigned int pos.135;
  _Bool D.24403;
  long int D.24404;
  long int D.24405;
  struct MonoMethod * method.136;
  _Bool D.24413;
  long int D.24414;
  long int D.24415;
  static struct MonoMethod * method;
  struct MonoMethodSignature * csig;
  struct MonoExceptionClause * clause;
  struct MonoMethodBuilder * mb;
  int pos;
  int posna;
  char * name;
  struct WrapperInfo * info;

  method.133 = method;
  if (method.133 != 0B) goto <D.24376>; else goto <D.24377>;
  <D.24376>:
  D.24378 = method;
  return D.24378;
  <D.24377>:
  D.24379 = mono_defaults.corlib;
  csig = mono_metadata_signature_alloc (D.24379, 4);
  D.24380 = mono_defaults.void_class;
  D.24381 = &D.24380->byval_arg;
  csig->ret = D.24381;
  D.24382 = mono_defaults.int_class;
  D.24383 = &D.24382->byval_arg;
  csig->params[0] = D.24383;
  D.24382 = mono_defaults.int_class;
  D.24383 = &D.24382->byval_arg;
  csig->params[1] = D.24383;
  D.24382 = mono_defaults.int_class;
  D.24383 = &D.24382->byval_arg;
  csig->params[2] = D.24383;
  D.24382 = mono_defaults.int_class;
  D.24383 = &D.24382->byval_arg;
  csig->params[3] = D.24383;
  name = monoeg_strdup ("runtime_invoke_dynamic");
  D.24384 = mono_defaults.object_class;
  mb = mono_mb_new (D.24384, name, 4);
  monoeg_g_free (name);
  D.24384 = mono_defaults.object_class;
  D.24385 = &D.24384->byval_arg;
  mono_mb_add_local (mb, D.24385);
  D.24384 = mono_defaults.object_class;
  D.24385 = &D.24384->byval_arg;
  mono_mb_add_local (mb, D.24385);
  mono_mb_emit_byte (mb, 3);
  mono_mb_emit_byte (mb, 44);
  mono_mb_emit_byte (mb, 3);
  mono_mb_emit_byte (mb, 3);
  mono_mb_emit_byte (mb, 20);
  mono_mb_emit_byte (mb, 81);
  emit_thread_force_interrupt_checkpoint (mb);
  mono_mb_emit_byte (mb, 2);
  mono_mb_emit_byte (mb, 4);
  mono_mb_emit_byte (mb, 240);
  mono_mb_emit_byte (mb, 15);
  D.24386 = mono_mb_emit_branch (mb, 221);
  pos = (int) D.24386;
  D.24379 = mono_defaults.corlib;
  clause = mono_image_alloc0 (D.24379, 32);
  clause->flags = 1;
  D.24387 = mono_mb_get_label (mb);
  D.24388 = (unsigned int) D.24387;
  clause->try_len = D.24388;
  D.24389 = mono_mb_get_label (mb);
  D.24390 = (unsigned int) D.24389;
  clause->data.filter_offset = D.24390;
  mono_mb_emit_byte (mb, 38);
  mono_mb_emit_byte (mb, 3);
  mono_mb_emit_byte (mb, 22);
  mono_mb_emit_byte (mb, 254);
  mono_mb_emit_byte (mb, 3);
  mono_mb_emit_byte (mb, 254);
  mono_mb_emit_byte (mb, 17);
  D.24391 = mono_mb_get_label (mb);
  D.24392 = (unsigned int) D.24391;
  clause->handler_offset = D.24392;
  mono_mb_emit_stloc (mb, 1);
  mono_mb_emit_byte (mb, 3);
  mono_mb_emit_ldloc (mb, 1);
  mono_mb_emit_byte (mb, 81);
  mono_mb_emit_byte (mb, 20);
  mono_mb_emit_stloc (mb, 0);
  mono_mb_emit_ldloc (mb, 1);
  D.24393 = mono_defaults.threadabortexception_class;
  mono_mb_emit_op (mb, 117, D.24393);
  D.24394 = mono_mb_emit_short_branch (mb, 44);
  posna = (int) D.24394;
  mono_mb_emit_icall (mb, ves_icall_System_Threading_Thread_ResetAbort);
  posna.134 = (unsigned int) posna;
  mono_mb_patch_short_branch (mb, posna.134);
  mono_mb_emit_branch (mb, 221);
  D.24396 = mono_mb_get_pos (mb);
  D.24397 = (unsigned int) D.24396;
  D.24398 = clause->handler_offset;
  D.24399 = D.24397 - D.24398;
  clause->handler_len = D.24399;
  mono_mb_set_clauses (mb, 1, clause);
  pos.135 = (unsigned int) pos;
  mono_mb_patch_branch (mb, pos.135);
  mono_mb_emit_byte (mb, 42);
  {
    int ret;

    ret = pthread_mutex_lock (&marshal_mutex.mutex);
    if (ret != 0) goto <D.24401>; else goto <D.24402>;
    <D.24401>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.24402>:
    D.24403 = ret != 0;
    D.24404 = (long int) D.24403;
    D.24405 = __builtin_expect (D.24404, 0);
    if (D.24405 != 0) goto <D.24406>; else goto <D.24407>;
    <D.24406>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 5213, "ret == 0");
    <D.24407>:
  }
  method.133 = method;
  if (method.133 == 0B) goto <D.24408>; else goto <D.24409>;
  <D.24408>:
  method.136 = mono_mb_create_method (mb, csig, 16);
  method = method.136;
  method.133 = method;
  info = mono_wrapper_info_create (method.133, 12);
  method.133 = method;
  mono_marshal_set_wrapper_info (method.133, info);
  <D.24409>:
  {
    int ret;

    ret = pthread_mutex_unlock (&marshal_mutex.mutex);
    if (ret != 0) goto <D.24411>; else goto <D.24412>;
    <D.24411>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.24412>:
    D.24413 = ret != 0;
    D.24414 = (long int) D.24413;
    D.24415 = __builtin_expect (D.24414, 0);
    if (D.24415 != 0) goto <D.24416>; else goto <D.24417>;
    <D.24416>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 5220, "ret == 0");
    <D.24417>:
  }
  mono_mb_free (mb);
  D.24378 = method;
  return D.24378;
}


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

  if (str != 0B) goto <D.24419>; else goto <D.24420>;
  <D.24419>:
  D.24421 = __strdup (str);
  return D.24421;
  <D.24420>:
  D.24421 = 0B;
  return D.24421;
}


__attribute__((visibility ("hidden")))
mono_marshal_get_ldfld_remote_wrapper (struct MonoClass * klass)
{
  _Bool D.24425;
  long int D.24426;
  long int D.24427;
  struct MonoMethod * cached.137;
  _Bool D.24435;
  long int D.24436;
  long int D.24437;
  struct MonoMethod * D.24440;
  _Bool D.24443;
  long int D.24444;
  long int D.24445;
  struct MonoClass * D.24448;
  struct MonoMethod * D.24449;
  struct MonoImage * D.24450;
  struct MonoType * D.24451;
  struct MonoClass * D.24452;
  struct MonoType * D.24453;
  _Bool D.24456;
  long int D.24457;
  long int D.24458;
  _Bool D.24463;
  long int D.24464;
  long int D.24465;
  _Bool D.24472;
  long int D.24473;
  long int D.24474;
  _Bool D.24481;
  long int D.24482;
  long int D.24483;
  _Bool D.24489;
  long int D.24490;
  long int D.24491;
  struct MonoMethodSignature * sig;
  struct MonoMethodSignature * csig;
  struct MonoMethodBuilder * mb;
  struct MonoMethod * res;
  static struct MonoMethod * cached = 0B;

  {
    int ret;

    ret = pthread_mutex_lock (&marshal_mutex.mutex);
    if (ret != 0) goto <D.24423>; else goto <D.24424>;
    <D.24423>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.24424>:
    D.24425 = ret != 0;
    D.24426 = (long int) D.24425;
    D.24427 = __builtin_expect (D.24426, 0);
    if (D.24427 != 0) goto <D.24428>; else goto <D.24429>;
    <D.24428>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 5256, "ret == 0");
    <D.24429>:
  }
  cached.137 = cached;
  if (cached.137 != 0B) goto <D.24431>; else goto <D.24432>;
  <D.24431>:
  {
    int ret;

    ret = pthread_mutex_unlock (&marshal_mutex.mutex);
    if (ret != 0) goto <D.24433>; else goto <D.24434>;
    <D.24433>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.24434>:
    D.24435 = ret != 0;
    D.24436 = (long int) D.24435;
    D.24437 = __builtin_expect (D.24436, 0);
    if (D.24437 != 0) goto <D.24438>; else goto <D.24439>;
    <D.24438>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 5258, "ret == 0");
    <D.24439>:
  }
  D.24440 = cached;
  return D.24440;
  <D.24432>:
  {
    int ret;

    ret = pthread_mutex_unlock (&marshal_mutex.mutex);
    if (ret != 0) goto <D.24441>; else goto <D.24442>;
    <D.24441>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.24442>:
    D.24443 = ret != 0;
    D.24444 = (long int) D.24443;
    D.24445 = __builtin_expect (D.24444, 0);
    if (D.24445 != 0) goto <D.24446>; else goto <D.24447>;
    <D.24446>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 5261, "ret == 0");
    <D.24447>:
  }
  D.24448 = mono_defaults.object_class;
  mb = mono_mb_new_no_dup_name (D.24448, "__mono_load_remote_field_new_wrapper", 14);
  D.24449 = mb->method;
  D.24449->save_lmf = 1;
  D.24450 = mono_defaults.corlib;
  sig = mono_metadata_signature_alloc (D.24450, 3);
  D.24448 = mono_defaults.object_class;
  D.24451 = &D.24448->byval_arg;
  sig->params[0] = D.24451;
  D.24452 = mono_defaults.int_class;
  D.24453 = &D.24452->byval_arg;
  sig->params[1] = D.24453;
  D.24452 = mono_defaults.int_class;
  D.24453 = &D.24452->byval_arg;
  sig->params[2] = D.24453;
  D.24448 = mono_defaults.object_class;
  D.24451 = &D.24448->byval_arg;
  sig->ret = D.24451;
  mono_mb_emit_ldarg (mb, 0);
  mono_mb_emit_ldarg (mb, 1);
  mono_mb_emit_ldarg (mb, 2);
  D.24450 = mono_defaults.corlib;
  csig = mono_metadata_signature_alloc (D.24450, 3);
  D.24448 = mono_defaults.object_class;
  D.24451 = &D.24448->byval_arg;
  csig->params[0] = D.24451;
  D.24452 = mono_defaults.int_class;
  D.24453 = &D.24452->byval_arg;
  csig->params[1] = D.24453;
  D.24452 = mono_defaults.int_class;
  D.24453 = &D.24452->byval_arg;
  csig->params[2] = D.24453;
  D.24448 = mono_defaults.object_class;
  D.24451 = &D.24448->byval_arg;
  csig->ret = D.24451;
  csig->pinvoke = 1;
  mono_mb_emit_native_call (mb, csig, mono_load_remote_field_new);
  emit_thread_interrupt_checkpoint (mb);
  mono_mb_emit_byte (mb, 42);
  {
    int ret;

    ret = pthread_mutex_lock (&marshal_mutex.mutex);
    if (ret != 0) goto <D.24454>; else goto <D.24455>;
    <D.24454>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.24455>:
    D.24456 = ret != 0;
    D.24457 = (long int) D.24456;
    D.24458 = __builtin_expect (D.24457, 0);
    if (D.24458 != 0) goto <D.24459>; else goto <D.24460>;
    <D.24459>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 5291, "ret == 0");
    <D.24460>:
  }
  res = cached;
  {
    int ret;

    ret = pthread_mutex_unlock (&marshal_mutex.mutex);
    if (ret != 0) goto <D.24461>; else goto <D.24462>;
    <D.24461>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.24462>:
    D.24463 = ret != 0;
    D.24464 = (long int) D.24463;
    D.24465 = __builtin_expect (D.24464, 0);
    if (D.24465 != 0) goto <D.24466>; else goto <D.24467>;
    <D.24466>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 5293, "ret == 0");
    <D.24467>:
  }
  if (res == 0B) goto <D.24468>; else goto <D.24469>;
  <D.24468>:
  {
    struct MonoMethod * newm;

    newm = mono_mb_create_method (mb, sig, 4);
    {
      int ret;

      ret = pthread_mutex_lock (&marshal_mutex.mutex);
      if (ret != 0) goto <D.24470>; else goto <D.24471>;
      <D.24470>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
      <D.24471>:
      D.24472 = ret != 0;
      D.24473 = (long int) D.24472;
      D.24474 = __builtin_expect (D.24473, 0);
      if (D.24474 != 0) goto <D.24475>; else goto <D.24476>;
      <D.24475>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 5297, "ret == 0");
      <D.24476>:
    }
    res = cached;
    if (res == 0B) goto <D.24477>; else goto <D.24478>;
    <D.24477>:
    res = newm;
    cached = res;
    {
      int ret;

      ret = pthread_mutex_unlock (&marshal_mutex.mutex);
      if (ret != 0) goto <D.24479>; else goto <D.24480>;
      <D.24479>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
      <D.24480>:
      D.24481 = ret != 0;
      D.24482 = (long int) D.24481;
      D.24483 = __builtin_expect (D.24482, 0);
      if (D.24483 != 0) goto <D.24484>; else goto <D.24485>;
      <D.24484>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 5302, "ret == 0");
      <D.24485>:
    }
    goto <D.24486>;
    <D.24478>:
    {
      int ret;

      ret = pthread_mutex_unlock (&marshal_mutex.mutex);
      if (ret != 0) goto <D.24487>; else goto <D.24488>;
      <D.24487>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
      <D.24488>:
      D.24489 = ret != 0;
      D.24490 = (long int) D.24489;
      D.24491 = __builtin_expect (D.24490, 0);
      if (D.24491 != 0) goto <D.24492>; else goto <D.24493>;
      <D.24492>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 5304, "ret == 0");
      <D.24493>:
    }
    mono_free_method (newm);
    <D.24486>:
  }
  <D.24469>:
  mono_mb_free (mb);
  D.24440 = res;
  return D.24440;
}


__attribute__((visibility ("hidden")))
mono_marshal_get_ldfld_wrapper (struct MonoType * type)
{
  unsigned char D.24495;
  long unsigned int D.24496;
  long unsigned int D.24497;
  int D.24517;
  struct MonoImage * D.24523;
  struct GHashTable * * D.24524;
  struct MonoMethod * D.24527;
  const char * D.24528;
  const char * D.24529;
  struct MonoClass * D.24530;
  struct MonoImage * D.24531;
  struct MonoType * D.24532;
  struct MonoClass * D.24533;
  struct MonoType * D.24534;
  struct MonoType * D.24535;
  struct MonoMethod * D.24536;
  long unsigned int D.24537;
  long unsigned int D.24538;
  unsigned int D.24541;
  unsigned int pos0.138;
  unsigned int pos1.139;
  unsigned int D.24547;
  unsigned char D.24548;
  long unsigned int D.24549;
  _Bool D.24550;
  long int D.24551;
  long int D.24552;
  int D.24555;
  int D.24559;
  short unsigned int D.24560;
  int D.24561;
  int D.24562;
  struct MonoMethodSignature * sig;
  struct MonoMethodBuilder * mb;
  struct MonoMethod * res;
  struct MonoClass * klass;
  struct GHashTable * cache;
  char * name;
  int t;
  int pos0;
  int pos1;

  pos1 = 0;
  type = mono_type_get_underlying_type (type);
  D.24495 = type->type;
  t = (int) D.24495;
  D.24496 = BIT_FIELD_REF <*type, 64, 64>;
  D.24497 = D.24496 & 8589934592;
  if (D.24497 == 0) goto <D.24498>; else goto <D.24499>;
  <D.24498>:
  D.24495 = type->type;
  if (D.24495 == 29) goto <D.24500>; else goto <D.24501>;
  <D.24500>:
  klass = mono_defaults.array_class;
  goto <D.24502>;
  <D.24501>:
  D.24495 = type->type;
  if (D.24495 == 17) goto <D.24503>; else goto <D.24504>;
  <D.24503>:
  klass = type->data.klass;
  goto <D.24505>;
  <D.24504>:
  if (t == 28) goto <D.24506>; else goto <D.24509>;
  <D.24509>:
  if (t == 18) goto <D.24506>; else goto <D.24510>;
  <D.24510>:
  if (t == 14) goto <D.24506>; else goto <D.24507>;
  <D.24506>:
  klass = mono_defaults.object_class;
  goto <D.24508>;
  <D.24507>:
  if (t == 15) goto <D.24511>; else goto <D.24514>;
  <D.24514>:
  if (t == 27) goto <D.24511>; else goto <D.24512>;
  <D.24511>:
  klass = mono_defaults.int_class;
  goto <D.24513>;
  <D.24512>:
  if (t == 21) goto <D.24515>; else goto <D.24516>;
  <D.24515>:
  D.24517 = mono_type_generic_inst_is_valuetype (type);
  if (D.24517 != 0) goto <D.24518>; else goto <D.24519>;
  <D.24518>:
  klass = mono_class_from_mono_type (type);
  goto <D.24520>;
  <D.24519>:
  klass = mono_defaults.object_class;
  <D.24520>:
  goto <D.24521>;
  <D.24516>:
  klass = mono_class_from_mono_type (type);
  <D.24521>:
  <D.24513>:
  <D.24508>:
  <D.24505>:
  <D.24502>:
  goto <D.24522>;
  <D.24499>:
  klass = mono_defaults.int_class;
  <D.24522>:
  D.24523 = klass->image;
  D.24524 = &D.24523->ldfld_wrapper_cache;
  cache = get_cache (D.24524, mono_aligned_addr_hash, 0B);
  res = mono_marshal_find_in_cache (cache, klass);
  if (res != 0B) goto <D.24525>; else goto <D.24526>;
  <D.24525>:
  D.24527 = res;
  return D.24527;
  <D.24526>:
  D.24528 = klass->name_space;
  D.24529 = klass->name;
  name = monoeg_g_strdup_printf ("__ldfld_wrapper_%p_%s.%s", klass, D.24528, D.24529);
  D.24530 = mono_defaults.object_class;
  mb = mono_mb_new (D.24530, name, 12);
  monoeg_g_free (name);
  D.24531 = mono_defaults.corlib;
  sig = mono_metadata_signature_alloc (D.24531, 4);
  D.24530 = mono_defaults.object_class;
  D.24532 = &D.24530->byval_arg;
  sig->params[0] = D.24532;
  D.24533 = mono_defaults.int_class;
  D.24534 = &D.24533->byval_arg;
  sig->params[1] = D.24534;
  D.24533 = mono_defaults.int_class;
  D.24534 = &D.24533->byval_arg;
  sig->params[2] = D.24534;
  D.24533 = mono_defaults.int_class;
  D.24534 = &D.24533->byval_arg;
  sig->params[3] = D.24534;
  D.24535 = &klass->byval_arg;
  sig->ret = D.24535;
  mono_mb_emit_ldarg (mb, 0);
  pos0 = mono_mb_emit_proxy_check (mb, 64);
  mono_mb_emit_ldarg (mb, 0);
  mono_mb_emit_ldarg (mb, 1);
  mono_mb_emit_ldarg (mb, 2);
  D.24536 = mono_marshal_get_ldfld_remote_wrapper (klass);
  mono_mb_emit_managed_call (mb, D.24536, 0B);
  D.24537 = BIT_FIELD_REF <*klass, 64, 256>;
  D.24538 = D.24537 & 1152921504606846976;
  if (D.24538 != 0) goto <D.24539>; else goto <D.24540>;
  <D.24539>:
  mono_mb_emit_op (mb, 121, klass);
  D.24541 = mono_mb_emit_branch (mb, 56);
  pos1 = (int) D.24541;
  goto <D.24542>;
  <D.24540>:
  mono_mb_emit_byte (mb, 42);
  <D.24542>:
  pos0.138 = (unsigned int) pos0;
  mono_mb_patch_branch (mb, pos0.138);
  mono_mb_emit_ldarg (mb, 0);
  mono_mb_emit_byte (mb, 240);
  mono_mb_emit_byte (mb, 1);
  mono_mb_emit_ldarg (mb, 3);
  mono_mb_emit_byte (mb, 88);
  D.24537 = BIT_FIELD_REF <*klass, 64, 256>;
  D.24538 = D.24537 & 1152921504606846976;
  if (D.24538 != 0) goto <D.24544>; else goto <D.24545>;
  <D.24544>:
  pos1.139 = (unsigned int) pos1;
  mono_mb_patch_branch (mb, pos1.139);
  <D.24545>:
  switch (t) <default: <D.20303>, case 2: <D.20279>, case 3: <D.20280>, case 4: <D.20277>, case 5: <D.20278>, case 6: <D.20281>, case 7: <D.20282>, case 8: <D.20283>, case 9: <D.20284>, case 10: <D.20285>, case 11: <D.20286>, case 12: <D.20287>, case 13: <D.20288>, case 14: <D.20293>, case 15: <D.20296>, case 17: <D.20299>, case 18: <D.20292>, case 19: <D.20301>, case 20: <D.20289>, case 21: <D.20300>, case 24: <D.20294>, case 25: <D.20295>, case 27: <D.20297>, case 28: <D.20291>, case 29: <D.20290>, case 30: <D.20302>>
  <D.20277>:
  <D.20278>:
  <D.20279>:
  <D.20280>:
  <D.20281>:
  <D.20282>:
  <D.20283>:
  <D.20284>:
  <D.20285>:
  <D.20286>:
  <D.20287>:
  <D.20288>:
  <D.20289>:
  <D.20290>:
  <D.20291>:
  <D.20292>:
  <D.20293>:
  <D.20294>:
  <D.20295>:
  <D.20296>:
  <D.20297>:
  D.24547 = mono_type_to_ldind (type);
  D.24548 = (unsigned char) D.24547;
  mono_mb_emit_byte (mb, D.24548);
  goto <D.20298>;
  <D.20299>:
  D.24537 = BIT_FIELD_REF <*klass, 64, 256>;
  D.24549 = D.24537 & 576460752303423488;
  D.24550 = D.24549 != 0;
  D.24551 = (long int) D.24550;
  D.24552 = __builtin_expect (D.24551, 0);
  if (D.24552 != 0) goto <D.24553>; else goto <D.24554>;
  <D.24553>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 5439, "!klass->enumtype");
  <D.24554>:
  mono_mb_emit_op (mb, 113, klass);
  goto <D.20298>;
  <D.20300>:
  D.24555 = mono_type_generic_inst_is_valuetype (type);
  if (D.24555 != 0) goto <D.24556>; else goto <D.24557>;
  <D.24556>:
  mono_mb_emit_op (mb, 113, klass);
  goto <D.24558>;
  <D.24557>:
  mono_mb_emit_byte (mb, 80);
  <D.24558>:
  goto <D.20298>;
  <D.20301>:
  <D.20302>:
  mono_mb_emit_op (mb, 113, klass);
  goto <D.20298>;
  <D.20303>:
  D.24495 = type->type;
  D.24559 = (int) D.24495;
  monoeg_g_log (0B, 16, "type %x not implemented", D.24559);
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "marshal.c", 5455);
  <D.20298>:
  mono_mb_emit_byte (mb, 42);
  D.24560 = sig->param_count;
  D.24561 = (int) D.24560;
  D.24562 = D.24561 + 16;
  res = mono_mb_create_and_cache (cache, klass, mb, sig, D.24562);
  mono_mb_free (mb);
  D.24527 = res;
  return D.24527;
}


__attribute__((visibility ("hidden")))
mono_marshal_get_ldflda_wrapper (struct MonoType * type)
{
  unsigned char D.24564;
  long unsigned int D.24565;
  long unsigned int D.24566;
  int D.24587;
  struct MonoImage * D.24593;
  struct GHashTable * * D.24594;
  struct MonoMethod * D.24597;
  const char * D.24598;
  const char * D.24599;
  struct MonoClass * D.24600;
  struct MonoImage * D.24601;
  struct MonoType * D.24602;
  struct MonoClass * D.24603;
  struct MonoType * D.24604;
  unsigned int pos1.140;
  unsigned int D.24606;
  unsigned int pos2.141;
  unsigned int pos3.142;
  unsigned int pos0.143;
  short unsigned int D.24610;
  int D.24611;
  int D.24612;
  struct MonoMethodSignature * sig;
  struct MonoMethodBuilder * mb;
  struct MonoMethod * res;
  struct MonoClass * klass;
  struct GHashTable * cache;
  char * name;
  int t;
  int pos0;
  int pos1;
  int pos2;
  int pos3;

  type = mono_type_get_underlying_type (type);
  D.24564 = type->type;
  t = (int) D.24564;
  D.24565 = BIT_FIELD_REF <*type, 64, 64>;
  D.24566 = D.24565 & 8589934592;
  if (D.24566 == 0) goto <D.24567>; else goto <D.24568>;
  <D.24567>:
  D.24564 = type->type;
  if (D.24564 == 29) goto <D.24569>; else goto <D.24570>;
  <D.24569>:
  klass = mono_defaults.array_class;
  goto <D.24571>;
  <D.24570>:
  D.24564 = type->type;
  if (D.24564 == 17) goto <D.24572>; else goto <D.24573>;
  <D.24572>:
  klass = type->data.klass;
  goto <D.24574>;
  <D.24573>:
  if (t == 28) goto <D.24575>; else goto <D.24578>;
  <D.24578>:
  if (t == 18) goto <D.24575>; else goto <D.24579>;
  <D.24579>:
  if (t == 14) goto <D.24575>; else goto <D.24580>;
  <D.24580>:
  if (t == 18) goto <D.24575>; else goto <D.24576>;
  <D.24575>:
  klass = mono_defaults.object_class;
  goto <D.24577>;
  <D.24576>:
  if (t == 15) goto <D.24581>; else goto <D.24584>;
  <D.24584>:
  if (t == 27) goto <D.24581>; else goto <D.24582>;
  <D.24581>:
  klass = mono_defaults.int_class;
  goto <D.24583>;
  <D.24582>:
  if (t == 21) goto <D.24585>; else goto <D.24586>;
  <D.24585>:
  D.24587 = mono_type_generic_inst_is_valuetype (type);
  if (D.24587 != 0) goto <D.24588>; else goto <D.24589>;
  <D.24588>:
  klass = mono_class_from_mono_type (type);
  goto <D.24590>;
  <D.24589>:
  klass = mono_defaults.object_class;
  <D.24590>:
  goto <D.24591>;
  <D.24586>:
  klass = mono_class_from_mono_type (type);
  <D.24591>:
  <D.24583>:
  <D.24577>:
  <D.24574>:
  <D.24571>:
  goto <D.24592>;
  <D.24568>:
  klass = mono_defaults.int_class;
  <D.24592>:
  D.24593 = klass->image;
  D.24594 = &D.24593->ldflda_wrapper_cache;
  cache = get_cache (D.24594, mono_aligned_addr_hash, 0B);
  res = mono_marshal_find_in_cache (cache, klass);
  if (res != 0B) goto <D.24595>; else goto <D.24596>;
  <D.24595>:
  D.24597 = res;
  return D.24597;
  <D.24596>:
  D.24598 = klass->name_space;
  D.24599 = klass->name;
  name = monoeg_g_strdup_printf ("__ldflda_wrapper_%p_%s.%s", klass, D.24598, D.24599);
  D.24600 = mono_defaults.object_class;
  mb = mono_mb_new (D.24600, name, 23);
  monoeg_g_free (name);
  D.24601 = mono_defaults.corlib;
  sig = mono_metadata_signature_alloc (D.24601, 4);
  D.24600 = mono_defaults.object_class;
  D.24602 = &D.24600->byval_arg;
  sig->params[0] = D.24602;
  D.24603 = mono_defaults.int_class;
  D.24604 = &D.24603->byval_arg;
  sig->params[1] = D.24604;
  D.24603 = mono_defaults.int_class;
  D.24604 = &D.24603->byval_arg;
  sig->params[2] = D.24604;
  D.24603 = mono_defaults.int_class;
  D.24604 = &D.24603->byval_arg;
  sig->params[3] = D.24604;
  D.24603 = mono_defaults.int_class;
  D.24604 = &D.24603->byval_arg;
  sig->ret = D.24604;
  mono_mb_emit_ldarg (mb, 0);
  pos0 = mono_mb_emit_proxy_check (mb, 64);
  mono_mb_emit_ldarg (mb, 0);
  pos1 = mono_mb_emit_xdomain_check (mb, 59);
  mono_mb_emit_exception_full (mb, "System", "InvalidOperationException", "Attempt to load field address from object in another appdomain.");
  pos1.140 = (unsigned int) pos1;
  mono_mb_patch_branch (mb, pos1.140);
  mono_mb_emit_ldarg (mb, 0);
  pos2 = mono_mb_emit_contextbound_check (mb, 59);
  mono_mb_emit_ldarg (mb, 0);
  mono_mb_emit_ldflda (mb, 16);
  mono_mb_emit_byte (mb, 80);
  mono_mb_emit_ldflda (mb, 24);
  mono_mb_emit_byte (mb, 80);
  mono_mb_emit_icall (mb, mono_context_get);
  D.24606 = mono_mb_emit_branch (mb, 59);
  pos3 = (int) D.24606;
  mono_mb_emit_exception_full (mb, "System", "InvalidOperationException", "Attempt to load field address from object in another context.");
  pos2.141 = (unsigned int) pos2;
  mono_mb_patch_branch (mb, pos2.141);
  pos3.142 = (unsigned int) pos3;
  mono_mb_patch_branch (mb, pos3.142);
  mono_mb_emit_ldarg (mb, 0);
  mono_mb_emit_ldflda (mb, 16);
  mono_mb_emit_byte (mb, 80);
  mono_mb_emit_ldflda (mb, 32);
  mono_mb_emit_byte (mb, 80);
  mono_mb_emit_byte (mb, 240);
  mono_mb_emit_byte (mb, 1);
  mono_mb_emit_ldarg (mb, 3);
  mono_mb_emit_byte (mb, 88);
  mono_mb_emit_byte (mb, 42);
  pos0.143 = (unsigned int) pos0;
  mono_mb_patch_branch (mb, pos0.143);
  mono_mb_emit_ldarg (mb, 0);
  mono_mb_emit_byte (mb, 240);
  mono_mb_emit_byte (mb, 1);
  mono_mb_emit_ldarg (mb, 3);
  mono_mb_emit_byte (mb, 88);
  mono_mb_emit_byte (mb, 42);
  D.24610 = sig->param_count;
  D.24611 = (int) D.24610;
  D.24612 = D.24611 + 16;
  res = mono_mb_create_and_cache (cache, klass, mb, sig, D.24612);
  mono_mb_free (mb);
  D.24597 = res;
  return D.24597;
}


mono_mb_emit_contextbound_check (struct MonoMethodBuilder * mb, int branch_code)
{
  int offset.144;
  unsigned char mask.145;
  int D.24618;
  int D.24619;
  unsigned char D.24620;
  unsigned int D.24621;
  static int offset = -1;
  static guint8 mask;

  offset.144 = offset;
  if (offset.144 < 0) goto <D.24615>; else goto <D.24616>;
  <D.24615>:
  {
    struct MonoClass tmp;

    try
      {
        memset (&tmp, 0, 272);
        tmp.contextbound = 1;
        mono_marshal_find_nonzero_bit_offset (&tmp, 272, &offset, &mask);
      }
    finally
      {
        tmp = {CLOBBER};
      }
  }
  <D.24616>:
  mono_mb_emit_ldflda (mb, 24);
  mono_mb_emit_byte (mb, 80);
  mono_mb_emit_ldflda (mb, 16);
  mono_mb_emit_byte (mb, 80);
  offset.144 = offset;
  mono_mb_emit_ldflda (mb, offset.144);
  mono_mb_emit_byte (mb, 71);
  mask.145 = mask;
  D.24618 = (int) mask.145;
  mono_mb_emit_icon (mb, D.24618);
  mono_mb_emit_byte (mb, 95);
  mono_mb_emit_icon (mb, 0);
  D.24620 = (unsigned char) branch_code;
  D.24621 = mono_mb_emit_branch (mb, D.24620);
  D.24619 = (int) D.24621;
  return D.24619;
}


__attribute__((visibility ("hidden")))
mono_marshal_get_stfld_remote_wrapper (struct MonoClass * klass)
{
  _Bool D.24625;
  long int D.24626;
  long int D.24627;
  struct MonoMethod * cached.146;
  _Bool D.24635;
  long int D.24636;
  long int D.24637;
  struct MonoMethod * D.24640;
  _Bool D.24643;
  long int D.24644;
  long int D.24645;
  struct MonoClass * D.24648;
  struct MonoMethod * D.24649;
  struct MonoImage * D.24650;
  struct MonoType * D.24651;
  struct MonoClass * D.24652;
  struct MonoType * D.24653;
  struct MonoClass * D.24654;
  struct MonoType * D.24655;
  _Bool D.24658;
  long int D.24659;
  long int D.24660;
  _Bool D.24665;
  long int D.24666;
  long int D.24667;
  _Bool D.24674;
  long int D.24675;
  long int D.24676;
  _Bool D.24683;
  long int D.24684;
  long int D.24685;
  _Bool D.24691;
  long int D.24692;
  long int D.24693;
  struct MonoMethodSignature * sig;
  struct MonoMethodSignature * csig;
  struct MonoMethodBuilder * mb;
  struct MonoMethod * res;
  static struct MonoMethod * cached = 0B;

  {
    int ret;

    ret = pthread_mutex_lock (&marshal_mutex.mutex);
    if (ret != 0) goto <D.24623>; else goto <D.24624>;
    <D.24623>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.24624>:
    D.24625 = ret != 0;
    D.24626 = (long int) D.24625;
    D.24627 = __builtin_expect (D.24626, 0);
    if (D.24627 != 0) goto <D.24628>; else goto <D.24629>;
    <D.24628>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 5608, "ret == 0");
    <D.24629>:
  }
  cached.146 = cached;
  if (cached.146 != 0B) goto <D.24631>; else goto <D.24632>;
  <D.24631>:
  {
    int ret;

    ret = pthread_mutex_unlock (&marshal_mutex.mutex);
    if (ret != 0) goto <D.24633>; else goto <D.24634>;
    <D.24633>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.24634>:
    D.24635 = ret != 0;
    D.24636 = (long int) D.24635;
    D.24637 = __builtin_expect (D.24636, 0);
    if (D.24637 != 0) goto <D.24638>; else goto <D.24639>;
    <D.24638>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 5610, "ret == 0");
    <D.24639>:
  }
  D.24640 = cached;
  return D.24640;
  <D.24632>:
  {
    int ret;

    ret = pthread_mutex_unlock (&marshal_mutex.mutex);
    if (ret != 0) goto <D.24641>; else goto <D.24642>;
    <D.24641>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.24642>:
    D.24643 = ret != 0;
    D.24644 = (long int) D.24643;
    D.24645 = __builtin_expect (D.24644, 0);
    if (D.24645 != 0) goto <D.24646>; else goto <D.24647>;
    <D.24646>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 5613, "ret == 0");
    <D.24647>:
  }
  D.24648 = mono_defaults.object_class;
  mb = mono_mb_new_no_dup_name (D.24648, "__mono_store_remote_field_new_wrapper", 15);
  D.24649 = mb->method;
  D.24649->save_lmf = 1;
  D.24650 = mono_defaults.corlib;
  sig = mono_metadata_signature_alloc (D.24650, 4);
  D.24648 = mono_defaults.object_class;
  D.24651 = &D.24648->byval_arg;
  sig->params[0] = D.24651;
  D.24652 = mono_defaults.int_class;
  D.24653 = &D.24652->byval_arg;
  sig->params[1] = D.24653;
  D.24652 = mono_defaults.int_class;
  D.24653 = &D.24652->byval_arg;
  sig->params[2] = D.24653;
  D.24648 = mono_defaults.object_class;
  D.24651 = &D.24648->byval_arg;
  sig->params[3] = D.24651;
  D.24654 = mono_defaults.void_class;
  D.24655 = &D.24654->byval_arg;
  sig->ret = D.24655;
  mono_mb_emit_ldarg (mb, 0);
  mono_mb_emit_ldarg (mb, 1);
  mono_mb_emit_ldarg (mb, 2);
  mono_mb_emit_ldarg (mb, 3);
  D.24650 = mono_defaults.corlib;
  csig = mono_metadata_signature_alloc (D.24650, 4);
  D.24648 = mono_defaults.object_class;
  D.24651 = &D.24648->byval_arg;
  csig->params[0] = D.24651;
  D.24652 = mono_defaults.int_class;
  D.24653 = &D.24652->byval_arg;
  csig->params[1] = D.24653;
  D.24652 = mono_defaults.int_class;
  D.24653 = &D.24652->byval_arg;
  csig->params[2] = D.24653;
  D.24648 = mono_defaults.object_class;
  D.24651 = &D.24648->byval_arg;
  csig->params[3] = D.24651;
  D.24654 = mono_defaults.void_class;
  D.24655 = &D.24654->byval_arg;
  csig->ret = D.24655;
  csig->pinvoke = 1;
  mono_mb_emit_native_call (mb, csig, mono_store_remote_field_new);
  emit_thread_interrupt_checkpoint (mb);
  mono_mb_emit_byte (mb, 42);
  {
    int ret;

    ret = pthread_mutex_lock (&marshal_mutex.mutex);
    if (ret != 0) goto <D.24656>; else goto <D.24657>;
    <D.24656>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.24657>:
    D.24658 = ret != 0;
    D.24659 = (long int) D.24658;
    D.24660 = __builtin_expect (D.24659, 0);
    if (D.24660 != 0) goto <D.24661>; else goto <D.24662>;
    <D.24661>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 5646, "ret == 0");
    <D.24662>:
  }
  res = cached;
  {
    int ret;

    ret = pthread_mutex_unlock (&marshal_mutex.mutex);
    if (ret != 0) goto <D.24663>; else goto <D.24664>;
    <D.24663>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.24664>:
    D.24665 = ret != 0;
    D.24666 = (long int) D.24665;
    D.24667 = __builtin_expect (D.24666, 0);
    if (D.24667 != 0) goto <D.24668>; else goto <D.24669>;
    <D.24668>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 5648, "ret == 0");
    <D.24669>:
  }
  if (res == 0B) goto <D.24670>; else goto <D.24671>;
  <D.24670>:
  {
    struct MonoMethod * newm;

    newm = mono_mb_create_method (mb, sig, 6);
    {
      int ret;

      ret = pthread_mutex_lock (&marshal_mutex.mutex);
      if (ret != 0) goto <D.24672>; else goto <D.24673>;
      <D.24672>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
      <D.24673>:
      D.24674 = ret != 0;
      D.24675 = (long int) D.24674;
      D.24676 = __builtin_expect (D.24675, 0);
      if (D.24676 != 0) goto <D.24677>; else goto <D.24678>;
      <D.24677>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 5652, "ret == 0");
      <D.24678>:
    }
    res = cached;
    if (res == 0B) goto <D.24679>; else goto <D.24680>;
    <D.24679>:
    res = newm;
    cached = res;
    {
      int ret;

      ret = pthread_mutex_unlock (&marshal_mutex.mutex);
      if (ret != 0) goto <D.24681>; else goto <D.24682>;
      <D.24681>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
      <D.24682>:
      D.24683 = ret != 0;
      D.24684 = (long int) D.24683;
      D.24685 = __builtin_expect (D.24684, 0);
      if (D.24685 != 0) goto <D.24686>; else goto <D.24687>;
      <D.24686>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 5657, "ret == 0");
      <D.24687>:
    }
    goto <D.24688>;
    <D.24680>:
    {
      int ret;

      ret = pthread_mutex_unlock (&marshal_mutex.mutex);
      if (ret != 0) goto <D.24689>; else goto <D.24690>;
      <D.24689>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
      <D.24690>:
      D.24691 = ret != 0;
      D.24692 = (long int) D.24691;
      D.24693 = __builtin_expect (D.24692, 0);
      if (D.24693 != 0) goto <D.24694>; else goto <D.24695>;
      <D.24694>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 5659, "ret == 0");
      <D.24695>:
    }
    mono_free_method (newm);
    <D.24688>:
  }
  <D.24671>:
  mono_mb_free (mb);
  D.24640 = res;
  return D.24640;
}


__attribute__((visibility ("hidden")))
mono_marshal_get_stfld_wrapper (struct MonoType * type)
{
  unsigned char D.24697;
  long unsigned int D.24698;
  long unsigned int D.24699;
  int D.24719;
  struct MonoImage * D.24725;
  struct GHashTable * * D.24726;
  struct MonoMethod * D.24729;
  const char * D.24730;
  const char * D.24731;
  struct MonoClass * D.24732;
  struct MonoImage * D.24733;
  struct MonoType * D.24734;
  struct MonoClass * D.24735;
  struct MonoType * D.24736;
  struct MonoType * D.24737;
  struct MonoClass * D.24738;
  struct MonoType * D.24739;
  long unsigned int D.24740;
  long unsigned int D.24741;
  struct MonoMethod * D.24744;
  unsigned int pos.147;
  unsigned int D.24746;
  unsigned char D.24747;
  long unsigned int D.24748;
  _Bool D.24749;
  long int D.24750;
  long int D.24751;
  int D.24754;
  short unsigned int D.24755;
  int D.24756;
  int D.24757;
  struct MonoMethodSignature * sig;
  struct MonoMethodBuilder * mb;
  struct MonoMethod * res;
  struct MonoClass * klass;
  struct GHashTable * cache;
  char * name;
  int t;
  int pos;

  type = mono_type_get_underlying_type (type);
  D.24697 = type->type;
  t = (int) D.24697;
  D.24698 = BIT_FIELD_REF <*type, 64, 64>;
  D.24699 = D.24698 & 8589934592;
  if (D.24699 == 0) goto <D.24700>; else goto <D.24701>;
  <D.24700>:
  D.24697 = type->type;
  if (D.24697 == 29) goto <D.24702>; else goto <D.24703>;
  <D.24702>:
  klass = mono_defaults.array_class;
  goto <D.24704>;
  <D.24703>:
  D.24697 = type->type;
  if (D.24697 == 17) goto <D.24705>; else goto <D.24706>;
  <D.24705>:
  klass = type->data.klass;
  goto <D.24707>;
  <D.24706>:
  if (t == 28) goto <D.24708>; else goto <D.24711>;
  <D.24711>:
  if (t == 18) goto <D.24708>; else goto <D.24712>;
  <D.24712>:
  if (t == 14) goto <D.24708>; else goto <D.24709>;
  <D.24708>:
  klass = mono_defaults.object_class;
  goto <D.24710>;
  <D.24709>:
  if (t == 15) goto <D.24713>; else goto <D.24716>;
  <D.24716>:
  if (t == 27) goto <D.24713>; else goto <D.24714>;
  <D.24713>:
  klass = mono_defaults.int_class;
  goto <D.24715>;
  <D.24714>:
  if (t == 21) goto <D.24717>; else goto <D.24718>;
  <D.24717>:
  D.24719 = mono_type_generic_inst_is_valuetype (type);
  if (D.24719 != 0) goto <D.24720>; else goto <D.24721>;
  <D.24720>:
  klass = mono_class_from_mono_type (type);
  goto <D.24722>;
  <D.24721>:
  klass = mono_defaults.object_class;
  <D.24722>:
  goto <D.24723>;
  <D.24718>:
  klass = mono_class_from_mono_type (type);
  <D.24723>:
  <D.24715>:
  <D.24710>:
  <D.24707>:
  <D.24704>:
  goto <D.24724>;
  <D.24701>:
  klass = mono_defaults.int_class;
  <D.24724>:
  D.24725 = klass->image;
  D.24726 = &D.24725->stfld_wrapper_cache;
  cache = get_cache (D.24726, mono_aligned_addr_hash, 0B);
  res = mono_marshal_find_in_cache (cache, klass);
  if (res != 0B) goto <D.24727>; else goto <D.24728>;
  <D.24727>:
  D.24729 = res;
  return D.24729;
  <D.24728>:
  D.24730 = klass->name_space;
  D.24731 = klass->name;
  name = monoeg_g_strdup_printf ("__stfld_wrapper_%p_%s.%s", klass, D.24730, D.24731);
  D.24732 = mono_defaults.object_class;
  mb = mono_mb_new (D.24732, name, 13);
  monoeg_g_free (name);
  D.24733 = mono_defaults.corlib;
  sig = mono_metadata_signature_alloc (D.24733, 5);
  D.24732 = mono_defaults.object_class;
  D.24734 = &D.24732->byval_arg;
  sig->params[0] = D.24734;
  D.24735 = mono_defaults.int_class;
  D.24736 = &D.24735->byval_arg;
  sig->params[1] = D.24736;
  D.24735 = mono_defaults.int_class;
  D.24736 = &D.24735->byval_arg;
  sig->params[2] = D.24736;
  D.24735 = mono_defaults.int_class;
  D.24736 = &D.24735->byval_arg;
  sig->params[3] = D.24736;
  D.24737 = &klass->byval_arg;
  sig->params[4] = D.24737;
  D.24738 = mono_defaults.void_class;
  D.24739 = &D.24738->byval_arg;
  sig->ret = D.24739;
  mono_mb_emit_ldarg (mb, 0);
  pos = mono_mb_emit_proxy_check (mb, 64);
  mono_mb_emit_ldarg (mb, 0);
  mono_mb_emit_ldarg (mb, 1);
  mono_mb_emit_ldarg (mb, 2);
  mono_mb_emit_ldarg (mb, 4);
  D.24740 = BIT_FIELD_REF <*klass, 64, 256>;
  D.24741 = D.24740 & 1152921504606846976;
  if (D.24741 != 0) goto <D.24742>; else goto <D.24743>;
  <D.24742>:
  mono_mb_emit_op (mb, 140, klass);
  <D.24743>:
  D.24744 = mono_marshal_get_stfld_remote_wrapper (klass);
  mono_mb_emit_managed_call (mb, D.24744, 0B);
  mono_mb_emit_byte (mb, 42);
  pos.147 = (unsigned int) pos;
  mono_mb_patch_branch (mb, pos.147);
  mono_mb_emit_ldarg (mb, 0);
  mono_mb_emit_byte (mb, 240);
  mono_mb_emit_byte (mb, 1);
  mono_mb_emit_ldarg (mb, 3);
  mono_mb_emit_byte (mb, 88);
  mono_mb_emit_ldarg (mb, 4);
  switch (t) <default: <D.20372>, case 2: <D.20348>, case 3: <D.20349>, case 4: <D.20346>, case 5: <D.20347>, case 6: <D.20350>, case 7: <D.20351>, case 8: <D.20352>, case 9: <D.20353>, case 10: <D.20354>, case 11: <D.20355>, case 12: <D.20356>, case 13: <D.20357>, case 14: <D.20362>, case 15: <D.20365>, case 17: <D.20368>, case 18: <D.20361>, case 19: <D.20370>, case 20: <D.20358>, case 21: <D.20369>, case 24: <D.20363>, case 25: <D.20364>, case 27: <D.20366>, case 28: <D.20360>, case 29: <D.20359>, case 30: <D.20371>>
  <D.20346>:
  <D.20347>:
  <D.20348>:
  <D.20349>:
  <D.20350>:
  <D.20351>:
  <D.20352>:
  <D.20353>:
  <D.20354>:
  <D.20355>:
  <D.20356>:
  <D.20357>:
  <D.20358>:
  <D.20359>:
  <D.20360>:
  <D.20361>:
  <D.20362>:
  <D.20363>:
  <D.20364>:
  <D.20365>:
  <D.20366>:
  D.24746 = mono_type_to_stind (type);
  D.24747 = (unsigned char) D.24746;
  mono_mb_emit_byte (mb, D.24747);
  goto <D.20367>;
  <D.20368>:
  D.24740 = BIT_FIELD_REF <*klass, 64, 256>;
  D.24748 = D.24740 & 576460752303423488;
  D.24749 = D.24748 != 0;
  D.24750 = (long int) D.24749;
  D.24751 = __builtin_expect (D.24750, 0);
  if (D.24751 != 0) goto <D.24752>; else goto <D.24753>;
  <D.24752>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 5777, "!klass->enumtype");
  <D.24753>:
  mono_mb_emit_op (mb, 129, klass);
  goto <D.20367>;
  <D.20369>:
  <D.20370>:
  <D.20371>:
  mono_mb_emit_op (mb, 129, klass);
  goto <D.20367>;
  <D.20372>:
  D.24697 = type->type;
  D.24754 = (int) D.24697;
  monoeg_g_log (0B, 16, "type %x not implemented", D.24754);
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "marshal.c", 5787);
  <D.20367>:
  mono_mb_emit_byte (mb, 42);
  D.24755 = sig->param_count;
  D.24756 = (int) D.24755;
  D.24757 = D.24756 + 16;
  res = mono_mb_create_and_cache (cache, klass, mb, sig, D.24757);
  mono_mb_free (mb);
  D.24729 = res;
  return D.24729;
}


__attribute__((visibility ("hidden")))
mono_marshal_get_icall_wrapper (struct MonoMethodSignature * sig, const char * name, const void * func, gboolean check_exceptions)
{
  long unsigned int D.24759;
  long unsigned int D.24760;
  _Bool D.24761;
  long int D.24762;
  long int D.24763;
  struct MonoClass * D.24766;
  struct MonoMethod * D.24767;
  long unsigned int D.24768;
  struct MonoImage * D.24771;
  <unnamed-unsigned:1> D.24775;
  int D.24776;
  int D.24777;
  unsigned int D.24778;
  short unsigned int D.24779;
  int D.24780;
  long unsigned int D.24783;
  long unsigned int D.24784;
  short unsigned int D.24787;
  int D.24788;
  int D.24789;
  struct MonoMethod * D.24790;
  struct MonoMethodSignature * csig;
  struct MonoMethodSignature * csig2;
  struct MonoMethodBuilder * mb;
  struct MonoMethod * res;
  int i;
  struct WrapperInfo * info;

  D.24759 = BIT_FIELD_REF <*sig, 64, 64>;
  D.24760 = D.24759 & 128;
  D.24761 = D.24760 == 0;
  D.24762 = (long int) D.24761;
  D.24763 = __builtin_expect (D.24762, 0);
  if (D.24763 != 0) goto <D.24764>; else goto <D.24765>;
  <D.24764>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 5815, "sig->pinvoke");
  <D.24765>:
  D.24766 = mono_defaults.object_class;
  mb = mono_mb_new (D.24766, name, 6);
  D.24767 = mb->method;
  D.24767->save_lmf = 1;
  D.24759 = BIT_FIELD_REF <*sig, 64, 64>;
  D.24768 = D.24759 & 512;
  if (D.24768 != 0) goto <D.24769>; else goto <D.24770>;
  <D.24769>:
  D.24771 = mono_defaults.corlib;
  D.24766 = mono_defaults.object_class;
  csig2 = signature_dup_add_this (D.24771, sig, D.24766);
  goto <D.24772>;
  <D.24770>:
  D.24771 = mono_defaults.corlib;
  csig2 = signature_dup (D.24771, sig);
  <D.24772>:
  D.24759 = BIT_FIELD_REF <*sig, 64, 64>;
  D.24768 = D.24759 & 512;
  if (D.24768 != 0) goto <D.24773>; else goto <D.24774>;
  <D.24773>:
  mono_mb_emit_byte (mb, 2);
  <D.24774>:
  i = 0;
  goto <D.20386>;
  <D.20385>:
  D.24775 = sig->hasthis;
  D.24776 = (int) D.24775;
  D.24777 = D.24776 + i;
  D.24778 = (unsigned int) D.24777;
  mono_mb_emit_ldarg (mb, D.24778);
  i = i + 1;
  <D.20386>:
  D.24779 = sig->param_count;
  D.24780 = (int) D.24779;
  if (D.24780 > i) goto <D.20385>; else goto <D.20387>;
  <D.20387>:
  mono_mb_emit_byte (mb, 240);
  mono_mb_emit_op (mb, 19, func);
  mono_mb_emit_calli (mb, csig2);
  if (check_exceptions != 0) goto <D.24781>; else goto <D.24782>;
  <D.24781>:
  emit_thread_interrupt_checkpoint (mb);
  <D.24782>:
  mono_mb_emit_byte (mb, 42);
  D.24771 = mono_defaults.corlib;
  csig = signature_dup (D.24771, sig);
  csig->pinvoke = 0;
  D.24783 = BIT_FIELD_REF <*csig, 64, 64>;
  D.24784 = D.24783 & 64512;
  if (D.24784 == 5120) goto <D.24785>; else goto <D.24786>;
  <D.24785>:
  csig->call_convention = 0;
  <D.24786>:
  D.24787 = csig->param_count;
  D.24788 = (int) D.24787;
  D.24789 = D.24788 + 16;
  res = mono_mb_create_method (mb, csig, D.24789);
  mono_mb_free (mb);
  info = mono_wrapper_info_create (res, 15);
  info->d.icall.func = func;
  mono_marshal_set_wrapper_info (res, info);
  D.24790 = res;
  return D.24790;
}


signature_dup_add_this (struct MonoImage * image, struct MonoMethodSignature * sig, struct MonoClass * klass)
{
  short unsigned int D.24792;
  int D.24793;
  int D.24794;
  unsigned int D.24795;
  short unsigned int D.24796;
  int D.24797;
  struct MonoType * D.24798;
  struct MonoType * iftmp.148;
  long unsigned int D.24800;
  long unsigned int D.24801;
  struct MonoMethodSignature * D.24805;
  struct MonoMethodSignature * res;
  int i;

  D.24792 = sig->param_count;
  D.24793 = (int) D.24792;
  D.24794 = D.24793 + 1;
  D.24795 = (unsigned int) D.24794;
  res = mono_metadata_signature_alloc (image, D.24795);
  memcpy (res, sig, 16);
  D.24792 = sig->param_count;
  D.24796 = D.24792 + 1;
  res->param_count = D.24796;
  res->hasthis = 0;
  D.24792 = sig->param_count;
  D.24793 = (int) D.24792;
  i = D.24793 + -1;
  goto <D.20065>;
  <D.20064>:
  D.24797 = i + 1;
  D.24798 = sig->params[i];
  res->params[D.24797] = D.24798;
  i = i + -1;
  <D.20065>:
  if (i >= 0) goto <D.20064>; else goto <D.20066>;
  <D.20066>:
  D.24800 = BIT_FIELD_REF <*klass, 64, 256>;
  D.24801 = D.24800 & 1152921504606846976;
  if (D.24801 != 0) goto <D.24802>; else goto <D.24803>;
  <D.24802>:
  iftmp.148 = &klass->this_arg;
  goto <D.24804>;
  <D.24803>:
  iftmp.148 = &klass->byval_arg;
  <D.24804>:
  res->params[0] = iftmp.148;
  D.24805 = res;
  return D.24805;
}


__attribute__((visibility ("hidden")))
mono_marshal_emit_native_wrapper (struct MonoImage * image, struct MonoMethodBuilder * mb, struct MonoMethodSignature * sig, struct MonoMethodPInvoke * piinfo, struct MonoMarshalSpec * * mspecs, void * func, gboolean aot, gboolean check_exceptions, gboolean func_param)
{
  long unsigned int D.24809;
  long unsigned int D.24810;
  _Bool D.24811;
  long int D.24812;
  long int D.24813;
  struct MonoMethod * D.24816;
  struct MonoClass * D.24817;
  struct MonoImage * D.24818;
  struct MonoClass * D.24821;
  struct MonoType * D.24822;
  struct MonoClass * D.24823;
  struct MonoType * D.24824;
  struct MonoType * D.24825;
  int D.24826;
  struct MonoMarshalSpec * D.24829;
  <unnamed type> D.24832;
  short unsigned int D.24835;
  long unsigned int D.24836;
  long unsigned int D.24837;
  int D.24838;
  int D.24839;
  long unsigned int D.24840;
  long unsigned int D.24841;
  void * D.24842;
  long unsigned int D.24843;
  long unsigned int D.24844;
  int * D.24845;
  int D.24846;
  struct MonoType * D.24847;
  sizetype D.24848;
  sizetype D.24849;
  sizetype D.24850;
  struct MonoMarshalSpec * * D.24851;
  struct MonoMarshalSpec * D.24852;
  struct MonoType * * D.24853;
  int D.24854;
  int D.24857;
  unsigned int D.24861;
  unsigned int D.24862;
  struct MonoMethod * D.24865;
  short unsigned int D.24870;
  int D.24871;
  int D.24872;
  struct MonoMethodSignature * get_last_error_sig.149;
  struct MonoImage * D.24878;
  struct MonoMethodSignature * get_last_error_sig.150;
  long unsigned int D.24880;
  long unsigned int D.24881;
  unsigned char D.24884;
  <unnamed type> D.24887;
  long unsigned int D.24889;
  long unsigned int D.24890;
  struct MonoClass * D.24893;
  struct MonoType * D.24894;
  unsigned char D.24895;
  int D.24896;
  <unnamed type> D.24904;
  unsigned char D.24906;
  int D.24907;
  int D.24909;
  struct EmitMarshalContext m;
  struct MonoMethodSignature * csig;
  struct MonoClass * klass;
  int i;
  int argnum;
  int * tmp_locals;
  int type;
  int param_shift;
  static struct MonoMethodSignature * get_last_error_sig = 0B;
  void handle_enum = <<< error >>>;

  try
    {
      param_shift = 0;
      m.mb = mb;
      m.piinfo = piinfo;
      if (func_param != 0) goto <D.24807>; else goto <D.24808>;
      <D.24807>:
      D.24809 = BIT_FIELD_REF <*sig, 64, 64>;
      D.24810 = D.24809 & 512;
      D.24811 = D.24810 != 0;
      D.24812 = (long int) D.24811;
      D.24813 = __builtin_expect (D.24812, 0);
      if (D.24813 != 0) goto <D.24814>; else goto <D.24815>;
      <D.24814>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 8635, "!sig->hasthis");
      <D.24815>:
      param_shift = param_shift + 1;
      <D.24808>:
      D.24816 = mb->method;
      D.24817 = D.24816->klass;
      D.24818 = D.24817->image;
      csig = signature_dup (D.24818, sig);
      csig->pinvoke = 1;
      m.csig = csig;
      m.image = image;
      D.24809 = BIT_FIELD_REF <*sig, 64, 64>;
      D.24810 = D.24809 & 512;
      if (D.24810 != 0) goto <D.24819>; else goto <D.24820>;
      <D.24819>:
      param_shift = param_shift + 1;
      <D.24820>:
      D.24821 = mono_defaults.int_class;
      D.24822 = &D.24821->byval_arg;
      mono_mb_add_local (mb, D.24822);
      D.24821 = mono_defaults.int_class;
      D.24822 = &D.24821->byval_arg;
      mono_mb_add_local (mb, D.24822);
      D.24823 = mono_defaults.boolean_class;
      D.24824 = &D.24823->byval_arg;
      mono_mb_add_local (mb, D.24824);
      mono_mb_emit_icon (mb, 0);
      mono_mb_emit_stloc (mb, 2);
      D.24825 = sig->ret;
      D.24826 = mono_type_is_void (D.24825);
      if (D.24826 == 0) goto <D.24827>; else goto <D.24828>;
      <D.24827>:
      D.24825 = sig->ret;
      mono_mb_add_local (mb, D.24825);
      <D.24828>:
      D.24829 = *mspecs;
      if (D.24829 != 0B) goto <D.24830>; else goto <D.24831>;
      <D.24830>:
      D.24829 = *mspecs;
      D.24832 = D.24829->native;
      if (D.24832 == 44) goto <D.24833>; else goto <D.24834>;
      <D.24833>:
      D.24821 = mono_defaults.int_class;
      D.24822 = &D.24821->byval_arg;
      csig->ret = D.24822;
      <D.24834>:
      <D.24831>:
      D.24835 = sig->param_count;
      D.24836 = (long unsigned int) D.24835;
      D.24837 = D.24836 * 4;
      tmp_locals = __builtin_alloca (D.24837);
      D.24835 = sig->param_count;
      D.24838 = (int) D.24835;
      D.24839 = D.24838 + 1;
      D.24840 = (long unsigned int) D.24839;
      D.24841 = D.24840 * 4;
      D.24842 = __builtin_alloca (D.24841);
      m.orig_conv_args = D.24842;
      i = 0;
      goto <D.20875>;
      <D.20874>:
      D.24843 = (long unsigned int) i;
      D.24844 = D.24843 * 4;
      D.24845 = tmp_locals + D.24844;
      D.24846 = i + param_shift;
      D.24847 = sig->params[i];
      D.24848 = (sizetype) i;
      D.24849 = D.24848 + 1;
      D.24850 = D.24849 * 8;
      D.24851 = mspecs + D.24850;
      D.24852 = *D.24851;
      D.24853 = &csig->params[i];
      D.24854 = emit_marshal (&m, D.24846, D.24847, D.24852, 0, D.24853, 0);
      *D.24845 = D.24854;
      i = i + 1;
      <D.20875>:
      D.24835 = sig->param_count;
      D.24838 = (int) D.24835;
      if (D.24838 > i) goto <D.20874>; else goto <D.20876>;
      <D.20876>:
      D.24809 = BIT_FIELD_REF <*sig, 64, 64>;
      D.24810 = D.24809 & 512;
      if (D.24810 != 0) goto <D.24855>; else goto <D.24856>;
      <D.24855>:
      mono_mb_emit_byte (mb, 2);
      <D.24856>:
      i = 0;
      goto <D.20878>;
      <D.20877>:
      D.24846 = i + param_shift;
      D.24847 = sig->params[i];
      D.24848 = (sizetype) i;
      D.24849 = D.24848 + 1;
      D.24850 = D.24849 * 8;
      D.24851 = mspecs + D.24850;
      D.24852 = *D.24851;
      D.24843 = (long unsigned int) i;
      D.24844 = D.24843 * 4;
      D.24845 = tmp_locals + D.24844;
      D.24857 = *D.24845;
      emit_marshal (&m, D.24846, D.24847, D.24852, D.24857, 0B, 1);
      i = i + 1;
      <D.20878>:
      D.24835 = sig->param_count;
      D.24838 = (int) D.24835;
      if (D.24838 > i) goto <D.20877>; else goto <D.20879>;
      <D.20879>:
      if (func_param != 0) goto <D.24858>; else goto <D.24859>;
      <D.24858>:
      mono_mb_emit_byte (mb, 2);
      D.24821 = mono_defaults.int_class;
      mono_mb_emit_op (mb, 121, D.24821);
      mono_mb_emit_byte (mb, 77);
      mono_mb_emit_calli (mb, csig);
      goto <D.24860>;
      <D.24859>:
      D.24816 = mb->method;
      D.24817 = D.24816->klass;
      D.24861 = D.24817->flags;
      D.24862 = D.24861 & 4096;
      if (D.24862 != 0) goto <D.24863>; else goto <D.24864>;
      <D.24863>:
      D.24865 = &piinfo->method;
      mono_mb_emit_cominterop_call (mb, csig, D.24865);
      goto <D.24866>;
      <D.24864>:
      if (aot != 0) goto <D.24867>; else goto <D.24868>;
      <D.24867>:
      mono_mb_emit_byte (mb, 240);
      D.24865 = &piinfo->method;
      mono_mb_emit_op (mb, 14, D.24865);
      mono_mb_emit_calli (mb, csig);
      goto <D.24869>;
      <D.24868>:
      mono_mb_emit_native_call (mb, csig, func);
      <D.24869>:
      <D.24866>:
      <D.24860>:
      D.24870 = piinfo->piflags;
      D.24871 = (int) D.24870;
      D.24872 = D.24871 & 64;
      if (D.24872 != 0) goto <D.24873>; else goto <D.24874>;
      <D.24873>:
      get_last_error_sig.149 = get_last_error_sig;
      if (get_last_error_sig.149 == 0B) goto <D.24876>; else goto <D.24877>;
      <D.24876>:
      D.24878 = mono_defaults.corlib;
      get_last_error_sig.150 = mono_metadata_signature_alloc (D.24878, 0);
      get_last_error_sig = get_last_error_sig.150;
      get_last_error_sig.149 = get_last_error_sig;
      D.24821 = mono_defaults.int_class;
      D.24822 = &D.24821->byval_arg;
      get_last_error_sig.149->ret = D.24822;
      get_last_error_sig.149 = get_last_error_sig;
      get_last_error_sig.149->pinvoke = 1;
      <D.24877>:
      mono_mb_emit_icall (mb, mono_marshal_set_last_error);
      <D.24874>:
      D.24825 = sig->ret;
      D.24880 = BIT_FIELD_REF <*D.24825, 64, 64>;
      D.24881 = D.24880 & 8589934592;
      if (D.24881 == 0) goto <D.24882>; else goto <D.24883>;
      <D.24882>:
      {
        struct MonoMarshalSpec * spec;

        spec = *mspecs;
        D.24825 = sig->ret;
        D.24884 = D.24825->type;
        type = (int) D.24884;
        if (spec != 0B) goto <D.24886>; else goto <D.24885>;
        <D.24886>:
        D.24887 = spec->native;
        if (D.24887 == 44) goto <D.24888>; else goto <D.24885>;
        <D.24888>:
        D.24825 = sig->ret;
        emit_marshal (&m, 0, D.24825, spec, 0, 0B, 3);
        goto <D.20883>;
        <D.24885>:
        handle_enum:
        switch (type) <default: <D.20908>, case 1: <D.20882>, case 2: <D.20901>, case 3: <D.20904>, case 4: <D.20885>, case 5: <D.20886>, case 6: <D.20887>, case 7: <D.20888>, case 8: <D.20889>, case 9: <D.20890>, case 10: <D.20895>, case 11: <D.20896>, case 12: <D.20893>, case 13: <D.20894>, case 14: <D.20898>, case 15: <D.20905>, case 17: <D.20884>, case 18: <D.20899>, case 20: <D.20902>, case 21: <D.20906>, case 22: <D.20907>, case 24: <D.20891>, case 25: <D.20892>, case 27: <D.20897>, case 28: <D.20900>, case 29: <D.20903>>
        <D.20882>:
        goto <D.20883>;
        <D.20884>:
        D.24825 = sig->ret;
        klass = D.24825->data.klass;
        D.24889 = BIT_FIELD_REF <*klass, 64, 256>;
        D.24890 = D.24889 & 576460752303423488;
        if (D.24890 != 0) goto <D.24891>; else goto <D.24892>;
        <D.24891>:
        D.24825 = sig->ret;
        D.24893 = D.24825->data.klass;
        D.24894 = mono_class_enum_basetype (D.24893);
        D.24895 = D.24894->type;
        type = (int) D.24895;
        goto handle_enum;
        <D.24892>:
        D.24825 = sig->ret;
        emit_marshal (&m, 0, D.24825, spec, 0, 0B, 3);
        goto <D.20883>;
        <D.20885>:
        <D.20886>:
        <D.20887>:
        <D.20888>:
        <D.20889>:
        <D.20890>:
        <D.20891>:
        <D.20892>:
        <D.20893>:
        <D.20894>:
        <D.20895>:
        <D.20896>:
        <D.20897>:
        <D.20898>:
        <D.20899>:
        <D.20900>:
        <D.20901>:
        <D.20902>:
        <D.20903>:
        <D.20904>:
        <D.20905>:
        <D.20906>:
        D.24825 = sig->ret;
        emit_marshal (&m, 0, D.24825, spec, 0, 0B, 3);
        goto <D.20883>;
        <D.20907>:
        <D.20908>:
        D.24825 = sig->ret;
        D.24884 = D.24825->type;
        D.24896 = (int) D.24884;
        monoeg_g_log (0B, 16, "return type 0x%02x unknown", D.24896);
        monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "marshal.c", 8782);
        <D.20883>:
      }
      goto <D.24897>;
      <D.24883>:
      mono_mb_emit_stloc (mb, 3);
      <D.24897>:
      if (check_exceptions != 0) goto <D.24898>; else goto <D.24899>;
      <D.24898>:
      emit_thread_interrupt_checkpoint (mb);
      <D.24899>:
      i = 0;
      goto <D.20920>;
      <D.20919>:
      {
        struct MonoType * t;
        struct MonoMarshalSpec * spec;

        t = sig->params[i];
        D.24848 = (sizetype) i;
        D.24849 = D.24848 + 1;
        D.24850 = D.24849 * 8;
        D.24851 = mspecs + D.24850;
        spec = *D.24851;
        argnum = i + param_shift;
        if (spec != 0B) goto <D.24902>; else goto <D.24903>;
        <D.24902>:
        D.24904 = spec->native;
        if (D.24904 == 44) goto <D.24900>; else goto <D.24905>;
        <D.24905>:
        D.24904 = spec->native;
        if (D.24904 == 40) goto <D.24900>; else goto <D.24901>;
        <D.24900>:
        D.24843 = (long unsigned int) i;
        D.24844 = D.24843 * 4;
        D.24845 = tmp_locals + D.24844;
        D.24857 = *D.24845;
        emit_marshal (&m, argnum, t, spec, D.24857, 0B, 2);
        // predicted unlikely by continue predictor.
        goto <D.20911>;
        <D.24901>:
        <D.24903>:
        D.24906 = t->type;
        D.24907 = (int) D.24906;
        switch (D.24907) <default: <D.24908>, case 2: <D.20917>, case 14: <D.20912>, case 17: <D.20913>, case 18: <D.20914>, case 28: <D.20915>, case 29: <D.20916>>
        <D.20912>:
        <D.20913>:
        <D.20914>:
        <D.20915>:
        <D.20916>:
        <D.20917>:
        D.24843 = (long unsigned int) i;
        D.24844 = D.24843 * 4;
        D.24845 = tmp_locals + D.24844;
        D.24857 = *D.24845;
        emit_marshal (&m, argnum, t, spec, D.24857, 0B, 2);
        goto <D.20918>;
        <D.24908>:
        <D.20918>:
      }
      <D.20911>:
      i = i + 1;
      <D.20920>:
      D.24835 = sig->param_count;
      D.24838 = (int) D.24835;
      if (D.24838 > i) goto <D.20919>; else goto <D.20921>;
      <D.20921>:
      D.24825 = sig->ret;
      D.24909 = mono_type_is_void (D.24825);
      if (D.24909 == 0) goto <D.24910>; else goto <D.24911>;
      <D.24910>:
      mono_mb_emit_ldloc (mb, 3);
      <D.24911>:
      mono_mb_emit_byte (mb, 42);
    }
  finally
    {
      m = {CLOBBER};
    }
}


emit_marshal (struct EmitMarshalContext * m, int argnum, struct MonoType * t, struct MonoMarshalSpec * spec, int conv_arg, struct MonoType * * conv_arg_type, MarshalAction action)
{
  struct MonoClass * D.24914;
  <unnamed type> D.24917;
  int D.24920;
  unsigned char D.24925;
  int D.24926;
  struct MonoClass * D.24927;
  struct MonoClass * D.24928;
  unsigned int D.24939;
  <unnamed type> D.24947;
  struct MonoClass * D.24952;
  int D.24957;
  int D.24960;

  D.24914 = mono_class_from_mono_type (t);
  mono_marshal_load_type_info (D.24914);
  if (spec != 0B) goto <D.24915>; else goto <D.24916>;
  <D.24915>:
  D.24917 = spec->native;
  if (D.24917 == 44) goto <D.24918>; else goto <D.24919>;
  <D.24918>:
  D.24920 = emit_marshal_custom (m, argnum, t, spec, conv_arg, conv_arg_type, action);
  return D.24920;
  <D.24919>:
  <D.24916>:
  if (spec != 0B) goto <D.24921>; else goto <D.24922>;
  <D.24921>:
  D.24917 = spec->native;
  if (D.24917 == 40) goto <D.24923>; else goto <D.24924>;
  <D.24923>:
  D.24920 = emit_marshal_asany (m, argnum, t, spec, conv_arg, conv_arg_type, action);
  return D.24920;
  <D.24924>:
  <D.24922>:
  D.24925 = t->type;
  D.24926 = (int) D.24925;
  switch (D.24926) <default: <D.24963>, case 2: <D.20837>, case 3: <D.20839>, case 4: <D.20840>, case 5: <D.20841>, case 6: <D.20842>, case 7: <D.20843>, case 8: <D.20844>, case 9: <D.20845>, case 10: <D.20850>, case 11: <D.20851>, case 12: <D.20848>, case 13: <D.20849>, case 14: <D.20832>, case 15: <D.20838>, case 17: <D.20831>, case 18: <D.20833>, case 20: <D.20835>, case 21: <D.20853>, case 24: <D.20846>, case 25: <D.20847>, case 27: <D.20852>, case 28: <D.20834>, case 29: <D.20836>>
  <D.20831>:
  D.24927 = t->data.klass;
  D.24928 = mono_defaults.handleref_class;
  if (D.24927 == D.24928) goto <D.24929>; else goto <D.24930>;
  <D.24929>:
  D.24920 = emit_marshal_handleref (m, argnum, t, spec, conv_arg, conv_arg_type, action);
  return D.24920;
  <D.24930>:
  D.24920 = emit_marshal_vtype (m, argnum, t, spec, conv_arg, conv_arg_type, action);
  return D.24920;
  <D.20832>:
  D.24920 = emit_marshal_string (m, argnum, t, spec, conv_arg, conv_arg_type, action);
  return D.24920;
  <D.20833>:
  <D.20834>:
  if (spec != 0B) goto <D.24931>; else goto <D.24932>;
  <D.24931>:
  D.24917 = spec->native;
  if (D.24917 == 27) goto <D.24933>; else goto <D.24934>;
  <D.24933>:
  D.24920 = emit_marshal_variant (m, argnum, t, spec, conv_arg, conv_arg_type, action);
  return D.24920;
  <D.24934>:
  <D.24932>:
  if (spec != 0B) goto <D.24937>; else goto <D.24938>;
  <D.24937>:
  D.24917 = spec->native;
  D.24939 = D.24917 + 4294967271;
  if (D.24939 <= 1) goto <D.24935>; else goto <D.24940>;
  <D.24940>:
  D.24917 = spec->native;
  if (D.24917 == 28) goto <D.24935>; else goto <D.24936>;
  <D.24935>:
  D.24920 = mono_cominterop_emit_marshal_com_interface (m, argnum, t, spec, conv_arg, conv_arg_type, action);
  return D.24920;
  <D.24936>:
  <D.24938>:
  if (spec != 0B) goto <D.24943>; else goto <D.24944>;
  <D.24943>:
  D.24917 = spec->native;
  if (D.24917 == 29) goto <D.24945>; else goto <D.24946>;
  <D.24945>:
  D.24947 = spec->data.safearray_data.elem_type;
  if (D.24947 == 12) goto <D.24948>; else goto <D.24949>;
  <D.24948>:
  if (action == 2) goto <D.24941>; else goto <D.24950>;
  <D.24950>:
  if (action == 0) goto <D.24941>; else goto <D.24951>;
  <D.24951>:
  if (action == 1) goto <D.24941>; else goto <D.24942>;
  <D.24941>:
  D.24920 = mono_cominterop_emit_marshal_safearray (m, argnum, t, spec, conv_arg, conv_arg_type, action);
  return D.24920;
  <D.24942>:
  <D.24949>:
  <D.24946>:
  <D.24944>:
  D.24952 = mono_defaults.safehandle_class;
  if (D.24952 != 0B) goto <D.24953>; else goto <D.24954>;
  <D.24953>:
  D.24927 = t->data.klass;
  if (D.24927 != 0B) goto <D.24955>; else goto <D.24956>;
  <D.24955>:
  D.24927 = t->data.klass;
  D.24952 = mono_defaults.safehandle_class;
  D.24957 = mono_class_is_subclass_of (D.24927, D.24952, 0);
  if (D.24957 != 0) goto <D.24958>; else goto <D.24959>;
  <D.24958>:
  D.24920 = emit_marshal_safehandle (m, argnum, t, spec, conv_arg, conv_arg_type, action);
  return D.24920;
  <D.24959>:
  <D.24956>:
  <D.24954>:
  D.24920 = emit_marshal_object (m, argnum, t, spec, conv_arg, conv_arg_type, action);
  return D.24920;
  <D.20835>:
  <D.20836>:
  D.24920 = emit_marshal_array (m, argnum, t, spec, conv_arg, conv_arg_type, action);
  return D.24920;
  <D.20837>:
  D.24920 = emit_marshal_boolean (m, argnum, t, spec, conv_arg, conv_arg_type, action);
  return D.24920;
  <D.20838>:
  D.24920 = emit_marshal_ptr (m, argnum, t, spec, conv_arg, conv_arg_type, action);
  return D.24920;
  <D.20839>:
  D.24920 = emit_marshal_char (m, argnum, t, spec, conv_arg, conv_arg_type, action);
  return D.24920;
  <D.20840>:
  <D.20841>:
  <D.20842>:
  <D.20843>:
  <D.20844>:
  <D.20845>:
  <D.20846>:
  <D.20847>:
  <D.20848>:
  <D.20849>:
  <D.20850>:
  <D.20851>:
  <D.20852>:
  D.24920 = emit_marshal_scalar (m, argnum, t, spec, conv_arg, conv_arg_type, action);
  return D.24920;
  <D.20853>:
  D.24960 = mono_type_generic_inst_is_valuetype (t);
  if (D.24960 != 0) goto <D.24961>; else goto <D.24962>;
  <D.24961>:
  D.24920 = emit_marshal_vtype (m, argnum, t, spec, conv_arg, conv_arg_type, action);
  return D.24920;
  <D.24962>:
  D.24920 = emit_marshal_object (m, argnum, t, spec, conv_arg, conv_arg_type, action);
  return D.24920;
  <D.24963>:
  D.24920 = conv_arg;
  return D.24920;
}


emit_marshal_custom (struct EmitMarshalContext * m, int argnum, struct MonoType * t, struct MonoMarshalSpec * spec, int conv_arg, struct MonoType * * conv_arg_type, MarshalAction action)
{
  struct MonoClass * ICustomMarshaler.151;
  struct MonoImage * D.24968;
  struct MonoClass * ICustomMarshaler.152;
  struct MonoMethod * cleanup_native.153;
  struct MonoMethod * cleanup_native.154;
  _Bool D.24974;
  long int D.24975;
  long int D.24976;
  struct MonoMethod * cleanup_managed.155;
  struct MonoMethod * cleanup_managed.156;
  _Bool D.24981;
  long int D.24982;
  long int D.24983;
  struct MonoMethod * marshal_managed_to_native.157;
  struct MonoMethod * marshal_managed_to_native.158;
  _Bool D.24988;
  long int D.24989;
  long int D.24990;
  struct MonoMethod * marshal_native_to_managed.159;
  struct MonoMethod * marshal_native_to_managed.160;
  _Bool D.24995;
  long int D.24996;
  long int D.24997;
  char * D.25000;
  struct MonoImage * D.25001;
  _Bool D.25002;
  long int D.25003;
  long int D.25004;
  _Bool D.25007;
  long int D.25008;
  long int D.25009;
  int D.25012;
  const char * D.25015;
  struct MonoType * D.25020;
  unsigned char D.25021;
  struct MonoClass * D.25023;
  struct MonoType * D.25025;
  unsigned char D.25026;
  int D.25034;
  unsigned char D.25035;
  int D.25036;
  struct MonoClass * D.25037;
  struct MonoType * D.25038;
  unsigned int conv_arg.161;
  long unsigned int D.25040;
  long unsigned int D.25041;
  short unsigned int D.25044;
  int D.25045;
  int D.25046;
  unsigned int D.25050;
  unsigned int D.25051;
  unsigned int argnum.162;
  unsigned int D.25056;
  char * D.25057;
  gchar * D.25058;
  struct MonoClass * D.25063;
  unsigned int pos2.163;
  unsigned int D.25065;
  gchar * D.25068;
  gchar * D.25072;
  gchar * D.25073;
  int D.25077;
  unsigned int D.25078;
  gchar * D.25079;
  struct MonoClass * D.25080;
  struct MonoType * D.25081;
  unsigned int D.25087;
  gchar * D.25088;
  _Bool D.25091;
  long int D.25092;
  long int D.25093;
  int D.25096;
  unsigned int D.25097;
  gchar * D.25098;
  unsigned int D.25099;
  gchar * D.25102;
  gchar * D.25103;
  struct MonoType * mtype;
  struct MonoClass * mklass;
  static struct MonoClass * ICustomMarshaler = 0B;
  static struct MonoMethod * cleanup_native;
  static struct MonoMethod * cleanup_managed;
  static struct MonoMethod * marshal_managed_to_native;
  static struct MonoMethod * marshal_native_to_managed;
  struct MonoMethod * get_instance;
  struct MonoMethodBuilder * mb;
  char * exception_msg;
  guint32 loc1;
  int pos2;
  void handle_exception = <<< error >>>;

  get_instance = 0B;
  mb = m->mb;
  exception_msg = 0B;
  ICustomMarshaler.151 = ICustomMarshaler;
  if (ICustomMarshaler.151 == 0B) goto <D.24966>; else goto <D.24967>;
  <D.24966>:
  D.24968 = mono_defaults.corlib;
  ICustomMarshaler.152 = mono_class_from_name (D.24968, "System.Runtime.InteropServices", "ICustomMarshaler");
  ICustomMarshaler = ICustomMarshaler.152;
  ICustomMarshaler.151 = ICustomMarshaler;
  if (ICustomMarshaler.151 == 0B) goto <D.24970>; else goto <D.24971>;
  <D.24970>:
  exception_msg = monoeg_strdup ("Current profile doesn\'t support ICustomMarshaler");
  goto handle_exception;
  <D.24971>:
  ICustomMarshaler.151 = ICustomMarshaler;
  cleanup_native.153 = mono_class_get_method_from_name (ICustomMarshaler.151, "CleanUpNativeData", 1);
  cleanup_native = cleanup_native.153;
  cleanup_native.154 = cleanup_native;
  D.24974 = cleanup_native.154 == 0B;
  D.24975 = (long int) D.24974;
  D.24976 = __builtin_expect (D.24975, 0);
  if (D.24976 != 0) goto <D.24977>; else goto <D.24978>;
  <D.24977>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 5887, "cleanup_native");
  <D.24978>:
  ICustomMarshaler.151 = ICustomMarshaler;
  cleanup_managed.155 = mono_class_get_method_from_name (ICustomMarshaler.151, "CleanUpManagedData", 1);
  cleanup_managed = cleanup_managed.155;
  cleanup_managed.156 = cleanup_managed;
  D.24981 = cleanup_managed.156 == 0B;
  D.24982 = (long int) D.24981;
  D.24983 = __builtin_expect (D.24982, 0);
  if (D.24983 != 0) goto <D.24984>; else goto <D.24985>;
  <D.24984>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 5889, "cleanup_managed");
  <D.24985>:
  ICustomMarshaler.151 = ICustomMarshaler;
  marshal_managed_to_native.157 = mono_class_get_method_from_name (ICustomMarshaler.151, "MarshalManagedToNative", 1);
  marshal_managed_to_native = marshal_managed_to_native.157;
  marshal_managed_to_native.158 = marshal_managed_to_native;
  D.24988 = marshal_managed_to_native.158 == 0B;
  D.24989 = (long int) D.24988;
  D.24990 = __builtin_expect (D.24989, 0);
  if (D.24990 != 0) goto <D.24991>; else goto <D.24992>;
  <D.24991>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 5891, "marshal_managed_to_native");
  <D.24992>:
  ICustomMarshaler.151 = ICustomMarshaler;
  marshal_native_to_managed.159 = mono_class_get_method_from_name (ICustomMarshaler.151, "MarshalNativeToManaged", 1);
  marshal_native_to_managed = marshal_native_to_managed.159;
  marshal_native_to_managed.160 = marshal_native_to_managed;
  D.24995 = marshal_native_to_managed.160 == 0B;
  D.24996 = (long int) D.24995;
  D.24997 = __builtin_expect (D.24996, 0);
  if (D.24997 != 0) goto <D.24998>; else goto <D.24999>;
  <D.24998>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 5893, "marshal_native_to_managed");
  <D.24999>:
  <D.24967>:
  D.25000 = spec->data.custom_data.custom_name;
  D.25001 = m->image;
  mtype = mono_reflection_type_from_name (D.25000, D.25001);
  D.25002 = mtype == 0B;
  D.25003 = (long int) D.25002;
  D.25004 = __builtin_expect (D.25003, 0);
  if (D.25004 != 0) goto <D.25005>; else goto <D.25006>;
  <D.25005>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 5897, "mtype != NULL");
  <D.25006>:
  mklass = mono_class_from_mono_type (mtype);
  D.25007 = mklass == 0B;
  D.25008 = (long int) D.25007;
  D.25009 = __builtin_expect (D.25008, 0);
  if (D.25009 != 0) goto <D.25010>; else goto <D.25011>;
  <D.25010>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 5899, "mklass != NULL");
  <D.25011>:
  ICustomMarshaler.151 = ICustomMarshaler;
  D.25012 = mono_class_is_assignable_from (ICustomMarshaler.151, mklass);
  if (D.25012 == 0) goto <D.25013>; else goto <D.25014>;
  <D.25013>:
  D.25015 = mklass->name;
  exception_msg = monoeg_g_strdup_printf ("Custom marshaler \'%s\' does not implement the ICustomMarshaler interface.", D.25015);
  <D.25014>:
  get_instance = mono_class_get_method_from_name_flags (mklass, "GetInstance", 1, 16);
  if (get_instance != 0B) goto <D.25016>; else goto <D.25017>;
  <D.25016>:
  {
    struct MonoMethodSignature * get_sig;

    get_sig = mono_method_signature (get_instance);
    D.25020 = get_sig->ret;
    D.25021 = D.25020->type;
    if (D.25021 != 18) goto <D.25018>; else goto <D.25022>;
    <D.25022>:
    D.25020 = get_sig->ret;
    D.25023 = mono_class_from_mono_type (D.25020);
    ICustomMarshaler.151 = ICustomMarshaler;
    if (D.25023 != ICustomMarshaler.151) goto <D.25018>; else goto <D.25024>;
    <D.25024>:
    D.25025 = get_sig->params[0];
    D.25026 = D.25025->type;
    if (D.25026 != 14) goto <D.25018>; else goto <D.25019>;
    <D.25018>:
    get_instance = 0B;
    <D.25019>:
  }
  <D.25017>:
  if (get_instance == 0B) goto <D.25027>; else goto <D.25028>;
  <D.25027>:
  D.25015 = mklass->name;
  exception_msg = monoeg_g_strdup_printf ("Custom marshaler \'%s\' does not implement a static GetInstance method that takes a single string parameter and returns an ICustomMarshaler.", D.25015);
  <D.25028>:
  handle_exception:
  if (exception_msg != 0B) goto <D.25029>; else goto <D.25030>;
  <D.25029>:
  switch (action) <default: <D.20416>, case 0: <D.20411>, case 1: <D.20415>, case 3: <D.20412>, case 6: <D.20413>>
  <D.20411>:
  <D.20412>:
  <D.20413>:
  if (action == 3) goto <D.25031>; else goto <D.25033>;
  <D.25033>:
  if (action == 6) goto <D.25031>; else goto <D.25032>;
  <D.25031>:
  mono_mb_emit_byte (mb, 38);
  <D.25032>:
  mono_mb_emit_exception_full (mb, "System", "ApplicationException", exception_msg);
  monoeg_g_free (exception_msg);
  goto <D.20414>;
  <D.20415>:
  mono_mb_emit_byte (mb, 20);
  goto <D.20414>;
  <D.20416>:
  goto <D.20414>;
  <D.20414>:
  D.25034 = 0;
  return D.25034;
  <D.25030>:
  switch (action) <default: <D.20433>, case 0: <D.20417>, case 1: <D.20428>, case 2: <D.20427>, case 3: <D.20429>, case 4: <D.20430>, case 5: <D.20432>, case 6: <D.20431>>
  <D.20417>:
  D.25035 = t->type;
  D.25036 = (int) D.25035;
  switch (D.25036) <default: <D.20425>, case 14: <D.20420>, case 17: <D.20423>, case 18: <D.20418>, case 20: <D.20421>, case 28: <D.20419>, case 29: <D.20422>>
  <D.20418>:
  <D.20419>:
  <D.20420>:
  <D.20421>:
  <D.20422>:
  <D.20423>:
  goto <D.20424>;
  <D.20425>:
  D.25035 = t->type;
  D.25036 = (int) D.25035;
  monoeg_g_log (0B, 16, "custom marshalling of type %x is currently not supported", D.25036);
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "marshal.c", 5955);
  <D.20424>:
  D.25037 = mono_defaults.int_class;
  D.25038 = &D.25037->byval_arg;
  conv_arg = mono_mb_add_local (mb, D.25038);
  mono_mb_emit_byte (mb, 20);
  conv_arg.161 = (unsigned int) conv_arg;
  mono_mb_emit_stloc (mb, conv_arg.161);
  D.25040 = BIT_FIELD_REF <*t, 64, 64>;
  D.25041 = D.25040 & 8589934592;
  if (D.25041 != 0) goto <D.25042>; else goto <D.25043>;
  <D.25042>:
  D.25044 = t->attrs;
  D.25045 = (int) D.25044;
  D.25046 = D.25045 & 2;
  if (D.25046 != 0) goto <D.20426>; else goto <D.25047>;
  <D.25047>:
  <D.25043>:
  D.25040 = BIT_FIELD_REF <*t, 64, 64>;
  D.25041 = D.25040 & 8589934592;
  if (D.25041 == 0) goto <D.25048>; else goto <D.25049>;
  <D.25048>:
  D.25044 = t->attrs;
  D.25050 = (unsigned int) D.25044;
  D.25051 = D.25050 & 3;
  if (D.25051 == 2) goto <D.20426>; else goto <D.25052>;
  <D.25052>:
  <D.25049>:
  argnum.162 = (unsigned int) argnum;
  mono_mb_emit_ldarg (mb, argnum.162);
  D.25040 = BIT_FIELD_REF <*t, 64, 64>;
  D.25041 = D.25040 & 8589934592;
  if (D.25041 != 0) goto <D.25054>; else goto <D.25055>;
  <D.25054>:
  mono_mb_emit_byte (mb, 77);
  <D.25055>:
  D.25056 = mono_mb_emit_branch (mb, 57);
  pos2 = (int) D.25056;
  D.25057 = spec->data.custom_data.cookie;
  D.25058 = monoeg_strdup (D.25057);
  mono_mb_emit_ldstr (mb, D.25058);
  mono_mb_emit_op (mb, 40, get_instance);
  argnum.162 = (unsigned int) argnum;
  mono_mb_emit_ldarg (mb, argnum.162);
  D.25040 = BIT_FIELD_REF <*t, 64, 64>;
  D.25041 = D.25040 & 8589934592;
  if (D.25041 != 0) goto <D.25059>; else goto <D.25060>;
  <D.25059>:
  mono_mb_emit_byte (mb, 80);
  <D.25060>:
  D.25035 = t->type;
  if (D.25035 == 17) goto <D.25061>; else goto <D.25062>;
  <D.25061>:
  D.25037 = mono_defaults.int_class;
  D.25038 = &D.25037->byval_arg;
  *conv_arg_type = D.25038;
  D.25063 = mono_class_from_mono_type (t);
  mono_mb_emit_op (mb, 140, D.25063);
  <D.25062>:
  marshal_managed_to_native.158 = marshal_managed_to_native;
  mono_mb_emit_op (mb, 111, marshal_managed_to_native.158);
  conv_arg.161 = (unsigned int) conv_arg;
  mono_mb_emit_stloc (mb, conv_arg.161);
  pos2.163 = (unsigned int) pos2;
  mono_mb_patch_branch (mb, pos2.163);
  goto <D.20426>;
  <D.20427>:
  conv_arg.161 = (unsigned int) conv_arg;
  mono_mb_emit_ldloc (mb, conv_arg.161);
  D.25065 = mono_mb_emit_branch (mb, 57);
  pos2 = (int) D.25065;
  D.25040 = BIT_FIELD_REF <*t, 64, 64>;
  D.25041 = D.25040 & 8589934592;
  if (D.25041 != 0) goto <D.25066>; else goto <D.25067>;
  <D.25066>:
  argnum.162 = (unsigned int) argnum;
  mono_mb_emit_ldarg (mb, argnum.162);
  D.25057 = spec->data.custom_data.cookie;
  D.25068 = monoeg_strdup (D.25057);
  mono_mb_emit_ldstr (mb, D.25068);
  mono_mb_emit_op (mb, 40, get_instance);
  conv_arg.161 = (unsigned int) conv_arg;
  mono_mb_emit_ldloc (mb, conv_arg.161);
  marshal_native_to_managed.160 = marshal_native_to_managed;
  mono_mb_emit_op (mb, 111, marshal_native_to_managed.160);
  mono_mb_emit_byte (mb, 81);
  goto <D.25069>;
  <D.25067>:
  D.25044 = t->attrs;
  D.25045 = (int) D.25044;
  D.25046 = D.25045 & 2;
  if (D.25046 != 0) goto <D.25070>; else goto <D.25071>;
  <D.25070>:
  D.25057 = spec->data.custom_data.cookie;
  D.25072 = monoeg_strdup (D.25057);
  mono_mb_emit_ldstr (mb, D.25072);
  mono_mb_emit_op (mb, 40, get_instance);
  conv_arg.161 = (unsigned int) conv_arg;
  mono_mb_emit_ldloc (mb, conv_arg.161);
  marshal_native_to_managed.160 = marshal_native_to_managed;
  mono_mb_emit_op (mb, 111, marshal_native_to_managed.160);
  mono_mb_emit_byte (mb, 38);
  <D.25071>:
  <D.25069>:
  D.25057 = spec->data.custom_data.cookie;
  D.25073 = monoeg_strdup (D.25057);
  mono_mb_emit_ldstr (mb, D.25073);
  mono_mb_emit_op (mb, 40, get_instance);
  conv_arg.161 = (unsigned int) conv_arg;
  mono_mb_emit_ldloc (mb, conv_arg.161);
  cleanup_native.154 = cleanup_native;
  mono_mb_emit_op (mb, 111, cleanup_native.154);
  pos2.163 = (unsigned int) pos2;
  mono_mb_patch_branch (mb, pos2.163);
  goto <D.20426>;
  <D.20428>:
  D.25040 = BIT_FIELD_REF <*t, 64, 64>;
  D.25041 = D.25040 & 8589934592;
  if (D.25041 != 0) goto <D.25074>; else goto <D.25075>;
  <D.25074>:
  conv_arg.161 = (unsigned int) conv_arg;
  mono_mb_emit_ldloc_addr (mb, conv_arg.161);
  goto <D.25076>;
  <D.25075>:
  conv_arg.161 = (unsigned int) conv_arg;
  mono_mb_emit_ldloc (mb, conv_arg.161);
  <D.25076>:
  goto <D.20426>;
  <D.20429>:
  D.25037 = mono_defaults.int_class;
  D.25038 = &D.25037->byval_arg;
  D.25077 = mono_mb_add_local (mb, D.25038);
  loc1 = (guint32) D.25077;
  mono_mb_emit_stloc (mb, 3);
  mono_mb_emit_ldloc (mb, 3);
  mono_mb_emit_stloc (mb, loc1);
  mono_mb_emit_ldloc (mb, 3);
  D.25078 = mono_mb_emit_branch (mb, 57);
  pos2 = (int) D.25078;
  D.25057 = spec->data.custom_data.cookie;
  D.25079 = monoeg_strdup (D.25057);
  mono_mb_emit_ldstr (mb, D.25079);
  mono_mb_emit_op (mb, 40, get_instance);
  mono_mb_emit_byte (mb, 37);
  mono_mb_emit_ldloc (mb, 3);
  marshal_native_to_managed.160 = marshal_native_to_managed;
  mono_mb_emit_op (mb, 111, marshal_native_to_managed.160);
  mono_mb_emit_stloc (mb, 3);
  mono_mb_emit_ldloc (mb, loc1);
  cleanup_native.154 = cleanup_native;
  mono_mb_emit_op (mb, 111, cleanup_native.154);
  pos2.163 = (unsigned int) pos2;
  mono_mb_patch_branch (mb, pos2.163);
  goto <D.20426>;
  <D.20430>:
  D.25080 = mono_defaults.object_class;
  D.25081 = &D.25080->byval_arg;
  conv_arg = mono_mb_add_local (mb, D.25081);
  mono_mb_emit_byte (mb, 20);
  conv_arg.161 = (unsigned int) conv_arg;
  mono_mb_emit_stloc (mb, conv_arg.161);
  D.25040 = BIT_FIELD_REF <*t, 64, 64>;
  D.25041 = D.25040 & 8589934592;
  if (D.25041 != 0) goto <D.25082>; else goto <D.25083>;
  <D.25082>:
  D.25044 = t->attrs;
  D.25045 = (int) D.25044;
  D.25046 = D.25045 & 2;
  if (D.25046 != 0) goto <D.20426>; else goto <D.25084>;
  <D.25084>:
  <D.25083>:
  argnum.162 = (unsigned int) argnum;
  mono_mb_emit_ldarg (mb, argnum.162);
  D.25040 = BIT_FIELD_REF <*t, 64, 64>;
  D.25041 = D.25040 & 8589934592;
  if (D.25041 != 0) goto <D.25085>; else goto <D.25086>;
  <D.25085>:
  mono_mb_emit_byte (mb, 77);
  <D.25086>:
  D.25087 = mono_mb_emit_branch (mb, 57);
  pos2 = (int) D.25087;
  D.25057 = spec->data.custom_data.cookie;
  D.25088 = monoeg_strdup (D.25057);
  mono_mb_emit_ldstr (mb, D.25088);
  mono_mb_emit_op (mb, 40, get_instance);
  argnum.162 = (unsigned int) argnum;
  mono_mb_emit_ldarg (mb, argnum.162);
  D.25040 = BIT_FIELD_REF <*t, 64, 64>;
  D.25041 = D.25040 & 8589934592;
  if (D.25041 != 0) goto <D.25089>; else goto <D.25090>;
  <D.25089>:
  mono_mb_emit_byte (mb, 77);
  <D.25090>:
  marshal_native_to_managed.160 = marshal_native_to_managed;
  mono_mb_emit_op (mb, 111, marshal_native_to_managed.160);
  conv_arg.161 = (unsigned int) conv_arg;
  mono_mb_emit_stloc (mb, conv_arg.161);
  pos2.163 = (unsigned int) pos2;
  mono_mb_patch_branch (mb, pos2.163);
  goto <D.20426>;
  <D.20431>:
  D.25040 = BIT_FIELD_REF <*t, 64, 64>;
  D.25041 = D.25040 & 8589934592;
  D.25091 = D.25041 != 0;
  D.25092 = (long int) D.25091;
  D.25093 = __builtin_expect (D.25092, 0);
  if (D.25093 != 0) goto <D.25094>; else goto <D.25095>;
  <D.25094>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 6102, "!t->byref");
  <D.25095>:
  D.25080 = mono_defaults.object_class;
  D.25081 = &D.25080->byval_arg;
  D.25096 = mono_mb_add_local (mb, D.25081);
  loc1 = (guint32) D.25096;
  mono_mb_emit_stloc (mb, 3);
  mono_mb_emit_ldloc (mb, 3);
  mono_mb_emit_stloc (mb, loc1);
  mono_mb_emit_ldloc (mb, 3);
  D.25097 = mono_mb_emit_branch (mb, 57);
  pos2 = (int) D.25097;
  D.25057 = spec->data.custom_data.cookie;
  D.25098 = monoeg_strdup (D.25057);
  mono_mb_emit_ldstr (mb, D.25098);
  mono_mb_emit_op (mb, 40, get_instance);
  mono_mb_emit_byte (mb, 37);
  mono_mb_emit_ldloc (mb, 3);
  marshal_managed_to_native.158 = marshal_managed_to_native;
  mono_mb_emit_op (mb, 111, marshal_managed_to_native.158);
  mono_mb_emit_stloc (mb, 3);
  mono_mb_emit_ldloc (mb, loc1);
  cleanup_managed.156 = cleanup_managed;
  mono_mb_emit_op (mb, 111, cleanup_managed.156);
  pos2.163 = (unsigned int) pos2;
  mono_mb_patch_branch (mb, pos2.163);
  goto <D.20426>;
  <D.20432>:
  conv_arg.161 = (unsigned int) conv_arg;
  mono_mb_emit_ldloc (mb, conv_arg.161);
  D.25099 = mono_mb_emit_branch (mb, 57);
  pos2 = (int) D.25099;
  D.25040 = BIT_FIELD_REF <*t, 64, 64>;
  D.25041 = D.25040 & 8589934592;
  if (D.25041 != 0) goto <D.25100>; else goto <D.25101>;
  <D.25100>:
  argnum.162 = (unsigned int) argnum;
  mono_mb_emit_ldarg (mb, argnum.162);
  D.25057 = spec->data.custom_data.cookie;
  D.25102 = monoeg_strdup (D.25057);
  mono_mb_emit_ldstr (mb, D.25102);
  mono_mb_emit_op (mb, 40, get_instance);
  conv_arg.161 = (unsigned int) conv_arg;
  mono_mb_emit_ldloc (mb, conv_arg.161);
  marshal_managed_to_native.158 = marshal_managed_to_native;
  mono_mb_emit_op (mb, 111, marshal_managed_to_native.158);
  mono_mb_emit_byte (mb, 223);
  <D.25101>:
  D.25057 = spec->data.custom_data.cookie;
  D.25103 = monoeg_strdup (D.25057);
  mono_mb_emit_ldstr (mb, D.25103);
  mono_mb_emit_op (mb, 40, get_instance);
  conv_arg.161 = (unsigned int) conv_arg;
  mono_mb_emit_ldloc (mb, conv_arg.161);
  cleanup_managed.156 = cleanup_managed;
  mono_mb_emit_op (mb, 111, cleanup_managed.156);
  pos2.163 = (unsigned int) pos2;
  mono_mb_patch_branch (mb, pos2.163);
  goto <D.20426>;
  <D.20433>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "marshal.c", 6159);
  <D.20426>:
  D.25034 = conv_arg;
  return D.25034;
}


emit_marshal_asany (struct EmitMarshalContext * m, int argnum, struct MonoType * t, struct MonoMarshalSpec * spec, int conv_arg, struct MonoType * * conv_arg_type, MarshalAction action)
{
  struct MonoMethodPInvoke * D.25107;
  unsigned char D.25108;
  _Bool D.25109;
  long int D.25110;
  long int D.25111;
  long unsigned int D.25114;
  long unsigned int D.25115;
  _Bool D.25116;
  long int D.25117;
  long int D.25118;
  struct MonoClass * D.25121;
  struct MonoType * D.25122;
  unsigned int argnum.164;
  int encoding.165;
  short unsigned int D.25125;
  int D.25126;
  unsigned int conv_arg.166;
  int encoding.167;
  int D.25129;
  struct MonoMethodBuilder * mb;

  mb = m->mb;
  switch (action) <default: <D.20450>, case 0: <D.20444>, case 1: <D.20447>, case 2: <D.20448>>
  <D.20444>:
  {
    MonoMarshalNative encoding;

    D.25107 = m->piinfo;
    encoding = mono_marshal_get_string_encoding (D.25107, 0B);
    D.25108 = t->type;
    D.25109 = D.25108 != 28;
    D.25110 = (long int) D.25109;
    D.25111 = __builtin_expect (D.25110, 0);
    if (D.25111 != 0) goto <D.25112>; else goto <D.25113>;
    <D.25112>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 6179, "t->type == MONO_TYPE_OBJECT");
    <D.25113>:
    D.25114 = BIT_FIELD_REF <*t, 64, 64>;
    D.25115 = D.25114 & 8589934592;
    D.25116 = D.25115 != 0;
    D.25117 = (long int) D.25116;
    D.25118 = __builtin_expect (D.25117, 0);
    if (D.25118 != 0) goto <D.25119>; else goto <D.25120>;
    <D.25119>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 6180, "!t->byref");
    <D.25120>:
    D.25121 = mono_defaults.int_class;
    D.25122 = &D.25121->byval_arg;
    conv_arg = mono_mb_add_local (mb, D.25122);
    argnum.164 = (unsigned int) argnum;
    mono_mb_emit_ldarg (mb, argnum.164);
    encoding.165 = (int) encoding;
    mono_mb_emit_icon (mb, encoding.165);
    D.25125 = t->attrs;
    D.25126 = (int) D.25125;
    mono_mb_emit_icon (mb, D.25126);
    mono_mb_emit_icall (mb, mono_marshal_asany);
    conv_arg.166 = (unsigned int) conv_arg;
    mono_mb_emit_stloc (mb, conv_arg.166);
    goto <D.20446>;
  }
  <D.20447>:
  conv_arg.166 = (unsigned int) conv_arg;
  mono_mb_emit_ldloc (mb, conv_arg.166);
  goto <D.20446>;
  <D.20448>:
  {
    MonoMarshalNative encoding;

    D.25107 = m->piinfo;
    encoding = mono_marshal_get_string_encoding (D.25107, 0B);
    argnum.164 = (unsigned int) argnum;
    mono_mb_emit_ldarg (mb, argnum.164);
    conv_arg.166 = (unsigned int) conv_arg;
    mono_mb_emit_ldloc (mb, conv_arg.166);
    encoding.167 = (int) encoding;
    mono_mb_emit_icon (mb, encoding.167);
    D.25125 = t->attrs;
    D.25126 = (int) D.25125;
    mono_mb_emit_icon (mb, D.25126);
    mono_mb_emit_icall (mb, mono_marshal_free_asany);
    goto <D.20446>;
  }
  <D.20450>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "marshal.c", 6207);
  <D.20446>:
  D.25129 = conv_arg;
  return D.25129;
}


mono_marshal_get_string_encoding (struct MonoMethodPInvoke * piinfo, struct MonoMarshalSpec * spec)
{
  <unnamed type> D.25133;
  <unnamed type> D.25136;
  MonoMarshalNative D.25141;
  short unsigned int D.25145;
  int D.25146;
  int D.25147;

  if (spec != 0B) goto <D.25131>; else goto <D.25132>;
  <D.25131>:
  D.25133 = spec->native;
  if (D.25133 == 42) goto <D.25134>; else goto <D.25135>;
  <D.25134>:
  D.25136 = spec->data.array_data.elem_type;
  if (D.25136 != 0) goto <D.25137>; else goto <D.25138>;
  <D.25137>:
  D.25136 = spec->data.array_data.elem_type;
  if (D.25136 != 80) goto <D.25139>; else goto <D.25140>;
  <D.25139>:
  D.25141 = spec->data.array_data.elem_type;
  return D.25141;
  <D.25140>:
  <D.25138>:
  goto <D.25142>;
  <D.25135>:
  D.25141 = spec->native;
  return D.25141;
  <D.25142>:
  <D.25132>:
  if (piinfo == 0B) goto <D.25143>; else goto <D.25144>;
  <D.25143>:
  D.25141 = 20;
  return D.25141;
  <D.25144>:
  D.25145 = piinfo->piflags;
  D.25146 = (int) D.25145;
  D.25147 = D.25146 & 6;
  switch (D.25147) <default: <D.19445>, case 2: <D.19442>, case 4: <D.19443>, case 6: <D.19444>>
  <D.19442>:
  D.25141 = 20;
  return D.25141;
  <D.19443>:
  D.25141 = 21;
  return D.25141;
  <D.19444>:
  D.25141 = 20;
  return D.25141;
  <D.19445>:
  D.25141 = 20;
  return D.25141;
}


emit_marshal_handleref (struct EmitMarshalContext * m, int argnum, struct MonoType * t, struct MonoMarshalSpec * spec, int conv_arg, struct MonoType * * conv_arg_type, MarshalAction action)
{
  struct MonoClass * D.25149;
  long unsigned int D.25150;
  long unsigned int D.25151;
  unsigned int argnum.168;
  unsigned int conv_arg.169;
  struct _IO_FILE * stderr.170;
  int D.25157;
  struct MonoMethodBuilder * mb;

  mb = m->mb;
  switch (action) <default: <D.20554>, case 0: <D.20543>, case 1: <D.20547>, case 2: <D.20548>, case 3: <D.20549>, case 4: <D.20551>, case 5: <D.20552>, case 6: <D.20553>>
  <D.20543>:
  {
    struct MonoType * intptr_type;

    D.25149 = mono_defaults.int_class;
    intptr_type = &D.25149->byval_arg;
    conv_arg = mono_mb_add_local (mb, intptr_type);
    *conv_arg_type = intptr_type;
    D.25150 = BIT_FIELD_REF <*t, 64, 64>;
    D.25151 = D.25150 & 8589934592;
    if (D.25151 != 0) goto <D.25152>; else goto <D.25153>;
    <D.25152>:
    {
      char * msg;

      msg = monoeg_strdup ("HandleRefs can not be returned from unmanaged code (or passed by ref)");
      mono_mb_emit_exception_marshal_directive (mb, msg);
      goto <D.20546>;
    }
    <D.25153>:
    argnum.168 = (unsigned int) argnum;
    mono_mb_emit_ldarg_addr (mb, argnum.168);
    mono_mb_emit_icon (mb, 8);
    mono_mb_emit_byte (mb, 88);
    mono_mb_emit_byte (mb, 77);
    conv_arg.169 = (unsigned int) conv_arg;
    mono_mb_emit_stloc (mb, conv_arg.169);
    goto <D.20546>;
  }
  <D.20547>:
  conv_arg.169 = (unsigned int) conv_arg;
  mono_mb_emit_ldloc (mb, conv_arg.169);
  goto <D.20546>;
  <D.20548>:
  goto <D.20546>;
  <D.20549>:
  {
    char * msg;

    msg = monoeg_strdup ("HandleRefs can not be returned from unmanaged code (or passed by ref)");
    mono_mb_emit_exception_marshal_directive (mb, msg);
    goto <D.20546>;
  }
  <D.20551>:
  stderr.170 = stderr;
  fprintf (stderr.170, "mono/marshal: SafeHandles missing MANAGED_CONV_IN\n");
  goto <D.20546>;
  <D.20552>:
  stderr.170 = stderr;
  fprintf (stderr.170, "mono/marshal: SafeHandles missing MANAGED_CONV_OUT\n");
  goto <D.20546>;
  <D.20553>:
  stderr.170 = stderr;
  fprintf (stderr.170, "mono/marshal: SafeHandles missing MANAGED_CONV_RESULT\n");
  goto <D.20546>;
  <D.20554>:
  stderr.170 = stderr;
  fprintf (stderr.170, "Unhandled case for MarshalAction: %d\n", action);
  <D.20546>:
  D.25157 = conv_arg;
  return D.25157;
}


mono_mb_emit_exception_marshal_directive (struct MonoMethodBuilder * mb, char * msg)
{
  int D.25160;
  struct MonoMethod * D.25163;
  struct MonoClass * D.25164;
  struct MonoImage * D.25165;
  char * s;

  D.25160 = mb->dynamic;
  if (D.25160 == 0) goto <D.25161>; else goto <D.25162>;
  <D.25161>:
  D.25163 = mb->method;
  D.25164 = D.25163->klass;
  D.25165 = D.25164->image;
  s = mono_image_strdup (D.25165, msg);
  monoeg_g_free (msg);
  goto <D.25166>;
  <D.25162>:
  s = monoeg_strdup (msg);
  <D.25166>:
  mono_mb_emit_exception_full (mb, "System.Runtime.InteropServices", "MarshalDirectiveException", s);
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__))
fprintf (struct FILE * restrict __stream, const char * restrict __fmt)
{
  int D.25167;

  D.25167 = __fprintf_chk (__stream, 1, __fmt, __builtin_va_arg_pack ());
  return D.25167;
}


emit_marshal_string (struct EmitMarshalContext * m, int argnum, struct MonoType * t, struct MonoMarshalSpec * spec, int conv_arg, struct MonoType * * conv_arg_type, MarshalAction action)
{
  struct MonoMethodPInvoke * D.25169;
  struct MonoClass * D.25170;
  struct MonoType * D.25171;
  long unsigned int D.25172;
  long unsigned int D.25173;
  short unsigned int D.25176;
  int D.25177;
  int D.25178;
  unsigned int argnum.171;
  void * D.25185;
  unsigned int conv_arg.172;
  struct MonoMethod * m.173;
  struct MonoClass * D.25194;
  struct MonoMethod * m.174;
  _Bool D.25196;
  long int D.25197;
  long int D.25198;
  _Bool D.25203;
  long int D.25204;
  long int D.25205;
  unsigned int D.25211;
  unsigned int D.25212;
  void * D.25215;
  int need_free.175;
  void * D.25228;
  struct MonoClass * D.25232;
  struct MonoType * D.25233;
  void * D.25241;
  void * D.25246;
  void * D.25247;
  void * D.25251;
  int D.25252;
  struct MonoMethodBuilder * mb;
  MonoMarshalNative encoding;
  MonoMarshalConv conv;
  gboolean need_free;

  try
    {
      mb = m->mb;
      D.25169 = m->piinfo;
      encoding = mono_marshal_get_string_encoding (D.25169, spec);
      D.25169 = m->piinfo;
      conv = mono_marshal_get_string_to_ptr_conv (D.25169, spec);
      switch (action) <default: <D.20505>, case 0: <D.20491>, case 1: <D.20498>, case 2: <D.20494>, case 3: <D.20499>, case 4: <D.20501>, case 5: <D.20503>, case 6: <D.20504>>
      <D.20491>:
      D.25170 = mono_defaults.int_class;
      D.25171 = &D.25170->byval_arg;
      *conv_arg_type = D.25171;
      D.25170 = mono_defaults.int_class;
      D.25171 = &D.25170->byval_arg;
      conv_arg = mono_mb_add_local (mb, D.25171);
      D.25172 = BIT_FIELD_REF <*t, 64, 64>;
      D.25173 = D.25172 & 8589934592;
      if (D.25173 != 0) goto <D.25174>; else goto <D.25175>;
      <D.25174>:
      D.25176 = t->attrs;
      D.25177 = (int) D.25176;
      D.25178 = D.25177 & 2;
      if (D.25178 != 0) goto <D.20492>; else goto <D.25179>;
      <D.25179>:
      argnum.171 = (unsigned int) argnum;
      mono_mb_emit_ldarg (mb, argnum.171);
      mono_mb_emit_byte (mb, 77);
      goto <D.25181>;
      <D.25175>:
      argnum.171 = (unsigned int) argnum;
      mono_mb_emit_ldarg (mb, argnum.171);
      <D.25181>:
      if (conv == 4294967295) goto <D.25182>; else goto <D.25183>;
      <D.25182>:
      {
        char * msg;

        msg = monoeg_g_strdup_printf ("string marshalling conversion %d not implemented", encoding);
        mono_mb_emit_exception_marshal_directive (mb, msg);
      }
      goto <D.25184>;
      <D.25183>:
      D.25185 = conv_to_icall (conv);
      mono_mb_emit_icall (mb, D.25185);
      conv_arg.172 = (unsigned int) conv_arg;
      mono_mb_emit_stloc (mb, conv_arg.172);
      <D.25184>:
      goto <D.20492>;
      <D.20494>:
      D.25169 = m->piinfo;
      conv = mono_marshal_get_ptr_to_string_conv (D.25169, spec, &need_free);
      if (conv == 4294967295) goto <D.25187>; else goto <D.25188>;
      <D.25187>:
      {
        char * msg;

        msg = monoeg_g_strdup_printf ("string marshalling conversion %d not implemented", encoding);
        mono_mb_emit_exception_marshal_directive (mb, msg);
        goto <D.20492>;
      }
      <D.25188>:
      if (encoding == 34) goto <D.25189>; else goto <D.25190>;
      <D.25189>:
      {
        static struct MonoMethod * m;

        m.173 = m;
        if (m.173 == 0B) goto <D.25192>; else goto <D.25193>;
        <D.25192>:
        D.25194 = mono_defaults.string_class;
        m.174 = mono_class_get_method_from_name_flags (D.25194, "get_Length", -1, 0);
        m = m.174;
        m.173 = m;
        D.25196 = m.173 == 0B;
        D.25197 = (long int) D.25196;
        D.25198 = __builtin_expect (D.25197, 0);
        if (D.25198 != 0) goto <D.25199>; else goto <D.25200>;
        <D.25199>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 6559, "m");
        <D.25200>:
        <D.25193>:
        D.25172 = BIT_FIELD_REF <*t, 64, 64>;
        D.25173 = D.25172 & 8589934592;
        if (D.25173 == 0) goto <D.25201>; else goto <D.25202>;
        <D.25201>:
        {
          char * msg;

          msg = monoeg_g_strdup_printf ("VBByRefStr marshalling requires a ref parameter.", encoding);
          mono_mb_emit_exception_marshal_directive (mb, msg);
          goto <D.20492>;
        }
        <D.25202>:
        D.25172 = BIT_FIELD_REF <*t, 64, 64>;
        D.25173 = D.25172 & 8589934592;
        D.25203 = D.25173 == 0;
        D.25204 = (long int) D.25203;
        D.25205 = __builtin_expect (D.25204, 0);
        if (D.25205 != 0) goto <D.25206>; else goto <D.25207>;
        <D.25206>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 6572, "t->byref");
        <D.25207>:
        argnum.171 = (unsigned int) argnum;
        mono_mb_emit_ldarg (mb, argnum.171);
        conv_arg.172 = (unsigned int) conv_arg;
        mono_mb_emit_ldloc (mb, conv_arg.172);
        argnum.171 = (unsigned int) argnum;
        mono_mb_emit_ldarg (mb, argnum.171);
        mono_mb_emit_byte (mb, 77);
        m.173 = m;
        mono_mb_emit_managed_call (mb, m.173, 0B);
        mono_mb_emit_icall (mb, mono_string_new_len_wrapper);
        mono_mb_emit_byte (mb, 81);
      }
      goto <D.25208>;
      <D.25190>:
      D.25172 = BIT_FIELD_REF <*t, 64, 64>;
      D.25173 = D.25172 & 8589934592;
      if (D.25173 != 0) goto <D.25209>; else goto <D.25210>;
      <D.25209>:
      D.25176 = t->attrs;
      D.25211 = (unsigned int) D.25176;
      D.25212 = D.25211 & 3;
      if (D.25212 != 1) goto <D.25213>; else goto <D.25214>;
      <D.25213>:
      argnum.171 = (unsigned int) argnum;
      mono_mb_emit_ldarg (mb, argnum.171);
      conv_arg.172 = (unsigned int) conv_arg;
      mono_mb_emit_ldloc (mb, conv_arg.172);
      D.25215 = conv_to_icall (conv);
      mono_mb_emit_icall (mb, D.25215);
      mono_mb_emit_byte (mb, 81);
      need_free = 1;
      <D.25214>:
      <D.25210>:
      <D.25208>:
      need_free.175 = need_free;
      if (need_free.175 != 0) goto <D.25217>; else goto <D.25218>;
      <D.25217>:
      conv_arg.172 = (unsigned int) conv_arg;
      mono_mb_emit_ldloc (mb, conv_arg.172);
      if (conv == 32) goto <D.25219>; else goto <D.25220>;
      <D.25219>:
      mono_mb_emit_icall (mb, mono_free_bstr);
      goto <D.25221>;
      <D.25220>:
      mono_mb_emit_icall (mb, mono_marshal_free);
      <D.25221>:
      <D.25218>:
      goto <D.20492>;
      <D.20498>:
      D.25172 = BIT_FIELD_REF <*t, 64, 64>;
      D.25173 = D.25172 & 8589934592;
      if (D.25173 != 0) goto <D.25224>; else goto <D.25222>;
      <D.25224>:
      if (encoding != 34) goto <D.25225>; else goto <D.25222>;
      <D.25225>:
      conv_arg.172 = (unsigned int) conv_arg;
      mono_mb_emit_ldloc_addr (mb, conv_arg.172);
      goto <D.25223>;
      <D.25222>:
      conv_arg.172 = (unsigned int) conv_arg;
      mono_mb_emit_ldloc (mb, conv_arg.172);
      <D.25223>:
      goto <D.20492>;
      <D.20499>:
      mono_mb_emit_stloc (mb, 0);
      D.25169 = m->piinfo;
      conv = mono_marshal_get_ptr_to_string_conv (D.25169, spec, &need_free);
      if (conv == 4294967295) goto <D.25226>; else goto <D.25227>;
      <D.25226>:
      {
        char * msg;

        msg = monoeg_g_strdup_printf ("string marshalling conversion %d not implemented", encoding);
        mono_mb_emit_exception_marshal_directive (mb, msg);
        goto <D.20492>;
      }
      <D.25227>:
      mono_mb_emit_ldloc (mb, 0);
      D.25228 = conv_to_icall (conv);
      mono_mb_emit_icall (mb, D.25228);
      mono_mb_emit_stloc (mb, 3);
      mono_mb_emit_ldloc (mb, 0);
      if (conv == 32) goto <D.25229>; else goto <D.25230>;
      <D.25229>:
      mono_mb_emit_icall (mb, mono_free_bstr);
      goto <D.25231>;
      <D.25230>:
      mono_mb_emit_icall (mb, mono_marshal_free);
      <D.25231>:
      goto <D.20492>;
      <D.20501>:
      D.25232 = mono_defaults.object_class;
      D.25233 = &D.25232->byval_arg;
      conv_arg = mono_mb_add_local (mb, D.25233);
      D.25170 = mono_defaults.int_class;
      D.25171 = &D.25170->byval_arg;
      *conv_arg_type = D.25171;
      D.25172 = BIT_FIELD_REF <*t, 64, 64>;
      D.25173 = D.25172 & 8589934592;
      if (D.25173 != 0) goto <D.25234>; else goto <D.25235>;
      <D.25234>:
      D.25176 = t->attrs;
      D.25177 = (int) D.25176;
      D.25178 = D.25177 & 2;
      if (D.25178 != 0) goto <D.20492>; else goto <D.25236>;
      <D.25236>:
      <D.25235>:
      D.25169 = m->piinfo;
      conv = mono_marshal_get_ptr_to_string_conv (D.25169, spec, &need_free);
      if (conv == 4294967295) goto <D.25237>; else goto <D.25238>;
      <D.25237>:
      {
        char * msg;

        msg = monoeg_g_strdup_printf ("string marshalling conversion %d not implemented", encoding);
        mono_mb_emit_exception_marshal_directive (mb, msg);
        goto <D.20492>;
      }
      <D.25238>:
      argnum.171 = (unsigned int) argnum;
      mono_mb_emit_ldarg (mb, argnum.171);
      D.25172 = BIT_FIELD_REF <*t, 64, 64>;
      D.25173 = D.25172 & 8589934592;
      if (D.25173 != 0) goto <D.25239>; else goto <D.25240>;
      <D.25239>:
      mono_mb_emit_byte (mb, 77);
      <D.25240>:
      D.25241 = conv_to_icall (conv);
      mono_mb_emit_icall (mb, D.25241);
      conv_arg.172 = (unsigned int) conv_arg;
      mono_mb_emit_stloc (mb, conv_arg.172);
      goto <D.20492>;
      <D.20503>:
      D.25172 = BIT_FIELD_REF <*t, 64, 64>;
      D.25173 = D.25172 & 8589934592;
      if (D.25173 != 0) goto <D.25242>; else goto <D.25243>;
      <D.25242>:
      if (conv_arg != 0) goto <D.25244>; else goto <D.25245>;
      <D.25244>:
      argnum.171 = (unsigned int) argnum;
      mono_mb_emit_ldarg (mb, argnum.171);
      conv_arg.172 = (unsigned int) conv_arg;
      mono_mb_emit_ldloc (mb, conv_arg.172);
      D.25246 = conv_to_icall (conv);
      mono_mb_emit_icall (mb, D.25246);
      mono_mb_emit_byte (mb, 223);
      <D.25245>:
      <D.25243>:
      goto <D.20492>;
      <D.20504>:
      D.25247 = conv_to_icall (conv);
      if (D.25247 == mono_marshal_string_to_utf16) goto <D.25248>; else goto <D.25249>;
      <D.25248>:
      mono_mb_emit_icall (mb, mono_marshal_string_to_utf16_copy);
      goto <D.25250>;
      <D.25249>:
      D.25251 = conv_to_icall (conv);
      mono_mb_emit_icall (mb, D.25251);
      <D.25250>:
      mono_mb_emit_stloc (mb, 3);
      goto <D.20492>;
      <D.20505>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "marshal.c", 6671);
      <D.20492>:
      D.25252 = conv_arg;
      return D.25252;
    }
  finally
    {
      need_free = {CLOBBER};
    }
}


mono_marshal_get_string_to_ptr_conv (struct MonoMethodPInvoke * piinfo, struct MonoMarshalSpec * spec)
{
  MonoMarshalConv D.25255;
  MonoMarshalNative encoding;

  encoding = mono_marshal_get_string_encoding (piinfo, spec);
  switch (encoding) <default: <D.19456>, case 19: <D.19455>, case 20: <D.19452>, case 21: <D.19451>, case 22: <D.19454>, case 34: <D.19453>>
  <D.19451>:
  D.25255 = 7;
  return D.25255;
  <D.19452>:
  <D.19453>:
  D.25255 = 4;
  return D.25255;
  <D.19454>:
  D.25255 = 9;
  return D.25255;
  <D.19455>:
  D.25255 = 3;
  return D.25255;
  <D.19456>:
  D.25255 = 4294967295;
  return D.25255;
}


mono_marshal_get_ptr_to_string_conv (struct MonoMethodPInvoke * piinfo, struct MonoMarshalSpec * spec, gboolean * need_free)
{
  MonoMarshalConv D.25257;
  MonoMarshalNative encoding;

  encoding = mono_marshal_get_string_encoding (piinfo, spec);
  *need_free = 1;
  switch (encoding) <default: <D.19477>, case 19: <D.19476>, case 20: <D.19473>, case 21: <D.19472>, case 22: <D.19475>, case 34: <D.19474>>
  <D.19472>:
  *need_free = 0;
  D.25257 = 8;
  return D.25257;
  <D.19473>:
  <D.19474>:
  D.25257 = 5;
  return D.25257;
  <D.19475>:
  D.25257 = 6;
  return D.25257;
  <D.19476>:
  D.25257 = 32;
  return D.25257;
  <D.19477>:
  D.25257 = 4294967295;
  return D.25257;
}


conv_to_icall (MonoMarshalConv conv)
{
  void * D.25259;

  switch (conv) <default: <D.19281>, case 3: <D.19263>, case 4: <D.19262>, case 5: <D.19260>, case 6: <D.19259>, case 7: <D.19257>, case 8: <D.19258>, case 9: <D.19261>, case 10: <D.19266>, case 11: <D.19265>, case 12: <D.19279>, case 13: <D.19280>, case 14: <D.19267>, case 15: <D.19268>, case 16: <D.19269>, case 17: <D.19275>, case 18: <D.19276>, case 19: <D.19277>, case 22: <D.19270>, case 23: <D.19271>, case 24: <D.19272>, case 29: <D.19273>, case 30: <D.19274>, case 31: <D.19278>, case 32: <D.19264>>
  <D.19257>:
  D.25259 = mono_marshal_string_to_utf16;
  return D.25259;
  <D.19258>:
  D.25259 = mono_string_from_utf16;
  return D.25259;
  <D.19259>:
  D.25259 = mono_string_new_wrapper;
  return D.25259;
  <D.19260>:
  D.25259 = mono_string_new_wrapper;
  return D.25259;
  <D.19261>:
  D.25259 = mono_string_to_lpstr;
  return D.25259;
  <D.19262>:
  D.25259 = mono_string_to_lpstr;
  return D.25259;
  <D.19263>:
  D.25259 = mono_string_to_bstr;
  return D.25259;
  <D.19264>:
  D.25259 = mono_string_from_bstr;
  return D.25259;
  <D.19265>:
  <D.19266>:
  D.25259 = mono_string_to_ansibstr;
  return D.25259;
  <D.19267>:
  D.25259 = mono_string_builder_to_utf8;
  return D.25259;
  <D.19268>:
  D.25259 = mono_string_builder_to_utf8;
  return D.25259;
  <D.19269>:
  D.25259 = mono_string_builder_to_utf16;
  return D.25259;
  <D.19270>:
  D.25259 = mono_array_to_savearray;
  return D.25259;
  <D.19271>:
  D.25259 = mono_array_to_lparray;
  return D.25259;
  <D.19272>:
  D.25259 = mono_free_lparray;
  return D.25259;
  <D.19273>:
  D.25259 = mono_delegate_to_ftnptr;
  return D.25259;
  <D.19274>:
  D.25259 = mono_ftnptr_to_delegate;
  return D.25259;
  <D.19275>:
  D.25259 = mono_string_utf8_to_builder;
  return D.25259;
  <D.19276>:
  D.25259 = mono_string_utf8_to_builder;
  return D.25259;
  <D.19277>:
  D.25259 = mono_string_utf16_to_builder;
  return D.25259;
  <D.19278>:
  D.25259 = mono_marshal_free_array;
  return D.25259;
  <D.19279>:
  D.25259 = mono_string_to_byvalstr;
  return D.25259;
  <D.19280>:
  D.25259 = mono_string_to_byvalwstr;
  return D.25259;
  <D.19281>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "marshal.c", 1582);
  D.25259 = 0B;
  return D.25259;
}


emit_marshal_variant (struct EmitMarshalContext * m, int argnum, struct MonoType * t, struct MonoMarshalSpec * spec, int conv_arg, struct MonoType * * conv_arg_type, MarshalAction action)
{
  struct MonoMethod * get_object_for_native_variant.176;
  struct MonoClass * D.25264;
  struct MonoMethod * get_object_for_native_variant.177;
  _Bool D.25266;
  long int D.25267;
  long int D.25268;
  struct MonoMethod * get_native_variant_for_object.178;
  struct MonoMethod * get_native_variant_for_object.179;
  _Bool D.25275;
  long int D.25276;
  long int D.25277;
  struct MonoClass * D.25280;
  struct MonoType * D.25281;
  long unsigned int D.25282;
  long unsigned int D.25283;
  struct MonoClass * D.25286;
  struct MonoType * D.25287;
  struct MonoClass * D.25289;
  struct MonoType * D.25290;
  short unsigned int D.25293;
  unsigned int D.25294;
  unsigned int D.25295;
  unsigned int argnum.180;
  unsigned int conv_arg.181;
  struct MonoMethod * variant_clear.182;
  struct MonoClass * D.25304;
  struct MonoMethod * variant_clear.183;
  _Bool D.25306;
  long int D.25307;
  long int D.25308;
  struct MonoClass * D.25318;
  struct MonoType * D.25319;
  struct MonoClass * D.25322;
  struct MonoType * D.25323;
  struct MonoClass * D.25325;
  struct MonoType * D.25326;
  int D.25337;
  struct MonoMethodBuilder * mb;
  static struct MonoMethod * get_object_for_native_variant = 0B;
  static struct MonoMethod * get_native_variant_for_object = 0B;

  mb = m->mb;
  get_object_for_native_variant.176 = get_object_for_native_variant;
  if (get_object_for_native_variant.176 == 0B) goto <D.25262>; else goto <D.25263>;
  <D.25262>:
  D.25264 = mono_defaults.marshal_class;
  get_object_for_native_variant.177 = mono_class_get_method_from_name (D.25264, "GetObjectForNativeVariant", 1);
  get_object_for_native_variant = get_object_for_native_variant.177;
  <D.25263>:
  get_object_for_native_variant.176 = get_object_for_native_variant;
  D.25266 = get_object_for_native_variant.176 == 0B;
  D.25267 = (long int) D.25266;
  D.25268 = __builtin_expect (D.25267, 0);
  if (D.25268 != 0) goto <D.25269>; else goto <D.25270>;
  <D.25269>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 7411, "get_object_for_native_variant");
  <D.25270>:
  get_native_variant_for_object.178 = get_native_variant_for_object;
  if (get_native_variant_for_object.178 == 0B) goto <D.25272>; else goto <D.25273>;
  <D.25272>:
  D.25264 = mono_defaults.marshal_class;
  get_native_variant_for_object.179 = mono_class_get_method_from_name (D.25264, "GetNativeVariantForObject", 2);
  get_native_variant_for_object = get_native_variant_for_object.179;
  <D.25273>:
  get_native_variant_for_object.178 = get_native_variant_for_object;
  D.25275 = get_native_variant_for_object.178 == 0B;
  D.25276 = (long int) D.25275;
  D.25277 = __builtin_expect (D.25276, 0);
  if (D.25277 != 0) goto <D.25278>; else goto <D.25279>;
  <D.25278>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 7415, "get_native_variant_for_object");
  <D.25279>:
  switch (action) <default: <D.20615>, case 0: <D.20604>, case 1: <D.20608>, case 2: <D.20606>, case 3: <D.20609>, case 4: <D.20611>, case 5: <D.20612>, case 6: <D.20613>>
  <D.20604>:
  D.25280 = mono_class_get_variant_class ();
  D.25281 = &D.25280->byval_arg;
  conv_arg = mono_mb_add_local (mb, D.25281);
  D.25282 = BIT_FIELD_REF <*t, 64, 64>;
  D.25283 = D.25282 & 8589934592;
  if (D.25283 != 0) goto <D.25284>; else goto <D.25285>;
  <D.25284>:
  D.25286 = mono_class_get_variant_class ();
  D.25287 = &D.25286->this_arg;
  *conv_arg_type = D.25287;
  goto <D.25288>;
  <D.25285>:
  D.25289 = mono_class_get_variant_class ();
  D.25290 = &D.25289->byval_arg;
  *conv_arg_type = D.25290;
  <D.25288>:
  D.25282 = BIT_FIELD_REF <*t, 64, 64>;
  D.25283 = D.25282 & 8589934592;
  if (D.25283 != 0) goto <D.25291>; else goto <D.25292>;
  <D.25291>:
  D.25293 = t->attrs;
  D.25294 = (unsigned int) D.25293;
  D.25295 = D.25294 & 3;
  if (D.25295 == 2) goto <D.20605>; else goto <D.25296>;
  <D.25296>:
  <D.25292>:
  argnum.180 = (unsigned int) argnum;
  mono_mb_emit_ldarg (mb, argnum.180);
  D.25282 = BIT_FIELD_REF <*t, 64, 64>;
  D.25283 = D.25282 & 8589934592;
  if (D.25283 != 0) goto <D.25298>; else goto <D.25299>;
  <D.25298>:
  mono_mb_emit_byte (mb, 80);
  <D.25299>:
  conv_arg.181 = (unsigned int) conv_arg;
  mono_mb_emit_ldloc_addr (mb, conv_arg.181);
  get_native_variant_for_object.178 = get_native_variant_for_object;
  mono_mb_emit_managed_call (mb, get_native_variant_for_object.178, 0B);
  goto <D.20605>;
  <D.20606>:
  {
    static struct MonoMethod * variant_clear = 0B;

    variant_clear.182 = variant_clear;
    if (variant_clear.182 == 0B) goto <D.25302>; else goto <D.25303>;
    <D.25302>:
    D.25304 = mono_class_get_variant_class ();
    variant_clear.183 = mono_class_get_method_from_name (D.25304, "Clear", 0);
    variant_clear = variant_clear.183;
    <D.25303>:
    variant_clear.182 = variant_clear;
    D.25306 = variant_clear.182 == 0B;
    D.25307 = (long int) D.25306;
    D.25308 = __builtin_expect (D.25307, 0);
    if (D.25308 != 0) goto <D.25309>; else goto <D.25310>;
    <D.25309>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 7442, "variant_clear");
    <D.25310>:
    D.25282 = BIT_FIELD_REF <*t, 64, 64>;
    D.25283 = D.25282 & 8589934592;
    if (D.25283 != 0) goto <D.25311>; else goto <D.25312>;
    <D.25311>:
    D.25293 = t->attrs;
    D.25294 = (unsigned int) D.25293;
    D.25295 = D.25294 & 3;
    if (D.25295 != 1) goto <D.25313>; else goto <D.25314>;
    <D.25313>:
    argnum.180 = (unsigned int) argnum;
    mono_mb_emit_ldarg (mb, argnum.180);
    conv_arg.181 = (unsigned int) conv_arg;
    mono_mb_emit_ldloc_addr (mb, conv_arg.181);
    get_object_for_native_variant.176 = get_object_for_native_variant;
    mono_mb_emit_managed_call (mb, get_object_for_native_variant.176, 0B);
    mono_mb_emit_byte (mb, 81);
    <D.25314>:
    <D.25312>:
    conv_arg.181 = (unsigned int) conv_arg;
    mono_mb_emit_ldloc_addr (mb, conv_arg.181);
    variant_clear.182 = variant_clear;
    mono_mb_emit_managed_call (mb, variant_clear.182, 0B);
    goto <D.20605>;
  }
  <D.20608>:
  D.25282 = BIT_FIELD_REF <*t, 64, 64>;
  D.25283 = D.25282 & 8589934592;
  if (D.25283 != 0) goto <D.25315>; else goto <D.25316>;
  <D.25315>:
  conv_arg.181 = (unsigned int) conv_arg;
  mono_mb_emit_ldloc_addr (mb, conv_arg.181);
  goto <D.25317>;
  <D.25316>:
  conv_arg.181 = (unsigned int) conv_arg;
  mono_mb_emit_ldloc (mb, conv_arg.181);
  <D.25317>:
  goto <D.20605>;
  <D.20609>:
  {
    char * msg;

    msg = monoeg_strdup ("Marshalling of VARIANT not supported as a return type.");
    mono_mb_emit_exception_marshal_directive (mb, msg);
    goto <D.20605>;
  }
  <D.20611>:
  D.25318 = mono_defaults.object_class;
  D.25319 = &D.25318->byval_arg;
  conv_arg = mono_mb_add_local (mb, D.25319);
  D.25282 = BIT_FIELD_REF <*t, 64, 64>;
  D.25283 = D.25282 & 8589934592;
  if (D.25283 != 0) goto <D.25320>; else goto <D.25321>;
  <D.25320>:
  D.25322 = mono_class_get_variant_class ();
  D.25323 = &D.25322->this_arg;
  *conv_arg_type = D.25323;
  goto <D.25324>;
  <D.25321>:
  D.25325 = mono_class_get_variant_class ();
  D.25326 = &D.25325->byval_arg;
  *conv_arg_type = D.25326;
  <D.25324>:
  D.25282 = BIT_FIELD_REF <*t, 64, 64>;
  D.25283 = D.25282 & 8589934592;
  if (D.25283 != 0) goto <D.25327>; else goto <D.25328>;
  <D.25327>:
  D.25293 = t->attrs;
  D.25294 = (unsigned int) D.25293;
  D.25295 = D.25294 & 3;
  if (D.25295 == 2) goto <D.20605>; else goto <D.25329>;
  <D.25329>:
  <D.25328>:
  D.25282 = BIT_FIELD_REF <*t, 64, 64>;
  D.25283 = D.25282 & 8589934592;
  if (D.25283 != 0) goto <D.25330>; else goto <D.25331>;
  <D.25330>:
  argnum.180 = (unsigned int) argnum;
  mono_mb_emit_ldarg (mb, argnum.180);
  goto <D.25332>;
  <D.25331>:
  argnum.180 = (unsigned int) argnum;
  mono_mb_emit_ldarg_addr (mb, argnum.180);
  <D.25332>:
  get_object_for_native_variant.176 = get_object_for_native_variant;
  mono_mb_emit_managed_call (mb, get_object_for_native_variant.176, 0B);
  conv_arg.181 = (unsigned int) conv_arg;
  mono_mb_emit_stloc (mb, conv_arg.181);
  goto <D.20605>;
  <D.20612>:
  D.25282 = BIT_FIELD_REF <*t, 64, 64>;
  D.25283 = D.25282 & 8589934592;
  if (D.25283 != 0) goto <D.25333>; else goto <D.25334>;
  <D.25333>:
  D.25293 = t->attrs;
  D.25294 = (unsigned int) D.25293;
  D.25295 = D.25294 & 3;
  if (D.25295 != 1) goto <D.25335>; else goto <D.25336>;
  <D.25335>:
  conv_arg.181 = (unsigned int) conv_arg;
  mono_mb_emit_ldloc (mb, conv_arg.181);
  argnum.180 = (unsigned int) argnum;
  mono_mb_emit_ldarg (mb, argnum.180);
  get_native_variant_for_object.178 = get_native_variant_for_object;
  mono_mb_emit_managed_call (mb, get_native_variant_for_object.178, 0B);
  <D.25336>:
  <D.25334>:
  goto <D.20605>;
  <D.20613>:
  {
    char * msg;

    msg = monoeg_strdup ("Marshalling of VARIANT not supported as a return type.");
    mono_mb_emit_exception_marshal_directive (mb, msg);
    goto <D.20605>;
  }
  <D.20615>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "marshal.c", 7506);
  <D.20605>:
  D.25337 = conv_arg;
  return D.25337;
}


emit_marshal_safehandle (struct EmitMarshalContext * m, int argnum, struct MonoType * t, struct MonoMarshalSpec * spec, int conv_arg, struct MonoType * * conv_arg_type, MarshalAction action)
{
  struct MonoClass * D.25339;
  struct MonoMethod * sh_dangerous_add_ref.184;
  unsigned int argnum.185;
  unsigned int D.25344;
  unsigned int pos.186;
  long unsigned int D.25346;
  long unsigned int D.25347;
  unsigned int conv_arg.187;
  struct MonoClass * D.25351;
  struct MonoType * D.25352;
  unsigned int dar_release_slot.188;
  struct MonoMethod * sh_dangerous_release.189;
  struct MonoClass * D.25362;
  unsigned int dar_release_slot.190;
  unsigned int D.25367;
  unsigned int label_next.191;
  unsigned int D.25369;
  unsigned int D.25370;
  gchar * D.25373;
  struct MonoType * D.25376;
  unsigned int intptr_handle_slot.192;
  struct _IO_FILE * stderr.193;
  int D.25379;
  struct MonoMethodBuilder * mb;

  mb = m->mb;
  switch (action) <default: <D.20532>, case 0: <D.20516>, case 1: <D.20521>, case 2: <D.20522>, case 3: <D.20526>, case 4: <D.20529>, case 5: <D.20530>, case 6: <D.20531>>
  <D.20516>:
  {
    struct MonoType * intptr_type;
    int dar_release_slot;
    int pos;

    D.25339 = mono_defaults.int_class;
    intptr_type = &D.25339->byval_arg;
    conv_arg = mono_mb_add_local (mb, intptr_type);
    *conv_arg_type = intptr_type;
    sh_dangerous_add_ref.184 = sh_dangerous_add_ref;
    if (sh_dangerous_add_ref.184 == 0B) goto <D.25341>; else goto <D.25342>;
    <D.25341>:
    init_safe_handle ();
    <D.25342>:
    argnum.185 = (unsigned int) argnum;
    mono_mb_emit_ldarg (mb, argnum.185);
    D.25344 = mono_mb_emit_branch (mb, 58);
    pos = (int) D.25344;
    mono_mb_emit_exception (mb, "ArgumentNullException", 0B);
    pos.186 = (unsigned int) pos;
    mono_mb_patch_branch (mb, pos.186);
    D.25346 = BIT_FIELD_REF <*t, 64, 64>;
    D.25347 = D.25346 & 8589934592;
    if (D.25347 != 0) goto <D.25348>; else goto <D.25349>;
    <D.25348>:
    mono_mb_emit_icon (mb, 0);
    conv_arg.187 = (unsigned int) conv_arg;
    mono_mb_emit_stloc (mb, conv_arg.187);
    goto <D.20520>;
    <D.25349>:
    D.25351 = mono_defaults.boolean_class;
    D.25352 = &D.25351->byval_arg;
    dar_release_slot = mono_mb_add_local (mb, D.25352);
    mono_mb_emit_icon (mb, 0);
    dar_release_slot.188 = (unsigned int) dar_release_slot;
    mono_mb_emit_stloc (mb, dar_release_slot.188);
    argnum.185 = (unsigned int) argnum;
    mono_mb_emit_ldarg (mb, argnum.185);
    dar_release_slot.188 = (unsigned int) dar_release_slot;
    mono_mb_emit_ldloc_addr (mb, dar_release_slot.188);
    sh_dangerous_add_ref.184 = sh_dangerous_add_ref;
    mono_mb_emit_managed_call (mb, sh_dangerous_add_ref.184, 0B);
    argnum.185 = (unsigned int) argnum;
    mono_mb_emit_ldarg (mb, argnum.185);
    mono_mb_emit_ldflda (mb, 16);
    mono_mb_emit_byte (mb, 77);
    conv_arg.187 = (unsigned int) conv_arg;
    mono_mb_emit_stloc (mb, conv_arg.187);
    goto <D.20520>;
  }
  <D.20521>:
  D.25346 = BIT_FIELD_REF <*t, 64, 64>;
  D.25347 = D.25346 & 8589934592;
  if (D.25347 != 0) goto <D.25354>; else goto <D.25355>;
  <D.25354>:
  conv_arg.187 = (unsigned int) conv_arg;
  mono_mb_emit_ldloc_addr (mb, conv_arg.187);
  goto <D.25356>;
  <D.25355>:
  conv_arg.187 = (unsigned int) conv_arg;
  mono_mb_emit_ldloc (mb, conv_arg.187);
  <D.25356>:
  goto <D.20520>;
  <D.20522>:
  {
    int dar_release_slot;
    int label_next;

    dar_release_slot = conv_arg + 1;
    sh_dangerous_release.189 = sh_dangerous_release;
    if (sh_dangerous_release.189 == 0B) goto <D.25358>; else goto <D.25359>;
    <D.25358>:
    init_safe_handle ();
    <D.25359>:
    D.25346 = BIT_FIELD_REF <*t, 64, 64>;
    D.25347 = D.25346 & 8589934592;
    if (D.25347 != 0) goto <D.25360>; else goto <D.25361>;
    <D.25360>:
    {
      struct MonoMethod * ctor;

      D.25362 = t->data.klass;
      ctor = mono_class_get_method_from_name (D.25362, ".ctor", 0);
      if (ctor == 0B) goto <D.25363>; else goto <D.25364>;
      <D.25363>:
      mono_mb_emit_exception (mb, "MissingMethodException", "paramterless constructor required");
      goto <D.20520>;
      <D.25364>:
      argnum.185 = (unsigned int) argnum;
      mono_mb_emit_ldarg (mb, argnum.185);
      mono_mb_emit_op (mb, 115, ctor);
      mono_mb_emit_byte (mb, 81);
      argnum.185 = (unsigned int) argnum;
      mono_mb_emit_ldarg (mb, argnum.185);
      mono_mb_emit_byte (mb, 80);
      mono_mb_emit_ldflda (mb, 16);
      conv_arg.187 = (unsigned int) conv_arg;
      mono_mb_emit_ldloc (mb, conv_arg.187);
      mono_mb_emit_byte (mb, 223);
    }
    goto <D.25365>;
    <D.25361>:
    dar_release_slot.190 = (unsigned int) dar_release_slot;
    mono_mb_emit_ldloc (mb, dar_release_slot.190);
    D.25367 = mono_mb_emit_branch (mb, 57);
    label_next = (int) D.25367;
    argnum.185 = (unsigned int) argnum;
    mono_mb_emit_ldarg (mb, argnum.185);
    sh_dangerous_release.189 = sh_dangerous_release;
    mono_mb_emit_managed_call (mb, sh_dangerous_release.189, 0B);
    label_next.191 = (unsigned int) label_next;
    mono_mb_patch_branch (mb, label_next.191);
    <D.25365>:
    goto <D.20520>;
  }
  <D.20526>:
  {
    struct MonoMethod * ctor;
    int intptr_handle_slot;

    ctor = 0B;
    D.25362 = t->data.klass;
    D.25369 = D.25362->flags;
    D.25370 = D.25369 & 128;
    if (D.25370 != 0) goto <D.25371>; else goto <D.25372>;
    <D.25371>:
    mono_mb_emit_byte (mb, 38);
    D.25373 = monoeg_strdup ("Returned SafeHandles should not be abstract");
    mono_mb_emit_exception_marshal_directive (mb, D.25373);
    goto <D.20520>;
    <D.25372>:
    D.25362 = t->data.klass;
    ctor = mono_class_get_method_from_name (D.25362, ".ctor", 0);
    if (ctor == 0B) goto <D.25374>; else goto <D.25375>;
    <D.25374>:
    mono_mb_emit_byte (mb, 38);
    mono_mb_emit_exception (mb, "MissingMethodException", "paramterless constructor required");
    goto <D.20520>;
    <D.25375>:
    D.25339 = mono_defaults.int_class;
    D.25376 = &D.25339->byval_arg;
    intptr_handle_slot = mono_mb_add_local (mb, D.25376);
    intptr_handle_slot.192 = (unsigned int) intptr_handle_slot;
    mono_mb_emit_stloc (mb, intptr_handle_slot.192);
    mono_mb_emit_op (mb, 115, ctor);
    mono_mb_emit_stloc (mb, 3);
    mono_mb_emit_ldloc (mb, 3);
    mono_mb_emit_ldflda (mb, 16);
    intptr_handle_slot.192 = (unsigned int) intptr_handle_slot;
    mono_mb_emit_ldloc (mb, intptr_handle_slot.192);
    mono_mb_emit_byte (mb, 223);
    goto <D.20520>;
  }
  <D.20529>:
  stderr.193 = stderr;
  fprintf (stderr.193, "mono/marshal: SafeHandles missing MANAGED_CONV_IN\n");
  goto <D.20520>;
  <D.20530>:
  stderr.193 = stderr;
  fprintf (stderr.193, "mono/marshal: SafeHandles missing MANAGED_CONV_OUT\n");
  goto <D.20520>;
  <D.20531>:
  stderr.193 = stderr;
  fprintf (stderr.193, "mono/marshal: SafeHandles missing MANAGED_CONV_RESULT\n");
  goto <D.20520>;
  <D.20532>:
  printf ("Unhandled case for MarshalAction: %d\n", action);
  <D.20520>:
  D.25379 = conv_arg;
  return D.25379;
}


init_safe_handle ()
{
  struct MonoClass * D.25381;
  struct MonoMethod * D.25382;
  struct MonoMethod * D.25383;

  D.25381 = mono_defaults.safehandle_class;
  D.25382 = mono_class_get_method_from_name (D.25381, "DangerousAddRef", 1);
  sh_dangerous_add_ref = D.25382;
  D.25381 = mono_defaults.safehandle_class;
  D.25383 = mono_class_get_method_from_name (D.25381, "DangerousRelease", 0);
  sh_dangerous_release = D.25383;
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__))
printf (const char * restrict __fmt)
{
  int D.25384;

  D.25384 = __printf_chk (1, __fmt, __builtin_va_arg_pack ());
  return D.25384;
}


emit_marshal_array (struct EmitMarshalContext * m, int argnum, struct MonoType * t, struct MonoMarshalSpec * spec, int conv_arg, struct MonoType * * conv_arg_type, MarshalAction action)
{
  struct MonoMethodPInvoke * D.25386;
  struct MonoClass * D.25387;
  struct MonoType * D.25388;
  struct MonoClass * D.25389;
  long unsigned int D.25390;
  long unsigned int D.25391;
  unsigned int argnum.194;
  long unsigned int D.25395;
  long unsigned int D.25396;
  void * D.25399;
  unsigned int conv_arg.195;
  struct MonoClass * D.25402;
  struct MonoType * D.25403;
  struct MonoClass * D.25404;
  struct MonoClass * D.25408;
  unsigned int src_var.196;
  struct MonoClass * D.25422;
  int iftmp.197;
  int D.25426;
  unsigned int dest_ptr.198;
  unsigned int index_var.199;
  int D.25435;
  void * D.25438;
  MonoMarshalNative iftmp.200;
  short unsigned int D.25444;
  short unsigned int D.25445;
  int iftmp.201;
  short unsigned int D.25455;
  int D.25456;
  int D.25457;
  struct MonoType * D.25458;
  int need_free.202;
  int need_free.203;
  int iftmp.204;
  int D.25471;
  unsigned int src_ptr.205;
  unsigned int index_var.206;
  int D.25480;
  _Bool D.25485;
  long int D.25486;
  long int D.25487;
  void * D.25492;
  MonoMarshalNative iftmp.207;
  unsigned int loc.208;
  short unsigned int D.25512;
  short unsigned int D.25513;
  void * D.25516;
  int D.25522;
  <unnamed type> D.25525;
  short int D.25528;
  short int D.25529;
  struct MonoMethodSignature * D.25547;
  short unsigned int D.25548;
  int D.25549;
  struct MonoType * D.25552;
  unsigned char D.25553;
  int D.25554;
  unsigned int src_ptr.209;
  unsigned int param_num.210;
  long unsigned int D.25562;
  long unsigned int D.25563;
  unsigned int index_var.211;
  int D.25567;
  _Bool D.25570;
  long int D.25571;
  long int D.25572;
  void * D.25575;
  short unsigned int D.25577;
  short unsigned int D.25578;
  _Bool D.25580;
  long int D.25581;
  long int D.25582;
  _Bool D.25585;
  long int D.25586;
  long int D.25587;
  _Bool D.25590;
  long int D.25591;
  long int D.25592;
  unsigned int dest_ptr.212;
  long unsigned int D.25611;
  long unsigned int D.25612;
  unsigned int index_var.213;
  int D.25616;
  _Bool D.25619;
  long int D.25620;
  long int D.25621;
  void * D.25624;
  short unsigned int D.25626;
  short unsigned int D.25627;
  int iftmp.214;
  int D.25639;
  unsigned int src.215;
  unsigned int dest.216;
  unsigned int index_var.217;
  int D.25649;
  _Bool D.25652;
  long int D.25653;
  long int D.25654;
  void * D.25657;
  short unsigned int D.25659;
  short unsigned int D.25660;
  struct MonoMethodBuilder * mb;
  struct MonoClass * klass;
  gboolean need_convert;
  gboolean need_free;
  MonoMarshalNative encoding;

  try
    {
      mb = m->mb;
      klass = mono_class_from_mono_type (t);
      D.25386 = m->piinfo;
      encoding = mono_marshal_get_string_encoding (D.25386, spec);
      switch (action) <default: <D.20721>, case 0: <D.20637>, case 1: <D.20661>, case 2: <D.20650>, case 3: <D.20662>, case 4: <D.20663>, case 5: <D.20695>, case 6: <D.20709>>
      <D.20637>:
      D.25387 = mono_defaults.object_class;
      D.25388 = &D.25387->byval_arg;
      *conv_arg_type = D.25388;
      D.25387 = mono_defaults.object_class;
      D.25388 = &D.25387->byval_arg;
      conv_arg = mono_mb_add_local (mb, D.25388);
      D.25389 = klass->element_class;
      D.25390 = BIT_FIELD_REF <*D.25389, 64, 256>;
      D.25391 = D.25390 & 288230376151711744;
      if (D.25391 != 0) goto <D.25392>; else goto <D.25393>;
      <D.25392>:
      argnum.194 = (unsigned int) argnum;
      mono_mb_emit_ldarg (mb, argnum.194);
      D.25395 = BIT_FIELD_REF <*t, 64, 64>;
      D.25396 = D.25395 & 8589934592;
      if (D.25396 != 0) goto <D.25397>; else goto <D.25398>;
      <D.25397>:
      mono_mb_emit_byte (mb, 77);
      <D.25398>:
      D.25399 = conv_to_icall (23);
      mono_mb_emit_icall (mb, D.25399);
      conv_arg.195 = (unsigned int) conv_arg;
      mono_mb_emit_stloc (mb, conv_arg.195);
      goto <D.25401>;
      <D.25393>:
      {
        struct MonoClass * eklass;
        guint32 label1;
        guint32 label2;
        guint32 label3;
        int index_var;
        int src_var;
        int dest_ptr;
        int esize;
        MonoMarshalConv conv;
        gboolean is_string;

        is_string = 0;
        D.25402 = mono_defaults.int_class;
        D.25403 = &D.25402->byval_arg;
        dest_ptr = mono_mb_add_local (mb, D.25403);
        eklass = klass->element_class;
        D.25404 = mono_defaults.string_class;
        if (D.25404 == eklass) goto <D.25405>; else goto <D.25406>;
        <D.25405>:
        is_string = 1;
        D.25386 = m->piinfo;
        conv = mono_marshal_get_string_to_ptr_conv (D.25386, spec);
        goto <D.25407>;
        <D.25406>:
        D.25408 = mono_defaults.stringbuilder_class;
        if (D.25408 == eklass) goto <D.25409>; else goto <D.25410>;
        <D.25409>:
        is_string = 1;
        D.25386 = m->piinfo;
        conv = mono_marshal_get_stringbuilder_to_ptr_conv (D.25386, spec);
        goto <D.25411>;
        <D.25410>:
        conv = 4294967295;
        <D.25411>:
        <D.25407>:
        if (is_string != 0) goto <D.25412>; else goto <D.25413>;
        <D.25412>:
        if (conv == 4294967295) goto <D.25414>; else goto <D.25415>;
        <D.25414>:
        {
          char * msg;

          msg = monoeg_g_strdup_printf ("string/stringbuilder marshalling conversion %d not implemented", encoding);
          mono_mb_emit_exception_marshal_directive (mb, msg);
          goto <D.20649>;
        }
        <D.25415>:
        <D.25413>:
        D.25387 = mono_defaults.object_class;
        D.25388 = &D.25387->byval_arg;
        src_var = mono_mb_add_local (mb, D.25388);
        argnum.194 = (unsigned int) argnum;
        mono_mb_emit_ldarg (mb, argnum.194);
        D.25395 = BIT_FIELD_REF <*t, 64, 64>;
        D.25396 = D.25395 & 8589934592;
        if (D.25396 != 0) goto <D.25416>; else goto <D.25417>;
        <D.25416>:
        mono_mb_emit_byte (mb, 77);
        <D.25417>:
        src_var.196 = (unsigned int) src_var;
        mono_mb_emit_stloc (mb, src_var.196);
        src_var.196 = (unsigned int) src_var;
        mono_mb_emit_ldloc (mb, src_var.196);
        conv_arg.195 = (unsigned int) conv_arg;
        mono_mb_emit_stloc (mb, conv_arg.195);
        src_var.196 = (unsigned int) src_var;
        mono_mb_emit_ldloc (mb, src_var.196);
        label1 = mono_mb_emit_branch (mb, 57);
        if (is_string != 0) goto <D.25419>; else goto <D.25420>;
        <D.25419>:
        esize = 8;
        goto <D.25421>;
        <D.25420>:
        D.25422 = mono_defaults.char_class;
        if (D.25422 == eklass) goto <D.25423>; else goto <D.25424>;
        <D.25423>:
        D.25386 = m->piinfo;
        D.25426 = mono_pinvoke_is_unicode (D.25386);
        if (D.25426 != 0) goto <D.25427>; else goto <D.25428>;
        <D.25427>:
        iftmp.197 = 2;
        goto <D.25429>;
        <D.25428>:
        iftmp.197 = 1;
        <D.25429>:
        esize = iftmp.197;
        goto <D.25430>;
        <D.25424>:
        esize = mono_class_native_size (eklass, 0B);
        <D.25430>:
        <D.25421>:
        mono_mb_emit_icon (mb, esize);
        src_var.196 = (unsigned int) src_var;
        mono_mb_emit_ldloc (mb, src_var.196);
        mono_mb_emit_byte (mb, 142);
        D.25404 = mono_defaults.string_class;
        if (D.25404 == eklass) goto <D.25431>; else goto <D.25432>;
        <D.25431>:
        mono_mb_emit_byte (mb, 23);
        mono_mb_emit_byte (mb, 88);
        <D.25432>:
        mono_mb_emit_byte (mb, 90);
        mono_mb_emit_byte (mb, 254);
        mono_mb_emit_byte (mb, 15);
        conv_arg.195 = (unsigned int) conv_arg;
        mono_mb_emit_stloc (mb, conv_arg.195);
        conv_arg.195 = (unsigned int) conv_arg;
        mono_mb_emit_ldloc (mb, conv_arg.195);
        dest_ptr.198 = (unsigned int) dest_ptr;
        mono_mb_emit_stloc (mb, dest_ptr.198);
        D.25402 = mono_defaults.int_class;
        D.25403 = &D.25402->byval_arg;
        index_var = mono_mb_add_local (mb, D.25403);
        mono_mb_emit_byte (mb, 22);
        index_var.199 = (unsigned int) index_var;
        mono_mb_emit_stloc (mb, index_var.199);
        D.25435 = mono_mb_get_label (mb);
        label2 = (guint32) D.25435;
        index_var.199 = (unsigned int) index_var;
        mono_mb_emit_ldloc (mb, index_var.199);
        src_var.196 = (unsigned int) src_var;
        mono_mb_emit_ldloc (mb, src_var.196);
        mono_mb_emit_byte (mb, 142);
        label3 = mono_mb_emit_branch (mb, 60);
        if (is_string != 0) goto <D.25436>; else goto <D.25437>;
        <D.25436>:
        dest_ptr.198 = (unsigned int) dest_ptr;
        mono_mb_emit_ldloc (mb, dest_ptr.198);
        src_var.196 = (unsigned int) src_var;
        mono_mb_emit_ldloc (mb, src_var.196);
        index_var.199 = (unsigned int) index_var;
        mono_mb_emit_ldloc (mb, index_var.199);
        mono_mb_emit_byte (mb, 154);
        D.25438 = conv_to_icall (conv);
        mono_mb_emit_icall (mb, D.25438);
        mono_mb_emit_byte (mb, 223);
        goto <D.25439>;
        <D.25437>:
        src_var.196 = (unsigned int) src_var;
        mono_mb_emit_ldloc (mb, src_var.196);
        index_var.199 = (unsigned int) index_var;
        mono_mb_emit_ldloc (mb, index_var.199);
        mono_mb_emit_op (mb, 143, eklass);
        mono_mb_emit_stloc (mb, 0);
        dest_ptr.198 = (unsigned int) dest_ptr;
        mono_mb_emit_ldloc (mb, dest_ptr.198);
        mono_mb_emit_stloc (mb, 1);
        D.25422 = mono_defaults.char_class;
        if (D.25422 == eklass) goto <D.25441>; else goto <D.25442>;
        <D.25441>:
        iftmp.200 = encoding;
        goto <D.25443>;
        <D.25442>:
        iftmp.200 = 4294967295;
        <D.25443>:
        emit_struct_conv_full (mb, eklass, 0, iftmp.200);
        <D.25439>:
        D.25444 = (short unsigned int) index_var;
        mono_mb_emit_add_to_local (mb, D.25444, 1);
        D.25445 = (short unsigned int) dest_ptr;
        mono_mb_emit_add_to_local (mb, D.25445, esize);
        mono_mb_emit_branch_label (mb, 56, label2);
        mono_mb_patch_branch (mb, label3);
        D.25404 = mono_defaults.string_class;
        if (D.25404 == eklass) goto <D.25446>; else goto <D.25447>;
        <D.25446>:
        dest_ptr.198 = (unsigned int) dest_ptr;
        mono_mb_emit_ldloc (mb, dest_ptr.198);
        mono_mb_emit_byte (mb, 22);
        mono_mb_emit_byte (mb, 81);
        <D.25447>:
        mono_mb_patch_branch (mb, label1);
      }
      <D.25401>:
      goto <D.20649>;
      <D.20650>:
      D.25389 = klass->element_class;
      D.25422 = mono_defaults.char_class;
      if (D.25389 == D.25422) goto <D.25453>; else goto <D.25449>;
      <D.25453>:
      if (encoding == 21) goto <D.25450>; else goto <D.25449>;
      <D.25449>:
      D.25389 = klass->element_class;
      D.25408 = mono_defaults.stringbuilder_class;
      if (D.25389 == D.25408) goto <D.25450>; else goto <D.25454>;
      <D.25454>:
      D.25455 = t->attrs;
      D.25456 = (int) D.25455;
      D.25457 = D.25456 & 2;
      if (D.25457 != 0) goto <D.25450>; else goto <D.25451>;
      <D.25450>:
      iftmp.201 = 1;
      goto <D.25452>;
      <D.25451>:
      iftmp.201 = 0;
      <D.25452>:
      need_convert = iftmp.201;
      D.25389 = klass->element_class;
      D.25458 = &D.25389->byval_arg;
      D.25386 = m->piinfo;
      need_free.202 = mono_marshal_need_free (D.25458, D.25386, spec);
      need_free = need_free.202;
      if (need_convert != 0) goto <D.25460>; else goto <D.25462>;
      <D.25462>:
      need_free.203 = need_free;
      if (need_free.203 != 0) goto <D.25460>; else goto <D.25461>;
      <D.25460>:
      {
        struct MonoClass * eklass;
        guint32 label1;
        guint32 label2;
        guint32 label3;
        int index_var;
        int src_ptr;
        int loc;
        int esize;

        eklass = klass->element_class;
        D.25408 = mono_defaults.stringbuilder_class;
        if (D.25408 == eklass) goto <D.25464>; else goto <D.25467>;
        <D.25467>:
        D.25404 = mono_defaults.string_class;
        if (D.25404 == eklass) goto <D.25464>; else goto <D.25465>;
        <D.25464>:
        esize = 8;
        goto <D.25466>;
        <D.25465>:
        D.25422 = mono_defaults.char_class;
        if (D.25422 == eklass) goto <D.25468>; else goto <D.25469>;
        <D.25468>:
        D.25386 = m->piinfo;
        D.25471 = mono_pinvoke_is_unicode (D.25386);
        if (D.25471 != 0) goto <D.25472>; else goto <D.25473>;
        <D.25472>:
        iftmp.204 = 2;
        goto <D.25474>;
        <D.25473>:
        iftmp.204 = 1;
        <D.25474>:
        esize = iftmp.204;
        goto <D.25475>;
        <D.25469>:
        esize = mono_class_native_size (eklass, 0B);
        <D.25475>:
        <D.25466>:
        D.25402 = mono_defaults.int_class;
        D.25403 = &D.25402->byval_arg;
        src_ptr = mono_mb_add_local (mb, D.25403);
        D.25402 = mono_defaults.int_class;
        D.25403 = &D.25402->byval_arg;
        loc = mono_mb_add_local (mb, D.25403);
        argnum.194 = (unsigned int) argnum;
        mono_mb_emit_ldarg (mb, argnum.194);
        D.25395 = BIT_FIELD_REF <*t, 64, 64>;
        D.25396 = D.25395 & 8589934592;
        if (D.25396 != 0) goto <D.25476>; else goto <D.25477>;
        <D.25476>:
        mono_mb_emit_byte (mb, 77);
        <D.25477>:
        label1 = mono_mb_emit_branch (mb, 57);
        conv_arg.195 = (unsigned int) conv_arg;
        mono_mb_emit_ldloc (mb, conv_arg.195);
        src_ptr.205 = (unsigned int) src_ptr;
        mono_mb_emit_stloc (mb, src_ptr.205);
        D.25402 = mono_defaults.int_class;
        D.25403 = &D.25402->byval_arg;
        index_var = mono_mb_add_local (mb, D.25403);
        mono_mb_emit_byte (mb, 22);
        index_var.206 = (unsigned int) index_var;
        mono_mb_emit_stloc (mb, index_var.206);
        D.25480 = mono_mb_get_label (mb);
        label2 = (guint32) D.25480;
        index_var.206 = (unsigned int) index_var;
        mono_mb_emit_ldloc (mb, index_var.206);
        argnum.194 = (unsigned int) argnum;
        mono_mb_emit_ldarg (mb, argnum.194);
        D.25395 = BIT_FIELD_REF <*t, 64, 64>;
        D.25396 = D.25395 & 8589934592;
        if (D.25396 != 0) goto <D.25481>; else goto <D.25482>;
        <D.25481>:
        mono_mb_emit_byte (mb, 80);
        <D.25482>:
        mono_mb_emit_byte (mb, 142);
        label3 = mono_mb_emit_branch (mb, 60);
        D.25408 = mono_defaults.stringbuilder_class;
        if (D.25408 == eklass) goto <D.25483>; else goto <D.25484>;
        <D.25483>:
        {
          gboolean need_free2;
          MonoMarshalConv conv;

          try
            {
              D.25386 = m->piinfo;
              conv = mono_marshal_get_ptr_to_stringbuilder_conv (D.25386, spec, &need_free2);
              D.25485 = conv == 4294967295;
              D.25486 = (long int) D.25485;
              D.25487 = __builtin_expect (D.25486, 0);
              if (D.25487 != 0) goto <D.25488>; else goto <D.25489>;
              <D.25488>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 7735, "conv != -1");
              <D.25489>:
              argnum.194 = (unsigned int) argnum;
              mono_mb_emit_ldarg (mb, argnum.194);
              D.25395 = BIT_FIELD_REF <*t, 64, 64>;
              D.25396 = D.25395 & 8589934592;
              if (D.25396 != 0) goto <D.25490>; else goto <D.25491>;
              <D.25490>:
              mono_mb_emit_byte (mb, 77);
              <D.25491>:
              index_var.206 = (unsigned int) index_var;
              mono_mb_emit_ldloc (mb, index_var.206);
              mono_mb_emit_byte (mb, 154);
              src_ptr.205 = (unsigned int) src_ptr;
              mono_mb_emit_ldloc (mb, src_ptr.205);
              mono_mb_emit_byte (mb, 77);
              D.25492 = conv_to_icall (conv);
              mono_mb_emit_icall (mb, D.25492);
              need_free.203 = need_free;
              if (need_free.203 != 0) goto <D.25493>; else goto <D.25494>;
              <D.25493>:
              src_ptr.205 = (unsigned int) src_ptr;
              mono_mb_emit_ldloc (mb, src_ptr.205);
              mono_mb_emit_byte (mb, 77);
              mono_mb_emit_icall (mb, mono_marshal_free);
              <D.25494>:
            }
          finally
            {
              need_free2 = {CLOBBER};
            }
        }
        goto <D.25495>;
        <D.25484>:
        D.25404 = mono_defaults.string_class;
        if (D.25404 == eklass) goto <D.25496>; else goto <D.25497>;
        <D.25496>:
        need_free.203 = need_free;
        if (need_free.203 != 0) goto <D.25498>; else goto <D.25499>;
        <D.25498>:
        src_ptr.205 = (unsigned int) src_ptr;
        mono_mb_emit_ldloc (mb, src_ptr.205);
        mono_mb_emit_byte (mb, 77);
        mono_mb_emit_icall (mb, mono_marshal_free);
        <D.25499>:
        goto <D.25500>;
        <D.25497>:
        if (need_convert != 0) goto <D.25501>; else goto <D.25502>;
        <D.25501>:
        src_ptr.205 = (unsigned int) src_ptr;
        mono_mb_emit_ldloc (mb, src_ptr.205);
        mono_mb_emit_stloc (mb, 0);
        argnum.194 = (unsigned int) argnum;
        mono_mb_emit_ldarg (mb, argnum.194);
        D.25395 = BIT_FIELD_REF <*t, 64, 64>;
        D.25396 = D.25395 & 8589934592;
        if (D.25396 != 0) goto <D.25503>; else goto <D.25504>;
        <D.25503>:
        mono_mb_emit_byte (mb, 80);
        <D.25504>:
        index_var.206 = (unsigned int) index_var;
        mono_mb_emit_ldloc (mb, index_var.206);
        mono_mb_emit_op (mb, 143, eklass);
        mono_mb_emit_stloc (mb, 1);
        D.25422 = mono_defaults.char_class;
        if (D.25422 == eklass) goto <D.25506>; else goto <D.25507>;
        <D.25506>:
        iftmp.207 = encoding;
        goto <D.25508>;
        <D.25507>:
        iftmp.207 = 4294967295;
        <D.25508>:
        emit_struct_conv_full (mb, eklass, 1, iftmp.207);
        <D.25502>:
        need_free.203 = need_free;
        if (need_free.203 != 0) goto <D.25509>; else goto <D.25510>;
        <D.25509>:
        src_ptr.205 = (unsigned int) src_ptr;
        mono_mb_emit_ldloc (mb, src_ptr.205);
        loc.208 = (unsigned int) loc;
        mono_mb_emit_stloc (mb, loc.208);
        loc.208 = (unsigned int) loc;
        mono_mb_emit_ldloc (mb, loc.208);
        emit_struct_free (mb, eklass, loc);
        <D.25510>:
        <D.25500>:
        <D.25495>:
        D.25512 = (short unsigned int) index_var;
        mono_mb_emit_add_to_local (mb, D.25512, 1);
        D.25513 = (short unsigned int) src_ptr;
        mono_mb_emit_add_to_local (mb, D.25513, esize);
        mono_mb_emit_branch_label (mb, 56, label2);
        mono_mb_patch_branch (mb, label1);
        mono_mb_patch_branch (mb, label3);
      }
      <D.25461>:
      D.25389 = klass->element_class;
      D.25390 = BIT_FIELD_REF <*D.25389, 64, 256>;
      D.25391 = D.25390 & 288230376151711744;
      if (D.25391 != 0) goto <D.25514>; else goto <D.25515>;
      <D.25514>:
      argnum.194 = (unsigned int) argnum;
      mono_mb_emit_ldarg (mb, argnum.194);
      conv_arg.195 = (unsigned int) conv_arg;
      mono_mb_emit_ldloc (mb, conv_arg.195);
      D.25516 = conv_to_icall (24);
      mono_mb_emit_icall (mb, D.25516);
      <D.25515>:
      goto <D.20649>;
      <D.20661>:
      D.25395 = BIT_FIELD_REF <*t, 64, 64>;
      D.25396 = D.25395 & 8589934592;
      if (D.25396 != 0) goto <D.25517>; else goto <D.25518>;
      <D.25517>:
      conv_arg.195 = (unsigned int) conv_arg;
      mono_mb_emit_ldloc_addr (mb, conv_arg.195);
      goto <D.25519>;
      <D.25518>:
      conv_arg.195 = (unsigned int) conv_arg;
      mono_mb_emit_ldloc (mb, conv_arg.195);
      <D.25519>:
      goto <D.20649>;
      <D.20662>:
      mono_mb_emit_stloc (mb, 3);
      goto <D.20649>;
      <D.20663>:
      {
        struct MonoClass * eklass;
        guint32 label1;
        guint32 label2;
        guint32 label3;
        int index_var;
        int src_ptr;
        int loc;
        int esize;
        int param_num;
        int num_elem;
        MonoMarshalConv conv;
        gboolean is_string;

        is_string = 0;
        D.25387 = mono_defaults.object_class;
        D.25388 = &D.25387->byval_arg;
        conv_arg = mono_mb_add_local (mb, D.25388);
        D.25402 = mono_defaults.int_class;
        D.25403 = &D.25402->byval_arg;
        *conv_arg_type = D.25403;
        D.25395 = BIT_FIELD_REF <*t, 64, 64>;
        D.25396 = D.25395 & 8589934592;
        if (D.25396 != 0) goto <D.25520>; else goto <D.25521>;
        <D.25520>:
        {
          char * msg;

          msg = monoeg_strdup ("Byref array marshalling to managed code is not implemented.");
          mono_mb_emit_exception_marshal_directive (mb, msg);
          D.25522 = conv_arg;
          return D.25522;
        }
        <D.25521>:
        if (spec == 0B) goto <D.25523>; else goto <D.25524>;
        <D.25523>:
        {
          char * msg;

          msg = monoeg_strdup ("[MarshalAs] attribute required to marshal arrays to managed code.");
          mono_mb_emit_exception_marshal_directive (mb, msg);
          D.25522 = conv_arg;
          return D.25522;
        }
        <D.25524>:
        D.25525 = spec->native;
        if (D.25525 != 42) goto <D.25526>; else goto <D.25527>;
        <D.25526>:
        {
          char * msg;

          msg = monoeg_strdup ("Non LPArray marshalling of arrays to managed code is not implemented.");
          mono_mb_emit_exception_marshal_directive (mb, msg);
          D.25522 = conv_arg;
          return D.25522;
        }
        <D.25527>:
        D.25528 = spec->data.array_data.param_num;
        param_num = (int) D.25528;
        num_elem = spec->data.array_data.num_elem;
        D.25529 = spec->data.array_data.elem_mult;
        if (D.25529 == 0) goto <D.25530>; else goto <D.25531>;
        <D.25530>:
        param_num = -1;
        <D.25531>:
        if (param_num == -1) goto <D.25532>; else goto <D.25533>;
        <D.25532>:
        if (num_elem <= 0) goto <D.25534>; else goto <D.25535>;
        <D.25534>:
        {
          char * msg;

          msg = monoeg_strdup ("Either SizeConst or SizeParamIndex should be specified when marshalling arrays to managed code.");
          mono_mb_emit_exception_marshal_directive (mb, msg);
          D.25522 = conv_arg;
          return D.25522;
        }
        <D.25535>:
        <D.25533>:
        eklass = klass->element_class;
        D.25404 = mono_defaults.string_class;
        if (D.25404 == eklass) goto <D.25536>; else goto <D.25537>;
        <D.25536>:
        is_string = 1;
        D.25386 = m->piinfo;
        conv = mono_marshal_get_ptr_to_string_conv (D.25386, spec, &need_free);
        goto <D.25538>;
        <D.25537>:
        D.25408 = mono_defaults.stringbuilder_class;
        if (D.25408 == eklass) goto <D.25539>; else goto <D.25540>;
        <D.25539>:
        is_string = 1;
        D.25386 = m->piinfo;
        conv = mono_marshal_get_ptr_to_stringbuilder_conv (D.25386, spec, &need_free);
        goto <D.25541>;
        <D.25540>:
        conv = 4294967295;
        <D.25541>:
        <D.25538>:
        mono_marshal_load_type_info (eklass);
        if (is_string != 0) goto <D.25542>; else goto <D.25543>;
        <D.25542>:
        esize = 8;
        goto <D.25544>;
        <D.25543>:
        esize = mono_class_native_size (eklass, 0B);
        <D.25544>:
        D.25402 = mono_defaults.int_class;
        D.25403 = &D.25402->byval_arg;
        src_ptr = mono_mb_add_local (mb, D.25403);
        D.25402 = mono_defaults.int_class;
        D.25403 = &D.25402->byval_arg;
        loc = mono_mb_add_local (mb, D.25403);
        mono_mb_emit_byte (mb, 20);
        conv_arg.195 = (unsigned int) conv_arg;
        mono_mb_emit_stloc (mb, conv_arg.195);
        if (param_num != -1) goto <D.25545>; else goto <D.25546>;
        <D.25545>:
        D.25547 = m->sig;
        D.25548 = D.25547->param_count;
        D.25549 = (int) D.25548;
        if (D.25549 <= param_num) goto <D.25550>; else goto <D.25551>;
        <D.25550>:
        {
          char * msg;

          msg = monoeg_strdup ("Array size control parameter index is out of range.");
          mono_mb_emit_exception_marshal_directive (mb, msg);
          D.25522 = conv_arg;
          return D.25522;
        }
        <D.25551>:
        D.25547 = m->sig;
        D.25552 = D.25547->params[param_num];
        D.25553 = D.25552->type;
        D.25554 = (int) D.25553;
        switch (D.25554) <default: <D.20692>, case 4: <D.20681>, case 5: <D.20682>, case 6: <D.20683>, case 7: <D.20684>, case 8: <D.20685>, case 9: <D.20686>, case 10: <D.20689>, case 11: <D.20690>, case 24: <D.20687>, case 25: <D.20688>>
        <D.20681>:
        <D.20682>:
        <D.20683>:
        <D.20684>:
        <D.20685>:
        <D.20686>:
        <D.20687>:
        <D.20688>:
        <D.20689>:
        <D.20690>:
        goto <D.20691>;
        <D.20692>:
        {
          char * msg;

          msg = monoeg_strdup ("Array size control parameter must be an integral type.");
          mono_mb_emit_exception_marshal_directive (mb, msg);
          D.25522 = conv_arg;
          return D.25522;
        }
        <D.20691>:
        <D.25546>:
        argnum.194 = (unsigned int) argnum;
        mono_mb_emit_ldarg (mb, argnum.194);
        label1 = mono_mb_emit_branch (mb, 57);
        argnum.194 = (unsigned int) argnum;
        mono_mb_emit_ldarg (mb, argnum.194);
        src_ptr.209 = (unsigned int) src_ptr;
        mono_mb_emit_stloc (mb, src_ptr.209);
        if (param_num == -1) goto <D.25556>; else goto <D.25557>;
        <D.25556>:
        mono_mb_emit_icon (mb, num_elem);
        goto <D.25558>;
        <D.25557>:
        param_num.210 = (unsigned int) param_num;
        mono_mb_emit_ldarg (mb, param_num.210);
        if (num_elem > 0) goto <D.25560>; else goto <D.25561>;
        <D.25560>:
        mono_mb_emit_icon (mb, num_elem);
        mono_mb_emit_byte (mb, 88);
        <D.25561>:
        mono_mb_emit_byte (mb, 212);
        <D.25558>:
        mono_mb_emit_op (mb, 141, eklass);
        conv_arg.195 = (unsigned int) conv_arg;
        mono_mb_emit_stloc (mb, conv_arg.195);
        D.25562 = BIT_FIELD_REF <*eklass, 64, 256>;
        D.25563 = D.25562 & 288230376151711744;
        if (D.25563 != 0) goto <D.25564>; else goto <D.25565>;
        <D.25564>:
        conv_arg.195 = (unsigned int) conv_arg;
        mono_mb_emit_ldloc (mb, conv_arg.195);
        mono_mb_emit_byte (mb, 211);
        mono_mb_emit_icon (mb, 32);
        mono_mb_emit_byte (mb, 88);
        argnum.194 = (unsigned int) argnum;
        mono_mb_emit_ldarg (mb, argnum.194);
        conv_arg.195 = (unsigned int) conv_arg;
        mono_mb_emit_ldloc (mb, conv_arg.195);
        mono_mb_emit_byte (mb, 142);
        mono_mb_emit_icon (mb, esize);
        mono_mb_emit_byte (mb, 90);
        mono_mb_emit_byte (mb, 254);
        mono_mb_emit_byte (mb, 23);
        goto <D.20649>;
        <D.25565>:
        D.25402 = mono_defaults.int_class;
        D.25403 = &D.25402->byval_arg;
        index_var = mono_mb_add_local (mb, D.25403);
        mono_mb_emit_byte (mb, 22);
        index_var.211 = (unsigned int) index_var;
        mono_mb_emit_stloc (mb, index_var.211);
        D.25567 = mono_mb_get_label (mb);
        label2 = (guint32) D.25567;
        index_var.211 = (unsigned int) index_var;
        mono_mb_emit_ldloc (mb, index_var.211);
        conv_arg.195 = (unsigned int) conv_arg;
        mono_mb_emit_ldloc (mb, conv_arg.195);
        mono_mb_emit_byte (mb, 142);
        label3 = mono_mb_emit_branch (mb, 60);
        if (is_string != 0) goto <D.25568>; else goto <D.25569>;
        <D.25568>:
        D.25570 = conv == 4294967295;
        D.25571 = (long int) D.25570;
        D.25572 = __builtin_expect (D.25571, 0);
        if (D.25572 != 0) goto <D.25573>; else goto <D.25574>;
        <D.25573>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 7976, "conv != -1");
        <D.25574>:
        conv_arg.195 = (unsigned int) conv_arg;
        mono_mb_emit_ldloc (mb, conv_arg.195);
        index_var.211 = (unsigned int) index_var;
        mono_mb_emit_ldloc (mb, index_var.211);
        src_ptr.209 = (unsigned int) src_ptr;
        mono_mb_emit_ldloc (mb, src_ptr.209);
        mono_mb_emit_byte (mb, 77);
        D.25575 = conv_to_icall (conv);
        mono_mb_emit_icall (mb, D.25575);
        mono_mb_emit_byte (mb, 162);
        goto <D.25576>;
        <D.25569>:
        {
          char * msg;

          msg = monoeg_strdup ("Marshalling of non-string and non-blittable arrays to managed code is not implemented.");
          mono_mb_emit_exception_marshal_directive (mb, msg);
          D.25522 = conv_arg;
          return D.25522;
        }
        <D.25576>:
        D.25577 = (short unsigned int) index_var;
        mono_mb_emit_add_to_local (mb, D.25577, 1);
        D.25578 = (short unsigned int) src_ptr;
        mono_mb_emit_add_to_local (mb, D.25578, esize);
        mono_mb_emit_branch_label (mb, 56, label2);
        mono_mb_patch_branch (mb, label1);
        mono_mb_patch_branch (mb, label3);
        goto <D.20649>;
      }
      <D.20695>:
      {
        struct MonoClass * eklass;
        guint32 label1;
        guint32 label2;
        guint32 label3;
        int index_var;
        int dest_ptr;
        int loc;
        int esize;
        int param_num;
        int num_elem;
        MonoMarshalConv conv;
        gboolean is_string;

        is_string = 0;
        if (spec == 0B) goto <D.20649>; else goto <D.25579>;
        <D.25579>:
        D.25395 = BIT_FIELD_REF <*t, 64, 64>;
        D.25396 = D.25395 & 8589934592;
        D.25580 = D.25396 != 0;
        D.25581 = (long int) D.25580;
        D.25582 = __builtin_expect (D.25581, 0);
        if (D.25582 != 0) goto <D.25583>; else goto <D.25584>;
        <D.25583>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 8015, "!t->byref");
        <D.25584>:
        D.25525 = spec->native;
        D.25585 = D.25525 != 42;
        D.25586 = (long int) D.25585;
        D.25587 = __builtin_expect (D.25586, 0);
        if (D.25587 != 0) goto <D.25588>; else goto <D.25589>;
        <D.25588>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 8016, "spec->native == MONO_NATIVE_LPARRAY");
        <D.25589>:
        D.25455 = t->attrs;
        D.25456 = (int) D.25455;
        D.25457 = D.25456 & 2;
        D.25590 = D.25457 == 0;
        D.25591 = (long int) D.25590;
        D.25592 = __builtin_expect (D.25591, 0);
        if (D.25592 != 0) goto <D.25593>; else goto <D.25594>;
        <D.25593>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 8017, "t->attrs & PARAM_ATTRIBUTE_OUT");
        <D.25594>:
        D.25528 = spec->data.array_data.param_num;
        param_num = (int) D.25528;
        num_elem = spec->data.array_data.num_elem;
        D.25529 = spec->data.array_data.elem_mult;
        if (D.25529 == 0) goto <D.25595>; else goto <D.25596>;
        <D.25595>:
        param_num = -1;
        <D.25596>:
        if (param_num == -1) goto <D.25597>; else goto <D.25598>;
        <D.25597>:
        if (num_elem <= 0) goto <D.25599>; else goto <D.25600>;
        <D.25599>:
        monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "marshal.c", 8028);
        <D.25600>:
        <D.25598>:
        eklass = klass->element_class;
        D.25404 = mono_defaults.string_class;
        if (D.25404 == eklass) goto <D.25601>; else goto <D.25602>;
        <D.25601>:
        is_string = 1;
        D.25386 = m->piinfo;
        conv = mono_marshal_get_string_to_ptr_conv (D.25386, spec);
        goto <D.25603>;
        <D.25602>:
        D.25408 = mono_defaults.stringbuilder_class;
        if (D.25408 == eklass) goto <D.25604>; else goto <D.25605>;
        <D.25604>:
        is_string = 1;
        D.25386 = m->piinfo;
        conv = mono_marshal_get_stringbuilder_to_ptr_conv (D.25386, spec);
        goto <D.25606>;
        <D.25605>:
        conv = 4294967295;
        <D.25606>:
        <D.25603>:
        mono_marshal_load_type_info (eklass);
        if (is_string != 0) goto <D.25607>; else goto <D.25608>;
        <D.25607>:
        esize = 8;
        goto <D.25609>;
        <D.25608>:
        esize = mono_class_native_size (eklass, 0B);
        <D.25609>:
        D.25402 = mono_defaults.int_class;
        D.25403 = &D.25402->byval_arg;
        dest_ptr = mono_mb_add_local (mb, D.25403);
        D.25402 = mono_defaults.int_class;
        D.25403 = &D.25402->byval_arg;
        loc = mono_mb_add_local (mb, D.25403);
        conv_arg.195 = (unsigned int) conv_arg;
        mono_mb_emit_ldloc (mb, conv_arg.195);
        label1 = mono_mb_emit_branch (mb, 57);
        argnum.194 = (unsigned int) argnum;
        mono_mb_emit_ldarg (mb, argnum.194);
        dest_ptr.212 = (unsigned int) dest_ptr;
        mono_mb_emit_stloc (mb, dest_ptr.212);
        D.25611 = BIT_FIELD_REF <*eklass, 64, 256>;
        D.25612 = D.25611 & 288230376151711744;
        if (D.25612 != 0) goto <D.25613>; else goto <D.25614>;
        <D.25613>:
        argnum.194 = (unsigned int) argnum;
        mono_mb_emit_ldarg (mb, argnum.194);
        conv_arg.195 = (unsigned int) conv_arg;
        mono_mb_emit_ldloc (mb, conv_arg.195);
        mono_mb_emit_byte (mb, 211);
        mono_mb_emit_icon (mb, 32);
        mono_mb_emit_byte (mb, 88);
        conv_arg.195 = (unsigned int) conv_arg;
        mono_mb_emit_ldloc (mb, conv_arg.195);
        mono_mb_emit_byte (mb, 142);
        mono_mb_emit_icon (mb, esize);
        mono_mb_emit_byte (mb, 90);
        mono_mb_emit_byte (mb, 254);
        mono_mb_emit_byte (mb, 23);
        goto <D.20649>;
        <D.25614>:
        D.25402 = mono_defaults.int_class;
        D.25403 = &D.25402->byval_arg;
        index_var = mono_mb_add_local (mb, D.25403);
        mono_mb_emit_byte (mb, 22);
        index_var.213 = (unsigned int) index_var;
        mono_mb_emit_stloc (mb, index_var.213);
        D.25616 = mono_mb_get_label (mb);
        label2 = (guint32) D.25616;
        index_var.213 = (unsigned int) index_var;
        mono_mb_emit_ldloc (mb, index_var.213);
        conv_arg.195 = (unsigned int) conv_arg;
        mono_mb_emit_ldloc (mb, conv_arg.195);
        mono_mb_emit_byte (mb, 142);
        label3 = mono_mb_emit_branch (mb, 60);
        if (is_string != 0) goto <D.25617>; else goto <D.25618>;
        <D.25617>:
        D.25619 = conv == 4294967295;
        D.25620 = (long int) D.25619;
        D.25621 = __builtin_expect (D.25620, 0);
        if (D.25621 != 0) goto <D.25622>; else goto <D.25623>;
        <D.25622>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 8093, "conv != -1");
        <D.25623>:
        dest_ptr.212 = (unsigned int) dest_ptr;
        mono_mb_emit_ldloc (mb, dest_ptr.212);
        conv_arg.195 = (unsigned int) conv_arg;
        mono_mb_emit_ldloc (mb, conv_arg.195);
        index_var.213 = (unsigned int) index_var;
        mono_mb_emit_ldloc (mb, index_var.213);
        mono_mb_emit_byte (mb, 154);
        D.25624 = conv_to_icall (conv);
        mono_mb_emit_icall (mb, D.25624);
        mono_mb_emit_byte (mb, 223);
        goto <D.25625>;
        <D.25618>:
        {
          char * msg;

          msg = monoeg_strdup ("Marshalling of non-string and non-blittable arrays to managed code is not implemented.");
          mono_mb_emit_exception_marshal_directive (mb, msg);
          D.25522 = conv_arg;
          return D.25522;
        }
        <D.25625>:
        D.25626 = (short unsigned int) index_var;
        mono_mb_emit_add_to_local (mb, D.25626, 1);
        D.25627 = (short unsigned int) dest_ptr;
        mono_mb_emit_add_to_local (mb, D.25627, esize);
        mono_mb_emit_branch_label (mb, 56, label2);
        mono_mb_patch_branch (mb, label1);
        mono_mb_patch_branch (mb, label3);
        goto <D.20649>;
      }
      <D.20709>:
      {
        struct MonoClass * eklass;
        guint32 label1;
        guint32 label2;
        guint32 label3;
        int index_var;
        int src;
        int dest;
        int esize;
        MonoMarshalConv conv;
        gboolean is_string;

        conv = 4294967295;
        is_string = 0;
        D.25395 = BIT_FIELD_REF <*t, 64, 64>;
        D.25396 = D.25395 & 8589934592;
        D.25580 = D.25396 != 0;
        D.25581 = (long int) D.25580;
        D.25582 = __builtin_expect (D.25581, 0);
        if (D.25582 != 0) goto <D.25628>; else goto <D.25629>;
        <D.25628>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 8130, "!t->byref");
        <D.25629>:
        eklass = klass->element_class;
        mono_marshal_load_type_info (eklass);
        D.25404 = mono_defaults.string_class;
        if (D.25404 == eklass) goto <D.25630>; else goto <D.25631>;
        <D.25630>:
        is_string = 1;
        D.25386 = m->piinfo;
        conv = mono_marshal_get_string_to_ptr_conv (D.25386, spec);
        goto <D.25632>;
        <D.25631>:
        monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "marshal.c", 8141);
        <D.25632>:
        if (is_string != 0) goto <D.25633>; else goto <D.25634>;
        <D.25633>:
        esize = 8;
        goto <D.25635>;
        <D.25634>:
        D.25422 = mono_defaults.char_class;
        if (D.25422 == eklass) goto <D.25636>; else goto <D.25637>;
        <D.25636>:
        D.25386 = m->piinfo;
        D.25639 = mono_pinvoke_is_unicode (D.25386);
        if (D.25639 != 0) goto <D.25640>; else goto <D.25641>;
        <D.25640>:
        iftmp.214 = 2;
        goto <D.25642>;
        <D.25641>:
        iftmp.214 = 1;
        <D.25642>:
        esize = iftmp.214;
        goto <D.25643>;
        <D.25637>:
        esize = mono_class_native_size (eklass, 0B);
        <D.25643>:
        <D.25635>:
        D.25387 = mono_defaults.object_class;
        D.25388 = &D.25387->byval_arg;
        src = mono_mb_add_local (mb, D.25388);
        D.25402 = mono_defaults.int_class;
        D.25403 = &D.25402->byval_arg;
        dest = mono_mb_add_local (mb, D.25403);
        src.215 = (unsigned int) src;
        mono_mb_emit_stloc (mb, src.215);
        src.215 = (unsigned int) src;
        mono_mb_emit_ldloc (mb, src.215);
        mono_mb_emit_stloc (mb, 3);
        src.215 = (unsigned int) src;
        mono_mb_emit_ldloc (mb, src.215);
        label1 = mono_mb_emit_branch (mb, 57);
        mono_mb_emit_icon (mb, esize);
        src.215 = (unsigned int) src;
        mono_mb_emit_ldloc (mb, src.215);
        mono_mb_emit_byte (mb, 142);
        D.25404 = mono_defaults.string_class;
        if (D.25404 == eklass) goto <D.25645>; else goto <D.25646>;
        <D.25645>:
        mono_mb_emit_byte (mb, 23);
        mono_mb_emit_byte (mb, 88);
        <D.25646>:
        mono_mb_emit_byte (mb, 90);
        mono_mb_emit_icall (mb, mono_marshal_alloc);
        dest.216 = (unsigned int) dest;
        mono_mb_emit_stloc (mb, dest.216);
        dest.216 = (unsigned int) dest;
        mono_mb_emit_ldloc (mb, dest.216);
        mono_mb_emit_stloc (mb, 3);
        D.25402 = mono_defaults.int_class;
        D.25403 = &D.25402->byval_arg;
        index_var = mono_mb_add_local (mb, D.25403);
        mono_mb_emit_byte (mb, 22);
        index_var.217 = (unsigned int) index_var;
        mono_mb_emit_stloc (mb, index_var.217);
        D.25649 = mono_mb_get_label (mb);
        label2 = (guint32) D.25649;
        index_var.217 = (unsigned int) index_var;
        mono_mb_emit_ldloc (mb, index_var.217);
        src.215 = (unsigned int) src;
        mono_mb_emit_ldloc (mb, src.215);
        mono_mb_emit_byte (mb, 142);
        label3 = mono_mb_emit_branch (mb, 60);
        if (is_string != 0) goto <D.25650>; else goto <D.25651>;
        <D.25650>:
        D.25652 = conv == 4294967295;
        D.25653 = (long int) D.25652;
        D.25654 = __builtin_expect (D.25653, 0);
        if (D.25654 != 0) goto <D.25655>; else goto <D.25656>;
        <D.25655>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 8190, "conv != -1");
        <D.25656>:
        dest.216 = (unsigned int) dest;
        mono_mb_emit_ldloc (mb, dest.216);
        src.215 = (unsigned int) src;
        mono_mb_emit_ldloc (mb, src.215);
        index_var.217 = (unsigned int) index_var;
        mono_mb_emit_ldloc (mb, index_var.217);
        mono_mb_emit_byte (mb, 154);
        D.25657 = conv_to_icall (conv);
        mono_mb_emit_icall (mb, D.25657);
        mono_mb_emit_byte (mb, 223);
        goto <D.25658>;
        <D.25651>:
        {
          char * msg;

          msg = monoeg_strdup ("Marshalling of non-string arrays to managed code is not implemented.");
          mono_mb_emit_exception_marshal_directive (mb, msg);
          D.25522 = conv_arg;
          return D.25522;
        }
        <D.25658>:
        D.25659 = (short unsigned int) index_var;
        mono_mb_emit_add_to_local (mb, D.25659, 1);
        D.25660 = (short unsigned int) dest;
        mono_mb_emit_add_to_local (mb, D.25660, esize);
        mono_mb_emit_branch_label (mb, 56, label2);
        mono_mb_patch_branch (mb, label3);
        mono_mb_patch_branch (mb, label1);
        goto <D.20649>;
      }
      <D.20721>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "marshal.c", 8220);
      <D.20649>:
      D.25522 = conv_arg;
      return D.25522;
    }
  finally
    {
      need_free = {CLOBBER};
    }
}


mono_marshal_need_free (struct MonoType * t, struct MonoMethodPInvoke * piinfo, struct MonoMarshalSpec * spec)
{
  unsigned char D.25664;
  int D.25665;
  gboolean D.25666;
  struct MonoClass * D.25667;
  struct MonoClass * D.25668;
  _Bool D.25671;
  MonoMarshalNative encoding;
  MonoMarshalConv conv;

  D.25664 = t->type;
  D.25665 = (int) D.25664;
  switch (D.25665) <default: <D.19500>, case 14: <D.19499>, case 17: <D.19495>, case 18: <D.19497>, case 28: <D.19496>>
  <D.19495>:
  D.25666 = 1;
  return D.25666;
  <D.19496>:
  <D.19497>:
  D.25667 = t->data.klass;
  D.25668 = mono_defaults.stringbuilder_class;
  if (D.25667 == D.25668) goto <D.25669>; else goto <D.25670>;
  <D.25669>:
  {
    gboolean need_free;

    try
      {
        conv = mono_marshal_get_ptr_to_stringbuilder_conv (piinfo, spec, &need_free);
        D.25666 = need_free;
        return D.25666;
      }
    finally
      {
        need_free = {CLOBBER};
      }
  }
  <D.25670>:
  D.25666 = 0;
  return D.25666;
  <D.19499>:
  encoding = mono_marshal_get_string_encoding (piinfo, spec);
  D.25671 = encoding != 21;
  D.25666 = (gboolean) D.25671;
  return D.25666;
  <D.19500>:
  D.25666 = 0;
  return D.25666;
}


emit_struct_conv_full (struct MonoMethodBuilder * mb, struct MonoClass * klass, gboolean to_object, MonoMarshalNative string_encoding)
{
  struct MonoClass * D.25674;
  unsigned int D.25677;
  long unsigned int D.25680;
  long unsigned int D.25681;
  unsigned int msize.218;
  _Bool D.25685;
  long int D.25686;
  long int D.25687;
  struct MonoClass * D.25690;
  unsigned int D.25693;
  unsigned int D.25694;
  struct MonoType * D.25697;
  char * D.25698;
  struct MonoClassField * D.25699;
  unsigned int D.25700;
  unsigned int D.25701;
  unsigned int i.219;
  _Bool D.25703;
  short unsigned int D.25704;
  int D.25705;
  int D.25706;
  struct MonoMarshalSpec * D.25709;
  <unnamed-unsigned:1> D.25710;
  int D.25711;
  int D.25714;
  int D.25715;
  unsigned int D.25716;
  unsigned int D.25717;
  int D.25719;
  struct MonoClassField * D.25720;
  int D.25721;
  unsigned int D.25722;
  unsigned int D.25723;
  struct MonoType * D.25732;
  int D.25733;
  struct MonoType * D.25736;
  int D.25737;
  char * D.25738;
  <unnamed type> conv.220;
  long unsigned int D.25742;
  long unsigned int D.25743;
  unsigned char D.25745;
  unsigned int D.25755;
  unsigned char D.25756;
  unsigned int D.25757;
  unsigned char D.25758;
  struct MonoClass * D.25759;
  long unsigned int D.25760;
  long unsigned int D.25761;
  struct MonoClass * D.25764;
  struct MonoType * D.25765;
  unsigned int src_var.221;
  unsigned int dst_var.222;
  struct MonoMethod * variant_clear.223;
  struct MonoClass * D.25773;
  struct MonoMethod * variant_clear.224;
  struct MonoMethod * get_object_for_native_variant.225;
  struct MonoClass * D.25778;
  struct MonoMethod * get_object_for_native_variant.226;
  struct MonoMethod * get_native_variant_for_object.227;
  struct MonoMethod * get_native_variant_for_object.228;
  int D.25785;
  unsigned int src_var.229;
  unsigned int dst_var.230;
  struct MonoMarshalType * info;
  int i;
  void handle_enum = <<< error >>>;

  D.25674 = klass->parent;
  if (D.25674 != 0B) goto <D.25675>; else goto <D.25676>;
  <D.25675>:
  D.25674 = klass->parent;
  emit_struct_conv (mb, D.25674, to_object);
  <D.25676>:
  info = mono_marshal_load_type_info (klass);
  D.25677 = info->native_size;
  if (D.25677 == 0) goto <D.25678>; else goto <D.25679>;
  <D.25678>:
  return;
  <D.25679>:
  D.25680 = BIT_FIELD_REF <*klass, 64, 256>;
  D.25681 = D.25680 & 288230376151711744;
  if (D.25681 != 0) goto <D.25682>; else goto <D.25683>;
  <D.25682>:
  {
    int msize;

    msize = mono_class_value_size (klass, 0B);
    D.25677 = info->native_size;
    msize.218 = (unsigned int) msize;
    D.25685 = D.25677 != msize.218;
    D.25686 = (long int) D.25685;
    D.25687 = __builtin_expect (D.25686, 0);
    if (D.25687 != 0) goto <D.25688>; else goto <D.25689>;
    <D.25688>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 1871, "msize == info->native_size");
    <D.25689>:
    mono_mb_emit_ldloc (mb, 1);
    mono_mb_emit_ldloc (mb, 0);
    mono_mb_emit_icon (mb, msize);
    mono_mb_emit_byte (mb, 254);
    mono_mb_emit_byte (mb, 23);
    mono_mb_emit_add_to_local (mb, 0, msize);
    mono_mb_emit_add_to_local (mb, 1, msize);
    return;
  }
  <D.25683>:
  D.25690 = mono_defaults.safehandle_class;
  if (D.25690 != klass) goto <D.25691>; else goto <D.25692>;
  <D.25691>:
  D.25693 = klass->flags;
  D.25694 = D.25693 & 24;
  if (D.25694 == 0) goto <D.25695>; else goto <D.25696>;
  <D.25695>:
  {
    char * msg;

    D.25697 = &klass->byval_arg;
    D.25698 = mono_type_full_name (D.25697);
    msg = monoeg_g_strdup_printf ("Type %s which is passed to unmanaged code must have a StructLayout attribute.", D.25698);
    mono_mb_emit_exception_marshal_directive (mb, msg);
    return;
  }
  <D.25696>:
  <D.25692>:
  i = 0;
  goto <D.19375>;
  <D.19374>:
  {
    MonoMarshalNative ntype;
    MonoMarshalConv conv;
    struct MonoType * ftype;
    int msize;
    int usize;
    gboolean last_field;

    try
      {
        D.25699 = info->fields[i].field;
        ftype = D.25699->type;
        msize = 0;
        usize = 0;
        D.25700 = info->num_fields;
        D.25701 = D.25700 + 4294967295;
        i.219 = (unsigned int) i;
        D.25703 = D.25701 <= i.219;
        last_field = (gboolean) D.25703;
        D.25704 = ftype->attrs;
        D.25705 = (int) D.25704;
        D.25706 = D.25705 & 16;
        if (D.25706 != 0) goto <D.25707>; else goto <D.25708>;
        <D.25707>:
        // predicted unlikely by continue predictor.
        goto <D.19343>;
        <D.25708>:
        D.25709 = info->fields[i].mspec;
        D.25710 = klass->unicode;
        D.25711 = (int) D.25710;
        ntype = mono_type_to_unmanaged (ftype, D.25709, 1, D.25711, &conv);
        if (last_field != 0) goto <D.25712>; else goto <D.25713>;
        <D.25712>:
        D.25714 = klass->instance_size;
        D.25699 = info->fields[i].field;
        D.25715 = D.25699->offset;
        msize = D.25714 - D.25715;
        D.25677 = info->native_size;
        D.25716 = info->fields[i].offset;
        D.25717 = D.25677 - D.25716;
        usize = (int) D.25717;
        goto <D.25718>;
        <D.25713>:
        D.25719 = i + 1;
        D.25720 = info->fields[D.25719].field;
        D.25721 = D.25720->offset;
        D.25699 = info->fields[i].field;
        D.25715 = D.25699->offset;
        msize = D.25721 - D.25715;
        D.25719 = i + 1;
        D.25722 = info->fields[D.25719].offset;
        D.25716 = info->fields[i].offset;
        D.25723 = D.25722 - D.25716;
        usize = (int) D.25723;
        <D.25718>:
        D.25690 = mono_defaults.safehandle_class;
        if (D.25690 != klass) goto <D.25724>; else goto <D.25725>;
        <D.25724>:
        D.25693 = klass->flags;
        D.25694 = D.25693 & 24;
        if (D.25694 == 16) goto <D.25726>; else goto <D.25727>;
        <D.25726>:
        if (usize == 0) goto <D.25728>; else goto <D.25729>;
        <D.25728>:
        D.25699 = info->fields[i].field;
        D.25732 = D.25699->type;
        D.25733 = mono_type_is_reference (D.25732);
        if (D.25733 != 0) goto <D.25730>; else goto <D.25734>;
        <D.25734>:
        if (last_field == 0) goto <D.25735>; else goto <D.25731>;
        <D.25735>:
        D.25719 = i + 1;
        D.25720 = info->fields[D.25719].field;
        D.25736 = D.25720->type;
        D.25737 = mono_type_is_reference (D.25736);
        if (D.25737 != 0) goto <D.25730>; else goto <D.25731>;
        <D.25730>:
        D.25697 = &klass->byval_arg;
        D.25738 = mono_type_full_name (D.25697);
        monoeg_g_log (0B, 4, "Type %s which has an [ExplicitLayout] attribute cannot have a reference field at the same offset as another field.", D.25738);
        <D.19344>:
        goto <D.19344>;
        <D.25731>:
        <D.25729>:
        <D.25727>:
        <D.25725>:
        conv.220 = conv;
        switch (conv.220) <default: <D.19371>, case 0: <D.19345>>
        <D.19345>:
        {
          int t;

          D.25742 = BIT_FIELD_REF <*ftype, 64, 64>;
          D.25743 = D.25742 & 8589934592;
          if (D.25743 != 0) goto <D.25740>; else goto <D.25744>;
          <D.25744>:
          D.25745 = ftype->type;
          if (D.25745 == 24) goto <D.25740>; else goto <D.25746>;
          <D.25746>:
          D.25745 = ftype->type;
          if (D.25745 == 25) goto <D.25740>; else goto <D.25741>;
          <D.25740>:
          mono_mb_emit_ldloc (mb, 1);
          mono_mb_emit_ldloc (mb, 0);
          mono_mb_emit_byte (mb, 77);
          mono_mb_emit_byte (mb, 223);
          goto <D.19347>;
          <D.25741>:
          handle_enum:
          D.25745 = ftype->type;
          t = (int) D.25745;
          switch (t) <default: <D.19370>, case 2: <D.19353>, case 3: <D.19356>, case 4: <D.19351>, case 5: <D.19352>, case 6: <D.19354>, case 7: <D.19355>, case 8: <D.19349>, case 9: <D.19350>, case 10: <D.19357>, case 11: <D.19358>, case 12: <D.19360>, case 13: <D.19361>, case 15: <D.19359>, case 17: <D.19363>, case 28: <D.19366>>
          <D.19349>:
          <D.19350>:
          <D.19351>:
          <D.19352>:
          <D.19353>:
          <D.19354>:
          <D.19355>:
          <D.19356>:
          <D.19357>:
          <D.19358>:
          <D.19359>:
          <D.19360>:
          <D.19361>:
          mono_mb_emit_ldloc (mb, 1);
          mono_mb_emit_ldloc (mb, 0);
          if (t == 3) goto <D.25749>; else goto <D.25747>;
          <D.25749>:
          if (ntype == 4) goto <D.25750>; else goto <D.25747>;
          <D.25750>:
          if (string_encoding != 21) goto <D.25751>; else goto <D.25747>;
          <D.25751>:
          if (to_object != 0) goto <D.25752>; else goto <D.25753>;
          <D.25752>:
          mono_mb_emit_byte (mb, 71);
          mono_mb_emit_byte (mb, 83);
          goto <D.25754>;
          <D.25753>:
          mono_mb_emit_byte (mb, 73);
          mono_mb_emit_byte (mb, 82);
          <D.25754>:
          goto <D.25748>;
          <D.25747>:
          D.25755 = mono_type_to_ldind (ftype);
          D.25756 = (unsigned char) D.25755;
          mono_mb_emit_byte (mb, D.25756);
          D.25757 = mono_type_to_stind (ftype);
          D.25758 = (unsigned char) D.25757;
          mono_mb_emit_byte (mb, D.25758);
          <D.25748>:
          goto <D.19362>;
          <D.19363>:
          {
            int src_var;
            int dst_var;

            D.25759 = ftype->data.klass;
            D.25760 = BIT_FIELD_REF <*D.25759, 64, 256>;
            D.25761 = D.25760 & 576460752303423488;
            if (D.25761 != 0) goto <D.25762>; else goto <D.25763>;
            <D.25762>:
            D.25759 = ftype->data.klass;
            ftype = mono_class_enum_basetype (D.25759);
            goto handle_enum;
            <D.25763>:
            D.25764 = mono_defaults.int_class;
            D.25765 = &D.25764->byval_arg;
            src_var = mono_mb_add_local (mb, D.25765);
            D.25764 = mono_defaults.int_class;
            D.25765 = &D.25764->byval_arg;
            dst_var = mono_mb_add_local (mb, D.25765);
            mono_mb_emit_ldloc (mb, 0);
            src_var.221 = (unsigned int) src_var;
            mono_mb_emit_stloc (mb, src_var.221);
            mono_mb_emit_ldloc (mb, 1);
            dst_var.222 = (unsigned int) dst_var;
            mono_mb_emit_stloc (mb, dst_var.222);
            D.25759 = ftype->data.klass;
            emit_struct_conv (mb, D.25759, to_object);
            src_var.221 = (unsigned int) src_var;
            mono_mb_emit_ldloc (mb, src_var.221);
            mono_mb_emit_stloc (mb, 0);
            dst_var.222 = (unsigned int) dst_var;
            mono_mb_emit_ldloc (mb, dst_var.222);
            mono_mb_emit_stloc (mb, 1);
            goto <D.19362>;
          }
          <D.19366>:
          if (to_object != 0) goto <D.25768>; else goto <D.25769>;
          <D.25768>:
          {
            static struct MonoMethod * variant_clear = 0B;
            static struct MonoMethod * get_object_for_native_variant = 0B;

            variant_clear.223 = variant_clear;
            if (variant_clear.223 == 0B) goto <D.25771>; else goto <D.25772>;
            <D.25771>:
            D.25773 = mono_class_get_variant_class ();
            variant_clear.224 = mono_class_get_method_from_name (D.25773, "Clear", 0);
            variant_clear = variant_clear.224;
            <D.25772>:
            get_object_for_native_variant.225 = get_object_for_native_variant;
            if (get_object_for_native_variant.225 == 0B) goto <D.25776>; else goto <D.25777>;
            <D.25776>:
            D.25778 = mono_defaults.marshal_class;
            get_object_for_native_variant.226 = mono_class_get_method_from_name (D.25778, "GetObjectForNativeVariant", 1);
            get_object_for_native_variant = get_object_for_native_variant.226;
            <D.25777>:
            mono_mb_emit_ldloc (mb, 1);
            mono_mb_emit_ldloc (mb, 0);
            get_object_for_native_variant.225 = get_object_for_native_variant;
            mono_mb_emit_managed_call (mb, get_object_for_native_variant.225, 0B);
            mono_mb_emit_byte (mb, 81);
            mono_mb_emit_ldloc (mb, 0);
            variant_clear.223 = variant_clear;
            mono_mb_emit_managed_call (mb, variant_clear.223, 0B);
          }
          goto <D.25780>;
          <D.25769>:
          {
            static struct MonoMethod * get_native_variant_for_object = 0B;

            get_native_variant_for_object.227 = get_native_variant_for_object;
            if (get_native_variant_for_object.227 == 0B) goto <D.25782>; else goto <D.25783>;
            <D.25782>:
            D.25778 = mono_defaults.marshal_class;
            get_native_variant_for_object.228 = mono_class_get_method_from_name (D.25778, "GetNativeVariantForObject", 2);
            get_native_variant_for_object = get_native_variant_for_object.228;
            <D.25783>:
            mono_mb_emit_ldloc (mb, 0);
            mono_mb_emit_byte (mb, 80);
            mono_mb_emit_ldloc (mb, 1);
            get_native_variant_for_object.227 = get_native_variant_for_object;
            mono_mb_emit_managed_call (mb, get_native_variant_for_object.227, 0B);
          }
          <D.25780>:
          goto <D.19362>;
          <D.19370>:
          D.25745 = ftype->type;
          D.25785 = (int) D.25745;
          monoeg_g_log (0B, 16, "marshaling type %02x not implemented", D.25785);
          monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "marshal.c", 2038);
          <D.19362>:
          goto <D.19347>;
        }
        <D.19371>:
        {
          int src_var;
          int dst_var;

          D.25764 = mono_defaults.int_class;
          D.25765 = &D.25764->byval_arg;
          src_var = mono_mb_add_local (mb, D.25765);
          D.25764 = mono_defaults.int_class;
          D.25765 = &D.25764->byval_arg;
          dst_var = mono_mb_add_local (mb, D.25765);
          mono_mb_emit_ldloc (mb, 0);
          src_var.229 = (unsigned int) src_var;
          mono_mb_emit_stloc (mb, src_var.229);
          mono_mb_emit_ldloc (mb, 1);
          dst_var.230 = (unsigned int) dst_var;
          mono_mb_emit_stloc (mb, dst_var.230);
          if (to_object != 0) goto <D.25788>; else goto <D.25789>;
          <D.25788>:
          conv.220 = conv;
          D.25709 = info->fields[i].mspec;
          emit_ptr_to_object_conv (mb, ftype, conv.220, D.25709);
          goto <D.25790>;
          <D.25789>:
          conv.220 = conv;
          D.25709 = info->fields[i].mspec;
          emit_object_to_ptr_conv (mb, ftype, conv.220, D.25709);
          <D.25790>:
          src_var.229 = (unsigned int) src_var;
          mono_mb_emit_ldloc (mb, src_var.229);
          mono_mb_emit_stloc (mb, 0);
          dst_var.230 = (unsigned int) dst_var;
          mono_mb_emit_ldloc (mb, dst_var.230);
          mono_mb_emit_stloc (mb, 1);
        }
        <D.19347>:
        if (to_object != 0) goto <D.25791>; else goto <D.25792>;
        <D.25791>:
        mono_mb_emit_add_to_local (mb, 0, usize);
        mono_mb_emit_add_to_local (mb, 1, msize);
        goto <D.25793>;
        <D.25792>:
        mono_mb_emit_add_to_local (mb, 0, msize);
        mono_mb_emit_add_to_local (mb, 1, usize);
        <D.25793>:
      }
    finally
      {
        conv = {CLOBBER};
      }
  }
  <D.19343>:
  i = i + 1;
  <D.19375>:
  D.25700 = info->num_fields;
  i.219 = (unsigned int) i;
  if (D.25700 > i.219) goto <D.19374>; else goto <D.19376>;
  <D.19376>:
}


emit_struct_conv (struct MonoMethodBuilder * mb, struct MonoClass * klass, gboolean to_object)
{
  emit_struct_conv_full (mb, klass, to_object, 4294967295);
}


emit_ptr_to_object_conv (struct MonoMethodBuilder * mb, struct MonoType * type, MonoMarshalConv conv, struct MonoMarshalSpec * mspec)
{
  unsigned char D.25797;
  int D.25801;
  long unsigned int D.25802;
  long unsigned int D.25803;
  int D.25806;
  struct MonoClass * D.25808;
  struct MonoType * D.25809;
  struct MonoClass * D.25810;
  struct MonoType * D.25811;
  unsigned int array_var.231;
  unsigned int src_var.232;
  unsigned int dst_var.233;
  unsigned int index_var.234;
  int D.25816;
  short unsigned int D.25817;
  <unnamed type> D.25821;
  unsigned int src_var.235;
  unsigned int dst_var.236;
  struct MonoClass * D.25826;
  const char * D.25827;

  switch (conv) <default: <D.19252>, case 1: <D.19218>, case 2: <D.19216>, case 3: <D.19248>, case 4: <D.19233>, case 7: <D.19234>, case 9: <D.19232>, case 10: <D.19249>, case 11: <D.19250>, case 12: <D.19230>, case 13: <D.19231>, case 20: <D.19219>, case 21: <D.19228>, case 22: <D.19251>, case 23: <D.19241>, case 25: <D.19243>, case 26: <D.19245>, case 27: <D.19244>, case 28: <D.19235>, case 29: <D.19239>, case 33: <D.19246>, case 34: <D.19247>>
  <D.19216>:
  mono_mb_emit_ldloc (mb, 1);
  mono_mb_emit_ldloc (mb, 0);
  mono_mb_emit_byte (mb, 74);
  mono_mb_emit_byte (mb, 44);
  mono_mb_emit_byte (mb, 3);
  mono_mb_emit_byte (mb, 23);
  mono_mb_emit_byte (mb, 43);
  mono_mb_emit_byte (mb, 1);
  mono_mb_emit_byte (mb, 22);
  mono_mb_emit_byte (mb, 82);
  goto <D.19217>;
  <D.19218>:
  mono_mb_emit_ldloc (mb, 1);
  mono_mb_emit_ldloc (mb, 0);
  mono_mb_emit_byte (mb, 72);
  mono_mb_emit_byte (mb, 44);
  mono_mb_emit_byte (mb, 3);
  mono_mb_emit_byte (mb, 23);
  mono_mb_emit_byte (mb, 43);
  mono_mb_emit_byte (mb, 1);
  mono_mb_emit_byte (mb, 22);
  mono_mb_emit_byte (mb, 82);
  goto <D.19217>;
  <D.19219>:
  {
    struct MonoClass * eklass;
    int esize;

    eklass = 0B;
    D.25797 = type->type;
    if (D.25797 == 29) goto <D.25798>; else goto <D.25799>;
    <D.25798>:
    eklass = type->data.klass;
    goto <D.25800>;
    <D.25799>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "marshal.c", 1279);
    <D.25800>:
    esize = mono_class_native_size (eklass, 0B);
    mono_mb_emit_ldloc (mb, 1);
    D.25801 = mspec->data.array_data.num_elem;
    mono_mb_emit_icon (mb, D.25801);
    mono_mb_emit_op (mb, 141, eklass);
    mono_mb_emit_byte (mb, 223);
    D.25802 = BIT_FIELD_REF <*eklass, 64, 256>;
    D.25803 = D.25802 & 288230376151711744;
    if (D.25803 != 0) goto <D.25804>; else goto <D.25805>;
    <D.25804>:
    mono_mb_emit_ldloc (mb, 1);
    mono_mb_emit_byte (mb, 77);
    mono_mb_emit_icon (mb, 32);
    mono_mb_emit_byte (mb, 88);
    mono_mb_emit_ldloc (mb, 0);
    D.25801 = mspec->data.array_data.num_elem;
    D.25806 = D.25801 * esize;
    mono_mb_emit_icon (mb, D.25806);
    mono_mb_emit_byte (mb, 254);
    mono_mb_emit_byte (mb, 23);
    goto <D.25807>;
    <D.25805>:
    {
      int array_var;
      int src_var;
      int dst_var;
      int index_var;
      guint32 label2;
      guint32 label3;

      D.25808 = mono_defaults.object_class;
      D.25809 = &D.25808->byval_arg;
      array_var = mono_mb_add_local (mb, D.25809);
      D.25810 = mono_defaults.int_class;
      D.25811 = &D.25810->byval_arg;
      src_var = mono_mb_add_local (mb, D.25811);
      D.25810 = mono_defaults.int_class;
      D.25811 = &D.25810->byval_arg;
      dst_var = mono_mb_add_local (mb, D.25811);
      mono_mb_emit_ldloc (mb, 1);
      mono_mb_emit_byte (mb, 80);
      array_var.231 = (unsigned int) array_var;
      mono_mb_emit_stloc (mb, array_var.231);
      mono_mb_emit_ldloc (mb, 0);
      src_var.232 = (unsigned int) src_var;
      mono_mb_emit_stloc (mb, src_var.232);
      mono_mb_emit_ldloc (mb, 1);
      dst_var.233 = (unsigned int) dst_var;
      mono_mb_emit_stloc (mb, dst_var.233);
      D.25810 = mono_defaults.int_class;
      D.25811 = &D.25810->byval_arg;
      index_var = mono_mb_add_local (mb, D.25811);
      mono_mb_emit_byte (mb, 22);
      index_var.234 = (unsigned int) index_var;
      mono_mb_emit_stloc (mb, index_var.234);
      D.25816 = mono_mb_get_label (mb);
      label2 = (guint32) D.25816;
      index_var.234 = (unsigned int) index_var;
      mono_mb_emit_ldloc (mb, index_var.234);
      array_var.231 = (unsigned int) array_var;
      mono_mb_emit_ldloc (mb, array_var.231);
      mono_mb_emit_byte (mb, 142);
      label3 = mono_mb_emit_branch (mb, 60);
      array_var.231 = (unsigned int) array_var;
      mono_mb_emit_ldloc (mb, array_var.231);
      index_var.234 = (unsigned int) index_var;
      mono_mb_emit_ldloc (mb, index_var.234);
      mono_mb_emit_op (mb, 143, eklass);
      mono_mb_emit_stloc (mb, 1);
      emit_struct_conv (mb, eklass, 1);
      D.25817 = (short unsigned int) index_var;
      mono_mb_emit_add_to_local (mb, D.25817, 1);
      mono_mb_emit_branch_label (mb, 56, label2);
      mono_mb_patch_branch (mb, label3);
      src_var.232 = (unsigned int) src_var;
      mono_mb_emit_ldloc (mb, src_var.232);
      mono_mb_emit_stloc (mb, 0);
      dst_var.233 = (unsigned int) dst_var;
      mono_mb_emit_ldloc (mb, dst_var.233);
      mono_mb_emit_stloc (mb, 1);
    }
    <D.25807>:
    goto <D.19217>;
  }
  <D.19228>:
  {
    struct MonoClass * eclass;

    eclass = mono_defaults.char_class;
    mono_mb_emit_ldloc (mb, 1);
    D.25801 = mspec->data.array_data.num_elem;
    mono_mb_emit_icon (mb, D.25801);
    mono_mb_emit_op (mb, 141, eclass);
    mono_mb_emit_byte (mb, 81);
    mono_mb_emit_ldloc (mb, 1);
    mono_mb_emit_byte (mb, 80);
    mono_mb_emit_ldloc (mb, 0);
    D.25801 = mspec->data.array_data.num_elem;
    mono_mb_emit_icon (mb, D.25801);
    mono_mb_emit_icall (mb, mono_byvalarray_to_byte_array);
    goto <D.19217>;
  }
  <D.19230>:
  mono_mb_emit_ldloc (mb, 1);
  mono_mb_emit_ldloc (mb, 0);
  mono_mb_emit_icall (mb, mono_string_new_wrapper);
  mono_mb_emit_byte (mb, 81);
  goto <D.19217>;
  <D.19231>:
  if (mspec != 0B) goto <D.25820>; else goto <D.25818>;
  <D.25820>:
  D.25821 = mspec->native;
  if (D.25821 == 23) goto <D.25822>; else goto <D.25818>;
  <D.25822>:
  D.25801 = mspec->data.array_data.num_elem;
  if (D.25801 != 0) goto <D.25823>; else goto <D.25818>;
  <D.25823>:
  mono_mb_emit_ldloc (mb, 1);
  mono_mb_emit_ldloc (mb, 0);
  D.25801 = mspec->data.array_data.num_elem;
  mono_mb_emit_icon (mb, D.25801);
  mono_mb_emit_icall (mb, mono_string_from_byvalwstr);
  goto <D.25819>;
  <D.25818>:
  mono_mb_emit_ldloc (mb, 1);
  mono_mb_emit_ldloc (mb, 0);
  mono_mb_emit_icall (mb, mono_string_from_utf16);
  <D.25819>:
  mono_mb_emit_byte (mb, 81);
  goto <D.19217>;
  <D.19232>:
  mono_mb_emit_ldloc (mb, 1);
  mono_mb_emit_ldloc (mb, 0);
  mono_mb_emit_byte (mb, 77);
  mono_mb_emit_icall (mb, mono_string_new_wrapper);
  mono_mb_emit_byte (mb, 81);
  goto <D.19217>;
  <D.19233>:
  mono_mb_emit_ldloc (mb, 1);
  mono_mb_emit_ldloc (mb, 0);
  mono_mb_emit_byte (mb, 77);
  mono_mb_emit_icall (mb, mono_string_new_wrapper);
  mono_mb_emit_byte (mb, 81);
  goto <D.19217>;
  <D.19234>:
  mono_mb_emit_ldloc (mb, 1);
  mono_mb_emit_ldloc (mb, 0);
  mono_mb_emit_byte (mb, 77);
  mono_mb_emit_icall (mb, mono_string_from_utf16);
  mono_mb_emit_byte (mb, 81);
  goto <D.19217>;
  <D.19235>:
  {
    struct MonoClass * klass;
    int src_var;
    int dst_var;

    klass = mono_class_from_mono_type (type);
    D.25810 = mono_defaults.int_class;
    D.25811 = &D.25810->byval_arg;
    src_var = mono_mb_add_local (mb, D.25811);
    D.25810 = mono_defaults.int_class;
    D.25811 = &D.25810->byval_arg;
    dst_var = mono_mb_add_local (mb, D.25811);
    mono_mb_emit_ldloc (mb, 1);
    mono_mb_emit_byte (mb, 240);
    mono_mb_emit_op (mb, 4, klass);
    mono_mb_emit_byte (mb, 81);
    mono_mb_emit_ldloc (mb, 0);
    src_var.235 = (unsigned int) src_var;
    mono_mb_emit_stloc (mb, src_var.235);
    mono_mb_emit_ldloc (mb, 1);
    dst_var.236 = (unsigned int) dst_var;
    mono_mb_emit_stloc (mb, dst_var.236);
    mono_mb_emit_ldloc (mb, 1);
    mono_mb_emit_byte (mb, 77);
    mono_mb_emit_icon (mb, 16);
    mono_mb_emit_byte (mb, 88);
    mono_mb_emit_stloc (mb, 1);
    emit_struct_conv (mb, klass, 1);
    src_var.235 = (unsigned int) src_var;
    mono_mb_emit_ldloc (mb, src_var.235);
    mono_mb_emit_stloc (mb, 0);
    dst_var.236 = (unsigned int) dst_var;
    mono_mb_emit_ldloc (mb, dst_var.236);
    mono_mb_emit_stloc (mb, 1);
    goto <D.19217>;
  }
  <D.19239>:
  {
    struct MonoClass * klass;

    klass = mono_class_from_mono_type (type);
    mono_mb_emit_ldloc (mb, 1);
    mono_mb_emit_byte (mb, 240);
    mono_mb_emit_op (mb, 11, klass);
    mono_mb_emit_ldloc (mb, 0);
    mono_mb_emit_byte (mb, 77);
    mono_mb_emit_icall (mb, mono_ftnptr_to_delegate);
    mono_mb_emit_byte (mb, 81);
    goto <D.19217>;
  }
  <D.19241>:
  D.25826 = mono_class_from_mono_type (type);
  D.25827 = D.25826->name;
  monoeg_g_log (0B, 4, "Structure field of type %s can\'t be marshalled as LPArray", D.25827);
  <D.19242>:
  goto <D.19242>;
  <D.19243>:
  <D.19244>:
  <D.19245>:
  mono_cominterop_emit_ptr_to_object_conv (mb, type, conv, mspec);
  goto <D.19217>;
  <D.19246>:
  goto <D.19217>;
  <D.19247>:
  goto <D.19217>;
  <D.19248>:
  <D.19249>:
  <D.19250>:
  <D.19251>:
  <D.19252>:
  {
    char * msg;

    msg = monoeg_g_strdup_printf ("marshaling conversion %d not implemented", conv);
    mono_mb_emit_exception_marshal_directive (mb, msg);
    goto <D.19217>;
  }
  <D.19217>:
}


emit_object_to_ptr_conv (struct MonoMethodBuilder * mb, struct MonoType * type, MonoMarshalConv conv, struct MonoMarshalSpec * mspec)
{
  unsigned int D.25829;
  unsigned int pos.237;
  void * D.25831;
  void * D.25832;
  _Bool D.25833;
  long int D.25834;
  long int D.25835;
  int D.25838;
  void * D.25839;
  unsigned char D.25840;
  long unsigned int D.25844;
  long unsigned int D.25845;
  unsigned int D.25849;
  long unsigned int D.25850;
  int D.25853;
  struct MonoClass * D.25855;
  struct MonoType * D.25856;
  struct MonoClass * D.25857;
  struct MonoType * D.25858;
  unsigned int array_var.238;
  unsigned int src_var.239;
  unsigned int dst_var.240;
  unsigned int index_var.241;
  int D.25863;
  short unsigned int D.25864;
  unsigned int pos.242;
  unsigned int D.25866;
  unsigned int D.25867;
  unsigned int src_var.243;
  unsigned int dst_var.244;
  struct MonoClass * D.25870;
  struct MonoClass * D.25871;
  struct MonoType * D.25872;
  unsigned int D.25873;
  unsigned int pos.245;
  int pos;

  switch (conv) <default: <D.19324>, case 1: <D.19291>, case 2: <D.19289>, case 3: <D.19295>, case 4: <D.19293>, case 7: <D.19292>, case 9: <D.19294>, case 10: <D.19296>, case 11: <D.19297>, case 12: <D.19302>, case 13: <D.19303>, case 20: <D.19304>, case 21: <D.19313>, case 22: <D.19299>, case 23: <D.19300>, case 25: <D.19317>, case 26: <D.19318>, case 27: <D.19319>, case 28: <D.19314>, case 29: <D.19301>, case 33: <D.19320>, case 34: <D.19323>>
  <D.19289>:
  mono_mb_emit_ldloc (mb, 1);
  mono_mb_emit_ldloc (mb, 0);
  mono_mb_emit_byte (mb, 71);
  mono_mb_emit_byte (mb, 84);
  goto <D.19290>;
  <D.19291>:
  mono_mb_emit_ldloc (mb, 1);
  mono_mb_emit_ldloc (mb, 0);
  mono_mb_emit_byte (mb, 71);
  mono_mb_emit_byte (mb, 101);
  mono_mb_emit_byte (mb, 83);
  goto <D.19290>;
  <D.19292>:
  <D.19293>:
  <D.19294>:
  <D.19295>:
  <D.19296>:
  <D.19297>:
  {
    int pos;

    mono_mb_emit_ldloc (mb, 2);
    D.25829 = mono_mb_emit_short_branch (mb, 44);
    pos = (int) D.25829;
    mono_mb_emit_ldloc (mb, 1);
    mono_mb_emit_byte (mb, 77);
    mono_mb_emit_icall (mb, monoeg_g_free);
    pos.237 = (unsigned int) pos;
    mono_mb_patch_short_branch (mb, pos.237);
    mono_mb_emit_ldloc (mb, 1);
    mono_mb_emit_ldloc (mb, 0);
    mono_mb_emit_byte (mb, 80);
    D.25831 = conv_to_icall (conv);
    mono_mb_emit_icall (mb, D.25831);
    mono_mb_emit_byte (mb, 223);
    goto <D.19290>;
  }
  <D.19299>:
  <D.19300>:
  <D.19301>:
  mono_mb_emit_ldloc (mb, 1);
  mono_mb_emit_ldloc (mb, 0);
  mono_mb_emit_byte (mb, 80);
  D.25832 = conv_to_icall (conv);
  mono_mb_emit_icall (mb, D.25832);
  mono_mb_emit_byte (mb, 223);
  goto <D.19290>;
  <D.19302>:
  <D.19303>:
  D.25833 = mspec == 0B;
  D.25834 = (long int) D.25833;
  D.25835 = __builtin_expect (D.25834, 0);
  if (D.25835 != 0) goto <D.25836>; else goto <D.25837>;
  <D.25836>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 1641, "mspec");
  <D.25837>:
  mono_mb_emit_ldloc (mb, 1);
  mono_mb_emit_ldloc (mb, 0);
  mono_mb_emit_byte (mb, 80);
  D.25838 = mspec->data.array_data.num_elem;
  mono_mb_emit_icon (mb, D.25838);
  D.25839 = conv_to_icall (conv);
  mono_mb_emit_icall (mb, D.25839);
  goto <D.19290>;
  <D.19304>:
  {
    struct MonoClass * eklass;
    int esize;

    eklass = 0B;
    D.25840 = type->type;
    if (D.25840 == 29) goto <D.25841>; else goto <D.25842>;
    <D.25841>:
    eklass = type->data.klass;
    goto <D.25843>;
    <D.25842>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "marshal.c", 1657);
    <D.25843>:
    D.25844 = BIT_FIELD_REF <*eklass, 64, 256>;
    D.25845 = D.25844 & 1152921504606846976;
    if (D.25845 != 0) goto <D.25846>; else goto <D.25847>;
    <D.25846>:
    esize = mono_class_native_size (eklass, 0B);
    goto <D.25848>;
    <D.25847>:
    esize = 8;
    <D.25848>:
    mono_mb_emit_ldloc (mb, 0);
    mono_mb_emit_byte (mb, 80);
    D.25849 = mono_mb_emit_branch (mb, 57);
    pos = (int) D.25849;
    D.25844 = BIT_FIELD_REF <*eklass, 64, 256>;
    D.25850 = D.25844 & 288230376151711744;
    if (D.25850 != 0) goto <D.25851>; else goto <D.25852>;
    <D.25851>:
    mono_mb_emit_ldloc (mb, 1);
    mono_mb_emit_ldloc (mb, 0);
    mono_mb_emit_byte (mb, 80);
    mono_mb_emit_ldflda (mb, 32);
    D.25838 = mspec->data.array_data.num_elem;
    D.25853 = D.25838 * esize;
    mono_mb_emit_icon (mb, D.25853);
    mono_mb_emit_byte (mb, 254);
    mono_mb_emit_byte (mb, 23);
    goto <D.25854>;
    <D.25852>:
    {
      int array_var;
      int src_var;
      int dst_var;
      int index_var;
      guint32 label2;
      guint32 label3;

      D.25855 = mono_defaults.object_class;
      D.25856 = &D.25855->byval_arg;
      array_var = mono_mb_add_local (mb, D.25856);
      D.25857 = mono_defaults.int_class;
      D.25858 = &D.25857->byval_arg;
      src_var = mono_mb_add_local (mb, D.25858);
      D.25857 = mono_defaults.int_class;
      D.25858 = &D.25857->byval_arg;
      dst_var = mono_mb_add_local (mb, D.25858);
      mono_mb_emit_ldloc (mb, 0);
      mono_mb_emit_byte (mb, 80);
      array_var.238 = (unsigned int) array_var;
      mono_mb_emit_stloc (mb, array_var.238);
      mono_mb_emit_ldloc (mb, 0);
      src_var.239 = (unsigned int) src_var;
      mono_mb_emit_stloc (mb, src_var.239);
      mono_mb_emit_ldloc (mb, 1);
      dst_var.240 = (unsigned int) dst_var;
      mono_mb_emit_stloc (mb, dst_var.240);
      D.25857 = mono_defaults.int_class;
      D.25858 = &D.25857->byval_arg;
      index_var = mono_mb_add_local (mb, D.25858);
      mono_mb_emit_byte (mb, 22);
      index_var.241 = (unsigned int) index_var;
      mono_mb_emit_stloc (mb, index_var.241);
      D.25863 = mono_mb_get_label (mb);
      label2 = (guint32) D.25863;
      index_var.241 = (unsigned int) index_var;
      mono_mb_emit_ldloc (mb, index_var.241);
      array_var.238 = (unsigned int) array_var;
      mono_mb_emit_ldloc (mb, array_var.238);
      mono_mb_emit_byte (mb, 142);
      label3 = mono_mb_emit_branch (mb, 60);
      array_var.238 = (unsigned int) array_var;
      mono_mb_emit_ldloc (mb, array_var.238);
      index_var.241 = (unsigned int) index_var;
      mono_mb_emit_ldloc (mb, index_var.241);
      mono_mb_emit_op (mb, 143, eklass);
      mono_mb_emit_stloc (mb, 0);
      emit_struct_conv (mb, eklass, 0);
      D.25864 = (short unsigned int) index_var;
      mono_mb_emit_add_to_local (mb, D.25864, 1);
      mono_mb_emit_branch_label (mb, 56, label2);
      mono_mb_patch_branch (mb, label3);
      src_var.239 = (unsigned int) src_var;
      mono_mb_emit_ldloc (mb, src_var.239);
      mono_mb_emit_stloc (mb, 0);
      dst_var.240 = (unsigned int) dst_var;
      mono_mb_emit_ldloc (mb, dst_var.240);
      mono_mb_emit_stloc (mb, 1);
    }
    <D.25854>:
    pos.242 = (unsigned int) pos;
    mono_mb_patch_branch (mb, pos.242);
    goto <D.19290>;
  }
  <D.19313>:
  mono_mb_emit_ldloc (mb, 0);
  mono_mb_emit_byte (mb, 80);
  D.25866 = mono_mb_emit_short_branch (mb, 44);
  pos = (int) D.25866;
  mono_mb_emit_ldloc (mb, 1);
  mono_mb_emit_ldloc (mb, 0);
  mono_mb_emit_byte (mb, 80);
  D.25838 = mspec->data.array_data.num_elem;
  mono_mb_emit_icon (mb, D.25838);
  mono_mb_emit_icall (mb, mono_array_to_byte_byvalarray);
  pos.242 = (unsigned int) pos;
  mono_mb_patch_short_branch (mb, pos.242);
  goto <D.19290>;
  <D.19314>:
  {
    int src_var;
    int dst_var;

    D.25857 = mono_defaults.int_class;
    D.25858 = &D.25857->byval_arg;
    src_var = mono_mb_add_local (mb, D.25858);
    D.25857 = mono_defaults.int_class;
    D.25858 = &D.25857->byval_arg;
    dst_var = mono_mb_add_local (mb, D.25858);
    mono_mb_emit_ldloc (mb, 0);
    mono_mb_emit_byte (mb, 77);
    D.25867 = mono_mb_emit_branch (mb, 57);
    pos = (int) D.25867;
    mono_mb_emit_ldloc (mb, 0);
    src_var.243 = (unsigned int) src_var;
    mono_mb_emit_stloc (mb, src_var.243);
    mono_mb_emit_ldloc (mb, 1);
    dst_var.244 = (unsigned int) dst_var;
    mono_mb_emit_stloc (mb, dst_var.244);
    mono_mb_emit_ldloc (mb, 0);
    mono_mb_emit_byte (mb, 77);
    mono_mb_emit_icon (mb, 16);
    mono_mb_emit_byte (mb, 88);
    mono_mb_emit_stloc (mb, 0);
    D.25870 = mono_class_from_mono_type (type);
    emit_struct_conv (mb, D.25870, 0);
    src_var.243 = (unsigned int) src_var;
    mono_mb_emit_ldloc (mb, src_var.243);
    mono_mb_emit_stloc (mb, 0);
    dst_var.244 = (unsigned int) dst_var;
    mono_mb_emit_ldloc (mb, dst_var.244);
    mono_mb_emit_stloc (mb, 1);
    pos.242 = (unsigned int) pos;
    mono_mb_patch_branch (mb, pos.242);
    goto <D.19290>;
  }
  <D.19317>:
  <D.19318>:
  <D.19319>:
  mono_cominterop_emit_object_to_ptr_conv (mb, type, conv, mspec);
  goto <D.19290>;
  <D.19320>:
  {
    int dar_release_slot;
    int pos;

    D.25871 = mono_defaults.boolean_class;
    D.25872 = &D.25871->byval_arg;
    dar_release_slot = mono_mb_add_local (mb, D.25872);
    mono_mb_emit_ldloc (mb, 0);
    mono_mb_emit_byte (mb, 77);
    D.25873 = mono_mb_emit_branch (mb, 58);
    pos = (int) D.25873;
    mono_mb_emit_exception (mb, "ArgumentNullException", 0B);
    pos.245 = (unsigned int) pos;
    mono_mb_patch_branch (mb, pos.245);
    mono_mb_emit_ldloc (mb, 1);
    mono_mb_emit_ldloc (mb, 0);
    mono_mb_emit_byte (mb, 77);
    mono_mb_emit_ldflda (mb, 16);
    mono_mb_emit_byte (mb, 77);
    mono_mb_emit_byte (mb, 223);
    goto <D.19290>;
  }
  <D.19323>:
  mono_mb_emit_ldloc (mb, 1);
  mono_mb_emit_ldloc (mb, 0);
  mono_mb_emit_icon (mb, 8);
  mono_mb_emit_byte (mb, 88);
  mono_mb_emit_byte (mb, 77);
  mono_mb_emit_byte (mb, 223);
  goto <D.19290>;
  <D.19324>:
  {
    char * msg;
    struct MonoException * exc;

    msg = monoeg_g_strdup_printf ("marshalling conversion %d not implemented", conv);
    exc = mono_get_exception_not_implemented (msg);
    monoeg_g_log (0B, 16, "%s", msg);
    monoeg_g_free (msg);
    mono_raise_exception (exc);
  }
  <D.19290>:
}


emit_struct_free (struct MonoMethodBuilder * mb, struct MonoClass * klass, int struct_var)
{
  unsigned int struct_var.246;

  mono_mb_emit_byte (mb, 240);
  mono_mb_emit_op (mb, 11, klass);
  struct_var.246 = (unsigned int) struct_var;
  mono_mb_emit_ldloc (mb, struct_var.246);
  mono_mb_emit_icall (mb, mono_struct_delete_old);
}


mono_marshal_get_ptr_to_stringbuilder_conv (struct MonoMethodPInvoke * piinfo, struct MonoMarshalSpec * spec, gboolean * need_free)
{
  MonoMarshalConv D.25876;
  MonoMarshalNative encoding;

  encoding = mono_marshal_get_string_encoding (piinfo, spec);
  *need_free = 1;
  switch (encoding) <default: <D.19487>, case 20: <D.19485>, case 21: <D.19484>, case 22: <D.19486>>
  <D.19484>:
  *need_free = 0;
  D.25876 = 19;
  return D.25876;
  <D.19485>:
  D.25876 = 17;
  return D.25876;
  <D.19486>:
  D.25876 = 18;
  return D.25876;
  <D.19487>:
  D.25876 = 4294967295;
  return D.25876;
}


mono_marshal_get_stringbuilder_to_ptr_conv (struct MonoMethodPInvoke * piinfo, struct MonoMarshalSpec * spec)
{
  MonoMarshalConv D.25878;
  MonoMarshalNative encoding;

  encoding = mono_marshal_get_string_encoding (piinfo, spec);
  switch (encoding) <default: <D.19465>, case 20: <D.19463>, case 21: <D.19462>, case 22: <D.19464>>
  <D.19462>:
  D.25878 = 16;
  return D.25878;
  <D.19463>:
  D.25878 = 14;
  return D.25878;
  <D.19464>:
  D.25878 = 15;
  return D.25878;
  <D.19465>:
  D.25878 = 4294967295;
  return D.25878;
}


mono_pinvoke_is_unicode (struct MonoMethodPInvoke * piinfo)
{
  short unsigned int D.25880;
  int D.25881;
  int D.25882;
  gboolean D.25883;

  D.25880 = piinfo->piflags;
  D.25881 = (int) D.25880;
  D.25882 = D.25881 & 6;
  switch (D.25882) <default: <D.20622>, case 2: <D.20619>, case 4: <D.20620>, case 6: <D.20621>>
  <D.20619>:
  D.25883 = 0;
  return D.25883;
  <D.20620>:
  D.25883 = 1;
  return D.25883;
  <D.20621>:
  <D.20622>:
  D.25883 = 0;
  return D.25883;
}


emit_marshal_boolean (struct EmitMarshalContext * m, int argnum, struct MonoType * t, struct MonoMarshalSpec * spec, int conv_arg, struct MonoType * * conv_arg_type, MarshalAction action)
{
  long unsigned int D.25885;
  long unsigned int D.25886;
  struct MonoClass * D.25889;
  struct MonoType * D.25890;
  unsigned int argnum.247;
  unsigned int D.25895;
  unsigned char ldc_op.248;
  unsigned int conv_arg.249;
  unsigned int label_false.250;
  unsigned int D.25900;
  unsigned int D.25901;
  unsigned int label_false.251;
  unsigned int label_end.252;
  struct MonoClass * D.25910;
  struct MonoType * D.25911;
  struct MonoType * D.25914;
  struct MonoType * D.25916;
  unsigned int D.25919;
  unsigned char ldop.253;
  unsigned int D.25922;
  unsigned int label_false.254;
  unsigned int label_null.255;
  <unnamed type> D.25930;
  unsigned int D.25931;
  unsigned int D.25932;
  unsigned int D.25933;
  unsigned int label_false.256;
  unsigned int label_end.257;
  unsigned int label_null.258;
  int D.25937;
  struct MonoMethodBuilder * mb;

  mb = m->mb;
  switch (action) <default: <D.20778>, case 0: <D.20752>, case 1: <D.20760>, case 2: <D.20757>, case 3: <D.20761>, case 4: <D.20762>, case 5: <D.20767>>
  <D.20752>:
  {
    struct MonoType * local_type;
    int label_false;
    guint8 ldc_op;

    try
      {
        ldc_op = 23;
        local_type = marshal_boolean_conv_in_get_local_type (spec, &ldc_op);
        D.25885 = BIT_FIELD_REF <*t, 64, 64>;
        D.25886 = D.25885 & 8589934592;
        if (D.25886 != 0) goto <D.25887>; else goto <D.25888>;
        <D.25887>:
        D.25889 = mono_defaults.int_class;
        D.25890 = &D.25889->byval_arg;
        *conv_arg_type = D.25890;
        goto <D.25891>;
        <D.25888>:
        *conv_arg_type = local_type;
        <D.25891>:
        conv_arg = mono_mb_add_local (mb, local_type);
        argnum.247 = (unsigned int) argnum;
        mono_mb_emit_ldarg (mb, argnum.247);
        D.25885 = BIT_FIELD_REF <*t, 64, 64>;
        D.25886 = D.25885 & 8589934592;
        if (D.25886 != 0) goto <D.25893>; else goto <D.25894>;
        <D.25893>:
        mono_mb_emit_byte (mb, 70);
        <D.25894>:
        D.25895 = mono_mb_emit_branch (mb, 57);
        label_false = (int) D.25895;
        ldc_op.248 = ldc_op;
        mono_mb_emit_byte (mb, ldc_op.248);
        conv_arg.249 = (unsigned int) conv_arg;
        mono_mb_emit_stloc (mb, conv_arg.249);
        label_false.250 = (unsigned int) label_false;
        mono_mb_patch_branch (mb, label_false.250);
        goto <D.20756>;
      }
    finally
      {
        ldc_op = {CLOBBER};
      }
  }
  <D.20757>:
  {
    int label_false;
    int label_end;

    D.25885 = BIT_FIELD_REF <*t, 64, 64>;
    D.25886 = D.25885 & 8589934592;
    if (D.25886 == 0) goto <D.20756>; else goto <D.25899>;
    <D.25899>:
    argnum.247 = (unsigned int) argnum;
    mono_mb_emit_ldarg (mb, argnum.247);
    conv_arg.249 = (unsigned int) conv_arg;
    mono_mb_emit_ldloc (mb, conv_arg.249);
    D.25900 = mono_mb_emit_branch (mb, 57);
    label_false = (int) D.25900;
    mono_mb_emit_byte (mb, 23);
    D.25901 = mono_mb_emit_branch (mb, 56);
    label_end = (int) D.25901;
    label_false.251 = (unsigned int) label_false;
    mono_mb_patch_branch (mb, label_false.251);
    mono_mb_emit_byte (mb, 22);
    label_end.252 = (unsigned int) label_end;
    mono_mb_patch_branch (mb, label_end.252);
    mono_mb_emit_byte (mb, 82);
    goto <D.20756>;
  }
  <D.20760>:
  D.25885 = BIT_FIELD_REF <*t, 64, 64>;
  D.25886 = D.25885 & 8589934592;
  if (D.25886 != 0) goto <D.25904>; else goto <D.25905>;
  <D.25904>:
  conv_arg.249 = (unsigned int) conv_arg;
  mono_mb_emit_ldloc_addr (mb, conv_arg.249);
  goto <D.25906>;
  <D.25905>:
  if (conv_arg != 0) goto <D.25907>; else goto <D.25908>;
  <D.25907>:
  conv_arg.249 = (unsigned int) conv_arg;
  mono_mb_emit_ldloc (mb, conv_arg.249);
  goto <D.25909>;
  <D.25908>:
  argnum.247 = (unsigned int) argnum;
  mono_mb_emit_ldarg (mb, argnum.247);
  <D.25909>:
  <D.25906>:
  goto <D.20756>;
  <D.20761>:
  mono_mb_emit_stloc (mb, 3);
  goto <D.20756>;
  <D.20762>:
  {
    struct MonoClass * conv_arg_class;
    guint8 ldop;
    int label_null;
    int label_false;

    try
      {
        conv_arg_class = mono_defaults.int32_class;
        ldop = 74;
        conv_arg_class = marshal_boolean_managed_conv_in_get_conv_arg_class (spec, &ldop);
        D.25910 = mono_defaults.boolean_class;
        D.25911 = &D.25910->byval_arg;
        conv_arg = mono_mb_add_local (mb, D.25911);
        D.25885 = BIT_FIELD_REF <*t, 64, 64>;
        D.25886 = D.25885 & 8589934592;
        if (D.25886 != 0) goto <D.25912>; else goto <D.25913>;
        <D.25912>:
        D.25914 = &conv_arg_class->this_arg;
        *conv_arg_type = D.25914;
        goto <D.25915>;
        <D.25913>:
        D.25916 = &conv_arg_class->byval_arg;
        *conv_arg_type = D.25916;
        <D.25915>:
        argnum.247 = (unsigned int) argnum;
        mono_mb_emit_ldarg (mb, argnum.247);
        D.25885 = BIT_FIELD_REF <*t, 64, 64>;
        D.25886 = D.25885 & 8589934592;
        if (D.25886 != 0) goto <D.25917>; else goto <D.25918>;
        <D.25917>:
        D.25919 = mono_mb_emit_branch (mb, 57);
        label_null = (int) D.25919;
        argnum.247 = (unsigned int) argnum;
        mono_mb_emit_ldarg (mb, argnum.247);
        ldop.253 = ldop;
        mono_mb_emit_byte (mb, ldop.253);
        goto <D.25921>;
        <D.25918>:
        label_null = 0;
        <D.25921>:
        D.25922 = mono_mb_emit_branch (mb, 57);
        label_false = (int) D.25922;
        mono_mb_emit_byte (mb, 23);
        conv_arg.249 = (unsigned int) conv_arg;
        mono_mb_emit_stloc (mb, conv_arg.249);
        label_false.254 = (unsigned int) label_false;
        mono_mb_patch_branch (mb, label_false.254);
        D.25885 = BIT_FIELD_REF <*t, 64, 64>;
        D.25886 = D.25885 & 8589934592;
        if (D.25886 != 0) goto <D.25924>; else goto <D.25925>;
        <D.25924>:
        label_null.255 = (unsigned int) label_null;
        mono_mb_patch_branch (mb, label_null.255);
        <D.25925>:
        goto <D.20756>;
      }
    finally
      {
        ldop = {CLOBBER};
      }
  }
  <D.20767>:
  {
    guint8 stop;
    guint8 ldc_op;
    int label_null;
    int label_false;
    int label_end;

    stop = 84;
    ldc_op = 23;
    D.25885 = BIT_FIELD_REF <*t, 64, 64>;
    D.25886 = D.25885 & 8589934592;
    if (D.25886 == 0) goto <D.20756>; else goto <D.25927>;
    <D.25927>:
    if (spec != 0B) goto <D.25928>; else goto <D.25929>;
    <D.25928>:
    D.25930 = spec->native;
    switch (D.25930) <default: <D.20777>, case 3: <D.20773>, case 4: <D.20774>, case 37: <D.20776>>
    <D.20773>:
    <D.20774>:
    stop = 82;
    goto <D.20775>;
    <D.20776>:
    stop = 83;
    ldc_op = 21;
    goto <D.20775>;
    <D.20777>:
    goto <D.20775>;
    <D.20775>:
    <D.25929>:
    argnum.247 = (unsigned int) argnum;
    mono_mb_emit_ldarg (mb, argnum.247);
    D.25931 = mono_mb_emit_branch (mb, 57);
    label_null = (int) D.25931;
    argnum.247 = (unsigned int) argnum;
    mono_mb_emit_ldarg (mb, argnum.247);
    conv_arg.249 = (unsigned int) conv_arg;
    mono_mb_emit_ldloc (mb, conv_arg.249);
    D.25932 = mono_mb_emit_branch (mb, 57);
    label_false = (int) D.25932;
    mono_mb_emit_byte (mb, ldc_op);
    D.25933 = mono_mb_emit_branch (mb, 56);
    label_end = (int) D.25933;
    label_false.256 = (unsigned int) label_false;
    mono_mb_patch_branch (mb, label_false.256);
    mono_mb_emit_byte (mb, 22);
    label_end.257 = (unsigned int) label_end;
    mono_mb_patch_branch (mb, label_end.257);
    mono_mb_emit_byte (mb, stop);
    label_null.258 = (unsigned int) label_null;
    mono_mb_patch_branch (mb, label_null.258);
    goto <D.20756>;
  }
  <D.20778>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "marshal.c", 8436);
  <D.20756>:
  D.25937 = conv_arg;
  return D.25937;
}


marshal_boolean_conv_in_get_local_type (struct MonoMarshalSpec * spec, guint8 * ldc_op)
{
  struct MonoType * D.25944;
  struct MonoClass * D.25945;
  <unnamed type> D.25946;
  struct MonoClass * D.25947;
  struct MonoClass * D.25950;

  if (spec == 0B) goto <D.25942>; else goto <D.25943>;
  <D.25942>:
  D.25945 = mono_defaults.int32_class;
  D.25944 = &D.25945->byval_arg;
  return D.25944;
  <D.25943>:
  D.25946 = spec->native;
  switch (D.25946) <default: <D.20730>, case 2: <D.20729>, case 3: <D.20726>, case 4: <D.20727>, case 37: <D.20728>>
  <D.20726>:
  <D.20727>:
  D.25947 = mono_defaults.byte_class;
  D.25944 = &D.25947->byval_arg;
  return D.25944;
  <D.20728>:
  if (ldc_op != 0B) goto <D.25948>; else goto <D.25949>;
  <D.25948>:
  *ldc_op = 21;
  <D.25949>:
  D.25950 = mono_defaults.int16_class;
  D.25944 = &D.25950->byval_arg;
  return D.25944;
  <D.20729>:
  D.25945 = mono_defaults.int32_class;
  D.25944 = &D.25945->byval_arg;
  return D.25944;
  <D.20730>:
  D.25946 = spec->native;
  monoeg_g_log (0B, 16, "marshalling bool as native type %x is currently not supported", D.25946);
  D.25945 = mono_defaults.int32_class;
  D.25944 = &D.25945->byval_arg;
  return D.25944;
}


marshal_boolean_managed_conv_in_get_conv_arg_class (struct MonoMarshalSpec * spec, guint8 * ldop)
{
  <unnamed type> D.25954;
  struct MonoClass * D.25959;
  struct MonoClass * conv_arg_class;

  conv_arg_class = mono_defaults.int32_class;
  if (spec != 0B) goto <D.25952>; else goto <D.25953>;
  <D.25952>:
  D.25954 = spec->native;
  switch (D.25954) <default: <D.20741>, case 2: <D.20740>, case 3: <D.20736>, case 4: <D.20737>, case 37: <D.20739>>
  <D.20736>:
  <D.20737>:
  conv_arg_class = mono_defaults.byte_class;
  if (ldop != 0B) goto <D.25955>; else goto <D.25956>;
  <D.25955>:
  *ldop = 70;
  <D.25956>:
  goto <D.20738>;
  <D.20739>:
  conv_arg_class = mono_defaults.int16_class;
  if (ldop != 0B) goto <D.25957>; else goto <D.25958>;
  <D.25957>:
  *ldop = 72;
  <D.25958>:
  goto <D.20738>;
  <D.20740>:
  goto <D.20738>;
  <D.20741>:
  D.25954 = spec->native;
  monoeg_g_log (0B, 16, "marshalling bool as native type %x is currently not supported", D.25954);
  <D.20738>:
  <D.25953>:
  D.25959 = conv_arg_class;
  return D.25959;
}


emit_marshal_ptr (struct EmitMarshalContext * m, int argnum, struct MonoType * t, struct MonoMarshalSpec * spec, int conv_arg, struct MonoType * * conv_arg_type, MarshalAction action)
{
  unsigned int argnum.259;
  int D.25963;
  struct MonoMethodBuilder * mb;

  mb = m->mb;
  switch (action) <default: <D.20793>, case 0: <D.20789>, case 1: <D.20791>, case 3: <D.20792>>
  <D.20789>:
  goto <D.20790>;
  <D.20791>:
  argnum.259 = (unsigned int) argnum;
  mono_mb_emit_ldarg (mb, argnum.259);
  goto <D.20790>;
  <D.20792>:
  mono_mb_emit_stloc (mb, 3);
  goto <D.20790>;
  <D.20793>:
  goto <D.20790>;
  <D.20790>:
  D.25963 = conv_arg;
  return D.25963;
}


emit_marshal_char (struct EmitMarshalContext * m, int argnum, struct MonoType * t, struct MonoMarshalSpec * spec, int conv_arg, struct MonoType * * conv_arg_type, MarshalAction action)
{
  unsigned int argnum.260;
  int D.25967;
  struct MonoMethodBuilder * mb;

  mb = m->mb;
  switch (action) <default: <D.20807>, case 1: <D.20804>, case 3: <D.20806>>
  <D.20804>:
  argnum.260 = (unsigned int) argnum;
  mono_mb_emit_ldarg (mb, argnum.260);
  goto <D.20805>;
  <D.20806>:
  mono_mb_emit_stloc (mb, 3);
  goto <D.20805>;
  <D.20807>:
  goto <D.20805>;
  <D.20805>:
  D.25967 = conv_arg;
  return D.25967;
}


emit_marshal_scalar (struct EmitMarshalContext * m, int argnum, struct MonoType * t, struct MonoMarshalSpec * spec, int conv_arg, struct MonoType * * conv_arg_type, MarshalAction action)
{
  unsigned int argnum.261;
  int D.25971;
  struct MonoMethodBuilder * mb;

  mb = m->mb;
  switch (action) <default: <D.20821>, case 1: <D.20818>, case 3: <D.20820>>
  <D.20818>:
  argnum.261 = (unsigned int) argnum;
  mono_mb_emit_ldarg (mb, argnum.261);
  goto <D.20819>;
  <D.20820>:
  mono_mb_emit_stloc (mb, 3);
  goto <D.20819>;
  <D.20821>:
  goto <D.20819>;
  <D.20819>:
  D.25971 = conv_arg;
  return D.25971;
}


emit_marshal_vtype (struct EmitMarshalContext * m, int argnum, struct MonoType * t, struct MonoMarshalSpec * spec, int conv_arg, struct MonoType * * conv_arg_type, MarshalAction action)
{
  struct MonoClass * date_time_class.264;
  struct MonoClass * tmp_klass.262;
  struct MonoImage * D.25979;
  struct MonoClass * tmp_klass.263;
  _Bool D.25981;
  long int D.25982;
  long int D.25983;
  struct MonoMethod * to_oadate.265;
  struct MonoMethod * to_oadate.266;
  _Bool D.25992;
  long int D.25993;
  long int D.25994;
  struct MonoClass * D.25997;
  struct MonoType * D.25998;
  long unsigned int D.25999;
  long unsigned int D.26000;
  unsigned int argnum.267;
  unsigned int D.26004;
  short unsigned int D.26008;
  unsigned int D.26009;
  unsigned int D.26010;
  struct MonoMethodSignature * D.26013;
  <unnamed-unsigned:1> D.26014;
  int D.26015;
  int D.26016;
  unsigned int conv_arg.268;
  unsigned int pos.269;
  unsigned int D.26021;
  unsigned int D.26022;
  long unsigned int D.26024;
  long unsigned int D.26025;
  struct MonoClass * D.26027;
  struct MonoType * D.26028;
  int D.26032;
  unsigned int D.26035;
  <unnamed type> D.26043;
  _Bool D.26046;
  long int D.26047;
  long int D.26048;
  struct MonoMethod * from_oadate.270;
  struct MonoMethod * from_oadate.271;
  _Bool D.26074;
  long int D.26075;
  long int D.26076;
  unsigned int D.26083;
  long unsigned int D.26091;
  struct MonoType * D.26095;
  int D.26096;
  int D.26097;
  unsigned int D.26104;
  unsigned int D.26112;
  unsigned int pos2.272;
  int D.26117;
  int D.26118;
  _Bool D.26119;
  long int D.26120;
  long int D.26121;
  int D.26124;
  unsigned int D.26125;
  int D.26126;
  struct MonoMethodBuilder * mb;
  struct MonoClass * klass;
  struct MonoClass * date_time_class;
  int pos;
  int pos2;

  mb = m->mb;
  pos = 0;
  klass = mono_class_from_mono_type (t);
  {
    static struct MonoClass * tmp_klass;

    {
      tmp_klass.262 = tmp_klass;
      if (tmp_klass.262 == 0B) goto <D.25975>; else goto <D.25976>;
      <D.25975>:
      if (0 != 0) goto <D.25977>; else goto <D.25978>;
      <D.25977>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 6226, "mono_defaults.corlib == mono_defaults.corlib");
      <D.25978>:
      D.25979 = mono_defaults.corlib;
      tmp_klass.263 = mono_class_from_name (D.25979, "System", "DateTime");
      tmp_klass = tmp_klass.263;
      tmp_klass.262 = tmp_klass;
      D.25981 = tmp_klass.262 == 0B;
      D.25982 = (long int) D.25981;
      D.25983 = __builtin_expect (D.25982, 0);
      if (D.25983 != 0) goto <D.25984>; else goto <D.25985>;
      <D.25984>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 6226, "tmp_klass");
      <D.25985>:
      <D.25976>:
    }
    date_time_class.264 = tmp_klass;
  }
  date_time_class = date_time_class.264;
  switch (action) <default: <D.20477>, case 0: <D.20467>, case 1: <D.20470>, case 2: <D.20471>, case 3: <D.20473>, case 4: <D.20474>, case 5: <D.20475>, case 6: <D.20476>>
  <D.20467>:
  if (klass == date_time_class) goto <D.25986>; else goto <D.25987>;
  <D.25986>:
  {
    static struct MonoMethod * to_oadate;

    to_oadate.265 = to_oadate;
    if (to_oadate.265 == 0B) goto <D.25989>; else goto <D.25990>;
    <D.25989>:
    to_oadate.266 = mono_class_get_method_from_name (date_time_class, "ToOADate", 0);
    to_oadate = to_oadate.266;
    <D.25990>:
    to_oadate.265 = to_oadate;
    D.25992 = to_oadate.265 == 0B;
    D.25993 = (long int) D.25992;
    D.25994 = __builtin_expect (D.25993, 0);
    if (D.25994 != 0) goto <D.25995>; else goto <D.25996>;
    <D.25995>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 6236, "to_oadate");
    <D.25996>:
    D.25997 = mono_defaults.double_class;
    D.25998 = &D.25997->byval_arg;
    conv_arg = mono_mb_add_local (mb, D.25998);
    D.25999 = BIT_FIELD_REF <*t, 64, 64>;
    D.26000 = D.25999 & 8589934592;
    if (D.26000 != 0) goto <D.26001>; else goto <D.26002>;
    <D.26001>:
    argnum.267 = (unsigned int) argnum;
    mono_mb_emit_ldarg (mb, argnum.267);
    D.26004 = mono_mb_emit_branch (mb, 57);
    pos = (int) D.26004;
    <D.26002>:
    D.25999 = BIT_FIELD_REF <*t, 64, 64>;
    D.26000 = D.25999 & 8589934592;
    if (D.26000 == 0) goto <D.26005>; else goto <D.26007>;
    <D.26007>:
    D.26008 = t->attrs;
    D.26009 = (unsigned int) D.26008;
    D.26010 = D.26009 & 3;
    if (D.26010 != 2) goto <D.26005>; else goto <D.26006>;
    <D.26005>:
    D.25999 = BIT_FIELD_REF <*t, 64, 64>;
    D.26000 = D.25999 & 8589934592;
    if (D.26000 == 0) goto <D.26011>; else goto <D.26012>;
    <D.26011>:
    D.26013 = m->csig;
    D.26013 = m->csig;
    D.26014 = D.26013->hasthis;
    D.26015 = (int) D.26014;
    D.26016 = argnum - D.26015;
    D.25997 = mono_defaults.double_class;
    D.25998 = &D.25997->byval_arg;
    D.26013->params[D.26016] = D.25998;
    <D.26012>:
    argnum.267 = (unsigned int) argnum;
    mono_mb_emit_ldarg_addr (mb, argnum.267);
    to_oadate.265 = to_oadate;
    mono_mb_emit_managed_call (mb, to_oadate.265, 0B);
    conv_arg.268 = (unsigned int) conv_arg;
    mono_mb_emit_stloc (mb, conv_arg.268);
    <D.26006>:
    D.25999 = BIT_FIELD_REF <*t, 64, 64>;
    D.26000 = D.25999 & 8589934592;
    if (D.26000 != 0) goto <D.26018>; else goto <D.26019>;
    <D.26018>:
    pos.269 = (unsigned int) pos;
    mono_mb_patch_branch (mb, pos.269);
    <D.26019>:
    goto <D.20469>;
  }
  <D.25987>:
  D.26021 = klass->flags;
  D.26022 = D.26021 & 24;
  if (D.26022 == 16) goto <D.20469>; else goto <D.26023>;
  <D.26023>:
  D.26024 = BIT_FIELD_REF <*klass, 64, 256>;
  D.26025 = D.26024 & 864691128455135232;
  if (D.26025 != 0) goto <D.20469>; else goto <D.26026>;
  <D.26026>:
  D.26027 = mono_defaults.int_class;
  D.26028 = &D.26027->byval_arg;
  conv_arg = mono_mb_add_local (mb, D.26028);
  D.25999 = BIT_FIELD_REF <*t, 64, 64>;
  D.26000 = D.25999 & 8589934592;
  if (D.26000 != 0) goto <D.26029>; else goto <D.26030>;
  <D.26029>:
  argnum.267 = (unsigned int) argnum;
  mono_mb_emit_ldarg (mb, argnum.267);
  goto <D.26031>;
  <D.26030>:
  argnum.267 = (unsigned int) argnum;
  mono_mb_emit_ldarg_addr (mb, argnum.267);
  <D.26031>:
  mono_mb_emit_stloc (mb, 0);
  D.26032 = mono_class_native_size (klass, 0B);
  mono_mb_emit_icon (mb, D.26032);
  mono_mb_emit_byte (mb, 254);
  mono_mb_emit_byte (mb, 15);
  conv_arg.268 = (unsigned int) conv_arg;
  mono_mb_emit_stloc (mb, conv_arg.268);
  D.25999 = BIT_FIELD_REF <*t, 64, 64>;
  D.26000 = D.25999 & 8589934592;
  if (D.26000 != 0) goto <D.26033>; else goto <D.26034>;
  <D.26033>:
  mono_mb_emit_ldloc (mb, 0);
  D.26035 = mono_mb_emit_branch (mb, 57);
  pos = (int) D.26035;
  <D.26034>:
  D.25999 = BIT_FIELD_REF <*t, 64, 64>;
  D.26000 = D.25999 & 8589934592;
  if (D.26000 == 0) goto <D.26036>; else goto <D.26038>;
  <D.26038>:
  D.26008 = t->attrs;
  D.26009 = (unsigned int) D.26008;
  D.26010 = D.26009 & 3;
  if (D.26010 != 2) goto <D.26036>; else goto <D.26037>;
  <D.26036>:
  conv_arg.268 = (unsigned int) conv_arg;
  mono_mb_emit_ldloc (mb, conv_arg.268);
  mono_mb_emit_stloc (mb, 1);
  emit_struct_conv (mb, klass, 0);
  <D.26037>:
  D.25999 = BIT_FIELD_REF <*t, 64, 64>;
  D.26000 = D.25999 & 8589934592;
  if (D.26000 != 0) goto <D.26039>; else goto <D.26040>;
  <D.26039>:
  pos.269 = (unsigned int) pos;
  mono_mb_patch_branch (mb, pos.269);
  <D.26040>:
  goto <D.20469>;
  <D.20470>:
  if (spec != 0B) goto <D.26041>; else goto <D.26042>;
  <D.26041>:
  D.26043 = spec->native;
  if (D.26043 == 43) goto <D.26044>; else goto <D.26045>;
  <D.26044>:
  D.25999 = BIT_FIELD_REF <*t, 64, 64>;
  D.26000 = D.25999 & 8589934592;
  D.26046 = D.26000 != 0;
  D.26047 = (long int) D.26046;
  D.26048 = __builtin_expect (D.26047, 0);
  if (D.26048 != 0) goto <D.26049>; else goto <D.26050>;
  <D.26049>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 6301, "!t->byref");
  <D.26050>:
  D.26013 = m->csig;
  D.26013 = m->csig;
  D.26014 = D.26013->hasthis;
  D.26015 = (int) D.26014;
  D.26016 = argnum - D.26015;
  D.26027 = mono_defaults.int_class;
  D.26028 = &D.26027->byval_arg;
  D.26013->params[D.26016] = D.26028;
  D.26021 = klass->flags;
  D.26022 = D.26021 & 24;
  if (D.26022 == 16) goto <D.26051>; else goto <D.26054>;
  <D.26054>:
  D.26024 = BIT_FIELD_REF <*klass, 64, 256>;
  D.26025 = D.26024 & 864691128455135232;
  if (D.26025 != 0) goto <D.26051>; else goto <D.26052>;
  <D.26051>:
  argnum.267 = (unsigned int) argnum;
  mono_mb_emit_ldarg_addr (mb, argnum.267);
  goto <D.26053>;
  <D.26052>:
  conv_arg.268 = (unsigned int) conv_arg;
  mono_mb_emit_ldloc (mb, conv_arg.268);
  <D.26053>:
  goto <D.20469>;
  <D.26045>:
  <D.26042>:
  if (klass == date_time_class) goto <D.26055>; else goto <D.26056>;
  <D.26055>:
  D.25999 = BIT_FIELD_REF <*t, 64, 64>;
  D.26000 = D.25999 & 8589934592;
  if (D.26000 != 0) goto <D.26057>; else goto <D.26058>;
  <D.26057>:
  conv_arg.268 = (unsigned int) conv_arg;
  mono_mb_emit_ldloc_addr (mb, conv_arg.268);
  goto <D.26059>;
  <D.26058>:
  conv_arg.268 = (unsigned int) conv_arg;
  mono_mb_emit_ldloc (mb, conv_arg.268);
  <D.26059>:
  goto <D.20469>;
  <D.26056>:
  D.26021 = klass->flags;
  D.26022 = D.26021 & 24;
  if (D.26022 == 16) goto <D.26060>; else goto <D.26062>;
  <D.26062>:
  D.26024 = BIT_FIELD_REF <*klass, 64, 256>;
  D.26025 = D.26024 & 864691128455135232;
  if (D.26025 != 0) goto <D.26060>; else goto <D.26061>;
  <D.26060>:
  argnum.267 = (unsigned int) argnum;
  mono_mb_emit_ldarg (mb, argnum.267);
  goto <D.20469>;
  <D.26061>:
  conv_arg.268 = (unsigned int) conv_arg;
  mono_mb_emit_ldloc (mb, conv_arg.268);
  D.25999 = BIT_FIELD_REF <*t, 64, 64>;
  D.26000 = D.25999 & 8589934592;
  if (D.26000 == 0) goto <D.26063>; else goto <D.26064>;
  <D.26063>:
  mono_mb_emit_byte (mb, 240);
  mono_mb_emit_op (mb, 6, klass);
  <D.26064>:
  goto <D.20469>;
  <D.20471>:
  if (klass == date_time_class) goto <D.26065>; else goto <D.26066>;
  <D.26065>:
  {
    static struct MonoMethod * from_oadate;

    D.25999 = BIT_FIELD_REF <*t, 64, 64>;
    D.26000 = D.25999 & 8589934592;
    if (D.26000 == 0) goto <D.20469>; else goto <D.26067>;
    <D.26067>:
    D.26008 = t->attrs;
    D.26009 = (unsigned int) D.26008;
    D.26010 = D.26009 & 3;
    if (D.26010 != 1) goto <D.26068>; else goto <D.26069>;
    <D.26068>:
    from_oadate.270 = from_oadate;
    if (from_oadate.270 == 0B) goto <D.26071>; else goto <D.26072>;
    <D.26071>:
    from_oadate.271 = mono_class_get_method_from_name (date_time_class, "FromOADate", 1);
    from_oadate = from_oadate.271;
    <D.26072>:
    from_oadate.270 = from_oadate;
    D.26074 = from_oadate.270 == 0B;
    D.26075 = (long int) D.26074;
    D.26076 = __builtin_expect (D.26075, 0);
    if (D.26076 != 0) goto <D.26077>; else goto <D.26078>;
    <D.26077>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 6345, "from_oadate");
    <D.26078>:
    argnum.267 = (unsigned int) argnum;
    mono_mb_emit_ldarg (mb, argnum.267);
    conv_arg.268 = (unsigned int) conv_arg;
    mono_mb_emit_ldloc (mb, conv_arg.268);
    from_oadate.270 = from_oadate;
    mono_mb_emit_managed_call (mb, from_oadate.270, 0B);
    mono_mb_emit_op (mb, 129, date_time_class);
    <D.26069>:
    goto <D.20469>;
  }
  <D.26066>:
  D.26021 = klass->flags;
  D.26022 = D.26021 & 24;
  if (D.26022 == 16) goto <D.20469>; else goto <D.26079>;
  <D.26079>:
  D.26024 = BIT_FIELD_REF <*klass, 64, 256>;
  D.26025 = D.26024 & 864691128455135232;
  if (D.26025 != 0) goto <D.20469>; else goto <D.26080>;
  <D.26080>:
  D.25999 = BIT_FIELD_REF <*t, 64, 64>;
  D.26000 = D.25999 & 8589934592;
  if (D.26000 != 0) goto <D.26081>; else goto <D.26082>;
  <D.26081>:
  argnum.267 = (unsigned int) argnum;
  mono_mb_emit_ldarg (mb, argnum.267);
  mono_mb_emit_stloc (mb, 1);
  mono_mb_emit_ldloc (mb, 1);
  D.26083 = mono_mb_emit_branch (mb, 57);
  pos = (int) D.26083;
  D.26008 = t->attrs;
  D.26009 = (unsigned int) D.26008;
  D.26010 = D.26009 & 3;
  if (D.26010 != 1) goto <D.26084>; else goto <D.26085>;
  <D.26084>:
  conv_arg.268 = (unsigned int) conv_arg;
  mono_mb_emit_ldloc (mb, conv_arg.268);
  mono_mb_emit_stloc (mb, 0);
  emit_struct_conv (mb, klass, 1);
  <D.26085>:
  <D.26082>:
  emit_struct_free (mb, klass, conv_arg);
  D.25999 = BIT_FIELD_REF <*t, 64, 64>;
  D.26000 = D.25999 & 8589934592;
  if (D.26000 != 0) goto <D.26086>; else goto <D.26087>;
  <D.26086>:
  pos.269 = (unsigned int) pos;
  mono_mb_patch_branch (mb, pos.269);
  <D.26087>:
  goto <D.20469>;
  <D.20473>:
  D.26021 = klass->flags;
  D.26022 = D.26021 & 24;
  if (D.26022 == 16) goto <D.26088>; else goto <D.26090>;
  <D.26090>:
  D.26024 = BIT_FIELD_REF <*klass, 64, 256>;
  D.26091 = D.26024 & 288230376151711744;
  if (D.26091 != 0) goto <D.26088>; else goto <D.26089>;
  <D.26088>:
  mono_mb_emit_stloc (mb, 3);
  goto <D.20469>;
  <D.26089>:
  mono_mb_emit_byte (mb, 240);
  mono_mb_emit_byte (mb, 3);
  mono_mb_emit_stloc (mb, 0);
  mono_mb_emit_ldloc_addr (mb, 3);
  mono_mb_emit_stloc (mb, 1);
  emit_struct_conv (mb, klass, 1);
  goto <D.20469>;
  <D.20474>:
  D.26021 = klass->flags;
  D.26022 = D.26021 & 24;
  if (D.26022 == 16) goto <D.26092>; else goto <D.26094>;
  <D.26094>:
  D.26024 = BIT_FIELD_REF <*klass, 64, 256>;
  D.26025 = D.26024 & 864691128455135232;
  if (D.26025 != 0) goto <D.26092>; else goto <D.26093>;
  <D.26092>:
  conv_arg = 0;
  goto <D.20469>;
  <D.26093>:
  D.26095 = &klass->byval_arg;
  conv_arg = mono_mb_add_local (mb, D.26095);
  D.26008 = t->attrs;
  D.26096 = (int) D.26008;
  D.26097 = D.26096 & 2;
  if (D.26097 != 0) goto <D.20469>; else goto <D.26098>;
  <D.26098>:
  D.25999 = BIT_FIELD_REF <*t, 64, 64>;
  D.26000 = D.25999 & 8589934592;
  if (D.26000 != 0) goto <D.26099>; else goto <D.26100>;
  <D.26099>:
  argnum.267 = (unsigned int) argnum;
  mono_mb_emit_ldarg (mb, argnum.267);
  goto <D.26101>;
  <D.26100>:
  argnum.267 = (unsigned int) argnum;
  mono_mb_emit_ldarg_addr (mb, argnum.267);
  <D.26101>:
  mono_mb_emit_stloc (mb, 0);
  D.25999 = BIT_FIELD_REF <*t, 64, 64>;
  D.26000 = D.25999 & 8589934592;
  if (D.26000 != 0) goto <D.26102>; else goto <D.26103>;
  <D.26102>:
  mono_mb_emit_ldloc (mb, 0);
  D.26104 = mono_mb_emit_branch (mb, 57);
  pos = (int) D.26104;
  <D.26103>:
  conv_arg.268 = (unsigned int) conv_arg;
  mono_mb_emit_ldloc_addr (mb, conv_arg.268);
  mono_mb_emit_stloc (mb, 1);
  emit_struct_conv (mb, klass, 1);
  D.25999 = BIT_FIELD_REF <*t, 64, 64>;
  D.26000 = D.25999 & 8589934592;
  if (D.26000 != 0) goto <D.26105>; else goto <D.26106>;
  <D.26105>:
  pos.269 = (unsigned int) pos;
  mono_mb_patch_branch (mb, pos.269);
  <D.26106>:
  goto <D.20469>;
  <D.20475>:
  D.26021 = klass->flags;
  D.26022 = D.26021 & 24;
  if (D.26022 == 16) goto <D.20469>; else goto <D.26107>;
  <D.26107>:
  D.26024 = BIT_FIELD_REF <*klass, 64, 256>;
  D.26025 = D.26024 & 864691128455135232;
  if (D.26025 != 0) goto <D.20469>; else goto <D.26108>;
  <D.26108>:
  D.25999 = BIT_FIELD_REF <*t, 64, 64>;
  D.26000 = D.25999 & 8589934592;
  if (D.26000 != 0) goto <D.26109>; else goto <D.26110>;
  <D.26109>:
  D.26008 = t->attrs;
  D.26009 = (unsigned int) D.26008;
  D.26010 = D.26009 & 3;
  if (D.26010 == 1) goto <D.20469>; else goto <D.26111>;
  <D.26111>:
  <D.26110>:
  argnum.267 = (unsigned int) argnum;
  mono_mb_emit_ldarg (mb, argnum.267);
  D.26112 = mono_mb_emit_branch (mb, 57);
  pos2 = (int) D.26112;
  conv_arg.268 = (unsigned int) conv_arg;
  mono_mb_emit_ldloc_addr (mb, conv_arg.268);
  mono_mb_emit_stloc (mb, 0);
  argnum.267 = (unsigned int) argnum;
  mono_mb_emit_ldarg (mb, argnum.267);
  mono_mb_emit_stloc (mb, 1);
  emit_struct_conv (mb, klass, 0);
  pos2.272 = (unsigned int) pos2;
  mono_mb_patch_branch (mb, pos2.272);
  goto <D.20469>;
  <D.20476>:
  D.26021 = klass->flags;
  D.26022 = D.26021 & 24;
  if (D.26022 == 16) goto <D.26114>; else goto <D.26116>;
  <D.26116>:
  D.26024 = BIT_FIELD_REF <*klass, 64, 256>;
  D.26025 = D.26024 & 864691128455135232;
  if (D.26025 != 0) goto <D.26114>; else goto <D.26115>;
  <D.26114>:
  mono_mb_emit_stloc (mb, 3);
  m->retobj_var = 0;
  goto <D.20469>;
  <D.26115>:
  mono_mb_emit_byte (mb, 240);
  mono_mb_emit_byte (mb, 3);
  mono_mb_emit_stloc (mb, 0);
  D.26027 = mono_defaults.int_class;
  D.26028 = &D.26027->byval_arg;
  D.26117 = mono_mb_add_local (mb, D.26028);
  m->retobj_var = D.26117;
  m->retobj_class = klass;
  D.26118 = m->retobj_var;
  D.26119 = D.26118 == 0;
  D.26120 = (long int) D.26119;
  D.26121 = __builtin_expect (D.26120, 0);
  if (D.26121 != 0) goto <D.26122>; else goto <D.26123>;
  <D.26122>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 6481, "m->retobj_var");
  <D.26123>:
  D.26124 = mono_class_native_size (klass, 0B);
  mono_mb_emit_icon (mb, D.26124);
  mono_mb_emit_byte (mb, 211);
  mono_mb_emit_icall (mb, mono_marshal_alloc);
  mono_mb_emit_stloc (mb, 1);
  mono_mb_emit_ldloc (mb, 1);
  D.26118 = m->retobj_var;
  D.26125 = (unsigned int) D.26118;
  mono_mb_emit_stloc (mb, D.26125);
  emit_struct_conv (mb, klass, 0);
  goto <D.20469>;
  <D.20477>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "marshal.c", 6494);
  <D.20469>:
  D.26126 = conv_arg;
  return D.26126;
}


emit_marshal_object (struct EmitMarshalContext * m, int argnum, struct MonoType * t, struct MonoMarshalSpec * spec, int conv_arg, struct MonoType * * conv_arg_type, MarshalAction action)
{
  struct MonoClass * D.26128;
  struct MonoType * D.26129;
  int * D.26130;
  long unsigned int D.26131;
  long unsigned int D.26132;
  int * D.26133;
  struct MonoClass * D.26134;
  struct MonoClass * D.26135;
  long unsigned int D.26138;
  long unsigned int D.26139;
  long unsigned int D.26142;
  long unsigned int D.26143;
  short unsigned int D.26146;
  int D.26147;
  int D.26148;
  unsigned int conv_arg.273;
  unsigned int argnum.274;
  void * D.26154;
  struct MonoClass * D.26156;
  struct MonoMethodPInvoke * D.26159;
  unsigned int D.26162;
  unsigned int D.26163;
  void * D.26169;
  long unsigned int D.26171;
  unsigned int D.26174;
  unsigned int pos.275;
  unsigned int D.26180;
  int D.26181;
  int D.26184;
  int D.26185;
  unsigned int D.26186;
  _Bool D.26189;
  long int D.26190;
  long int D.26191;
  void * D.26197;
  int need_free.276;
  void * D.26205;
  unsigned int D.26212;
  unsigned int D.26219;
  _Bool D.26222;
  long int D.26223;
  long int D.26224;
  unsigned int pos2.277;
  _Bool D.26233;
  long int D.26234;
  long int D.26235;
  void * D.26238;
  unsigned int loc.278;
  unsigned int D.26241;
  struct MonoType * D.26242;
  void * D.26247;
  _Bool D.26250;
  long int D.26251;
  long int D.26252;
  _Bool D.26257;
  long int D.26258;
  long int D.26259;
  unsigned int D.26262;
  unsigned int D.26263;
  unsigned int D.26270;
  unsigned int pos2.279;
  unsigned int D.26272;
  unsigned int D.26275;
  unsigned int D.26276;
  int D.26277;
  void * D.26281;
  unsigned int D.26284;
  unsigned int D.26285;
  int D.26286;
  int D.26287;
  struct MonoMethodBuilder * mb;
  struct MonoClass * klass;
  int pos;
  int pos2;
  int loc;

  mb = m->mb;
  klass = mono_class_from_mono_type (t);
  switch (action) <default: <D.20591>, case 0: <D.20569>, case 1: <D.20584>, case 2: <D.20576>, case 3: <D.20585>, case 4: <D.20586>, case 5: <D.20589>, case 6: <D.20590>>
  <D.20569>:
  D.26128 = mono_defaults.int_class;
  D.26129 = &D.26128->byval_arg;
  *conv_arg_type = D.26129;
  D.26128 = mono_defaults.int_class;
  D.26129 = &D.26128->byval_arg;
  conv_arg = mono_mb_add_local (mb, D.26129);
  D.26130 = m->orig_conv_args;
  D.26131 = (long unsigned int) argnum;
  D.26132 = D.26131 * 4;
  D.26133 = D.26130 + D.26132;
  *D.26133 = 0;
  D.26134 = mono_class_from_mono_type (t);
  D.26135 = mono_defaults.object_class;
  if (D.26134 == D.26135) goto <D.26136>; else goto <D.26137>;
  <D.26136>:
  {
    char * msg;

    msg = monoeg_g_strdup_printf ("Marshalling of type object is not implemented");
    mono_mb_emit_exception_marshal_directive (mb, msg);
    goto <D.20571>;
  }
  <D.26137>:
  D.26138 = BIT_FIELD_REF <*klass, 64, 256>;
  D.26139 = D.26138 & 549755813888;
  if (D.26139 != 0) goto <D.26140>; else goto <D.26141>;
  <D.26140>:
  D.26142 = BIT_FIELD_REF <*t, 64, 64>;
  D.26143 = D.26142 & 8589934592;
  if (D.26143 != 0) goto <D.26144>; else goto <D.26145>;
  <D.26144>:
  D.26146 = t->attrs;
  D.26147 = (int) D.26146;
  D.26148 = D.26147 & 2;
  if (D.26148 == 0) goto <D.26149>; else goto <D.26150>;
  <D.26149>:
  {
    char * msg;

    msg = monoeg_g_strdup_printf ("Byref marshalling of delegates is not implemented.");
    mono_mb_emit_exception_marshal_directive (mb, msg);
  }
  <D.26150>:
  mono_mb_emit_byte (mb, 20);
  conv_arg.273 = (unsigned int) conv_arg;
  mono_mb_emit_stloc (mb, conv_arg.273);
  goto <D.26152>;
  <D.26145>:
  argnum.274 = (unsigned int) argnum;
  mono_mb_emit_ldarg (mb, argnum.274);
  D.26154 = conv_to_icall (29);
  mono_mb_emit_icall (mb, D.26154);
  conv_arg.273 = (unsigned int) conv_arg;
  mono_mb_emit_stloc (mb, conv_arg.273);
  <D.26152>:
  goto <D.26155>;
  <D.26141>:
  D.26156 = mono_defaults.stringbuilder_class;
  if (D.26156 == klass) goto <D.26157>; else goto <D.26158>;
  <D.26157>:
  {
    MonoMarshalNative encoding;
    MonoMarshalConv conv;

    D.26159 = m->piinfo;
    encoding = mono_marshal_get_string_encoding (D.26159, spec);
    D.26159 = m->piinfo;
    conv = mono_marshal_get_stringbuilder_to_ptr_conv (D.26159, spec);
    D.26142 = BIT_FIELD_REF <*t, 64, 64>;
    D.26143 = D.26142 & 8589934592;
    if (D.26143 != 0) goto <D.26160>; else goto <D.26161>;
    <D.26160>:
    D.26146 = t->attrs;
    D.26162 = (unsigned int) D.26146;
    D.26163 = D.26162 & 3;
    if (D.26163 == 2) goto <D.20571>; else goto <D.26164>;
    <D.26164>:
    <D.26161>:
    if (conv == 4294967295) goto <D.26165>; else goto <D.26166>;
    <D.26165>:
    {
      char * msg;

      msg = monoeg_g_strdup_printf ("stringbuilder marshalling conversion %d not implemented", encoding);
      mono_mb_emit_exception_marshal_directive (mb, msg);
      goto <D.20571>;
    }
    <D.26166>:
    argnum.274 = (unsigned int) argnum;
    mono_mb_emit_ldarg (mb, argnum.274);
    D.26142 = BIT_FIELD_REF <*t, 64, 64>;
    D.26143 = D.26142 & 8589934592;
    if (D.26143 != 0) goto <D.26167>; else goto <D.26168>;
    <D.26167>:
    mono_mb_emit_byte (mb, 77);
    <D.26168>:
    D.26169 = conv_to_icall (conv);
    mono_mb_emit_icall (mb, D.26169);
    conv_arg.273 = (unsigned int) conv_arg;
    mono_mb_emit_stloc (mb, conv_arg.273);
  }
  goto <D.26170>;
  <D.26158>:
  D.26138 = BIT_FIELD_REF <*klass, 64, 256>;
  D.26171 = D.26138 & 288230376151711744;
  if (D.26171 != 0) goto <D.26172>; else goto <D.26173>;
  <D.26172>:
  mono_mb_emit_byte (mb, 20);
  conv_arg.273 = (unsigned int) conv_arg;
  mono_mb_emit_stloc (mb, conv_arg.273);
  argnum.274 = (unsigned int) argnum;
  mono_mb_emit_ldarg (mb, argnum.274);
  D.26174 = mono_mb_emit_branch (mb, 57);
  pos = (int) D.26174;
  argnum.274 = (unsigned int) argnum;
  mono_mb_emit_ldarg (mb, argnum.274);
  mono_mb_emit_ldflda (mb, 16);
  conv_arg.273 = (unsigned int) conv_arg;
  mono_mb_emit_stloc (mb, conv_arg.273);
  pos.275 = (unsigned int) pos;
  mono_mb_patch_branch (mb, pos.275);
  goto <D.20571>;
  <D.26173>:
  mono_mb_emit_byte (mb, 20);
  conv_arg.273 = (unsigned int) conv_arg;
  mono_mb_emit_stloc (mb, conv_arg.273);
  D.26142 = BIT_FIELD_REF <*t, 64, 64>;
  D.26143 = D.26142 & 8589934592;
  if (D.26143 != 0) goto <D.26176>; else goto <D.26177>;
  <D.26176>:
  D.26146 = t->attrs;
  D.26147 = (int) D.26146;
  D.26148 = D.26147 & 2;
  if (D.26148 != 0) goto <D.20571>; else goto <D.26178>;
  <D.26178>:
  argnum.274 = (unsigned int) argnum;
  mono_mb_emit_ldarg (mb, argnum.274);
  mono_mb_emit_byte (mb, 77);
  goto <D.26179>;
  <D.26177>:
  argnum.274 = (unsigned int) argnum;
  mono_mb_emit_ldarg (mb, argnum.274);
  mono_mb_emit_byte (mb, 240);
  mono_mb_emit_byte (mb, 1);
  <D.26179>:
  mono_mb_emit_stloc (mb, 0);
  mono_mb_emit_ldloc (mb, 0);
  D.26180 = mono_mb_emit_branch (mb, 57);
  pos = (int) D.26180;
  D.26181 = mono_class_native_size (klass, 0B);
  mono_mb_emit_icon (mb, D.26181);
  mono_mb_emit_byte (mb, 254);
  mono_mb_emit_byte (mb, 15);
  conv_arg.273 = (unsigned int) conv_arg;
  mono_mb_emit_stloc (mb, conv_arg.273);
  D.26142 = BIT_FIELD_REF <*t, 64, 64>;
  D.26143 = D.26142 & 8589934592;
  if (D.26143 != 0) goto <D.26182>; else goto <D.26183>;
  <D.26182>:
  D.26130 = m->orig_conv_args;
  D.26131 = (long unsigned int) argnum;
  D.26132 = D.26131 * 4;
  D.26133 = D.26130 + D.26132;
  D.26128 = mono_defaults.int_class;
  D.26129 = &D.26128->byval_arg;
  D.26184 = mono_mb_add_local (mb, D.26129);
  *D.26133 = D.26184;
  conv_arg.273 = (unsigned int) conv_arg;
  mono_mb_emit_ldloc (mb, conv_arg.273);
  D.26130 = m->orig_conv_args;
  D.26131 = (long unsigned int) argnum;
  D.26132 = D.26131 * 4;
  D.26133 = D.26130 + D.26132;
  D.26185 = *D.26133;
  D.26186 = (unsigned int) D.26185;
  mono_mb_emit_stloc (mb, D.26186);
  <D.26183>:
  mono_mb_emit_ldloc (mb, 0);
  mono_mb_emit_ldflda (mb, 16);
  mono_mb_emit_stloc (mb, 0);
  conv_arg.273 = (unsigned int) conv_arg;
  mono_mb_emit_ldloc (mb, conv_arg.273);
  mono_mb_emit_stloc (mb, 1);
  emit_struct_conv (mb, klass, 0);
  pos.275 = (unsigned int) pos;
  mono_mb_patch_branch (mb, pos.275);
  <D.26170>:
  <D.26155>:
  goto <D.20571>;
  <D.20576>:
  D.26156 = mono_defaults.stringbuilder_class;
  if (D.26156 == klass) goto <D.26187>; else goto <D.26188>;
  <D.26187>:
  {
    gboolean need_free;
    MonoMarshalNative encoding;
    MonoMarshalConv conv;

    try
      {
        D.26159 = m->piinfo;
        encoding = mono_marshal_get_string_encoding (D.26159, spec);
        D.26159 = m->piinfo;
        conv = mono_marshal_get_ptr_to_stringbuilder_conv (D.26159, spec, &need_free);
        D.26189 = encoding == 4294967295;
        D.26190 = (long int) D.26189;
        D.26191 = __builtin_expect (D.26190, 0);
        if (D.26191 != 0) goto <D.26192>; else goto <D.26193>;
        <D.26192>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 7051, "encoding != -1");
        <D.26193>:
        D.26142 = BIT_FIELD_REF <*t, 64, 64>;
        D.26143 = D.26142 & 8589934592;
        if (D.26143 != 0) goto <D.26194>; else goto <D.26195>;
        <D.26194>:
        need_free = 1;
        argnum.274 = (unsigned int) argnum;
        mono_mb_emit_ldarg (mb, argnum.274);
        conv_arg.273 = (unsigned int) conv_arg;
        mono_mb_emit_ldloc (mb, conv_arg.273);
        switch (encoding) <default: <D.20583>, case 20: <D.20582>, case 21: <D.20580>>
        <D.20580>:
        mono_mb_emit_icall (mb, mono_string_utf16_to_builder2);
        goto <D.20581>;
        <D.20582>:
        mono_mb_emit_icall (mb, mono_string_utf8_to_builder2);
        goto <D.20581>;
        <D.20583>:
        monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "marshal.c", 7069);
        <D.20581>:
        mono_mb_emit_byte (mb, 81);
        goto <D.26196>;
        <D.26195>:
        argnum.274 = (unsigned int) argnum;
        mono_mb_emit_ldarg (mb, argnum.274);
        conv_arg.273 = (unsigned int) conv_arg;
        mono_mb_emit_ldloc (mb, conv_arg.273);
        D.26197 = conv_to_icall (conv);
        mono_mb_emit_icall (mb, D.26197);
        <D.26196>:
        need_free.276 = need_free;
        if (need_free.276 != 0) goto <D.26199>; else goto <D.26200>;
        <D.26199>:
        conv_arg.273 = (unsigned int) conv_arg;
        mono_mb_emit_ldloc (mb, conv_arg.273);
        mono_mb_emit_icall (mb, mono_marshal_free);
        <D.26200>:
        goto <D.20571>;
      }
    finally
      {
        need_free = {CLOBBER};
      }
  }
  <D.26188>:
  D.26138 = BIT_FIELD_REF <*klass, 64, 256>;
  D.26139 = D.26138 & 549755813888;
  if (D.26139 != 0) goto <D.26201>; else goto <D.26202>;
  <D.26201>:
  D.26142 = BIT_FIELD_REF <*t, 64, 64>;
  D.26143 = D.26142 & 8589934592;
  if (D.26143 != 0) goto <D.26203>; else goto <D.26204>;
  <D.26203>:
  argnum.274 = (unsigned int) argnum;
  mono_mb_emit_ldarg (mb, argnum.274);
  mono_mb_emit_byte (mb, 240);
  mono_mb_emit_op (mb, 11, klass);
  conv_arg.273 = (unsigned int) conv_arg;
  mono_mb_emit_ldloc (mb, conv_arg.273);
  D.26205 = conv_to_icall (30);
  mono_mb_emit_icall (mb, D.26205);
  mono_mb_emit_byte (mb, 81);
  <D.26204>:
  goto <D.20571>;
  <D.26202>:
  D.26142 = BIT_FIELD_REF <*t, 64, 64>;
  D.26143 = D.26142 & 8589934592;
  if (D.26143 != 0) goto <D.26206>; else goto <D.26207>;
  <D.26206>:
  D.26146 = t->attrs;
  D.26147 = (int) D.26146;
  D.26148 = D.26147 & 2;
  if (D.26148 != 0) goto <D.26208>; else goto <D.26209>;
  <D.26208>:
  argnum.274 = (unsigned int) argnum;
  mono_mb_emit_ldarg (mb, argnum.274);
  mono_mb_emit_byte (mb, 240);
  mono_mb_emit_op (mb, 4, klass);
  mono_mb_emit_byte (mb, 81);
  <D.26209>:
  <D.26207>:
  argnum.274 = (unsigned int) argnum;
  mono_mb_emit_ldarg (mb, argnum.274);
  D.26142 = BIT_FIELD_REF <*t, 64, 64>;
  D.26143 = D.26142 & 8589934592;
  if (D.26143 != 0) goto <D.26210>; else goto <D.26211>;
  <D.26210>:
  mono_mb_emit_byte (mb, 77);
  <D.26211>:
  mono_mb_emit_stloc (mb, 1);
  mono_mb_emit_ldloc (mb, 1);
  D.26212 = mono_mb_emit_branch (mb, 57);
  pos = (int) D.26212;
  D.26142 = BIT_FIELD_REF <*t, 64, 64>;
  D.26143 = D.26142 & 8589934592;
  if (D.26143 != 0) goto <D.26213>; else goto <D.26216>;
  <D.26216>:
  D.26146 = t->attrs;
  D.26147 = (int) D.26146;
  D.26148 = D.26147 & 2;
  if (D.26148 != 0) goto <D.26213>; else goto <D.26214>;
  <D.26213>:
  mono_mb_emit_ldloc (mb, 1);
  mono_mb_emit_icon (mb, 16);
  mono_mb_emit_byte (mb, 88);
  mono_mb_emit_stloc (mb, 1);
  conv_arg.273 = (unsigned int) conv_arg;
  mono_mb_emit_ldloc (mb, conv_arg.273);
  mono_mb_emit_stloc (mb, 0);
  emit_struct_conv (mb, klass, 1);
  emit_struct_free (mb, klass, conv_arg);
  D.26130 = m->orig_conv_args;
  D.26131 = (long unsigned int) argnum;
  D.26132 = D.26131 * 4;
  D.26133 = D.26130 + D.26132;
  D.26185 = *D.26133;
  if (D.26185 != 0) goto <D.26217>; else goto <D.26218>;
  <D.26217>:
  D.26130 = m->orig_conv_args;
  D.26131 = (long unsigned int) argnum;
  D.26132 = D.26131 * 4;
  D.26133 = D.26130 + D.26132;
  D.26185 = *D.26133;
  D.26186 = (unsigned int) D.26185;
  mono_mb_emit_ldloc (mb, D.26186);
  conv_arg.273 = (unsigned int) conv_arg;
  mono_mb_emit_ldloc (mb, conv_arg.273);
  D.26219 = mono_mb_emit_branch (mb, 59);
  pos2 = (int) D.26219;
  D.26146 = t->attrs;
  D.26147 = (int) D.26146;
  D.26148 = D.26147 & 2;
  if (D.26148 == 0) goto <D.26220>; else goto <D.26221>;
  <D.26220>:
  D.26130 = m->orig_conv_args;
  D.26131 = (long unsigned int) argnum;
  D.26132 = D.26131 * 4;
  D.26133 = D.26130 + D.26132;
  D.26185 = *D.26133;
  D.26222 = D.26185 == 0;
  D.26223 = (long int) D.26222;
  D.26224 = __builtin_expect (D.26223, 0);
  if (D.26224 != 0) goto <D.26225>; else goto <D.26226>;
  <D.26225>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 7144, "m->orig_conv_args [argnum]");
  <D.26226>:
  D.26130 = m->orig_conv_args;
  D.26131 = (long unsigned int) argnum;
  D.26132 = D.26131 * 4;
  D.26133 = D.26130 + D.26132;
  D.26185 = *D.26133;
  emit_struct_free (mb, klass, D.26185);
  <D.26221>:
  conv_arg.273 = (unsigned int) conv_arg;
  mono_mb_emit_ldloc (mb, conv_arg.273);
  mono_mb_emit_icall (mb, mono_marshal_free);
  pos2.277 = (unsigned int) pos2;
  mono_mb_patch_branch (mb, pos2.277);
  <D.26218>:
  goto <D.26215>;
  <D.26214>:
  emit_struct_free (mb, klass, conv_arg);
  <D.26215>:
  pos.275 = (unsigned int) pos;
  mono_mb_patch_branch (mb, pos.275);
  goto <D.20571>;
  <D.20584>:
  D.26142 = BIT_FIELD_REF <*t, 64, 64>;
  D.26143 = D.26142 & 8589934592;
  if (D.26143 != 0) goto <D.26228>; else goto <D.26229>;
  <D.26228>:
  conv_arg.273 = (unsigned int) conv_arg;
  mono_mb_emit_ldloc_addr (mb, conv_arg.273);
  goto <D.26230>;
  <D.26229>:
  conv_arg.273 = (unsigned int) conv_arg;
  mono_mb_emit_ldloc (mb, conv_arg.273);
  <D.26230>:
  goto <D.20571>;
  <D.20585>:
  D.26138 = BIT_FIELD_REF <*klass, 64, 256>;
  D.26139 = D.26138 & 549755813888;
  if (D.26139 != 0) goto <D.26231>; else goto <D.26232>;
  <D.26231>:
  D.26142 = BIT_FIELD_REF <*t, 64, 64>;
  D.26143 = D.26142 & 8589934592;
  D.26233 = D.26143 != 0;
  D.26234 = (long int) D.26233;
  D.26235 = __builtin_expect (D.26234, 0);
  if (D.26235 != 0) goto <D.26236>; else goto <D.26237>;
  <D.26236>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 7171, "!t->byref");
  <D.26237>:
  mono_mb_emit_stloc (mb, 0);
  mono_mb_emit_byte (mb, 240);
  mono_mb_emit_op (mb, 11, klass);
  mono_mb_emit_ldloc (mb, 0);
  D.26238 = conv_to_icall (30);
  mono_mb_emit_icall (mb, D.26238);
  mono_mb_emit_stloc (mb, 3);
  goto <D.26239>;
  <D.26232>:
  mono_mb_emit_stloc (mb, 0);
  D.26128 = mono_defaults.int_class;
  D.26129 = &D.26128->byval_arg;
  loc = mono_mb_add_local (mb, D.26129);
  mono_mb_emit_ldloc (mb, 0);
  loc.278 = (unsigned int) loc;
  mono_mb_emit_stloc (mb, loc.278);
  mono_mb_emit_byte (mb, 20);
  mono_mb_emit_stloc (mb, 3);
  mono_mb_emit_ldloc (mb, 0);
  D.26241 = mono_mb_emit_branch (mb, 57);
  pos = (int) D.26241;
  mono_mb_emit_byte (mb, 240);
  mono_mb_emit_op (mb, 4, klass);
  mono_mb_emit_stloc (mb, 3);
  mono_mb_emit_ldloc (mb, 3);
  mono_mb_emit_ldflda (mb, 16);
  mono_mb_emit_stloc (mb, 1);
  emit_struct_conv (mb, klass, 1);
  emit_struct_free (mb, klass, loc);
  loc.278 = (unsigned int) loc;
  mono_mb_emit_ldloc (mb, loc.278);
  mono_mb_emit_icall (mb, mono_marshal_free);
  pos.275 = (unsigned int) pos;
  mono_mb_patch_branch (mb, pos.275);
  <D.26239>:
  goto <D.20571>;
  <D.20586>:
  D.26242 = &klass->byval_arg;
  conv_arg = mono_mb_add_local (mb, D.26242);
  D.26138 = BIT_FIELD_REF <*klass, 64, 256>;
  D.26139 = D.26138 & 549755813888;
  if (D.26139 != 0) goto <D.26243>; else goto <D.26244>;
  <D.26243>:
  D.26142 = BIT_FIELD_REF <*t, 64, 64>;
  D.26143 = D.26142 & 8589934592;
  D.26233 = D.26143 != 0;
  D.26234 = (long int) D.26233;
  D.26235 = __builtin_expect (D.26234, 0);
  if (D.26235 != 0) goto <D.26245>; else goto <D.26246>;
  <D.26245>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 7221, "!t->byref");
  <D.26246>:
  mono_mb_emit_byte (mb, 240);
  mono_mb_emit_op (mb, 11, klass);
  argnum.274 = (unsigned int) argnum;
  mono_mb_emit_ldarg (mb, argnum.274);
  D.26247 = conv_to_icall (30);
  mono_mb_emit_icall (mb, D.26247);
  conv_arg.273 = (unsigned int) conv_arg;
  mono_mb_emit_stloc (mb, conv_arg.273);
  goto <D.20571>;
  <D.26244>:
  D.26156 = mono_defaults.stringbuilder_class;
  if (D.26156 == klass) goto <D.26248>; else goto <D.26249>;
  <D.26248>:
  {
    MonoMarshalNative encoding;

    D.26159 = m->piinfo;
    encoding = mono_marshal_get_string_encoding (D.26159, spec);
    D.26250 = encoding != 20;
    D.26251 = (long int) D.26250;
    D.26252 = __builtin_expect (D.26251, 0);
    if (D.26252 != 0) goto <D.26253>; else goto <D.26254>;
    <D.26253>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 7236, "encoding == MONO_NATIVE_LPSTR");
    <D.26254>:
    D.26142 = BIT_FIELD_REF <*t, 64, 64>;
    D.26143 = D.26142 & 8589934592;
    D.26233 = D.26143 != 0;
    D.26234 = (long int) D.26233;
    D.26235 = __builtin_expect (D.26234, 0);
    if (D.26235 != 0) goto <D.26255>; else goto <D.26256>;
    <D.26255>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 7238, "!t->byref");
    <D.26256>:
    D.26257 = encoding == 4294967295;
    D.26258 = (long int) D.26257;
    D.26259 = __builtin_expect (D.26258, 0);
    if (D.26259 != 0) goto <D.26260>; else goto <D.26261>;
    <D.26260>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 7239, "encoding != -1");
    <D.26261>:
    argnum.274 = (unsigned int) argnum;
    mono_mb_emit_ldarg (mb, argnum.274);
    mono_mb_emit_icall (mb, mono_string_utf8_to_builder2);
    conv_arg.273 = (unsigned int) conv_arg;
    mono_mb_emit_stloc (mb, conv_arg.273);
    goto <D.20571>;
  }
  <D.26249>:
  D.26262 = klass->flags;
  D.26263 = D.26262 & 24;
  if (D.26263 == 0) goto <D.26264>; else goto <D.26265>;
  <D.26264>:
  mono_mb_emit_auto_layout_exception (mb, klass);
  goto <D.20571>;
  <D.26265>:
  D.26146 = t->attrs;
  D.26147 = (int) D.26146;
  D.26148 = D.26147 & 2;
  if (D.26148 != 0) goto <D.26266>; else goto <D.26267>;
  <D.26266>:
  mono_mb_emit_byte (mb, 20);
  conv_arg.273 = (unsigned int) conv_arg;
  mono_mb_emit_stloc (mb, conv_arg.273);
  goto <D.20571>;
  <D.26267>:
  argnum.274 = (unsigned int) argnum;
  mono_mb_emit_ldarg (mb, argnum.274);
  D.26142 = BIT_FIELD_REF <*t, 64, 64>;
  D.26143 = D.26142 & 8589934592;
  if (D.26143 != 0) goto <D.26268>; else goto <D.26269>;
  <D.26268>:
  {
    int pos2;

    D.26270 = mono_mb_emit_branch (mb, 58);
    pos2 = (int) D.26270;
    mono_mb_emit_exception (mb, "ArgumentNullException", 0B);
    pos2.279 = (unsigned int) pos2;
    mono_mb_patch_branch (mb, pos2.279);
    argnum.274 = (unsigned int) argnum;
    mono_mb_emit_ldarg (mb, argnum.274);
    mono_mb_emit_byte (mb, 77);
  }
  <D.26269>:
  mono_mb_emit_stloc (mb, 0);
  mono_mb_emit_byte (mb, 22);
  conv_arg.273 = (unsigned int) conv_arg;
  mono_mb_emit_stloc (mb, conv_arg.273);
  mono_mb_emit_ldloc (mb, 0);
  D.26272 = mono_mb_emit_branch (mb, 57);
  pos = (int) D.26272;
  mono_mb_emit_byte (mb, 240);
  mono_mb_emit_op (mb, 4, klass);
  conv_arg.273 = (unsigned int) conv_arg;
  mono_mb_emit_stloc (mb, conv_arg.273);
  conv_arg.273 = (unsigned int) conv_arg;
  mono_mb_emit_ldloc (mb, conv_arg.273);
  mono_mb_emit_ldflda (mb, 16);
  mono_mb_emit_stloc (mb, 1);
  emit_struct_conv (mb, klass, 1);
  pos.275 = (unsigned int) pos;
  mono_mb_patch_branch (mb, pos.275);
  goto <D.20571>;
  <D.20589>:
  D.26142 = BIT_FIELD_REF <*t, 64, 64>;
  D.26143 = D.26142 & 8589934592;
  if (D.26143 != 0) goto <D.26273>; else goto <D.26274>;
  <D.26273>:
  conv_arg.273 = (unsigned int) conv_arg;
  mono_mb_emit_ldloc (mb, conv_arg.273);
  D.26275 = mono_mb_emit_branch (mb, 58);
  pos = (int) D.26275;
  argnum.274 = (unsigned int) argnum;
  mono_mb_emit_ldarg (mb, argnum.274);
  mono_mb_emit_byte (mb, 22);
  mono_mb_emit_byte (mb, 81);
  D.26276 = mono_mb_emit_branch (mb, 56);
  pos2 = (int) D.26276;
  pos.275 = (unsigned int) pos;
  mono_mb_patch_branch (mb, pos.275);
  conv_arg.273 = (unsigned int) conv_arg;
  mono_mb_emit_ldloc (mb, conv_arg.273);
  mono_mb_emit_ldflda (mb, 16);
  mono_mb_emit_stloc (mb, 0);
  D.26277 = mono_class_native_size (klass, 0B);
  mono_mb_emit_icon (mb, D.26277);
  mono_mb_emit_byte (mb, 211);
  mono_mb_emit_icall (mb, mono_marshal_alloc);
  mono_mb_emit_stloc (mb, 1);
  argnum.274 = (unsigned int) argnum;
  mono_mb_emit_ldarg (mb, argnum.274);
  mono_mb_emit_ldloc (mb, 1);
  mono_mb_emit_byte (mb, 223);
  emit_struct_conv (mb, klass, 0);
  pos2.277 = (unsigned int) pos2;
  mono_mb_patch_branch (mb, pos2.277);
  goto <D.26278>;
  <D.26274>:
  conv_arg.273 = (unsigned int) conv_arg;
  mono_mb_emit_ldloc (mb, conv_arg.273);
  mono_mb_emit_ldflda (mb, 16);
  mono_mb_emit_stloc (mb, 0);
  argnum.274 = (unsigned int) argnum;
  mono_mb_emit_ldarg (mb, argnum.274);
  mono_mb_emit_stloc (mb, 1);
  emit_struct_conv (mb, klass, 0);
  <D.26278>:
  goto <D.20571>;
  <D.20590>:
  D.26138 = BIT_FIELD_REF <*klass, 64, 256>;
  D.26139 = D.26138 & 549755813888;
  if (D.26139 != 0) goto <D.26279>; else goto <D.26280>;
  <D.26279>:
  D.26281 = conv_to_icall (29);
  mono_mb_emit_icall (mb, D.26281);
  mono_mb_emit_stloc (mb, 3);
  goto <D.20571>;
  <D.26280>:
  D.26262 = klass->flags;
  D.26263 = D.26262 & 24;
  if (D.26263 == 0) goto <D.26282>; else goto <D.26283>;
  <D.26282>:
  mono_mb_emit_auto_layout_exception (mb, klass);
  goto <D.20571>;
  <D.26283>:
  mono_mb_emit_stloc (mb, 0);
  mono_mb_emit_ldloc (mb, 0);
  D.26284 = mono_mb_emit_branch (mb, 58);
  pos = (int) D.26284;
  mono_mb_emit_byte (mb, 20);
  mono_mb_emit_stloc (mb, 3);
  D.26285 = mono_mb_emit_branch (mb, 56);
  pos2 = (int) D.26285;
  pos.275 = (unsigned int) pos;
  mono_mb_patch_branch (mb, pos.275);
  mono_mb_emit_ldloc (mb, 0);
  mono_mb_emit_ldflda (mb, 16);
  mono_mb_emit_stloc (mb, 0);
  D.26286 = mono_class_native_size (klass, 0B);
  mono_mb_emit_icon (mb, D.26286);
  mono_mb_emit_byte (mb, 211);
  mono_mb_emit_icall (mb, mono_marshal_alloc);
  mono_mb_emit_byte (mb, 37);
  mono_mb_emit_stloc (mb, 1);
  mono_mb_emit_stloc (mb, 3);
  emit_struct_conv (mb, klass, 0);
  pos2.277 = (unsigned int) pos2;
  mono_mb_patch_branch (mb, pos2.277);
  goto <D.20571>;
  <D.20591>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "marshal.c", 7389);
  <D.20571>:
  D.26287 = conv_arg;
  return D.26287;
}


mono_mb_emit_auto_layout_exception (struct MonoMethodBuilder * mb, struct MonoClass * klass)
{
  const char * D.26290;
  const char * D.26291;
  char * msg;

  D.26290 = klass->name_space;
  D.26291 = klass->name;
  msg = monoeg_g_strdup_printf ("The type `%s.%s\' layout needs to be Sequential or Explicit", D.26290, D.26291);
  mono_mb_emit_exception_marshal_directive (mb, msg);
}


__attribute__((visibility ("hidden")))
mono_marshal_get_native_wrapper (struct MonoMethod * method, gboolean check_exceptions, gboolean aot)
{
  _Bool D.26292;
  long int D.26293;
  long int D.26294;
  struct MonoMethodSignature * D.26297;
  long unsigned int D.26298;
  long unsigned int D.26299;
  _Bool D.26300;
  long int D.26301;
  long int D.26302;
  struct MonoClass * D.26307;
  struct MonoImage * D.26308;
  struct GHashTable * * D.26309;
  struct GHashTable * * D.26311;
  struct MonoMethod * D.26314;
  unsigned int D.26315;
  unsigned int D.26316;
  short unsigned int D.26319;
  int D.26320;
  int D.26321;
  short unsigned int D.26324;
  int D.26325;
  int D.26326;
  void * D.26329;
  int D.26334;
  void * D.26341;
  _Bool D.26344;
  long int D.26345;
  long int D.26346;
  long unsigned int D.26349;
  long unsigned int D.26350;
  _Bool D.26351;
  long int D.26352;
  long int D.26353;
  long unsigned int D.26356;
  long unsigned int D.26357;
  _Bool D.26358;
  long int D.26359;
  long int D.26360;
  struct MonoClass * D.26363;
  struct MonoType * D.26364;
  const char * D.26365;
  int D.26366;
  struct MonoMethodSignature * D.26369;
  int D.26370;
  short unsigned int D.26373;
  int D.26374;
  int D.26375;
  _Bool D.26376;
  long int D.26377;
  long int D.26378;
  short unsigned int D.26381;
  int D.26382;
  int D.26383;
  _Bool D.26384;
  long int D.26385;
  long int D.26386;
  const char * D.26389;
  unsigned int i.280;
  short unsigned int D.26391;
  int D.26392;
  int D.26393;
  struct MonoMethod * D.26394;
  const char * exc_class.281;
  const char * exc_arg.282;
  int D.26401;
  int D.26402;
  unsigned int D.26412;
  unsigned int pos.283;
  <unnamed-unsigned:1> D.26414;
  int D.26415;
  int D.26416;
  unsigned int D.26417;
  short unsigned int D.26418;
  int D.26419;
  struct MonoMethod * D.26422;
  _Bool D.26424;
  long int D.26425;
  long int D.26426;
  _Bool D.26431;
  long int D.26432;
  long int D.26433;
  int D.26440;
  long unsigned int D.26441;
  long unsigned int D.26442;
  struct MonoClass * D.26443;
  struct MonoImage * D.26444;
  long unsigned int D.26445;
  long unsigned int D.26446;
  struct MonoMarshalSpec * * D.26447;
  struct MonoMarshalSpec * D.26448;
  struct MonoMethodSignature * sig;
  struct MonoMethodSignature * csig;
  struct MonoMethodPInvoke * piinfo;
  struct MonoMethodBuilder * mb;
  struct MonoMarshalSpec * * mspecs;
  struct MonoMethod * res;
  struct GHashTable * cache;
  gboolean pinvoke;
  void * iter;
  int i;
  const char * exc_class;
  const char * exc_arg;
  struct WrapperInfo * info;

  try
    {
      piinfo = method;
      pinvoke = 0;
      exc_class = "MissingMethodException";
      exc_arg = 0B;
      D.26292 = method == 0B;
      D.26293 = (long int) D.26292;
      D.26294 = __builtin_expect (D.26293, 0);
      if (D.26294 != 0) goto <D.26295>; else goto <D.26296>;
      <D.26295>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 8859, "method != NULL");
      <D.26296>:
      D.26297 = mono_method_signature (method);
      D.26298 = BIT_FIELD_REF <*D.26297, 64, 64>;
      D.26299 = D.26298 & 128;
      D.26300 = D.26299 == 0;
      D.26301 = (long int) D.26300;
      D.26302 = __builtin_expect (D.26301, 0);
      if (D.26302 != 0) goto <D.26303>; else goto <D.26304>;
      <D.26303>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 8860, "mono_method_signature (method)->pinvoke");
      <D.26304>:
      if (aot != 0) goto <D.26305>; else goto <D.26306>;
      <D.26305>:
      D.26307 = method->klass;
      D.26308 = D.26307->image;
      D.26309 = &D.26308->native_wrapper_aot_cache;
      cache = get_cache (D.26309, mono_aligned_addr_hash, 0B);
      goto <D.26310>;
      <D.26306>:
      D.26307 = method->klass;
      D.26308 = D.26307->image;
      D.26311 = &D.26308->native_wrapper_cache;
      cache = get_cache (D.26311, mono_aligned_addr_hash, 0B);
      <D.26310>:
      res = mono_marshal_find_in_cache (cache, method);
      if (res != 0B) goto <D.26312>; else goto <D.26313>;
      <D.26312>:
      D.26314 = res;
      return D.26314;
      <D.26313>:
      D.26307 = method->klass;
      D.26315 = D.26307->flags;
      D.26316 = D.26315 & 4096;
      if (D.26316 != 0) goto <D.26317>; else goto <D.26318>;
      <D.26317>:
      D.26314 = mono_cominterop_get_native_wrapper (method);
      return D.26314;
      <D.26318>:
      sig = mono_method_signature (method);
      D.26319 = method->iflags;
      D.26320 = (int) D.26319;
      D.26321 = D.26320 & 4096;
      if (D.26321 == 0) goto <D.26322>; else goto <D.26323>;
      <D.26322>:
      D.26324 = method->flags;
      D.26325 = (int) D.26324;
      D.26326 = D.26325 & 8192;
      if (D.26326 != 0) goto <D.26327>; else goto <D.26328>;
      <D.26327>:
      pinvoke = 1;
      <D.26328>:
      <D.26323>:
      D.26329 = piinfo->addr;
      if (D.26329 == 0B) goto <D.26330>; else goto <D.26331>;
      <D.26330>:
      if (pinvoke != 0) goto <D.26332>; else goto <D.26333>;
      <D.26332>:
      D.26319 = method->iflags;
      D.26320 = (int) D.26319;
      D.26334 = D.26320 & 1;
      if (D.26334 != 0) goto <D.26335>; else goto <D.26336>;
      <D.26335>:
      exc_arg = "Method contains unsupported native code";
      goto <D.26337>;
      <D.26336>:
      if (aot == 0) goto <D.26338>; else goto <D.26339>;
      <D.26338>:
      mono_lookup_pinvoke_call (method, &exc_class, &exc_arg);
      <D.26339>:
      <D.26337>:
      goto <D.26340>;
      <D.26333>:
      D.26341 = mono_lookup_internal_call (method);
      piinfo->addr = D.26341;
      <D.26340>:
      <D.26331>:
      D.26329 = piinfo->addr;
      if (D.26329 == ves_icall_System_String_ctor_RedirectToCreateString) goto <D.26342>; else goto <D.26343>;
      <D.26342>:
      D.26344 = pinvoke != 0;
      D.26345 = (long int) D.26344;
      D.26346 = __builtin_expect (D.26345, 0);
      if (D.26346 != 0) goto <D.26347>; else goto <D.26348>;
      <D.26347>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 8896, "!pinvoke");
      <D.26348>:
      D.26349 = BIT_FIELD_REF <*method, 64, 256>;
      D.26350 = D.26349 & 72057594037927936;
      D.26351 = D.26350 == 0;
      D.26352 = (long int) D.26351;
      D.26353 = __builtin_expect (D.26352, 0);
      if (D.26353 != 0) goto <D.26354>; else goto <D.26355>;
      <D.26354>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 8897, "method->string_ctor");
      <D.26355>:
      D.26356 = BIT_FIELD_REF <*sig, 64, 64>;
      D.26357 = D.26356 & 512;
      D.26358 = D.26357 == 0;
      D.26359 = (long int) D.26358;
      D.26360 = __builtin_expect (D.26359, 0);
      if (D.26360 != 0) goto <D.26361>; else goto <D.26362>;
      <D.26361>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 8898, "sig->hasthis");
      <D.26362>:
      D.26307 = method->klass;
      D.26308 = D.26307->image;
      csig = signature_dup (D.26308, sig);
      D.26363 = mono_defaults.string_class;
      D.26364 = &D.26363->byval_arg;
      csig->ret = D.26364;
      csig->pinvoke = 0;
      iter = 0B;
      goto <D.20949>;
      <D.20948>:
      D.26365 = res->name;
      D.26366 = strcmp ("CreateString", D.26365);
      if (D.26366 == 0) goto <D.26367>; else goto <D.26368>;
      <D.26367>:
      D.26369 = mono_method_signature (res);
      D.26370 = mono_metadata_signature_equal (csig, D.26369);
      if (D.26370 != 0) goto <D.26371>; else goto <D.26372>;
      <D.26371>:
      {
        struct WrapperInfo * info;

        D.26373 = res->iflags;
        D.26374 = (int) D.26373;
        D.26375 = D.26374 & 4096;
        D.26376 = D.26375 != 0;
        D.26377 = (long int) D.26376;
        D.26378 = __builtin_expect (D.26377, 0);
        if (D.26378 != 0) goto <D.26379>; else goto <D.26380>;
        <D.26379>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 8911, "!(res->iflags & METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL)");
        <D.26380>:
        D.26381 = res->flags;
        D.26382 = (int) D.26381;
        D.26383 = D.26382 & 8192;
        D.26384 = D.26383 != 0;
        D.26385 = (long int) D.26384;
        D.26386 = __builtin_expect (D.26385, 0);
        if (D.26386 != 0) goto <D.26387>; else goto <D.26388>;
        <D.26387>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 8912, "!(res->flags & METHOD_ATTRIBUTE_PINVOKE_IMPL)");
        <D.26388>:
        D.26307 = method->klass;
        D.26389 = method->name;
        mb = mono_mb_new (D.26307, D.26389, 7);
        mono_mb_emit_byte (mb, 2);
        i = 1;
        goto <D.20946>;
        <D.20945>:
        i.280 = (unsigned int) i;
        mono_mb_emit_ldarg (mb, i.280);
        i = i + 1;
        <D.20946>:
        D.26391 = csig->param_count;
        D.26392 = (int) D.26391;
        if (D.26392 >= i) goto <D.20945>; else goto <D.20947>;
        <D.20947>:
        mono_mb_emit_managed_call (mb, res, 0B);
        mono_mb_emit_byte (mb, 42);
        D.26391 = csig->param_count;
        D.26392 = (int) D.26391;
        D.26393 = D.26392 + 1;
        res = mono_mb_create_and_cache (cache, method, mb, csig, D.26393);
        mono_mb_free (mb);
        info = mono_wrapper_info_create (res, 2);
        info->d.string_ctor.method = method;
        mono_marshal_set_wrapper_info (res, info);
        D.26314 = res;
        return D.26314;
      }
      <D.26372>:
      <D.26368>:
      <D.20949>:
      D.26363 = mono_defaults.string_class;
      res = mono_class_get_methods (D.26363, &iter);
      if (res != 0B) goto <D.20948>; else goto <D.20950>;
      <D.20950>:
      piinfo->addr = 0B;
      monoeg_g_log (0B, 16, "cannot find CreateString for .ctor");
      <D.26343>:
      D.26307 = method->klass;
      D.26389 = method->name;
      mb = mono_mb_new (D.26307, D.26389, 6);
      D.26394 = mb->method;
      D.26394->save_lmf = 1;
      D.26329 = piinfo->addr;
      if (D.26329 == 0B) goto <D.26395>; else goto <D.26396>;
      <D.26395>:
      if (aot == 0) goto <D.26397>; else goto <D.26398>;
      <D.26397>:
      exc_class.281 = exc_class;
      exc_arg.282 = exc_arg;
      mono_mb_emit_exception (mb, exc_class.281, exc_arg.282);
      D.26307 = method->klass;
      D.26308 = D.26307->image;
      csig = signature_dup (D.26308, sig);
      csig->pinvoke = 0;
      D.26391 = csig->param_count;
      D.26392 = (int) D.26391;
      D.26401 = D.26392 + 16;
      res = mono_mb_create_and_cache (cache, method, mb, csig, D.26401);
      mono_mb_free (mb);
      info = mono_wrapper_info_create (res, 0);
      info->d.managed_to_native.method = method;
      mono_marshal_set_wrapper_info (res, info);
      D.26314 = res;
      return D.26314;
      <D.26398>:
      <D.26396>:
      D.26319 = method->iflags;
      D.26320 = (int) D.26319;
      D.26402 = D.26320 & 4099;
      if (D.26402 != 0) goto <D.26403>; else goto <D.26404>;
      <D.26403>:
      D.26356 = BIT_FIELD_REF <*sig, 64, 64>;
      D.26357 = D.26356 & 512;
      if (D.26357 != 0) goto <D.26405>; else goto <D.26406>;
      <D.26405>:
      D.26307 = method->klass;
      D.26308 = D.26307->image;
      D.26307 = method->klass;
      csig = signature_dup_add_this (D.26308, sig, D.26307);
      goto <D.26407>;
      <D.26406>:
      D.26307 = method->klass;
      D.26308 = D.26307->image;
      csig = signature_dup (D.26308, sig);
      <D.26407>:
      D.26349 = BIT_FIELD_REF <*method, 64, 256>;
      D.26350 = D.26349 & 72057594037927936;
      if (D.26350 != 0) goto <D.26408>; else goto <D.26409>;
      <D.26408>:
      D.26363 = mono_defaults.string_class;
      D.26364 = &D.26363->byval_arg;
      csig->ret = D.26364;
      <D.26409>:
      D.26356 = BIT_FIELD_REF <*sig, 64, 64>;
      D.26357 = D.26356 & 512;
      if (D.26357 != 0) goto <D.26410>; else goto <D.26411>;
      <D.26410>:
      {
        int pos;

        mono_mb_emit_byte (mb, 2);
        D.26412 = mono_mb_emit_branch (mb, 58);
        pos = (int) D.26412;
        mono_mb_emit_exception (mb, "NullReferenceException", 0B);
        pos.283 = (unsigned int) pos;
        mono_mb_patch_branch (mb, pos.283);
        mono_mb_emit_byte (mb, 2);
      }
      <D.26411>:
      i = 0;
      goto <D.20953>;
      <D.20952>:
      D.26414 = sig->hasthis;
      D.26415 = (int) D.26414;
      D.26416 = D.26415 + i;
      D.26417 = (unsigned int) D.26416;
      mono_mb_emit_ldarg (mb, D.26417);
      i = i + 1;
      <D.20953>:
      D.26418 = sig->param_count;
      D.26419 = (int) D.26418;
      if (D.26419 > i) goto <D.20952>; else goto <D.20954>;
      <D.20954>:
      if (aot != 0) goto <D.26420>; else goto <D.26421>;
      <D.26420>:
      mono_mb_emit_byte (mb, 240);
      D.26422 = &piinfo->method;
      mono_mb_emit_op (mb, 14, D.26422);
      mono_mb_emit_calli (mb, csig);
      goto <D.26423>;
      <D.26421>:
      D.26329 = piinfo->addr;
      D.26424 = D.26329 == 0B;
      D.26425 = (long int) D.26424;
      D.26426 = __builtin_expect (D.26425, 0);
      if (D.26426 != 0) goto <D.26427>; else goto <D.26428>;
      <D.26427>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 9005, "piinfo->addr");
      <D.26428>:
      D.26329 = piinfo->addr;
      mono_mb_emit_native_call (mb, csig, D.26329);
      <D.26423>:
      if (check_exceptions != 0) goto <D.26429>; else goto <D.26430>;
      <D.26429>:
      emit_thread_interrupt_checkpoint (mb);
      <D.26430>:
      mono_mb_emit_byte (mb, 42);
      D.26307 = method->klass;
      D.26308 = D.26307->image;
      csig = signature_dup (D.26308, csig);
      csig->pinvoke = 0;
      D.26391 = csig->param_count;
      D.26392 = (int) D.26391;
      D.26401 = D.26392 + 16;
      res = mono_mb_create_and_cache (cache, method, mb, csig, D.26401);
      info = mono_wrapper_info_create (res, 0);
      info->d.managed_to_native.method = method;
      mono_marshal_set_wrapper_info (res, info);
      mono_mb_free (mb);
      D.26314 = res;
      return D.26314;
      <D.26404>:
      D.26431 = pinvoke == 0;
      D.26432 = (long int) D.26431;
      D.26433 = __builtin_expect (D.26432, 0);
      if (D.26433 != 0) goto <D.26434>; else goto <D.26435>;
      <D.26434>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 9026, "pinvoke");
      <D.26435>:
      if (aot == 0) goto <D.26436>; else goto <D.26437>;
      <D.26436>:
      D.26329 = piinfo->addr;
      D.26424 = D.26329 == 0B;
      D.26425 = (long int) D.26424;
      D.26426 = __builtin_expect (D.26425, 0);
      if (D.26426 != 0) goto <D.26438>; else goto <D.26439>;
      <D.26438>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 9028, "piinfo->addr");
      <D.26439>:
      <D.26437>:
      D.26418 = sig->param_count;
      D.26419 = (int) D.26418;
      D.26440 = D.26419 + 1;
      D.26441 = (long unsigned int) D.26440;
      D.26442 = D.26441 * 8;
      mspecs = monoeg_malloc (D.26442);
      mono_method_get_marshal_info (method, mspecs);
      D.26394 = mb->method;
      D.26443 = D.26394->klass;
      D.26444 = D.26443->image;
      D.26329 = piinfo->addr;
      mono_marshal_emit_native_wrapper (D.26444, mb, sig, piinfo, mspecs, D.26329, aot, check_exceptions, 0);
      D.26307 = method->klass;
      D.26308 = D.26307->image;
      csig = signature_dup (D.26308, sig);
      csig->pinvoke = 0;
      D.26391 = csig->param_count;
      D.26392 = (int) D.26391;
      D.26401 = D.26392 + 16;
      res = mono_mb_create_and_cache (cache, method, mb, csig, D.26401);
      mono_mb_free (mb);
      info = mono_wrapper_info_create (res, 0);
      info->d.managed_to_native.method = method;
      mono_marshal_set_wrapper_info (res, info);
      D.26418 = sig->param_count;
      i = (int) D.26418;
      goto <D.20956>;
      <D.20955>:
      D.26445 = (long unsigned int) i;
      D.26446 = D.26445 * 8;
      D.26447 = mspecs + D.26446;
      D.26448 = *D.26447;
      if (D.26448 != 0B) goto <D.26449>; else goto <D.26450>;
      <D.26449>:
      D.26445 = (long unsigned int) i;
      D.26446 = D.26445 * 8;
      D.26447 = mspecs + D.26446;
      D.26448 = *D.26447;
      mono_metadata_free_marshal_spec (D.26448);
      <D.26450>:
      i = i + -1;
      <D.20956>:
      if (i >= 0) goto <D.20955>; else goto <D.20957>;
      <D.20957>:
      monoeg_g_free (mspecs);
      D.26314 = res;
      return D.26314;
    }
  finally
    {
      iter = {CLOBBER};
      exc_class = {CLOBBER};
      exc_arg = {CLOBBER};
    }
}


__attribute__((visibility ("hidden")))
mono_marshal_get_native_func_wrapper (struct MonoImage * image, struct MonoMethodSignature * sig, struct MonoMethodPInvoke * piinfo, struct MonoMarshalSpec * * mspecs, void * func)
{
  struct GHashTable * * D.26453;
  struct MonoMethod * D.26456;
  struct MonoClass * D.26457;
  struct MonoMethod * D.26458;
  short unsigned int D.26459;
  int D.26460;
  int D.26461;
  struct MonoMethodSignature * csig;
  struct MonoMethodBuilder * mb;
  struct MonoMethod * res;
  struct GHashTable * cache;
  char * name;

  D.26453 = &image->native_wrapper_cache;
  cache = get_cache (D.26453, mono_aligned_addr_hash, 0B);
  res = mono_marshal_find_in_cache (cache, func);
  if (res != 0B) goto <D.26454>; else goto <D.26455>;
  <D.26454>:
  D.26456 = res;
  return D.26456;
  <D.26455>:
  name = monoeg_g_strdup_printf ("wrapper_native_%p", func);
  D.26457 = mono_defaults.object_class;
  mb = mono_mb_new (D.26457, name, 6);
  D.26458 = mb->method;
  D.26458->save_lmf = 1;
  mono_marshal_emit_native_wrapper (image, mb, sig, piinfo, mspecs, func, 0, 1, 0);
  csig = signature_dup (image, sig);
  csig->pinvoke = 0;
  D.26459 = csig->param_count;
  D.26460 = (int) D.26459;
  D.26461 = D.26460 + 16;
  res = mono_mb_create_and_cache (cache, func, mb, csig, D.26461);
  mono_mb_free (mb);
  mono_marshal_set_wrapper_info (res, 0B);
  D.26456 = res;
  return D.26456;
}


__attribute__((visibility ("hidden")))
mono_marshal_get_native_func_wrapper_aot (struct MonoClass * klass)
{
  struct MonoClass * D.26463;
  struct GHashTable * * D.26464;
  struct MonoMethod * D.26467;
  struct MonoMethodSignature * D.26468;
  short unsigned int D.26469;
  int D.26470;
  int D.26471;
  long unsigned int D.26472;
  long unsigned int D.26473;
  struct MonoMethodSignature * D.26474;
  struct MonoMethod * D.26475;
  long unsigned int D.26476;
  long unsigned int D.26477;
  _Bool D.26478;
  long int D.26479;
  long int D.26480;
  struct MonoClass * D.26483;
  short unsigned int D.26484;
  int D.26485;
  int D.26486;
  struct MonoMethodSignature * D.26487;
  short unsigned int D.26488;
  long unsigned int D.26489;
  long unsigned int D.26490;
  struct MonoMarshalSpec * * D.26491;
  struct MonoMarshalSpec * D.26492;
  struct MonoMethodSignature * sig;
  struct MonoMethodSignature * csig;
  struct MonoMethodBuilder * mb;
  struct MonoMethod * res;
  struct GHashTable * cache;
  char * name;
  struct WrapperInfo * info;
  struct MonoMethodPInvoke mpiinfo;
  struct MonoMethodPInvoke * piinfo;
  struct MonoMarshalSpec * * mspecs;
  struct MonoMethod * invoke;
  struct MonoImage * image;
  int i;

  try
    {
      piinfo = &mpiinfo;
      invoke = mono_get_delegate_invoke (klass);
      D.26463 = invoke->klass;
      image = D.26463->image;
      D.26464 = &image->native_func_wrapper_aot_cache;
      cache = get_cache (D.26464, mono_aligned_addr_hash, 0B);
      res = mono_marshal_find_in_cache (cache, invoke);
      if (res != 0B) goto <D.26465>; else goto <D.26466>;
      <D.26465>:
      D.26467 = res;
      return D.26467;
      <D.26466>:
      memset (&mpiinfo, 0, 56);
      parse_unmanaged_function_pointer_attr (klass, &mpiinfo);
      D.26468 = mono_method_signature (invoke);
      D.26469 = D.26468->param_count;
      D.26470 = (int) D.26469;
      D.26471 = D.26470 + 1;
      D.26472 = (long unsigned int) D.26471;
      D.26473 = D.26472 * 8;
      mspecs = monoeg_malloc0 (D.26473);
      mono_method_get_marshal_info (invoke, mspecs);
      D.26474 = mono_method_signature (invoke);
      sig = mono_metadata_signature_dup (D.26474);
      sig->hasthis = 0;
      name = monoeg_g_strdup_printf ("wrapper_aot_native");
      D.26463 = invoke->klass;
      mb = mono_mb_new (D.26463, name, 6);
      D.26475 = mb->method;
      D.26475->save_lmf = 1;
      mono_marshal_emit_native_wrapper (image, mb, sig, piinfo, mspecs, 0B, 0, 1, 1);
      D.26476 = BIT_FIELD_REF <*sig, 64, 64>;
      D.26477 = D.26476 & 512;
      D.26478 = D.26477 != 0;
      D.26479 = (long int) D.26478;
      D.26480 = __builtin_expect (D.26479, 0);
      if (D.26480 != 0) goto <D.26481>; else goto <D.26482>;
      <D.26481>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 9148, "!sig->hasthis");
      <D.26482>:
      D.26483 = mono_defaults.int_class;
      csig = signature_dup_add_this (image, sig, D.26483);
      csig->pinvoke = 0;
      D.26484 = csig->param_count;
      D.26485 = (int) D.26484;
      D.26486 = D.26485 + 16;
      res = mono_mb_create_and_cache (cache, invoke, mb, csig, D.26486);
      mono_mb_free (mb);
      info = mono_wrapper_info_create (res, 16);
      info->d.managed_to_native.method = invoke;
      mono_marshal_set_wrapper_info (res, info);
      D.26487 = mono_method_signature (invoke);
      D.26488 = D.26487->param_count;
      i = (int) D.26488;
      goto <D.20987>;
      <D.20986>:
      D.26489 = (long unsigned int) i;
      D.26490 = D.26489 * 8;
      D.26491 = mspecs + D.26490;
      D.26492 = *D.26491;
      if (D.26492 != 0B) goto <D.26493>; else goto <D.26494>;
      <D.26493>:
      D.26489 = (long unsigned int) i;
      D.26490 = D.26489 * 8;
      D.26491 = mspecs + D.26490;
      D.26492 = *D.26491;
      mono_metadata_free_marshal_spec (D.26492);
      <D.26494>:
      i = i + -1;
      <D.20987>:
      if (i >= 0) goto <D.20986>; else goto <D.20988>;
      <D.20988>:
      monoeg_g_free (mspecs);
      monoeg_g_free (sig);
      D.26467 = res;
      return D.26467;
    }
  finally
    {
      mpiinfo = {CLOBBER};
    }
}


__attribute__((visibility ("hidden")))
mono_marshal_emit_managed_wrapper (struct MonoMethodBuilder * mb, struct MonoMethodSignature * invoke_sig, struct MonoMarshalSpec * * mspecs, struct EmitMarshalContext * m, struct MonoMethod * method, uint32_t target_handle)
{
  struct MonoClass * D.26497;
  struct MonoType * D.26498;
  struct MonoClass * D.26499;
  struct MonoType * D.26500;
  long unsigned int D.26501;
  long unsigned int D.26502;
  short unsigned int D.26505;
  short unsigned int D.26506;
  int D.26509;
  int D.26510;
  int D.26511;
  _Bool D.26512;
  long int D.26513;
  long int D.26514;
  struct MonoType * * D.26517;
  struct MonoType * * D.26518;
  int D.26519;
  long unsigned int D.26520;
  long unsigned int D.26521;
  short unsigned int D.26522;
  short unsigned int D.26523;
  struct MonoType * D.26524;
  int D.26525;
  long unsigned int D.26528;
  long unsigned int D.26529;
  unsigned char D.26530;
  int D.26531;
  long unsigned int D.26532;
  long unsigned int D.26533;
  int * D.26534;
  struct MonoType * D.26535;
  sizetype D.26536;
  sizetype D.26537;
  sizetype D.26538;
  struct MonoMarshalSpec * * D.26539;
  struct MonoMarshalSpec * D.26540;
  struct MonoType * * D.26541;
  int D.26542;
  int target_handle.284;
  int D.26552;
  long unsigned int D.26555;
  long unsigned int D.26556;
  unsigned int D.26559;
  unsigned int i.285;
  struct MonoMarshalSpec * D.26565;
  <unnamed type> D.26567;
  long unsigned int D.26569;
  long unsigned int D.26570;
  unsigned char D.26573;
  int D.26574;
  <unnamed type> D.26579;
  long unsigned int D.26581;
  long unsigned int D.26582;
  unsigned char D.26585;
  int D.26586;
  struct MonoType * D.26589;
  short unsigned int D.26590;
  int D.26591;
  int D.26592;
  int D.26595;
  unsigned int D.26598;
  struct MonoClass * D.26599;
  int D.26601;
  struct MonoMethodSignature * sig;
  struct MonoMethodSignature * csig;
  int i;
  int * tmp_locals;
  gboolean closed;

  closed = 0;
  sig = m->sig;
  csig = m->csig;
  D.26497 = mono_defaults.int_class;
  D.26498 = &D.26497->byval_arg;
  mono_mb_add_local (mb, D.26498);
  D.26497 = mono_defaults.int_class;
  D.26498 = &D.26497->byval_arg;
  mono_mb_add_local (mb, D.26498);
  D.26499 = mono_defaults.boolean_class;
  D.26500 = &D.26499->byval_arg;
  mono_mb_add_local (mb, D.26500);
  D.26501 = BIT_FIELD_REF <*sig, 64, 64>;
  D.26502 = D.26501 & 512;
  if (D.26502 == 0) goto <D.26503>; else goto <D.26504>;
  <D.26503>:
  D.26505 = sig->param_count;
  D.26506 = invoke_sig->param_count;
  if (D.26505 != D.26506) goto <D.26507>; else goto <D.26508>;
  <D.26507>:
  D.26505 = sig->param_count;
  D.26509 = (int) D.26505;
  D.26506 = invoke_sig->param_count;
  D.26510 = (int) D.26506;
  D.26511 = D.26510 + 1;
  D.26512 = D.26509 != D.26511;
  D.26513 = (long int) D.26512;
  D.26514 = __builtin_expect (D.26513, 0);
  if (D.26514 != 0) goto <D.26515>; else goto <D.26516>;
  <D.26515>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 9229, "sig->param_count == invoke_sig->param_count + 1");
  <D.26516>:
  closed = 1;
  sig = mono_metadata_signature_dup (sig);
  D.26517 = &sig->params[0];
  D.26518 = &sig->params[1];
  D.26505 = sig->param_count;
  D.26509 = (int) D.26505;
  D.26519 = D.26509 + -1;
  D.26520 = (long unsigned int) D.26519;
  D.26521 = D.26520 * 8;
  memmove (D.26517, D.26518, D.26521);
  D.26505 = sig->param_count;
  D.26522 = D.26505;
  D.26523 = D.26522 + 65535;
  sig->param_count = D.26523;
  <D.26508>:
  <D.26504>:
  D.26524 = sig->ret;
  D.26525 = mono_type_is_void (D.26524);
  if (D.26525 == 0) goto <D.26526>; else goto <D.26527>;
  <D.26526>:
  D.26524 = sig->ret;
  mono_mb_add_local (mb, D.26524);
  <D.26527>:
  mono_mb_emit_icon (mb, 0);
  mono_mb_emit_stloc (mb, 2);
  mono_mb_emit_byte (mb, 240);
  mono_mb_emit_byte (mb, 17);
  D.26505 = sig->param_count;
  D.26528 = (long unsigned int) D.26505;
  D.26529 = D.26528 * 4;
  tmp_locals = __builtin_alloca (D.26529);
  i = 0;
  goto <D.21013>;
  <D.21012>:
  {
    struct MonoType * t;

    t = sig->params[i];
    D.26530 = t->type;
    D.26531 = (int) D.26530;
    switch (D.26531) <default: <D.21011>, case 2: <D.21009>, case 14: <D.21008>, case 17: <D.21005>, case 18: <D.21004>, case 20: <D.21006>, case 28: <D.21003>, case 29: <D.21007>>
    <D.21003>:
    <D.21004>:
    <D.21005>:
    <D.21006>:
    <D.21007>:
    <D.21008>:
    <D.21009>:
    D.26532 = (long unsigned int) i;
    D.26533 = D.26532 * 4;
    D.26534 = tmp_locals + D.26533;
    D.26535 = sig->params[i];
    D.26536 = (sizetype) i;
    D.26537 = D.26536 + 1;
    D.26538 = D.26537 * 8;
    D.26539 = mspecs + D.26538;
    D.26540 = *D.26539;
    D.26541 = &csig->params[i];
    D.26542 = emit_marshal (m, i, D.26535, D.26540, 0, D.26541, 4);
    *D.26534 = D.26542;
    goto <D.21010>;
    <D.21011>:
    D.26532 = (long unsigned int) i;
    D.26533 = D.26532 * 4;
    D.26534 = tmp_locals + D.26533;
    *D.26534 = 0;
    goto <D.21010>;
    <D.21010>:
  }
  i = i + 1;
  <D.21013>:
  D.26505 = sig->param_count;
  D.26509 = (int) D.26505;
  if (D.26509 > i) goto <D.21012>; else goto <D.21014>;
  <D.21014>:
  emit_thread_interrupt_checkpoint (mb);
  D.26501 = BIT_FIELD_REF <*sig, 64, 64>;
  D.26502 = D.26501 & 512;
  if (D.26502 != 0) goto <D.26543>; else goto <D.26544>;
  <D.26543>:
  if (target_handle != 0) goto <D.26545>; else goto <D.26546>;
  <D.26545>:
  target_handle.284 = (int) target_handle;
  mono_mb_emit_icon (mb, target_handle.284);
  mono_mb_emit_icall (mb, mono_gchandle_get_target);
  goto <D.26548>;
  <D.26546>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "marshal.c", 9282);
  <D.26548>:
  goto <D.26549>;
  <D.26544>:
  if (closed != 0) goto <D.26550>; else goto <D.26551>;
  <D.26550>:
  target_handle.284 = (int) target_handle;
  mono_mb_emit_icon (mb, target_handle.284);
  mono_mb_emit_icall (mb, mono_gchandle_get_target);
  <D.26551>:
  <D.26549>:
  i = 0;
  goto <D.21017>;
  <D.21016>:
  {
    struct MonoType * t;

    t = sig->params[i];
    D.26532 = (long unsigned int) i;
    D.26533 = D.26532 * 4;
    D.26534 = tmp_locals + D.26533;
    D.26552 = *D.26534;
    if (D.26552 != 0) goto <D.26553>; else goto <D.26554>;
    <D.26553>:
    D.26555 = BIT_FIELD_REF <*t, 64, 64>;
    D.26556 = D.26555 & 8589934592;
    if (D.26556 != 0) goto <D.26557>; else goto <D.26558>;
    <D.26557>:
    D.26532 = (long unsigned int) i;
    D.26533 = D.26532 * 4;
    D.26534 = tmp_locals + D.26533;
    D.26552 = *D.26534;
    D.26559 = (unsigned int) D.26552;
    mono_mb_emit_ldloc_addr (mb, D.26559);
    goto <D.26560>;
    <D.26558>:
    D.26532 = (long unsigned int) i;
    D.26533 = D.26532 * 4;
    D.26534 = tmp_locals + D.26533;
    D.26552 = *D.26534;
    D.26559 = (unsigned int) D.26552;
    mono_mb_emit_ldloc (mb, D.26559);
    <D.26560>:
    goto <D.26561>;
    <D.26554>:
    i.285 = (unsigned int) i;
    mono_mb_emit_ldarg (mb, i.285);
    <D.26561>:
  }
  i = i + 1;
  <D.21017>:
  D.26505 = sig->param_count;
  D.26509 = (int) D.26505;
  if (D.26509 > i) goto <D.21016>; else goto <D.21018>;
  <D.21018>:
  mono_mb_emit_managed_call (mb, method, 0B);
  D.26565 = *mspecs;
  if (D.26565 != 0B) goto <D.26566>; else goto <D.26563>;
  <D.26566>:
  D.26565 = *mspecs;
  D.26567 = D.26565->native;
  if (D.26567 == 44) goto <D.26568>; else goto <D.26563>;
  <D.26568>:
  D.26524 = sig->ret;
  D.26565 = *mspecs;
  emit_marshal (m, 0, D.26524, D.26565, 0, 0B, 6);
  goto <D.26564>;
  <D.26563>:
  D.26524 = sig->ret;
  D.26569 = BIT_FIELD_REF <*D.26524, 64, 64>;
  D.26570 = D.26569 & 8589934592;
  if (D.26570 == 0) goto <D.26571>; else goto <D.26572>;
  <D.26571>:
  D.26524 = sig->ret;
  D.26573 = D.26524->type;
  D.26574 = (int) D.26573;
  switch (D.26574) <default: <D.21041>, case 1: <D.21019>, case 2: <D.21021>, case 3: <D.21024>, case 4: <D.21022>, case 5: <D.21023>, case 6: <D.21025>, case 7: <D.21026>, case 8: <D.21027>, case 9: <D.21028>, case 10: <D.21034>, case 11: <D.21035>, case 12: <D.21032>, case 13: <D.21033>, case 14: <D.21037>, case 15: <D.21031>, case 17: <D.21038>, case 18: <D.21039>, case 24: <D.21029>, case 25: <D.21030>, case 28: <D.21036>, case 29: <D.21040>>
  <D.21019>:
  goto <D.21020>;
  <D.21021>:
  <D.21022>:
  <D.21023>:
  <D.21024>:
  <D.21025>:
  <D.21026>:
  <D.21027>:
  <D.21028>:
  <D.21029>:
  <D.21030>:
  <D.21031>:
  <D.21032>:
  <D.21033>:
  <D.21034>:
  <D.21035>:
  <D.21036>:
  mono_mb_emit_stloc (mb, 3);
  goto <D.21020>;
  <D.21037>:
  D.26497 = mono_defaults.int_class;
  D.26498 = &D.26497->byval_arg;
  csig->ret = D.26498;
  D.26524 = sig->ret;
  D.26565 = *mspecs;
  emit_marshal (m, 0, D.26524, D.26565, 0, 0B, 6);
  goto <D.21020>;
  <D.21038>:
  <D.21039>:
  <D.21040>:
  D.26524 = sig->ret;
  D.26565 = *mspecs;
  emit_marshal (m, 0, D.26524, D.26565, 0, 0B, 6);
  goto <D.21020>;
  <D.21041>:
  D.26524 = sig->ret;
  D.26573 = D.26524->type;
  D.26574 = (int) D.26573;
  monoeg_g_log (0B, 16, "return type 0x%02x unknown", D.26574);
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "marshal.c", 9339);
  <D.21020>:
  goto <D.26575>;
  <D.26572>:
  mono_mb_emit_stloc (mb, 3);
  <D.26575>:
  <D.26564>:
  i = 0;
  goto <D.21056>;
  <D.21055>:
  {
    struct MonoType * t;
    struct MonoMarshalSpec * spec;

    t = sig->params[i];
    D.26536 = (sizetype) i;
    D.26537 = D.26536 + 1;
    D.26538 = D.26537 * 8;
    D.26539 = mspecs + D.26538;
    spec = *D.26539;
    if (spec != 0B) goto <D.26578>; else goto <D.26576>;
    <D.26578>:
    D.26579 = spec->native;
    if (D.26579 == 44) goto <D.26580>; else goto <D.26576>;
    <D.26580>:
    D.26536 = (sizetype) i;
    D.26537 = D.26536 + 1;
    D.26538 = D.26537 * 8;
    D.26539 = mspecs + D.26538;
    D.26540 = *D.26539;
    D.26532 = (long unsigned int) i;
    D.26533 = D.26532 * 4;
    D.26534 = tmp_locals + D.26533;
    D.26552 = *D.26534;
    emit_marshal (m, i, t, D.26540, D.26552, 0B, 5);
    goto <D.26577>;
    <D.26576>:
    D.26581 = BIT_FIELD_REF <*t, 64, 64>;
    D.26582 = D.26581 & 8589934592;
    if (D.26582 != 0) goto <D.26583>; else goto <D.26584>;
    <D.26583>:
    D.26585 = t->type;
    D.26586 = (int) D.26585;
    switch (D.26586) <default: <D.26587>, case 2: <D.21048>, case 14: <D.21047>, case 17: <D.21045>, case 18: <D.21044>, case 28: <D.21046>>
    <D.21044>:
    <D.21045>:
    <D.21046>:
    <D.21047>:
    <D.21048>:
    D.26536 = (sizetype) i;
    D.26537 = D.26536 + 1;
    D.26538 = D.26537 * 8;
    D.26539 = mspecs + D.26538;
    D.26540 = *D.26539;
    D.26532 = (long unsigned int) i;
    D.26533 = D.26532 * 4;
    D.26534 = tmp_locals + D.26533;
    D.26552 = *D.26534;
    emit_marshal (m, i, t, D.26540, D.26552, 0B, 5);
    goto <D.21049>;
    <D.26587>:
    <D.21049>:
    goto <D.26588>;
    <D.26584>:
    D.26589 = invoke_sig->params[i];
    D.26590 = D.26589->attrs;
    D.26591 = (int) D.26590;
    D.26592 = D.26591 & 2;
    if (D.26592 != 0) goto <D.26593>; else goto <D.26594>;
    <D.26593>:
    D.26585 = t->type;
    D.26586 = (int) D.26585;
    switch (D.26586) <default: <D.21054>, case 17: <D.21052>, case 18: <D.21051>, case 29: <D.21050>>
    <D.21050>:
    <D.21051>:
    <D.21052>:
    D.26589 = invoke_sig->params[i];
    D.26536 = (sizetype) i;
    D.26537 = D.26536 + 1;
    D.26538 = D.26537 * 8;
    D.26539 = mspecs + D.26538;
    D.26540 = *D.26539;
    D.26532 = (long unsigned int) i;
    D.26533 = D.26532 * 4;
    D.26534 = tmp_locals + D.26533;
    D.26552 = *D.26534;
    emit_marshal (m, i, D.26589, D.26540, D.26552, 0B, 5);
    goto <D.21053>;
    <D.21054>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "marshal.c", 9373);
    <D.21053>:
    <D.26594>:
    <D.26588>:
    <D.26577>:
  }
  i = i + 1;
  <D.21056>:
  D.26505 = sig->param_count;
  D.26509 = (int) D.26505;
  if (D.26509 > i) goto <D.21055>; else goto <D.21057>;
  <D.21057>:
  mono_mb_emit_byte (mb, 240);
  mono_mb_emit_byte (mb, 18);
  D.26595 = m->retobj_var;
  if (D.26595 != 0) goto <D.26596>; else goto <D.26597>;
  <D.26596>:
  D.26595 = m->retobj_var;
  D.26598 = (unsigned int) D.26595;
  mono_mb_emit_ldloc (mb, D.26598);
  mono_mb_emit_byte (mb, 240);
  D.26599 = m->retobj_class;
  mono_mb_emit_op (mb, 5, D.26599);
  goto <D.26600>;
  <D.26597>:
  D.26524 = sig->ret;
  D.26601 = mono_type_is_void (D.26524);
  if (D.26601 == 0) goto <D.26602>; else goto <D.26603>;
  <D.26602>:
  mono_mb_emit_ldloc (mb, 3);
  <D.26603>:
  mono_mb_emit_byte (mb, 42);
  <D.26600>:
  if (closed != 0) goto <D.26604>; else goto <D.26605>;
  <D.26604>:
  monoeg_g_free (sig);
  <D.26605>:
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__, __nothrow__, __leaf__))
memmove (void * __dest, const void * __src, size_t __len)
{
  void * D.26609;
  long unsigned int D.26610;

  D.26610 = __builtin_object_size (__dest, 0);
  D.26609 = __builtin___memmove_chk (__dest, __src, __len, D.26610);
  return D.26609;
}


__attribute__((visibility ("hidden")))
mono_marshal_get_managed_wrapper (struct MonoMethod * method, struct MonoClass * delegate_klass, uint32_t target_handle)
{
  _Bool D.26612;
  long int D.26613;
  long int D.26614;
  struct MonoMethodSignature * D.26617;
  long unsigned int D.26618;
  long unsigned int D.26619;
  _Bool D.26620;
  long int D.26621;
  long int D.26622;
  struct MonoClass * D.26625;
  struct MonoImage * D.26626;
  struct GHashTable * * D.26627;
  struct MonoMethod * D.26632;
  struct MonoMethodSignature * D.26633;
  short unsigned int D.26634;
  int D.26635;
  int D.26636;
  long unsigned int D.26637;
  long unsigned int D.26638;
  const char * D.26639;
  long unsigned int D.26640;
  void * D.26641;
  struct MonoClass * UnmanagedFunctionPointerAttribute.286;
  struct MonoImage * D.26648;
  struct MonoClass * UnmanagedFunctionPointerAttribute.287;
  struct MonoMethod * D.26654;
  int D.26655;
  int D.26658;
  struct MonoMethod * D.26661;
  const mono_byte * D.26662;
  unsigned int D.26663;
  int D.26664;
  _Bool D.26665;
  long int D.26666;
  long int D.26667;
  struct MonoArray * typed_args.288;
  long unsigned int D.26671;
  _Bool D.26672;
  long int D.26673;
  long int D.26674;
  char * D.26677;
  void * D.26678;
  struct CattrNamedArg * arginfo.289;
  long unsigned int D.26680;
  long unsigned int D.26681;
  struct MonoArray * named_args.290;
  long unsigned int D.26683;
  char * D.26684;
  struct MonoClassField * D.26685;
  _Bool D.26686;
  long int D.26687;
  long int D.26688;
  const char * D.26691;
  int D.26692;
  void * D.26695;
  int D.26697;
  void * D.26700;
  int D.26702;
  void * D.26705;
  int D.26707;
  void * D.26710;
  long unsigned int D.26712;
  int D.26713;
  signed short D.26714;
  signed short iftmp.291;
  int D.26718;
  unsigned short D.26719;
  unsigned short D.26720;
  signed short D.26722;
  signed short D.26723;
  signed short D.26724;
  short unsigned int D.26725;
  unsigned char D.26726;
  unsigned char D.26727;
  <unnamed-unsigned:6> D.26728;
  int D.26731;
  short unsigned int D.26736;
  int D.26737;
  int D.26738;
  struct MonoMethodSignature * D.26740;
  short unsigned int D.26741;
  long unsigned int D.26742;
  struct MonoMarshalSpec * * D.26743;
  struct MonoMarshalSpec * D.26744;
  static struct MonoClass * UnmanagedFunctionPointerAttribute;
  struct MonoMethodSignature * sig;
  struct MonoMethodSignature * csig;
  struct MonoMethodSignature * invoke_sig;
  struct MonoMethodBuilder * mb;
  struct MonoMethod * res;
  struct MonoMethod * invoke;
  struct MonoMarshalSpec * * mspecs;
  struct MonoMethodPInvoke piinfo;
  struct GHashTable * cache;
  int i;
  struct EmitMarshalContext m;

  try
    {
      D.26612 = method == 0B;
      D.26613 = (long int) D.26612;
      D.26614 = __builtin_expect (D.26613, 0);
      if (D.26614 != 0) goto <D.26615>; else goto <D.26616>;
      <D.26615>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 9450, "method != NULL");
      <D.26616>:
      D.26617 = mono_method_signature (method);
      D.26618 = BIT_FIELD_REF <*D.26617, 64, 64>;
      D.26619 = D.26618 & 128;
      D.26620 = D.26619 != 0;
      D.26621 = (long int) D.26620;
      D.26622 = __builtin_expect (D.26621, 0);
      if (D.26622 != 0) goto <D.26623>; else goto <D.26624>;
      <D.26623>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 9451, "!mono_method_signature (method)->pinvoke");
      <D.26624>:
      D.26625 = method->klass;
      D.26626 = D.26625->image;
      D.26627 = &D.26626->managed_wrapper_cache;
      cache = get_cache (D.26627, mono_aligned_addr_hash, 0B);
      if (target_handle == 0) goto <D.26628>; else goto <D.26629>;
      <D.26628>:
      res = mono_marshal_find_in_cache (cache, method);
      if (res != 0B) goto <D.26630>; else goto <D.26631>;
      <D.26630>:
      D.26632 = res;
      return D.26632;
      <D.26631>:
      <D.26629>:
      invoke = mono_get_delegate_invoke (delegate_klass);
      invoke_sig = mono_method_signature (invoke);
      D.26633 = mono_method_signature (invoke);
      D.26634 = D.26633->param_count;
      D.26635 = (int) D.26634;
      D.26636 = D.26635 + 1;
      D.26637 = (long unsigned int) D.26636;
      D.26638 = D.26637 * 8;
      mspecs = monoeg_malloc0 (D.26638);
      mono_method_get_marshal_info (invoke, mspecs);
      sig = mono_method_signature (method);
      D.26625 = method->klass;
      D.26639 = method->name;
      mb = mono_mb_new (D.26625, D.26639, 5);
      D.26640 = (long unsigned int) target_handle;
      D.26641 = (void *) D.26640;
      mono_mb_add_data (mb, D.26641);
      if (target_handle != 0) goto <D.26642>; else goto <D.26643>;
      <D.26642>:
      csig = mono_metadata_signature_dup (invoke_sig);
      goto <D.26644>;
      <D.26643>:
      D.26625 = method->klass;
      D.26626 = D.26625->image;
      csig = signature_dup (D.26626, invoke_sig);
      <D.26644>:
      csig->hasthis = 0;
      csig->pinvoke = 1;
      m.mb = mb;
      m.sig = sig;
      m.piinfo = 0B;
      m.retobj_var = 0;
      m.csig = csig;
      D.26625 = method->klass;
      D.26626 = D.26625->image;
      m.image = D.26626;
      mono_marshal_set_callconv_from_modopt (invoke, csig);
      UnmanagedFunctionPointerAttribute.286 = UnmanagedFunctionPointerAttribute;
      if (UnmanagedFunctionPointerAttribute.286 == 0B) goto <D.26646>; else goto <D.26647>;
      <D.26646>:
      D.26648 = mono_defaults.corlib;
      UnmanagedFunctionPointerAttribute.287 = mono_class_from_name (D.26648, "System.Runtime.InteropServices", "UnmanagedFunctionPointerAttribute");
      UnmanagedFunctionPointerAttribute = UnmanagedFunctionPointerAttribute.287;
      <D.26647>:
      UnmanagedFunctionPointerAttribute.286 = UnmanagedFunctionPointerAttribute;
      if (UnmanagedFunctionPointerAttribute.286 != 0B) goto <D.26650>; else goto <D.26651>;
      <D.26650>:
      {
        struct MonoCustomAttrInfo * cinfo;
        struct MonoCustomAttrEntry * attr;

        cinfo = mono_custom_attrs_from_class (delegate_klass);
        attr = 0B;
        if (cinfo != 0B) goto <D.26652>; else goto <D.26653>;
        <D.26652>:
        i = 0;
        goto <D.21090>;
        <D.21089>:
        {
          struct MonoClass * ctor_class;

          D.26654 = cinfo->attrs[i].ctor;
          ctor_class = D.26654->klass;
          UnmanagedFunctionPointerAttribute.286 = UnmanagedFunctionPointerAttribute;
          D.26655 = mono_class_has_parent (ctor_class, UnmanagedFunctionPointerAttribute.286);
          if (D.26655 != 0) goto <D.26656>; else goto <D.26657>;
          <D.26656>:
          attr = &cinfo->attrs[i];
          goto <D.21088>;
          <D.26657>:
        }
        i = i + 1;
        <D.21090>:
        D.26658 = cinfo->num_attrs;
        if (D.26658 > i) goto <D.21089>; else goto <D.21088>;
        <D.21088>:
        <D.26653>:
        if (attr != 0B) goto <D.26659>; else goto <D.26660>;
        <D.26659>:
        {
          struct MonoArray * typed_args;
          struct MonoArray * named_args;
          struct CattrNamedArg * arginfo;
          struct MonoObject * o;
          gint32 call_conv;
          gint32 charset;
          MonoBoolean set_last_error;
          MonoBoolean best_fit_mapping;
          MonoBoolean throw_on_unmappable;
          struct MonoError error;

          try
            {
              charset = 0;
              set_last_error = 0;
              best_fit_mapping = 0;
              throw_on_unmappable = 0;
              D.26648 = mono_defaults.corlib;
              D.26661 = attr->ctor;
              D.26662 = attr->data;
              D.26663 = attr->data_size;
              mono_reflection_create_custom_attr_data_args (D.26648, D.26661, D.26662, D.26663, &typed_args, &named_args, &arginfo, &error);
              D.26664 = mono_error_ok (&error);
              D.26665 = D.26664 == 0;
              D.26666 = (long int) D.26665;
              D.26667 = __builtin_expect (D.26666, 0);
              if (D.26667 != 0) goto <D.26668>; else goto <D.26669>;
              <D.26668>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 9530, "mono_error_ok (&error)");
              <D.26669>:
              typed_args.288 = typed_args;
              D.26671 = mono_array_length (typed_args.288);
              D.26672 = D.26671 != 1;
              D.26673 = (long int) D.26672;
              D.26674 = __builtin_expect (D.26673, 0);
              if (D.26674 != 0) goto <D.26675>; else goto <D.26676>;
              <D.26675>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 9531, "mono_array_length (typed_args) == 1");
              <D.26676>:
              typed_args.288 = typed_args;
              D.26677 = mono_array_addr_with_size (typed_args.288, 8, 0);
              o = MEM[(struct MonoObject * *)D.26677];
              D.26678 = mono_object_unbox (o);
              call_conv = MEM[(gint32 *)D.26678];
              i = 0;
              goto <D.21103>;
              <D.21102>:
              {
                struct CattrNamedArg * narg;

                arginfo.289 = arginfo;
                D.26680 = (long unsigned int) i;
                D.26681 = D.26680 * 24;
                narg = arginfo.289 + D.26681;
                named_args.290 = named_args;
                D.26683 = (long unsigned int) i;
                D.26684 = mono_array_addr_with_size (named_args.290, 8, D.26683);
                o = MEM[(struct MonoObject * *)D.26684];
                D.26685 = narg->field;
                D.26686 = D.26685 == 0B;
                D.26687 = (long int) D.26686;
                D.26688 = __builtin_expect (D.26687, 0);
                if (D.26688 != 0) goto <D.26689>; else goto <D.26690>;
                <D.26689>:
                monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 9543, "narg->field");
                <D.26690>:
                D.26685 = narg->field;
                D.26691 = D.26685->name;
                D.26692 = strcmp (D.26691, "CharSet");
                if (D.26692 == 0) goto <D.26693>; else goto <D.26694>;
                <D.26693>:
                D.26695 = mono_object_unbox (o);
                charset = MEM[(gint32 *)D.26695];
                goto <D.26696>;
                <D.26694>:
                D.26685 = narg->field;
                D.26691 = D.26685->name;
                D.26697 = strcmp (D.26691, "SetLastError");
                if (D.26697 == 0) goto <D.26698>; else goto <D.26699>;
                <D.26698>:
                D.26700 = mono_object_unbox (o);
                set_last_error = MEM[(MonoBoolean *)D.26700];
                goto <D.26701>;
                <D.26699>:
                D.26685 = narg->field;
                D.26691 = D.26685->name;
                D.26702 = strcmp (D.26691, "BestFitMapping");
                if (D.26702 == 0) goto <D.26703>; else goto <D.26704>;
                <D.26703>:
                D.26705 = mono_object_unbox (o);
                best_fit_mapping = MEM[(MonoBoolean *)D.26705];
                goto <D.26706>;
                <D.26704>:
                D.26685 = narg->field;
                D.26691 = D.26685->name;
                D.26707 = strcmp (D.26691, "ThrowOnUnmappableChar");
                if (D.26707 == 0) goto <D.26708>; else goto <D.26709>;
                <D.26708>:
                D.26710 = mono_object_unbox (o);
                throw_on_unmappable = MEM[(MonoBoolean *)D.26710];
                goto <D.26711>;
                <D.26709>:
                monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "marshal.c", 9553);
                <D.26711>:
                <D.26706>:
                <D.26701>:
                <D.26696>:
              }
              i = i + 1;
              <D.21103>:
              D.26683 = (long unsigned int) i;
              named_args.290 = named_args;
              D.26712 = mono_array_length (named_args.290);
              if (D.26683 < D.26712) goto <D.21102>; else goto <D.21104>;
              <D.21104>:
              arginfo.289 = arginfo;
              monoeg_g_free (arginfo.289);
              memset (&piinfo, 0, 56);
              m.piinfo = &piinfo;
              D.26713 = call_conv << 8;
              D.26714 = (signed short) D.26713;
              if (charset != 0) goto <D.26716>; else goto <D.26717>;
              <D.26716>:
              D.26718 = charset + -1;
              D.26719 = (unsigned short) D.26718;
              D.26720 = D.26719 * 2;
              iftmp.291 = (signed short) D.26720;
              goto <D.26721>;
              <D.26717>:
              iftmp.291 = 1;
              <D.26721>:
              D.26722 = D.26714 | iftmp.291;
              D.26723 = (signed short) set_last_error;
              D.26724 = D.26722 | D.26723;
              D.26725 = (short unsigned int) D.26724;
              piinfo.piflags = D.26725;
              D.26726 = (unsigned char) call_conv;
              D.26727 = D.26726 + 255;
              D.26728 = (<unnamed-unsigned:6>) D.26727;
              csig->call_convention = D.26728;
            }
          finally
            {
              typed_args = {CLOBBER};
              named_args = {CLOBBER};
              arginfo = {CLOBBER};
              error = {CLOBBER};
            }
        }
        <D.26660>:
        if (cinfo != 0B) goto <D.26729>; else goto <D.26730>;
        <D.26729>:
        D.26731 = cinfo->cached;
        if (D.26731 == 0) goto <D.26732>; else goto <D.26733>;
        <D.26732>:
        mono_custom_attrs_free (cinfo);
        <D.26733>:
        <D.26730>:
      }
      <D.26651>:
      mono_marshal_emit_managed_wrapper (mb, invoke_sig, mspecs, &m, method, target_handle);
      if (target_handle == 0) goto <D.26734>; else goto <D.26735>;
      <D.26734>:
      {
        struct WrapperInfo * info;

        D.26736 = sig->param_count;
        D.26737 = (int) D.26736;
        D.26738 = D.26737 + 16;
        res = mono_mb_create_and_cache (cache, method, mb, csig, D.26738);
        info = mono_wrapper_info_create (res, 0);
        info->d.native_to_managed.method = method;
        info->d.native_to_managed.klass = delegate_klass;
        mono_marshal_set_wrapper_info (res, info);
      }
      goto <D.26739>;
      <D.26735>:
      mb->dynamic = 1;
      D.26736 = sig->param_count;
      D.26737 = (int) D.26736;
      D.26738 = D.26737 + 16;
      res = mono_mb_create_method (mb, csig, D.26738);
      <D.26739>:
      mono_mb_free (mb);
      D.26740 = mono_method_signature (invoke);
      D.26741 = D.26740->param_count;
      i = (int) D.26741;
      goto <D.21107>;
      <D.21106>:
      D.26680 = (long unsigned int) i;
      D.26742 = D.26680 * 8;
      D.26743 = mspecs + D.26742;
      D.26744 = *D.26743;
      if (D.26744 != 0B) goto <D.26745>; else goto <D.26746>;
      <D.26745>:
      D.26680 = (long unsigned int) i;
      D.26742 = D.26680 * 8;
      D.26743 = mspecs + D.26742;
      D.26744 = *D.26743;
      mono_metadata_free_marshal_spec (D.26744);
      <D.26746>:
      i = i + -1;
      <D.21107>:
      if (i >= 0) goto <D.21106>; else goto <D.21108>;
      <D.21108>:
      monoeg_g_free (mspecs);
      D.26632 = res;
      return D.26632;
    }
  finally
    {
      piinfo = {CLOBBER};
      m = {CLOBBER};
    }
}


mono_marshal_set_callconv_from_modopt (struct MonoMethod * method, struct MonoMethodSignature * csig)
{
  struct MonoType * D.26749;
  long unsigned int D.26752;
  long unsigned int D.26753;
  struct MonoClass * D.26756;
  struct MonoImage * D.26757;
  <unnamed-unsigned:31> D.26758;
  unsigned int D.26759;
  _Bool D.26760;
  long int D.26761;
  long int D.26762;
  struct MonoImage * D.26765;
  struct MonoImage * D.26766;
  const char * D.26769;
  int D.26770;
  const char * D.26773;
  int D.26774;
  int D.26778;
  int D.26782;
  int D.26786;
  <unnamed-unsigned:6> D.26789;
  int D.26790;
  struct MonoMethodSignature * sig;
  int i;

  sig = mono_method_signature (method);
  D.26749 = sig->ret;
  if (D.26749 != 0B) goto <D.26750>; else goto <D.26751>;
  <D.26750>:
  D.26749 = sig->ret;
  D.26752 = BIT_FIELD_REF <*D.26749, 64, 64>;
  D.26753 = D.26752 & 1082331758592;
  if (D.26753 != 0) goto <D.26754>; else goto <D.26755>;
  <D.26754>:
  i = 0;
  goto <D.21066>;
  <D.21065>:
  {
    struct MonoClass * cmod_class;

    D.26756 = method->klass;
    D.26757 = D.26756->image;
    D.26749 = sig->ret;
    D.26758 = D.26749->modifiers[i].token;
    D.26759 = (unsigned int) D.26758;
    cmod_class = mono_class_get (D.26757, D.26759);
    D.26760 = cmod_class == 0B;
    D.26761 = (long int) D.26760;
    D.26762 = __builtin_expect (D.26761, 0);
    if (D.26762 != 0) goto <D.26763>; else goto <D.26764>;
    <D.26763>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 9418, "cmod_class");
    <D.26764>:
    D.26765 = cmod_class->image;
    D.26766 = mono_defaults.corlib;
    if (D.26765 == D.26766) goto <D.26767>; else goto <D.26768>;
    <D.26767>:
    D.26769 = cmod_class->name_space;
    D.26770 = strcmp (D.26769, "System.Runtime.CompilerServices");
    if (D.26770 == 0) goto <D.26771>; else goto <D.26772>;
    <D.26771>:
    D.26773 = cmod_class->name;
    D.26774 = strcmp (D.26773, "CallConvCdecl");
    if (D.26774 == 0) goto <D.26775>; else goto <D.26776>;
    <D.26775>:
    csig->call_convention = 1;
    goto <D.26777>;
    <D.26776>:
    D.26773 = cmod_class->name;
    D.26778 = strcmp (D.26773, "CallConvStdcall");
    if (D.26778 == 0) goto <D.26779>; else goto <D.26780>;
    <D.26779>:
    csig->call_convention = 2;
    goto <D.26781>;
    <D.26780>:
    D.26773 = cmod_class->name;
    D.26782 = strcmp (D.26773, "CallConvFastcall");
    if (D.26782 == 0) goto <D.26783>; else goto <D.26784>;
    <D.26783>:
    csig->call_convention = 4;
    goto <D.26785>;
    <D.26784>:
    D.26773 = cmod_class->name;
    D.26786 = strcmp (D.26773, "CallConvThiscall");
    if (D.26786 == 0) goto <D.26787>; else goto <D.26788>;
    <D.26787>:
    csig->call_convention = 3;
    <D.26788>:
    <D.26785>:
    <D.26781>:
    <D.26777>:
    <D.26772>:
    <D.26768>:
  }
  i = i + 1;
  <D.21066>:
  D.26749 = sig->ret;
  D.26789 = D.26749->num_mods;
  D.26790 = (int) D.26789;
  if (D.26790 > i) goto <D.21065>; else goto <D.21067>;
  <D.21067>:
  <D.26755>:
  <D.26751>:
}


mono_class_has_parent (struct MonoClass * klass, struct MonoClass * parent)
{
  struct MonoClass * * D.26791;
  _Bool D.26792;
  long int D.26793;
  long int D.26794;
  struct MonoClass * * D.26797;
  _Bool D.26798;
  long int D.26799;
  long int D.26800;
  gboolean D.26803;

  D.26791 = klass->supertypes;
  D.26792 = D.26791 == 0B;
  D.26793 = (long int) D.26792;
  D.26794 = __builtin_expect (D.26793, 0);
  if (D.26794 != 0) goto <D.26795>; else goto <D.26796>;
  <D.26795>:
  mono_class_setup_supertypes (klass);
  <D.26796>:
  D.26797 = parent->supertypes;
  D.26798 = D.26797 == 0B;
  D.26799 = (long int) D.26798;
  D.26800 = __builtin_expect (D.26799, 0);
  if (D.26800 != 0) goto <D.26801>; else goto <D.26802>;
  <D.26801>:
  mono_class_setup_supertypes (parent);
  <D.26802>:
  D.26803 = mono_class_has_parent_fast (klass, parent);
  return D.26803;
}


mono_class_has_parent_fast (struct MonoClass * klass, struct MonoClass * parent)
{
  gboolean D.26805;
  int iftmp.292;
  short unsigned int D.26809;
  short unsigned int D.26810;
  struct MonoClass * * D.26812;
  long unsigned int D.26813;
  long unsigned int D.26814;
  sizetype D.26815;
  struct MonoClass * * D.26816;
  struct MonoClass * D.26817;

  D.26809 = klass->idepth;
  D.26810 = parent->idepth;
  if (D.26809 >= D.26810) goto <D.26811>; else goto <D.26807>;
  <D.26811>:
  D.26812 = klass->supertypes;
  D.26810 = parent->idepth;
  D.26813 = (long unsigned int) D.26810;
  D.26814 = D.26813 * 8;
  D.26815 = D.26814 + 18446744073709551608;
  D.26816 = D.26812 + D.26815;
  D.26817 = *D.26816;
  if (D.26817 == parent) goto <D.26818>; else goto <D.26807>;
  <D.26818>:
  iftmp.292 = 1;
  goto <D.26808>;
  <D.26807>:
  iftmp.292 = 0;
  <D.26808>:
  D.26805 = iftmp.292;
  return D.26805;
}


__attribute__((visibility ("hidden")))
mono_marshal_get_vtfixup_ftnptr (struct MonoImage * image, guint32 token, guint16 type)
{
  _Bool D.26820;
  long int D.26821;
  long int D.26822;
  _Bool D.26825;
  long int D.26826;
  long int D.26827;
  int D.26830;
  int D.26831;
  long unsigned int D.26834;
  long unsigned int D.26835;
  _Bool D.26836;
  long int D.26837;
  long int D.26838;
  short unsigned int D.26841;
  int D.26842;
  int D.26843;
  long unsigned int D.26844;
  long unsigned int D.26845;
  struct MonoClass * D.26846;
  const char * D.26847;
  int D.26848;
  long unsigned int D.26849;
  long unsigned int D.26850;
  struct MonoMarshalSpec * * D.26851;
  struct MonoMarshalSpec * D.26852;
  void * D.26855;
  <unnamed-unsigned:1> D.26856;
  int D.26857;
  unsigned int i.293;
  int D.26859;
  struct MonoMethod * method;
  struct MonoMethodSignature * sig;
  struct MonoMethodBuilder * mb;
  int i;
  int param_count;

  D.26820 = token == 0;
  D.26821 = (long int) D.26820;
  D.26822 = __builtin_expect (D.26821, 0);
  if (D.26822 != 0) goto <D.26823>; else goto <D.26824>;
  <D.26823>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 9608, "token");
  <D.26824>:
  method = mono_get_method (image, token, 0B);
  D.26825 = method == 0B;
  D.26826 = (long int) D.26825;
  D.26827 = __builtin_expect (D.26826, 0);
  if (D.26827 != 0) goto <D.26828>; else goto <D.26829>;
  <D.26828>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 9611, "method");
  <D.26829>:
  D.26830 = (int) type;
  D.26831 = D.26830 & 12;
  if (D.26831 != 0) goto <D.26832>; else goto <D.26833>;
  <D.26832>:
  {
    struct MonoMethodSignature * csig;
    struct MonoMarshalSpec * * mspecs;
    struct EmitMarshalContext m;

    try
      {
        sig = mono_method_signature (method);
        D.26834 = BIT_FIELD_REF <*sig, 64, 64>;
        D.26835 = D.26834 & 512;
        D.26836 = D.26835 != 0;
        D.26837 = (long int) D.26836;
        D.26838 = __builtin_expect (D.26837, 0);
        if (D.26838 != 0) goto <D.26839>; else goto <D.26840>;
        <D.26839>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 9619, "!sig->hasthis");
        <D.26840>:
        D.26841 = sig->param_count;
        D.26842 = (int) D.26841;
        D.26843 = D.26842 + 1;
        D.26844 = (long unsigned int) D.26843;
        D.26845 = D.26844 * 8;
        mspecs = monoeg_malloc0 (D.26845);
        mono_method_get_marshal_info (method, mspecs);
        D.26846 = method->klass;
        D.26847 = method->name;
        mb = mono_mb_new (D.26846, D.26847, 5);
        csig = signature_dup (image, sig);
        csig->hasthis = 0;
        csig->pinvoke = 1;
        m.mb = mb;
        m.sig = sig;
        m.piinfo = 0B;
        m.retobj_var = 0;
        m.csig = csig;
        m.image = image;
        mono_marshal_set_callconv_from_modopt (method, csig);
        mono_marshal_emit_managed_wrapper (mb, sig, mspecs, &m, method, 0);
        mb->dynamic = 1;
        D.26841 = sig->param_count;
        D.26842 = (int) D.26841;
        D.26848 = D.26842 + 16;
        method = mono_mb_create_method (mb, csig, D.26848);
        mono_mb_free (mb);
        D.26841 = sig->param_count;
        i = (int) D.26841;
        goto <D.21123>;
        <D.21122>:
        D.26849 = (long unsigned int) i;
        D.26850 = D.26849 * 8;
        D.26851 = mspecs + D.26850;
        D.26852 = *D.26851;
        if (D.26852 != 0B) goto <D.26853>; else goto <D.26854>;
        <D.26853>:
        D.26849 = (long unsigned int) i;
        D.26850 = D.26849 * 8;
        D.26851 = mspecs + D.26850;
        D.26852 = *D.26851;
        mono_metadata_free_marshal_spec (D.26852);
        <D.26854>:
        i = i + -1;
        <D.21123>:
        if (i >= 0) goto <D.21122>; else goto <D.21124>;
        <D.21124>:
        monoeg_g_free (mspecs);
        D.26855 = mono_compile_method (method);
        return D.26855;
      }
    finally
      {
        m = {CLOBBER};
      }
  }
  <D.26833>:
  sig = mono_method_signature (method);
  D.26846 = method->klass;
  D.26847 = method->name;
  mb = mono_mb_new (D.26846, D.26847, 7);
  D.26841 = sig->param_count;
  D.26842 = (int) D.26841;
  D.26856 = sig->hasthis;
  D.26857 = (int) D.26856;
  param_count = D.26842 + D.26857;
  i = 0;
  goto <D.21126>;
  <D.21125>:
  i.293 = (unsigned int) i;
  mono_mb_emit_ldarg (mb, i.293);
  i = i + 1;
  <D.21126>:
  if (i < param_count) goto <D.21125>; else goto <D.21127>;
  <D.21127>:
  D.26830 = (int) type;
  D.26859 = D.26830 & 16;
  if (D.26859 != 0) goto <D.26860>; else goto <D.26861>;
  <D.26860>:
  mono_mb_emit_op (mb, 111, method);
  goto <D.26862>;
  <D.26861>:
  mono_mb_emit_op (mb, 40, method);
  <D.26862>:
  mono_mb_emit_byte (mb, 42);
  mb->dynamic = 1;
  method = mono_mb_create_method (mb, sig, param_count);
  mono_mb_free (mb);
  D.26855 = mono_compile_method (method);
  return D.26855;
}


__attribute__((visibility ("hidden")))
mono_marshal_get_castclass_with_cache ()
{
  struct MonoMethod * cached.294;
  struct MonoMethod * D.26868;
  struct MonoClass * D.26869;
  struct MonoImage * D.26870;
  struct MonoType * D.26871;
  struct MonoClass * D.26872;
  struct MonoType * D.26873;
  unsigned int D.26874;
  unsigned int D.26875;
  unsigned int cache_miss_pos.295;
  unsigned int D.26877;
  unsigned int invalid_cast_pos.296;
  unsigned int return_null_pos.297;
  void * D.26880;
  static struct MonoMethod * cached;
  struct MonoMethod * res;
  struct MonoMethodBuilder * mb;
  struct MonoMethodSignature * sig;
  int return_null_pos;
  int cache_miss_pos;
  int invalid_cast_pos;
  struct WrapperInfo * info;

  cached.294 = cached;
  if (cached.294 != 0B) goto <D.26866>; else goto <D.26867>;
  <D.26866>:
  D.26868 = cached;
  return D.26868;
  <D.26867>:
  D.26869 = mono_defaults.object_class;
  mb = mono_mb_new (D.26869, "__castclass_with_cache", 19);
  D.26870 = mono_defaults.corlib;
  sig = mono_metadata_signature_alloc (D.26870, 3);
  D.26869 = mono_defaults.object_class;
  D.26871 = &D.26869->byval_arg;
  sig->params[0] = D.26871;
  D.26872 = mono_defaults.int_class;
  D.26873 = &D.26872->byval_arg;
  sig->params[1] = D.26873;
  D.26872 = mono_defaults.int_class;
  D.26873 = &D.26872->byval_arg;
  sig->params[2] = D.26873;
  D.26869 = mono_defaults.object_class;
  D.26871 = &D.26869->byval_arg;
  sig->ret = D.26871;
  sig->pinvoke = 0;
  D.26872 = mono_defaults.int_class;
  D.26873 = &D.26872->byval_arg;
  mono_mb_add_local (mb, D.26873);
  mono_mb_emit_ldarg (mb, 0);
  D.26874 = mono_mb_emit_branch (mb, 57);
  return_null_pos = (int) D.26874;
  mono_mb_emit_ldarg (mb, 0);
  mono_mb_emit_ldflda (mb, 0);
  mono_mb_emit_byte (mb, 77);
  mono_mb_emit_stloc (mb, 0);
  mono_mb_emit_ldarg (mb, 2);
  mono_mb_emit_byte (mb, 77);
  mono_mb_emit_ldloc (mb, 0);
  D.26875 = mono_mb_emit_branch (mb, 64);
  cache_miss_pos = (int) D.26875;
  mono_mb_emit_ldarg (mb, 0);
  mono_mb_emit_byte (mb, 42);
  cache_miss_pos.295 = (unsigned int) cache_miss_pos;
  mono_mb_patch_branch (mb, cache_miss_pos.295);
  mono_mb_emit_ldarg (mb, 0);
  mono_mb_emit_ldarg (mb, 1);
  mono_mb_emit_icall (mb, mono_object_isinst);
  D.26877 = mono_mb_emit_branch (mb, 57);
  invalid_cast_pos = (int) D.26877;
  mono_mb_emit_ldarg (mb, 2);
  mono_mb_emit_ldloc (mb, 0);
  mono_mb_emit_byte (mb, 223);
  mono_mb_emit_ldarg (mb, 0);
  mono_mb_emit_byte (mb, 42);
  invalid_cast_pos.296 = (unsigned int) invalid_cast_pos;
  mono_mb_patch_branch (mb, invalid_cast_pos.296);
  mono_mb_emit_exception (mb, "InvalidCastException", 0B);
  return_null_pos.297 = (unsigned int) return_null_pos;
  mono_mb_patch_branch (mb, return_null_pos.297);
  mono_mb_emit_byte (mb, 20);
  mono_mb_emit_byte (mb, 42);
  res = mono_mb_create_method (mb, sig, 8);
  info = mono_wrapper_info_create (res, 9);
  mono_marshal_set_wrapper_info (res, info);
  D.26880 = InterlockedCompareExchangePointer (&cached, res, 0B);
  if (D.26880 != 0B) goto <D.26881>; else goto <D.26882>;
  <D.26881>:
  mono_free_method (res);
  mono_metadata_free_method_signature (sig);
  <D.26882>:
  mono_mb_free (mb);
  D.26868 = cached;
  return D.26868;
}


InterlockedCompareExchangePointer (void * volatile * dest, void * exch, void * comp)
{
  void * D.26884;
  long unsigned int comp.298;
  long unsigned int exch.299;
  long unsigned int D.26887;

  comp.298 = (long unsigned int) comp;
  exch.299 = (long unsigned int) exch;
  D.26887 = __sync_val_compare_and_swap_8 (dest, comp.298, exch.299);
  D.26884 = (void *) D.26887;
  return D.26884;
}


__attribute__((visibility ("hidden")))
mono_marshal_get_isinst_with_cache ()
{
  struct MonoMethod * cached.300;
  struct MonoMethod * D.26892;
  struct MonoClass * D.26893;
  struct MonoImage * D.26894;
  struct MonoType * D.26895;
  struct MonoClass * D.26896;
  struct MonoType * D.26897;
  unsigned int D.26898;
  unsigned int D.26899;
  unsigned int D.26900;
  unsigned int D.26901;
  unsigned int negative_cache_hit_pos.301;
  unsigned int cache_hit_pos.302;
  unsigned int cache_miss_pos.303;
  unsigned int D.26905;
  unsigned int not_an_instance_pos.304;
  unsigned int return_null_pos.305;
  void * D.26908;
  static struct MonoMethod * cached;
  struct MonoMethod * res;
  struct MonoMethodBuilder * mb;
  struct MonoMethodSignature * sig;
  int return_null_pos;
  int cache_miss_pos;
  int cache_hit_pos;
  int not_an_instance_pos;
  int negative_cache_hit_pos;
  struct WrapperInfo * info;

  cached.300 = cached;
  if (cached.300 != 0B) goto <D.26890>; else goto <D.26891>;
  <D.26890>:
  D.26892 = cached;
  return D.26892;
  <D.26891>:
  D.26893 = mono_defaults.object_class;
  mb = mono_mb_new (D.26893, "__isinst_with_cache", 19);
  D.26894 = mono_defaults.corlib;
  sig = mono_metadata_signature_alloc (D.26894, 3);
  D.26893 = mono_defaults.object_class;
  D.26895 = &D.26893->byval_arg;
  sig->params[0] = D.26895;
  D.26896 = mono_defaults.int_class;
  D.26897 = &D.26896->byval_arg;
  sig->params[1] = D.26897;
  D.26896 = mono_defaults.int_class;
  D.26897 = &D.26896->byval_arg;
  sig->params[2] = D.26897;
  D.26893 = mono_defaults.object_class;
  D.26895 = &D.26893->byval_arg;
  sig->ret = D.26895;
  sig->pinvoke = 0;
  D.26896 = mono_defaults.int_class;
  D.26897 = &D.26896->byval_arg;
  mono_mb_add_local (mb, D.26897);
  D.26896 = mono_defaults.int_class;
  D.26897 = &D.26896->byval_arg;
  mono_mb_add_local (mb, D.26897);
  mono_mb_emit_ldarg (mb, 0);
  D.26898 = mono_mb_emit_branch (mb, 57);
  return_null_pos = (int) D.26898;
  mono_mb_emit_ldarg (mb, 0);
  mono_mb_emit_ldflda (mb, 0);
  mono_mb_emit_byte (mb, 77);
  mono_mb_emit_stloc (mb, 0);
  mono_mb_emit_ldarg (mb, 2);
  mono_mb_emit_byte (mb, 77);
  mono_mb_emit_stloc (mb, 1);
  mono_mb_emit_ldloc (mb, 1);
  mono_mb_emit_byte (mb, 32);
  mono_mb_emit_i4 (mb, -2);
  mono_mb_emit_byte (mb, 224);
  mono_mb_emit_byte (mb, 95);
  mono_mb_emit_ldloc (mb, 0);
  D.26899 = mono_mb_emit_branch (mb, 64);
  cache_miss_pos = (int) D.26899;
  mono_mb_emit_ldloc (mb, 1);
  mono_mb_emit_byte (mb, 23);
  mono_mb_emit_byte (mb, 224);
  mono_mb_emit_byte (mb, 95);
  D.26900 = mono_mb_emit_branch (mb, 58);
  negative_cache_hit_pos = (int) D.26900;
  mono_mb_emit_ldarg (mb, 0);
  D.26901 = mono_mb_emit_branch (mb, 56);
  cache_hit_pos = (int) D.26901;
  negative_cache_hit_pos.301 = (unsigned int) negative_cache_hit_pos;
  mono_mb_patch_branch (mb, negative_cache_hit_pos.301);
  mono_mb_emit_byte (mb, 20);
  cache_hit_pos.302 = (unsigned int) cache_hit_pos;
  mono_mb_patch_branch (mb, cache_hit_pos.302);
  mono_mb_emit_byte (mb, 42);
  cache_miss_pos.303 = (unsigned int) cache_miss_pos;
  mono_mb_patch_branch (mb, cache_miss_pos.303);
  mono_mb_emit_ldarg (mb, 0);
  mono_mb_emit_ldarg (mb, 1);
  mono_mb_emit_icall (mb, mono_object_isinst);
  D.26905 = mono_mb_emit_branch (mb, 57);
  not_an_instance_pos = (int) D.26905;
  mono_mb_emit_ldarg (mb, 2);
  mono_mb_emit_ldloc (mb, 0);
  mono_mb_emit_byte (mb, 223);
  mono_mb_emit_ldarg (mb, 0);
  mono_mb_emit_byte (mb, 42);
  not_an_instance_pos.304 = (unsigned int) not_an_instance_pos;
  mono_mb_patch_branch (mb, not_an_instance_pos.304);
  mono_mb_emit_ldarg (mb, 2);
  mono_mb_emit_ldloc (mb, 0);
  mono_mb_emit_byte (mb, 23);
  mono_mb_emit_byte (mb, 224);
  mono_mb_emit_byte (mb, 96);
  mono_mb_emit_byte (mb, 223);
  return_null_pos.305 = (unsigned int) return_null_pos;
  mono_mb_patch_branch (mb, return_null_pos.305);
  mono_mb_emit_byte (mb, 20);
  mono_mb_emit_byte (mb, 42);
  res = mono_mb_create_method (mb, sig, 8);
  info = mono_wrapper_info_create (res, 10);
  mono_marshal_set_wrapper_info (res, info);
  D.26908 = InterlockedCompareExchangePointer (&cached, res, 0B);
  if (D.26908 != 0B) goto <D.26909>; else goto <D.26910>;
  <D.26909>:
  mono_free_method (res);
  mono_metadata_free_method_signature (sig);
  <D.26910>:
  mono_mb_free (mb);
  D.26892 = cached;
  return D.26892;
}


__attribute__((visibility ("hidden")))
mono_marshal_get_isinst (struct MonoClass * klass)
{
  struct MonoImage * D.26912;
  struct GHashTable * * D.26913;
  struct MonoMethod * D.26916;
  struct MonoMethodSignature * isint_sig.306;
  struct MonoImage * D.26920;
  struct MonoMethodSignature * isint_sig.307;
  struct MonoClass * D.26922;
  struct MonoType * D.26923;
  const char * D.26924;
  struct MonoMethod * D.26925;
  unsigned int D.26926;
  unsigned int D.26927;
  struct MonoMethod * D.26928;
  unsigned int D.26929;
  unsigned int pos_failed.308;
  unsigned int D.26931;
  unsigned int pos_was_ok.309;
  unsigned int pos_end.310;
  unsigned int pos_end2.311;
  short unsigned int D.26935;
  int D.26936;
  int D.26937;
  static struct MonoMethodSignature * isint_sig = 0B;
  struct GHashTable * cache;
  struct MonoMethod * res;
  int pos_was_ok;
  int pos_end;
  int pos_end2;
  int pos_failed;
  char * name;
  struct MonoMethodBuilder * mb;

  D.26912 = klass->image;
  D.26913 = &D.26912->isinst_cache;
  cache = get_cache (D.26913, mono_aligned_addr_hash, 0B);
  res = mono_marshal_find_in_cache (cache, klass);
  if (res != 0B) goto <D.26914>; else goto <D.26915>;
  <D.26914>:
  D.26916 = res;
  return D.26916;
  <D.26915>:
  isint_sig.306 = isint_sig;
  if (isint_sig.306 == 0B) goto <D.26918>; else goto <D.26919>;
  <D.26918>:
  D.26920 = mono_defaults.corlib;
  isint_sig.307 = mono_metadata_signature_alloc (D.26920, 1);
  isint_sig = isint_sig.307;
  isint_sig.306 = isint_sig;
  D.26922 = mono_defaults.object_class;
  D.26923 = &D.26922->byval_arg;
  isint_sig.306->params[0] = D.26923;
  isint_sig.306 = isint_sig;
  D.26922 = mono_defaults.object_class;
  D.26923 = &D.26922->byval_arg;
  isint_sig.306->ret = D.26923;
  isint_sig.306 = isint_sig;
  isint_sig.306->pinvoke = 0;
  <D.26919>:
  D.26924 = klass->name;
  name = monoeg_g_strdup_printf ("__isinst_wrapper_%s", D.26924);
  D.26922 = mono_defaults.object_class;
  mb = mono_mb_new (D.26922, name, 18);
  monoeg_g_free (name);
  D.26925 = mb->method;
  D.26925->save_lmf = 1;
  mono_mb_emit_ldarg (mb, 0);
  mono_mb_emit_byte (mb, 240);
  mono_mb_emit_op (mb, 7, klass);
  mono_mb_emit_byte (mb, 37);
  D.26926 = mono_mb_emit_branch (mb, 57);
  pos_was_ok = (int) D.26926;
  mono_mb_emit_byte (mb, 24);
  D.26927 = mono_mb_emit_branch (mb, 64);
  pos_failed = (int) D.26927;
  mono_mb_emit_ldarg (mb, 0);
  D.26928 = mono_marshal_get_proxy_cancast (klass);
  mono_mb_emit_managed_call (mb, D.26928, 0B);
  D.26929 = mono_mb_emit_branch (mb, 56);
  pos_end = (int) D.26929;
  pos_failed.308 = (unsigned int) pos_failed;
  mono_mb_patch_branch (mb, pos_failed.308);
  mono_mb_emit_byte (mb, 20);
  D.26931 = mono_mb_emit_branch (mb, 56);
  pos_end2 = (int) D.26931;
  pos_was_ok.309 = (unsigned int) pos_was_ok;
  mono_mb_patch_branch (mb, pos_was_ok.309);
  mono_mb_emit_byte (mb, 38);
  mono_mb_emit_ldarg (mb, 0);
  pos_end.310 = (unsigned int) pos_end;
  mono_mb_patch_branch (mb, pos_end.310);
  pos_end2.311 = (unsigned int) pos_end2;
  mono_mb_patch_branch (mb, pos_end2.311);
  mono_mb_emit_byte (mb, 42);
  isint_sig.306 = isint_sig;
  isint_sig.306 = isint_sig;
  D.26935 = isint_sig.306->param_count;
  D.26936 = (int) D.26935;
  D.26937 = D.26936 + 16;
  res = mono_mb_create_and_cache (cache, klass, mb, isint_sig.306, D.26937);
  mono_mb_free (mb);
  D.26916 = res;
  return D.26916;
}


__attribute__((visibility ("hidden")))
mono_marshal_get_castclass (struct MonoClass * klass)
{
  struct MonoImage * D.26939;
  struct GHashTable * * D.26940;
  struct MonoMethod * D.26943;
  struct MonoMethodSignature * castclass_sig.312;
  struct MonoImage * D.26947;
  struct MonoMethodSignature * castclass_sig.313;
  struct MonoClass * D.26949;
  struct MonoType * D.26950;
  const char * D.26951;
  struct MonoMethod * D.26952;
  unsigned int D.26953;
  struct MonoMethod * D.26954;
  unsigned int D.26955;
  unsigned int pos_was_ok.314;
  unsigned int pos_was_ok2.315;
  short unsigned int D.26958;
  int D.26959;
  int D.26960;
  static struct MonoMethodSignature * castclass_sig = 0B;
  struct GHashTable * cache;
  struct MonoMethod * res;
  int pos_was_ok;
  int pos_was_ok2;
  char * name;
  struct MonoMethodBuilder * mb;
  struct WrapperInfo * info;

  D.26939 = klass->image;
  D.26940 = &D.26939->castclass_cache;
  cache = get_cache (D.26940, mono_aligned_addr_hash, 0B);
  res = mono_marshal_find_in_cache (cache, klass);
  if (res != 0B) goto <D.26941>; else goto <D.26942>;
  <D.26941>:
  D.26943 = res;
  return D.26943;
  <D.26942>:
  castclass_sig.312 = castclass_sig;
  if (castclass_sig.312 == 0B) goto <D.26945>; else goto <D.26946>;
  <D.26945>:
  D.26947 = mono_defaults.corlib;
  castclass_sig.313 = mono_metadata_signature_alloc (D.26947, 1);
  castclass_sig = castclass_sig.313;
  castclass_sig.312 = castclass_sig;
  D.26949 = mono_defaults.object_class;
  D.26950 = &D.26949->byval_arg;
  castclass_sig.312->params[0] = D.26950;
  castclass_sig.312 = castclass_sig;
  D.26949 = mono_defaults.object_class;
  D.26950 = &D.26949->byval_arg;
  castclass_sig.312->ret = D.26950;
  castclass_sig.312 = castclass_sig;
  castclass_sig.312->pinvoke = 0;
  <D.26946>:
  D.26951 = klass->name;
  name = monoeg_g_strdup_printf ("__castclass_wrapper_%s", D.26951);
  D.26949 = mono_defaults.object_class;
  mb = mono_mb_new (D.26949, name, 19);
  monoeg_g_free (name);
  D.26952 = mb->method;
  D.26952->save_lmf = 1;
  mono_mb_emit_ldarg (mb, 0);
  mono_mb_emit_byte (mb, 240);
  mono_mb_emit_op (mb, 8, klass);
  D.26953 = mono_mb_emit_branch (mb, 57);
  pos_was_ok = (int) D.26953;
  mono_mb_emit_ldarg (mb, 0);
  D.26954 = mono_marshal_get_proxy_cancast (klass);
  mono_mb_emit_managed_call (mb, D.26954, 0B);
  D.26955 = mono_mb_emit_branch (mb, 58);
  pos_was_ok2 = (int) D.26955;
  mono_mb_emit_exception (mb, "InvalidCastException", 0B);
  pos_was_ok.314 = (unsigned int) pos_was_ok;
  mono_mb_patch_branch (mb, pos_was_ok.314);
  pos_was_ok2.315 = (unsigned int) pos_was_ok2;
  mono_mb_patch_branch (mb, pos_was_ok2.315);
  mono_mb_emit_ldarg (mb, 0);
  mono_mb_emit_byte (mb, 42);
  castclass_sig.312 = castclass_sig;
  castclass_sig.312 = castclass_sig;
  D.26958 = castclass_sig.312->param_count;
  D.26959 = (int) D.26958;
  D.26960 = D.26959 + 16;
  res = mono_mb_create_and_cache (cache, klass, mb, castclass_sig.312, D.26960);
  mono_mb_free (mb);
  info = mono_wrapper_info_create (res, 0);
  mono_marshal_set_wrapper_info (res, info);
  D.26943 = res;
  return D.26943;
}


__attribute__((visibility ("hidden")))
mono_marshal_get_proxy_cancast (struct MonoClass * klass)
{
  struct MonoImage * D.26962;
  struct GHashTable * * D.26963;
  struct MonoMethod * D.26966;
  struct MonoMethodSignature * isint_sig.316;
  struct MonoImage * D.26970;
  struct MonoMethodSignature * isint_sig.317;
  struct MonoClass * D.26972;
  struct MonoType * D.26973;
  struct MonoType * D.26974;
  struct MonoMethod * D.26975;
  struct MonoClass * D.26976;
  _Bool D.26977;
  long int D.26978;
  long int D.26979;
  unsigned int D.26982;
  unsigned int D.26983;
  unsigned int pos_failed.318;
  unsigned int pos_end.319;
  short unsigned int D.26986;
  int D.26987;
  int D.26988;
  static struct MonoMethodSignature * isint_sig = 0B;
  struct GHashTable * cache;
  struct MonoMethod * res;
  int pos_failed;
  int pos_end;
  char * name;
  char * klass_name;
  struct MonoMethod * can_cast_to;
  struct MonoMethodDesc * desc;
  struct MonoMethodBuilder * mb;

  D.26962 = klass->image;
  D.26963 = &D.26962->proxy_isinst_cache;
  cache = get_cache (D.26963, mono_aligned_addr_hash, 0B);
  res = mono_marshal_find_in_cache (cache, klass);
  if (res != 0B) goto <D.26964>; else goto <D.26965>;
  <D.26964>:
  D.26966 = res;
  return D.26966;
  <D.26965>:
  isint_sig.316 = isint_sig;
  if (isint_sig.316 == 0B) goto <D.26968>; else goto <D.26969>;
  <D.26968>:
  D.26970 = mono_defaults.corlib;
  isint_sig.317 = mono_metadata_signature_alloc (D.26970, 1);
  isint_sig = isint_sig.317;
  isint_sig.316 = isint_sig;
  D.26972 = mono_defaults.object_class;
  D.26973 = &D.26972->byval_arg;
  isint_sig.316->params[0] = D.26973;
  isint_sig.316 = isint_sig;
  D.26972 = mono_defaults.object_class;
  D.26973 = &D.26972->byval_arg;
  isint_sig.316->ret = D.26973;
  isint_sig.316 = isint_sig;
  isint_sig.316->pinvoke = 0;
  <D.26969>:
  D.26974 = &klass->byval_arg;
  klass_name = mono_type_full_name (D.26974);
  name = monoeg_g_strdup_printf ("__proxy_isinst_wrapper_%s", klass_name);
  D.26972 = mono_defaults.object_class;
  mb = mono_mb_new (D.26972, name, 20);
  monoeg_g_free (klass_name);
  monoeg_g_free (name);
  D.26975 = mb->method;
  D.26975->save_lmf = 1;
  mono_mb_emit_ldarg (mb, 0);
  mono_mb_emit_ldflda (mb, 16);
  mono_mb_emit_byte (mb, 80);
  D.26974 = &klass->byval_arg;
  mono_mb_emit_ptr (mb, D.26974);
  mono_mb_emit_icall (mb, type_from_handle);
  mono_mb_emit_ldarg (mb, 0);
  desc = mono_method_desc_new ("IRemotingTypeInfo:CanCastTo", 0);
  D.26976 = mono_defaults.iremotingtypeinfo_class;
  can_cast_to = mono_method_desc_search_in_class (desc, D.26976);
  D.26977 = can_cast_to == 0B;
  D.26978 = (long int) D.26977;
  D.26979 = __builtin_expect (D.26978, 0);
  if (D.26979 != 0) goto <D.26980>; else goto <D.26981>;
  <D.26980>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 10142, "can_cast_to");
  <D.26981>:
  mono_method_desc_free (desc);
  mono_mb_emit_op (mb, 111, can_cast_to);
  D.26982 = mono_mb_emit_branch (mb, 57);
  pos_failed = (int) D.26982;
  D.26974 = &klass->byval_arg;
  mono_mb_emit_ptr (mb, D.26974);
  mono_mb_emit_icall (mb, type_from_handle);
  mono_mb_emit_ldarg (mb, 0);
  mono_mb_emit_icall (mb, mono_upgrade_remote_class_wrapper);
  emit_thread_interrupt_checkpoint (mb);
  mono_mb_emit_ldarg (mb, 0);
  D.26983 = mono_mb_emit_branch (mb, 56);
  pos_end = (int) D.26983;
  pos_failed.318 = (unsigned int) pos_failed;
  mono_mb_patch_branch (mb, pos_failed.318);
  mono_mb_emit_byte (mb, 20);
  pos_end.319 = (unsigned int) pos_end;
  mono_mb_patch_branch (mb, pos_end.319);
  mono_mb_emit_byte (mb, 42);
  isint_sig.316 = isint_sig;
  isint_sig.316 = isint_sig;
  D.26986 = isint_sig.316->param_count;
  D.26987 = (int) D.26986;
  D.26988 = D.26987 + 16;
  res = mono_mb_create_and_cache (cache, klass, mb, isint_sig.316, D.26988);
  mono_mb_free (mb);
  D.26966 = res;
  return D.26966;
}


mono_upgrade_remote_class_wrapper (struct MonoReflectionType * rtype, struct MonoTransparentProxy * tproxy)
{
  struct MonoVTable * D.26990;
  struct MonoType * D.26991;
  struct MonoClass * klass;
  struct MonoDomain * domain;

  D.26990 = MEM[(struct MonoObject *)tproxy].vtable;
  domain = D.26990->domain;
  D.26991 = rtype->type;
  klass = mono_class_from_mono_type (D.26991);
  mono_upgrade_remote_class (domain, tproxy, klass);
}


__attribute__((visibility ("hidden")))
mono_marshal_get_struct_to_ptr (struct MonoClass * klass)
{
  _Bool D.26992;
  long int D.26993;
  long int D.26994;
  struct MonoMarshalType * D.26997;
  struct MonoMethod * D.26998;
  struct MonoMethod * D.27001;
  struct MonoMethod * stoptr.320;
  struct MonoClass * D.27005;
  struct MonoMethod * stoptr.321;
  _Bool D.27007;
  long int D.27008;
  long int D.27009;
  const char * D.27012;
  long unsigned int D.27013;
  long unsigned int D.27014;
  int D.27017;
  struct MonoClass * D.27019;
  struct MonoType * D.27020;
  struct MonoClass * D.27021;
  struct MonoType * D.27022;
  struct MonoMethodSignature * D.27023;
  struct MonoMethodBuilder * mb;
  static struct MonoMethod * stoptr = 0B;
  struct MonoMethod * res;
  struct WrapperInfo * info;

  D.26992 = klass == 0B;
  D.26993 = (long int) D.26992;
  D.26994 = __builtin_expect (D.26993, 0);
  if (D.26994 != 0) goto <D.26995>; else goto <D.26996>;
  <D.26995>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 10201, "klass != NULL");
  <D.26996>:
  mono_marshal_load_type_info (klass);
  D.26997 = klass->marshal_info;
  D.26998 = D.26997->str_to_ptr;
  if (D.26998 != 0B) goto <D.26999>; else goto <D.27000>;
  <D.26999>:
  D.26997 = klass->marshal_info;
  D.27001 = D.26997->str_to_ptr;
  return D.27001;
  <D.27000>:
  stoptr.320 = stoptr;
  if (stoptr.320 == 0B) goto <D.27003>; else goto <D.27004>;
  <D.27003>:
  D.27005 = mono_defaults.marshal_class;
  stoptr.321 = mono_class_get_method_from_name (D.27005, "StructureToPtr", 3);
  stoptr = stoptr.321;
  <D.27004>:
  stoptr.320 = stoptr;
  D.27007 = stoptr.320 == 0B;
  D.27008 = (long int) D.27007;
  D.27009 = __builtin_expect (D.27008, 0);
  if (D.27009 != 0) goto <D.27010>; else goto <D.27011>;
  <D.27010>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 10210, "stoptr");
  <D.27011>:
  stoptr.320 = stoptr;
  D.27012 = stoptr.320->name;
  mb = mono_mb_new (klass, D.27012, 25);
  D.27013 = BIT_FIELD_REF <*klass, 64, 256>;
  D.27014 = D.27013 & 288230376151711744;
  if (D.27014 != 0) goto <D.27015>; else goto <D.27016>;
  <D.27015>:
  mono_mb_emit_byte (mb, 3);
  mono_mb_emit_byte (mb, 2);
  mono_mb_emit_ldflda (mb, 16);
  D.27017 = mono_class_value_size (klass, 0B);
  mono_mb_emit_icon (mb, D.27017);
  mono_mb_emit_byte (mb, 254);
  mono_mb_emit_byte (mb, 23);
  goto <D.27018>;
  <D.27016>:
  D.27019 = mono_defaults.int_class;
  D.27020 = &D.27019->byval_arg;
  mono_mb_add_local (mb, D.27020);
  D.27019 = mono_defaults.int_class;
  D.27020 = &D.27019->byval_arg;
  mono_mb_add_local (mb, D.27020);
  D.27021 = mono_defaults.boolean_class;
  D.27022 = &D.27021->byval_arg;
  mono_mb_add_local (mb, D.27022);
  mono_mb_emit_byte (mb, 4);
  mono_mb_emit_stloc (mb, 2);
  mono_mb_emit_byte (mb, 2);
  mono_mb_emit_ldflda (mb, 16);
  mono_mb_emit_stloc (mb, 0);
  mono_mb_emit_byte (mb, 3);
  mono_mb_emit_stloc (mb, 1);
  emit_struct_conv (mb, klass, 0);
  <D.27018>:
  mono_mb_emit_byte (mb, 42);
  stoptr.320 = stoptr;
  D.27023 = mono_signature_no_pinvoke (stoptr.320);
  res = mono_mb_create_method (mb, D.27023, 0);
  mono_mb_free (mb);
  info = mono_wrapper_info_create (res, 8);
  mono_marshal_set_wrapper_info (res, info);
  D.26997 = klass->marshal_info;
  D.26997->str_to_ptr = res;
  D.27001 = res;
  return D.27001;
}


__attribute__((visibility ("hidden")))
mono_marshal_get_ptr_to_struct (struct MonoClass * klass)
{
  _Bool D.27025;
  long int D.27026;
  long int D.27027;
  struct MonoMarshalType * D.27030;
  struct MonoMethod * D.27031;
  struct MonoMethod * D.27034;
  struct MonoMethodSignature * ptostr.322;
  struct MonoImage * D.27038;
  long unsigned int D.27039;
  long unsigned int D.27040;
  int D.27043;
  struct MonoClass * D.27045;
  struct MonoType * D.27046;
  struct MonoType * D.27047;
  struct MonoMethodBuilder * mb;
  static struct MonoMethodSignature * ptostr = 0B;
  struct MonoMethod * res;
  struct WrapperInfo * info;

  D.27025 = klass == 0B;
  D.27026 = (long int) D.27025;
  D.27027 = __builtin_expect (D.27026, 0);
  if (D.27027 != 0) goto <D.27028>; else goto <D.27029>;
  <D.27028>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 10273, "klass != NULL");
  <D.27029>:
  mono_marshal_load_type_info (klass);
  D.27030 = klass->marshal_info;
  D.27031 = D.27030->ptr_to_str;
  if (D.27031 != 0B) goto <D.27032>; else goto <D.27033>;
  <D.27032>:
  D.27030 = klass->marshal_info;
  D.27034 = D.27030->ptr_to_str;
  return D.27034;
  <D.27033>:
  ptostr.322 = ptostr;
  if (ptostr.322 == 0B) goto <D.27036>; else goto <D.27037>;
  <D.27036>:
  {
    struct MonoMethodSignature * sig;

    sig = mono_create_icall_signature ("void ptr object");
    D.27038 = mono_defaults.corlib;
    sig = signature_dup (D.27038, sig);
    sig->pinvoke = 0;
    mono_memory_barrier ();
    ptostr = sig;
  }
  <D.27037>:
  mb = mono_mb_new (klass, "PtrToStructure", 25);
  D.27039 = BIT_FIELD_REF <*klass, 64, 256>;
  D.27040 = D.27039 & 288230376151711744;
  if (D.27040 != 0) goto <D.27041>; else goto <D.27042>;
  <D.27041>:
  mono_mb_emit_byte (mb, 3);
  mono_mb_emit_ldflda (mb, 16);
  mono_mb_emit_byte (mb, 2);
  D.27043 = mono_class_value_size (klass, 0B);
  mono_mb_emit_icon (mb, D.27043);
  mono_mb_emit_byte (mb, 254);
  mono_mb_emit_byte (mb, 23);
  goto <D.27044>;
  <D.27042>:
  D.27045 = mono_defaults.int_class;
  D.27046 = &D.27045->byval_arg;
  mono_mb_add_local (mb, D.27046);
  D.27047 = &klass->this_arg;
  mono_mb_add_local (mb, D.27047);
  mono_mb_emit_byte (mb, 2);
  mono_mb_emit_stloc (mb, 0);
  mono_mb_emit_byte (mb, 3);
  mono_mb_emit_op (mb, 121, klass);
  mono_mb_emit_stloc (mb, 1);
  emit_struct_conv (mb, klass, 1);
  <D.27044>:
  mono_mb_emit_byte (mb, 42);
  ptostr.322 = ptostr;
  res = mono_mb_create_method (mb, ptostr.322, 0);
  mono_mb_free (mb);
  info = mono_wrapper_info_create (res, 7);
  mono_marshal_set_wrapper_info (res, info);
  D.27030 = klass->marshal_info;
  D.27030->ptr_to_str = res;
  D.27034 = res;
  return D.27034;
}


__attribute__((visibility ("hidden")))
mono_marshal_get_synchronized_inner_wrapper (struct MonoMethod * method)
{
  long unsigned int D.27049;
  long unsigned int D.27050;
  struct MonoGenericContext * D.27053;
  struct MonoGenericInst * D.27054;
  struct MonoClass * D.27059;
  _Bool D.27060;
  long int D.27061;
  long int D.27062;
  const char * D.27065;
  struct MonoImage * D.27066;
  struct MonoMethodSignature * D.27067;
  struct MonoMethod * D.27070;
  struct MonoMethodBuilder * mb;
  struct WrapperInfo * info;
  struct MonoMethodSignature * sig;
  struct MonoMethod * res;
  struct MonoGenericContext * ctx;
  struct MonoMethod * orig_method;
  struct MonoGenericContainer * container;

  ctx = 0B;
  orig_method = 0B;
  container = 0B;
  D.27049 = BIT_FIELD_REF <*method, 64, 256>;
  D.27050 = D.27049 & 2251799813685248;
  if (D.27050 != 0) goto <D.27051>; else goto <D.27052>;
  <D.27051>:
  D.27053 = mono_method_get_context (method);
  D.27054 = D.27053->method_inst;
  if (D.27054 == 0B) goto <D.27055>; else goto <D.27056>;
  <D.27055>:
  orig_method = method;
  ctx = &MEM[(struct MonoMethodInflated *)method].context;
  method = MEM[(struct MonoMethodInflated *)method].declaring;
  container = mono_method_get_generic_container (method);
  if (container == 0B) goto <D.27057>; else goto <D.27058>;
  <D.27057>:
  D.27059 = method->klass;
  container = D.27059->generic_container;
  <D.27058>:
  D.27060 = container == 0B;
  D.27061 = (long int) D.27060;
  D.27062 = __builtin_expect (D.27061, 0);
  if (D.27062 != 0) goto <D.27063>; else goto <D.27064>;
  <D.27063>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 10360, "container");
  <D.27064>:
  <D.27056>:
  <D.27052>:
  D.27059 = method->klass;
  D.27065 = method->name;
  mb = mono_mb_new (D.27059, D.27065, 25);
  mono_mb_emit_exception_full (mb, "System", "ExecutionEngineException", "Shouldn\'t be called.");
  mono_mb_emit_byte (mb, 42);
  D.27059 = method->klass;
  D.27066 = D.27059->image;
  D.27067 = mono_method_signature (method);
  sig = signature_dup (D.27066, D.27067);
  res = mono_mb_create_method (mb, sig, 0);
  mono_mb_free (mb);
  info = mono_wrapper_info_create (res, 17);
  info->d.synchronized_inner.method = method;
  mono_marshal_set_wrapper_info (res, info);
  if (ctx != 0B) goto <D.27068>; else goto <D.27069>;
  <D.27068>:
  res = mono_class_inflate_generic_method (res, ctx);
  <D.27069>:
  D.27070 = res;
  return D.27070;
}


__attribute__((visibility ("hidden")))
mono_marshal_get_synchronized_wrapper (struct MonoMethod * method)
{
  _Bool D.27072;
  long int D.27073;
  long int D.27074;
  long unsigned int D.27077;
  long unsigned int D.27078;
  struct MonoMethod * D.27081;
  long unsigned int D.27082;
  struct MonoGenericContext * D.27085;
  struct MonoGenericInst * D.27086;
  struct MonoClass * D.27091;
  _Bool D.27092;
  long int D.27093;
  long int D.27094;
  struct MonoImage * D.27099;
  struct GHashTable * * D.27100;
  struct GHashTable * * D.27104;
  struct MonoMethodSignature * D.27107;
  const char * D.27108;
  struct MonoType * D.27109;
  int D.27110;
  long unsigned int D.27113;
  long unsigned int D.27114;
  short unsigned int D.27117;
  int D.27118;
  int D.27119;
  int D.27122;
  unsigned int ret_local.323;
  short unsigned int D.27126;
  int D.27127;
  int D.27128;
  struct MonoClass * D.27129;
  struct MonoType * D.27130;
  _Bool D.27133;
  long int D.27134;
  long int D.27135;
  struct MonoMethod * enter_method.324;
  struct MonoClass * D.27141;
  struct MonoMethod * enter_method.325;
  _Bool D.27143;
  long int D.27144;
  long int D.27145;
  struct MonoMethod * exit_method.326;
  struct MonoMethod * exit_method.327;
  _Bool D.27150;
  long int D.27151;
  long int D.27152;
  struct MonoClass * D.27155;
  struct MonoMethod * gettypefromhandle_method.328;
  struct MonoMethod * gettypefromhandle_method.329;
  _Bool D.27158;
  long int D.27159;
  long int D.27160;
  _Bool D.27165;
  long int D.27166;
  long int D.27167;
  unsigned int D.27172;
  struct MonoClass * D.27173;
  unsigned int this_local.330;
  int D.27176;
  unsigned int D.27177;
  long unsigned int D.27178;
  long unsigned int D.27179;
  _Bool D.27182;
  int D.27183;
  int D.27184;
  unsigned int D.27185;
  struct MonoGenericContext * D.27188;
  struct MonoMethod * D.27189;
  int D.27191;
  unsigned int D.27194;
  int D.27195;
  unsigned int D.27196;
  unsigned int D.27197;
  unsigned int D.27198;
  int D.27199;
  unsigned int D.27200;
  int D.27201;
  unsigned int D.27202;
  unsigned int D.27203;
  unsigned int D.27204;
  unsigned int pos.331;
  int D.27206;
  static struct MonoMethod * enter_method;
  static struct MonoMethod * exit_method;
  static struct MonoMethod * gettypefromhandle_method;
  struct MonoMethodSignature * sig;
  struct MonoExceptionClause * clause;
  struct MonoMethodBuilder * mb;
  struct MonoMethod * res;
  struct GHashTable * cache;
  int i;
  int pos;
  int this_local;
  int ret_local;
  struct MonoGenericContext * ctx;
  struct MonoMethod * orig_method;
  struct MonoGenericContainer * container;

  ret_local = 0;
  ctx = 0B;
  orig_method = 0B;
  container = 0B;
  D.27072 = method == 0B;
  D.27073 = (long int) D.27072;
  D.27074 = __builtin_expect (D.27073, 0);
  if (D.27074 != 0) goto <D.27075>; else goto <D.27076>;
  <D.27075>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 10397, "method");
  <D.27076>:
  D.27077 = BIT_FIELD_REF <*method, 64, 256>;
  D.27078 = D.27077 & 4467570830351532032;
  if (D.27078 == 2305843009213693952) goto <D.27079>; else goto <D.27080>;
  <D.27079>:
  D.27081 = method;
  return D.27081;
  <D.27080>:
  D.27077 = BIT_FIELD_REF <*method, 64, 256>;
  D.27082 = D.27077 & 2251799813685248;
  if (D.27082 != 0) goto <D.27083>; else goto <D.27084>;
  <D.27083>:
  D.27085 = mono_method_get_context (method);
  D.27086 = D.27085->method_inst;
  if (D.27086 == 0B) goto <D.27087>; else goto <D.27088>;
  <D.27087>:
  orig_method = method;
  ctx = &MEM[(struct MonoMethodInflated *)method].context;
  method = MEM[(struct MonoMethodInflated *)method].declaring;
  container = mono_method_get_generic_container (method);
  if (container == 0B) goto <D.27089>; else goto <D.27090>;
  <D.27089>:
  D.27091 = method->klass;
  container = D.27091->generic_container;
  <D.27090>:
  D.27092 = container == 0B;
  D.27093 = (long int) D.27092;
  D.27094 = __builtin_expect (D.27093, 0);
  if (D.27094 != 0) goto <D.27095>; else goto <D.27096>;
  <D.27095>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 10410, "container");
  <D.27096>:
  <D.27088>:
  <D.27084>:
  if (ctx != 0B) goto <D.27097>; else goto <D.27098>;
  <D.27097>:
  D.27091 = method->klass;
  D.27099 = D.27091->image;
  D.27100 = &D.27099->synchronized_generic_cache;
  cache = get_cache (D.27100, mono_aligned_addr_hash, 0B);
  res = check_generic_wrapper_cache (cache, orig_method, orig_method, method);
  if (res != 0B) goto <D.27101>; else goto <D.27102>;
  <D.27101>:
  D.27081 = res;
  return D.27081;
  <D.27102>:
  goto <D.27103>;
  <D.27098>:
  D.27091 = method->klass;
  D.27099 = D.27091->image;
  D.27104 = &D.27099->synchronized_cache;
  cache = get_cache (D.27104, mono_aligned_addr_hash, 0B);
  res = mono_marshal_find_in_cache (cache, method);
  if (res != 0B) goto <D.27105>; else goto <D.27106>;
  <D.27105>:
  D.27081 = res;
  return D.27081;
  <D.27106>:
  <D.27103>:
  D.27091 = method->klass;
  D.27099 = D.27091->image;
  D.27107 = mono_method_signature (method);
  sig = signature_dup (D.27099, D.27107);
  sig->pinvoke = 0;
  D.27091 = method->klass;
  D.27108 = method->name;
  mb = mono_mb_new (D.27091, D.27108, 16);
  D.27109 = sig->ret;
  D.27110 = mono_type_is_void (D.27109);
  if (D.27110 == 0) goto <D.27111>; else goto <D.27112>;
  <D.27111>:
  D.27109 = sig->ret;
  ret_local = mono_mb_add_local (mb, D.27109);
  <D.27112>:
  D.27091 = method->klass;
  D.27113 = BIT_FIELD_REF <*D.27091, 64, 256>;
  D.27114 = D.27113 & 1152921504606846976;
  if (D.27114 != 0) goto <D.27115>; else goto <D.27116>;
  <D.27115>:
  D.27117 = method->flags;
  D.27118 = (int) D.27117;
  D.27119 = D.27118 & 16;
  if (D.27119 == 0) goto <D.27120>; else goto <D.27121>;
  <D.27120>:
  D.27091 = method->klass;
  mono_class_set_failure (D.27091, 7, 0B);
  mono_mb_emit_byte (mb, 20);
  D.27091 = method->klass;
  mono_mb_emit_op (mb, 117, D.27091);
  mono_mb_emit_byte (mb, 38);
  D.27109 = sig->ret;
  D.27122 = mono_type_is_void (D.27109);
  if (D.27122 == 0) goto <D.27123>; else goto <D.27124>;
  <D.27123>:
  ret_local.323 = (unsigned int) ret_local;
  mono_mb_emit_ldloc (mb, ret_local.323);
  <D.27124>:
  mono_mb_emit_byte (mb, 42);
  D.27126 = sig->param_count;
  D.27127 = (int) D.27126;
  D.27128 = D.27127 + 16;
  res = mono_mb_create_and_cache (cache, method, mb, sig, D.27128);
  mono_mb_free (mb);
  D.27081 = res;
  return D.27081;
  <D.27121>:
  <D.27116>:
  D.27129 = mono_defaults.object_class;
  D.27130 = &D.27129->byval_arg;
  this_local = mono_mb_add_local (mb, D.27130);
  D.27091 = method->klass;
  D.27099 = D.27091->image;
  clause = mono_image_alloc0 (D.27099, 32);
  clause->flags = 2;
  {
    int ret;

    ret = pthread_mutex_lock (&marshal_mutex.mutex);
    if (ret != 0) goto <D.27131>; else goto <D.27132>;
    <D.27131>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.27132>:
    D.27133 = ret != 0;
    D.27134 = (long int) D.27133;
    D.27135 = __builtin_expect (D.27134, 0);
    if (D.27135 != 0) goto <D.27136>; else goto <D.27137>;
    <D.27136>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 10466, "ret == 0");
    <D.27137>:
  }
  enter_method.324 = enter_method;
  if (enter_method.324 == 0B) goto <D.27139>; else goto <D.27140>;
  <D.27139>:
  {
    struct MonoMethodDesc * desc;

    desc = mono_method_desc_new ("Monitor:Enter", 0);
    D.27141 = mono_defaults.monitor_class;
    enter_method.325 = mono_method_desc_search_in_class (desc, D.27141);
    enter_method = enter_method.325;
    enter_method.324 = enter_method;
    D.27143 = enter_method.324 == 0B;
    D.27144 = (long int) D.27143;
    D.27145 = __builtin_expect (D.27144, 0);
    if (D.27145 != 0) goto <D.27146>; else goto <D.27147>;
    <D.27146>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 10473, "enter_method");
    <D.27147>:
    mono_method_desc_free (desc);
    desc = mono_method_desc_new ("Monitor:Exit", 0);
    D.27141 = mono_defaults.monitor_class;
    exit_method.326 = mono_method_desc_search_in_class (desc, D.27141);
    exit_method = exit_method.326;
    exit_method.327 = exit_method;
    D.27150 = exit_method.327 == 0B;
    D.27151 = (long int) D.27150;
    D.27152 = __builtin_expect (D.27151, 0);
    if (D.27152 != 0) goto <D.27153>; else goto <D.27154>;
    <D.27153>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 10478, "exit_method");
    <D.27154>:
    mono_method_desc_free (desc);
    desc = mono_method_desc_new ("Type:GetTypeFromHandle", 0);
    D.27155 = mono_defaults.systemtype_class;
    gettypefromhandle_method.328 = mono_method_desc_search_in_class (desc, D.27155);
    gettypefromhandle_method = gettypefromhandle_method.328;
    gettypefromhandle_method.329 = gettypefromhandle_method;
    D.27158 = gettypefromhandle_method.329 == 0B;
    D.27159 = (long int) D.27158;
    D.27160 = __builtin_expect (D.27159, 0);
    if (D.27160 != 0) goto <D.27161>; else goto <D.27162>;
    <D.27161>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 10483, "gettypefromhandle_method");
    <D.27162>:
    mono_method_desc_free (desc);
  }
  <D.27140>:
  {
    int ret;

    ret = pthread_mutex_unlock (&marshal_mutex.mutex);
    if (ret != 0) goto <D.27163>; else goto <D.27164>;
    <D.27163>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.27164>:
    D.27165 = ret != 0;
    D.27166 = (long int) D.27165;
    D.27167 = __builtin_expect (D.27166, 0);
    if (D.27167 != 0) goto <D.27168>; else goto <D.27169>;
    <D.27168>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 10487, "ret == 0");
    <D.27169>:
  }
  D.27117 = method->flags;
  D.27118 = (int) D.27117;
  D.27119 = D.27118 & 16;
  if (D.27119 != 0) goto <D.27170>; else goto <D.27171>;
  <D.27170>:
  {
    int index;

    D.27091 = method->klass;
    D.27172 = mono_mb_add_data (mb, D.27091);
    index = (int) D.27172;
    D.27173 = mono_defaults.typehandle_class;
    mono_mb_add_data (mb, D.27173);
    mono_mb_emit_byte (mb, 208);
    mono_mb_emit_i4 (mb, index);
    gettypefromhandle_method.329 = gettypefromhandle_method;
    mono_mb_emit_managed_call (mb, gettypefromhandle_method.329, 0B);
  }
  goto <D.27174>;
  <D.27171>:
  mono_mb_emit_ldarg (mb, 0);
  <D.27174>:
  this_local.330 = (unsigned int) this_local;
  mono_mb_emit_stloc (mb, this_local.330);
  this_local.330 = (unsigned int) this_local;
  mono_mb_emit_ldloc (mb, this_local.330);
  enter_method.324 = enter_method;
  mono_mb_emit_managed_call (mb, enter_method.324, 0B);
  D.27176 = mono_mb_get_label (mb);
  D.27177 = (unsigned int) D.27176;
  clause->try_offset = D.27177;
  D.27178 = BIT_FIELD_REF <*sig, 64, 64>;
  D.27179 = D.27178 & 512;
  if (D.27179 != 0) goto <D.27180>; else goto <D.27181>;
  <D.27180>:
  mono_mb_emit_ldarg (mb, 0);
  <D.27181>:
  i = 0;
  goto <D.21247>;
  <D.21246>:
  D.27178 = BIT_FIELD_REF <*sig, 64, 64>;
  D.27179 = D.27178 & 512;
  D.27182 = D.27179 != 0;
  D.27183 = (int) D.27182;
  D.27184 = D.27183 + i;
  D.27185 = (unsigned int) D.27184;
  mono_mb_emit_ldarg (mb, D.27185);
  i = i + 1;
  <D.21247>:
  D.27126 = sig->param_count;
  D.27127 = (int) D.27126;
  if (D.27127 > i) goto <D.21246>; else goto <D.21248>;
  <D.21248>:
  if (ctx != 0B) goto <D.27186>; else goto <D.27187>;
  <D.27186>:
  D.27188 = &container->context;
  D.27189 = mono_class_inflate_generic_method (method, D.27188);
  mono_mb_emit_managed_call (mb, D.27189, 0B);
  goto <D.27190>;
  <D.27187>:
  mono_mb_emit_managed_call (mb, method, 0B);
  <D.27190>:
  D.27109 = sig->ret;
  D.27191 = mono_type_is_void (D.27109);
  if (D.27191 == 0) goto <D.27192>; else goto <D.27193>;
  <D.27192>:
  ret_local.323 = (unsigned int) ret_local;
  mono_mb_emit_stloc (mb, ret_local.323);
  <D.27193>:
  D.27194 = mono_mb_emit_branch (mb, 221);
  pos = (int) D.27194;
  D.27195 = mono_mb_get_pos (mb);
  D.27196 = (unsigned int) D.27195;
  D.27197 = clause->try_offset;
  D.27198 = D.27196 - D.27197;
  clause->try_len = D.27198;
  D.27199 = mono_mb_get_label (mb);
  D.27200 = (unsigned int) D.27199;
  clause->handler_offset = D.27200;
  this_local.330 = (unsigned int) this_local;
  mono_mb_emit_ldloc (mb, this_local.330);
  exit_method.327 = exit_method;
  mono_mb_emit_managed_call (mb, exit_method.327, 0B);
  mono_mb_emit_byte (mb, 220);
  D.27201 = mono_mb_get_pos (mb);
  D.27202 = (unsigned int) D.27201;
  D.27203 = clause->handler_offset;
  D.27204 = D.27202 - D.27203;
  clause->handler_len = D.27204;
  pos.331 = (unsigned int) pos;
  mono_mb_patch_branch (mb, pos.331);
  D.27109 = sig->ret;
  D.27206 = mono_type_is_void (D.27109);
  if (D.27206 == 0) goto <D.27207>; else goto <D.27208>;
  <D.27207>:
  ret_local.323 = (unsigned int) ret_local;
  mono_mb_emit_ldloc (mb, ret_local.323);
  <D.27208>:
  mono_mb_emit_byte (mb, 42);
  mono_mb_set_clauses (mb, 1, clause);
  if (ctx != 0B) goto <D.27209>; else goto <D.27210>;
  <D.27209>:
  {
    struct MonoMethod * def;

    D.27126 = sig->param_count;
    D.27127 = (int) D.27126;
    D.27128 = D.27127 + 16;
    def = mono_mb_create_and_cache (cache, method, mb, sig, D.27128);
    res = cache_generic_wrapper (cache, orig_method, def, ctx, orig_method);
  }
  goto <D.27211>;
  <D.27210>:
  D.27126 = sig->param_count;
  D.27127 = (int) D.27126;
  D.27128 = D.27127 + 16;
  res = mono_mb_create_and_cache (cache, method, mb, sig, D.27128);
  <D.27211>:
  mono_mb_free (mb);
  D.27081 = res;
  return D.27081;
}


check_generic_wrapper_cache (struct GHashTable * cache, struct MonoMethod * orig_method, void * key, void * def_key)
{
  long unsigned int D.27213;
  long unsigned int D.27214;
  _Bool D.27215;
  long int D.27216;
  long int D.27217;
  struct MonoMethod * D.27222;
  _Bool D.27227;
  long int D.27228;
  long int D.27229;
  _Bool D.27236;
  long int D.27237;
  long int D.27238;
  struct MonoMethod * res;
  struct MonoMethod * inst;
  struct MonoMethod * def;
  struct MonoGenericContext * ctx;
  struct MonoMethod * def_method;

  D.27213 = BIT_FIELD_REF <*orig_method, 64, 256>;
  D.27214 = D.27213 & 2251799813685248;
  D.27215 = D.27214 == 0;
  D.27216 = (long int) D.27215;
  D.27217 = __builtin_expect (D.27216, 0);
  if (D.27217 != 0) goto <D.27218>; else goto <D.27219>;
  <D.27218>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 2720, "orig_method->is_inflated");
  <D.27219>:
  def_method = MEM[(struct MonoMethodInflated *)orig_method].declaring;
  ctx = mono_method_get_context (orig_method);
  res = mono_marshal_find_in_cache (cache, key);
  if (res != 0B) goto <D.27220>; else goto <D.27221>;
  <D.27220>:
  D.27222 = res;
  return D.27222;
  <D.27221>:
  def = mono_marshal_find_in_cache (cache, def_key);
  if (def != 0B) goto <D.27223>; else goto <D.27224>;
  <D.27223>:
  inst = mono_class_inflate_generic_method (def, ctx);
  mono_memory_barrier ();
  {
    int ret;

    ret = pthread_mutex_lock (&marshal_mutex.mutex);
    if (ret != 0) goto <D.27225>; else goto <D.27226>;
    <D.27225>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.27226>:
    D.27227 = ret != 0;
    D.27228 = (long int) D.27227;
    D.27229 = __builtin_expect (D.27228, 0);
    if (D.27229 != 0) goto <D.27230>; else goto <D.27231>;
    <D.27230>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 2739, "ret == 0");
    <D.27231>:
  }
  res = monoeg_g_hash_table_lookup (cache, key);
  if (res == 0B) goto <D.27232>; else goto <D.27233>;
  <D.27232>:
  monoeg_g_hash_table_insert_replace (cache, key, inst, 0);
  res = inst;
  <D.27233>:
  {
    int ret;

    ret = pthread_mutex_unlock (&marshal_mutex.mutex);
    if (ret != 0) goto <D.27234>; else goto <D.27235>;
    <D.27234>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.27235>:
    D.27236 = ret != 0;
    D.27237 = (long int) D.27236;
    D.27238 = __builtin_expect (D.27237, 0);
    if (D.27238 != 0) goto <D.27239>; else goto <D.27240>;
    <D.27239>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 2745, "ret == 0");
    <D.27240>:
  }
  D.27222 = res;
  return D.27222;
  <D.27224>:
  D.27222 = 0B;
  return D.27222;
}


cache_generic_wrapper (struct GHashTable * cache, struct MonoMethod * orig_method, struct MonoMethod * def, struct MonoGenericContext * ctx, void * key)
{
  _Bool D.27244;
  long int D.27245;
  long int D.27246;
  _Bool D.27253;
  long int D.27254;
  long int D.27255;
  struct MonoMethod * D.27258;
  struct MonoMethod * inst;
  struct MonoMethod * res;

  inst = mono_class_inflate_generic_method (def, ctx);
  mono_memory_barrier ();
  {
    int ret;

    ret = pthread_mutex_lock (&marshal_mutex.mutex);
    if (ret != 0) goto <D.27242>; else goto <D.27243>;
    <D.27242>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.27243>:
    D.27244 = ret != 0;
    D.27245 = (long int) D.27244;
    D.27246 = __builtin_expect (D.27245, 0);
    if (D.27246 != 0) goto <D.27247>; else goto <D.27248>;
    <D.27247>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 2761, "ret == 0");
    <D.27248>:
  }
  res = monoeg_g_hash_table_lookup (cache, key);
  if (res == 0B) goto <D.27249>; else goto <D.27250>;
  <D.27249>:
  monoeg_g_hash_table_insert_replace (cache, key, inst, 0);
  res = inst;
  <D.27250>:
  {
    int ret;

    ret = pthread_mutex_unlock (&marshal_mutex.mutex);
    if (ret != 0) goto <D.27251>; else goto <D.27252>;
    <D.27251>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.27252>:
    D.27253 = ret != 0;
    D.27254 = (long int) D.27253;
    D.27255 = __builtin_expect (D.27254, 0);
    if (D.27255 != 0) goto <D.27256>; else goto <D.27257>;
    <D.27256>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 2767, "ret == 0");
    <D.27257>:
  }
  D.27258 = res;
  return D.27258;
}


__attribute__((visibility ("hidden")))
mono_marshal_get_unbox_wrapper (struct MonoMethod * method)
{
  struct MonoClass * D.27260;
  struct MonoImage * D.27261;
  struct GHashTable * * D.27262;
  struct MonoMethod * D.27265;
  const char * D.27266;
  long unsigned int D.27267;
  long unsigned int D.27268;
  _Bool D.27269;
  long int D.27270;
  long int D.27271;
  int D.27274;
  unsigned int D.27275;
  short unsigned int D.27276;
  int D.27277;
  int D.27278;
  struct MonoMethodSignature * sig;
  int i;
  struct MonoMethodBuilder * mb;
  struct MonoMethod * res;
  struct GHashTable * cache;

  sig = mono_method_signature (method);
  D.27260 = method->klass;
  D.27261 = D.27260->image;
  D.27262 = &D.27261->unbox_wrapper_cache;
  cache = get_cache (D.27262, mono_aligned_addr_hash, 0B);
  res = mono_marshal_find_in_cache (cache, method);
  if (res != 0B) goto <D.27263>; else goto <D.27264>;
  <D.27263>:
  D.27265 = res;
  return D.27265;
  <D.27264>:
  D.27260 = method->klass;
  D.27266 = method->name;
  mb = mono_mb_new (D.27260, D.27266, 22);
  D.27267 = BIT_FIELD_REF <*sig, 64, 64>;
  D.27268 = D.27267 & 512;
  D.27269 = D.27268 == 0;
  D.27270 = (long int) D.27269;
  D.27271 = __builtin_expect (D.27270, 0);
  if (D.27271 != 0) goto <D.27272>; else goto <D.27273>;
  <D.27272>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 10576, "sig->hasthis");
  <D.27273>:
  mono_mb_emit_ldarg (mb, 0);
  mono_mb_emit_icon (mb, 16);
  mono_mb_emit_byte (mb, 88);
  i = 0;
  goto <D.21259>;
  <D.21258>:
  D.27274 = i + 1;
  D.27275 = (unsigned int) D.27274;
  mono_mb_emit_ldarg (mb, D.27275);
  i = i + 1;
  <D.21259>:
  D.27276 = sig->param_count;
  D.27277 = (int) D.27276;
  if (D.27277 > i) goto <D.21258>; else goto <D.21260>;
  <D.21260>:
  mono_mb_emit_managed_call (mb, method, 0B);
  mono_mb_emit_byte (mb, 42);
  D.27276 = sig->param_count;
  D.27277 = (int) D.27276;
  D.27278 = D.27277 + 16;
  res = mono_mb_create_and_cache (cache, method, mb, sig, D.27278);
  mono_mb_free (mb);
  D.27265 = res;
  return D.27265;
}


__attribute__((visibility ("hidden")))
mono_marshal_get_virtual_stelemref (struct MonoClass * array_class)
{
  unsigned char D.27280;
  _Bool D.27281;
  long int D.27282;
  long int D.27283;
  struct MonoClass * D.27286;
  struct MonoMethod * D.27287;
  int kind;

  D.27280 = array_class->rank;
  D.27281 = D.27280 != 1;
  D.27282 = (long int) D.27281;
  D.27283 = __builtin_expect (D.27282, 0);
  if (D.27283 != 0) goto <D.27284>; else goto <D.27285>;
  <D.27284>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 11083, "array_class->rank == 1");
  <D.27285>:
  D.27286 = array_class->element_class;
  kind = get_virtual_stelemref_kind (D.27286);
  D.27287 = get_virtual_stelemref_wrapper (kind);
  return D.27287;
}


get_virtual_stelemref_kind (struct MonoClass * element_class)
{
  struct MonoClass * D.27289;
  int D.27292;
  int D.27293;
  unsigned int D.27298;
  unsigned int D.27299;
  unsigned char D.27301;
  int D.27303;
  long unsigned int D.27308;
  long unsigned int D.27309;
  unsigned char D.27311;
  int D.27313;
  unsigned int D.27314;

  D.27289 = mono_defaults.object_class;
  if (D.27289 == element_class) goto <D.27290>; else goto <D.27291>;
  <D.27290>:
  D.27292 = 0;
  return D.27292;
  <D.27291>:
  D.27293 = is_monomorphic_array (element_class);
  if (D.27293 != 0) goto <D.27294>; else goto <D.27295>;
  <D.27294>:
  D.27292 = 1;
  return D.27292;
  <D.27295>:
  D.27298 = element_class->flags;
  D.27299 = D.27298 & 32;
  if (D.27299 != 0) goto <D.27296>; else goto <D.27300>;
  <D.27300>:
  D.27301 = element_class->byval_arg.type;
  if (D.27301 == 19) goto <D.27296>; else goto <D.27302>;
  <D.27302>:
  D.27301 = element_class->byval_arg.type;
  if (D.27301 == 30) goto <D.27296>; else goto <D.27297>;
  <D.27296>:
  D.27303 = mono_class_has_variant_generic_params (element_class);
  if (D.27303 == 0) goto <D.27304>; else goto <D.27305>;
  <D.27304>:
  D.27292 = 3;
  return D.27292;
  <D.27305>:
  <D.27297>:
  D.27308 = BIT_FIELD_REF <*element_class, 64, 256>;
  D.27309 = D.27308 & 2199023255552;
  if (D.27309 != 0) goto <D.27306>; else goto <D.27310>;
  <D.27310>:
  D.27311 = element_class->rank;
  if (D.27311 != 0) goto <D.27306>; else goto <D.27312>;
  <D.27312>:
  D.27313 = mono_class_has_variant_generic_params (element_class);
  if (D.27313 != 0) goto <D.27306>; else goto <D.27307>;
  <D.27306>:
  D.27292 = 4;
  return D.27292;
  <D.27307>:
  D.27298 = element_class->flags;
  D.27314 = D.27298 & 256;
  if (D.27314 != 0) goto <D.27315>; else goto <D.27316>;
  <D.27315>:
  D.27292 = 1;
  return D.27292;
  <D.27316>:
  D.27292 = 2;
  return D.27292;
}


is_monomorphic_array (struct MonoClass * klass)
{
  unsigned char D.27318;
  gboolean D.27321;
  int iftmp.332;
  unsigned int D.27326;
  unsigned int D.27327;
  long unsigned int D.27329;
  long unsigned int D.27330;
  struct MonoClass * element_class;

  D.27318 = klass->rank;
  if (D.27318 != 1) goto <D.27319>; else goto <D.27320>;
  <D.27319>:
  D.27321 = 0;
  return D.27321;
  <D.27320>:
  element_class = klass->element_class;
  D.27326 = element_class->flags;
  D.27327 = D.27326 & 256;
  if (D.27327 != 0) goto <D.27323>; else goto <D.27328>;
  <D.27328>:
  D.27329 = BIT_FIELD_REF <*element_class, 64, 256>;
  D.27330 = D.27329 & 1152921504606846976;
  if (D.27330 != 0) goto <D.27323>; else goto <D.27324>;
  <D.27323>:
  iftmp.332 = 1;
  goto <D.27325>;
  <D.27324>:
  iftmp.332 = 0;
  <D.27325>:
  D.27321 = iftmp.332;
  return D.27321;
}


get_virtual_stelemref_wrapper (int kind)
{
  struct MonoMethod * D.27332;
  struct MonoMethod * D.27335;
  const char * D.27336;
  struct MonoClass * D.27337;
  struct MonoMethodSignature * signature.333;
  struct MonoImage * D.27341;
  struct MonoClass * D.27342;
  struct MonoType * D.27343;
  struct MonoClass * D.27344;
  struct MonoType * D.27345;
  struct MonoType * D.27346;
  struct MonoType * D.27347;
  unsigned int array_slot_addr.334;
  unsigned int aklass.335;
  unsigned int vklass.336;
  struct MonoClass * D.27351;
  struct MonoType * D.27352;
  unsigned int vtable.337;
  unsigned int uiid.338;
  struct MonoMethod * D.27355;
  short unsigned int D.27358;
  short unsigned int D.27359;
  _Bool D.27362;
  long int D.27363;
  long int D.27364;
  _Bool D.27371;
  long int D.27372;
  long int D.27373;
  _Bool D.27379;
  long int D.27380;
  long int D.27381;
  static struct MonoMethod * cached_methods[5] = {0B};
  static struct MonoMethodSignature * signature;
  struct MonoMethodBuilder * mb;
  struct MonoMethod * res;
  char * name;
  const char * param_names[16];
  guint32 b1;
  guint32 b2;
  guint32 b3;
  int aklass;
  int vklass;
  int vtable;
  int uiid;
  int array_slot_addr;
  struct WrapperInfo * info;

  try
    {
      D.27332 = cached_methods[kind];
      if (D.27332 != 0B) goto <D.27333>; else goto <D.27334>;
      <D.27333>:
      D.27335 = cached_methods[kind];
      return D.27335;
      <D.27334>:
      D.27336 = strelemref_wrapper_name[kind];
      name = monoeg_g_strdup_printf ("virt_stelemref_%s", D.27336);
      D.27337 = mono_defaults.object_class;
      mb = mono_mb_new (D.27337, name, 21);
      monoeg_g_free (name);
      signature.333 = signature;
      if (signature.333 == 0B) goto <D.27339>; else goto <D.27340>;
      <D.27339>:
      {
        struct MonoMethodSignature * sig;

        D.27341 = mono_defaults.corlib;
        sig = mono_metadata_signature_alloc (D.27341, 2);
        D.27342 = mono_defaults.void_class;
        D.27343 = &D.27342->byval_arg;
        sig->ret = D.27343;
        sig->hasthis = 1;
        D.27344 = mono_defaults.int_class;
        D.27345 = &D.27344->byval_arg;
        sig->params[0] = D.27345;
        D.27337 = mono_defaults.object_class;
        D.27346 = &D.27337->byval_arg;
        sig->params[1] = D.27346;
        signature = sig;
      }
      <D.27340>:
      param_names[0] = "index";
      param_names[1] = "value";
      mono_mb_set_param_names (mb, &param_names);
      switch (kind) <default: <D.21312>, case 0: <D.21306>, case 1: <D.21309>, case 2: <D.21310>, case 3: <D.21311>, case 4: <D.21308>>
      <D.21306>:
      load_array_element_address (mb);
      mono_mb_emit_ldarg (mb, 2);
      mono_mb_emit_byte (mb, 81);
      mono_mb_emit_byte (mb, 42);
      goto <D.21307>;
      <D.21308>:
      D.27344 = mono_defaults.int_class;
      D.27345 = &D.27344->byval_arg;
      aklass = mono_mb_add_local (mb, D.27345);
      D.27337 = mono_defaults.object_class;
      D.27347 = &D.27337->this_arg;
      array_slot_addr = mono_mb_add_local (mb, D.27347);
      load_array_element_address (mb);
      array_slot_addr.334 = (unsigned int) array_slot_addr;
      mono_mb_emit_stloc (mb, array_slot_addr.334);
      mono_mb_emit_ldarg (mb, 2);
      b1 = mono_mb_emit_branch (mb, 57);
      load_array_class (mb, aklass);
      mono_mb_emit_ldarg (mb, 2);
      aklass.335 = (unsigned int) aklass;
      mono_mb_emit_ldloc (mb, aklass.335);
      mono_mb_emit_icall (mb, mono_object_isinst);
      b2 = mono_mb_emit_branch (mb, 57);
      mono_mb_patch_branch (mb, b1);
      array_slot_addr.334 = (unsigned int) array_slot_addr;
      mono_mb_emit_ldloc (mb, array_slot_addr.334);
      mono_mb_emit_ldarg (mb, 2);
      mono_mb_emit_byte (mb, 81);
      mono_mb_emit_byte (mb, 42);
      mono_mb_patch_branch (mb, b2);
      mono_mb_emit_exception (mb, "ArrayTypeMismatchException", 0B);
      goto <D.21307>;
      <D.21309>:
      D.27344 = mono_defaults.int_class;
      D.27345 = &D.27344->byval_arg;
      aklass = mono_mb_add_local (mb, D.27345);
      D.27344 = mono_defaults.int_class;
      D.27345 = &D.27344->byval_arg;
      vklass = mono_mb_add_local (mb, D.27345);
      D.27337 = mono_defaults.object_class;
      D.27347 = &D.27337->this_arg;
      array_slot_addr = mono_mb_add_local (mb, D.27347);
      load_array_element_address (mb);
      array_slot_addr.334 = (unsigned int) array_slot_addr;
      mono_mb_emit_stloc (mb, array_slot_addr.334);
      mono_mb_emit_ldarg (mb, 2);
      b1 = mono_mb_emit_branch (mb, 57);
      load_array_class (mb, aklass);
      load_value_class (mb, vklass);
      aklass.335 = (unsigned int) aklass;
      mono_mb_emit_ldloc (mb, aklass.335);
      vklass.336 = (unsigned int) vklass;
      mono_mb_emit_ldloc (mb, vklass.336);
      b2 = mono_mb_emit_branch (mb, 64);
      mono_mb_patch_branch (mb, b1);
      array_slot_addr.334 = (unsigned int) array_slot_addr;
      mono_mb_emit_ldloc (mb, array_slot_addr.334);
      mono_mb_emit_ldarg (mb, 2);
      mono_mb_emit_byte (mb, 81);
      mono_mb_emit_byte (mb, 42);
      mono_mb_patch_branch (mb, b2);
      mono_mb_emit_exception (mb, "ArrayTypeMismatchException", 0B);
      goto <D.21307>;
      <D.21310>:
      D.27344 = mono_defaults.int_class;
      D.27345 = &D.27344->byval_arg;
      aklass = mono_mb_add_local (mb, D.27345);
      D.27344 = mono_defaults.int_class;
      D.27345 = &D.27344->byval_arg;
      vklass = mono_mb_add_local (mb, D.27345);
      D.27337 = mono_defaults.object_class;
      D.27347 = &D.27337->this_arg;
      array_slot_addr = mono_mb_add_local (mb, D.27347);
      load_array_element_address (mb);
      array_slot_addr.334 = (unsigned int) array_slot_addr;
      mono_mb_emit_stloc (mb, array_slot_addr.334);
      mono_mb_emit_ldarg (mb, 2);
      b1 = mono_mb_emit_branch (mb, 57);
      load_array_class (mb, aklass);
      load_value_class (mb, vklass);
      mono_mb_emit_ldarg (mb, 2);
      aklass.335 = (unsigned int) aklass;
      mono_mb_emit_ldloc (mb, aklass.335);
      mono_mb_emit_icall (mb, mono_object_isinst);
      b2 = mono_mb_emit_branch (mb, 57);
      vklass.336 = (unsigned int) vklass;
      mono_mb_emit_ldloc (mb, vklass.336);
      mono_mb_emit_ldflda (mb, 24);
      mono_mb_emit_byte (mb, 73);
      aklass.335 = (unsigned int) aklass;
      mono_mb_emit_ldloc (mb, aklass.335);
      mono_mb_emit_ldflda (mb, 24);
      mono_mb_emit_byte (mb, 73);
      b2 = mono_mb_emit_branch (mb, 68);
      vklass.336 = (unsigned int) vklass;
      mono_mb_emit_ldloc (mb, vklass.336);
      mono_mb_emit_ldflda (mb, 16);
      mono_mb_emit_byte (mb, 77);
      aklass.335 = (unsigned int) aklass;
      mono_mb_emit_ldloc (mb, aklass.335);
      mono_mb_emit_ldflda (mb, 24);
      mono_mb_emit_byte (mb, 73);
      mono_mb_emit_icon (mb, 1);
      mono_mb_emit_byte (mb, 89);
      mono_mb_emit_icon (mb, 8);
      mono_mb_emit_byte (mb, 90);
      mono_mb_emit_byte (mb, 88);
      mono_mb_emit_byte (mb, 77);
      aklass.335 = (unsigned int) aklass;
      mono_mb_emit_ldloc (mb, aklass.335);
      b3 = mono_mb_emit_branch (mb, 64);
      mono_mb_patch_branch (mb, b1);
      array_slot_addr.334 = (unsigned int) array_slot_addr;
      mono_mb_emit_ldloc (mb, array_slot_addr.334);
      mono_mb_emit_ldarg (mb, 2);
      mono_mb_emit_byte (mb, 81);
      mono_mb_emit_byte (mb, 42);
      mono_mb_patch_branch (mb, b2);
      mono_mb_patch_branch (mb, b3);
      mono_mb_emit_exception (mb, "ArrayTypeMismatchException", 0B);
      goto <D.21307>;
      <D.21311>:
      D.27337 = mono_defaults.object_class;
      D.27347 = &D.27337->this_arg;
      array_slot_addr = mono_mb_add_local (mb, D.27347);
      D.27344 = mono_defaults.int_class;
      D.27345 = &D.27344->byval_arg;
      aklass = mono_mb_add_local (mb, D.27345);
      D.27344 = mono_defaults.int_class;
      D.27345 = &D.27344->byval_arg;
      vtable = mono_mb_add_local (mb, D.27345);
      D.27351 = mono_defaults.int32_class;
      D.27352 = &D.27351->byval_arg;
      uiid = mono_mb_add_local (mb, D.27352);
      load_array_element_address (mb);
      array_slot_addr.334 = (unsigned int) array_slot_addr;
      mono_mb_emit_stloc (mb, array_slot_addr.334);
      mono_mb_emit_ldarg (mb, 2);
      b1 = mono_mb_emit_branch (mb, 57);
      load_array_class (mb, aklass);
      mono_mb_emit_ldarg (mb, 2);
      mono_mb_emit_ldflda (mb, 0);
      mono_mb_emit_byte (mb, 77);
      vtable.337 = (unsigned int) vtable;
      mono_mb_emit_stloc (mb, vtable.337);
      aklass.335 = (unsigned int) aklass;
      mono_mb_emit_ldloc (mb, aklass.335);
      mono_mb_emit_ldflda (mb, 90);
      mono_mb_emit_byte (mb, 73);
      uiid.338 = (unsigned int) uiid;
      mono_mb_emit_stloc (mb, uiid.338);
      uiid.338 = (unsigned int) uiid;
      mono_mb_emit_ldloc (mb, uiid.338);
      vtable.337 = (unsigned int) vtable;
      mono_mb_emit_ldloc (mb, vtable.337);
      mono_mb_emit_ldflda (mb, 40);
      mono_mb_emit_byte (mb, 73);
      b2 = mono_mb_emit_branch (mb, 66);
      vtable.337 = (unsigned int) vtable;
      mono_mb_emit_ldloc (mb, vtable.337);
      mono_mb_emit_ldflda (mb, 32);
      mono_mb_emit_byte (mb, 77);
      uiid.338 = (unsigned int) uiid;
      mono_mb_emit_ldloc (mb, uiid.338);
      mono_mb_emit_icon (mb, 3);
      mono_mb_emit_byte (mb, 100);
      mono_mb_emit_byte (mb, 88);
      mono_mb_emit_byte (mb, 71);
      mono_mb_emit_icon (mb, 1);
      uiid.338 = (unsigned int) uiid;
      mono_mb_emit_ldloc (mb, uiid.338);
      mono_mb_emit_icon (mb, 7);
      mono_mb_emit_byte (mb, 95);
      mono_mb_emit_byte (mb, 98);
      mono_mb_emit_byte (mb, 95);
      b3 = mono_mb_emit_branch (mb, 57);
      mono_mb_patch_branch (mb, b1);
      array_slot_addr.334 = (unsigned int) array_slot_addr;
      mono_mb_emit_ldloc (mb, array_slot_addr.334);
      mono_mb_emit_ldarg (mb, 2);
      mono_mb_emit_byte (mb, 81);
      mono_mb_emit_byte (mb, 42);
      mono_mb_patch_branch (mb, b2);
      mono_mb_patch_branch (mb, b3);
      mono_mb_emit_exception (mb, "ArrayTypeMismatchException", 0B);
      goto <D.21307>;
      <D.21312>:
      mono_mb_emit_ldarg (mb, 0);
      mono_mb_emit_ldarg (mb, 1);
      mono_mb_emit_ldarg (mb, 2);
      D.27355 = mono_marshal_get_stelemref ();
      mono_mb_emit_managed_call (mb, D.27355, 0B);
      mono_mb_emit_byte (mb, 42);
      if (1 != 0) goto <D.27356>; else goto <D.27357>;
      <D.27356>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 11054, "0");
      <D.27357>:
      <D.21307>:
      signature.333 = signature;
      res = mono_mb_create_method (mb, signature.333, 4);
      D.27358 = res->flags;
      D.27359 = D.27358 | 64;
      res->flags = D.27359;
      info = mono_wrapper_info_create (res, 3);
      info->d.virtual_stelemref.kind = kind;
      mono_marshal_set_wrapper_info (res, info);
      {
        int ret;

        ret = pthread_mutex_lock (&marshal_mutex.mutex);
        if (ret != 0) goto <D.27360>; else goto <D.27361>;
        <D.27360>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.27361>:
        D.27362 = ret != 0;
        D.27363 = (long int) D.27362;
        D.27364 = __builtin_expect (D.27363, 0);
        if (D.27364 != 0) goto <D.27365>; else goto <D.27366>;
        <D.27365>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 11065, "ret == 0");
        <D.27366>:
      }
      D.27332 = cached_methods[kind];
      if (D.27332 == 0B) goto <D.27367>; else goto <D.27368>;
      <D.27367>:
      cached_methods[kind] = res;
      {
        int ret;

        ret = pthread_mutex_unlock (&marshal_mutex.mutex);
        if (ret != 0) goto <D.27369>; else goto <D.27370>;
        <D.27369>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.27370>:
        D.27371 = ret != 0;
        D.27372 = (long int) D.27371;
        D.27373 = __builtin_expect (D.27372, 0);
        if (D.27373 != 0) goto <D.27374>; else goto <D.27375>;
        <D.27374>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 11068, "ret == 0");
        <D.27375>:
      }
      goto <D.27376>;
      <D.27368>:
      {
        int ret;

        ret = pthread_mutex_unlock (&marshal_mutex.mutex);
        if (ret != 0) goto <D.27377>; else goto <D.27378>;
        <D.27377>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.27378>:
        D.27379 = ret != 0;
        D.27380 = (long int) D.27379;
        D.27381 = __builtin_expect (D.27380, 0);
        if (D.27381 != 0) goto <D.27382>; else goto <D.27383>;
        <D.27382>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 11070, "ret == 0");
        <D.27383>:
      }
      mono_free_method (res);
      <D.27376>:
      mono_mb_free (mb);
      D.27335 = cached_methods[kind];
      return D.27335;
    }
  finally
    {
      param_names = {CLOBBER};
    }
}


load_value_class (struct MonoMethodBuilder * mb, int vklass)
{
  unsigned int vklass.339;

  mono_mb_emit_ldarg (mb, 2);
  mono_mb_emit_ldflda (mb, 0);
  mono_mb_emit_byte (mb, 77);
  mono_mb_emit_ldflda (mb, 0);
  mono_mb_emit_byte (mb, 77);
  vklass.339 = (unsigned int) vklass;
  mono_mb_emit_stloc (mb, vklass.339);
}


load_array_element_address (struct MonoMethodBuilder * mb)
{
  struct MonoClass * D.27387;

  mono_mb_emit_ldarg (mb, 0);
  mono_mb_emit_ldarg (mb, 1);
  D.27387 = mono_defaults.object_class;
  mono_mb_emit_op (mb, 143, D.27387);
}


load_array_class (struct MonoMethodBuilder * mb, int aklass)
{
  unsigned int aklass.340;

  mono_mb_emit_ldarg (mb, 0);
  mono_mb_emit_ldflda (mb, 0);
  mono_mb_emit_byte (mb, 77);
  mono_mb_emit_ldflda (mb, 0);
  mono_mb_emit_byte (mb, 77);
  mono_mb_emit_ldflda (mb, 0);
  mono_mb_emit_byte (mb, 77);
  aklass.340 = (unsigned int) aklass;
  mono_mb_emit_stloc (mb, aklass.340);
}


__attribute__((visibility ("hidden")))
mono_marshal_get_virtual_stelemref_wrappers (int * nwrappers)
{
  long unsigned int D.27389;
  long unsigned int D.27390;
  struct MonoMethod * * D.27391;
  struct MonoMethod * D.27392;
  struct MonoMethod * * D.27393;
  struct MonoMethod * * res;
  int i;

  *nwrappers = 5;
  res = monoeg_malloc0 (40);
  i = 0;
  goto <D.21326>;
  <D.21325>:
  D.27389 = (long unsigned int) i;
  D.27390 = D.27389 * 8;
  D.27391 = res + D.27390;
  D.27392 = get_virtual_stelemref_wrapper (i);
  *D.27391 = D.27392;
  i = i + 1;
  <D.21326>:
  if (i <= 4) goto <D.21325>; else goto <D.21327>;
  <D.21327>:
  D.27393 = res;
  return D.27393;
}


__attribute__((visibility ("hidden")))
mono_marshal_get_stelemref ()
{
  struct MonoMethod * ret.341;
  struct MonoMethod * D.27398;
  struct MonoClass * D.27399;
  struct MonoImage * D.27400;
  struct MonoClass * D.27401;
  struct MonoType * D.27402;
  struct MonoType * D.27403;
  struct MonoClass * D.27404;
  struct MonoType * D.27405;
  struct MonoType * D.27406;
  unsigned int array_slot_addr.342;
  unsigned int aklass.343;
  unsigned int vklass.344;
  int D.27410;
  int b4.345;
  unsigned int D.27412;
  unsigned int D.27413;
  int D.27414;
  struct MonoMethod * ret.346;
  static struct MonoMethod * ret = 0B;
  struct MonoMethodSignature * sig;
  struct MonoMethodBuilder * mb;
  struct WrapperInfo * info;
  guint32 b1;
  guint32 b2;
  guint32 b3;
  guint32 b4;
  guint32 copy_pos;
  int aklass;
  int vklass;
  int array_slot_addr;

  ret.341 = ret;
  if (ret.341 != 0B) goto <D.27396>; else goto <D.27397>;
  <D.27396>:
  D.27398 = ret;
  return D.27398;
  <D.27397>:
  D.27399 = mono_defaults.object_class;
  mb = mono_mb_new (D.27399, "stelemref", 21);
  D.27400 = mono_defaults.corlib;
  sig = mono_metadata_signature_alloc (D.27400, 3);
  D.27401 = mono_defaults.void_class;
  D.27402 = &D.27401->byval_arg;
  sig->ret = D.27402;
  D.27399 = mono_defaults.object_class;
  D.27403 = &D.27399->byval_arg;
  sig->params[0] = D.27403;
  D.27404 = mono_defaults.int_class;
  D.27405 = &D.27404->byval_arg;
  sig->params[1] = D.27405;
  D.27399 = mono_defaults.object_class;
  D.27403 = &D.27399->byval_arg;
  sig->params[2] = D.27403;
  D.27404 = mono_defaults.int_class;
  D.27405 = &D.27404->byval_arg;
  aklass = mono_mb_add_local (mb, D.27405);
  D.27404 = mono_defaults.int_class;
  D.27405 = &D.27404->byval_arg;
  vklass = mono_mb_add_local (mb, D.27405);
  D.27399 = mono_defaults.object_class;
  D.27406 = &D.27399->this_arg;
  array_slot_addr = mono_mb_add_local (mb, D.27406);
  mono_mb_emit_ldarg (mb, 0);
  mono_mb_emit_ldarg (mb, 1);
  D.27399 = mono_defaults.object_class;
  mono_mb_emit_op (mb, 143, D.27399);
  array_slot_addr.342 = (unsigned int) array_slot_addr;
  mono_mb_emit_stloc (mb, array_slot_addr.342);
  mono_mb_emit_ldarg (mb, 2);
  b1 = mono_mb_emit_branch (mb, 57);
  mono_mb_emit_ldarg (mb, 0);
  mono_mb_emit_ldflda (mb, 0);
  mono_mb_emit_byte (mb, 77);
  mono_mb_emit_ldflda (mb, 0);
  mono_mb_emit_byte (mb, 77);
  mono_mb_emit_ldflda (mb, 0);
  mono_mb_emit_byte (mb, 77);
  aklass.343 = (unsigned int) aklass;
  mono_mb_emit_stloc (mb, aklass.343);
  mono_mb_emit_ldarg (mb, 2);
  mono_mb_emit_ldflda (mb, 0);
  mono_mb_emit_byte (mb, 77);
  mono_mb_emit_ldflda (mb, 0);
  mono_mb_emit_byte (mb, 77);
  vklass.344 = (unsigned int) vklass;
  mono_mb_emit_stloc (mb, vklass.344);
  vklass.344 = (unsigned int) vklass;
  mono_mb_emit_ldloc (mb, vklass.344);
  mono_mb_emit_ldflda (mb, 24);
  mono_mb_emit_byte (mb, 73);
  aklass.343 = (unsigned int) aklass;
  mono_mb_emit_ldloc (mb, aklass.343);
  mono_mb_emit_ldflda (mb, 24);
  mono_mb_emit_byte (mb, 73);
  b2 = mono_mb_emit_branch (mb, 68);
  vklass.344 = (unsigned int) vklass;
  mono_mb_emit_ldloc (mb, vklass.344);
  mono_mb_emit_ldflda (mb, 16);
  mono_mb_emit_byte (mb, 77);
  aklass.343 = (unsigned int) aklass;
  mono_mb_emit_ldloc (mb, aklass.343);
  mono_mb_emit_ldflda (mb, 24);
  mono_mb_emit_byte (mb, 73);
  mono_mb_emit_icon (mb, 1);
  mono_mb_emit_byte (mb, 89);
  mono_mb_emit_icon (mb, 8);
  mono_mb_emit_byte (mb, 90);
  mono_mb_emit_byte (mb, 88);
  mono_mb_emit_byte (mb, 77);
  aklass.343 = (unsigned int) aklass;
  mono_mb_emit_ldloc (mb, aklass.343);
  b3 = mono_mb_emit_branch (mb, 64);
  D.27410 = mono_mb_get_label (mb);
  copy_pos = (guint32) D.27410;
  mono_mb_patch_branch (mb, b1);
  array_slot_addr.342 = (unsigned int) array_slot_addr;
  mono_mb_emit_ldloc (mb, array_slot_addr.342);
  mono_mb_emit_ldarg (mb, 2);
  mono_mb_emit_byte (mb, 81);
  mono_mb_emit_byte (mb, 42);
  mono_mb_patch_branch (mb, b2);
  mono_mb_patch_branch (mb, b3);
  mono_mb_emit_ldarg (mb, 2);
  aklass.343 = (unsigned int) aklass;
  mono_mb_emit_ldloc (mb, aklass.343);
  mono_mb_emit_icall (mb, mono_object_isinst);
  b4 = mono_mb_emit_branch (mb, 58);
  b4.345 = (int) b4;
  D.27412 = copy_pos - b4;
  D.27413 = D.27412 + 4294967292;
  D.27414 = (int) D.27413;
  mono_mb_patch_addr (mb, b4.345, D.27414);
  mono_mb_emit_exception (mb, "ArrayTypeMismatchException", 0B);
  mono_mb_emit_byte (mb, 42);
  ret.346 = mono_mb_create_method (mb, sig, 4);
  ret = ret.346;
  mono_mb_free (mb);
  ret.341 = ret;
  info = mono_wrapper_info_create (ret.341, 0);
  ret.341 = ret;
  mono_marshal_set_wrapper_info (ret.341, info);
  D.27398 = ret;
  return D.27398;
}


__attribute__((visibility ("hidden")))
mono_marshal_get_gsharedvt_in_wrapper ()
{
  struct MonoMethod * ret.347;
  struct MonoMethod * D.27420;
  struct MonoClass * D.27421;
  struct MonoImage * D.27422;
  struct MonoClass * D.27423;
  struct MonoType * D.27424;
  struct MonoMethod * ret.348;
  static struct MonoMethod * ret = 0B;
  struct MonoMethodSignature * sig;
  struct MonoMethodBuilder * mb;
  struct WrapperInfo * info;

  ret.347 = ret;
  if (ret.347 != 0B) goto <D.27418>; else goto <D.27419>;
  <D.27418>:
  D.27420 = ret;
  return D.27420;
  <D.27419>:
  D.27421 = mono_defaults.object_class;
  mb = mono_mb_new (D.27421, "gsharedvt_in", 25);
  D.27422 = mono_defaults.corlib;
  sig = mono_metadata_signature_alloc (D.27422, 0);
  D.27423 = mono_defaults.void_class;
  D.27424 = &D.27423->byval_arg;
  sig->ret = D.27424;
  mono_mb_emit_byte (mb, 42);
  ret.348 = mono_mb_create_method (mb, sig, 4);
  ret = ret.348;
  mono_mb_free (mb);
  ret.347 = ret;
  info = mono_wrapper_info_create (ret.347, 18);
  ret.347 = ret;
  mono_marshal_set_wrapper_info (ret.347, info);
  D.27420 = ret;
  return D.27420;
}


__attribute__((visibility ("hidden")))
mono_marshal_get_gsharedvt_out_wrapper ()
{
  struct MonoMethod * ret.349;
  struct MonoMethod * D.27430;
  struct MonoClass * D.27431;
  struct MonoImage * D.27432;
  struct MonoClass * D.27433;
  struct MonoType * D.27434;
  struct MonoMethod * ret.350;
  static struct MonoMethod * ret = 0B;
  struct MonoMethodSignature * sig;
  struct MonoMethodBuilder * mb;
  struct WrapperInfo * info;

  ret.349 = ret;
  if (ret.349 != 0B) goto <D.27428>; else goto <D.27429>;
  <D.27428>:
  D.27430 = ret;
  return D.27430;
  <D.27429>:
  D.27431 = mono_defaults.object_class;
  mb = mono_mb_new (D.27431, "gsharedvt_out", 25);
  D.27432 = mono_defaults.corlib;
  sig = mono_metadata_signature_alloc (D.27432, 0);
  D.27433 = mono_defaults.void_class;
  D.27434 = &D.27433->byval_arg;
  sig->ret = D.27434;
  mono_mb_emit_byte (mb, 42);
  ret.350 = mono_mb_create_method (mb, sig, 4);
  ret = ret.350;
  mono_mb_free (mb);
  ret.349 = ret;
  info = mono_wrapper_info_create (ret.349, 19);
  ret.349 = ret;
  mono_marshal_set_wrapper_info (ret.349, info);
  D.27430 = ret;
  return D.27430;
}


__attribute__((visibility ("hidden")))
mono_marshal_get_array_address (int rank, int elem_size)
{
  _Bool D.27439;
  long int D.27440;
  long int D.27441;
  struct ArrayElemAddr * elem_addr_cache.351;
  long unsigned int D.27445;
  long unsigned int D.27446;
  struct ArrayElemAddr * D.27447;
  int D.27448;
  int D.27451;
  int elem_addr_cache_next.352;
  _Bool D.27457;
  long int D.27458;
  long int D.27459;
  struct MonoMethod * D.27464;
  long unsigned int D.27465;
  long unsigned int D.27466;
  struct MonoImage * D.27467;
  int D.27468;
  unsigned int D.27469;
  struct MonoClass * D.27470;
  struct MonoType * D.27471;
  struct MonoClass * D.27472;
  struct MonoType * D.27473;
  int D.27474;
  struct MonoClass * D.27475;
  struct MonoType * D.27476;
  unsigned int bounds.353;
  unsigned int ind.354;
  unsigned int D.27479;
  unsigned int D.27480;
  unsigned int D.27481;
  unsigned int D.27482;
  unsigned int D.27483;
  int D.27484;
  unsigned int realidx.355;
  unsigned int i.356;
  unsigned int D.27487;
  int D.27488;
  long unsigned int D.27489;
  int * D.27490;
  unsigned int D.27491;
  int D.27492;
  int D.27493;
  unsigned int D.27494;
  unsigned int branch_pos.357;
  _Bool D.27498;
  long int D.27499;
  long int D.27500;
  int elem_addr_cache_size.358;
  long unsigned int D.27512;
  long unsigned int D.27513;
  long unsigned int D.27514;
  long unsigned int D.27515;
  long unsigned int D.27516;
  long unsigned int D.27517;
  struct ArrayElemAddr * D.27518;
  int D.27519;
  unsigned int rank.359;
  unsigned int elem_size.360;
  _Bool D.27524;
  long int D.27525;
  long int D.27526;
  struct MonoMethod * ret;
  struct MonoMethodBuilder * mb;
  struct MonoMethodSignature * sig;
  int i;
  int bounds;
  int ind;
  int realidx;
  int branch_pos;
  int * branch_positions;
  int cached;

  ret = 0B;
  {
    int ret;

    ret = pthread_mutex_lock (&marshal_mutex.mutex);
    if (ret != 0) goto <D.27437>; else goto <D.27438>;
    <D.27437>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.27438>:
    D.27439 = ret != 0;
    D.27440 = (long int) D.27439;
    D.27441 = __builtin_expect (D.27440, 0);
    if (D.27441 != 0) goto <D.27442>; else goto <D.27443>;
    <D.27442>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 11364, "ret == 0");
    <D.27443>:
  }
  i = 0;
  goto <D.21381>;
  <D.21380>:
  elem_addr_cache.351 = elem_addr_cache;
  D.27445 = (long unsigned int) i;
  D.27446 = D.27445 * 16;
  D.27447 = elem_addr_cache.351 + D.27446;
  D.27448 = D.27447->rank;
  if (D.27448 == rank) goto <D.27449>; else goto <D.27450>;
  <D.27449>:
  elem_addr_cache.351 = elem_addr_cache;
  D.27445 = (long unsigned int) i;
  D.27446 = D.27445 * 16;
  D.27447 = elem_addr_cache.351 + D.27446;
  D.27451 = D.27447->elem_size;
  if (D.27451 == elem_size) goto <D.27452>; else goto <D.27453>;
  <D.27452>:
  elem_addr_cache.351 = elem_addr_cache;
  D.27445 = (long unsigned int) i;
  D.27446 = D.27445 * 16;
  D.27447 = elem_addr_cache.351 + D.27446;
  ret = D.27447->method;
  goto <D.21379>;
  <D.27453>:
  <D.27450>:
  i = i + 1;
  <D.21381>:
  elem_addr_cache_next.352 = elem_addr_cache_next;
  if (i < elem_addr_cache_next.352) goto <D.21380>; else goto <D.21379>;
  <D.21379>:
  {
    int ret;

    ret = pthread_mutex_unlock (&marshal_mutex.mutex);
    if (ret != 0) goto <D.27455>; else goto <D.27456>;
    <D.27455>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.27456>:
    D.27457 = ret != 0;
    D.27458 = (long int) D.27457;
    D.27459 = __builtin_expect (D.27458, 0);
    if (D.27459 != 0) goto <D.27460>; else goto <D.27461>;
    <D.27460>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 11371, "ret == 0");
    <D.27461>:
  }
  if (ret != 0B) goto <D.27462>; else goto <D.27463>;
  <D.27462>:
  D.27464 = ret;
  return D.27464;
  <D.27463>:
  D.27465 = (long unsigned int) rank;
  D.27466 = D.27465 * 4;
  branch_positions = monoeg_malloc0 (D.27466);
  D.27467 = mono_defaults.corlib;
  D.27468 = rank + 1;
  D.27469 = (unsigned int) D.27468;
  sig = mono_metadata_signature_alloc (D.27467, D.27469);
  D.27470 = mono_defaults.int_class;
  D.27471 = &D.27470->byval_arg;
  sig->ret = D.27471;
  D.27472 = mono_defaults.object_class;
  D.27473 = &D.27472->byval_arg;
  sig->params[0] = D.27473;
  i = 0;
  goto <D.21384>;
  <D.21383>:
  D.27474 = i + 1;
  D.27475 = mono_defaults.int32_class;
  D.27476 = &D.27475->byval_arg;
  sig->params[D.27474] = D.27476;
  i = i + 1;
  <D.21384>:
  if (i < rank) goto <D.21383>; else goto <D.21385>;
  <D.21385>:
  D.27472 = mono_defaults.object_class;
  mb = mono_mb_new (D.27472, "ElementAddr", 7);
  D.27470 = mono_defaults.int_class;
  D.27471 = &D.27470->byval_arg;
  bounds = mono_mb_add_local (mb, D.27471);
  D.27475 = mono_defaults.int32_class;
  D.27476 = &D.27475->byval_arg;
  ind = mono_mb_add_local (mb, D.27476);
  D.27475 = mono_defaults.int32_class;
  D.27476 = &D.27475->byval_arg;
  realidx = mono_mb_add_local (mb, D.27476);
  mono_mb_emit_ldarg (mb, 0);
  mono_mb_emit_ldflda (mb, 16);
  mono_mb_emit_byte (mb, 77);
  bounds.353 = (unsigned int) bounds;
  mono_mb_emit_stloc (mb, bounds.353);
  mono_mb_emit_ldarg (mb, 1);
  bounds.353 = (unsigned int) bounds;
  mono_mb_emit_ldloc (mb, bounds.353);
  mono_mb_emit_icon (mb, 4);
  mono_mb_emit_byte (mb, 88);
  mono_mb_emit_byte (mb, 74);
  mono_mb_emit_byte (mb, 89);
  ind.354 = (unsigned int) ind;
  mono_mb_emit_stloc (mb, ind.354);
  ind.354 = (unsigned int) ind;
  mono_mb_emit_ldloc (mb, ind.354);
  bounds.353 = (unsigned int) bounds;
  mono_mb_emit_ldloc (mb, bounds.353);
  mono_mb_emit_icon (mb, 0);
  mono_mb_emit_byte (mb, 88);
  mono_mb_emit_byte (mb, 74);
  D.27479 = mono_mb_emit_branch (mb, 65);
  branch_pos = (int) D.27479;
  i = 1;
  goto <D.21387>;
  <D.21386>:
  D.27474 = i + 1;
  D.27480 = (unsigned int) D.27474;
  mono_mb_emit_ldarg (mb, D.27480);
  bounds.353 = (unsigned int) bounds;
  mono_mb_emit_ldloc (mb, bounds.353);
  D.27445 = (long unsigned int) i;
  D.27481 = (unsigned int) D.27445;
  D.27482 = D.27481 * 8;
  D.27483 = D.27482 + 4;
  D.27484 = (int) D.27483;
  mono_mb_emit_icon (mb, D.27484);
  mono_mb_emit_byte (mb, 88);
  mono_mb_emit_byte (mb, 74);
  mono_mb_emit_byte (mb, 89);
  realidx.355 = (unsigned int) realidx;
  mono_mb_emit_stloc (mb, realidx.355);
  realidx.355 = (unsigned int) realidx;
  mono_mb_emit_ldloc (mb, realidx.355);
  bounds.353 = (unsigned int) bounds;
  mono_mb_emit_ldloc (mb, bounds.353);
  i.356 = (unsigned int) i;
  D.27487 = i.356 * 8;
  D.27488 = (int) D.27487;
  mono_mb_emit_icon (mb, D.27488);
  mono_mb_emit_byte (mb, 88);
  mono_mb_emit_byte (mb, 74);
  D.27445 = (long unsigned int) i;
  D.27489 = D.27445 * 4;
  D.27490 = branch_positions + D.27489;
  D.27491 = mono_mb_emit_branch (mb, 65);
  D.27492 = (int) D.27491;
  *D.27490 = D.27492;
  ind.354 = (unsigned int) ind;
  mono_mb_emit_ldloc (mb, ind.354);
  bounds.353 = (unsigned int) bounds;
  mono_mb_emit_ldloc (mb, bounds.353);
  i.356 = (unsigned int) i;
  D.27487 = i.356 * 8;
  D.27488 = (int) D.27487;
  mono_mb_emit_icon (mb, D.27488);
  mono_mb_emit_byte (mb, 88);
  mono_mb_emit_byte (mb, 74);
  mono_mb_emit_byte (mb, 90);
  realidx.355 = (unsigned int) realidx;
  mono_mb_emit_ldloc (mb, realidx.355);
  mono_mb_emit_byte (mb, 88);
  ind.354 = (unsigned int) ind;
  mono_mb_emit_stloc (mb, ind.354);
  i = i + 1;
  <D.21387>:
  if (i < rank) goto <D.21386>; else goto <D.21388>;
  <D.21388>:
  mono_mb_emit_ldarg (mb, 0);
  mono_mb_emit_ldflda (mb, 32);
  ind.354 = (unsigned int) ind;
  mono_mb_emit_ldloc (mb, ind.354);
  mono_mb_emit_icon (mb, elem_size);
  mono_mb_emit_byte (mb, 90);
  mono_mb_emit_byte (mb, 88);
  mono_mb_emit_byte (mb, 42);
  i = 1;
  goto <D.21390>;
  <D.21389>:
  D.27445 = (long unsigned int) i;
  D.27489 = D.27445 * 4;
  D.27490 = branch_positions + D.27489;
  D.27493 = *D.27490;
  D.27494 = (unsigned int) D.27493;
  mono_mb_patch_branch (mb, D.27494);
  i = i + 1;
  <D.21390>:
  if (i < rank) goto <D.21389>; else goto <D.21391>;
  <D.21391>:
  branch_pos.357 = (unsigned int) branch_pos;
  mono_mb_patch_branch (mb, branch_pos.357);
  mono_mb_emit_exception (mb, "IndexOutOfRangeException", 0B);
  monoeg_g_free (branch_positions);
  ret = mono_mb_create_method (mb, sig, 4);
  mono_mb_free (mb);
  cached = 0;
  {
    int ret;

    ret = pthread_mutex_lock (&marshal_mutex.mutex);
    if (ret != 0) goto <D.27496>; else goto <D.27497>;
    <D.27496>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.27497>:
    D.27498 = ret != 0;
    D.27499 = (long int) D.27498;
    D.27500 = __builtin_expect (D.27499, 0);
    if (D.27500 != 0) goto <D.27501>; else goto <D.27502>;
    <D.27501>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 11475, "ret == 0");
    <D.27502>:
  }
  i = 0;
  goto <D.21395>;
  <D.21394>:
  elem_addr_cache.351 = elem_addr_cache;
  D.27445 = (long unsigned int) i;
  D.27446 = D.27445 * 16;
  D.27447 = elem_addr_cache.351 + D.27446;
  D.27448 = D.27447->rank;
  if (D.27448 == rank) goto <D.27503>; else goto <D.27504>;
  <D.27503>:
  elem_addr_cache.351 = elem_addr_cache;
  D.27445 = (long unsigned int) i;
  D.27446 = D.27445 * 16;
  D.27447 = elem_addr_cache.351 + D.27446;
  D.27451 = D.27447->elem_size;
  if (D.27451 == elem_size) goto <D.27505>; else goto <D.27506>;
  <D.27505>:
  elem_addr_cache.351 = elem_addr_cache;
  D.27445 = (long unsigned int) i;
  D.27446 = D.27445 * 16;
  D.27447 = elem_addr_cache.351 + D.27446;
  ret = D.27447->method;
  cached = 1;
  goto <D.21393>;
  <D.27506>:
  <D.27504>:
  i = i + 1;
  <D.21395>:
  elem_addr_cache_next.352 = elem_addr_cache_next;
  if (i < elem_addr_cache_next.352) goto <D.21394>; else goto <D.21393>;
  <D.21393>:
  if (cached == 0) goto <D.27507>; else goto <D.27508>;
  <D.27507>:
  {
    struct WrapperInfo * info;

    elem_addr_cache_next.352 = elem_addr_cache_next;
    elem_addr_cache_size.358 = elem_addr_cache_size;
    if (elem_addr_cache_next.352 >= elem_addr_cache_size.358) goto <D.27510>; else goto <D.27511>;
    <D.27510>:
    {
      int new_size;
      struct ArrayElemAddr * new_array;

      elem_addr_cache_size.358 = elem_addr_cache_size;
      new_size = elem_addr_cache_size.358 + 4;
      D.27512 = (long unsigned int) new_size;
      D.27513 = D.27512 * 16;
      new_array = monoeg_malloc0 (D.27513);
      elem_addr_cache.351 = elem_addr_cache;
      elem_addr_cache_size.358 = elem_addr_cache_size;
      D.27514 = (long unsigned int) elem_addr_cache_size.358;
      D.27515 = D.27514 * 16;
      memcpy (new_array, elem_addr_cache.351, D.27515);
      elem_addr_cache.351 = elem_addr_cache;
      monoeg_g_free (elem_addr_cache.351);
      elem_addr_cache = new_array;
      elem_addr_cache_size = new_size;
    }
    <D.27511>:
    elem_addr_cache.351 = elem_addr_cache;
    elem_addr_cache_next.352 = elem_addr_cache_next;
    D.27516 = (long unsigned int) elem_addr_cache_next.352;
    D.27517 = D.27516 * 16;
    D.27518 = elem_addr_cache.351 + D.27517;
    D.27518->rank = rank;
    elem_addr_cache.351 = elem_addr_cache;
    elem_addr_cache_next.352 = elem_addr_cache_next;
    D.27516 = (long unsigned int) elem_addr_cache_next.352;
    D.27517 = D.27516 * 16;
    D.27518 = elem_addr_cache.351 + D.27517;
    D.27518->elem_size = elem_size;
    elem_addr_cache.351 = elem_addr_cache;
    elem_addr_cache_next.352 = elem_addr_cache_next;
    D.27516 = (long unsigned int) elem_addr_cache_next.352;
    D.27517 = D.27516 * 16;
    D.27518 = elem_addr_cache.351 + D.27517;
    D.27518->method = ret;
    elem_addr_cache_next.352 = elem_addr_cache_next;
    D.27519 = elem_addr_cache_next.352 + 1;
    elem_addr_cache_next = D.27519;
    info = mono_wrapper_info_create (ret, 1);
    rank.359 = (unsigned int) rank;
    info->d.element_addr.rank = rank.359;
    elem_size.360 = (unsigned int) elem_size;
    info->d.element_addr.elem_size = elem_size.360;
    mono_marshal_set_wrapper_info (ret, info);
  }
  <D.27508>:
  {
    int ret;

    ret = pthread_mutex_unlock (&marshal_mutex.mutex);
    if (ret != 0) goto <D.27522>; else goto <D.27523>;
    <D.27522>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.27523>:
    D.27524 = ret != 0;
    D.27525 = (long int) D.27524;
    D.27526 = __builtin_expect (D.27525, 0);
    if (D.27526 != 0) goto <D.27527>; else goto <D.27528>;
    <D.27527>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 11505, "ret == 0");
    <D.27528>:
  }
  D.27464 = ret;
  return D.27464;
}


__attribute__((visibility ("hidden")))
mono_marshal_get_array_accessor_wrapper (struct MonoMethod * method)
{
  struct MonoClass * D.27532;
  struct MonoImage * D.27533;
  struct GHashTable * * D.27534;
  struct MonoMethod * D.27537;
  struct MonoMethodSignature * D.27538;
  const char * D.27539;
  long unsigned int D.27540;
  long unsigned int D.27541;
  _Bool D.27544;
  int D.27545;
  int D.27546;
  unsigned int D.27547;
  short unsigned int D.27548;
  int D.27549;
  struct MonoGenericContext * D.27552;
  struct MonoMethod * D.27553;
  int D.27557;
  struct MonoMethodSignature * sig;
  struct MonoMethodBuilder * mb;
  struct MonoMethod * res;
  struct GHashTable * cache;
  int i;
  struct MonoGenericContext * ctx;
  struct MonoMethod * orig_method;
  struct MonoGenericContainer * container;
  struct WrapperInfo * info;

  ctx = 0B;
  orig_method = 0B;
  container = 0B;
  if (ctx != 0B) goto <D.27530>; else goto <D.27531>;
  <D.27530>:
  cache = 0B;
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "marshal.c", 11537);
  <D.27531>:
  D.27532 = method->klass;
  D.27533 = D.27532->image;
  D.27534 = &D.27533->array_accessor_cache;
  cache = get_cache (D.27534, mono_aligned_addr_hash, 0B);
  res = mono_marshal_find_in_cache (cache, method);
  if (res != 0B) goto <D.27535>; else goto <D.27536>;
  <D.27535>:
  D.27537 = res;
  return D.27537;
  <D.27536>:
  D.27532 = method->klass;
  D.27533 = D.27532->image;
  D.27538 = mono_method_signature (method);
  sig = signature_dup (D.27533, D.27538);
  sig->pinvoke = 0;
  D.27532 = method->klass;
  D.27539 = method->name;
  mb = mono_mb_new (D.27532, D.27539, 25);
  D.27540 = BIT_FIELD_REF <*sig, 64, 64>;
  D.27541 = D.27540 & 512;
  if (D.27541 != 0) goto <D.27542>; else goto <D.27543>;
  <D.27542>:
  mono_mb_emit_ldarg (mb, 0);
  <D.27543>:
  i = 0;
  goto <D.21413>;
  <D.21412>:
  D.27540 = BIT_FIELD_REF <*sig, 64, 64>;
  D.27541 = D.27540 & 512;
  D.27544 = D.27541 != 0;
  D.27545 = (int) D.27544;
  D.27546 = D.27545 + i;
  D.27547 = (unsigned int) D.27546;
  mono_mb_emit_ldarg (mb, D.27547);
  i = i + 1;
  <D.21413>:
  D.27548 = sig->param_count;
  D.27549 = (int) D.27548;
  if (D.27549 > i) goto <D.21412>; else goto <D.21414>;
  <D.21414>:
  if (ctx != 0B) goto <D.27550>; else goto <D.27551>;
  <D.27550>:
  D.27552 = &container->context;
  D.27553 = mono_class_inflate_generic_method (method, D.27552);
  mono_mb_emit_managed_call (mb, D.27553, 0B);
  goto <D.27554>;
  <D.27551>:
  mono_mb_emit_managed_call (mb, method, 0B);
  <D.27554>:
  mono_mb_emit_byte (mb, 42);
  if (ctx != 0B) goto <D.27555>; else goto <D.27556>;
  <D.27555>:
  {
    struct MonoMethod * def;

    D.27548 = sig->param_count;
    D.27549 = (int) D.27548;
    D.27557 = D.27549 + 16;
    def = mono_mb_create_and_cache (cache, method, mb, sig, D.27557);
    res = cache_generic_wrapper (cache, orig_method, def, ctx, orig_method);
  }
  goto <D.27558>;
  <D.27556>:
  D.27548 = sig->param_count;
  D.27549 = (int) D.27548;
  D.27557 = D.27549 + 16;
  res = mono_mb_create_and_cache (cache, method, mb, sig, D.27557);
  info = mono_wrapper_info_create (res, 20);
  info->d.array_accessor.method = method;
  mono_marshal_set_wrapper_info (res, info);
  <D.27558>:
  mono_mb_free (mb);
  D.27537 = res;
  return D.27537;
}


__attribute__((visibility ("hidden")))
mono_marshal_alloc (gulong size)
{
  void * D.27562;
  void * res;

  res = monoeg_try_malloc (size);
  if (res == 0B) goto <D.27560>; else goto <D.27561>;
  <D.27560>:
  mono_gc_out_of_memory (size);
  <D.27561>:
  D.27562 = res;
  return D.27562;
}


__attribute__((visibility ("hidden")))
mono_marshal_free (void * ptr)
{
  monoeg_g_free (ptr);
}


__attribute__((visibility ("hidden")))
mono_marshal_free_array (void * * ptr, int size)
{
  long unsigned int D.27566;
  long unsigned int D.27567;
  void * * D.27568;
  void * D.27569;
  int i;

  if (ptr == 0B) goto <D.27564>; else goto <D.27565>;
  <D.27564>:
  return;
  <D.27565>:
  i = 0;
  goto <D.21429>;
  <D.21428>:
  D.27566 = (long unsigned int) i;
  D.27567 = D.27566 * 8;
  D.27568 = ptr + D.27567;
  D.27569 = *D.27568;
  if (D.27569 != 0B) goto <D.27570>; else goto <D.27571>;
  <D.27570>:
  D.27566 = (long unsigned int) i;
  D.27567 = D.27566 * 8;
  D.27568 = ptr + D.27567;
  D.27569 = *D.27568;
  monoeg_g_free (D.27569);
  <D.27571>:
  i = i + 1;
  <D.21429>:
  if (i < size) goto <D.21428>; else goto <D.21430>;
  <D.21430>:
}


mono_marshal_string_to_utf16 (struct MonoString * s)
{
  void * D.27573;
  void * iftmp.361;

  if (s != 0B) goto <D.27575>; else goto <D.27576>;
  <D.27575>:
  iftmp.361 = mono_string_chars (s);
  goto <D.27577>;
  <D.27576>:
  iftmp.361 = 0B;
  <D.27577>:
  D.27573 = iftmp.361;
  return D.27573;
}


__attribute__((visibility ("hidden")))
mono_marshal_set_last_error ()
{
  unsigned int last_error_tls_id.362;
  int * D.27580;
  int D.27581;
  long int D.27582;
  void * D.27583;

  last_error_tls_id.362 = last_error_tls_id;
  D.27580 = __errno_location ();
  D.27581 = *D.27580;
  D.27582 = (long int) D.27581;
  D.27583 = (void *) D.27582;
  mono_native_tls_set_value (last_error_tls_id.362, D.27583);
}


mono_native_tls_set_value (pthread_key_t key, void * value)
{
  int D.27584;
  int D.27585;
  _Bool D.27586;

  D.27585 = pthread_setspecific (key, value);
  D.27586 = D.27585 == 0;
  D.27584 = (int) D.27586;
  return D.27584;
}


__attribute__((visibility ("hidden")))
ves_icall_System_Runtime_InteropServices_Marshal_copy_to_unmanaged (struct MonoArray * src, gint32 start_index, void * dest, gint32 length)
{
  _Bool D.27588;
  long int D.27589;
  long int D.27590;
  _Bool D.27595;
  long int D.27596;
  long int D.27597;
  struct MonoVTable * D.27602;
  struct MonoClass * D.27603;
  unsigned char D.27604;
  struct MonoException * D.27607;
  struct MonoException * D.27610;
  struct MonoException * D.27613;
  int D.27614;
  long unsigned int D.27615;
  long unsigned int D.27616;
  struct MonoException * D.27619;
  double[0:] * D.27620;
  int D.27621;
  sizetype D.27622;
  int D.27623;
  long unsigned int D.27624;
  int element_size;
  void * source_addr;

  D.27588 = src == 0B;
  D.27589 = (long int) D.27588;
  D.27590 = __builtin_expect (D.27589, 0);
  if (D.27590 != 0) goto <D.27591>; else goto <D.27592>;
  <D.27591>:
  {
    struct MonoException * ex;

    if (src != 0B) goto <D.27593>; else goto <D.27594>;
    <D.27593>:
    <D.27594>:
    ex = mono_get_exception_argument_null ("src");
    mono_raise_exception (ex);
  }
  <D.27592>:
  D.27595 = dest == 0B;
  D.27596 = (long int) D.27595;
  D.27597 = __builtin_expect (D.27596, 0);
  if (D.27597 != 0) goto <D.27598>; else goto <D.27599>;
  <D.27598>:
  {
    struct MonoException * ex;

    if (dest != 0B) goto <D.27600>; else goto <D.27601>;
    <D.27600>:
    <D.27601>:
    ex = mono_get_exception_argument_null ("dest");
    mono_raise_exception (ex);
  }
  <D.27599>:
  D.27602 = src->obj.vtable;
  D.27603 = D.27602->klass;
  D.27604 = D.27603->rank;
  if (D.27604 != 1) goto <D.27605>; else goto <D.27606>;
  <D.27605>:
  D.27607 = mono_get_exception_argument ("array", "array is multi-dimensional");
  mono_raise_exception (D.27607);
  <D.27606>:
  if (start_index < 0) goto <D.27608>; else goto <D.27609>;
  <D.27608>:
  D.27610 = mono_get_exception_argument ("startIndex", "Must be >= 0");
  mono_raise_exception (D.27610);
  <D.27609>:
  if (length < 0) goto <D.27611>; else goto <D.27612>;
  <D.27611>:
  D.27613 = mono_get_exception_argument ("length", "Must be >= 0");
  mono_raise_exception (D.27613);
  <D.27612>:
  D.27614 = start_index + length;
  D.27615 = (long unsigned int) D.27614;
  D.27616 = mono_array_length (src);
  if (D.27615 > D.27616) goto <D.27617>; else goto <D.27618>;
  <D.27617>:
  D.27619 = mono_get_exception_argument ("length", "start_index + length > array length");
  mono_raise_exception (D.27619);
  <D.27618>:
  D.27602 = src->obj.vtable;
  D.27603 = D.27602->klass;
  element_size = mono_array_element_size (D.27603);
  D.27620 = &src->vector;
  D.27621 = element_size * start_index;
  D.27622 = (sizetype) D.27621;
  source_addr = D.27620 + D.27622;
  D.27623 = length * element_size;
  D.27624 = (long unsigned int) D.27623;
  memcpy (dest, source_addr, D.27624);
}


__attribute__((visibility ("hidden")))
ves_icall_System_Runtime_InteropServices_Marshal_copy_from_unmanaged (void * src, gint32 start_index, struct MonoArray * dest, gint32 length)
{
  _Bool D.27625;
  long int D.27626;
  long int D.27627;
  _Bool D.27632;
  long int D.27633;
  long int D.27634;
  struct MonoVTable * D.27639;
  struct MonoClass * D.27640;
  unsigned char D.27641;
  struct MonoException * D.27644;
  struct MonoException * D.27647;
  struct MonoException * D.27650;
  int D.27651;
  long unsigned int D.27652;
  long unsigned int D.27653;
  struct MonoException * D.27656;
  double[0:] * D.27657;
  int D.27658;
  sizetype D.27659;
  int D.27660;
  long unsigned int D.27661;
  int element_size;
  void * dest_addr;

  D.27625 = src == 0B;
  D.27626 = (long int) D.27625;
  D.27627 = __builtin_expect (D.27626, 0);
  if (D.27627 != 0) goto <D.27628>; else goto <D.27629>;
  <D.27628>:
  {
    struct MonoException * ex;

    if (src != 0B) goto <D.27630>; else goto <D.27631>;
    <D.27630>:
    <D.27631>:
    ex = mono_get_exception_argument_null ("src");
    mono_raise_exception (ex);
  }
  <D.27629>:
  D.27632 = dest == 0B;
  D.27633 = (long int) D.27632;
  D.27634 = __builtin_expect (D.27633, 0);
  if (D.27634 != 0) goto <D.27635>; else goto <D.27636>;
  <D.27635>:
  {
    struct MonoException * ex;

    if (dest != 0B) goto <D.27637>; else goto <D.27638>;
    <D.27637>:
    <D.27638>:
    ex = mono_get_exception_argument_null ("dest");
    mono_raise_exception (ex);
  }
  <D.27636>:
  D.27639 = dest->obj.vtable;
  D.27640 = D.27639->klass;
  D.27641 = D.27640->rank;
  if (D.27641 != 1) goto <D.27642>; else goto <D.27643>;
  <D.27642>:
  D.27644 = mono_get_exception_argument ("array", "array is multi-dimensional");
  mono_raise_exception (D.27644);
  <D.27643>:
  if (start_index < 0) goto <D.27645>; else goto <D.27646>;
  <D.27645>:
  D.27647 = mono_get_exception_argument ("startIndex", "Must be >= 0");
  mono_raise_exception (D.27647);
  <D.27646>:
  if (length < 0) goto <D.27648>; else goto <D.27649>;
  <D.27648>:
  D.27650 = mono_get_exception_argument ("length", "Must be >= 0");
  mono_raise_exception (D.27650);
  <D.27649>:
  D.27651 = start_index + length;
  D.27652 = (long unsigned int) D.27651;
  D.27653 = mono_array_length (dest);
  if (D.27652 > D.27653) goto <D.27654>; else goto <D.27655>;
  <D.27654>:
  D.27656 = mono_get_exception_argument ("length", "start_index + length > array length");
  mono_raise_exception (D.27656);
  <D.27655>:
  D.27639 = dest->obj.vtable;
  D.27640 = D.27639->klass;
  element_size = mono_array_element_size (D.27640);
  D.27657 = &dest->vector;
  D.27658 = element_size * start_index;
  D.27659 = (sizetype) D.27658;
  dest_addr = D.27657 + D.27659;
  D.27660 = length * element_size;
  D.27661 = (long unsigned int) D.27660;
  memcpy (dest_addr, src, D.27661);
}


__attribute__((visibility ("hidden")))
ves_icall_System_Runtime_InteropServices_Marshal_PtrToStringAnsi (char * ptr)
{
  struct MonoString * D.27664;
  struct MonoDomain * D.27665;

  if (ptr == 0B) goto <D.27662>; else goto <D.27663>;
  <D.27662>:
  D.27664 = 0B;
  return D.27664;
  <D.27663>:
  D.27665 = mono_domain_get ();
  D.27664 = mono_string_new (D.27665, ptr);
  return D.27664;
}


__attribute__((visibility ("hidden")))
ves_icall_System_Runtime_InteropServices_Marshal_PtrToStringAnsi_len (char * ptr, gint32 len)
{
  struct MonoException * D.27669;
  struct MonoString * D.27670;
  struct MonoDomain * D.27671;
  unsigned int len.363;

  if (ptr == 0B) goto <D.27667>; else goto <D.27668>;
  <D.27667>:
  D.27669 = mono_get_exception_argument_null ("ptr");
  mono_raise_exception (D.27669);
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "marshal.c", 11736);
  D.27670 = 0B;
  return D.27670;
  <D.27668>:
  D.27671 = mono_domain_get ();
  len.363 = (unsigned int) len;
  D.27670 = mono_string_new_len (D.27671, ptr, len.363);
  return D.27670;
}


__attribute__((visibility ("hidden")))
ves_icall_System_Runtime_InteropServices_Marshal_PtrToStringUni (guint16 * ptr)
{
  struct MonoString * D.27676;
  guint16 * t.364;
  short unsigned int D.27678;
  struct MonoDomain * domain;
  int len;
  guint16 * t;

  domain = mono_domain_get ();
  len = 0;
  t = ptr;
  if (ptr == 0B) goto <D.27674>; else goto <D.27675>;
  <D.27674>:
  D.27676 = 0B;
  return D.27676;
  <D.27675>:
  goto <D.21478>;
  <D.21477>:
  len = len + 1;
  <D.21478>:
  t.364 = t;
  t = t.364 + 2;
  D.27678 = *t.364;
  if (D.27678 != 0) goto <D.21477>; else goto <D.21479>;
  <D.21479>:
  D.27676 = mono_string_new_utf16 (domain, ptr, len);
  return D.27676;
}


__attribute__((visibility ("hidden")))
ves_icall_System_Runtime_InteropServices_Marshal_PtrToStringUni_len (guint16 * ptr, gint32 len)
{
  struct MonoException * D.27682;
  struct MonoString * D.27683;
  struct MonoDomain * domain;

  domain = mono_domain_get ();
  if (ptr == 0B) goto <D.27680>; else goto <D.27681>;
  <D.27680>:
  D.27682 = mono_get_exception_argument_null ("ptr");
  mono_raise_exception (D.27682);
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "marshal.c", 11770);
  D.27683 = 0B;
  return D.27683;
  <D.27681>:
  D.27683 = mono_string_new_utf16 (domain, ptr, len);
  return D.27683;
}


__attribute__((visibility ("hidden")))
ves_icall_System_Runtime_InteropServices_Marshal_GetLastWin32Error ()
{
  guint32 D.27685;
  unsigned int last_error_tls_id.365;
  void * D.27687;
  long int D.27688;

  last_error_tls_id.365 = last_error_tls_id;
  D.27687 = pthread_getspecific (last_error_tls_id.365);
  D.27688 = (long int) D.27687;
  D.27685 = (guint32) D.27688;
  return D.27685;
}


__attribute__((visibility ("hidden")))
ves_icall_System_Runtime_InteropServices_Marshal_SizeOf (struct MonoReflectionType * rtype)
{
  _Bool D.27690;
  long int D.27691;
  long int D.27692;
  int D.27697;
  struct MonoException * D.27700;
  unsigned int D.27701;
  const char * D.27704;
  guint32 D.27705;
  int D.27706;
  struct MonoClass * klass;
  struct MonoType * type;
  guint32 layout;

  D.27690 = rtype == 0B;
  D.27691 = (long int) D.27690;
  D.27692 = __builtin_expect (D.27691, 0);
  if (D.27692 != 0) goto <D.27693>; else goto <D.27694>;
  <D.27693>:
  {
    struct MonoException * ex;

    if (rtype != 0B) goto <D.27695>; else goto <D.27696>;
    <D.27695>:
    <D.27696>:
    ex = mono_get_exception_argument_null ("rtype");
    mono_raise_exception (ex);
  }
  <D.27694>:
  type = rtype->type;
  klass = mono_class_from_mono_type (type);
  D.27697 = mono_class_init (klass);
  if (D.27697 == 0) goto <D.27698>; else goto <D.27699>;
  <D.27698>:
  D.27700 = mono_class_get_exception_for_failure (klass);
  mono_raise_exception (D.27700);
  <D.27699>:
  D.27701 = klass->flags;
  layout = D.27701 & 24;
  if (layout == 0) goto <D.27702>; else goto <D.27703>;
  <D.27702>:
  {
    gchar * msg;
    struct MonoException * exc;

    D.27704 = klass->name;
    msg = monoeg_g_strdup_printf ("Type %s cannot be marshaled as an unmanaged structure.", D.27704);
    exc = mono_get_exception_argument ("t", msg);
    monoeg_g_free (msg);
    mono_raise_exception (exc);
  }
  <D.27703>:
  D.27706 = mono_class_native_size (klass, 0B);
  D.27705 = (guint32) D.27706;
  return D.27705;
}


__attribute__((visibility ("hidden")))
ves_icall_System_Runtime_InteropServices_Marshal_StructureToPtr (struct MonoObject * obj, void * dst, MonoBoolean delete_old)
{
  _Bool D.27708;
  long int D.27709;
  long int D.27710;
  void * dst.366;
  _Bool D.27716;
  long int D.27717;
  long int D.27718;
  struct MonoVTable * D.27723;
  struct MonoClass * D.27724;
  struct MonoMethod * method;
  void * pa[3];

  try
    {
      D.27708 = obj == 0B;
      D.27709 = (long int) D.27708;
      D.27710 = __builtin_expect (D.27709, 0);
      if (D.27710 != 0) goto <D.27711>; else goto <D.27712>;
      <D.27711>:
      {
        struct MonoException * ex;

        if (obj != 0B) goto <D.27713>; else goto <D.27714>;
        <D.27713>:
        <D.27714>:
        ex = mono_get_exception_argument_null ("obj");
        mono_raise_exception (ex);
      }
      <D.27712>:
      dst.366 = dst;
      D.27716 = dst.366 == 0B;
      D.27717 = (long int) D.27716;
      D.27718 = __builtin_expect (D.27717, 0);
      if (D.27718 != 0) goto <D.27719>; else goto <D.27720>;
      <D.27719>:
      {
        struct MonoException * ex;

        dst.366 = dst;
        if (dst.366 != 0B) goto <D.27721>; else goto <D.27722>;
        <D.27721>:
        <D.27722>:
        ex = mono_get_exception_argument_null ("dst");
        mono_raise_exception (ex);
      }
      <D.27720>:
      D.27723 = obj->vtable;
      D.27724 = D.27723->klass;
      method = mono_marshal_get_struct_to_ptr (D.27724);
      pa[0] = obj;
      pa[1] = &dst;
      pa[2] = &delete_old;
      mono_runtime_invoke (method, 0B, &pa, 0B);
    }
  finally
    {
      pa = {CLOBBER};
    }
}


__attribute__((visibility ("hidden")))
ves_icall_System_Runtime_InteropServices_Marshal_PtrToStructure (void * src, struct MonoObject * dst)
{
  _Bool D.27725;
  long int D.27726;
  long int D.27727;
  _Bool D.27732;
  long int D.27733;
  long int D.27734;
  struct MonoVTable * D.27739;
  struct MonoClass * D.27740;
  struct MonoType * D.27741;
  unsigned char D.27742;
  struct MonoType * t;

  D.27725 = src == 0B;
  D.27726 = (long int) D.27725;
  D.27727 = __builtin_expect (D.27726, 0);
  if (D.27727 != 0) goto <D.27728>; else goto <D.27729>;
  <D.27728>:
  {
    struct MonoException * ex;

    if (src != 0B) goto <D.27730>; else goto <D.27731>;
    <D.27730>:
    <D.27731>:
    ex = mono_get_exception_argument_null ("src");
    mono_raise_exception (ex);
  }
  <D.27729>:
  D.27732 = dst == 0B;
  D.27733 = (long int) D.27732;
  D.27734 = __builtin_expect (D.27733, 0);
  if (D.27734 != 0) goto <D.27735>; else goto <D.27736>;
  <D.27735>:
  {
    struct MonoException * ex;

    if (dst != 0B) goto <D.27737>; else goto <D.27738>;
    <D.27737>:
    <D.27738>:
    ex = mono_get_exception_argument_null ("dst");
    mono_raise_exception (ex);
  }
  <D.27736>:
  D.27739 = dst->vtable;
  D.27740 = D.27739->klass;
  D.27741 = mono_class_get_type (D.27740);
  t = mono_type_get_underlying_type (D.27741);
  D.27742 = t->type;
  if (D.27742 == 17) goto <D.27743>; else goto <D.27744>;
  <D.27743>:
  {
    struct MonoException * exc;
    gchar * tmp;

    tmp = monoeg_g_strdup_printf ("Destination is a boxed value type.");
    exc = mono_get_exception_argument ("dst", tmp);
    monoeg_g_free (tmp);
    mono_raise_exception (exc);
    return;
  }
  <D.27744>:
  ptr_to_structure (src, dst);
}


ptr_to_structure (void * src, struct MonoObject * dst)
{
  struct MonoVTable * D.27746;
  struct MonoClass * D.27747;
  struct MonoMethod * method;
  void * pa[2];

  try
    {
      D.27746 = dst->vtable;
      D.27747 = D.27746->klass;
      method = mono_marshal_get_ptr_to_struct (D.27747);
      pa[0] = &src;
      pa[1] = dst;
      mono_runtime_invoke (method, 0B, &pa, 0B);
    }
  finally
    {
      pa = {CLOBBER};
    }
}


__attribute__((visibility ("hidden")))
ves_icall_System_Runtime_InteropServices_Marshal_PtrToStructure_type (void * src, struct MonoReflectionType * type)
{
  struct MonoObject * D.27750;
  _Bool D.27751;
  long int D.27752;
  long int D.27753;
  struct MonoType * D.27758;
  int D.27759;
  struct MonoException * D.27762;
  struct MonoClass * klass;
  struct MonoDomain * domain;
  struct MonoObject * res;

  domain = mono_domain_get ();
  if (src == 0B) goto <D.27748>; else goto <D.27749>;
  <D.27748>:
  D.27750 = 0B;
  return D.27750;
  <D.27749>:
  D.27751 = type == 0B;
  D.27752 = (long int) D.27751;
  D.27753 = __builtin_expect (D.27752, 0);
  if (D.27753 != 0) goto <D.27754>; else goto <D.27755>;
  <D.27754>:
  {
    struct MonoException * ex;

    if (type != 0B) goto <D.27756>; else goto <D.27757>;
    <D.27756>:
    <D.27757>:
    ex = mono_get_exception_argument_null ("type");
    mono_raise_exception (ex);
  }
  <D.27755>:
  D.27758 = type->type;
  klass = mono_class_from_mono_type (D.27758);
  D.27759 = mono_class_init (klass);
  if (D.27759 == 0) goto <D.27760>; else goto <D.27761>;
  <D.27760>:
  D.27762 = mono_class_get_exception_for_failure (klass);
  mono_raise_exception (D.27762);
  <D.27761>:
  res = mono_object_new (domain, klass);
  ptr_to_structure (src, res);
  D.27750 = res;
  return D.27750;
}


__attribute__((visibility ("hidden")))
ves_icall_System_Runtime_InteropServices_Marshal_OffsetOf (struct MonoReflectionType * type, struct MonoString * field_name)
{
  _Bool D.27764;
  long int D.27765;
  long int D.27766;
  _Bool D.27771;
  long int D.27772;
  long int D.27773;
  struct MonoType * D.27778;
  int D.27779;
  struct MonoException * D.27782;
  struct MonoType * D.27783;
  short unsigned int D.27784;
  int D.27785;
  int D.27786;
  const char * D.27789;
  int D.27790;
  const char * D.27798;
  int D.27799;
  unsigned int D.27800;
  struct MonoMarshalType * info;
  struct MonoClass * klass;
  char * fname;
  int match_index;

  match_index = -1;
  D.27764 = type == 0B;
  D.27765 = (long int) D.27764;
  D.27766 = __builtin_expect (D.27765, 0);
  if (D.27766 != 0) goto <D.27767>; else goto <D.27768>;
  <D.27767>:
  {
    struct MonoException * ex;

    if (type != 0B) goto <D.27769>; else goto <D.27770>;
    <D.27769>:
    <D.27770>:
    ex = mono_get_exception_argument_null ("type");
    mono_raise_exception (ex);
  }
  <D.27768>:
  D.27771 = field_name == 0B;
  D.27772 = (long int) D.27771;
  D.27773 = __builtin_expect (D.27772, 0);
  if (D.27773 != 0) goto <D.27774>; else goto <D.27775>;
  <D.27774>:
  {
    struct MonoException * ex;

    if (field_name != 0B) goto <D.27776>; else goto <D.27777>;
    <D.27776>:
    <D.27777>:
    ex = mono_get_exception_argument_null ("field_name");
    mono_raise_exception (ex);
  }
  <D.27775>:
  fname = mono_string_to_utf8 (field_name);
  D.27778 = type->type;
  klass = mono_class_from_mono_type (D.27778);
  D.27779 = mono_class_init (klass);
  if (D.27779 == 0) goto <D.27780>; else goto <D.27781>;
  <D.27780>:
  D.27782 = mono_class_get_exception_for_failure (klass);
  mono_raise_exception (D.27782);
  <D.27781>:
  goto <D.21546>;
  <D.21545>:
  {
    struct MonoClassField * field;
    int i;
    void * iter;

    try
      {
        i = 0;
        iter = 0B;
        goto <D.21542>;
        <D.21544>:
        D.27783 = field->type;
        D.27784 = D.27783->attrs;
        D.27785 = (int) D.27784;
        D.27786 = D.27785 & 16;
        if (D.27786 != 0) goto <D.27787>; else goto <D.27788>;
        <D.27787>:
        // predicted unlikely by continue predictor.
        goto <D.21542>;
        <D.27788>:
        D.27789 = mono_field_get_name (field);
        D.27790 = strcmp (fname, D.27789);
        if (D.27790 == 0) goto <D.27791>; else goto <D.27792>;
        <D.27791>:
        match_index = i;
        goto <D.21543>;
        <D.27792>:
        i = i + 1;
        <D.21542>:
        field = mono_class_get_fields (klass, &iter);
        if (field != 0B) goto <D.21544>; else goto <D.21543>;
        <D.21543>:
        if (match_index == -1) goto <D.27793>; else goto <D.27794>;
        <D.27793>:
        klass = klass->parent;
        <D.27794>:
      }
    finally
      {
        iter = {CLOBBER};
      }
  }
  <D.21546>:
  if (klass != 0B) goto <D.27795>; else goto <D.21547>;
  <D.27795>:
  if (match_index == -1) goto <D.21545>; else goto <D.21547>;
  <D.21547>:
  monoeg_g_free (fname);
  if (match_index == -1) goto <D.27796>; else goto <D.27797>;
  <D.27796>:
  {
    struct MonoException * exc;
    gchar * tmp;

    D.27778 = type->type;
    klass = mono_class_from_mono_type (D.27778);
    D.27798 = klass->name;
    tmp = monoeg_g_strdup_printf ("Field passed in is not a marshaled member of the type %s", D.27798);
    exc = mono_get_exception_argument ("fieldName", tmp);
    monoeg_g_free (tmp);
    mono_raise_exception (exc);
  }
  <D.27797>:
  info = mono_marshal_load_type_info (klass);
  D.27800 = info->fields[match_index].offset;
  D.27799 = (int) D.27800;
  return D.27799;
}


__attribute__((visibility ("hidden")))
ves_icall_System_Runtime_InteropServices_Marshal_StringToHGlobalAnsi (struct MonoString * string)
{
  void * D.27802;

  D.27802 = mono_string_to_utf8 (string);
  return D.27802;
}


__attribute__((visibility ("hidden")))
ves_icall_System_Runtime_InteropServices_Marshal_StringToHGlobalUni (struct MonoString * string)
{
  void * D.27806;
  int D.27807;
  int D.27808;
  int D.27809;
  long unsigned int D.27810;
  mono_unichar2 * D.27811;
  int D.27812;
  int D.27813;
  long unsigned int D.27814;
  int D.27815;
  long unsigned int D.27816;
  long unsigned int D.27817;
  gunichar2 * D.27818;

  if (string == 0B) goto <D.27804>; else goto <D.27805>;
  <D.27804>:
  D.27806 = 0B;
  return D.27806;
  <D.27805>:
  {
    gunichar2 * res;

    D.27807 = mono_string_length (string);
    D.27808 = D.27807 + 1;
    D.27809 = D.27808 * 2;
    D.27810 = (long unsigned int) D.27809;
    res = monoeg_malloc (D.27810);
    D.27811 = mono_string_chars (string);
    D.27812 = mono_string_length (string);
    D.27813 = D.27812 * 2;
    D.27814 = (long unsigned int) D.27813;
    memcpy (res, D.27811, D.27814);
    D.27815 = mono_string_length (string);
    D.27816 = (long unsigned int) D.27815;
    D.27817 = D.27816 * 2;
    D.27818 = res + D.27817;
    *D.27818 = 0;
    D.27806 = res;
    return D.27806;
  }
}


__attribute__((visibility ("hidden")))
ves_icall_System_Runtime_InteropServices_Marshal_DestroyStructure (void * src, struct MonoReflectionType * type)
{
  _Bool D.27820;
  long int D.27821;
  long int D.27822;
  _Bool D.27827;
  long int D.27828;
  long int D.27829;
  struct MonoType * D.27834;
  int D.27835;
  struct MonoException * D.27838;
  struct MonoClass * klass;

  D.27820 = src == 0B;
  D.27821 = (long int) D.27820;
  D.27822 = __builtin_expect (D.27821, 0);
  if (D.27822 != 0) goto <D.27823>; else goto <D.27824>;
  <D.27823>:
  {
    struct MonoException * ex;

    if (src != 0B) goto <D.27825>; else goto <D.27826>;
    <D.27825>:
    <D.27826>:
    ex = mono_get_exception_argument_null ("src");
    mono_raise_exception (ex);
  }
  <D.27824>:
  D.27827 = type == 0B;
  D.27828 = (long int) D.27827;
  D.27829 = __builtin_expect (D.27828, 0);
  if (D.27829 != 0) goto <D.27830>; else goto <D.27831>;
  <D.27830>:
  {
    struct MonoException * ex;

    if (type != 0B) goto <D.27832>; else goto <D.27833>;
    <D.27832>:
    <D.27833>:
    ex = mono_get_exception_argument_null ("type");
    mono_raise_exception (ex);
  }
  <D.27831>:
  D.27834 = type->type;
  klass = mono_class_from_mono_type (D.27834);
  D.27835 = mono_class_init (klass);
  if (D.27835 == 0) goto <D.27836>; else goto <D.27837>;
  <D.27836>:
  D.27838 = mono_class_get_exception_for_failure (klass);
  mono_raise_exception (D.27838);
  <D.27837>:
  mono_struct_delete_old (klass, src);
}


__attribute__((visibility ("hidden")))
ves_icall_System_Runtime_InteropServices_Marshal_AllocHGlobal (int size)
{
  long unsigned int D.27841;
  void * D.27844;
  void * res;

  if (size == 0) goto <D.27839>; else goto <D.27840>;
  <D.27839>:
  size = 4;
  <D.27840>:
  D.27841 = (long unsigned int) size;
  res = monoeg_try_malloc (D.27841);
  if (res == 0B) goto <D.27842>; else goto <D.27843>;
  <D.27842>:
  D.27841 = (long unsigned int) size;
  mono_gc_out_of_memory (D.27841);
  <D.27843>:
  D.27844 = res;
  return D.27844;
}


__attribute__((visibility ("hidden")))
ves_icall_System_Runtime_InteropServices_Marshal_ReAllocHGlobal (void * ptr, int size)
{
  long unsigned int D.27848;
  void * D.27849;
  void * res;

  if (ptr == 0B) goto <D.27846>; else goto <D.27847>;
  <D.27846>:
  D.27848 = (long unsigned int) size;
  mono_gc_out_of_memory (D.27848);
  D.27849 = 0B;
  return D.27849;
  <D.27847>:
  D.27848 = (long unsigned int) size;
  res = monoeg_try_realloc (ptr, D.27848);
  if (res == 0B) goto <D.27850>; else goto <D.27851>;
  <D.27850>:
  D.27848 = (long unsigned int) size;
  mono_gc_out_of_memory (D.27848);
  <D.27851>:
  D.27849 = res;
  return D.27849;
}


__attribute__((visibility ("hidden")))
ves_icall_System_Runtime_InteropServices_Marshal_FreeHGlobal (void * ptr)
{
  monoeg_g_free (ptr);
}


__attribute__((visibility ("hidden")))
ves_icall_System_Runtime_InteropServices_Marshal_AllocCoTaskMem (int size)
{
  void * D.27853;
  long unsigned int D.27854;

  D.27854 = (long unsigned int) size;
  D.27853 = monoeg_try_malloc (D.27854);
  return D.27853;
}


__attribute__((visibility ("hidden")))
ves_icall_System_Runtime_InteropServices_Marshal_FreeCoTaskMem (void * ptr)
{
  monoeg_g_free (ptr);
}


__attribute__((visibility ("hidden")))
ves_icall_System_Runtime_InteropServices_Marshal_ReAllocCoTaskMem (void * ptr, int size)
{
  void * D.27856;
  long unsigned int D.27857;

  D.27857 = (long unsigned int) size;
  D.27856 = monoeg_try_realloc (ptr, D.27857);
  return D.27856;
}


__attribute__((visibility ("hidden")))
ves_icall_System_Runtime_InteropServices_Marshal_UnsafeAddrOfPinnedArrayElement (struct MonoArray * arrayobj, int index)
{
  void * D.27859;
  double[0:] * D.27860;
  struct MonoVTable * D.27861;
  struct MonoClass * D.27862;
  int D.27863;
  int D.27864;
  sizetype D.27865;

  D.27860 = &arrayobj->vector;
  D.27861 = arrayobj->obj.vtable;
  D.27862 = D.27861->klass;
  D.27863 = mono_array_element_size (D.27862);
  D.27864 = D.27863 * index;
  D.27865 = (sizetype) D.27864;
  D.27859 = D.27860 + D.27865;
  return D.27859;
}


__attribute__((visibility ("hidden")))
ves_icall_System_Runtime_InteropServices_Marshal_GetDelegateForFunctionPointerInternal (void * ftn, struct MonoReflectionType * type)
{
  struct MonoType * D.27867;
  int D.27868;
  struct MonoException * D.27871;
  struct MonoDelegate * D.27872;
  struct MonoClass * klass;

  D.27867 = type->type;
  klass = mono_type_get_class (D.27867);
  D.27868 = mono_class_init (klass);
  if (D.27868 == 0) goto <D.27869>; else goto <D.27870>;
  <D.27869>:
  D.27871 = mono_class_get_exception_for_failure (klass);
  mono_raise_exception (D.27871);
  <D.27870>:
  D.27872 = mono_ftnptr_to_delegate (klass, ftn);
  return D.27872;
}


__attribute__((visibility ("hidden")))
mono_marshal_load_type_info (struct MonoClass * klass)
{
  _Bool D.27874;
  long int D.27875;
  long int D.27876;
  struct MonoMarshalType * D.27879;
  struct MonoMarshalType * D.27882;
  long unsigned int D.27883;
  long unsigned int D.27884;
  int D.27889;
  _Bool D.27890;
  long int D.27891;
  long int D.27892;
  unsigned int load_type_info_tls_id.367;
  struct MonoType * D.27896;
  short unsigned int D.27897;
  int D.27898;
  int D.27899;
  int D.27902;
  const char * D.27905;
  int D.27906;
  unsigned int D.27909;
  struct MonoImage * D.27910;
  long unsigned int D.27911;
  unsigned int D.27912;
  unsigned int D.27913;
  unsigned int D.27914;
  unsigned int count.368;
  unsigned int D.27916;
  struct MonoClass * D.27917;
  unsigned int native_size.369;
  unsigned int parent_size.370;
  unsigned int native_size.371;
  guint32 iftmp.372;
  long unsigned int D.27924;
  <unnamed-unsigned:4> D.27927;
  const char * D.27933;
  int D.27934;
  int D.27937;
  unsigned int D.27940;
  unsigned int D.27941;
  unsigned int D.27942;
  struct MonoMarshalSpec * * D.27943;
  int D.27944;
  int D.27947;
  const char * D.27950;
  int D.27951;
  struct MonoMarshalSpec * D.27954;
  <unnamed-unsigned:1> D.27955;
  int D.27956;
  guint32 iftmp.373;
  unsigned int D.27960;
  unsigned int align.374;
  unsigned int D.27963;
  unsigned int D.27964;
  unsigned int D.27965;
  unsigned int D.27966;
  unsigned int D.27967;
  unsigned int D.27968;
  unsigned int size.375;
  unsigned int D.27970;
  int D.27971;
  unsigned int D.27972;
  unsigned int D.27973;
  unsigned int D.27974;
  unsigned int D.27978;
  unsigned int D.27986;
  unsigned int D.27987;
  unsigned int D.27990;
  unsigned int D.27991;
  unsigned int D.27992;
  unsigned int D.27993;
  int D.27994;
  unsigned int D.27995;
  unsigned char D.27998;
  struct MonoClass * D.28001;
  int D.28002;
  _Bool D.28007;
  long int D.28008;
  long int D.28009;
  _Bool D.28016;
  long int D.28017;
  long int D.28018;
  int j;
  int count;
  guint32 native_size;
  guint32 min_align;
  guint32 packing;
  struct MonoMarshalType * info;
  struct MonoClassField * field;
  void * iter;
  guint32 layout;
  struct GSList * loads_list;

  try
    {
      count = 0;
      native_size = 0;
      min_align = 1;
      D.27874 = klass == 0B;
      D.27875 = (long int) D.27874;
      D.27876 = __builtin_expect (D.27875, 0);
      if (D.27876 != 0) goto <D.27877>; else goto <D.27878>;
      <D.27877>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 12208, "klass != NULL");
      <D.27878>:
      D.27879 = klass->marshal_info;
      if (D.27879 != 0B) goto <D.27880>; else goto <D.27881>;
      <D.27880>:
      D.27882 = klass->marshal_info;
      return D.27882;
      <D.27881>:
      D.27883 = BIT_FIELD_REF <*klass, 64, 256>;
      D.27884 = D.27883 & 9223372036854775808;
      if (D.27884 == 0) goto <D.27885>; else goto <D.27886>;
      <D.27885>:
      mono_class_init (klass);
      <D.27886>:
      D.27879 = klass->marshal_info;
      if (D.27879 != 0B) goto <D.27887>; else goto <D.27888>;
      <D.27887>:
      D.27882 = klass->marshal_info;
      return D.27882;
      <D.27888>:
      D.27889 = mono_marshal_is_loading_type_info (klass);
      D.27890 = D.27889 != 0;
      D.27891 = (long int) D.27890;
      D.27892 = __builtin_expect (D.27891, 0);
      if (D.27892 != 0) goto <D.27893>; else goto <D.27894>;
      <D.27893>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 12223, "!mono_marshal_is_loading_type_info (klass)");
      <D.27894>:
      load_type_info_tls_id.367 = load_type_info_tls_id;
      loads_list = pthread_getspecific (load_type_info_tls_id.367);
      loads_list = monoeg_g_slist_prepend (loads_list, klass);
      load_type_info_tls_id.367 = load_type_info_tls_id;
      mono_native_tls_set_value (load_type_info_tls_id.367, loads_list);
      iter = 0B;
      goto <D.21635>;
      <D.21636>:
      D.27896 = field->type;
      D.27897 = D.27896->attrs;
      D.27898 = (int) D.27897;
      D.27899 = D.27898 & 16;
      if (D.27899 != 0) goto <D.27900>; else goto <D.27901>;
      <D.27900>:
      // predicted unlikely by continue predictor.
      goto <D.21635>;
      <D.27901>:
      D.27896 = field->type;
      D.27897 = D.27896->attrs;
      D.27898 = (int) D.27897;
      D.27902 = D.27898 & 1536;
      if (D.27902 != 0) goto <D.27903>; else goto <D.27904>;
      <D.27903>:
      D.27905 = mono_field_get_name (field);
      D.27906 = strcmp (D.27905, "_Deleted");
      if (D.27906 == 0) goto <D.27907>; else goto <D.27908>;
      <D.27907>:
      // predicted unlikely by continue predictor.
      goto <D.21635>;
      <D.27908>:
      <D.27904>:
      count = count + 1;
      <D.21635>:
      field = mono_class_get_fields (klass, &iter);
      if (field != 0B) goto <D.21636>; else goto <D.21637>;
      <D.21637>:
      D.27909 = klass->flags;
      layout = D.27909 & 24;
      D.27910 = klass->image;
      D.27911 = (long unsigned int) count;
      D.27912 = (unsigned int) D.27911;
      D.27913 = D.27912 * 24;
      D.27914 = D.27913 + 32;
      info = mono_image_alloc0 (D.27910, D.27914);
      count.368 = (unsigned int) count;
      info->num_fields = count.368;
      D.27910 = klass->image;
      D.27916 = klass->type_token;
      mono_metadata_packing_from_typedef (D.27910, D.27916, 0B, &native_size);
      D.27917 = klass->parent;
      if (D.27917 != 0B) goto <D.27918>; else goto <D.27919>;
      <D.27918>:
      {
        int parent_size;

        D.27917 = klass->parent;
        parent_size = mono_class_native_size (D.27917, 0B);
        native_size.369 = native_size;
        parent_size.370 = (unsigned int) parent_size;
        native_size.371 = native_size.369 + parent_size.370;
        native_size = native_size.371;
        parent_size.370 = (unsigned int) parent_size;
        info->native_size = parent_size.370;
      }
      <D.27919>:
      D.27883 = BIT_FIELD_REF <*klass, 64, 256>;
      D.27924 = D.27883 & 263882790666240;
      if (D.27924 != 0) goto <D.27925>; else goto <D.27926>;
      <D.27925>:
      D.27927 = klass->packing_size;
      iftmp.372 = (guint32) D.27927;
      goto <D.27928>;
      <D.27926>:
      iftmp.372 = 8;
      <D.27928>:
      packing = iftmp.372;
      iter = 0B;
      j = 0;
      goto <D.21641>;
      <D.21646>:
      {
        int size;
        guint32 align;

        try
          {
            D.27896 = field->type;
            D.27897 = D.27896->attrs;
            D.27898 = (int) D.27897;
            D.27899 = D.27898 & 16;
            if (D.27899 != 0) goto <D.27929>; else goto <D.27930>;
            <D.27929>:
            // predicted unlikely by continue predictor.
            goto <D.21641>;
            <D.27930>:
            D.27896 = field->type;
            D.27897 = D.27896->attrs;
            D.27898 = (int) D.27897;
            D.27902 = D.27898 & 1536;
            if (D.27902 != 0) goto <D.27931>; else goto <D.27932>;
            <D.27931>:
            D.27933 = mono_field_get_name (field);
            D.27934 = strcmp (D.27933, "_Deleted");
            if (D.27934 == 0) goto <D.27935>; else goto <D.27936>;
            <D.27935>:
            // predicted unlikely by continue predictor.
            goto <D.21641>;
            <D.27936>:
            <D.27932>:
            D.27896 = field->type;
            D.27897 = D.27896->attrs;
            D.27898 = (int) D.27897;
            D.27937 = D.27898 & 4096;
            if (D.27937 != 0) goto <D.27938>; else goto <D.27939>;
            <D.27938>:
            D.27910 = klass->image;
            D.27940 = mono_class_get_field_token (field);
            D.27941 = D.27940 & 16777215;
            D.27942 = D.27941 + 4294967295;
            D.27943 = &info->fields[j].mspec;
            mono_metadata_field_info_with_mempool (D.27910, D.27942, 0B, 0B, D.27943);
            <D.27939>:
            info->fields[j].field = field;
            D.27944 = mono_class_num_fields (klass);
            if (D.27944 == 1) goto <D.27945>; else goto <D.27946>;
            <D.27945>:
            D.27947 = klass->instance_size;
            if (D.27947 == 16) goto <D.27948>; else goto <D.27949>;
            <D.27948>:
            D.27950 = mono_field_get_name (field);
            D.27951 = strcmp (D.27950, "$PRIVATE$");
            if (D.27951 == 0) goto <D.27952>; else goto <D.27953>;
            <D.27952>:
            // predicted unlikely by continue predictor.
            goto <D.21641>;
            <D.27953>:
            <D.27949>:
            <D.27946>:
            switch (layout) <default: <D.27975>, case 0: <D.21642>, case 8: <D.21643>, case 16: <D.21645>>
            <D.21642>:
            <D.21643>:
            D.27896 = field->type;
            D.27954 = info->fields[j].mspec;
            D.27955 = klass->unicode;
            D.27956 = (int) D.27955;
            size = mono_marshal_type_size (D.27896, D.27954, &align, 1, D.27956);
            D.27883 = BIT_FIELD_REF <*klass, 64, 256>;
            D.27924 = D.27883 & 263882790666240;
            if (D.27924 != 0) goto <D.27958>; else goto <D.27959>;
            <D.27958>:
            D.27927 = klass->packing_size;
            D.27960 = (unsigned int) D.27927;
            align.374 = align;
            iftmp.373 = MIN_EXPR <D.27960, align.374>;
            goto <D.27962>;
            <D.27959>:
            iftmp.373 = align;
            <D.27962>:
            align = iftmp.373;
            align.374 = align;
            min_align = MAX_EXPR <min_align, align.374>;
            D.27963 = info->native_size;
            info->fields[j].offset = D.27963;
            D.27964 = info->fields[j].offset;
            align.374 = align;
            D.27965 = D.27964 + align.374;
            D.27966 = D.27965 + 4294967295;
            info->fields[j].offset = D.27966;
            D.27964 = info->fields[j].offset;
            align.374 = align;
            D.27967 = -align.374;
            D.27968 = D.27964 & D.27967;
            info->fields[j].offset = D.27968;
            D.27964 = info->fields[j].offset;
            size.375 = (unsigned int) size;
            D.27970 = D.27964 + size.375;
            info->native_size = D.27970;
            goto <D.21644>;
            <D.21645>:
            D.27896 = field->type;
            D.27954 = info->fields[j].mspec;
            D.27955 = klass->unicode;
            D.27956 = (int) D.27955;
            size = mono_marshal_type_size (D.27896, D.27954, &align, 1, D.27956);
            align.374 = align;
            min_align = MAX_EXPR <min_align, align.374>;
            D.27971 = field->offset;
            D.27972 = (unsigned int) D.27971;
            D.27973 = D.27972 + 4294967280;
            info->fields[j].offset = D.27973;
            D.27964 = info->fields[j].offset;
            size.375 = (unsigned int) size;
            D.27970 = D.27964 + size.375;
            D.27963 = info->native_size;
            D.27974 = MAX_EXPR <D.27970, D.27963>;
            info->native_size = D.27974;
            goto <D.21644>;
            <D.27975>:
            <D.21644>:
            j = j + 1;
          }
        finally
          {
            align = {CLOBBER};
          }
      }
      <D.21641>:
      field = mono_class_get_fields (klass, &iter);
      if (field != 0B) goto <D.21646>; else goto <D.21647>;
      <D.21647>:
      if (layout != 0) goto <D.27976>; else goto <D.27977>;
      <D.27976>:
      D.27963 = info->native_size;
      native_size.369 = native_size;
      D.27978 = MAX_EXPR <D.27963, native_size.369>;
      info->native_size = D.27978;
      if (layout == 16) goto <D.27979>; else goto <D.27980>;
      <D.27979>:
      native_size.369 = native_size;
      if (native_size.369 != 0) goto <D.27983>; else goto <D.27981>;
      <D.27983>:
      D.27963 = info->native_size;
      native_size.369 = native_size;
      if (D.27963 == native_size.369) goto <D.27984>; else goto <D.27981>;
      <D.27984>:
      D.27883 = BIT_FIELD_REF <*klass, 64, 256>;
      D.27924 = D.27883 & 263882790666240;
      if (D.27924 == 0) goto <D.27985>; else goto <D.27981>;
      <D.27985>:
      min_align = 1;
      goto <D.27982>;
      <D.27981>:
      min_align = MIN_EXPR <packing, min_align>;
      <D.27982>:
      <D.27980>:
      <D.27977>:
      D.27963 = info->native_size;
      D.27986 = min_align + 4294967295;
      D.27987 = D.27963 & D.27986;
      if (D.27987 != 0) goto <D.27988>; else goto <D.27989>;
      <D.27988>:
      D.27963 = info->native_size;
      D.27990 = D.27963 + min_align;
      D.27991 = D.27990 + 4294967295;
      info->native_size = D.27991;
      D.27963 = info->native_size;
      D.27992 = -min_align;
      D.27993 = D.27963 & D.27992;
      info->native_size = D.27993;
      <D.27989>:
      info->min_align = min_align;
      D.27963 = info->native_size;
      D.27994 = mono_class_value_size (klass, 0B);
      D.27995 = (unsigned int) D.27994;
      if (D.27963 != D.27995) goto <D.27996>; else goto <D.27997>;
      <D.27996>:
      klass->blittable = 0;
      <D.27997>:
      D.27998 = klass->rank;
      if (D.27998 != 0) goto <D.27999>; else goto <D.28000>;
      <D.27999>:
      D.28001 = klass->element_class;
      D.28002 = mono_marshal_is_loading_type_info (D.28001);
      if (D.28002 == 0) goto <D.28003>; else goto <D.28004>;
      <D.28003>:
      D.28001 = klass->element_class;
      mono_marshal_load_type_info (D.28001);
      <D.28004>:
      <D.28000>:
      load_type_info_tls_id.367 = load_type_info_tls_id;
      loads_list = pthread_getspecific (load_type_info_tls_id.367);
      loads_list = monoeg_g_slist_remove (loads_list, klass);
      load_type_info_tls_id.367 = load_type_info_tls_id;
      mono_native_tls_set_value (load_type_info_tls_id.367, loads_list);
      {
        int ret;

        ret = pthread_mutex_lock (&marshal_mutex.mutex);
        if (ret != 0) goto <D.28005>; else goto <D.28006>;
        <D.28005>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.28006>:
        D.28007 = ret != 0;
        D.28008 = (long int) D.28007;
        D.28009 = __builtin_expect (D.28008, 0);
        if (D.28009 != 0) goto <D.28010>; else goto <D.28011>;
        <D.28010>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 12335, "ret == 0");
        <D.28011>:
      }
      D.27879 = klass->marshal_info;
      if (D.27879 == 0B) goto <D.28012>; else goto <D.28013>;
      <D.28012>:
      mono_memory_barrier ();
      klass->marshal_info = info;
      <D.28013>:
      {
        int ret;

        ret = pthread_mutex_unlock (&marshal_mutex.mutex);
        if (ret != 0) goto <D.28014>; else goto <D.28015>;
        <D.28014>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.28015>:
        D.28016 = ret != 0;
        D.28017 = (long int) D.28016;
        D.28018 = __builtin_expect (D.28017, 0);
        if (D.28018 != 0) goto <D.28019>; else goto <D.28020>;
        <D.28019>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 12341, "ret == 0");
        <D.28020>:
      }
      D.27882 = klass->marshal_info;
      return D.27882;
    }
  finally
    {
      native_size = {CLOBBER};
      iter = {CLOBBER};
    }
}


mono_marshal_is_loading_type_info (struct MonoClass * klass)
{
  unsigned int load_type_info_tls_id.376;
  gboolean D.28026;
  struct GSList * D.28027;
  _Bool D.28028;
  struct GSList * loads_list;

  load_type_info_tls_id.376 = load_type_info_tls_id;
  loads_list = pthread_getspecific (load_type_info_tls_id.376);
  D.28027 = monoeg_g_slist_find (loads_list, klass);
  D.28028 = D.28027 != 0B;
  D.28026 = (gboolean) D.28028;
  return D.28026;
}


__attribute__((visibility ("hidden")))
mono_class_native_size (struct MonoClass * klass, guint32 * align)
{
  struct MonoMarshalType * D.28030;
  int D.28033;
  gint32 D.28038;
  unsigned int D.28041;
  unsigned int D.28042;

  D.28030 = klass->marshal_info;
  if (D.28030 == 0B) goto <D.28031>; else goto <D.28032>;
  <D.28031>:
  D.28033 = mono_marshal_is_loading_type_info (klass);
  if (D.28033 != 0) goto <D.28034>; else goto <D.28035>;
  <D.28034>:
  if (align != 0B) goto <D.28036>; else goto <D.28037>;
  <D.28036>:
  *align = 0;
  <D.28037>:
  D.28038 = 0;
  return D.28038;
  <D.28035>:
  mono_marshal_load_type_info (klass);
  <D.28032>:
  if (align != 0B) goto <D.28039>; else goto <D.28040>;
  <D.28039>:
  D.28030 = klass->marshal_info;
  D.28041 = D.28030->min_align;
  *align = D.28041;
  <D.28040>:
  D.28030 = klass->marshal_info;
  D.28042 = D.28030->native_size;
  D.28038 = (gint32) D.28042;
  return D.28038;
}


__attribute__((visibility ("hidden")))
mono_type_native_stack_size (struct MonoType * t, guint32 * align)
{
  _Bool D.28044;
  long int D.28045;
  long int D.28046;
  long unsigned int D.28051;
  long unsigned int D.28052;
  int D.28055;
  unsigned char D.28056;
  int D.28057;
  int D.28058;
  long unsigned int D.28061;
  long unsigned int D.28062;
  struct MonoType * D.28065;
  int D.28066;
  unsigned int D.28067;
  unsigned int D.28068;
  unsigned int D.28069;
  guint32 tmp;

  try
    {
      D.28044 = t == 0B;
      D.28045 = (long int) D.28044;
      D.28046 = __builtin_expect (D.28045, 0);
      if (D.28046 != 0) goto <D.28047>; else goto <D.28048>;
      <D.28047>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 12389, "t != NULL");
      <D.28048>:
      if (align == 0B) goto <D.28049>; else goto <D.28050>;
      <D.28049>:
      align = &tmp;
      <D.28050>:
      D.28051 = BIT_FIELD_REF <*t, 64, 64>;
      D.28052 = D.28051 & 8589934592;
      if (D.28052 != 0) goto <D.28053>; else goto <D.28054>;
      <D.28053>:
      *align = 8;
      D.28055 = 8;
      return D.28055;
      <D.28054>:
      D.28056 = t->type;
      D.28057 = (int) D.28056;
      switch (D.28057) <default: <D.21691>, case 2: <D.21659>, case 3: <D.21660>, case 4: <D.21661>, case 5: <D.21662>, case 6: <D.21663>, case 7: <D.21664>, case 8: <D.21665>, case 9: <D.21666>, case 10: <D.21681>, case 11: <D.21682>, case 12: <D.21676>, case 13: <D.21677>, case 14: <D.21669>, case 15: <D.21673>, case 17: <D.21688>, case 18: <D.21671>, case 20: <D.21675>, case 21: <D.21686>, case 22: <D.21687>, case 24: <D.21667>, case 25: <D.21668>, case 27: <D.21674>, case 28: <D.21670>, case 29: <D.21672>>
      {
        typedef struct 
      {
        char c;
        gdouble x;
      } struct struct 
      {
        char c;
        gdouble x;
      };
        typedef struct 
      {
        char c;
        glong x;
      } struct struct 
      {
        char c;
        glong x;
      };

        <D.21659>:
        <D.21660>:
        <D.21661>:
        <D.21662>:
        <D.21663>:
        <D.21664>:
        <D.21665>:
        <D.21666>:
        *align = 4;
        D.28055 = 4;
        return D.28055;
        <D.21667>:
        <D.21668>:
        <D.21669>:
        <D.21670>:
        <D.21671>:
        <D.21672>:
        <D.21673>:
        <D.21674>:
        <D.21675>:
        *align = 8;
        D.28055 = 8;
        return D.28055;
        <D.21676>:
        *align = 4;
        D.28055 = 4;
        return D.28055;
        <D.21677>:
        *align = 8;
        D.28055 = 8;
        return D.28055;
        <D.21681>:
        <D.21682>:
        *align = 8;
        D.28055 = 8;
        return D.28055;
        <D.21686>:
        D.28058 = mono_type_generic_inst_is_valuetype (t);
        if (D.28058 == 0) goto <D.28059>; else goto <D.28060>;
        <D.28059>:
        *align = 8;
        D.28055 = 8;
        return D.28055;
        <D.28060>:
        <D.21687>:
        <D.21688>:
        {
          guint32 size;
          struct MonoClass * klass;

          klass = mono_class_from_mono_type (t);
          D.28061 = BIT_FIELD_REF <*klass, 64, 256>;
          D.28062 = D.28061 & 576460752303423488;
          if (D.28062 != 0) goto <D.28063>; else goto <D.28064>;
          <D.28063>:
          D.28065 = mono_class_enum_basetype (klass);
          D.28055 = mono_type_native_stack_size (D.28065, align);
          return D.28055;
          <D.28064>:
          D.28066 = mono_class_native_size (klass, align);
          size = (guint32) D.28066;
          D.28067 = *align;
          D.28068 = D.28067 + 3;
          *align = D.28068;
          D.28067 = *align;
          D.28069 = D.28067 & 4294967292;
          *align = D.28069;
          size = size + 3;
          size = size & 4294967292;
          D.28055 = (int) size;
          return D.28055;
        }
        <D.21691>:
        D.28056 = t->type;
        D.28057 = (int) D.28056;
        monoeg_g_log (0B, 4, "type 0x%02x unknown", D.28057);
        <D.21692>:
        goto <D.21692>;
      }
      D.28055 = 0;
      return D.28055;
    }
  finally
    {
      tmp = {CLOBBER};
    }
}


__attribute__((visibility ("hidden")))
mono_marshal_type_size (struct MonoType * type, struct MonoMarshalSpec * mspec, guint32 * align, gboolean as_field, gboolean unicode)
{
  gint32 D.28072;
  struct MonoClass * D.28073;
  <unnamed type> D.28078;
  int iftmp.377;
  _Bool D.28085;
  long int D.28086;
  long int D.28087;
  unsigned int esize.378;
  int D.28091;
  struct MonoClass * D.28092;
  struct MonoClass * D.28093;
  int iftmp.379;
  unsigned int esize.380;
  MonoMarshalNative native_type;
  struct MonoClass * klass;

  native_type = mono_type_to_unmanaged (type, mspec, as_field, unicode, 0B);
  switch (native_type) <default: <D.21748>, case 2: <D.21702>, case 3: <D.21703>, case 4: <D.21704>, case 5: <D.21705>, case 6: <D.21706>, case 7: <D.21708>, case 8: <D.21709>, case 9: <D.21711>, case 10: <D.21712>, case 11: <D.21716>, case 12: <D.21717>, case 15: <D.21746>, case 19: <D.21726>, case 20: <D.21723>, case 21: <D.21724>, case 22: <D.21725>, case 23: <D.21741>, case 25: <D.21731>, case 26: <D.21732>, case 27: <D.21740>, case 28: <D.21733>, case 29: <D.21730>, case 30: <D.21743>, case 31: <D.21721>, case 32: <D.21722>, case 34: <D.21747>, case 35: <D.21727>, case 36: <D.21728>, case 37: <D.21707>, case 38: <D.21735>, case 40: <D.21734>, case 42: <D.21729>, case 43: <D.21736>, case 44: <D.21745>, case 45: <D.21710>>
  {
    typedef struct 
  {
    char c;
    guint64 x;
  } struct struct 
  {
    char c;
    guint64 x;
  };
    typedef struct 
  {
    char c;
    double x;
  } struct struct 
  {
    char c;
    double x;
  };
    typedef struct 
  {
    char c;
    void * x;
  } struct struct 
  {
    char c;
    void * x;
  };

    <D.21702>:
    *align = 4;
    D.28072 = 4;
    return D.28072;
    <D.21703>:
    <D.21704>:
    *align = 1;
    D.28072 = 1;
    return D.28072;
    <D.21705>:
    <D.21706>:
    <D.21707>:
    *align = 2;
    D.28072 = 2;
    return D.28072;
    <D.21708>:
    <D.21709>:
    <D.21710>:
    *align = 4;
    D.28072 = 4;
    return D.28072;
    <D.21711>:
    <D.21712>:
    *align = 8;
    D.28072 = 8;
    return D.28072;
    <D.21716>:
    *align = 4;
    D.28072 = 4;
    return D.28072;
    <D.21717>:
    *align = 8;
    D.28072 = 8;
    return D.28072;
    <D.21721>:
    <D.21722>:
    <D.21723>:
    <D.21724>:
    <D.21725>:
    <D.21726>:
    <D.21727>:
    <D.21728>:
    <D.21729>:
    <D.21730>:
    <D.21731>:
    <D.21732>:
    <D.21733>:
    <D.21734>:
    <D.21735>:
    <D.21736>:
    *align = 8;
    D.28072 = 8;
    return D.28072;
    <D.21740>:
    klass = mono_class_from_mono_type (type);
    D.28073 = mono_defaults.object_class;
    if (D.28073 == klass) goto <D.28074>; else goto <D.28075>;
    <D.28074>:
    if (mspec != 0B) goto <D.28076>; else goto <D.28077>;
    <D.28076>:
    D.28078 = mspec->native;
    if (D.28078 == 27) goto <D.28079>; else goto <D.28080>;
    <D.28079>:
    *align = 16;
    D.28072 = 16;
    return D.28072;
    <D.28080>:
    <D.28077>:
    <D.28075>:
    D.28072 = mono_class_native_size (klass, align);
    return D.28072;
    <D.21741>:
    {
      int esize;

      if (unicode != 0) goto <D.28082>; else goto <D.28083>;
      <D.28082>:
      iftmp.377 = 2;
      goto <D.28084>;
      <D.28083>:
      iftmp.377 = 1;
      <D.28084>:
      esize = iftmp.377;
      D.28085 = mspec == 0B;
      D.28086 = (long int) D.28085;
      D.28087 = __builtin_expect (D.28086, 0);
      if (D.28087 != 0) goto <D.28088>; else goto <D.28089>;
      <D.28088>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 12524, "mspec");
      <D.28089>:
      esize.378 = (unsigned int) esize;
      *align = esize.378;
      D.28091 = mspec->data.array_data.num_elem;
      D.28072 = D.28091 * esize;
      return D.28072;
    }
    <D.21743>:
    {
      int esize;

      klass = mono_class_from_mono_type (type);
      D.28092 = klass->element_class;
      D.28093 = mono_defaults.char_class;
      if (D.28092 == D.28093) goto <D.28094>; else goto <D.28095>;
      <D.28094>:
      if (unicode != 0) goto <D.28097>; else goto <D.28098>;
      <D.28097>:
      iftmp.379 = 2;
      goto <D.28099>;
      <D.28098>:
      iftmp.379 = 1;
      <D.28099>:
      esize = iftmp.379;
      esize.380 = (unsigned int) esize;
      *align = esize.380;
      goto <D.28101>;
      <D.28095>:
      D.28092 = klass->element_class;
      esize = mono_class_native_size (D.28092, align);
      <D.28101>:
      D.28085 = mspec == 0B;
      D.28086 = (long int) D.28085;
      D.28087 = __builtin_expect (D.28086, 0);
      if (D.28087 != 0) goto <D.28102>; else goto <D.28103>;
      <D.28102>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 12538, "mspec");
      <D.28103>:
      D.28091 = mspec->data.array_data.num_elem;
      D.28072 = D.28091 * esize;
      return D.28072;
    }
    <D.21745>:
    *align = 8;
    D.28072 = 8;
    return D.28072;
    <D.21746>:
    <D.21747>:
    <D.21748>:
    monoeg_g_log (0B, 4, "native type %02x not implemented", native_type);
    <D.21749>:
    goto <D.21749>;
  }
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "marshal.c", 12551);
  D.28072 = 0;
  return D.28072;
}


__attribute__((visibility ("hidden")))
mono_marshal_asany (struct MonoObject * o, MonoMarshalNative string_encoding, int param_attrs)
{
  void * D.28107;
  struct MonoVTable * D.28108;
  struct MonoClass * D.28109;
  unsigned char D.28110;
  int D.28111;
  unsigned int D.28112;
  unsigned int D.28113;
  long unsigned int D.28117;
  long unsigned int D.28118;
  long unsigned int D.28122;
  int D.28123;
  long unsigned int D.28124;
  void * res.381;
  unsigned int param_attrs.382;
  unsigned int D.28127;
  struct MonoException * D.28131;
  struct MonoType * t;
  struct MonoClass * klass;

  if (o == 0B) goto <D.28105>; else goto <D.28106>;
  <D.28105>:
  D.28107 = 0B;
  return D.28107;
  <D.28106>:
  D.28108 = o->vtable;
  D.28109 = D.28108->klass;
  t = &D.28109->byval_arg;
  D.28110 = t->type;
  D.28111 = (int) D.28110;
  switch (D.28111) <default: <D.28130>, case 2: <D.21762>, case 3: <D.21765>, case 4: <D.21760>, case 5: <D.21761>, case 6: <D.21763>, case 7: <D.21764>, case 8: <D.21757>, case 9: <D.21758>, case 10: <D.21766>, case 11: <D.21767>, case 12: <D.21768>, case 13: <D.21769>, case 14: <D.21770>, case 15: <D.21759>, case 17: <D.21776>, case 18: <D.21775>>
  <D.21757>:
  <D.21758>:
  <D.21759>:
  <D.21760>:
  <D.21761>:
  <D.21762>:
  <D.21763>:
  <D.21764>:
  <D.21765>:
  <D.21766>:
  <D.21767>:
  <D.21768>:
  <D.21769>:
  D.28107 = mono_object_unbox (o);
  return D.28107;
  <D.21770>:
  switch (string_encoding) <default: <D.21773>, case 20: <D.21772>, case 21: <D.21771>>
  <D.21771>:
  D.28107 = mono_marshal_string_to_utf16_copy (o);
  return D.28107;
  <D.21772>:
  D.28107 = mono_string_to_lpstr (o);
  return D.28107;
  <D.21773>:
  monoeg_g_log (0B, 16, "marshaling conversion %d not implemented", string_encoding);
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "marshal.c", 12591);
  goto <D.21774>;
  <D.21775>:
  <D.21776>:
  {
    struct MonoMethod * method;
    void * pa[3];
    void * res;
    MonoBoolean delete_old;

    try
      {
        delete_old = 0;
        klass = t->data.klass;
        D.28112 = klass->flags;
        D.28113 = D.28112 & 24;
        if (D.28113 == 0) goto <D.21774>; else goto <D.28114>;
        <D.28114>:
        D.28117 = BIT_FIELD_REF <*klass, 64, 256>;
        D.28118 = D.28117 & 1152921504606846976;
        if (D.28118 != 0) goto <D.28119>; else goto <D.28120>;
        <D.28119>:
        D.28112 = klass->flags;
        D.28113 = D.28112 & 24;
        if (D.28113 == 16) goto <D.28115>; else goto <D.28121>;
        <D.28121>:
        D.28117 = BIT_FIELD_REF <*klass, 64, 256>;
        D.28122 = D.28117 & 864691128455135232;
        if (D.28122 != 0) goto <D.28115>; else goto <D.28116>;
        <D.28115>:
        D.28107 = mono_object_unbox (o);
        return D.28107;
        <D.28116>:
        <D.28120>:
        D.28123 = mono_class_native_size (klass, 0B);
        D.28124 = (long unsigned int) D.28123;
        res.381 = mono_marshal_alloc (D.28124);
        res = res.381;
        param_attrs.382 = (unsigned int) param_attrs;
        D.28127 = param_attrs.382 & 3;
        if (D.28127 != 2) goto <D.28128>; else goto <D.28129>;
        <D.28128>:
        D.28108 = o->vtable;
        D.28109 = D.28108->klass;
        method = mono_marshal_get_struct_to_ptr (D.28109);
        pa[0] = o;
        pa[1] = &res;
        pa[2] = &delete_old;
        mono_runtime_invoke (method, 0B, &pa, 0B);
        <D.28129>:
        D.28107 = res;
        return D.28107;
      }
    finally
      {
        pa = {CLOBBER};
        res = {CLOBBER};
        delete_old = {CLOBBER};
      }
  }
  <D.28130>:
  <D.21774>:
  D.28131 = mono_get_exception_argument ("", "No PInvoke conversion exists for value passed to Object-typed parameter.");
  mono_raise_exception (D.28131);
  D.28107 = 0B;
  return D.28107;
}


__attribute__((visibility ("hidden")))
mono_marshal_free_asany (struct MonoObject * o, void * ptr, MonoMarshalNative string_encoding, int param_attrs)
{
  struct MonoVTable * D.28137;
  struct MonoClass * D.28138;
  unsigned char D.28139;
  int D.28140;
  void * ptr.383;
  long unsigned int D.28142;
  long unsigned int D.28143;
  unsigned int D.28146;
  unsigned int D.28147;
  long unsigned int D.28149;
  int D.28151;
  unsigned int param_attrs.384;
  unsigned int D.28155;
  struct MonoType * t;
  struct MonoClass * klass;

  if (o == 0B) goto <D.28135>; else goto <D.28136>;
  <D.28135>:
  return;
  <D.28136>:
  D.28137 = o->vtable;
  D.28138 = D.28137->klass;
  t = &D.28138->byval_arg;
  D.28139 = t->type;
  D.28140 = (int) D.28139;
  switch (D.28140) <default: <D.21799>, case 14: <D.21789>, case 17: <D.21796>, case 18: <D.21795>>
  <D.21789>:
  switch (string_encoding) <default: <D.21793>, case 20: <D.21791>, case 21: <D.21790>>
  <D.21790>:
  <D.21791>:
  ptr.383 = ptr;
  mono_marshal_free (ptr.383);
  goto <D.21792>;
  <D.21793>:
  monoeg_g_log (0B, 16, "marshaling conversion %d not implemented", string_encoding);
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "marshal.c", 12650);
  <D.21792>:
  goto <D.21794>;
  <D.21795>:
  <D.21796>:
  klass = t->data.klass;
  D.28142 = BIT_FIELD_REF <*klass, 64, 256>;
  D.28143 = D.28142 & 1152921504606846976;
  if (D.28143 != 0) goto <D.28144>; else goto <D.28145>;
  <D.28144>:
  D.28146 = klass->flags;
  D.28147 = D.28146 & 24;
  if (D.28147 == 16) goto <D.21794>; else goto <D.28148>;
  <D.28148>:
  D.28142 = BIT_FIELD_REF <*klass, 64, 256>;
  D.28149 = D.28142 & 864691128455135232;
  if (D.28149 != 0) goto <D.21794>; else goto <D.28150>;
  <D.28150>:
  <D.28145>:
  D.28151 = param_attrs & 2;
  if (D.28151 != 0) goto <D.28152>; else goto <D.28153>;
  <D.28152>:
  {
    struct MonoMethod * method;
    void * pa[2];

    try
      {
        D.28137 = o->vtable;
        D.28138 = D.28137->klass;
        method = mono_marshal_get_ptr_to_struct (D.28138);
        pa[0] = &ptr;
        pa[1] = o;
        mono_runtime_invoke (method, 0B, &pa, 0B);
      }
    finally
      {
        pa = {CLOBBER};
      }
  }
  <D.28153>:
  param_attrs.384 = (unsigned int) param_attrs;
  D.28155 = param_attrs.384 & 3;
  if (D.28155 != 2) goto <D.28156>; else goto <D.28157>;
  <D.28156>:
  ptr.383 = ptr;
  mono_struct_delete_old (klass, ptr.383);
  <D.28157>:
  ptr.383 = ptr;
  mono_marshal_free (ptr.383);
  goto <D.21794>;
  <D.21799>:
  goto <D.21794>;
  <D.21794>:
}


__attribute__((visibility ("hidden")))
mono_marshal_get_generic_array_helper (struct MonoClass * class, struct MonoClass * iface, gchar * name, struct MonoMethod * method)
{
  struct MonoMethod * D.28160;
  struct MonoClass * D.28161;
  struct MonoImage * D.28162;
  int D.28163;
  unsigned int D.28164;
  short unsigned int D.28165;
  int D.28166;
  int D.28167;
  struct MonoMethod * D.28168;
  struct MonoMethodSignature * sig;
  struct MonoMethodSignature * csig;
  struct MonoMethodBuilder * mb;
  struct MonoMethod * res;
  struct WrapperInfo * info;
  int i;

  mb = mono_mb_new_no_dup_name (class, name, 7);
  D.28160 = mb->method;
  D.28160->slot = -1;
  D.28160 = mb->method;
  D.28160->flags = 481;
  sig = mono_method_signature (method);
  D.28161 = method->klass;
  D.28162 = D.28161->image;
  csig = signature_dup (D.28162, sig);
  csig->generic_param_count = 0;
  mono_mb_emit_ldarg (mb, 0);
  i = 0;
  goto <D.21813>;
  <D.21812>:
  D.28163 = i + 1;
  D.28164 = (unsigned int) D.28163;
  mono_mb_emit_ldarg (mb, D.28164);
  i = i + 1;
  <D.21813>:
  D.28165 = csig->param_count;
  D.28166 = (int) D.28165;
  if (D.28166 > i) goto <D.21812>; else goto <D.21814>;
  <D.21814>:
  mono_mb_emit_managed_call (mb, method, 0B);
  mono_mb_emit_byte (mb, 42);
  mb->skip_visibility = 1;
  D.28165 = csig->param_count;
  D.28166 = (int) D.28165;
  D.28167 = D.28166 + 16;
  res = mono_mb_create_method (mb, csig, D.28167);
  info = mono_wrapper_info_create (res, 21);
  info->d.generic_array_helper.method = method;
  mono_marshal_set_wrapper_info (res, info);
  mono_mb_free (mb);
  D.28168 = res;
  return D.28168;
}


mono_win32_compat_CopyMemory (void * dest, const void * source, gsize length)
{
  if (dest == 0B) goto <D.28170>; else goto <D.28172>;
  <D.28172>:
  if (source == 0B) goto <D.28170>; else goto <D.28171>;
  <D.28170>:
  return;
  <D.28171>:
  memcpy (dest, source, length);
}


mono_win32_compat_FillMemory (void * dest, gsize length, guchar fill)
{
  int D.28174;

  D.28174 = (int) fill;
  memset (dest, D.28174, length);
}


mono_win32_compat_MoveMemory (void * dest, const void * source, gsize length)
{
  if (dest == 0B) goto <D.28175>; else goto <D.28177>;
  <D.28177>:
  if (source == 0B) goto <D.28175>; else goto <D.28176>;
  <D.28175>:
  return;
  <D.28176>:
  memmove (dest, source, length);
}


mono_win32_compat_ZeroMemory (void * dest, gsize length)
{
  memset (dest, 0, length);
}


__attribute__((visibility ("hidden")))
mono_marshal_find_nonzero_bit_offset (guint8 * buf, int len, int * byte_offset, guint8 * bitmask)
{
  sizetype D.28179;
  guint8 * D.28180;
  unsigned char D.28181;
  _Bool D.28183;
  long int D.28184;
  long int D.28185;
  int D.28189;
  int D.28190;
  _Bool D.28191;
  long int D.28192;
  long int D.28193;
  int i;
  guint8 byte;

  i = 0;
  goto <D.21844>;
  <D.21843>:
  D.28179 = (sizetype) i;
  D.28180 = buf + D.28179;
  D.28181 = *D.28180;
  if (D.28181 != 0) goto <D.21842>; else goto <D.28182>;
  <D.28182>:
  i = i + 1;
  <D.21844>:
  if (i < len) goto <D.21843>; else goto <D.21842>;
  <D.21842>:
  D.28183 = i >= len;
  D.28184 = (long int) D.28183;
  D.28185 = __builtin_expect (D.28184, 0);
  if (D.28185 != 0) goto <D.28186>; else goto <D.28187>;
  <D.28186>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 12773, "i < len");
  <D.28187>:
  D.28179 = (sizetype) i;
  D.28180 = buf + D.28179;
  byte = *D.28180;
  goto <D.21846>;
  <D.21845>:
  byte = byte >> 1;
  <D.21846>:
  if (byte != 0) goto <D.28188>; else goto <D.21847>;
  <D.28188>:
  D.28189 = (int) byte;
  D.28190 = D.28189 & 1;
  if (D.28190 == 0) goto <D.21845>; else goto <D.21847>;
  <D.21847>:
  D.28191 = byte != 1;
  D.28192 = (long int) D.28191;
  D.28193 = __builtin_expect (D.28192, 0);
  if (D.28193 != 0) goto <D.28194>; else goto <D.28195>;
  <D.28194>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 12778, "byte == 1");
  <D.28195>:
  *byte_offset = i;
  D.28179 = (sizetype) i;
  D.28180 = buf + D.28179;
  D.28181 = *D.28180;
  *bitmask = D.28181;
}


__attribute__((visibility ("hidden")))
mono_marshal_get_thunk_invoke_wrapper (struct MonoMethod * method)
{
  _Bool D.28196;
  long int D.28197;
  long int D.28198;
  struct MonoClass * D.28201;
  struct GHashTable * * D.28202;
  struct MonoMethod * D.28205;
  const char * D.28206;
  short unsigned int D.28207;
  int D.28208;
  <unnamed-unsigned:1> D.28209;
  int D.28210;
  int D.28211;
  unsigned int param_count.385;
  long unsigned int D.28213;
  long unsigned int D.28214;
  unsigned int D.28215;
  unsigned int D.28216;
  long unsigned int D.28217;
  short unsigned int D.28218;
  long unsigned int D.28219;
  long unsigned int D.28220;
  struct MonoType * D.28223;
  int D.28224;
  struct MonoType * D.28225;
  int D.28226;
  struct MonoClass * D.28227;
  struct MonoType * D.28228;
  struct MonoType * D.28229;
  struct MonoType * D.28230;
  struct MonoType * D.28231;
  int D.28232;
  struct MonoClass * D.28235;
  struct MonoType * D.28236;
  int D.28237;
  unsigned int D.28240;
  int D.28241;
  unsigned int D.28242;
  unsigned int i.386;
  struct MonoType * D.28244;
  int D.28245;
  long unsigned int D.28250;
  long unsigned int D.28251;
  short unsigned int D.28255;
  int D.28256;
  int D.28257;
  int D.28261;
  unsigned int D.28264;
  int D.28265;
  unsigned int D.28266;
  unsigned int D.28267;
  unsigned int D.28268;
  int D.28269;
  unsigned int D.28270;
  int D.28271;
  unsigned int D.28272;
  unsigned int D.28273;
  unsigned int D.28274;
  unsigned int pos_leave.387;
  int D.28276;
  int D.28279;
  struct MonoClass * D.28282;
  int D.28283;
  struct MonoMethodBuilder * mb;
  struct MonoMethodSignature * sig;
  struct MonoMethodSignature * csig;
  struct MonoExceptionClause * clause;
  struct MonoImage * image;
  struct MonoClass * klass;
  struct GHashTable * cache;
  struct MonoMethod * res;
  int i;
  int param_count;
  int sig_size;
  int pos_leave;

  D.28196 = method == 0B;
  D.28197 = (long int) D.28196;
  D.28198 = __builtin_expect (D.28197, 0);
  if (D.28198 != 0) goto <D.28199>; else goto <D.28200>;
  <D.28199>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 12796, "method");
  <D.28200>:
  klass = method->klass;
  D.28201 = method->klass;
  image = D.28201->image;
  D.28202 = &image->thunk_invoke_cache;
  cache = get_cache (D.28202, mono_aligned_addr_hash, 0B);
  res = mono_marshal_find_in_cache (cache, method);
  if (res != 0B) goto <D.28203>; else goto <D.28204>;
  <D.28203>:
  D.28205 = res;
  return D.28205;
  <D.28204>:
  sig = mono_method_signature (method);
  D.28206 = method->name;
  mb = mono_mb_new (klass, D.28206, 5);
  D.28207 = sig->param_count;
  D.28208 = (int) D.28207;
  D.28209 = sig->hasthis;
  D.28210 = (int) D.28209;
  D.28211 = D.28208 + D.28210;
  param_count = D.28211 + 1;
  param_count.385 = (unsigned int) param_count;
  csig = mono_metadata_signature_alloc (image, param_count.385);
  D.28207 = sig->param_count;
  D.28213 = (long unsigned int) D.28207;
  D.28214 = D.28213 + 2;
  D.28215 = (unsigned int) D.28214;
  D.28216 = D.28215 * 8;
  sig_size = (int) D.28216;
  D.28217 = (long unsigned int) sig_size;
  memcpy (csig, sig, D.28217);
  D.28218 = (short unsigned int) param_count;
  csig->param_count = D.28218;
  csig->hasthis = 0;
  csig->pinvoke = 1;
  csig->call_convention = 0;
  D.28219 = BIT_FIELD_REF <*sig, 64, 64>;
  D.28220 = D.28219 & 512;
  if (D.28220 != 0) goto <D.28221>; else goto <D.28222>;
  <D.28221>:
  D.28223 = &klass->byval_arg;
  csig->params[0] = D.28223;
  i = 0;
  goto <D.21864>;
  <D.21863>:
  D.28224 = i + 1;
  D.28225 = sig->params[i];
  csig->params[D.28224] = D.28225;
  i = i + 1;
  <D.21864>:
  D.28207 = sig->param_count;
  D.28208 = (int) D.28207;
  if (D.28208 > i) goto <D.21863>; else goto <D.21865>;
  <D.21865>:
  <D.28222>:
  D.28226 = param_count + -1;
  D.28227 = mono_defaults.exception_class;
  D.28228 = &D.28227->byval_arg;
  D.28229 = mono_metadata_type_dup (image, D.28228);
  csig->params[D.28226] = D.28229;
  D.28226 = param_count + -1;
  D.28230 = csig->params[D.28226];
  D.28230->byref = 1;
  D.28226 = param_count + -1;
  D.28230 = csig->params[D.28226];
  D.28230->attrs = 2;
  D.28231 = sig->ret;
  D.28232 = mono_type_is_struct (D.28231);
  if (D.28232 != 0) goto <D.28233>; else goto <D.28234>;
  <D.28233>:
  D.28235 = mono_defaults.object_class;
  D.28236 = &D.28235->byval_arg;
  csig->ret = D.28236;
  <D.28234>:
  D.28235 = mono_defaults.object_class;
  D.28236 = &D.28235->byval_arg;
  mono_mb_add_local (mb, D.28236);
  D.28231 = sig->ret;
  D.28237 = mono_type_is_void (D.28231);
  if (D.28237 == 0) goto <D.28238>; else goto <D.28239>;
  <D.28238>:
  D.28231 = sig->ret;
  mono_mb_add_local (mb, D.28231);
  <D.28239>:
  D.28226 = param_count + -1;
  D.28240 = (unsigned int) D.28226;
  mono_mb_emit_ldarg (mb, D.28240);
  mono_mb_emit_byte (mb, 20);
  mono_mb_emit_byte (mb, 81);
  clause = mono_image_alloc0 (image, 32);
  D.28241 = mono_mb_get_label (mb);
  D.28242 = (unsigned int) D.28241;
  clause->try_offset = D.28242;
  i = 0;
  goto <D.21869>;
  <D.21868>:
  {
    struct MonoType * type;
    struct MonoClass * klass;

    i.386 = (unsigned int) i;
    mono_mb_emit_ldarg (mb, i.386);
    D.28244 = csig->params[i];
    klass = mono_class_from_mono_type (D.28244);
    type = &klass->byval_arg;
    D.28245 = mono_type_is_struct (type);
    if (D.28245 != 0) goto <D.28246>; else goto <D.28247>;
    <D.28246>:
    mono_mb_emit_op (mb, 121, klass);
    D.28244 = csig->params[i];
    D.28250 = BIT_FIELD_REF <*D.28244, 64, 64>;
    D.28251 = D.28250 & 8589934592;
    if (D.28251 == 0) goto <D.28252>; else goto <D.28253>;
    <D.28252>:
    if (i != 0) goto <D.28248>; else goto <D.28254>;
    <D.28254>:
    D.28219 = BIT_FIELD_REF <*sig, 64, 64>;
    D.28220 = D.28219 & 512;
    if (D.28220 == 0) goto <D.28248>; else goto <D.28249>;
    <D.28248>:
    mono_mb_emit_op (mb, 113, klass);
    <D.28249>:
    <D.28253>:
    D.28235 = mono_defaults.object_class;
    D.28236 = &D.28235->byval_arg;
    csig->params[i] = D.28236;
    <D.28247>:
  }
  i = i + 1;
  <D.21869>:
  D.28226 = param_count + -1;
  if (D.28226 > i) goto <D.21868>; else goto <D.21870>;
  <D.21870>:
  D.28255 = method->flags;
  D.28256 = (int) D.28255;
  D.28257 = D.28256 & 64;
  if (D.28257 != 0) goto <D.28258>; else goto <D.28259>;
  <D.28258>:
  mono_mb_emit_op (mb, 111, method);
  goto <D.28260>;
  <D.28259>:
  mono_mb_emit_op (mb, 40, method);
  <D.28260>:
  D.28231 = sig->ret;
  D.28261 = mono_type_is_void (D.28231);
  if (D.28261 == 0) goto <D.28262>; else goto <D.28263>;
  <D.28262>:
  mono_mb_emit_stloc (mb, 1);
  <D.28263>:
  D.28264 = mono_mb_emit_branch (mb, 221);
  pos_leave = (int) D.28264;
  clause->flags = 0;
  D.28265 = mono_mb_get_pos (mb);
  D.28266 = (unsigned int) D.28265;
  D.28267 = clause->try_offset;
  D.28268 = D.28266 - D.28267;
  clause->try_len = D.28268;
  D.28235 = mono_defaults.object_class;
  clause->data.catch_class = D.28235;
  D.28269 = mono_mb_get_label (mb);
  D.28270 = (unsigned int) D.28269;
  clause->handler_offset = D.28270;
  mono_mb_emit_stloc (mb, 0);
  D.28226 = param_count + -1;
  D.28240 = (unsigned int) D.28226;
  mono_mb_emit_ldarg (mb, D.28240);
  mono_mb_emit_ldloc (mb, 0);
  mono_mb_emit_byte (mb, 81);
  mono_mb_emit_branch (mb, 221);
  D.28271 = mono_mb_get_pos (mb);
  D.28272 = (unsigned int) D.28271;
  D.28273 = clause->handler_offset;
  D.28274 = D.28272 - D.28273;
  clause->handler_len = D.28274;
  mono_mb_set_clauses (mb, 1, clause);
  pos_leave.387 = (unsigned int) pos_leave;
  mono_mb_patch_branch (mb, pos_leave.387);
  D.28231 = sig->ret;
  D.28276 = mono_type_is_void (D.28231);
  if (D.28276 == 0) goto <D.28277>; else goto <D.28278>;
  <D.28277>:
  mono_mb_emit_ldloc (mb, 1);
  D.28231 = sig->ret;
  D.28279 = mono_type_is_struct (D.28231);
  if (D.28279 != 0) goto <D.28280>; else goto <D.28281>;
  <D.28280>:
  D.28231 = sig->ret;
  D.28282 = mono_class_from_mono_type (D.28231);
  mono_mb_emit_op (mb, 140, D.28282);
  <D.28281>:
  <D.28278>:
  mono_mb_emit_byte (mb, 42);
  D.28283 = param_count + 16;
  res = mono_mb_create_and_cache (cache, method, mb, csig, D.28283);
  mono_mb_free (mb);
  D.28205 = res;
  return D.28205;
}


__attribute__((visibility ("hidden")))
mono_marshal_free_dynamic_wrappers (struct MonoMethod * method)
{
  struct MonoClass * D.28285;
  long unsigned int D.28286;
  long unsigned int D.28287;
  _Bool D.28288;
  long int D.28289;
  long int D.28290;
  int marshal_mutex_initialized.388;
  _Bool D.28298;
  long int D.28299;
  long int D.28300;
  struct GHashTable * D.28303;
  struct GHashTable * D.28306;
  _Bool D.28313;
  long int D.28314;
  long int D.28315;
  struct MonoImage * image;

  D.28285 = method->klass;
  image = D.28285->image;
  D.28286 = BIT_FIELD_REF <*method, 64, 256>;
  D.28287 = D.28286 & 18014398509481984;
  D.28288 = D.28287 == 0;
  D.28289 = (long int) D.28288;
  D.28290 = __builtin_expect (D.28289, 0);
  if (D.28290 != 0) goto <D.28291>; else goto <D.28292>;
  <D.28291>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 12939, "method->dynamic");
  <D.28292>:
  marshal_mutex_initialized.388 = marshal_mutex_initialized;
  if (marshal_mutex_initialized.388 != 0) goto <D.28294>; else goto <D.28295>;
  <D.28294>:
  {
    int ret;

    ret = pthread_mutex_lock (&marshal_mutex.mutex);
    if (ret != 0) goto <D.28296>; else goto <D.28297>;
    <D.28296>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.28297>:
    D.28298 = ret != 0;
    D.28299 = (long int) D.28298;
    D.28300 = __builtin_expect (D.28299, 0);
    if (D.28300 != 0) goto <D.28301>; else goto <D.28302>;
    <D.28301>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 12943, "ret == 0");
    <D.28302>:
  }
  <D.28295>:
  D.28303 = image->runtime_invoke_direct_cache;
  if (D.28303 != 0B) goto <D.28304>; else goto <D.28305>;
  <D.28304>:
  D.28303 = image->runtime_invoke_direct_cache;
  monoeg_g_hash_table_remove (D.28303, method);
  <D.28305>:
  D.28306 = image->delegate_abstract_invoke_cache;
  if (D.28306 != 0B) goto <D.28307>; else goto <D.28308>;
  <D.28307>:
  D.28306 = image->delegate_abstract_invoke_cache;
  monoeg_g_hash_table_foreach_remove (D.28306, signature_method_pair_matches_method, method);
  <D.28308>:
  marshal_mutex_initialized.388 = marshal_mutex_initialized;
  if (marshal_mutex_initialized.388 != 0) goto <D.28309>; else goto <D.28310>;
  <D.28309>:
  {
    int ret;

    ret = pthread_mutex_unlock (&marshal_mutex.mutex);
    if (ret != 0) goto <D.28311>; else goto <D.28312>;
    <D.28311>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.28312>:
    D.28313 = ret != 0;
    D.28314 = (long int) D.28313;
    D.28315 = __builtin_expect (D.28314, 0);
    if (D.28315 != 0) goto <D.28316>; else goto <D.28317>;
    <D.28316>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 12954, "ret == 0");
    <D.28317>:
  }
  <D.28310>:
}


signature_method_pair_matches_method (void * key, void * value, void * user_data)
{
  gboolean D.28318;
  struct MonoMethod * D.28319;
  _Bool D.28320;
  struct SignatureMethodPair * pair;
  struct MonoMethod * method;

  pair = key;
  method = user_data;
  D.28319 = pair->method;
  D.28320 = D.28319 == method;
  D.28318 = (gboolean) D.28320;
  return D.28318;
}


__attribute__((visibility ("hidden")))
mono_marshal_free_inflated_wrappers (struct MonoMethod * method)
{
  long unsigned int D.28322;
  long unsigned int D.28323;
  _Bool D.28324;
  long int D.28325;
  long int D.28326;
  int marshal_mutex_initialized.389;
  _Bool D.28334;
  long int D.28335;
  long int D.28336;
  struct MonoClass * D.28341;
  struct MonoImage * D.28342;
  struct GHashTable * D.28343;
  struct GHashTable * D.28348;
  struct GHashTable * D.28353;
  struct GHashTable * D.28358;
  struct GHashTable * D.28363;
  struct GHashTable * D.28368;
  struct GHashTable * D.28371;
  struct GHashTable * D.28374;
  struct GHashTable * D.28377;
  struct GHashTable * D.28380;
  struct GHashTable * D.28383;
  struct GHashTable * D.28386;
  struct GHashTable * D.28389;
  struct GHashTable * D.28392;
  struct GHashTable * D.28395;
  struct GHashTable * D.28398;
  _Bool D.28403;
  long int D.28404;
  long int D.28405;
  struct MonoMethodSignature * sig;

  sig = method->signature;
  D.28322 = BIT_FIELD_REF <*method, 64, 256>;
  D.28323 = D.28322 & 2251799813685248;
  D.28324 = D.28323 == 0;
  D.28325 = (long int) D.28324;
  D.28326 = __builtin_expect (D.28325, 0);
  if (D.28326 != 0) goto <D.28327>; else goto <D.28328>;
  <D.28327>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 12976, "method->is_inflated");
  <D.28328>:
  marshal_mutex_initialized.389 = marshal_mutex_initialized;
  if (marshal_mutex_initialized.389 == 0) goto <D.28330>; else goto <D.28331>;
  <D.28330>:
  return;
  <D.28331>:
  {
    int ret;

    ret = pthread_mutex_lock (&marshal_mutex.mutex);
    if (ret != 0) goto <D.28332>; else goto <D.28333>;
    <D.28332>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.28333>:
    D.28334 = ret != 0;
    D.28335 = (long int) D.28334;
    D.28336 = __builtin_expect (D.28335, 0);
    if (D.28336 != 0) goto <D.28337>; else goto <D.28338>;
    <D.28337>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 12982, "ret == 0");
    <D.28338>:
  }
  if (sig != 0B) goto <D.28339>; else goto <D.28340>;
  <D.28339>:
  D.28341 = method->klass;
  D.28342 = D.28341->image;
  D.28343 = D.28342->delegate_begin_invoke_cache;
  if (D.28343 != 0B) goto <D.28344>; else goto <D.28345>;
  <D.28344>:
  D.28341 = method->klass;
  D.28342 = D.28341->image;
  D.28343 = D.28342->delegate_begin_invoke_cache;
  monoeg_g_hash_table_remove (D.28343, sig);
  <D.28345>:
  <D.28340>:
  if (sig != 0B) goto <D.28346>; else goto <D.28347>;
  <D.28346>:
  D.28341 = method->klass;
  D.28342 = D.28341->image;
  D.28348 = D.28342->delegate_end_invoke_cache;
  if (D.28348 != 0B) goto <D.28349>; else goto <D.28350>;
  <D.28349>:
  D.28341 = method->klass;
  D.28342 = D.28341->image;
  D.28348 = D.28342->delegate_end_invoke_cache;
  monoeg_g_hash_table_remove (D.28348, sig);
  <D.28350>:
  <D.28347>:
  if (sig != 0B) goto <D.28351>; else goto <D.28352>;
  <D.28351>:
  D.28341 = method->klass;
  D.28342 = D.28341->image;
  D.28353 = D.28342->delegate_invoke_cache;
  if (D.28353 != 0B) goto <D.28354>; else goto <D.28355>;
  <D.28354>:
  D.28341 = method->klass;
  D.28342 = D.28341->image;
  D.28353 = D.28342->delegate_invoke_cache;
  monoeg_g_hash_table_remove (D.28353, sig);
  <D.28355>:
  <D.28352>:
  if (sig != 0B) goto <D.28356>; else goto <D.28357>;
  <D.28356>:
  D.28341 = method->klass;
  D.28342 = D.28341->image;
  D.28358 = D.28342->runtime_invoke_cache;
  if (D.28358 != 0B) goto <D.28359>; else goto <D.28360>;
  <D.28359>:
  D.28341 = method->klass;
  D.28342 = D.28341->image;
  D.28358 = D.28342->runtime_invoke_cache;
  monoeg_g_hash_table_remove (D.28358, sig);
  <D.28360>:
  <D.28357>:
  if (sig != 0B) goto <D.28361>; else goto <D.28362>;
  <D.28361>:
  D.28341 = method->klass;
  D.28342 = D.28341->image;
  D.28363 = D.28342->runtime_invoke_vtype_cache;
  if (D.28363 != 0B) goto <D.28364>; else goto <D.28365>;
  <D.28364>:
  D.28341 = method->klass;
  D.28342 = D.28341->image;
  D.28363 = D.28342->runtime_invoke_vtype_cache;
  monoeg_g_hash_table_remove (D.28363, sig);
  <D.28365>:
  <D.28362>:
  if (sig != 0B) goto <D.28366>; else goto <D.28367>;
  <D.28366>:
  D.28341 = method->klass;
  D.28342 = D.28341->image;
  D.28368 = D.28342->delegate_abstract_invoke_cache;
  if (D.28368 != 0B) goto <D.28369>; else goto <D.28370>;
  <D.28369>:
  D.28341 = method->klass;
  D.28342 = D.28341->image;
  D.28368 = D.28342->delegate_abstract_invoke_cache;
  monoeg_g_hash_table_foreach_remove (D.28368, signature_method_pair_matches_signature, sig);
  <D.28370>:
  <D.28367>:
  D.28341 = method->klass;
  D.28342 = D.28341->image;
  D.28371 = D.28342->runtime_invoke_direct_cache;
  if (D.28371 != 0B) goto <D.28372>; else goto <D.28373>;
  <D.28372>:
  D.28341 = method->klass;
  D.28342 = D.28341->image;
  D.28371 = D.28342->runtime_invoke_direct_cache;
  monoeg_g_hash_table_remove (D.28371, method);
  <D.28373>:
  D.28341 = method->klass;
  D.28342 = D.28341->image;
  D.28374 = D.28342->managed_wrapper_cache;
  if (D.28374 != 0B) goto <D.28375>; else goto <D.28376>;
  <D.28375>:
  D.28341 = method->klass;
  D.28342 = D.28341->image;
  D.28374 = D.28342->managed_wrapper_cache;
  monoeg_g_hash_table_remove (D.28374, method);
  <D.28376>:
  D.28341 = method->klass;
  D.28342 = D.28341->image;
  D.28377 = D.28342->native_wrapper_cache;
  if (D.28377 != 0B) goto <D.28378>; else goto <D.28379>;
  <D.28378>:
  D.28341 = method->klass;
  D.28342 = D.28341->image;
  D.28377 = D.28342->native_wrapper_cache;
  monoeg_g_hash_table_remove (D.28377, method);
  <D.28379>:
  D.28341 = method->klass;
  D.28342 = D.28341->image;
  D.28380 = D.28342->remoting_invoke_cache;
  if (D.28380 != 0B) goto <D.28381>; else goto <D.28382>;
  <D.28381>:
  D.28341 = method->klass;
  D.28342 = D.28341->image;
  D.28380 = D.28342->remoting_invoke_cache;
  monoeg_g_hash_table_remove (D.28380, method);
  <D.28382>:
  D.28341 = method->klass;
  D.28342 = D.28341->image;
  D.28383 = D.28342->synchronized_cache;
  if (D.28383 != 0B) goto <D.28384>; else goto <D.28385>;
  <D.28384>:
  D.28341 = method->klass;
  D.28342 = D.28341->image;
  D.28383 = D.28342->synchronized_cache;
  monoeg_g_hash_table_remove (D.28383, method);
  <D.28385>:
  D.28341 = method->klass;
  D.28342 = D.28341->image;
  D.28386 = D.28342->unbox_wrapper_cache;
  if (D.28386 != 0B) goto <D.28387>; else goto <D.28388>;
  <D.28387>:
  D.28341 = method->klass;
  D.28342 = D.28341->image;
  D.28386 = D.28342->unbox_wrapper_cache;
  monoeg_g_hash_table_remove (D.28386, method);
  <D.28388>:
  D.28341 = method->klass;
  D.28342 = D.28341->image;
  D.28389 = D.28342->cominterop_invoke_cache;
  if (D.28389 != 0B) goto <D.28390>; else goto <D.28391>;
  <D.28390>:
  D.28341 = method->klass;
  D.28342 = D.28341->image;
  D.28389 = D.28342->cominterop_invoke_cache;
  monoeg_g_hash_table_remove (D.28389, method);
  <D.28391>:
  D.28341 = method->klass;
  D.28342 = D.28341->image;
  D.28392 = D.28342->cominterop_wrapper_cache;
  if (D.28392 != 0B) goto <D.28393>; else goto <D.28394>;
  <D.28393>:
  D.28341 = method->klass;
  D.28342 = D.28341->image;
  D.28392 = D.28342->cominterop_wrapper_cache;
  monoeg_g_hash_table_remove (D.28392, method);
  <D.28394>:
  D.28341 = method->klass;
  D.28342 = D.28341->image;
  D.28395 = D.28342->thunk_invoke_cache;
  if (D.28395 != 0B) goto <D.28396>; else goto <D.28397>;
  <D.28396>:
  D.28341 = method->klass;
  D.28342 = D.28341->image;
  D.28395 = D.28342->thunk_invoke_cache;
  monoeg_g_hash_table_remove (D.28395, method);
  <D.28397>:
  D.28341 = method->klass;
  D.28342 = D.28341->image;
  D.28398 = D.28342->native_func_wrapper_aot_cache;
  if (D.28398 != 0B) goto <D.28399>; else goto <D.28400>;
  <D.28399>:
  D.28341 = method->klass;
  D.28342 = D.28341->image;
  D.28398 = D.28342->native_func_wrapper_aot_cache;
  monoeg_g_hash_table_remove (D.28398, method);
  <D.28400>:
  {
    int ret;

    ret = pthread_mutex_unlock (&marshal_mutex.mutex);
    if (ret != 0) goto <D.28401>; else goto <D.28402>;
    <D.28401>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.28402>:
    D.28403 = ret != 0;
    D.28404 = (long int) D.28403;
    D.28405 = __builtin_expect (D.28404, 0);
    if (D.28405 != 0) goto <D.28406>; else goto <D.28407>;
    <D.28406>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "marshal.c", 13034, "ret == 0");
    <D.28407>:
  }
}


signature_method_pair_matches_signature (void * key, void * value, void * user_data)
{
  gboolean D.28409;
  struct MonoMethodSignature * D.28410;
  struct SignatureMethodPair * pair;
  struct MonoMethodSignature * sig;

  pair = key;
  sig = user_data;
  D.28410 = pair->sig;
  D.28409 = mono_metadata_signature_equal (D.28410, sig);
  return D.28409;
}