mono_class_get_interop_proxy_class ()
{
  struct MonoImage * D.20069;
  _Bool D.20070;
  long int D.20071;
  long int D.20072;
  struct MonoClass * D.20075;
  static struct MonoClass * tmp_class;
  struct MonoClass * class;

  class = tmp_class;
  if (class == 0B) goto <D.20067>; else goto <D.20068>;
  <D.20067>:
  D.20069 = mono_defaults.corlib;
  class = mono_class_from_name (D.20069, "Mono.Interop", "ComInteropProxy");
  D.20070 = class == 0B;
  D.20071 = (long int) D.20070;
  D.20072 = __builtin_expect (D.20071, 0);
  if (D.20072 != 0) goto <D.20073>; else goto <D.20074>;
  <D.20073>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "cominterop.c", 88, "class");
  <D.20074>:
  mono_memory_barrier ();
  tmp_class = class;
  <D.20068>:
  D.20075 = class;
  return D.20075;
}


mono_memory_barrier ()
{
  __sync_synchronize ();
}


mono_class_get_idispatch_class ()
{
  struct MonoImage * D.20079;
  _Bool D.20080;
  long int D.20081;
  long int D.20082;
  struct MonoClass * D.20085;
  static struct MonoClass * tmp_class;
  struct MonoClass * class;

  class = tmp_class;
  if (class == 0B) goto <D.20077>; else goto <D.20078>;
  <D.20077>:
  D.20079 = mono_defaults.corlib;
  class = mono_class_from_name (D.20079, "Mono.Interop", "IDispatch");
  D.20080 = class == 0B;
  D.20081 = (long int) D.20080;
  D.20082 = __builtin_expect (D.20081, 0);
  if (D.20082 != 0) goto <D.20083>; else goto <D.20084>;
  <D.20083>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "cominterop.c", 89, "class");
  <D.20084>:
  mono_memory_barrier ();
  tmp_class = class;
  <D.20078>:
  D.20085 = class;
  return D.20085;
}


mono_class_get_iunknown_class ()
{
  struct MonoImage * D.20089;
  _Bool D.20090;
  long int D.20091;
  long int D.20092;
  struct MonoClass * D.20095;
  static struct MonoClass * tmp_class;
  struct MonoClass * class;

  class = tmp_class;
  if (class == 0B) goto <D.20087>; else goto <D.20088>;
  <D.20087>:
  D.20089 = mono_defaults.corlib;
  class = mono_class_from_name (D.20089, "Mono.Interop", "IUnknown");
  D.20090 = class == 0B;
  D.20091 = (long int) D.20090;
  D.20092 = __builtin_expect (D.20091, 0);
  if (D.20092 != 0) goto <D.20093>; else goto <D.20094>;
  <D.20093>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "cominterop.c", 90, "class");
  <D.20094>:
  mono_memory_barrier ();
  tmp_class = class;
  <D.20088>:
  D.20095 = class;
  return D.20095;
}


mono_class_get_com_object_class ()
{
  struct MonoImage * D.20099;
  _Bool D.20100;
  long int D.20101;
  long int D.20102;
  struct MonoClass * D.20105;
  static struct MonoClass * tmp_class;
  struct MonoClass * class;

  class = tmp_class;
  if (class == 0B) goto <D.20097>; else goto <D.20098>;
  <D.20097>:
  D.20099 = mono_defaults.corlib;
  class = mono_class_from_name (D.20099, "System", "__ComObject");
  D.20100 = class == 0B;
  D.20101 = (long int) D.20100;
  D.20102 = __builtin_expect (D.20101, 0);
  if (D.20102 != 0) goto <D.20103>; else goto <D.20104>;
  <D.20103>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "cominterop.c", 92, "class");
  <D.20104>:
  mono_memory_barrier ();
  tmp_class = class;
  <D.20098>:
  D.20105 = class;
  return D.20105;
}


mono_class_get_variant_class ()
{
  struct MonoImage * D.20109;
  _Bool D.20110;
  long int D.20111;
  long int D.20112;
  struct MonoClass * D.20115;
  static struct MonoClass * tmp_class;
  struct MonoClass * class;

  class = tmp_class;
  if (class == 0B) goto <D.20107>; else goto <D.20108>;
  <D.20107>:
  D.20109 = mono_defaults.corlib;
  class = mono_class_from_name (D.20109, "System", "Variant");
  D.20110 = class == 0B;
  D.20111 = (long int) D.20110;
  D.20112 = __builtin_expect (D.20111, 0);
  if (D.20112 != 0) goto <D.20113>; else goto <D.20114>;
  <D.20113>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "cominterop.c", 93, "class");
  <D.20114>:
  mono_memory_barrier ();
  tmp_class = class;
  <D.20108>:
  D.20115 = class;
  return D.20115;
}


mono_cominterop_init ()
{
  int D.19406;
  int iftmp.0;
  int D.19405;
  const char[3] * D.20122;
  unsigned char D.20123;
  int D.20124;
  unsigned char D.20125;
  int D.20126;
  const unsigned char * D.20131;
  unsigned char D.20132;
  int D.20133;
  const unsigned char * D.20134;
  unsigned char D.20135;
  int D.20136;
  const unsigned char * D.20141;
  unsigned char D.20142;
  int D.20143;
  const unsigned char * D.20144;
  unsigned char D.20145;
  int D.20146;
  const unsigned char * D.20151;
  unsigned char D.20152;
  int D.20153;
  const unsigned char * D.20154;
  unsigned char D.20155;
  int D.20156;
  const char * com_provider_env;

  InitializeCriticalSection (&cominterop_mutex);
  com_provider_env = monoeg_g_getenv ("MONO_COM");
  if (com_provider_env != 0B) goto <D.20117>; else goto <D.20118>;
  <D.20117>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 2;
    if (__s2_len <= 3) goto <D.20120>; else goto <D.20121>;
    <D.20120>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = com_provider_env;
      D.20122 = "MS";
      D.20123 = MEM[(const unsigned char *)D.20122];
      D.20124 = (int) D.20123;
      D.20125 = *__s2;
      D.20126 = (int) D.20125;
      __result = D.20124 - D.20126;
      {
        if (__s2_len != 0) goto <D.20127>; else goto <D.20128>;
        <D.20127>:
        if (__result == 0) goto <D.20129>; else goto <D.20130>;
        <D.20129>:
        D.20131 = &MEM[(void *)"MS" + 1B];
        D.20132 = *D.20131;
        D.20133 = (int) D.20132;
        D.20134 = __s2 + 1;
        D.20135 = *D.20134;
        D.20136 = (int) D.20135;
        __result = D.20133 - D.20136;
        if (__s2_len > 1) goto <D.20137>; else goto <D.20138>;
        <D.20137>:
        if (__result == 0) goto <D.20139>; else goto <D.20140>;
        <D.20139>:
        D.20141 = &MEM[(void *)"MS" + 2B];
        D.20142 = *D.20141;
        D.20143 = (int) D.20142;
        D.20144 = __s2 + 2;
        D.20145 = *D.20144;
        D.20146 = (int) D.20145;
        __result = D.20143 - D.20146;
        if (__s2_len > 2) goto <D.20147>; else goto <D.20148>;
        <D.20147>:
        if (__result == 0) goto <D.20149>; else goto <D.20150>;
        <D.20149>:
        D.20151 = &MEM[(void *)"MS" + 3B];
        D.20152 = *D.20151;
        D.20153 = (int) D.20152;
        D.20154 = __s2 + 3;
        D.20155 = *D.20154;
        D.20156 = (int) D.20155;
        __result = D.20153 - D.20156;
        <D.20150>:
        <D.20148>:
        <D.20140>:
        <D.20138>:
        <D.20130>:
        <D.20128>:
      }
      D.19405 = __result;
    }
    iftmp.0 = -D.19405;
    goto <D.20157>;
    <D.20121>:
    iftmp.0 = __builtin_strcmp (com_provider_env, "MS");
    <D.20157>:
    D.19406 = iftmp.0;
  }
  if (D.19406 == 0) goto <D.20158>; else goto <D.20159>;
  <D.20158>:
  com_provider = 1;
  <D.20159>:
  <D.20118>:
  register_icall (cominterop_get_method_interface, "cominterop_get_method_interface", "ptr ptr", 0);
  register_icall (cominterop_get_function_pointer, "cominterop_get_function_pointer", "ptr ptr int32", 0);
  register_icall (cominterop_object_is_rcw, "cominterop_object_is_rcw", "int32 object", 0);
  register_icall (cominterop_get_ccw, "cominterop_get_ccw", "ptr object ptr", 0);
  register_icall (cominterop_get_ccw_object, "cominterop_get_ccw_object", "object ptr int32", 0);
  register_icall (cominterop_get_hresult_for_exception, "cominterop_get_hresult_for_exception", "int32 object", 0);
  register_icall (cominterop_get_interface, "cominterop_get_interface", "ptr object ptr int32", 0);
  register_icall (mono_string_to_bstr, "mono_string_to_bstr", "ptr obj", 0);
  register_icall (mono_string_from_bstr, "mono_string_from_bstr", "obj ptr", 0);
  register_icall (mono_free_bstr, "mono_free_bstr", "void ptr", 0);
  register_icall (cominterop_type_from_handle, "cominterop_type_from_handle", "object ptr", 0);
  register_icall (mono_marshal_safearray_begin, "mono_marshal_safearray_begin", "int32 ptr ptr ptr ptr ptr int32", 0);
  register_icall (mono_marshal_safearray_get_value, "mono_marshal_safearray_get_value", "ptr ptr ptr", 0);
  register_icall (mono_marshal_safearray_next, "mono_marshal_safearray_next", "int32 ptr ptr", 0);
  register_icall (mono_marshal_safearray_end, "mono_marshal_safearray_end", "void ptr ptr", 0);
  register_icall (mono_marshal_safearray_create, "mono_marshal_safearray_create", "int32 object ptr ptr ptr", 0);
  register_icall (mono_marshal_safearray_set_value, "mono_marshal_safearray_set_value", "void ptr ptr ptr", 0);
  register_icall (mono_marshal_safearray_free_indices, "mono_marshal_safearray_free_indices", "void ptr", 0);
}


mono_marshal_safearray_free_indices (void * indices)
{
  monoeg_g_free (indices);
}


mono_marshal_safearray_set_value (void * safearray, void * indices, void * value)
{
  <unnamed type> com_provider.1;
  int D.20164;
  int (*<T346e>) (void *, glong *, void * *) safe_array_put_element_ms.2;

  com_provider.1 = com_provider;
  if (com_provider.1 == 1) goto <D.20163>; else goto <D.20160>;
  <D.20163>:
  D.20164 = init_com_provider_ms ();
  if (D.20164 != 0) goto <D.20165>; else goto <D.20160>;
  <D.20165>:
  {
    int hr;

    safe_array_put_element_ms.2 = safe_array_put_element_ms;
    hr = safe_array_put_element_ms.2 (safearray, indices, value);
    if (hr < 0) goto <D.20167>; else goto <D.20168>;
    <D.20167>:
    cominterop_raise_hr_exception (hr);
    <D.20168>:
  }
  goto <D.20161>;
  <D.20160>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "cominterop.c", 3154);
  <D.20161>:
}


init_com_provider_ms ()
{
  int initialized.3;
  gboolean D.20172;
  char * error_msg.4;
  char * error_msg.5;
  char * error_msg.6;
  char * error_msg.7;
  char * error_msg.8;
  char * error_msg.9;
  char * error_msg.10;
  char * error_msg.11;
  char * error_msg.12;
  char * error_msg.13;
  char * error_msg.14;
  static gboolean initialized = 0;
  char * error_msg;
  struct MonoDl * module;
  const char * scope;

  try
    {
      module = 0B;
      scope = "liboleaut32.so";
      initialized.3 = initialized;
      if (initialized.3 != 0) goto <D.20170>; else goto <D.20171>;
      <D.20170>:
      D.20172 = 1;
      return D.20172;
      <D.20171>:
      module = mono_dl_open (scope, 1, &error_msg);
      error_msg.4 = error_msg;
      if (error_msg.4 != 0B) goto <D.20174>; else goto <D.20175>;
      <D.20174>:
      error_msg.4 = error_msg;
      monoeg_g_log (0B, 16, "Error loading COM support library \'%s\': %s", scope, error_msg.4);
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "cominterop.c", 2497);
      D.20172 = 0;
      return D.20172;
      <D.20175>:
      error_msg.5 = mono_dl_symbol (module, "SysAllocStringLen", &sys_alloc_string_len_ms);
      error_msg = error_msg.5;
      error_msg.4 = error_msg;
      if (error_msg.4 != 0B) goto <D.20177>; else goto <D.20178>;
      <D.20177>:
      error_msg.4 = error_msg;
      monoeg_g_log (0B, 16, "Error loading entry point \'%s\' in COM support library \'%s\': %s", "SysAllocStringLen", scope, error_msg.4);
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "cominterop.c", 2503);
      D.20172 = 0;
      return D.20172;
      <D.20178>:
      error_msg.6 = mono_dl_symbol (module, "SysStringLen", &sys_string_len_ms);
      error_msg = error_msg.6;
      error_msg.4 = error_msg;
      if (error_msg.4 != 0B) goto <D.20180>; else goto <D.20181>;
      <D.20180>:
      error_msg.4 = error_msg;
      monoeg_g_log (0B, 16, "Error loading entry point \'%s\' in COM support library \'%s\': %s", "SysStringLen", scope, error_msg.4);
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "cominterop.c", 2510);
      D.20172 = 0;
      return D.20172;
      <D.20181>:
      error_msg.7 = mono_dl_symbol (module, "SysFreeString", &sys_free_string_ms);
      error_msg = error_msg.7;
      error_msg.4 = error_msg;
      if (error_msg.4 != 0B) goto <D.20183>; else goto <D.20184>;
      <D.20183>:
      error_msg.4 = error_msg;
      monoeg_g_log (0B, 16, "Error loading entry point \'%s\' in COM support library \'%s\': %s", "SysFreeString", scope, error_msg.4);
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "cominterop.c", 2517);
      D.20172 = 0;
      return D.20172;
      <D.20184>:
      error_msg.8 = mono_dl_symbol (module, "SafeArrayGetDim", &safe_array_get_dim_ms);
      error_msg = error_msg.8;
      error_msg.4 = error_msg;
      if (error_msg.4 != 0B) goto <D.20186>; else goto <D.20187>;
      <D.20186>:
      error_msg.4 = error_msg;
      monoeg_g_log (0B, 16, "Error loading entry point \'%s\' in COM support library \'%s\': %s", "SafeArrayGetDim", scope, error_msg.4);
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "cominterop.c", 2524);
      D.20172 = 0;
      return D.20172;
      <D.20187>:
      error_msg.9 = mono_dl_symbol (module, "SafeArrayGetLBound", &safe_array_get_lbound_ms);
      error_msg = error_msg.9;
      error_msg.4 = error_msg;
      if (error_msg.4 != 0B) goto <D.20189>; else goto <D.20190>;
      <D.20189>:
      error_msg.4 = error_msg;
      monoeg_g_log (0B, 16, "Error loading entry point \'%s\' in COM support library \'%s\': %s", "SafeArrayGetLBound", scope, error_msg.4);
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "cominterop.c", 2531);
      D.20172 = 0;
      return D.20172;
      <D.20190>:
      error_msg.10 = mono_dl_symbol (module, "SafeArrayGetUBound", &safe_array_get_ubound_ms);
      error_msg = error_msg.10;
      error_msg.4 = error_msg;
      if (error_msg.4 != 0B) goto <D.20192>; else goto <D.20193>;
      <D.20192>:
      error_msg.4 = error_msg;
      monoeg_g_log (0B, 16, "Error loading entry point \'%s\' in COM support library \'%s\': %s", "SafeArrayGetUBound", scope, error_msg.4);
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "cominterop.c", 2538);
      D.20172 = 0;
      return D.20172;
      <D.20193>:
      error_msg.11 = mono_dl_symbol (module, "SafeArrayPtrOfIndex", &safe_array_ptr_of_index_ms);
      error_msg = error_msg.11;
      error_msg.4 = error_msg;
      if (error_msg.4 != 0B) goto <D.20195>; else goto <D.20196>;
      <D.20195>:
      error_msg.4 = error_msg;
      monoeg_g_log (0B, 16, "Error loading entry point \'%s\' in COM support library \'%s\': %s", "SafeArrayPtrOfIndex", scope, error_msg.4);
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "cominterop.c", 2545);
      D.20172 = 0;
      return D.20172;
      <D.20196>:
      error_msg.12 = mono_dl_symbol (module, "SafeArrayDestroy", &safe_array_destroy_ms);
      error_msg = error_msg.12;
      error_msg.4 = error_msg;
      if (error_msg.4 != 0B) goto <D.20198>; else goto <D.20199>;
      <D.20198>:
      error_msg.4 = error_msg;
      monoeg_g_log (0B, 16, "Error loading entry point \'%s\' in COM support library \'%s\': %s", "SafeArrayDestroy", scope, error_msg.4);
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "cominterop.c", 2552);
      D.20172 = 0;
      return D.20172;
      <D.20199>:
      error_msg.13 = mono_dl_symbol (module, "SafeArrayPutElement", &safe_array_put_element_ms);
      error_msg = error_msg.13;
      error_msg.4 = error_msg;
      if (error_msg.4 != 0B) goto <D.20201>; else goto <D.20202>;
      <D.20201>:
      error_msg.4 = error_msg;
      monoeg_g_log (0B, 16, "Error loading entry point \'%s\' in COM support library \'%s\': %s", "SafeArrayPutElement", scope, error_msg.4);
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "cominterop.c", 2559);
      D.20172 = 0;
      return D.20172;
      <D.20202>:
      error_msg.14 = mono_dl_symbol (module, "SafeArrayCreate", &safe_array_create_ms);
      error_msg = error_msg.14;
      error_msg.4 = error_msg;
      if (error_msg.4 != 0B) goto <D.20204>; else goto <D.20205>;
      <D.20204>:
      error_msg.4 = error_msg;
      monoeg_g_log (0B, 16, "Error loading entry point \'%s\' in COM support library \'%s\': %s", "SafeArrayCreate", scope, error_msg.4);
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "cominterop.c", 2566);
      D.20172 = 0;
      return D.20172;
      <D.20205>:
      initialized = 1;
      D.20172 = 1;
      return D.20172;
    }
  finally
    {
      error_msg = {CLOBBER};
    }
}


cominterop_raise_hr_exception (int hr)
{
  struct MonoMethod * throw_exception_for_hr.15;
  struct MonoClass * D.20211;
  struct MonoMethod * throw_exception_for_hr.16;
  static struct MonoMethod * throw_exception_for_hr = 0B;
  struct MonoException * ex;
  void * params[1];

  try
    {
      params[0] = &hr;
      throw_exception_for_hr.15 = throw_exception_for_hr;
      if (throw_exception_for_hr.15 == 0B) goto <D.20209>; else goto <D.20210>;
      <D.20209>:
      D.20211 = mono_defaults.marshal_class;
      throw_exception_for_hr.16 = mono_class_get_method_from_name (D.20211, "GetExceptionForHR", 1);
      throw_exception_for_hr = throw_exception_for_hr.16;
      <D.20210>:
      throw_exception_for_hr.15 = throw_exception_for_hr;
      ex = mono_runtime_invoke (throw_exception_for_hr.15, 0B, &params, 0B);
      mono_raise_exception (ex);
    }
  finally
    {
      params = {CLOBBER};
    }
}


mono_marshal_safearray_create (struct MonoArray * input, void * * newsafearray, void * * indices, void * empty)
{
  <unnamed type> com_provider.17;
  int D.20217;
  gboolean D.20218;
  long unsigned int D.20219;
  struct MonoVTable * D.20220;
  struct MonoClass * D.20221;
  unsigned char D.20222;
  long unsigned int D.20223;
  long unsigned int D.20224;
  void * D.20225;
  long unsigned int D.20226;
  _Bool D.20227;
  int D.20228;
  void * D.20231;
  long unsigned int D.20232;
  long unsigned int D.20233;
  int * D.20234;
  long unsigned int D.20235;
  struct SAFEARRAYBOUND * D.20236;
  struct MonoArrayBounds * D.20237;
  struct MonoArrayBounds * D.20238;
  int D.20239;
  int D.20240;
  unsigned int D.20241;
  unsigned int max_array_length.18;
  void * (*<T347a>) (int, guint32, struct SAFEARRAYBOUND *) safe_array_create_ms.19;
  unsigned int dim.20;
  void * D.20246;
  int dim;
  struct SAFEARRAYBOUND * bounds;
  int i;
  int max_array_length;

  com_provider.17 = com_provider;
  if (com_provider.17 != 1) goto <D.20213>; else goto <D.20216>;
  <D.20216>:
  D.20217 = init_com_provider_ms ();
  if (D.20217 == 0) goto <D.20213>; else goto <D.20214>;
  <D.20213>:
  D.20218 = 0;
  return D.20218;
  <D.20214>:
  D.20219 = mono_array_length (input);
  max_array_length = (int) D.20219;
  D.20220 = MEM[(struct MonoObject *)input].vtable;
  D.20221 = D.20220->klass;
  D.20222 = D.20221->rank;
  dim = (int) D.20222;
  D.20223 = (long unsigned int) dim;
  D.20224 = D.20223 * 4;
  D.20225 = monoeg_malloc (D.20224);
  *indices = D.20225;
  D.20223 = (long unsigned int) dim;
  D.20226 = D.20223 * 8;
  bounds = __builtin_alloca (D.20226);
  D.20227 = max_array_length == 0;
  D.20228 = (int) D.20227;
  MEM[(int *)empty] = D.20228;
  if (dim > 1) goto <D.20229>; else goto <D.20230>;
  <D.20229>:
  i = 0;
  goto <D.20046>;
  <D.20045>:
  D.20231 = *indices;
  D.20232 = (long unsigned int) i;
  D.20233 = D.20232 * 4;
  D.20234 = D.20231 + D.20233;
  D.20232 = (long unsigned int) i;
  D.20235 = D.20232 * 8;
  D.20236 = bounds + D.20235;
  D.20237 = input->bounds;
  D.20232 = (long unsigned int) i;
  D.20235 = D.20232 * 8;
  D.20238 = D.20237 + D.20235;
  D.20239 = D.20238->lower_bound;
  D.20236->lLbound = D.20239;
  D.20240 = D.20236->lLbound;
  *D.20234 = D.20240;
  D.20232 = (long unsigned int) i;
  D.20235 = D.20232 * 8;
  D.20236 = bounds + D.20235;
  D.20237 = input->bounds;
  D.20232 = (long unsigned int) i;
  D.20235 = D.20232 * 8;
  D.20238 = D.20237 + D.20235;
  D.20241 = D.20238->length;
  D.20236->cElements = D.20241;
  i = i + 1;
  <D.20046>:
  if (i < dim) goto <D.20045>; else goto <D.20047>;
  <D.20047>:
  goto <D.20242>;
  <D.20230>:
  D.20231 = *indices;
  MEM[(int *)D.20231] = 0;
  max_array_length.18 = (unsigned int) max_array_length;
  bounds->cElements = max_array_length.18;
  bounds->lLbound = 0;
  <D.20242>:
  safe_array_create_ms.19 = safe_array_create_ms;
  dim.20 = (unsigned int) dim;
  D.20246 = safe_array_create_ms.19 (12, dim.20, bounds);
  *newsafearray = D.20246;
  D.20218 = 1;
  return D.20218;
}


mono_marshal_safearray_end (void * safearray, void * indices)
{
  <unnamed type> com_provider.21;
  int D.20252;
  int (*<T3258>) (void *) safe_array_destroy_ms.22;

  monoeg_g_free (indices);
  com_provider.21 = com_provider;
  if (com_provider.21 == 1) goto <D.20251>; else goto <D.20248>;
  <D.20251>:
  D.20252 = init_com_provider_ms ();
  if (D.20252 != 0) goto <D.20253>; else goto <D.20248>;
  <D.20253>:
  safe_array_destroy_ms.22 = safe_array_destroy_ms;
  safe_array_destroy_ms.22 (safearray);
  goto <D.20249>;
  <D.20248>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "cominterop.c", 3089);
  <D.20249>:
}


mono_marshal_safearray_next (void * safearray, void * indices)
{
  unsigned int D.20255;
  int D.20256;
  unsigned int D.20257;
  long unsigned int D.20260;
  long unsigned int D.20261;
  int * D.20262;
  int D.20263;
  int D.20264;
  long int D.20265;
  long int ubound.23;
  long int lbound.24;
  int D.20271;
  gboolean D.20274;
  int i;
  int dim;
  gboolean ret;
  int * pIndices;
  int hr;

  D.20255 = mono_marshal_safearray_get_dim (safearray);
  dim = (int) D.20255;
  ret = 1;
  pIndices = indices;
  i = dim + -1;
  goto <D.20030>;
  <D.20029>:
  {
    glong lbound;
    glong ubound;

    try
      {
        D.20256 = i + 1;
        D.20257 = (unsigned int) D.20256;
        hr = mono_marshal_safe_array_get_ubound (safearray, D.20257, &ubound);
        if (hr < 0) goto <D.20258>; else goto <D.20259>;
        <D.20258>:
        cominterop_raise_hr_exception (hr);
        <D.20259>:
        D.20260 = (long unsigned int) i;
        D.20261 = D.20260 * 4;
        D.20262 = pIndices + D.20261;
        D.20263 = *D.20262;
        D.20264 = D.20263 + 1;
        *D.20262 = D.20264;
        D.20263 = *D.20262;
        D.20265 = (long int) D.20263;
        ubound.23 = ubound;
        if (D.20265 <= ubound.23) goto <D.20028>; else goto <D.20267>;
        <D.20267>:
        D.20256 = i + 1;
        D.20257 = (unsigned int) D.20256;
        hr = mono_marshal_safe_array_get_lbound (safearray, D.20257, &lbound);
        if (hr < 0) goto <D.20268>; else goto <D.20269>;
        <D.20268>:
        cominterop_raise_hr_exception (hr);
        <D.20269>:
        D.20260 = (long unsigned int) i;
        D.20261 = D.20260 * 4;
        D.20262 = pIndices + D.20261;
        lbound.24 = lbound;
        D.20271 = (int) lbound.24;
        *D.20262 = D.20271;
        if (i == 0) goto <D.20272>; else goto <D.20273>;
        <D.20272>:
        ret = 0;
        <D.20273>:
      }
    finally
      {
        lbound = {CLOBBER};
        ubound = {CLOBBER};
      }
  }
  i = i + -1;
  <D.20030>:
  if (i >= 0) goto <D.20029>; else goto <D.20028>;
  <D.20028>:
  D.20274 = ret;
  return D.20274;
}


mono_marshal_safearray_get_dim (void * safearray)
{
  <unnamed type> com_provider.25;
  int D.20282;
  guint32 (*<T184b>) (void *) safe_array_get_dim_ms.26;
  guint32 D.20285;
  guint32 result;

  result = 0;
  com_provider.25 = com_provider;
  if (com_provider.25 == 1) goto <D.20281>; else goto <D.20278>;
  <D.20281>:
  D.20282 = init_com_provider_ms ();
  if (D.20282 != 0) goto <D.20283>; else goto <D.20278>;
  <D.20283>:
  safe_array_get_dim_ms.26 = safe_array_get_dim_ms;
  result = safe_array_get_dim_ms.26 (safearray);
  goto <D.20279>;
  <D.20278>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "cominterop.c", 2914);
  <D.20279>:
  D.20285 = result;
  return D.20285;
}


mono_marshal_safe_array_get_ubound (void * psa, guint nDim, glong * plUbound)
{
  <unnamed type> com_provider.27;
  int D.20291;
  int (*<T3466>) (void *, guint32, glong *) safe_array_get_ubound_ms.28;
  int D.20294;
  int result;

  result = 0;
  com_provider.27 = com_provider;
  if (com_provider.27 == 1) goto <D.20290>; else goto <D.20287>;
  <D.20290>:
  D.20291 = init_com_provider_ms ();
  if (D.20291 != 0) goto <D.20292>; else goto <D.20287>;
  <D.20292>:
  safe_array_get_ubound_ms.28 = safe_array_get_ubound_ms;
  result = safe_array_get_ubound_ms.28 (psa, nDim, plUbound);
  goto <D.20288>;
  <D.20287>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "cominterop.c", 2946);
  <D.20288>:
  D.20294 = result;
  return D.20294;
}


mono_marshal_safe_array_get_lbound (void * psa, guint nDim, glong * plLbound)
{
  <unnamed type> com_provider.29;
  int D.20300;
  int (*<T3466>) (void *, guint32, glong *) safe_array_get_lbound_ms.30;
  int D.20303;
  int result;

  result = 0;
  com_provider.29 = com_provider;
  if (com_provider.29 == 1) goto <D.20299>; else goto <D.20296>;
  <D.20299>:
  D.20300 = init_com_provider_ms ();
  if (D.20300 != 0) goto <D.20301>; else goto <D.20296>;
  <D.20301>:
  safe_array_get_lbound_ms.30 = safe_array_get_lbound_ms;
  result = safe_array_get_lbound_ms.30 (psa, nDim, plLbound);
  goto <D.20297>;
  <D.20296>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "cominterop.c", 2930);
  <D.20297>:
  D.20303 = result;
  return D.20303;
}


mono_marshal_safearray_get_value (void * safearray, void * indices)
{
  <unnamed type> com_provider.31;
  int D.20309;
  int (*<T346e>) (void *, glong *, void * *) safe_array_ptr_of_index_ms.32;
  void * D.20314;
  void * result;

  try
    {
      com_provider.31 = com_provider;
      if (com_provider.31 == 1) goto <D.20308>; else goto <D.20305>;
      <D.20308>:
      D.20309 = init_com_provider_ms ();
      if (D.20309 != 0) goto <D.20310>; else goto <D.20305>;
      <D.20310>:
      {
        int hr;

        safe_array_ptr_of_index_ms.32 = safe_array_ptr_of_index_ms;
        hr = safe_array_ptr_of_index_ms.32 (safearray, indices, &result);
        if (hr < 0) goto <D.20312>; else goto <D.20313>;
        <D.20312>:
        cominterop_raise_hr_exception (hr);
        <D.20313>:
      }
      goto <D.20306>;
      <D.20305>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "cominterop.c", 3038);
      <D.20306>:
      D.20314 = result;
      return D.20314;
    }
  finally
    {
      result = {CLOBBER};
    }
}


mono_marshal_safearray_begin (void * safearray, struct MonoArray * * result, void * * indices, void * empty, void * parameter, gboolean allocateNewArray)
{
  <unnamed type> com_provider.33;
  int D.20321;
  gboolean D.20322;
  unsigned int D.20325;
  long unsigned int D.20328;
  long unsigned int D.20329;
  void * D.20330;
  long unsigned int D.20331;
  int D.20332;
  unsigned int D.20333;
  long int lbound.34;
  long int ubound.35;
  unsigned int D.20342;
  unsigned int D.20343;
  unsigned int D.20344;
  unsigned int D.20345;
  long unsigned int D.20346;
  long unsigned int D.20347;
  uintptr_t * D.20348;
  long unsigned int D.20349;
  intptr_t * D.20350;
  void * D.20351;
  long unsigned int D.20352;
  int * D.20353;
  int D.20354;
  struct MonoClass * D.20359;
  unsigned int dim.36;
  struct MonoDomain * D.20361;
  struct MonoArray * D.20362;
  int dim;
  uintptr_t * sizes;
  intptr_t * bounds;
  struct MonoClass * aklass;
  int i;
  gboolean bounded;

  bounded = 0;
  com_provider.33 = com_provider;
  if (com_provider.33 != 1) goto <D.20317>; else goto <D.20320>;
  <D.20320>:
  D.20321 = init_com_provider_ms ();
  if (D.20321 == 0) goto <D.20317>; else goto <D.20318>;
  <D.20317>:
  D.20322 = 0;
  return D.20322;
  <D.20318>:
  MEM[(int *)empty] = 1;
  if (safearray != 0B) goto <D.20323>; else goto <D.20324>;
  <D.20323>:
  D.20325 = mono_marshal_safearray_get_dim (safearray);
  dim = (int) D.20325;
  if (dim > 0) goto <D.20326>; else goto <D.20327>;
  <D.20326>:
  D.20328 = (long unsigned int) dim;
  D.20329 = D.20328 * 4;
  D.20330 = monoeg_malloc (D.20329);
  *indices = D.20330;
  D.20328 = (long unsigned int) dim;
  D.20331 = D.20328 * 8;
  sizes = __builtin_alloca (D.20331);
  D.20328 = (long unsigned int) dim;
  D.20331 = D.20328 * 8;
  bounds = __builtin_alloca (D.20331);
  i = 0;
  goto <D.20009>;
  <D.20008>:
  {
    glong lbound;
    glong ubound;
    int cursize;
    int hr;

    try
      {
        D.20332 = i + 1;
        D.20333 = (unsigned int) D.20332;
        hr = mono_marshal_safe_array_get_lbound (safearray, D.20333, &lbound);
        if (hr < 0) goto <D.20334>; else goto <D.20335>;
        <D.20334>:
        cominterop_raise_hr_exception (hr);
        <D.20335>:
        lbound.34 = lbound;
        if (lbound.34 != 0) goto <D.20337>; else goto <D.20338>;
        <D.20337>:
        bounded = 1;
        <D.20338>:
        D.20332 = i + 1;
        D.20333 = (unsigned int) D.20332;
        hr = mono_marshal_safe_array_get_ubound (safearray, D.20333, &ubound);
        if (hr < 0) goto <D.20339>; else goto <D.20340>;
        <D.20339>:
        cominterop_raise_hr_exception (hr);
        <D.20340>:
        ubound.35 = ubound;
        D.20342 = (unsigned int) ubound.35;
        lbound.34 = lbound;
        D.20343 = (unsigned int) lbound.34;
        D.20344 = D.20342 - D.20343;
        D.20345 = D.20344 + 1;
        cursize = (int) D.20345;
        D.20346 = (long unsigned int) i;
        D.20347 = D.20346 * 8;
        D.20348 = sizes + D.20347;
        D.20349 = (long unsigned int) cursize;
        *D.20348 = D.20349;
        D.20346 = (long unsigned int) i;
        D.20347 = D.20346 * 8;
        D.20350 = bounds + D.20347;
        lbound.34 = lbound;
        *D.20350 = lbound.34;
        D.20351 = *indices;
        D.20346 = (long unsigned int) i;
        D.20352 = D.20346 * 4;
        D.20353 = D.20351 + D.20352;
        lbound.34 = lbound;
        D.20354 = (int) lbound.34;
        *D.20353 = D.20354;
        if (cursize != 0) goto <D.20355>; else goto <D.20356>;
        <D.20355>:
        MEM[(int *)empty] = 0;
        <D.20356>:
      }
    finally
      {
        lbound = {CLOBBER};
        ubound = {CLOBBER};
      }
  }
  i = i + 1;
  <D.20009>:
  if (i < dim) goto <D.20008>; else goto <D.20010>;
  <D.20010>:
  if (allocateNewArray != 0) goto <D.20357>; else goto <D.20358>;
  <D.20357>:
  D.20359 = mono_defaults.object_class;
  dim.36 = (unsigned int) dim;
  aklass = mono_bounded_array_class_get (D.20359, dim.36, bounded);
  D.20361 = mono_domain_get ();
  D.20362 = mono_array_new_full (D.20361, aklass, sizes, bounds);
  *result = D.20362;
  goto <D.20363>;
  <D.20358>:
  *result = parameter;
  <D.20363>:
  <D.20327>:
  <D.20324>:
  D.20322 = 1;
  return D.20322;
}


cominterop_type_from_handle (struct MonoType * handle)
{
  struct MonoReflectionType * D.20365;
  struct MonoDomain * domain;
  struct MonoClass * klass;

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


cominterop_get_interface (struct MonoComObject * obj, struct MonoClass * ic, gboolean throw_exception)
{
  _Bool D.20367;
  long int D.20368;
  long int D.20369;
  int iftmp.37;
  unsigned int D.20375;
  unsigned int D.20376;
  unsigned char D.20378;
  _Bool D.20381;
  long int D.20382;
  long int D.20383;
  _Bool D.20388;
  long int D.20389;
  long int D.20390;
  struct GHashTable * D.20393;
  short unsigned int D.20396;
  long unsigned int D.20397;
  const void * D.20398;
  void * itf.38;
  _Bool D.20402;
  long int D.20403;
  long int D.20404;
  void * itf.39;
  _Bool D.20410;
  long int D.20411;
  long int D.20412;
  void * D.20415;
  _Bool D.20426;
  long int D.20427;
  long int D.20428;
  struct GHashTable * D.20433;
  void * D.20434;
  _Bool D.20437;
  long int D.20438;
  long int D.20439;
  _Bool D.20444;
  long int D.20445;
  long int D.20446;
  void * D.20449;
  void * itf;

  try
    {
      itf = 0B;
      D.20367 = ic == 0B;
      D.20368 = (long int) D.20367;
      D.20369 = __builtin_expect (D.20368, 0);
      if (D.20369 != 0) goto <D.20370>; else goto <D.20371>;
      <D.20370>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "cominterop.c", 473, "ic");
      <D.20371>:
      D.20375 = ic->flags;
      D.20376 = D.20375 & 32;
      if (D.20376 == 0) goto <D.20377>; else goto <D.20373>;
      <D.20377>:
      D.20378 = ic->byval_arg.type;
      if (D.20378 != 19) goto <D.20379>; else goto <D.20373>;
      <D.20379>:
      D.20378 = ic->byval_arg.type;
      if (D.20378 != 30) goto <D.20380>; else goto <D.20373>;
      <D.20380>:
      iftmp.37 = 1;
      goto <D.20374>;
      <D.20373>:
      iftmp.37 = 0;
      <D.20374>:
      D.20381 = iftmp.37 != 0;
      D.20382 = (long int) D.20381;
      D.20383 = __builtin_expect (D.20382, 0);
      if (D.20383 != 0) goto <D.20384>; else goto <D.20385>;
      <D.20384>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "cominterop.c", 474, "MONO_CLASS_IS_INTERFACE (ic)");
      <D.20385>:
      {
        int ret;

        ret = pthread_mutex_lock (&cominterop_mutex.mutex);
        if (ret != 0) goto <D.20386>; else goto <D.20387>;
        <D.20386>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.20387>:
        D.20388 = ret != 0;
        D.20389 = (long int) D.20388;
        D.20390 = __builtin_expect (D.20389, 0);
        if (D.20390 != 0) goto <D.20391>; else goto <D.20392>;
        <D.20391>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "cominterop.c", 476, "ret == 0");
        <D.20392>:
      }
      D.20393 = obj->itf_hash;
      if (D.20393 != 0B) goto <D.20394>; else goto <D.20395>;
      <D.20394>:
      D.20393 = obj->itf_hash;
      D.20396 = ic->interface_id;
      D.20397 = (long unsigned int) D.20396;
      D.20398 = (const void *) D.20397;
      itf.38 = monoeg_g_hash_table_lookup (D.20393, D.20398);
      itf = itf.38;
      <D.20395>:
      {
        int ret;

        ret = pthread_mutex_unlock (&cominterop_mutex.mutex);
        if (ret != 0) goto <D.20400>; else goto <D.20401>;
        <D.20400>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.20401>:
        D.20402 = ret != 0;
        D.20403 = (long int) D.20402;
        D.20404 = __builtin_expect (D.20403, 0);
        if (D.20404 != 0) goto <D.20405>; else goto <D.20406>;
        <D.20405>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "cominterop.c", 479, "ret == 0");
        <D.20406>:
      }
      itf.39 = itf;
      if (itf.39 == 0B) goto <D.20408>; else goto <D.20409>;
      <D.20408>:
      {
        guint8 iid[16];
        int found;
        int hr;

        try
          {
            found = cominterop_class_guid (ic, &iid);
            D.20410 = found == 0;
            D.20411 = (long int) D.20410;
            D.20412 = __builtin_expect (D.20411, 0);
            if (D.20412 != 0) goto <D.20413>; else goto <D.20414>;
            <D.20413>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "cominterop.c", 485, "found");
            <D.20414>:
            D.20415 = obj->iunknown;
            hr = ves_icall_System_Runtime_InteropServices_Marshal_QueryInterfaceInternal (D.20415, &iid, &itf);
            if (hr < 0) goto <D.20416>; else goto <D.20417>;
            <D.20416>:
            if (throw_exception != 0) goto <D.20418>; else goto <D.20419>;
            <D.20418>:
            cominterop_raise_hr_exception (hr);
            <D.20419>:
            <D.20417>:
            if (hr >= 0) goto <D.20420>; else goto <D.20421>;
            <D.20420>:
            itf.39 = itf;
            if (itf.39 != 0B) goto <D.20422>; else goto <D.20423>;
            <D.20422>:
            {
              int ret;

              ret = pthread_mutex_lock (&cominterop_mutex.mutex);
              if (ret != 0) goto <D.20424>; else goto <D.20425>;
              <D.20424>:
              monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
              <D.20425>:
              D.20426 = ret != 0;
              D.20427 = (long int) D.20426;
              D.20428 = __builtin_expect (D.20427, 0);
              if (D.20428 != 0) goto <D.20429>; else goto <D.20430>;
              <D.20429>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "cominterop.c", 492, "ret == 0");
              <D.20430>:
            }
            D.20393 = obj->itf_hash;
            if (D.20393 == 0B) goto <D.20431>; else goto <D.20432>;
            <D.20431>:
            D.20433 = monoeg_g_hash_table_new (mono_aligned_addr_hash, 0B);
            obj->itf_hash = D.20433;
            <D.20432>:
            D.20393 = obj->itf_hash;
            D.20396 = ic->interface_id;
            D.20397 = (long unsigned int) D.20396;
            D.20434 = (void *) D.20397;
            itf.39 = itf;
            monoeg_g_hash_table_insert_replace (D.20393, D.20434, itf.39, 0);
            {
              int ret;

              ret = pthread_mutex_unlock (&cominterop_mutex.mutex);
              if (ret != 0) goto <D.20435>; else goto <D.20436>;
              <D.20435>:
              monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
              <D.20436>:
              D.20437 = ret != 0;
              D.20438 = (long int) D.20437;
              D.20439 = __builtin_expect (D.20438, 0);
              if (D.20439 != 0) goto <D.20440>; else goto <D.20441>;
              <D.20440>:
              monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "cominterop.c", 496, "ret == 0");
              <D.20441>:
            }
            <D.20423>:
            <D.20421>:
          }
        finally
          {
            iid = {CLOBBER};
          }
      }
      <D.20409>:
      if (throw_exception != 0) goto <D.20442>; else goto <D.20443>;
      <D.20442>:
      itf.39 = itf;
      D.20444 = itf.39 == 0B;
      D.20445 = (long int) D.20444;
      D.20446 = __builtin_expect (D.20445, 0);
      if (D.20446 != 0) goto <D.20447>; else goto <D.20448>;
      <D.20447>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "cominterop.c", 501, "itf");
      <D.20448>:
      <D.20443>:
      D.20449 = itf;
      return D.20449;
    }
  finally
    {
      itf = {CLOBBER};
    }
}


cominterop_class_guid (struct MonoClass * klass, guint8 * guid)
{
  struct MonoClass * GuidAttribute.40;
  struct MonoImage * D.20455;
  struct MonoClass * GuidAttribute.41;
  gboolean D.20461;
  int D.20462;
  struct MonoString * D.20465;
  static struct MonoClass * GuidAttribute = 0B;
  struct MonoCustomAttrInfo * cinfo;

  GuidAttribute.40 = GuidAttribute;
  if (GuidAttribute.40 == 0B) goto <D.20453>; else goto <D.20454>;
  <D.20453>:
  D.20455 = mono_defaults.corlib;
  GuidAttribute.41 = mono_class_from_name (D.20455, "System.Runtime.InteropServices", "GuidAttribute");
  GuidAttribute = GuidAttribute.41;
  <D.20454>:
  cinfo = mono_custom_attrs_from_class (klass);
  if (cinfo != 0B) goto <D.20457>; else goto <D.20458>;
  <D.20457>:
  {
    struct MonoReflectionGuidAttribute * attr;

    GuidAttribute.40 = GuidAttribute;
    attr = mono_custom_attrs_get_attr (cinfo, GuidAttribute.40);
    if (attr == 0B) goto <D.20459>; else goto <D.20460>;
    <D.20459>:
    D.20461 = 0;
    return D.20461;
    <D.20460>:
    D.20462 = cinfo->cached;
    if (D.20462 == 0) goto <D.20463>; else goto <D.20464>;
    <D.20463>:
    mono_custom_attrs_free (cinfo);
    <D.20464>:
    D.20465 = attr->guid;
    cominterop_mono_string_to_guid (D.20465, guid);
    D.20461 = 1;
    return D.20461;
  }
  <D.20458>:
  D.20461 = 0;
  return D.20461;
}


cominterop_mono_string_to_guid (struct MonoString * string, guint8 * guid)
{
  sizetype D.20467;
  guint8 * D.20468;
  unsigned char D.20469;
  long unsigned int D.20470;
  long unsigned int D.20471;
  gunichar2 * D.20472;
  short unsigned int D.20473;
  unsigned int D.20474;
  int D.20475;
  unsigned char D.20476;
  sizetype D.20477;
  gunichar2 * D.20478;
  short unsigned int D.20479;
  unsigned int D.20480;
  int D.20481;
  unsigned char D.20482;
  unsigned char D.20483;
  unsigned char D.20484;
  unsigned int i.42;
  gunichar2 * chars;
  int i;
  static guint8 indexes[16] = {7, 5, 3, 1, 12, 10, 17, 15, 20, 22, 25, 27, 29, 31, 33, 35};

  chars = mono_string_chars (string);
  i = 0;
  i = 0;
  goto <D.19788>;
  <D.19787>:
  D.20467 = (sizetype) i;
  D.20468 = guid + D.20467;
  D.20469 = indexes[i];
  D.20470 = (long unsigned int) D.20469;
  D.20471 = D.20470 * 2;
  D.20472 = chars + D.20471;
  D.20473 = *D.20472;
  D.20474 = (unsigned int) D.20473;
  D.20475 = monoeg_g_unichar_xdigit_value (D.20474);
  D.20476 = (unsigned char) D.20475;
  D.20469 = indexes[i];
  D.20470 = (long unsigned int) D.20469;
  D.20471 = D.20470 * 2;
  D.20477 = D.20471 + 18446744073709551614;
  D.20478 = chars + D.20477;
  D.20479 = *D.20478;
  D.20480 = (unsigned int) D.20479;
  D.20481 = monoeg_g_unichar_xdigit_value (D.20480);
  D.20482 = (unsigned char) D.20481;
  D.20483 = D.20482 << 4;
  D.20484 = D.20476 + D.20483;
  *D.20468 = D.20484;
  i = i + 1;
  <D.19788>:
  i.42 = (unsigned int) i;
  if (i.42 <= 15) goto <D.19787>; else goto <D.19789>;
  <D.19789>:
}


cominterop_get_hresult_for_exception (struct MonoException * exc)
{
  int D.20486;
  int hr;

  hr = 0;
  D.20486 = hr;
  return D.20486;
}


cominterop_get_ccw_object (struct MonoCCWInterface * ccw_entry, gboolean verify)
{
  struct GHashTable * ccw_interface_hash.43;
  struct MonoObject * D.20491;
  _Bool D.20495;
  long int D.20496;
  long int D.20497;
  unsigned int D.20502;
  struct MonoCCW * ccw;

  ccw = 0B;
  ccw_interface_hash.43 = ccw_interface_hash;
  if (ccw_interface_hash.43 == 0B) goto <D.20489>; else goto <D.20490>;
  <D.20489>:
  D.20491 = 0B;
  return D.20491;
  <D.20490>:
  if (verify != 0) goto <D.20492>; else goto <D.20493>;
  <D.20492>:
  ccw_interface_hash.43 = ccw_interface_hash;
  ccw = monoeg_g_hash_table_lookup (ccw_interface_hash.43, ccw_entry);
  goto <D.20494>;
  <D.20493>:
  ccw = ccw_entry->ccw;
  D.20495 = ccw == 0B;
  D.20496 = (long int) D.20495;
  D.20497 = __builtin_expect (D.20496, 0);
  if (D.20497 != 0) goto <D.20498>; else goto <D.20499>;
  <D.20498>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "cominterop.c", 1764, "ccw");
  <D.20499>:
  <D.20494>:
  if (ccw != 0B) goto <D.20500>; else goto <D.20501>;
  <D.20500>:
  D.20502 = ccw->gc_handle;
  D.20491 = mono_gchandle_get_target (D.20502);
  return D.20491;
  <D.20501>:
  D.20491 = 0B;
  return D.20491;
}


cominterop_get_ccw (struct MonoObject * object, struct MonoClass * itf)
{
  void * D.20506;
  _Bool D.20509;
  long int D.20510;
  long int D.20511;
  struct GHashTable * ccw_hash.44;
  struct GHashTable * ccw_hash.45;
  struct GHashTable * ccw_interface_hash.46;
  struct GHashTable * ccw_interface_hash.47;
  int D.20522;
  long int D.20523;
  const void * D.20524;
  _Bool D.20527;
  long int D.20528;
  long int D.20529;
  unsigned int D.20532;
  struct MonoObject * D.20533;
  struct GList * iftmp.48;
  void * D.20540;
  void * D.20543;
  struct GHashTable * D.20548;
  unsigned int D.20549;
  _Bool D.20555;
  long int D.20556;
  long int D.20557;
  int D.20560;
  long int D.20561;
  void * D.20562;
  _Bool D.20565;
  long int D.20566;
  long int D.20567;
  struct MonoClass * coclass_attribute.49;
  struct MonoImage * D.20575;
  struct MonoClass * coclass_attribute.50;
  int D.20577;
  int iftmp.51;
  short unsigned int D.20584;
  struct MonoClass * * D.20586;
  struct MonoClass * D.20587;
  _Bool D.20588;
  long int D.20589;
  long int D.20590;
  int D.20593;
  struct MonoClass * D.20596;
  struct MonoClass * D.20600;
  unsigned int D.20604;
  unsigned int method_count.52;
  unsigned int D.20606;
  struct GHashTable * D.20607;
  int D.20610;
  struct MonoImage * D.20611;
  int D.20612;
  long unsigned int D.20613;
  unsigned int D.20614;
  unsigned int D.20615;
  void * * D.20618;
  unsigned int D.20619;
  struct MonoMethod * * D.20620;
  long unsigned int D.20621;
  long unsigned int D.20622;
  struct MonoMethod * * D.20623;
  short unsigned int D.20624;
  int D.20625;
  const char * D.20626;
  short unsigned int D.20627;
  int D.20628;
  int D.20629;
  long unsigned int D.20630;
  long unsigned int D.20631;
  short unsigned int D.20632;
  long unsigned int D.20633;
  long unsigned int D.20634;
  struct MonoMarshalSpec * * D.20635;
  long unsigned int D.20636;
  long unsigned int D.20637;
  struct MonoMarshalSpec * * D.20638;
  struct MonoMarshalSpec * D.20639;
  struct MonoMarshalSpec * D.20640;
  struct MonoType * D.20643;
  unsigned char D.20644;
  void * D.20647;
  void * D.20651;
  void * D.20655;
  void * D.20659;
  short int D.20664;
  short int D.20667;
  unsigned short D.20668;
  unsigned short D.20669;
  short int D.20670;
  struct MonoMarshalSpec * * D.20671;
  struct MonoType * D.20674;
  int D.20675;
  struct MonoMarshalSpec * D.20678;
  int D.20681;
  struct MonoType * D.20682;
  unsigned char D.20683;
  void * D.20686;
  void * D.20690;
  void * D.20694;
  void * D.20698;
  long unsigned int D.20699;
  long unsigned int D.20700;
  struct MonoMarshalSpec * * D.20701;
  _Bool D.20704;
  long int D.20705;
  long int D.20706;
  struct MonoMethodSignature * D.20709;
  short unsigned int D.20710;
  int D.20711;
  int D.20712;
  _Bool D.20715;
  long int D.20716;
  long int D.20717;
  int vtable_index.53;
  long unsigned int D.20721;
  long unsigned int D.20722;
  void * * D.20723;
  void * D.20724;
  int i;
  struct MonoCCW * ccw;
  struct MonoCCWInterface * ccw_entry;
  void * * vtable;
  static void * iunknown[3] = {0B, 0B, 0B};
  static void * idispatch[4] = {0B, 0B, 0B, 0B};
  struct MonoClass * iface;
  struct MonoClass * klass;
  struct EmitMarshalContext m;
  int start_slot;
  int method_count;
  struct GList * ccw_list;
  struct GList * ccw_list_item;
  struct MonoCustomAttrInfo * cinfo;

  try
    {
      ccw = 0B;
      ccw_entry = 0B;
      vtable = 0B;
      iface = 0B;
      klass = 0B;
      start_slot = 3;
      method_count = 0;
      cinfo = 0B;
      if (object == 0B) goto <D.20504>; else goto <D.20505>;
      <D.20504>:
      D.20506 = 0B;
      return D.20506;
      <D.20505>:
      klass = mono_object_get_class (object);
      {
        int ret;

        ret = pthread_mutex_lock (&cominterop_mutex.mutex);
        if (ret != 0) goto <D.20507>; else goto <D.20508>;
        <D.20507>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.20508>:
        D.20509 = ret != 0;
        D.20510 = (long int) D.20509;
        D.20511 = __builtin_expect (D.20510, 0);
        if (D.20511 != 0) goto <D.20512>; else goto <D.20513>;
        <D.20512>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "cominterop.c", 1828, "ret == 0");
        <D.20513>:
      }
      ccw_hash.44 = ccw_hash;
      if (ccw_hash.44 == 0B) goto <D.20515>; else goto <D.20516>;
      <D.20515>:
      ccw_hash.45 = monoeg_g_hash_table_new (mono_aligned_addr_hash, 0B);
      ccw_hash = ccw_hash.45;
      <D.20516>:
      ccw_interface_hash.46 = ccw_interface_hash;
      if (ccw_interface_hash.46 == 0B) goto <D.20519>; else goto <D.20520>;
      <D.20519>:
      ccw_interface_hash.47 = monoeg_g_hash_table_new (mono_aligned_addr_hash, 0B);
      ccw_interface_hash = ccw_interface_hash.47;
      <D.20520>:
      ccw_hash.44 = ccw_hash;
      D.20522 = mono_object_hash (object);
      D.20523 = (long int) D.20522;
      D.20524 = (const void *) D.20523;
      ccw_list = monoeg_g_hash_table_lookup (ccw_hash.44, D.20524);
      {
        int ret;

        ret = pthread_mutex_unlock (&cominterop_mutex.mutex);
        if (ret != 0) goto <D.20525>; else goto <D.20526>;
        <D.20525>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.20526>:
        D.20527 = ret != 0;
        D.20528 = (long int) D.20527;
        D.20529 = __builtin_expect (D.20528, 0);
        if (D.20529 != 0) goto <D.20530>; else goto <D.20531>;
        <D.20530>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "cominterop.c", 1835, "ret == 0");
        <D.20531>:
      }
      ccw_list_item = ccw_list;
      goto <D.19710>;
      <D.19709>:
      {
        struct MonoCCW * ccw_iter;

        ccw_iter = ccw_list_item->data;
        D.20532 = ccw_iter->gc_handle;
        D.20533 = mono_gchandle_get_target (D.20532);
        if (D.20533 == object) goto <D.20534>; else goto <D.20535>;
        <D.20534>:
        ccw = ccw_iter;
        goto <D.19708>;
        <D.20535>:
        if (ccw_list_item != 0B) goto <D.20537>; else goto <D.20538>;
        <D.20537>:
        iftmp.48 = ccw_list_item->next;
        goto <D.20539>;
        <D.20538>:
        iftmp.48 = 0B;
        <D.20539>:
        ccw_list_item = iftmp.48;
      }
      <D.19710>:
      if (ccw_list_item != 0B) goto <D.19709>; else goto <D.19708>;
      <D.19708>:
      D.20540 = iunknown[0];
      if (D.20540 == 0B) goto <D.20541>; else goto <D.20542>;
      <D.20541>:
      iunknown[0] = cominterop_ccw_queryinterface;
      iunknown[1] = cominterop_ccw_addref;
      iunknown[2] = cominterop_ccw_release;
      <D.20542>:
      D.20543 = idispatch[0];
      if (D.20543 == 0B) goto <D.20544>; else goto <D.20545>;
      <D.20544>:
      idispatch[0] = cominterop_ccw_get_type_info_count;
      idispatch[1] = cominterop_ccw_get_type_info;
      idispatch[2] = cominterop_ccw_get_ids_of_names;
      idispatch[3] = cominterop_ccw_invoke;
      <D.20545>:
      if (ccw == 0B) goto <D.20546>; else goto <D.20547>;
      <D.20546>:
      ccw = monoeg_malloc0 (16);
      D.20548 = monoeg_g_hash_table_new (mono_aligned_addr_hash, 0B);
      ccw->vtable_hash = D.20548;
      ccw->ref_count = 0;
      D.20549 = mono_gchandle_new_weakref (object, 0);
      ccw->gc_handle = D.20549;
      if (ccw_list == 0B) goto <D.20550>; else goto <D.20551>;
      <D.20550>:
      ccw_list = monoeg_g_list_alloc ();
      ccw_list->data = ccw;
      goto <D.20552>;
      <D.20551>:
      ccw_list = monoeg_g_list_append (ccw_list, ccw);
      <D.20552>:
      {
        int ret;

        ret = pthread_mutex_lock (&cominterop_mutex.mutex);
        if (ret != 0) goto <D.20553>; else goto <D.20554>;
        <D.20553>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.20554>:
        D.20555 = ret != 0;
        D.20556 = (long int) D.20555;
        D.20557 = __builtin_expect (D.20556, 0);
        if (D.20557 != 0) goto <D.20558>; else goto <D.20559>;
        <D.20558>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "cominterop.c", 1876, "ret == 0");
        <D.20559>:
      }
      ccw_hash.44 = ccw_hash;
      D.20560 = mono_object_hash (object);
      D.20561 = (long int) D.20560;
      D.20562 = (void *) D.20561;
      monoeg_g_hash_table_insert_replace (ccw_hash.44, D.20562, ccw_list, 0);
      {
        int ret;

        ret = pthread_mutex_unlock (&cominterop_mutex.mutex);
        if (ret != 0) goto <D.20563>; else goto <D.20564>;
        <D.20563>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.20564>:
        D.20565 = ret != 0;
        D.20566 = (long int) D.20565;
        D.20567 = __builtin_expect (D.20566, 0);
        if (D.20567 != 0) goto <D.20568>; else goto <D.20569>;
        <D.20568>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "cominterop.c", 1878, "ret == 0");
        <D.20569>:
      }
      mono_object_register_finalizer (object);
      <D.20547>:
      cinfo = mono_custom_attrs_from_class (itf);
      if (cinfo != 0B) goto <D.20570>; else goto <D.20571>;
      <D.20570>:
      {
        static struct MonoClass * coclass_attribute = 0B;

        coclass_attribute.49 = coclass_attribute;
        if (coclass_attribute.49 == 0B) goto <D.20573>; else goto <D.20574>;
        <D.20573>:
        D.20575 = mono_defaults.corlib;
        coclass_attribute.50 = mono_class_from_name (D.20575, "System.Runtime.InteropServices", "CoClassAttribute");
        coclass_attribute = coclass_attribute.50;
        <D.20574>:
        coclass_attribute.49 = coclass_attribute;
        D.20577 = mono_custom_attrs_has_attr (cinfo, coclass_attribute.49);
        if (D.20577 != 0) goto <D.20578>; else goto <D.20579>;
        <D.20578>:
        D.20584 = itf->interface_count;
        if (D.20584 == 0) goto <D.20581>; else goto <D.20585>;
        <D.20585>:
        D.20586 = itf->interfaces;
        D.20587 = *D.20586;
        if (D.20587 == 0B) goto <D.20581>; else goto <D.20582>;
        <D.20581>:
        iftmp.51 = 1;
        goto <D.20583>;
        <D.20582>:
        iftmp.51 = 0;
        <D.20583>:
        D.20588 = iftmp.51 != 0;
        D.20589 = (long int) D.20588;
        D.20590 = __builtin_expect (D.20589, 0);
        if (D.20590 != 0) goto <D.20591>; else goto <D.20592>;
        <D.20591>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "cominterop.c", 1889, "itf->interface_count && itf->interfaces[0]");
        <D.20592>:
        D.20586 = itf->interfaces;
        itf = *D.20586;
        <D.20579>:
        D.20593 = cinfo->cached;
        if (D.20593 == 0) goto <D.20594>; else goto <D.20595>;
        <D.20594>:
        mono_custom_attrs_free (cinfo);
        <D.20595>:
      }
      <D.20571>:
      iface = itf;
      D.20596 = mono_class_get_iunknown_class ();
      if (D.20596 == iface) goto <D.20597>; else goto <D.20598>;
      <D.20597>:
      start_slot = 3;
      goto <D.20599>;
      <D.20598>:
      D.20600 = mono_class_get_idispatch_class ();
      if (D.20600 == iface) goto <D.20601>; else goto <D.20602>;
      <D.20601>:
      start_slot = 7;
      goto <D.20603>;
      <D.20602>:
      D.20604 = iface->method.count;
      method_count.52 = (unsigned int) method_count;
      D.20606 = D.20604 + method_count.52;
      method_count = (int) D.20606;
      start_slot = cominterop_get_com_slot_begin (iface);
      iface = 0B;
      <D.20603>:
      <D.20599>:
      D.20607 = ccw->vtable_hash;
      ccw_entry = monoeg_g_hash_table_lookup (D.20607, itf);
      if (ccw_entry == 0B) goto <D.20608>; else goto <D.20609>;
      <D.20608>:
      {
        int vtable_index;

        D.20610 = method_count + -1;
        vtable_index = D.20610 + start_slot;
        D.20611 = klass->image;
        D.20612 = method_count + start_slot;
        D.20613 = (long unsigned int) D.20612;
        D.20614 = (unsigned int) D.20613;
        D.20615 = D.20614 * 8;
        vtable = mono_image_alloc0 (D.20611, D.20615);
        memcpy (vtable, &iunknown, 24);
        if (start_slot == 7) goto <D.20616>; else goto <D.20617>;
        <D.20616>:
        D.20618 = vtable + 24;
        memcpy (D.20618, &idispatch, 32);
        <D.20617>:
        iface = itf;
        D.20604 = iface->method.count;
        D.20619 = D.20604 + 4294967295;
        i = (int) D.20619;
        goto <D.19734>;
        <D.19733>:
        {
          int param_index;
          struct MonoMethodBuilder * mb;
          struct MonoMarshalSpec * * mspecs;
          struct MonoMethod * wrapper_method;
          struct MonoMethod * adjust_method;
          struct MonoMethod * method;
          struct MonoMethodSignature * sig_adjusted;
          struct MonoMethodSignature * sig;
          gboolean preserve_sig;

          param_index = 0;
          D.20620 = iface->methods;
          D.20621 = (long unsigned int) i;
          D.20622 = D.20621 * 8;
          D.20623 = D.20620 + D.20622;
          method = *D.20623;
          sig = mono_method_signature (method);
          D.20624 = method->iflags;
          D.20625 = (int) D.20624;
          preserve_sig = D.20625 & 128;
          D.20626 = method->name;
          mb = mono_mb_new (iface, D.20626, 5);
          adjust_method = cominterop_get_managed_wrapper_adjusted (method);
          sig_adjusted = mono_method_signature (adjust_method);
          D.20627 = sig_adjusted->param_count;
          D.20628 = (int) D.20627;
          D.20629 = D.20628 + 1;
          D.20630 = (long unsigned int) D.20629;
          D.20631 = D.20630 * 8;
          mspecs = monoeg_malloc (D.20631);
          mono_method_get_marshal_info (method, mspecs);
          D.20632 = sig->param_count;
          param_index = (int) D.20632;
          goto <D.19726>;
          <D.19725>:
          {
            int mspec_index;

            mspec_index = param_index + 1;
            D.20633 = (long unsigned int) mspec_index;
            D.20634 = D.20633 * 8;
            D.20635 = mspecs + D.20634;
            D.20636 = (long unsigned int) param_index;
            D.20637 = D.20636 * 8;
            D.20638 = mspecs + D.20637;
            D.20639 = *D.20638;
            *D.20635 = D.20639;
            D.20633 = (long unsigned int) mspec_index;
            D.20634 = D.20633 * 8;
            D.20635 = mspecs + D.20634;
            D.20640 = *D.20635;
            if (D.20640 == 0B) goto <D.20641>; else goto <D.20642>;
            <D.20641>:
            D.20643 = sig_adjusted->params[param_index];
            D.20644 = D.20643->type;
            if (D.20644 == 28) goto <D.20645>; else goto <D.20646>;
            <D.20645>:
            D.20633 = (long unsigned int) mspec_index;
            D.20634 = D.20633 * 8;
            D.20635 = mspecs + D.20634;
            D.20647 = monoeg_malloc0 (24);
            *D.20635 = D.20647;
            D.20633 = (long unsigned int) mspec_index;
            D.20634 = D.20633 * 8;
            D.20635 = mspecs + D.20634;
            D.20640 = *D.20635;
            D.20640->native = 27;
            goto <D.20648>;
            <D.20646>:
            D.20643 = sig_adjusted->params[param_index];
            D.20644 = D.20643->type;
            if (D.20644 == 14) goto <D.20649>; else goto <D.20650>;
            <D.20649>:
            D.20633 = (long unsigned int) mspec_index;
            D.20634 = D.20633 * 8;
            D.20635 = mspecs + D.20634;
            D.20651 = monoeg_malloc0 (24);
            *D.20635 = D.20651;
            D.20633 = (long unsigned int) mspec_index;
            D.20634 = D.20633 * 8;
            D.20635 = mspecs + D.20634;
            D.20640 = *D.20635;
            D.20640->native = 19;
            goto <D.20652>;
            <D.20650>:
            D.20643 = sig_adjusted->params[param_index];
            D.20644 = D.20643->type;
            if (D.20644 == 18) goto <D.20653>; else goto <D.20654>;
            <D.20653>:
            D.20633 = (long unsigned int) mspec_index;
            D.20634 = D.20633 * 8;
            D.20635 = mspecs + D.20634;
            D.20655 = monoeg_malloc0 (24);
            *D.20635 = D.20655;
            D.20633 = (long unsigned int) mspec_index;
            D.20634 = D.20633 * 8;
            D.20635 = mspecs + D.20634;
            D.20640 = *D.20635;
            D.20640->native = 28;
            goto <D.20656>;
            <D.20654>:
            D.20643 = sig_adjusted->params[param_index];
            D.20644 = D.20643->type;
            if (D.20644 == 2) goto <D.20657>; else goto <D.20658>;
            <D.20657>:
            D.20633 = (long unsigned int) mspec_index;
            D.20634 = D.20633 * 8;
            D.20635 = mspecs + D.20634;
            D.20659 = monoeg_malloc0 (24);
            *D.20635 = D.20659;
            D.20633 = (long unsigned int) mspec_index;
            D.20634 = D.20633 * 8;
            D.20635 = mspecs + D.20634;
            D.20640 = *D.20635;
            D.20640->native = 37;
            <D.20658>:
            <D.20656>:
            <D.20652>:
            <D.20648>:
            goto <D.20660>;
            <D.20642>:
            D.20643 = sig_adjusted->params[param_index];
            D.20644 = D.20643->type;
            if (D.20644 == 20) goto <D.20661>; else goto <D.20663>;
            <D.20663>:
            D.20643 = sig_adjusted->params[param_index];
            D.20644 = D.20643->type;
            if (D.20644 == 29) goto <D.20661>; else goto <D.20662>;
            <D.20661>:
            D.20633 = (long unsigned int) mspec_index;
            D.20634 = D.20633 * 8;
            D.20635 = mspecs + D.20634;
            D.20640 = *D.20635;
            D.20664 = D.20640->data.array_data.param_num;
            if (D.20664 != -1) goto <D.20665>; else goto <D.20666>;
            <D.20665>:
            D.20633 = (long unsigned int) mspec_index;
            D.20634 = D.20633 * 8;
            D.20635 = mspecs + D.20634;
            D.20640 = *D.20635;
            D.20664 = D.20640->data.array_data.param_num;
            D.20667 = D.20664;
            D.20668 = (unsigned short) D.20667;
            D.20669 = D.20668 + 1;
            D.20670 = (short int) D.20669;
            D.20640->data.array_data.param_num = D.20670;
            <D.20666>:
            <D.20662>:
            <D.20660>:
          }
          param_index = param_index + -1;
          <D.19726>:
          if (param_index > 0) goto <D.19725>; else goto <D.19727>;
          <D.19727>:
          D.20671 = mspecs + 8;
          *D.20671 = 0B;
          if (preserve_sig == 0) goto <D.20672>; else goto <D.20673>;
          <D.20672>:
          D.20674 = sig->ret;
          D.20675 = mono_type_is_void (D.20674);
          if (D.20675 == 0) goto <D.20676>; else goto <D.20677>;
          <D.20676>:
          D.20678 = *mspecs;
          if (D.20678 == 0B) goto <D.20679>; else goto <D.20680>;
          <D.20679>:
          D.20627 = sig_adjusted->param_count;
          D.20628 = (int) D.20627;
          D.20681 = D.20628 + -1;
          D.20682 = sig_adjusted->params[D.20681];
          D.20683 = D.20682->type;
          if (D.20683 == 28) goto <D.20684>; else goto <D.20685>;
          <D.20684>:
          D.20686 = monoeg_malloc0 (24);
          *mspecs = D.20686;
          D.20678 = *mspecs;
          D.20678->native = 27;
          goto <D.20687>;
          <D.20685>:
          D.20627 = sig_adjusted->param_count;
          D.20628 = (int) D.20627;
          D.20681 = D.20628 + -1;
          D.20682 = sig_adjusted->params[D.20681];
          D.20683 = D.20682->type;
          if (D.20683 == 14) goto <D.20688>; else goto <D.20689>;
          <D.20688>:
          D.20690 = monoeg_malloc0 (24);
          *mspecs = D.20690;
          D.20678 = *mspecs;
          D.20678->native = 19;
          goto <D.20691>;
          <D.20689>:
          D.20627 = sig_adjusted->param_count;
          D.20628 = (int) D.20627;
          D.20681 = D.20628 + -1;
          D.20682 = sig_adjusted->params[D.20681];
          D.20683 = D.20682->type;
          if (D.20683 == 18) goto <D.20692>; else goto <D.20693>;
          <D.20692>:
          D.20694 = monoeg_malloc0 (24);
          *mspecs = D.20694;
          D.20678 = *mspecs;
          D.20678->native = 28;
          goto <D.20695>;
          <D.20693>:
          D.20627 = sig_adjusted->param_count;
          D.20628 = (int) D.20627;
          D.20681 = D.20628 + -1;
          D.20682 = sig_adjusted->params[D.20681];
          D.20683 = D.20682->type;
          if (D.20683 == 2) goto <D.20696>; else goto <D.20697>;
          <D.20696>:
          D.20698 = monoeg_malloc0 (24);
          *mspecs = D.20698;
          D.20678 = *mspecs;
          D.20678->native = 37;
          <D.20697>:
          <D.20695>:
          <D.20691>:
          <D.20687>:
          <D.20680>:
          D.20627 = sig_adjusted->param_count;
          D.20699 = (long unsigned int) D.20627;
          D.20700 = D.20699 * 8;
          D.20701 = mspecs + D.20700;
          D.20678 = *mspecs;
          *D.20701 = D.20678;
          *mspecs = 0B;
          <D.20677>:
          <D.20673>:
          mb->skip_visibility = 1;
          cominterop_setup_marshal_context (&m, adjust_method);
          m.mb = mb;
          mono_marshal_emit_managed_wrapper (mb, sig_adjusted, mspecs, &m, adjust_method, 0);
          {
            int ret;

            ret = pthread_mutex_lock (&cominterop_mutex.mutex);
            if (ret != 0) goto <D.20702>; else goto <D.20703>;
            <D.20702>:
            monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
            <D.20703>:
            D.20704 = ret != 0;
            D.20705 = (long int) D.20704;
            D.20706 = __builtin_expect (D.20705, 0);
            if (D.20706 != 0) goto <D.20707>; else goto <D.20708>;
            <D.20707>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "cominterop.c", 2003, "ret == 0");
            <D.20708>:
          }
          D.20709 = m.csig;
          D.20709 = m.csig;
          D.20710 = D.20709->param_count;
          D.20711 = (int) D.20710;
          D.20712 = D.20711 + 16;
          wrapper_method = mono_mb_create_method (mb, D.20709, D.20712);
          {
            int ret;

            ret = pthread_mutex_unlock (&cominterop_mutex.mutex);
            if (ret != 0) goto <D.20713>; else goto <D.20714>;
            <D.20713>:
            monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
            <D.20714>:
            D.20715 = ret != 0;
            D.20716 = (long int) D.20715;
            D.20717 = __builtin_expect (D.20716, 0);
            if (D.20717 != 0) goto <D.20718>; else goto <D.20719>;
            <D.20718>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "cominterop.c", 2005, "ret == 0");
            <D.20719>:
          }
          vtable_index.53 = vtable_index;
          vtable_index = vtable_index.53 + -1;
          D.20721 = (long unsigned int) vtable_index.53;
          D.20722 = D.20721 * 8;
          D.20723 = vtable + D.20722;
          D.20724 = mono_compile_method (wrapper_method);
          *D.20723 = D.20724;
          D.20627 = sig_adjusted->param_count;
          param_index = (int) D.20627;
          goto <D.19731>;
          <D.19730>:
          D.20636 = (long unsigned int) param_index;
          D.20637 = D.20636 * 8;
          D.20638 = mspecs + D.20637;
          D.20639 = *D.20638;
          if (D.20639 != 0B) goto <D.20725>; else goto <D.20726>;
          <D.20725>:
          D.20636 = (long unsigned int) param_index;
          D.20637 = D.20636 * 8;
          D.20638 = mspecs + D.20637;
          D.20639 = *D.20638;
          mono_metadata_free_marshal_spec (D.20639);
          <D.20726>:
          param_index = param_index + -1;
          <D.19731>:
          if (param_index >= 0) goto <D.19730>; else goto <D.19732>;
          <D.19732>:
          monoeg_g_free (mspecs);
        }
        i = i + -1;
        <D.19734>:
        if (i >= 0) goto <D.19733>; else goto <D.19735>;
        <D.19735>:
        ccw_entry = monoeg_malloc0 (16);
        ccw_entry->ccw = ccw;
        ccw_entry->vtable = vtable;
        D.20607 = ccw->vtable_hash;
        monoeg_g_hash_table_insert_replace (D.20607, itf, ccw_entry, 0);
        ccw_interface_hash.46 = ccw_interface_hash;
        monoeg_g_hash_table_insert_replace (ccw_interface_hash.46, ccw_entry, ccw, 0);
      }
      <D.20609>:
      D.20506 = ccw_entry;
      return D.20506;
    }
  finally
    {
      m = {CLOBBER};
    }
}


cominterop_ccw_invoke (struct MonoCCWInterface * ccwe, guint32 dispIdMember, void * riid, guint32 lcid, guint16 wFlags, void * pDispParams, void * pVarResult, void * pExcepInfo, guint32 * puArgErr)
{
  int D.20729;

  D.20729 = -2147467263;
  return D.20729;
}


cominterop_ccw_get_ids_of_names (struct MonoCCWInterface * ccwe, void * riid, gunichar2 * * rgszNames, guint32 cNames, guint32 lcid, gint32 * rgDispId)
{
  unsigned int D.20731;
  _Bool D.20732;
  long int D.20733;
  long int D.20734;
  struct MonoVTable * D.20737;
  struct MonoDomain * D.20738;
  struct MonoDomain * D.20741;
  long unsigned int D.20742;
  long unsigned int D.20743;
  gunichar2 * * D.20744;
  gunichar2 * D.20745;
  long unsigned int D.20748;
  gint32 * D.20749;
  unsigned int D.20750;
  int D.20751;
  unsigned int i.54;
  int D.20754;
  int i;
  int ret;
  struct MonoMethod * method;
  gchar * methodname;
  struct MonoClass * klass;
  struct MonoCCW * ccw;
  struct MonoObject * object;

  ret = 0;
  klass = 0B;
  ccw = ccwe->ccw;
  D.20731 = ccw->gc_handle;
  object = mono_gchandle_get_target (D.20731);
  D.20732 = object == 0B;
  D.20733 = (long int) D.20732;
  D.20734 = __builtin_expect (D.20733, 0);
  if (D.20734 != 0) goto <D.20735>; else goto <D.20736>;
  <D.20735>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "cominterop.c", 2418, "object");
  <D.20736>:
  D.20737 = object->vtable;
  klass = D.20737->klass;
  D.20738 = mono_domain_get ();
  if (D.20738 == 0B) goto <D.20739>; else goto <D.20740>;
  <D.20739>:
  D.20741 = mono_get_root_domain ();
  mono_thread_attach (D.20741);
  <D.20740>:
  i = 0;
  goto <D.19853>;
  <D.19852>:
  D.20742 = (long unsigned int) i;
  D.20743 = D.20742 * 8;
  D.20744 = rgszNames + D.20743;
  D.20745 = *D.20744;
  methodname = mono_unicode_to_external (D.20745);
  method = mono_class_get_method_from_name (klass, methodname, -1);
  if (method != 0B) goto <D.20746>; else goto <D.20747>;
  <D.20746>:
  D.20742 = (long unsigned int) i;
  D.20748 = D.20742 * 4;
  D.20749 = rgDispId + D.20748;
  D.20750 = method->token;
  D.20751 = (int) D.20750;
  *D.20749 = D.20751;
  goto <D.20752>;
  <D.20747>:
  D.20742 = (long unsigned int) i;
  D.20748 = D.20742 * 4;
  D.20749 = rgDispId + D.20748;
  *D.20749 = -1;
  ret = -2147352570;
  <D.20752>:
  i = i + 1;
  <D.19853>:
  i.54 = (unsigned int) i;
  if (i.54 < cNames) goto <D.19852>; else goto <D.19854>;
  <D.19854>:
  D.20754 = ret;
  return D.20754;
}


cominterop_ccw_get_type_info (struct MonoCCWInterface * ccwe, guint32 iTInfo, guint32 lcid, void * * ppTInfo)
{
  int D.20756;

  D.20756 = -2147467263;
  return D.20756;
}


cominterop_ccw_get_type_info_count (struct MonoCCWInterface * ccwe, guint32 * pctinfo)
{
  int D.20760;

  if (pctinfo == 0B) goto <D.20758>; else goto <D.20759>;
  <D.20758>:
  D.20760 = -2147024809;
  return D.20760;
  <D.20759>:
  *pctinfo = 1;
  D.20760 = 0;
  return D.20760;
}


cominterop_ccw_release (struct MonoCCWInterface * ccwe)
{
  _Bool D.20762;
  long int D.20763;
  long int D.20764;
  unsigned int D.20767;
  _Bool D.20768;
  long int D.20769;
  long int D.20770;
  guint32 * D.20773;
  _Bool D.20776;
  long int D.20777;
  long int D.20778;
  struct MonoObject * D.20781;
  unsigned int D.20782;
  int D.20783;
  gint32 ref_count;
  struct MonoCCW * ccw;

  ref_count = 0;
  ccw = ccwe->ccw;
  D.20762 = ccw == 0B;
  D.20763 = (long int) D.20762;
  D.20764 = __builtin_expect (D.20763, 0);
  if (D.20764 != 0) goto <D.20765>; else goto <D.20766>;
  <D.20765>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "cominterop.c", 2272, "ccw");
  <D.20766>:
  D.20767 = ccw->ref_count;
  D.20768 = D.20767 == 0;
  D.20769 = (long int) D.20768;
  D.20770 = __builtin_expect (D.20769, 0);
  if (D.20770 != 0) goto <D.20771>; else goto <D.20772>;
  <D.20771>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "cominterop.c", 2273, "ccw->ref_count > 0");
  <D.20772>:
  D.20773 = &ccw->ref_count;
  ref_count = InterlockedDecrement (D.20773);
  if (ref_count == 0) goto <D.20774>; else goto <D.20775>;
  <D.20774>:
  {
    guint32 oldhandle;

    oldhandle = ccw->gc_handle;
    D.20776 = oldhandle == 0;
    D.20777 = (long int) D.20776;
    D.20778 = __builtin_expect (D.20777, 0);
    if (D.20778 != 0) goto <D.20779>; else goto <D.20780>;
    <D.20779>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "cominterop.c", 2278, "oldhandle");
    <D.20780>:
    D.20781 = mono_gchandle_get_target (oldhandle);
    D.20782 = mono_gchandle_new_weakref (D.20781, 0);
    ccw->gc_handle = D.20782;
    mono_gchandle_free (oldhandle);
  }
  <D.20775>:
  D.20783 = ref_count;
  return D.20783;
}


InterlockedDecrement (volatile gint32 * val)
{
  gint32 D.20785;
  unsigned int D.20786;

  D.20786 = __sync_sub_and_fetch_4 (val, 1);
  D.20785 = (gint32) D.20786;
  return D.20785;
}


cominterop_ccw_addref (struct MonoCCWInterface * ccwe)
{
  _Bool D.20788;
  long int D.20789;
  long int D.20790;
  unsigned int D.20793;
  _Bool D.20794;
  long int D.20795;
  long int D.20796;
  guint32 * D.20801;
  _Bool D.20804;
  long int D.20805;
  long int D.20806;
  struct MonoObject * D.20809;
  unsigned int D.20810;
  int D.20811;
  gint32 ref_count;
  struct MonoCCW * ccw;

  ref_count = 0;
  ccw = ccwe->ccw;
  D.20788 = ccw == 0B;
  D.20789 = (long int) D.20788;
  D.20790 = __builtin_expect (D.20789, 0);
  if (D.20790 != 0) goto <D.20791>; else goto <D.20792>;
  <D.20791>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "cominterop.c", 2253, "ccw");
  <D.20792>:
  D.20793 = ccw->gc_handle;
  D.20794 = D.20793 == 0;
  D.20795 = (long int) D.20794;
  D.20796 = __builtin_expect (D.20795, 0);
  if (D.20796 != 0) goto <D.20797>; else goto <D.20798>;
  <D.20797>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "cominterop.c", 2254, "ccw->gc_handle");
  <D.20798>:
  if (0 != 0) goto <D.20799>; else goto <D.20800>;
  <D.20799>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "cominterop.c", 2255, "ccw->ref_count >= 0");
  <D.20800>:
  D.20801 = &ccw->ref_count;
  ref_count = InterlockedIncrement (D.20801);
  if (ref_count == 1) goto <D.20802>; else goto <D.20803>;
  <D.20802>:
  {
    guint32 oldhandle;

    oldhandle = ccw->gc_handle;
    D.20804 = oldhandle == 0;
    D.20805 = (long int) D.20804;
    D.20806 = __builtin_expect (D.20805, 0);
    if (D.20806 != 0) goto <D.20807>; else goto <D.20808>;
    <D.20807>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "cominterop.c", 2259, "oldhandle");
    <D.20808>:
    D.20809 = mono_gchandle_get_target (oldhandle);
    D.20810 = mono_gchandle_new (D.20809, 0);
    ccw->gc_handle = D.20810;
    mono_gchandle_free (oldhandle);
  }
  <D.20803>:
  D.20811 = ref_count;
  return D.20811;
}


InterlockedIncrement (volatile gint32 * val)
{
  gint32 D.20813;
  unsigned int D.20814;

  D.20814 = __sync_add_and_fetch_4 (val, 1);
  D.20813 = (gint32) D.20814;
  return D.20813;
}


cominterop_ccw_queryinterface (struct MonoCCWInterface * ccwe, guint8 * riid, void * * ppv)
{
  unsigned int D.20816;
  _Bool D.20817;
  long int D.20818;
  long int D.20819;
  struct MonoVTable * D.20822;
  struct MonoDomain * D.20825;
  struct MonoDomain * D.20828;
  struct MonoClass * D.20829;
  int D.20830;
  struct MonoClass * D.20833;
  void * D.20834;
  void * D.20835;
  int D.20836;
  struct MonoClass * D.20837;
  int D.20838;
  int D.20841;
  struct MonoClass * D.20844;
  void * D.20845;
  int D.20846;
  _Bool D.20847;
  long int D.20848;
  long int D.20849;
  void * * D.20854;
  long unsigned int D.20855;
  long unsigned int D.20856;
  void * * D.20857;
  int D.20858;
  unsigned int i.55;
  unsigned int D.20862;
  struct MonoClass * D.20865;
  void * D.20868;
  struct MonoError error;
  struct GPtrArray * ifaces;
  struct MonoClass * itf;
  int i;
  struct MonoCCW * ccw;
  struct MonoClass * klass;
  struct MonoClass * klass_iter;
  struct MonoObject * object;

  try
    {
      itf = 0B;
      ccw = ccwe->ccw;
      klass = 0B;
      klass_iter = 0B;
      D.20816 = ccw->gc_handle;
      object = mono_gchandle_get_target (D.20816);
      D.20817 = object == 0B;
      D.20818 = (long int) D.20817;
      D.20819 = __builtin_expect (D.20818, 0);
      if (D.20819 != 0) goto <D.20820>; else goto <D.20821>;
      <D.20820>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "cominterop.c", 2324, "object");
      <D.20821>:
      D.20822 = object->vtable;
      klass = D.20822->klass;
      if (ppv != 0B) goto <D.20823>; else goto <D.20824>;
      <D.20823>:
      *ppv = 0B;
      <D.20824>:
      D.20825 = mono_domain_get ();
      if (D.20825 == 0B) goto <D.20826>; else goto <D.20827>;
      <D.20826>:
      D.20828 = mono_get_root_domain ();
      mono_thread_attach (D.20828);
      <D.20827>:
      D.20829 = mono_class_get_iunknown_class ();
      D.20830 = cominterop_class_guid_equal (riid, D.20829);
      if (D.20830 != 0) goto <D.20831>; else goto <D.20832>;
      <D.20831>:
      D.20833 = mono_class_get_iunknown_class ();
      D.20834 = cominterop_get_ccw (object, D.20833);
      *ppv = D.20834;
      D.20835 = *ppv;
      cominterop_ccw_addref (D.20835);
      D.20836 = 0;
      return D.20836;
      <D.20832>:
      D.20837 = mono_class_get_idispatch_class ();
      D.20838 = cominterop_class_guid_equal (riid, D.20837);
      if (D.20838 != 0) goto <D.20839>; else goto <D.20840>;
      <D.20839>:
      D.20841 = cominterop_can_support_dispatch (klass);
      if (D.20841 == 0) goto <D.20842>; else goto <D.20843>;
      <D.20842>:
      D.20836 = -2147467262;
      return D.20836;
      <D.20843>:
      D.20844 = mono_class_get_idispatch_class ();
      D.20845 = cominterop_get_ccw (object, D.20844);
      *ppv = D.20845;
      D.20835 = *ppv;
      cominterop_ccw_addref (D.20835);
      D.20836 = 0;
      return D.20836;
      <D.20840>:
      klass_iter = klass;
      goto <D.19826>;
      <D.19825>:
      ifaces = mono_class_get_implemented_interfaces (klass_iter, &error);
      D.20846 = mono_error_ok (&error);
      D.20847 = D.20846 == 0;
      D.20848 = (long int) D.20847;
      D.20849 = __builtin_expect (D.20848, 0);
      if (D.20849 != 0) goto <D.20850>; else goto <D.20851>;
      <D.20850>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "cominterop.c", 2361, "mono_error_ok (&error)");
      <D.20851>:
      if (ifaces != 0B) goto <D.20852>; else goto <D.20853>;
      <D.20852>:
      i = 0;
      goto <D.19823>;
      <D.19822>:
      {
        struct MonoClass * ic;

        ic = 0B;
        D.20854 = ifaces->pdata;
        D.20855 = (long unsigned int) i;
        D.20856 = D.20855 * 8;
        D.20857 = D.20854 + D.20856;
        ic = *D.20857;
        D.20858 = cominterop_class_guid_equal (riid, ic);
        if (D.20858 != 0) goto <D.20859>; else goto <D.20860>;
        <D.20859>:
        itf = ic;
        goto <D.19821>;
        <D.20860>:
      }
      i = i + 1;
      <D.19823>:
      i.55 = (unsigned int) i;
      D.20862 = ifaces->len;
      if (i.55 < D.20862) goto <D.19822>; else goto <D.19821>;
      <D.19821>:
      monoeg_g_ptr_array_free (ifaces, 1);
      <D.20853>:
      if (itf != 0B) goto <D.19824>; else goto <D.20863>;
      <D.20863>:
      klass_iter = klass_iter->parent;
      <D.19826>:
      if (klass_iter != 0B) goto <D.20864>; else goto <D.19824>;
      <D.20864>:
      D.20865 = mono_defaults.object_class;
      if (D.20865 != klass_iter) goto <D.19825>; else goto <D.19824>;
      <D.19824>:
      if (itf != 0B) goto <D.20866>; else goto <D.20867>;
      <D.20866>:
      D.20868 = cominterop_get_ccw (object, itf);
      *ppv = D.20868;
      D.20835 = *ppv;
      cominterop_ccw_addref (D.20835);
      D.20836 = 0;
      return D.20836;
      <D.20867>:
      D.20836 = -2147467262;
      return D.20836;
    }
  finally
    {
      error = {CLOBBER};
    }
}


cominterop_can_support_dispatch (struct MonoClass * klass)
{
  unsigned int D.20871;
  unsigned int D.20872;
  gboolean D.20875;
  int D.20876;

  D.20871 = klass->flags;
  D.20872 = D.20871 & 1;
  if (D.20872 == 0) goto <D.20873>; else goto <D.20874>;
  <D.20873>:
  D.20875 = 0;
  return D.20875;
  <D.20874>:
  D.20876 = cominterop_com_visible (klass);
  if (D.20876 == 0) goto <D.20877>; else goto <D.20878>;
  <D.20877>:
  D.20875 = 0;
  return D.20875;
  <D.20878>:
  D.20875 = 1;
  return D.20875;
}


cominterop_com_visible (struct MonoClass * klass)
{
  struct MonoClass * ComVisibleAttribute.56;
  struct MonoImage * D.20883;
  struct MonoClass * ComVisibleAttribute.57;
  int D.20889;
  gboolean D.20894;
  int D.20895;
  _Bool D.20896;
  long int D.20897;
  long int D.20898;
  void * * D.20903;
  long unsigned int D.20904;
  long unsigned int D.20905;
  void * * D.20906;
  unsigned int D.20907;
  unsigned int D.20908;
  unsigned int i.58;
  unsigned int D.20912;
  static struct MonoClass * ComVisibleAttribute = 0B;
  struct MonoError error;
  struct MonoCustomAttrInfo * cinfo;
  struct GPtrArray * ifaces;
  MonoBoolean visible;

  try
    {
      visible = 1;
      ComVisibleAttribute.56 = ComVisibleAttribute;
      if (ComVisibleAttribute.56 == 0B) goto <D.20881>; else goto <D.20882>;
      <D.20881>:
      D.20883 = mono_defaults.corlib;
      ComVisibleAttribute.57 = mono_class_from_name (D.20883, "System.Runtime.InteropServices", "ComVisibleAttribute");
      ComVisibleAttribute = ComVisibleAttribute.57;
      <D.20882>:
      cinfo = mono_custom_attrs_from_class (klass);
      if (cinfo != 0B) goto <D.20885>; else goto <D.20886>;
      <D.20885>:
      {
        struct MonoReflectionComVisibleAttribute * attr;

        ComVisibleAttribute.56 = ComVisibleAttribute;
        attr = mono_custom_attrs_get_attr (cinfo, ComVisibleAttribute.56);
        if (attr != 0B) goto <D.20887>; else goto <D.20888>;
        <D.20887>:
        visible = attr->visible;
        <D.20888>:
        D.20889 = cinfo->cached;
        if (D.20889 == 0) goto <D.20890>; else goto <D.20891>;
        <D.20890>:
        mono_custom_attrs_free (cinfo);
        <D.20891>:
        if (visible != 0) goto <D.20892>; else goto <D.20893>;
        <D.20892>:
        D.20894 = 1;
        return D.20894;
        <D.20893>:
      }
      <D.20886>:
      ifaces = mono_class_get_implemented_interfaces (klass, &error);
      D.20895 = mono_error_ok (&error);
      D.20896 = D.20895 == 0;
      D.20897 = (long int) D.20896;
      D.20898 = __builtin_expect (D.20897, 0);
      if (D.20898 != 0) goto <D.20899>; else goto <D.20900>;
      <D.20899>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "cominterop.c", 434, "mono_error_ok (&error)");
      <D.20900>:
      if (ifaces != 0B) goto <D.20901>; else goto <D.20902>;
      <D.20901>:
      {
        int i;

        i = 0;
        goto <D.19364>;
        <D.19363>:
        {
          struct MonoClass * ic;

          ic = 0B;
          D.20903 = ifaces->pdata;
          D.20904 = (long unsigned int) i;
          D.20905 = D.20904 * 8;
          D.20906 = D.20903 + D.20905;
          ic = *D.20906;
          D.20907 = ic->flags;
          D.20908 = D.20907 & 4096;
          if (D.20908 != 0) goto <D.20909>; else goto <D.20910>;
          <D.20909>:
          visible = 1;
          <D.20910>:
        }
        i = i + 1;
        <D.19364>:
        i.58 = (unsigned int) i;
        D.20912 = ifaces->len;
        if (i.58 < D.20912) goto <D.19363>; else goto <D.19365>;
        <D.19365>:
        monoeg_g_ptr_array_free (ifaces, 1);
      }
      <D.20902>:
      D.20894 = (gboolean) visible;
      return D.20894;
    }
  finally
    {
      error = {CLOBBER};
    }
}


cominterop_class_guid_equal (guint8 * guid, struct MonoClass * klass)
{
  int D.20915;
  gboolean D.20918;
  int D.20919;
  _Bool D.20920;
  guint8 klass_guid[16];

  try
    {
      D.20915 = cominterop_class_guid (klass, &klass_guid);
      if (D.20915 != 0) goto <D.20916>; else goto <D.20917>;
      <D.20916>:
      D.20919 = memcmp (guid, &klass_guid, 16);
      D.20920 = D.20919 == 0;
      D.20918 = (gboolean) D.20920;
      return D.20918;
      <D.20917>:
      D.20918 = 0;
      return D.20918;
    }
  finally
    {
      klass_guid = {CLOBBER};
    }
}


cominterop_get_com_slot_begin (struct MonoClass * klass)
{
  struct MonoClass * interface_type_attribute.59;
  struct MonoImage * D.20926;
  struct MonoClass * interface_type_attribute.60;
  int D.20930;
  unsigned int D.20935;
  int D.20937;
  static struct MonoClass * interface_type_attribute = 0B;
  struct MonoCustomAttrInfo * cinfo;
  struct MonoInterfaceTypeAttribute * itf_attr;

  cinfo = 0B;
  itf_attr = 0B;
  interface_type_attribute.59 = interface_type_attribute;
  if (interface_type_attribute.59 == 0B) goto <D.20924>; else goto <D.20925>;
  <D.20924>:
  D.20926 = mono_defaults.corlib;
  interface_type_attribute.60 = mono_class_from_name (D.20926, "System.Runtime.InteropServices", "InterfaceTypeAttribute");
  interface_type_attribute = interface_type_attribute.60;
  <D.20925>:
  cinfo = mono_custom_attrs_from_class (klass);
  if (cinfo != 0B) goto <D.20928>; else goto <D.20929>;
  <D.20928>:
  interface_type_attribute.59 = interface_type_attribute;
  itf_attr = mono_custom_attrs_get_attr (cinfo, interface_type_attribute.59);
  D.20930 = cinfo->cached;
  if (D.20930 == 0) goto <D.20931>; else goto <D.20932>;
  <D.20931>:
  mono_custom_attrs_free (cinfo);
  <D.20932>:
  <D.20929>:
  if (itf_attr != 0B) goto <D.20934>; else goto <D.20933>;
  <D.20934>:
  D.20935 = itf_attr->intType;
  if (D.20935 == 1) goto <D.20936>; else goto <D.20933>;
  <D.20936>:
  D.20937 = 3;
  return D.20937;
  <D.20933>:
  D.20937 = 7;
  return D.20937;
}


memcpy (void * restrict __dest, const void * restrict __src, size_t __len)
{
  void * D.20939;
  long unsigned int D.20940;

  D.20940 = __builtin_object_size (__dest, 0);
  D.20939 = __builtin___memcpy_chk (__dest, __src, __len, D.20940);
  return D.20939;
}


cominterop_get_managed_wrapper_adjusted (struct MonoMethod * method)
{
  short unsigned int D.20942;
  int D.20943;
  struct MonoMethod * get_hr_for_exception.61;
  struct MonoClass * D.20947;
  struct MonoMethod * get_hr_for_exception.62;
  struct MonoClass * D.20949;
  const char * D.20950;
  short unsigned int D.20951;
  int D.20952;
  int D.20953;
  long unsigned int D.20954;
  long unsigned int D.20955;
  short unsigned int D.20956;
  sizetype D.20957;
  sizetype D.20958;
  sizetype D.20959;
  struct MonoMarshalSpec * * D.20960;
  long unsigned int D.20961;
  long unsigned int D.20962;
  struct MonoMarshalSpec * * D.20963;
  struct MonoMarshalSpec * D.20964;
  struct MonoMarshalSpec * * D.20965;
  struct MonoType * D.20968;
  int D.20969;
  long unsigned int D.20972;
  long unsigned int D.20973;
  struct MonoMarshalSpec * * D.20974;
  struct MonoMarshalSpec * D.20975;
  struct MonoClass * D.20978;
  struct MonoType * D.20979;
  int D.20981;
  int D.20984;
  unsigned int D.20985;
  int D.20988;
  int D.20991;
  unsigned int D.20992;
  int D.20993;
  unsigned int D.20994;
  int D.20995;
  int D.20996;
  long unsigned int D.21001;
  long unsigned int D.21002;
  unsigned int D.21006;
  unsigned char D.21007;
  unsigned int hr.63;
  unsigned int D.21010;
  int D.21011;
  unsigned int D.21012;
  unsigned int D.21013;
  unsigned int D.21014;
  struct MonoClass * D.21015;
  int D.21016;
  unsigned int D.21017;
  long unsigned int D.21023;
  long unsigned int D.21024;
  unsigned char D.21026;
  unsigned char D.21027;
  int D.21028;
  unsigned int D.21029;
  unsigned int D.21030;
  unsigned int D.21031;
  unsigned int pos_leave.64;
  int D.21036;
  _Bool D.21039;
  long int D.21040;
  long int D.21041;
  int D.21044;
  _Bool D.21047;
  long int D.21048;
  long int D.21049;
  struct MonoMethod * D.21054;
  static struct MonoMethod * get_hr_for_exception = 0B;
  struct MonoMethod * res;
  struct MonoMethodBuilder * mb;
  struct MonoMarshalSpec * * mspecs;
  struct MonoMethodSignature * sig;
  struct MonoMethodSignature * sig_native;
  struct MonoExceptionClause * main_clause;
  int pos_leave;
  int hr;
  int i;
  gboolean preserve_sig;

  res = 0B;
  main_clause = 0B;
  hr = 0;
  D.20942 = method->iflags;
  D.20943 = (int) D.20942;
  preserve_sig = D.20943 & 128;
  get_hr_for_exception.61 = get_hr_for_exception;
  if (get_hr_for_exception.61 == 0B) goto <D.20945>; else goto <D.20946>;
  <D.20945>:
  D.20947 = mono_defaults.marshal_class;
  get_hr_for_exception.62 = mono_class_get_method_from_name (D.20947, "GetHRForException", -1);
  get_hr_for_exception = get_hr_for_exception.62;
  <D.20946>:
  sig = mono_method_signature (method);
  D.20949 = method->klass;
  D.20950 = method->name;
  mb = mono_mb_new (D.20949, D.20950, 27);
  sig_native = cominterop_method_signature (method);
  D.20951 = sig_native->param_count;
  D.20952 = (int) D.20951;
  D.20953 = D.20952 + 1;
  D.20954 = (long unsigned int) D.20953;
  D.20955 = D.20954 * 8;
  mspecs = monoeg_malloc0 (D.20955);
  mono_method_get_marshal_info (method, mspecs);
  D.20956 = sig->param_count;
  i = (int) D.20956;
  goto <D.19769>;
  <D.19768>:
  D.20957 = (sizetype) i;
  D.20958 = D.20957 + 1;
  D.20959 = D.20958 * 8;
  D.20960 = mspecs + D.20959;
  D.20961 = (long unsigned int) i;
  D.20962 = D.20961 * 8;
  D.20963 = mspecs + D.20962;
  D.20964 = *D.20963;
  *D.20960 = D.20964;
  i = i + -1;
  <D.19769>:
  if (i > 0) goto <D.19768>; else goto <D.19770>;
  <D.19770>:
  D.20965 = mspecs + 8;
  *D.20965 = 0B;
  if (preserve_sig == 0) goto <D.20966>; else goto <D.20967>;
  <D.20966>:
  D.20968 = sig->ret;
  D.20969 = mono_type_is_void (D.20968);
  if (D.20969 == 0) goto <D.20970>; else goto <D.20971>;
  <D.20970>:
  D.20951 = sig_native->param_count;
  D.20972 = (long unsigned int) D.20951;
  D.20973 = D.20972 * 8;
  D.20974 = mspecs + D.20973;
  D.20975 = *mspecs;
  *D.20974 = D.20975;
  <D.20971>:
  <D.20967>:
  *mspecs = 0B;
  if (preserve_sig == 0) goto <D.20976>; else goto <D.20977>;
  <D.20976>:
  D.20978 = mono_defaults.int32_class;
  D.20979 = &D.20978->byval_arg;
  hr = mono_mb_add_local (mb, D.20979);
  goto <D.20980>;
  <D.20977>:
  D.20968 = sig->ret;
  D.20981 = mono_type_is_void (D.20968);
  if (D.20981 == 0) goto <D.20982>; else goto <D.20983>;
  <D.20982>:
  D.20968 = sig->ret;
  hr = mono_mb_add_local (mb, D.20968);
  <D.20983>:
  <D.20980>:
  main_clause = monoeg_malloc0 (32);
  D.20984 = mono_mb_get_label (mb);
  D.20985 = (unsigned int) D.20984;
  main_clause->try_offset = D.20985;
  if (preserve_sig == 0) goto <D.20986>; else goto <D.20987>;
  <D.20986>:
  D.20968 = sig->ret;
  D.20988 = mono_type_is_void (D.20968);
  if (D.20988 == 0) goto <D.20989>; else goto <D.20990>;
  <D.20989>:
  D.20951 = sig_native->param_count;
  D.20952 = (int) D.20951;
  D.20991 = D.20952 + -1;
  D.20992 = (unsigned int) D.20991;
  mono_mb_emit_ldarg (mb, D.20992);
  <D.20990>:
  <D.20987>:
  mono_mb_emit_ldarg (mb, 0);
  mono_mb_emit_icon (mb, 0);
  mono_mb_emit_icall (mb, cominterop_get_ccw_object);
  i = 0;
  goto <D.19772>;
  <D.19771>:
  D.20993 = i + 1;
  D.20994 = (unsigned int) D.20993;
  mono_mb_emit_ldarg (mb, D.20994);
  i = i + 1;
  <D.19772>:
  D.20956 = sig->param_count;
  D.20995 = (int) D.20956;
  if (D.20995 > i) goto <D.19771>; else goto <D.19773>;
  <D.19773>:
  mono_mb_emit_managed_call (mb, method, 0B);
  D.20968 = sig->ret;
  D.20996 = mono_type_is_void (D.20968);
  if (D.20996 == 0) goto <D.20997>; else goto <D.20998>;
  <D.20997>:
  if (preserve_sig == 0) goto <D.20999>; else goto <D.21000>;
  <D.20999>:
  {
    struct MonoClass * rclass;

    D.20968 = sig->ret;
    rclass = mono_class_from_mono_type (D.20968);
    D.21001 = BIT_FIELD_REF <*rclass, 64, 256>;
    D.21002 = D.21001 & 8;
    if (D.21002 != 0) goto <D.21003>; else goto <D.21004>;
    <D.21003>:
    mono_mb_emit_op (mb, 129, rclass);
    goto <D.21005>;
    <D.21004>:
    D.20968 = sig->ret;
    D.21006 = mono_type_to_stind (D.20968);
    D.21007 = (unsigned char) D.21006;
    mono_mb_emit_byte (mb, D.21007);
    <D.21005>:
  }
  goto <D.21008>;
  <D.21000>:
  hr.63 = (unsigned int) hr;
  mono_mb_emit_stloc (mb, hr.63);
  <D.21008>:
  <D.20998>:
  D.21010 = mono_mb_emit_branch (mb, 221);
  pos_leave = (int) D.21010;
  main_clause->flags = 0;
  D.21011 = mono_mb_get_pos (mb);
  D.21012 = (unsigned int) D.21011;
  D.21013 = main_clause->try_offset;
  D.21014 = D.21012 - D.21013;
  main_clause->try_len = D.21014;
  D.21015 = mono_defaults.object_class;
  main_clause->data.catch_class = D.21015;
  D.21016 = mono_mb_get_label (mb);
  D.21017 = (unsigned int) D.21016;
  main_clause->handler_offset = D.21017;
  if (preserve_sig == 0) goto <D.21018>; else goto <D.21021>;
  <D.21021>:
  D.20968 = sig->ret;
  if (D.20968 != 0B) goto <D.21022>; else goto <D.21019>;
  <D.21022>:
  D.20968 = sig->ret;
  D.21023 = BIT_FIELD_REF <*D.20968, 64, 64>;
  D.21024 = D.21023 & 1073741824;
  if (D.21024 == 0) goto <D.21025>; else goto <D.21019>;
  <D.21025>:
  D.20968 = sig->ret;
  D.21026 = D.20968->type;
  D.21027 = D.21026 + 248;
  if (D.21027 <= 1) goto <D.21018>; else goto <D.21019>;
  <D.21018>:
  get_hr_for_exception.61 = get_hr_for_exception;
  mono_mb_emit_managed_call (mb, get_hr_for_exception.61, 0B);
  hr.63 = (unsigned int) hr;
  mono_mb_emit_stloc (mb, hr.63);
  goto <D.21020>;
  <D.21019>:
  mono_mb_emit_byte (mb, 38);
  <D.21020>:
  mono_mb_emit_branch (mb, 221);
  D.21028 = mono_mb_get_pos (mb);
  D.21029 = (unsigned int) D.21028;
  D.21030 = main_clause->handler_offset;
  D.21031 = D.21029 - D.21030;
  main_clause->handler_len = D.21031;
  mono_mb_set_clauses (mb, 1, main_clause);
  pos_leave.64 = (unsigned int) pos_leave;
  mono_mb_patch_branch (mb, pos_leave.64);
  if (preserve_sig == 0) goto <D.21033>; else goto <D.21035>;
  <D.21035>:
  D.20968 = sig->ret;
  D.21036 = mono_type_is_void (D.20968);
  if (D.21036 == 0) goto <D.21033>; else goto <D.21034>;
  <D.21033>:
  hr.63 = (unsigned int) hr;
  mono_mb_emit_ldloc (mb, hr.63);
  <D.21034>:
  mono_mb_emit_byte (mb, 42);
  {
    int ret;

    ret = pthread_mutex_lock (&cominterop_mutex.mutex);
    if (ret != 0) goto <D.21037>; else goto <D.21038>;
    <D.21037>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.21038>:
    D.21039 = ret != 0;
    D.21040 = (long int) D.21039;
    D.21041 = __builtin_expect (D.21040, 0);
    if (D.21041 != 0) goto <D.21042>; else goto <D.21043>;
    <D.21042>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "cominterop.c", 2209, "ret == 0");
    <D.21043>:
  }
  D.20951 = sig_native->param_count;
  D.20952 = (int) D.20951;
  D.21044 = D.20952 + 16;
  res = mono_mb_create_method (mb, sig_native, D.21044);
  {
    int ret;

    ret = pthread_mutex_unlock (&cominterop_mutex.mutex);
    if (ret != 0) goto <D.21045>; else goto <D.21046>;
    <D.21045>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.21046>:
    D.21047 = ret != 0;
    D.21048 = (long int) D.21047;
    D.21049 = __builtin_expect (D.21048, 0);
    if (D.21049 != 0) goto <D.21050>; else goto <D.21051>;
    <D.21050>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "cominterop.c", 2211, "ret == 0");
    <D.21051>:
  }
  mono_mb_free (mb);
  D.20951 = sig_native->param_count;
  i = (int) D.20951;
  goto <D.19778>;
  <D.19777>:
  D.20961 = (long unsigned int) i;
  D.20962 = D.20961 * 8;
  D.20963 = mspecs + D.20962;
  D.20964 = *D.20963;
  if (D.20964 != 0B) goto <D.21052>; else goto <D.21053>;
  <D.21052>:
  D.20961 = (long unsigned int) i;
  D.20962 = D.20961 * 8;
  D.20963 = mspecs + D.20962;
  D.20964 = *D.20963;
  mono_metadata_free_marshal_spec (D.20964);
  <D.21053>:
  i = i + -1;
  <D.19778>:
  if (i >= 0) goto <D.19777>; else goto <D.19779>;
  <D.19779>:
  monoeg_g_free (mspecs);
  D.21054 = res;
  return D.21054;
}


cominterop_method_signature (struct MonoMethod * method)
{
  struct MonoClass * D.21056;
  short unsigned int D.21057;
  int D.21058;
  short unsigned int D.21059;
  int D.21060;
  struct MonoType * D.21063;
  int D.21064;
  unsigned int param_count.65;
  long unsigned int D.21068;
  long unsigned int D.21069;
  unsigned int D.21070;
  unsigned int D.21071;
  long unsigned int D.21072;
  int D.21073;
  struct MonoType * D.21074;
  struct MonoClass * D.21075;
  struct MonoType * D.21076;
  int D.21080;
  int D.21083;
  struct MonoType * D.21084;
  struct MonoType * D.21085;
  struct MonoClass * D.21086;
  struct MonoType * D.21087;
  short unsigned int D.21088;
  struct MonoMethodSignature * D.21089;
  struct MonoMethodSignature * res;
  struct MonoImage * image;
  struct MonoMethodSignature * sig;
  gboolean preserve_sig;
  int sigsize;
  int i;
  int param_count;

  D.21056 = method->klass;
  image = D.21056->image;
  sig = mono_method_signature (method);
  D.21057 = method->iflags;
  D.21058 = (int) D.21057;
  preserve_sig = D.21058 & 128;
  D.21059 = sig->param_count;
  D.21060 = (int) D.21059;
  param_count = D.21060 + 1;
  if (preserve_sig == 0) goto <D.21061>; else goto <D.21062>;
  <D.21061>:
  D.21063 = sig->ret;
  D.21064 = mono_type_is_void (D.21063);
  if (D.21064 == 0) goto <D.21065>; else goto <D.21066>;
  <D.21065>:
  param_count = param_count + 1;
  <D.21066>:
  <D.21062>:
  param_count.65 = (unsigned int) param_count;
  res = mono_metadata_signature_alloc (image, param_count.65);
  D.21059 = sig->param_count;
  D.21068 = (long unsigned int) D.21059;
  D.21069 = D.21068 + 2;
  D.21070 = (unsigned int) D.21069;
  D.21071 = D.21070 * 8;
  sigsize = (int) D.21071;
  D.21072 = (long unsigned int) sigsize;
  memcpy (res, sig, D.21072);
  D.21059 = sig->param_count;
  D.21060 = (int) D.21059;
  i = D.21060 + -1;
  goto <D.19298>;
  <D.19297>:
  D.21073 = i + 1;
  D.21074 = sig->params[i];
  res->params[D.21073] = D.21074;
  i = i + -1;
  <D.19298>:
  if (i >= 0) goto <D.19297>; else goto <D.19299>;
  <D.19299>:
  D.21075 = mono_defaults.int_class;
  D.21076 = &D.21075->byval_arg;
  res->params[0] = D.21076;
  if (preserve_sig != 0) goto <D.21077>; else goto <D.21078>;
  <D.21077>:
  D.21063 = sig->ret;
  res->ret = D.21063;
  goto <D.21079>;
  <D.21078>:
  D.21063 = sig->ret;
  D.21080 = mono_type_is_void (D.21063);
  if (D.21080 == 0) goto <D.21081>; else goto <D.21082>;
  <D.21081>:
  D.21083 = param_count + -1;
  D.21063 = sig->ret;
  D.21084 = mono_metadata_type_dup (image, D.21063);
  res->params[D.21083] = D.21084;
  D.21083 = param_count + -1;
  D.21085 = res->params[D.21083];
  D.21085->byref = 1;
  D.21083 = param_count + -1;
  D.21085 = res->params[D.21083];
  D.21085->attrs = 2;
  <D.21082>:
  D.21086 = mono_defaults.int32_class;
  D.21087 = &D.21086->byval_arg;
  res->ret = D.21087;
  <D.21079>:
  res->pinvoke = 0;
  res->hasthis = 0;
  D.21088 = (short unsigned int) param_count;
  res->param_count = D.21088;
  res->call_convention = 1;
  D.21089 = res;
  return D.21089;
}


cominterop_setup_marshal_context (struct EmitMarshalContext * m, struct MonoMethod * method)
{
  struct MonoClass * D.21091;
  struct MonoImage * D.21092;
  struct MonoMethodSignature * sig;
  struct MonoMethodSignature * csig;

  sig = mono_method_signature (method);
  D.21091 = method->klass;
  D.21092 = D.21091->image;
  csig = mono_metadata_signature_dup_full (D.21092, sig);
  csig->call_convention = 1;
  csig->hasthis = 0;
  csig->pinvoke = 1;
  D.21091 = method->klass;
  D.21092 = D.21091->image;
  m->image = D.21092;
  m->piinfo = 0B;
  m->retobj_var = 0;
  m->sig = sig;
  m->csig = csig;
}


cominterop_object_is_rcw (struct MonoObject * obj)
{
  gboolean D.21095;
  struct MonoVTable * D.21096;
  struct MonoClass * D.21097;
  struct MonoVTable * D.21102;
  int iftmp.66;
  struct MonoClass * D.21107;
  struct MonoClass * klass;
  struct MonoRealProxy * real_proxy;

  klass = 0B;
  real_proxy = 0B;
  if (obj == 0B) goto <D.21093>; else goto <D.21094>;
  <D.21093>:
  D.21095 = 0;
  return D.21095;
  <D.21094>:
  D.21096 = obj->vtable;
  klass = D.21096->klass;
  D.21097 = mono_defaults.transparent_proxy_class;
  if (D.21097 != klass) goto <D.21098>; else goto <D.21099>;
  <D.21098>:
  D.21095 = 0;
  return D.21095;
  <D.21099>:
  real_proxy = MEM[(struct MonoTransparentProxy *)obj].rp;
  if (real_proxy == 0B) goto <D.21100>; else goto <D.21101>;
  <D.21100>:
  D.21095 = 0;
  return D.21095;
  <D.21101>:
  D.21102 = MEM[(struct MonoObject *)real_proxy].vtable;
  klass = D.21102->klass;
  if (klass != 0B) goto <D.21106>; else goto <D.21104>;
  <D.21106>:
  D.21107 = mono_class_get_interop_proxy_class ();
  if (D.21107 == klass) goto <D.21108>; else goto <D.21104>;
  <D.21108>:
  iftmp.66 = 1;
  goto <D.21105>;
  <D.21104>:
  iftmp.66 = 0;
  <D.21105>:
  D.21095 = iftmp.66;
  return D.21095;
}


cominterop_get_function_pointer (void * itf, int slot)
{
  void * * D.21110;
  long unsigned int D.21111;
  long unsigned int D.21112;
  void * * D.21113;
  void * D.21114;
  void * func;

  D.21110 = MEM[(void * * *)itf];
  D.21111 = (long unsigned int) slot;
  D.21112 = D.21111 * 8;
  D.21113 = D.21110 + D.21112;
  func = *D.21113;
  D.21114 = func;
  return D.21114;
}


cominterop_get_method_interface (struct MonoMethod * method)
{
  struct MonoClass * D.21116;
  unsigned int D.21117;
  unsigned int D.21118;
  unsigned char D.21121;
  int D.21126;
  _Bool D.21127;
  long int D.21128;
  long int D.21129;
  void * * D.21134;
  long unsigned int D.21135;
  long unsigned int D.21136;
  void * * D.21137;
  struct MonoMethod * * D.21138;
  int D.21139;
  long unsigned int D.21140;
  long unsigned int D.21141;
  struct MonoMethod * * D.21142;
  struct MonoMethod * D.21143;
  unsigned int j.67;
  unsigned int D.21147;
  unsigned int i.68;
  unsigned int D.21150;
  _Bool D.21153;
  long int D.21154;
  long int D.21155;
  int iftmp.69;
  unsigned int D.21161;
  unsigned int D.21162;
  unsigned char D.21164;
  _Bool D.21167;
  long int D.21168;
  long int D.21169;
  struct MonoClass * D.21172;
  struct MonoError error;
  struct MonoClass * ic;

  try
    {
      ic = method->klass;
      D.21116 = method->klass;
      D.21117 = D.21116->flags;
      D.21118 = D.21117 & 32;
      if (D.21118 == 0) goto <D.21119>; else goto <D.21120>;
      <D.21119>:
      D.21116 = method->klass;
      D.21121 = D.21116->byval_arg.type;
      if (D.21121 != 19) goto <D.21122>; else goto <D.21123>;
      <D.21122>:
      D.21116 = method->klass;
      D.21121 = D.21116->byval_arg.type;
      if (D.21121 != 30) goto <D.21124>; else goto <D.21125>;
      <D.21124>:
      {
        struct GPtrArray * ifaces;

        D.21116 = method->klass;
        ifaces = mono_class_get_implemented_interfaces (D.21116, &error);
        D.21126 = mono_error_ok (&error);
        D.21127 = D.21126 == 0;
        D.21128 = (long int) D.21127;
        D.21129 = __builtin_expect (D.21128, 0);
        if (D.21129 != 0) goto <D.21130>; else goto <D.21131>;
        <D.21130>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "cominterop.c", 315, "mono_error_ok (&error)");
        <D.21131>:
        if (ifaces != 0B) goto <D.21132>; else goto <D.21133>;
        <D.21132>:
        {
          int i;

          D.21116 = method->klass;
          mono_class_setup_vtable (D.21116);
          i = 0;
          goto <D.19331>;
          <D.19330>:
          {
            int j;
            int offset;
            gboolean found;

            found = 0;
            D.21134 = ifaces->pdata;
            D.21135 = (long unsigned int) i;
            D.21136 = D.21135 * 8;
            D.21137 = D.21134 + D.21136;
            ic = *D.21137;
            D.21116 = method->klass;
            offset = mono_class_interface_offset (D.21116, ic);
            j = 0;
            goto <D.19328>;
            <D.19327>:
            D.21116 = method->klass;
            D.21138 = D.21116->vtable;
            D.21139 = j + offset;
            D.21140 = (long unsigned int) D.21139;
            D.21141 = D.21140 * 8;
            D.21142 = D.21138 + D.21141;
            D.21143 = *D.21142;
            if (D.21143 == method) goto <D.21144>; else goto <D.21145>;
            <D.21144>:
            found = 1;
            goto <D.19326>;
            <D.21145>:
            j = j + 1;
            <D.19328>:
            j.67 = (unsigned int) j;
            D.21147 = ic->method.count;
            if (j.67 < D.21147) goto <D.19327>; else goto <D.19326>;
            <D.19326>:
            if (found != 0) goto <D.19329>; else goto <D.21148>;
            <D.21148>:
            ic = 0B;
          }
          i = i + 1;
          <D.19331>:
          i.68 = (unsigned int) i;
          D.21150 = ifaces->len;
          if (i.68 < D.21150) goto <D.19330>; else goto <D.19329>;
          <D.19329>:
          monoeg_g_ptr_array_free (ifaces, 1);
        }
        <D.21133>:
      }
      <D.21125>:
      <D.21123>:
      <D.21120>:
      if (ic == 0B) goto <D.21151>; else goto <D.21152>;
      <D.21151>:
      D.21153 = ic == 0B;
      D.21154 = (long int) D.21153;
      D.21155 = __builtin_expect (D.21154, 0);
      if (D.21155 != 0) goto <D.21156>; else goto <D.21157>;
      <D.21156>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "cominterop.c", 339, "ic");
      <D.21157>:
      <D.21152>:
      D.21161 = ic->flags;
      D.21162 = D.21161 & 32;
      if (D.21162 == 0) goto <D.21163>; else goto <D.21159>;
      <D.21163>:
      D.21164 = ic->byval_arg.type;
      if (D.21164 != 19) goto <D.21165>; else goto <D.21159>;
      <D.21165>:
      D.21164 = ic->byval_arg.type;
      if (D.21164 != 30) goto <D.21166>; else goto <D.21159>;
      <D.21166>:
      iftmp.69 = 1;
      goto <D.21160>;
      <D.21159>:
      iftmp.69 = 0;
      <D.21160>:
      D.21167 = iftmp.69 != 0;
      D.21168 = (long int) D.21167;
      D.21169 = __builtin_expect (D.21168, 0);
      if (D.21169 != 0) goto <D.21170>; else goto <D.21171>;
      <D.21170>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "cominterop.c", 340, "MONO_CLASS_IS_INTERFACE (ic)");
      <D.21171>:
      D.21172 = ic;
      return D.21172;
    }
  finally
    {
      error = {CLOBBER};
    }
}


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);
}


mono_cominterop_cleanup ()
{
  DeleteCriticalSection (&cominterop_mutex);
}


mono_mb_emit_cominterop_call (struct MonoMethodBuilder * mb, struct MonoMethodSignature * sig, struct MonoMethod * method)
{
  int D.21175;

  mono_mb_emit_ldarg (mb, 0);
  D.21175 = cominterop_get_com_slot_for_method (method);
  mono_mb_emit_icon (mb, D.21175);
  mono_mb_emit_icall (mb, cominterop_get_function_pointer);
  mono_mb_emit_byte (mb, 240);
  mono_mb_emit_byte (mb, 9);
  mono_mb_emit_calli (mb, sig);
  mono_mb_emit_byte (mb, 240);
  mono_mb_emit_byte (mb, 10);
}


cominterop_get_com_slot_for_method (struct MonoMethod * method)
{
  short int D.21176;
  unsigned int D.21177;
  unsigned int D.21178;
  unsigned char D.21181;
  struct MonoClass * D.21186;
  _Bool D.21187;
  long int D.21188;
  long int D.21189;
  struct MonoMethod * * D.21192;
  int D.21193;
  long unsigned int D.21194;
  long unsigned int D.21195;
  struct MonoMethod * * D.21196;
  struct MonoMethod * D.21197;
  struct MonoMethod * * D.21200;
  long unsigned int D.21201;
  long unsigned int D.21202;
  struct MonoMethod * * D.21203;
  struct MonoMethod * D.21204;
  short int D.21205;
  unsigned int i.70;
  unsigned int D.21207;
  _Bool D.21208;
  long int D.21209;
  long int D.21210;
  int iftmp.71;
  _Bool D.21219;
  long int D.21220;
  long int D.21221;
  int D.21224;
  int D.21225;
  unsigned int D.21226;
  unsigned int D.21227;
  guint32 slot;
  struct MonoClass * ic;

  D.21176 = method->slot;
  slot = (guint32) D.21176;
  ic = method->klass;
  D.21177 = ic->flags;
  D.21178 = D.21177 & 32;
  if (D.21178 == 0) goto <D.21179>; else goto <D.21180>;
  <D.21179>:
  D.21181 = ic->byval_arg.type;
  if (D.21181 != 19) goto <D.21182>; else goto <D.21183>;
  <D.21182>:
  D.21181 = ic->byval_arg.type;
  if (D.21181 != 30) goto <D.21184>; else goto <D.21185>;
  <D.21184>:
  {
    int offset;
    int i;

    offset = 0;
    i = 0;
    ic = cominterop_get_method_interface (method);
    D.21186 = method->klass;
    offset = mono_class_interface_offset (D.21186, ic);
    D.21187 = offset < 0;
    D.21188 = (long int) D.21187;
    D.21189 = __builtin_expect (D.21188, 0);
    if (D.21189 != 0) goto <D.21190>; else goto <D.21191>;
    <D.21190>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "cominterop.c", 363, "offset >= 0");
    <D.21191>:
    i = 0;
    goto <D.19341>;
    <D.19340>:
    D.21186 = method->klass;
    D.21192 = D.21186->vtable;
    D.21193 = i + offset;
    D.21194 = (long unsigned int) D.21193;
    D.21195 = D.21194 * 8;
    D.21196 = D.21192 + D.21195;
    D.21197 = *D.21196;
    if (D.21197 == method) goto <D.21198>; else goto <D.21199>;
    <D.21198>:
    D.21200 = ic->methods;
    D.21201 = (long unsigned int) i;
    D.21202 = D.21201 * 8;
    D.21203 = D.21200 + D.21202;
    D.21204 = *D.21203;
    D.21205 = D.21204->slot;
    slot = (guint32) D.21205;
    goto <D.19339>;
    <D.21199>:
    i = i + 1;
    <D.19341>:
    i.70 = (unsigned int) i;
    D.21207 = ic->method.count;
    if (i.70 < D.21207) goto <D.19340>; else goto <D.19339>;
    <D.19339>:
  }
  <D.21185>:
  <D.21183>:
  <D.21180>:
  D.21208 = ic == 0B;
  D.21209 = (long int) D.21208;
  D.21210 = __builtin_expect (D.21209, 0);
  if (D.21210 != 0) goto <D.21211>; else goto <D.21212>;
  <D.21211>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "cominterop.c", 373, "ic");
  <D.21212>:
  D.21177 = ic->flags;
  D.21178 = D.21177 & 32;
  if (D.21178 == 0) goto <D.21216>; else goto <D.21214>;
  <D.21216>:
  D.21181 = ic->byval_arg.type;
  if (D.21181 != 19) goto <D.21217>; else goto <D.21214>;
  <D.21217>:
  D.21181 = ic->byval_arg.type;
  if (D.21181 != 30) goto <D.21218>; else goto <D.21214>;
  <D.21218>:
  iftmp.71 = 1;
  goto <D.21215>;
  <D.21214>:
  iftmp.71 = 0;
  <D.21215>:
  D.21219 = iftmp.71 != 0;
  D.21220 = (long int) D.21219;
  D.21221 = __builtin_expect (D.21220, 0);
  if (D.21221 != 0) goto <D.21222>; else goto <D.21223>;
  <D.21222>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "cominterop.c", 374, "MONO_CLASS_IS_INTERFACE (ic)");
  <D.21223>:
  D.21225 = cominterop_get_com_slot_begin (ic);
  D.21226 = (unsigned int) D.21225;
  D.21227 = D.21226 + slot;
  D.21224 = (int) D.21227;
  return D.21224;
}


mono_cominterop_emit_ptr_to_object_conv (struct MonoMethodBuilder * mb, struct MonoType * type, MonoMarshalConv conv, struct MonoMarshalSpec * mspec)
{
  struct MonoClass * com_interop_proxy_class.72;
  struct MonoImage * D.21232;
  struct MonoClass * com_interop_proxy_class.73;
  struct MonoMethod * com_interop_proxy_get_proxy.74;
  struct MonoMethod * com_interop_proxy_get_proxy.75;
  struct MonoMethod * get_transparent_proxy.76;
  struct MonoClass * D.21241;
  struct MonoMethod * get_transparent_proxy.77;
  struct MonoType * D.21243;
  struct MonoClass * D.21244;
  struct MonoType * D.21245;
  _Bool D.21248;
  long int D.21249;
  long int D.21250;

  switch (conv) <default: <D.19433>, case 25: <D.19421>, case 26: <D.19423>, case 27: <D.19422>>
  <D.19421>:
  <D.19422>:
  <D.19423>:
  {
    static struct MonoClass * com_interop_proxy_class = 0B;
    static struct MonoMethod * com_interop_proxy_get_proxy = 0B;
    static struct MonoMethod * get_transparent_proxy = 0B;
    int real_proxy;
    guint32 pos_null;
    guint32 pos_ccw;
    guint32 pos_end;
    struct MonoClass * klass;

    pos_null = 0;
    pos_ccw = 0;
    pos_end = 0;
    klass = 0B;
    klass = mono_class_from_mono_type (type);
    mono_mb_emit_ldloc (mb, 1);
    mono_mb_emit_byte (mb, 20);
    mono_mb_emit_byte (mb, 81);
    mono_mb_emit_ldloc (mb, 0);
    mono_mb_emit_byte (mb, 77);
    pos_null = mono_mb_emit_short_branch (mb, 44);
    mono_mb_emit_ldloc (mb, 1);
    mono_mb_emit_ldloc (mb, 0);
    mono_mb_emit_byte (mb, 77);
    mono_mb_emit_icon (mb, 1);
    mono_mb_emit_icall (mb, cominterop_get_ccw_object);
    pos_ccw = mono_mb_emit_short_branch (mb, 45);
    com_interop_proxy_class.72 = com_interop_proxy_class;
    if (com_interop_proxy_class.72 == 0B) goto <D.21230>; else goto <D.21231>;
    <D.21230>:
    D.21232 = mono_defaults.corlib;
    com_interop_proxy_class.73 = mono_class_from_name (D.21232, "Mono.Interop", "ComInteropProxy");
    com_interop_proxy_class = com_interop_proxy_class.73;
    <D.21231>:
    com_interop_proxy_get_proxy.74 = com_interop_proxy_get_proxy;
    if (com_interop_proxy_get_proxy.74 == 0B) goto <D.21235>; else goto <D.21236>;
    <D.21235>:
    com_interop_proxy_class.72 = com_interop_proxy_class;
    com_interop_proxy_get_proxy.75 = mono_class_get_method_from_name_flags (com_interop_proxy_class.72, "GetProxy", 2, 1);
    com_interop_proxy_get_proxy = com_interop_proxy_get_proxy.75;
    <D.21236>:
    get_transparent_proxy.76 = get_transparent_proxy;
    if (get_transparent_proxy.76 == 0B) goto <D.21239>; else goto <D.21240>;
    <D.21239>:
    D.21241 = mono_defaults.real_proxy_class;
    get_transparent_proxy.77 = mono_class_get_method_from_name (D.21241, "GetTransparentProxy", 0);
    get_transparent_proxy = get_transparent_proxy.77;
    <D.21240>:
    com_interop_proxy_class.72 = com_interop_proxy_class;
    D.21243 = &com_interop_proxy_class.72->byval_arg;
    real_proxy = mono_mb_add_local (mb, D.21243);
    mono_mb_emit_ldloc (mb, 0);
    mono_mb_emit_byte (mb, 77);
    D.21244 = mono_class_get_com_object_class ();
    D.21245 = &D.21244->byval_arg;
    mono_mb_emit_ptr (mb, D.21245);
    mono_mb_emit_icall (mb, cominterop_type_from_handle);
    com_interop_proxy_get_proxy.74 = com_interop_proxy_get_proxy;
    mono_mb_emit_managed_call (mb, com_interop_proxy_get_proxy.74, 0B);
    get_transparent_proxy.76 = get_transparent_proxy;
    mono_mb_emit_managed_call (mb, get_transparent_proxy.76, 0B);
    if (conv == 25) goto <D.21246>; else goto <D.21247>;
    <D.21246>:
    D.21248 = klass == 0B;
    D.21249 = (long int) D.21248;
    D.21250 = __builtin_expect (D.21249, 0);
    if (D.21250 != 0) goto <D.21251>; else goto <D.21252>;
    <D.21251>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "cominterop.c", 631, "klass");
    <D.21252>:
    mono_mb_emit_op (mb, 116, klass);
    <D.21247>:
    mono_mb_emit_byte (mb, 81);
    pos_end = mono_mb_emit_short_branch (mb, 43);
    mono_mb_patch_short_branch (mb, pos_ccw);
    mono_mb_emit_ldloc (mb, 0);
    mono_mb_emit_byte (mb, 77);
    mono_mb_emit_icon (mb, 1);
    mono_mb_emit_icall (mb, cominterop_get_ccw_object);
    if (conv == 25) goto <D.21253>; else goto <D.21254>;
    <D.21253>:
    D.21248 = klass == 0B;
    D.21249 = (long int) D.21248;
    D.21250 = __builtin_expect (D.21249, 0);
    if (D.21250 != 0) goto <D.21255>; else goto <D.21256>;
    <D.21255>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "cominterop.c", 645, "klass");
    <D.21256>:
    mono_mb_emit_op (mb, 116, klass);
    <D.21254>:
    mono_mb_emit_byte (mb, 81);
    mono_mb_patch_short_branch (mb, pos_end);
    mono_mb_patch_short_branch (mb, pos_null);
    goto <D.19432>;
  }
  <D.19433>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "cominterop.c", 656);
  <D.19432>:
}


mono_cominterop_emit_object_to_ptr_conv (struct MonoMethodBuilder * mb, struct MonoType * type, MonoMarshalConv conv, struct MonoMarshalSpec * mspec)
{
  struct MonoClass * D.21259;
  struct MonoProperty * iunknown.78;
  struct MonoClass * D.21266;
  struct MonoProperty * iunknown.79;
  struct MonoMethod * D.21268;
  struct MonoProperty * idispatch.80;
  struct MonoClass * D.21275;
  struct MonoProperty * idispatch.81;
  struct MonoMethod * D.21277;
  struct MonoClass * D.21281;
  struct MonoClass * D.21285;
  struct MonoClass * D.21289;

  switch (conv) <default: <D.19449>, case 25: <D.19440>, case 26: <D.19441>, case 27: <D.19442>>
  <D.19440>:
  <D.19441>:
  <D.19442>:
  {
    guint32 pos_null;
    guint32 pos_rcw;
    guint32 pos_end;

    pos_null = 0;
    pos_rcw = 0;
    pos_end = 0;
    mono_mb_emit_ldloc (mb, 1);
    mono_mb_emit_icon (mb, 0);
    mono_mb_emit_byte (mb, 224);
    mono_mb_emit_byte (mb, 223);
    mono_mb_emit_ldloc (mb, 0);
    mono_mb_emit_byte (mb, 80);
    pos_null = mono_mb_emit_short_branch (mb, 44);
    mono_mb_emit_ldloc (mb, 0);
    mono_mb_emit_byte (mb, 80);
    mono_mb_emit_icall (mb, cominterop_object_is_rcw);
    pos_rcw = mono_mb_emit_short_branch (mb, 44);
    mono_mb_emit_ldloc (mb, 1);
    mono_mb_emit_ldloc (mb, 0);
    mono_mb_emit_byte (mb, 80);
    mono_mb_emit_ldflda (mb, 16);
    mono_mb_emit_byte (mb, 80);
    mono_mb_emit_ldflda (mb, 80);
    mono_mb_emit_byte (mb, 80);
    if (conv == 25) goto <D.21257>; else goto <D.21258>;
    <D.21257>:
    D.21259 = mono_type_get_class (type);
    mono_mb_emit_ptr (mb, D.21259);
    mono_mb_emit_icon (mb, 1);
    mono_mb_emit_icall (mb, cominterop_get_interface);
    goto <D.21260>;
    <D.21258>:
    if (conv == 27) goto <D.21261>; else goto <D.21262>;
    <D.21261>:
    {
      static struct MonoProperty * iunknown = 0B;

      iunknown.78 = iunknown;
      if (iunknown.78 == 0B) goto <D.21264>; else goto <D.21265>;
      <D.21264>:
      D.21266 = mono_class_get_com_object_class ();
      iunknown.79 = mono_class_get_property_from_name (D.21266, "IUnknown");
      iunknown = iunknown.79;
      <D.21265>:
      iunknown.78 = iunknown;
      D.21268 = iunknown.78->get;
      mono_mb_emit_managed_call (mb, D.21268, 0B);
    }
    goto <D.21269>;
    <D.21262>:
    if (conv == 26) goto <D.21270>; else goto <D.21271>;
    <D.21270>:
    {
      static struct MonoProperty * idispatch = 0B;

      idispatch.80 = idispatch;
      if (idispatch.80 == 0B) goto <D.21273>; else goto <D.21274>;
      <D.21273>:
      D.21275 = mono_class_get_com_object_class ();
      idispatch.81 = mono_class_get_property_from_name (D.21275, "IDispatch");
      idispatch = idispatch.81;
      <D.21274>:
      idispatch.80 = idispatch;
      D.21277 = idispatch.80->get;
      mono_mb_emit_managed_call (mb, D.21277, 0B);
    }
    goto <D.21278>;
    <D.21271>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "cominterop.c", 719);
    <D.21278>:
    <D.21269>:
    <D.21260>:
    mono_mb_emit_byte (mb, 223);
    pos_end = mono_mb_emit_short_branch (mb, 43);
    mono_mb_patch_short_branch (mb, pos_rcw);
    mono_mb_emit_ldloc (mb, 1);
    mono_mb_emit_ldloc (mb, 0);
    mono_mb_emit_byte (mb, 80);
    if (conv == 25) goto <D.21279>; else goto <D.21280>;
    <D.21279>:
    D.21281 = mono_type_get_class (type);
    mono_mb_emit_ptr (mb, D.21281);
    goto <D.21282>;
    <D.21280>:
    if (conv == 27) goto <D.21283>; else goto <D.21284>;
    <D.21283>:
    D.21285 = mono_class_get_iunknown_class ();
    mono_mb_emit_ptr (mb, D.21285);
    goto <D.21286>;
    <D.21284>:
    if (conv == 26) goto <D.21287>; else goto <D.21288>;
    <D.21287>:
    D.21289 = mono_class_get_idispatch_class ();
    mono_mb_emit_ptr (mb, D.21289);
    goto <D.21290>;
    <D.21288>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "cominterop.c", 739);
    <D.21290>:
    <D.21286>:
    <D.21282>:
    mono_mb_emit_icall (mb, cominterop_get_ccw);
    mono_mb_emit_byte (mb, 223);
    mono_mb_patch_short_branch (mb, pos_end);
    mono_mb_patch_short_branch (mb, pos_null);
    goto <D.19448>;
  }
  <D.19449>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "cominterop.c", 748);
  <D.19448>:
}


mono_cominterop_get_native_wrapper (struct MonoMethod * method)
{
  _Bool D.21291;
  long int D.21292;
  long int D.21293;
  struct MonoClass * D.21296;
  struct MonoImage * D.21297;
  struct GHashTable * * D.21298;
  struct MonoMethod * D.21301;
  struct MonoMethod * * D.21302;
  struct MonoMethod * * D.21305;
  unsigned char D.21308;
  _Bool D.21309;
  long int D.21310;
  long int D.21311;
  const char * D.21314;
  unsigned int D.21315;
  unsigned int D.21316;
  int D.19486;
  int iftmp.82;
  int D.19485;
  const char[6] * D.21322;
  unsigned char D.21323;
  int D.21324;
  unsigned char D.21325;
  int D.21326;
  const unsigned char * D.21331;
  unsigned char D.21332;
  int D.21333;
  const unsigned char * D.21334;
  unsigned char D.21335;
  int D.21336;
  const unsigned char * D.21341;
  unsigned char D.21342;
  int D.21343;
  const unsigned char * D.21344;
  unsigned char D.21345;
  int D.21346;
  const unsigned char * D.21351;
  unsigned char D.21352;
  int D.21353;
  const unsigned char * D.21354;
  unsigned char D.21355;
  int D.21356;
  struct MonoMethod * ctor.83;
  struct MonoClass * D.21363;
  struct MonoMethod * ctor.84;
  short unsigned int D.21366;
  int D.21367;
  struct MonoClass * D.21368;
  struct MonoType * D.21369;
  struct MonoType * D.21370;
  int D.21371;
  unsigned int ptr_this.85;
  unsigned int i.86;
  short unsigned int D.21376;
  int D.21377;
  int D.21378;
  unsigned int retval.87;
  struct MonoMethod * ThrowExceptionForHR.88;
  struct MonoClass * D.21389;
  struct MonoMethod * ThrowExceptionForHR.89;
  int D.21391;
  short unsigned int D.21395;
  int D.21396;
  int D.21397;
  struct MonoMethod * res;
  struct GHashTable * cache;
  struct MonoMethodBuilder * mb;
  struct MonoMethodSignature * sig;
  struct MonoMethodSignature * csig;

  D.21291 = method == 0B;
  D.21292 = (long int) D.21291;
  D.21293 = __builtin_expect (D.21292, 0);
  if (D.21293 != 0) goto <D.21294>; else goto <D.21295>;
  <D.21294>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "cominterop.c", 869, "method");
  <D.21295>:
  D.21296 = method->klass;
  D.21297 = D.21296->image;
  D.21298 = &D.21297->cominterop_wrapper_cache;
  cache = mono_marshal_get_cache (D.21298, mono_aligned_addr_hash, 0B);
  res = mono_marshal_find_in_cache (cache, method);
  if (res != 0B) goto <D.21299>; else goto <D.21300>;
  <D.21299>:
  D.21301 = res;
  return D.21301;
  <D.21300>:
  D.21296 = method->klass;
  D.21302 = D.21296->vtable;
  if (D.21302 == 0B) goto <D.21303>; else goto <D.21304>;
  <D.21303>:
  D.21296 = method->klass;
  mono_class_setup_vtable (D.21296);
  <D.21304>:
  D.21296 = method->klass;
  D.21305 = D.21296->methods;
  if (D.21305 == 0B) goto <D.21306>; else goto <D.21307>;
  <D.21306>:
  D.21296 = method->klass;
  mono_class_setup_methods (D.21296);
  <D.21307>:
  D.21296 = method->klass;
  D.21308 = D.21296->exception_type;
  D.21309 = D.21308 != 0;
  D.21310 = (long int) D.21309;
  D.21311 = __builtin_expect (D.21310, 0);
  if (D.21311 != 0) goto <D.21312>; else goto <D.21313>;
  <D.21312>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "cominterop.c", 880, "!method->klass->exception_type");
  <D.21313>:
  sig = mono_method_signature (method);
  D.21296 = method->klass;
  D.21314 = method->name;
  mb = mono_mb_new (D.21296, D.21314, 27);
  D.21296 = method->klass;
  D.21315 = D.21296->flags;
  D.21316 = D.21315 & 4096;
  if (D.21316 != 0) goto <D.21317>; else goto <D.21318>;
  <D.21317>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 5;
    if (__s2_len <= 3) goto <D.21320>; else goto <D.21321>;
    <D.21320>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = method->name;
      D.21322 = ".ctor";
      D.21323 = MEM[(const unsigned char *)D.21322];
      D.21324 = (int) D.21323;
      D.21325 = *__s2;
      D.21326 = (int) D.21325;
      __result = D.21324 - D.21326;
      {
        if (__s2_len != 0) goto <D.21327>; else goto <D.21328>;
        <D.21327>:
        if (__result == 0) goto <D.21329>; else goto <D.21330>;
        <D.21329>:
        D.21331 = &MEM[(void *)".ctor" + 1B];
        D.21332 = *D.21331;
        D.21333 = (int) D.21332;
        D.21334 = __s2 + 1;
        D.21335 = *D.21334;
        D.21336 = (int) D.21335;
        __result = D.21333 - D.21336;
        if (__s2_len > 1) goto <D.21337>; else goto <D.21338>;
        <D.21337>:
        if (__result == 0) goto <D.21339>; else goto <D.21340>;
        <D.21339>:
        D.21341 = &MEM[(void *)".ctor" + 2B];
        D.21342 = *D.21341;
        D.21343 = (int) D.21342;
        D.21344 = __s2 + 2;
        D.21345 = *D.21344;
        D.21346 = (int) D.21345;
        __result = D.21343 - D.21346;
        if (__s2_len > 2) goto <D.21347>; else goto <D.21348>;
        <D.21347>:
        if (__result == 0) goto <D.21349>; else goto <D.21350>;
        <D.21349>:
        D.21351 = &MEM[(void *)".ctor" + 3B];
        D.21352 = *D.21351;
        D.21353 = (int) D.21352;
        D.21354 = __s2 + 3;
        D.21355 = *D.21354;
        D.21356 = (int) D.21355;
        __result = D.21353 - D.21356;
        <D.21350>:
        <D.21348>:
        <D.21340>:
        <D.21338>:
        <D.21330>:
        <D.21328>:
      }
      D.19485 = __result;
    }
    iftmp.82 = -D.19485;
    goto <D.21357>;
    <D.21321>:
    D.21314 = method->name;
    iftmp.82 = __builtin_strcmp (D.21314, ".ctor");
    <D.21357>:
    D.19486 = iftmp.82;
  }
  if (D.19486 == 0) goto <D.21358>; else goto <D.21359>;
  <D.21358>:
  {
    static struct MonoMethod * ctor = 0B;

    ctor.83 = ctor;
    if (ctor.83 == 0B) goto <D.21361>; else goto <D.21362>;
    <D.21361>:
    D.21363 = mono_class_get_com_object_class ();
    ctor.84 = mono_class_get_method_from_name (D.21363, ".ctor", 0);
    ctor = ctor.84;
    <D.21362>:
    mono_mb_emit_ldarg (mb, 0);
    ctor.83 = ctor;
    mono_mb_emit_managed_call (mb, ctor.83, 0B);
    mono_mb_emit_byte (mb, 42);
  }
  goto <D.21365>;
  <D.21359>:
  {
    static struct MonoMethod * ThrowExceptionForHR = 0B;
    struct MonoMethod * adjusted_method;
    int retval;
    int ptr_this;
    int i;
    gboolean preserve_sig;

    retval = 0;
    D.21366 = method->iflags;
    D.21367 = (int) D.21366;
    preserve_sig = D.21367 & 128;
    D.21368 = mono_defaults.int_class;
    D.21369 = &D.21368->byval_arg;
    ptr_this = mono_mb_add_local (mb, D.21369);
    D.21370 = sig->ret;
    D.21371 = mono_type_is_void (D.21370);
    if (D.21371 == 0) goto <D.21372>; else goto <D.21373>;
    <D.21372>:
    D.21370 = sig->ret;
    retval = mono_mb_add_local (mb, D.21370);
    <D.21373>:
    mono_mb_emit_ldarg (mb, 0);
    mono_mb_emit_ptr (mb, method);
    mono_mb_emit_icall (mb, cominterop_get_method_interface);
    mono_mb_emit_icon (mb, 1);
    mono_mb_emit_icall (mb, cominterop_get_interface);
    ptr_this.85 = (unsigned int) ptr_this;
    mono_mb_emit_stloc (mb, ptr_this.85);
    ptr_this.85 = (unsigned int) ptr_this;
    mono_mb_emit_ldloc (mb, ptr_this.85);
    i = 1;
    goto <D.19495>;
    <D.19494>:
    i.86 = (unsigned int) i;
    mono_mb_emit_ldarg (mb, i.86);
    i = i + 1;
    <D.19495>:
    D.21376 = sig->param_count;
    D.21377 = (int) D.21376;
    if (D.21377 >= i) goto <D.19494>; else goto <D.19496>;
    <D.19496>:
    D.21370 = sig->ret;
    D.21378 = mono_type_is_void (D.21370);
    if (D.21378 == 0) goto <D.21379>; else goto <D.21380>;
    <D.21379>:
    if (preserve_sig == 0) goto <D.21381>; else goto <D.21382>;
    <D.21381>:
    retval.87 = (unsigned int) retval;
    mono_mb_emit_ldloc_addr (mb, retval.87);
    <D.21382>:
    <D.21380>:
    adjusted_method = cominterop_get_native_wrapper_adjusted (method);
    mono_mb_emit_managed_call (mb, adjusted_method, 0B);
    if (preserve_sig == 0) goto <D.21384>; else goto <D.21385>;
    <D.21384>:
    ThrowExceptionForHR.88 = ThrowExceptionForHR;
    if (ThrowExceptionForHR.88 == 0B) goto <D.21387>; else goto <D.21388>;
    <D.21387>:
    D.21389 = mono_defaults.marshal_class;
    ThrowExceptionForHR.89 = mono_class_get_method_from_name (D.21389, "ThrowExceptionForHR", 1);
    ThrowExceptionForHR = ThrowExceptionForHR.89;
    <D.21388>:
    ThrowExceptionForHR.88 = ThrowExceptionForHR;
    mono_mb_emit_managed_call (mb, ThrowExceptionForHR.88, 0B);
    D.21370 = sig->ret;
    D.21391 = mono_type_is_void (D.21370);
    if (D.21391 == 0) goto <D.21392>; else goto <D.21393>;
    <D.21392>:
    retval.87 = (unsigned int) retval;
    mono_mb_emit_ldloc (mb, retval.87);
    <D.21393>:
    <D.21385>:
    mono_mb_emit_byte (mb, 42);
  }
  <D.21365>:
  goto <D.21394>;
  <D.21318>:
  {
    char * msg;

    msg = monoeg_strdup ("non imported interfaces on \t\t\timported classes is not yet implemented.");
    mono_mb_emit_exception (mb, "NotSupportedException", msg);
  }
  <D.21394>:
  D.21296 = method->klass;
  D.21297 = D.21296->image;
  csig = mono_metadata_signature_dup_full (D.21297, sig);
  csig->pinvoke = 0;
  D.21395 = csig->param_count;
  D.21396 = (int) D.21395;
  D.21397 = D.21396 + 16;
  res = mono_mb_create_and_cache (cache, method, mb, csig, D.21397);
  mono_mb_free (mb);
  D.21301 = res;
  return D.21301;
}


cominterop_get_native_wrapper_adjusted (struct MonoMethod * method)
{
  struct MonoClass * D.21399;
  const char * D.21400;
  short unsigned int D.21401;
  int D.21402;
  int D.21403;
  long unsigned int D.21404;
  long unsigned int D.21405;
  short unsigned int D.21406;
  sizetype D.21407;
  sizetype D.21408;
  sizetype D.21409;
  struct MonoMarshalSpec * * D.21410;
  long unsigned int D.21411;
  long unsigned int D.21412;
  struct MonoMarshalSpec * * D.21413;
  struct MonoMarshalSpec * D.21414;
  struct MonoMarshalSpec * * D.21415;
  short unsigned int D.21416;
  int D.21417;
  int D.21418;
  struct MonoType * D.21421;
  int D.21422;
  long unsigned int D.21425;
  long unsigned int D.21426;
  struct MonoMarshalSpec * * D.21427;
  struct MonoMarshalSpec * D.21428;
  long unsigned int D.21429;
  long unsigned int D.21430;
  struct MonoMarshalSpec * * D.21431;
  struct MonoMarshalSpec * D.21432;
  struct MonoType * D.21435;
  unsigned char D.21436;
  void * D.21439;
  void * D.21443;
  void * D.21447;
  void * D.21451;
  int D.21454;
  unsigned char D.21459;
  void * D.21462;
  void * D.21466;
  void * D.21470;
  void * D.21474;
  struct MonoImage * D.21475;
  void * D.21476;
  int D.21477;
  struct MonoMethod * D.21480;
  struct MonoMethod * res;
  struct MonoMethodBuilder * mb_native;
  struct MonoMarshalSpec * * mspecs;
  struct MonoMethodSignature * sig;
  struct MonoMethodSignature * sig_native;
  struct MonoMethodPInvoke * piinfo;
  int i;

  piinfo = method;
  sig = mono_method_signature (method);
  D.21399 = method->klass;
  D.21400 = method->name;
  mb_native = mono_mb_new (D.21399, D.21400, 6);
  sig_native = cominterop_method_signature (method);
  D.21401 = sig_native->param_count;
  D.21402 = (int) D.21401;
  D.21403 = D.21402 + 1;
  D.21404 = (long unsigned int) D.21403;
  D.21405 = D.21404 * 8;
  mspecs = monoeg_malloc (D.21405);
  D.21401 = sig_native->param_count;
  D.21402 = (int) D.21401;
  D.21403 = D.21402 + 1;
  D.21404 = (long unsigned int) D.21403;
  D.21405 = D.21404 * 8;
  memset (mspecs, 0, D.21405);
  mono_method_get_marshal_info (method, mspecs);
  D.21406 = sig->param_count;
  i = (int) D.21406;
  goto <D.19461>;
  <D.19460>:
  D.21407 = (sizetype) i;
  D.21408 = D.21407 + 1;
  D.21409 = D.21408 * 8;
  D.21410 = mspecs + D.21409;
  D.21411 = (long unsigned int) i;
  D.21412 = D.21411 * 8;
  D.21413 = mspecs + D.21412;
  D.21414 = *D.21413;
  *D.21410 = D.21414;
  i = i + -1;
  <D.19461>:
  if (i > 0) goto <D.19460>; else goto <D.19462>;
  <D.19462>:
  D.21415 = mspecs + 8;
  *D.21415 = 0B;
  D.21416 = method->iflags;
  D.21417 = (int) D.21416;
  D.21418 = D.21417 & 128;
  if (D.21418 == 0) goto <D.21419>; else goto <D.21420>;
  <D.21419>:
  D.21421 = sig->ret;
  D.21422 = mono_type_is_void (D.21421);
  if (D.21422 == 0) goto <D.21423>; else goto <D.21424>;
  <D.21423>:
  D.21401 = sig_native->param_count;
  D.21425 = (long unsigned int) D.21401;
  D.21426 = D.21425 * 8;
  D.21427 = mspecs + D.21426;
  D.21428 = *mspecs;
  *D.21427 = D.21428;
  <D.21424>:
  *mspecs = 0B;
  <D.21420>:
  i = 1;
  goto <D.19465>;
  <D.19464>:
  {
    int mspec_index;

    mspec_index = i + 1;
    D.21429 = (long unsigned int) mspec_index;
    D.21430 = D.21429 * 8;
    D.21431 = mspecs + D.21430;
    D.21432 = *D.21431;
    if (D.21432 == 0B) goto <D.21433>; else goto <D.21434>;
    <D.21433>:
    D.21435 = sig_native->params[i];
    D.21436 = D.21435->type;
    if (D.21436 == 28) goto <D.21437>; else goto <D.21438>;
    <D.21437>:
    D.21429 = (long unsigned int) mspec_index;
    D.21430 = D.21429 * 8;
    D.21431 = mspecs + D.21430;
    D.21439 = monoeg_malloc0 (24);
    *D.21431 = D.21439;
    D.21429 = (long unsigned int) mspec_index;
    D.21430 = D.21429 * 8;
    D.21431 = mspecs + D.21430;
    D.21432 = *D.21431;
    D.21432->native = 27;
    goto <D.21440>;
    <D.21438>:
    D.21435 = sig_native->params[i];
    D.21436 = D.21435->type;
    if (D.21436 == 14) goto <D.21441>; else goto <D.21442>;
    <D.21441>:
    D.21429 = (long unsigned int) mspec_index;
    D.21430 = D.21429 * 8;
    D.21431 = mspecs + D.21430;
    D.21443 = monoeg_malloc0 (24);
    *D.21431 = D.21443;
    D.21429 = (long unsigned int) mspec_index;
    D.21430 = D.21429 * 8;
    D.21431 = mspecs + D.21430;
    D.21432 = *D.21431;
    D.21432->native = 19;
    goto <D.21444>;
    <D.21442>:
    D.21435 = sig_native->params[i];
    D.21436 = D.21435->type;
    if (D.21436 == 18) goto <D.21445>; else goto <D.21446>;
    <D.21445>:
    D.21429 = (long unsigned int) mspec_index;
    D.21430 = D.21429 * 8;
    D.21431 = mspecs + D.21430;
    D.21447 = monoeg_malloc0 (24);
    *D.21431 = D.21447;
    D.21429 = (long unsigned int) mspec_index;
    D.21430 = D.21429 * 8;
    D.21431 = mspecs + D.21430;
    D.21432 = *D.21431;
    D.21432->native = 28;
    goto <D.21448>;
    <D.21446>:
    D.21435 = sig_native->params[i];
    D.21436 = D.21435->type;
    if (D.21436 == 2) goto <D.21449>; else goto <D.21450>;
    <D.21449>:
    D.21429 = (long unsigned int) mspec_index;
    D.21430 = D.21429 * 8;
    D.21431 = mspecs + D.21430;
    D.21451 = monoeg_malloc0 (24);
    *D.21431 = D.21451;
    D.21429 = (long unsigned int) mspec_index;
    D.21430 = D.21429 * 8;
    D.21431 = mspecs + D.21430;
    D.21432 = *D.21431;
    D.21432->native = 37;
    <D.21450>:
    <D.21448>:
    <D.21444>:
    <D.21440>:
    <D.21434>:
  }
  i = i + 1;
  <D.19465>:
  D.21401 = sig_native->param_count;
  D.21402 = (int) D.21401;
  if (D.21402 > i) goto <D.19464>; else goto <D.19466>;
  <D.19466>:
  D.21416 = method->iflags;
  D.21417 = (int) D.21416;
  D.21418 = D.21417 & 128;
  if (D.21418 != 0) goto <D.21452>; else goto <D.21453>;
  <D.21452>:
  D.21421 = sig->ret;
  D.21454 = mono_type_is_void (D.21421);
  if (D.21454 == 0) goto <D.21455>; else goto <D.21456>;
  <D.21455>:
  D.21428 = *mspecs;
  if (D.21428 == 0B) goto <D.21457>; else goto <D.21458>;
  <D.21457>:
  D.21421 = sig->ret;
  D.21459 = D.21421->type;
  if (D.21459 == 28) goto <D.21460>; else goto <D.21461>;
  <D.21460>:
  D.21462 = monoeg_malloc0 (24);
  *mspecs = D.21462;
  D.21428 = *mspecs;
  D.21428->native = 27;
  goto <D.21463>;
  <D.21461>:
  D.21421 = sig->ret;
  D.21459 = D.21421->type;
  if (D.21459 == 14) goto <D.21464>; else goto <D.21465>;
  <D.21464>:
  D.21466 = monoeg_malloc0 (24);
  *mspecs = D.21466;
  D.21428 = *mspecs;
  D.21428->native = 19;
  goto <D.21467>;
  <D.21465>:
  D.21421 = sig->ret;
  D.21459 = D.21421->type;
  if (D.21459 == 18) goto <D.21468>; else goto <D.21469>;
  <D.21468>:
  D.21470 = monoeg_malloc0 (24);
  *mspecs = D.21470;
  D.21428 = *mspecs;
  D.21428->native = 28;
  goto <D.21471>;
  <D.21469>:
  D.21421 = sig->ret;
  D.21459 = D.21421->type;
  if (D.21459 == 2) goto <D.21472>; else goto <D.21473>;
  <D.21472>:
  D.21474 = monoeg_malloc0 (24);
  *mspecs = D.21474;
  D.21428 = *mspecs;
  D.21428->native = 37;
  <D.21473>:
  <D.21471>:
  <D.21467>:
  <D.21463>:
  <D.21458>:
  <D.21456>:
  <D.21453>:
  D.21399 = method->klass;
  D.21475 = D.21399->image;
  D.21476 = piinfo->addr;
  mono_marshal_emit_native_wrapper (D.21475, mb_native, sig_native, piinfo, mspecs, D.21476, 0, 1, 0);
  D.21401 = sig_native->param_count;
  D.21402 = (int) D.21401;
  D.21477 = D.21402 + 16;
  res = mono_mb_create_method (mb_native, sig_native, D.21477);
  mono_mb_free (mb_native);
  D.21401 = sig_native->param_count;
  i = (int) D.21401;
  goto <D.19468>;
  <D.19467>:
  D.21411 = (long unsigned int) i;
  D.21412 = D.21411 * 8;
  D.21413 = mspecs + D.21412;
  D.21414 = *D.21413;
  if (D.21414 != 0B) goto <D.21478>; else goto <D.21479>;
  <D.21478>:
  D.21411 = (long unsigned int) i;
  D.21412 = D.21411 * 8;
  D.21413 = mspecs + D.21412;
  D.21414 = *D.21413;
  mono_metadata_free_marshal_spec (D.21414);
  <D.21479>:
  i = i + -1;
  <D.19468>:
  if (i >= 0) goto <D.19467>; else goto <D.19469>;
  <D.19469>:
  monoeg_g_free (mspecs);
  D.21480 = res;
  return D.21480;
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.21484;
  int D.21489;
  void * D.21491;
  long unsigned int D.21492;

  D.21484 = __builtin_constant_p (__len);
  if (D.21484 != 0) goto <D.21485>; else goto <D.21486>;
  <D.21485>:
  if (__len == 0) goto <D.21487>; else goto <D.21488>;
  <D.21487>:
  D.21489 = __builtin_constant_p (__ch);
  if (D.21489 == 0) goto <D.21482>; else goto <D.21490>;
  <D.21490>:
  if (__ch != 0) goto <D.21482>; else goto <D.21483>;
  <D.21482>:
  __warn_memset_zero_len ();
  D.21491 = __dest;
  return D.21491;
  <D.21483>:
  <D.21488>:
  <D.21486>:
  D.21492 = __builtin_object_size (__dest, 0);
  D.21491 = __builtin___memset_chk (__dest, __ch, __len, D.21492);
  return D.21491;
}


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

  if (str != 0B) goto <D.21494>; else goto <D.21495>;
  <D.21494>:
  D.21496 = __strdup (str);
  return D.21496;
  <D.21495>:
  D.21496 = 0B;
  return D.21496;
}


mono_cominterop_get_invoke (struct MonoMethod * method)
{
  struct MonoClass * D.21498;
  struct MonoImage * D.21499;
  struct GHashTable * * D.21500;
  _Bool D.21501;
  long int D.21502;
  long int D.21503;
  struct MonoMethod * D.21508;
  long unsigned int D.21509;
  long unsigned int D.21510;
  const char * D.21513;
  struct MonoClass * D.21514;
  struct MonoType * D.21515;
  unsigned int i.90;
  short unsigned int D.21517;
  int D.21518;
  short unsigned int D.21519;
  int D.21520;
  int D.21521;
  short unsigned int D.21525;
  int D.21526;
  int D.21527;
  int D.19519;
  int iftmp.91;
  int D.19518;
  const char[6] * D.21534;
  unsigned char D.21535;
  int D.21536;
  unsigned char D.21537;
  int D.21538;
  const unsigned char * D.21543;
  unsigned char D.21544;
  int D.21545;
  const unsigned char * D.21546;
  unsigned char D.21547;
  int D.21548;
  const unsigned char * D.21553;
  unsigned char D.21554;
  int D.21555;
  const unsigned char * D.21556;
  unsigned char D.21557;
  int D.21558;
  const unsigned char * D.21563;
  unsigned char D.21564;
  int D.21565;
  const unsigned char * D.21566;
  unsigned char D.21567;
  int D.21568;
  struct MonoClass * com_interop_proxy_class.92;
  struct MonoImage * D.21575;
  struct MonoClass * com_interop_proxy_class.93;
  struct MonoMethod * cache_proxy.94;
  struct MonoMethod * cache_proxy.95;
  int D.21581;
  struct MonoMethodSignature * sig;
  struct MonoMethodBuilder * mb;
  struct MonoMethod * res;
  int i;
  int temp_obj;
  struct GHashTable * cache;

  D.21498 = method->klass;
  D.21499 = D.21498->image;
  D.21500 = &D.21499->cominterop_invoke_cache;
  cache = mono_marshal_get_cache (D.21500, mono_aligned_addr_hash, 0B);
  D.21501 = method == 0B;
  D.21502 = (long int) D.21501;
  D.21503 = __builtin_expect (D.21502, 0);
  if (D.21503 != 0) goto <D.21504>; else goto <D.21505>;
  <D.21504>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "cominterop.c", 982, "method");
  <D.21505>:
  res = mono_marshal_find_in_cache (cache, method);
  if (res != 0B) goto <D.21506>; else goto <D.21507>;
  <D.21506>:
  D.21508 = res;
  return D.21508;
  <D.21507>:
  sig = mono_signature_no_pinvoke (method);
  D.21509 = BIT_FIELD_REF <*sig, 64, 64>;
  D.21510 = D.21509 & 18014398509481984;
  if (D.21510 == 0) goto <D.21511>; else goto <D.21512>;
  <D.21511>:
  D.21508 = method;
  return D.21508;
  <D.21512>:
  D.21498 = method->klass;
  D.21513 = method->name;
  mb = mono_mb_new (D.21498, D.21513, 26);
  D.21514 = mono_defaults.object_class;
  D.21515 = &D.21514->byval_arg;
  temp_obj = mono_mb_add_local (mb, D.21515);
  mono_mb_emit_ldarg (mb, 0);
  mono_mb_emit_ldflda (mb, 16);
  mono_mb_emit_byte (mb, 80);
  mono_mb_emit_ldflda (mb, 80);
  mono_mb_emit_byte (mb, 80);
  i = 1;
  goto <D.19508>;
  <D.19507>:
  i.90 = (unsigned int) i;
  mono_mb_emit_ldarg (mb, i.90);
  i = i + 1;
  <D.19508>:
  D.21517 = sig->param_count;
  D.21518 = (int) D.21517;
  if (D.21518 >= i) goto <D.19507>; else goto <D.19509>;
  <D.19509>:
  D.21519 = method->iflags;
  D.21520 = (int) D.21519;
  D.21521 = D.21520 & 4096;
  if (D.21521 != 0) goto <D.21522>; else goto <D.21523>;
  <D.21522>:
  {
    struct MonoMethod * native_wrapper;

    native_wrapper = mono_cominterop_get_native_wrapper (method);
    mono_mb_emit_managed_call (mb, native_wrapper, 0B);
  }
  goto <D.21524>;
  <D.21523>:
  D.21525 = method->flags;
  D.21526 = (int) D.21525;
  D.21527 = D.21526 & 64;
  if (D.21527 != 0) goto <D.21528>; else goto <D.21529>;
  <D.21528>:
  mono_mb_emit_op (mb, 111, method);
  goto <D.21530>;
  <D.21529>:
  mono_mb_emit_op (mb, 40, method);
  <D.21530>:
  <D.21524>:
  {
    size_t __s1_len;
    size_t __s2_len;

    __s2_len = 5;
    if (__s2_len <= 3) goto <D.21532>; else goto <D.21533>;
    <D.21532>:
    {
      const unsigned char * __s2;
      int __result;

      __s2 = method->name;
      D.21534 = ".ctor";
      D.21535 = MEM[(const unsigned char *)D.21534];
      D.21536 = (int) D.21535;
      D.21537 = *__s2;
      D.21538 = (int) D.21537;
      __result = D.21536 - D.21538;
      {
        if (__s2_len != 0) goto <D.21539>; else goto <D.21540>;
        <D.21539>:
        if (__result == 0) goto <D.21541>; else goto <D.21542>;
        <D.21541>:
        D.21543 = &MEM[(void *)".ctor" + 1B];
        D.21544 = *D.21543;
        D.21545 = (int) D.21544;
        D.21546 = __s2 + 1;
        D.21547 = *D.21546;
        D.21548 = (int) D.21547;
        __result = D.21545 - D.21548;
        if (__s2_len > 1) goto <D.21549>; else goto <D.21550>;
        <D.21549>:
        if (__result == 0) goto <D.21551>; else goto <D.21552>;
        <D.21551>:
        D.21553 = &MEM[(void *)".ctor" + 2B];
        D.21554 = *D.21553;
        D.21555 = (int) D.21554;
        D.21556 = __s2 + 2;
        D.21557 = *D.21556;
        D.21558 = (int) D.21557;
        __result = D.21555 - D.21558;
        if (__s2_len > 2) goto <D.21559>; else goto <D.21560>;
        <D.21559>:
        if (__result == 0) goto <D.21561>; else goto <D.21562>;
        <D.21561>:
        D.21563 = &MEM[(void *)".ctor" + 3B];
        D.21564 = *D.21563;
        D.21565 = (int) D.21564;
        D.21566 = __s2 + 3;
        D.21567 = *D.21566;
        D.21568 = (int) D.21567;
        __result = D.21565 - D.21568;
        <D.21562>:
        <D.21560>:
        <D.21552>:
        <D.21550>:
        <D.21542>:
        <D.21540>:
      }
      D.19518 = __result;
    }
    iftmp.91 = -D.19518;
    goto <D.21569>;
    <D.21533>:
    D.21513 = method->name;
    iftmp.91 = __builtin_strcmp (D.21513, ".ctor");
    <D.21569>:
    D.19519 = iftmp.91;
  }
  if (D.19519 == 0) goto <D.21570>; else goto <D.21571>;
  <D.21570>:
  {
    static struct MonoClass * com_interop_proxy_class = 0B;
    static struct MonoMethod * cache_proxy = 0B;

    com_interop_proxy_class.92 = com_interop_proxy_class;
    if (com_interop_proxy_class.92 == 0B) goto <D.21573>; else goto <D.21574>;
    <D.21573>:
    D.21575 = mono_defaults.corlib;
    com_interop_proxy_class.93 = mono_class_from_name (D.21575, "Mono.Interop", "ComInteropProxy");
    com_interop_proxy_class = com_interop_proxy_class.93;
    <D.21574>:
    cache_proxy.94 = cache_proxy;
    if (cache_proxy.94 == 0B) goto <D.21578>; else goto <D.21579>;
    <D.21578>:
    com_interop_proxy_class.92 = com_interop_proxy_class;
    cache_proxy.95 = mono_class_get_method_from_name (com_interop_proxy_class.92, "CacheProxy", 0);
    cache_proxy = cache_proxy.95;
    <D.21579>:
    mono_mb_emit_ldarg (mb, 0);
    mono_mb_emit_ldflda (mb, 16);
    mono_mb_emit_byte (mb, 80);
    cache_proxy.94 = cache_proxy;
    mono_mb_emit_managed_call (mb, cache_proxy.94, 0B);
  }
  <D.21571>:
  mono_marshal_emit_thread_interrupt_checkpoint (mb);
  mono_mb_emit_byte (mb, 42);
  D.21517 = sig->param_count;
  D.21518 = (int) D.21517;
  D.21581 = D.21518 + 16;
  res = mono_mb_create_and_cache (cache, method, mb, sig, D.21581);
  mono_mb_free (mb);
  D.21508 = res;
  return D.21508;
}


mono_cominterop_emit_marshal_com_interface (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_iunknown.96;
  struct MonoClass * D.21586;
  struct MonoMethod * get_object_for_iunknown.97;
  struct MonoMethod * get_iunknown_for_object_internal.98;
  struct MonoMethod * get_iunknown_for_object_internal.99;
  struct MonoMethod * get_idispatch_for_object_internal.100;
  struct MonoMethod * get_idispatch_for_object_internal.101;
  struct MonoMethod * get_com_interface_for_object_internal.102;
  struct MonoMethod * get_com_interface_for_object_internal.103;
  struct MonoMethod * marshal_release.104;
  struct MonoMethod * marshal_release.105;
  struct MonoClass * D.21604;
  struct MonoType * D.21605;
  unsigned int conv_arg.106;
  long unsigned int D.21607;
  long unsigned int D.21608;
  short unsigned int D.21611;
  int D.21612;
  int D.21613;
  unsigned int argnum.107;
  struct MonoClass * D.21623;
  <unnamed type> D.21625;
  struct MonoType * D.21640;
  unsigned int ccw_obj.108;
  unsigned int ret_ptr.109;
  unsigned int ccw_obj.110;
  struct MonoType * D.21663;
  unsigned int ccw_obj.111;
  struct MonoMethod * AddRef.112;
  struct MonoMethod * AddRef.113;
  struct MonoMethod * AddRef.114;
  unsigned int ccw_obj.115;
  int D.21720;
  struct MonoMethodBuilder * mb;
  struct MonoClass * klass;
  static struct MonoMethod * get_object_for_iunknown = 0B;
  static struct MonoMethod * get_iunknown_for_object_internal = 0B;
  static struct MonoMethod * get_com_interface_for_object_internal = 0B;
  static struct MonoMethod * get_idispatch_for_object_internal = 0B;
  static struct MonoMethod * marshal_release = 0B;
  static struct MonoMethod * AddRef = 0B;

  mb = m->mb;
  klass = t->data.klass;
  get_object_for_iunknown.96 = get_object_for_iunknown;
  if (get_object_for_iunknown.96 == 0B) goto <D.21584>; else goto <D.21585>;
  <D.21584>:
  D.21586 = mono_defaults.marshal_class;
  get_object_for_iunknown.97 = mono_class_get_method_from_name (D.21586, "GetObjectForIUnknown", 1);
  get_object_for_iunknown = get_object_for_iunknown.97;
  <D.21585>:
  get_iunknown_for_object_internal.98 = get_iunknown_for_object_internal;
  if (get_iunknown_for_object_internal.98 == 0B) goto <D.21589>; else goto <D.21590>;
  <D.21589>:
  D.21586 = mono_defaults.marshal_class;
  get_iunknown_for_object_internal.99 = mono_class_get_method_from_name (D.21586, "GetIUnknownForObjectInternal", 1);
  get_iunknown_for_object_internal = get_iunknown_for_object_internal.99;
  <D.21590>:
  get_idispatch_for_object_internal.100 = get_idispatch_for_object_internal;
  if (get_idispatch_for_object_internal.100 == 0B) goto <D.21593>; else goto <D.21594>;
  <D.21593>:
  D.21586 = mono_defaults.marshal_class;
  get_idispatch_for_object_internal.101 = mono_class_get_method_from_name (D.21586, "GetIDispatchForObjectInternal", 1);
  get_idispatch_for_object_internal = get_idispatch_for_object_internal.101;
  <D.21594>:
  get_com_interface_for_object_internal.102 = get_com_interface_for_object_internal;
  if (get_com_interface_for_object_internal.102 == 0B) goto <D.21597>; else goto <D.21598>;
  <D.21597>:
  D.21586 = mono_defaults.marshal_class;
  get_com_interface_for_object_internal.103 = mono_class_get_method_from_name (D.21586, "GetComInterfaceForObjectInternal", 2);
  get_com_interface_for_object_internal = get_com_interface_for_object_internal.103;
  <D.21598>:
  marshal_release.104 = marshal_release;
  if (marshal_release.104 == 0B) goto <D.21601>; else goto <D.21602>;
  <D.21601>:
  D.21586 = mono_defaults.marshal_class;
  marshal_release.105 = mono_class_get_method_from_name (D.21586, "Release", 1);
  marshal_release = marshal_release.105;
  <D.21602>:
  switch (action) <default: <D.19567>, case 0: <D.19542>, case 1: <D.19550>, case 2: <D.19545>, case 3: <D.19551>, case 4: <D.19557>, case 5: <D.19562>, case 6: <D.19564>>
  <D.19542>:
  {
    guint32 pos_null;

    pos_null = 0;
    D.21604 = mono_defaults.int_class;
    D.21605 = &D.21604->byval_arg;
    *conv_arg_type = D.21605;
    D.21604 = mono_defaults.int_class;
    D.21605 = &D.21604->byval_arg;
    conv_arg = mono_mb_add_local (mb, D.21605);
    mono_mb_emit_ptr (mb, 0B);
    conv_arg.106 = (unsigned int) conv_arg;
    mono_mb_emit_stloc (mb, conv_arg.106);
    D.21607 = BIT_FIELD_REF <*t, 64, 64>;
    D.21608 = D.21607 & 1073741824;
    if (D.21608 != 0) goto <D.21609>; else goto <D.21610>;
    <D.21609>:
    D.21611 = t->attrs;
    D.21612 = (int) D.21611;
    D.21613 = D.21612 & 2;
    if (D.21613 != 0) goto <D.19544>; else goto <D.21614>;
    <D.21614>:
    <D.21610>:
    argnum.107 = (unsigned int) argnum;
    mono_mb_emit_ldarg (mb, argnum.107);
    D.21607 = BIT_FIELD_REF <*t, 64, 64>;
    D.21608 = D.21607 & 1073741824;
    if (D.21608 != 0) goto <D.21616>; else goto <D.21617>;
    <D.21616>:
    mono_mb_emit_byte (mb, 80);
    <D.21617>:
    pos_null = mono_mb_emit_short_branch (mb, 44);
    argnum.107 = (unsigned int) argnum;
    mono_mb_emit_ldarg (mb, argnum.107);
    D.21607 = BIT_FIELD_REF <*t, 64, 64>;
    D.21608 = D.21607 & 1073741824;
    if (D.21608 != 0) goto <D.21618>; else goto <D.21619>;
    <D.21618>:
    mono_mb_emit_byte (mb, 80);
    <D.21619>:
    if (klass != 0B) goto <D.21622>; else goto <D.21620>;
    <D.21622>:
    D.21623 = mono_defaults.object_class;
    if (D.21623 != klass) goto <D.21624>; else goto <D.21620>;
    <D.21624>:
    mono_mb_emit_ptr (mb, t);
    mono_mb_emit_icall (mb, cominterop_type_from_handle);
    get_com_interface_for_object_internal.102 = get_com_interface_for_object_internal;
    mono_mb_emit_managed_call (mb, get_com_interface_for_object_internal.102, 0B);
    goto <D.21621>;
    <D.21620>:
    D.21625 = spec->native;
    if (D.21625 == 25) goto <D.21626>; else goto <D.21627>;
    <D.21626>:
    get_iunknown_for_object_internal.98 = get_iunknown_for_object_internal;
    mono_mb_emit_managed_call (mb, get_iunknown_for_object_internal.98, 0B);
    goto <D.21628>;
    <D.21627>:
    D.21625 = spec->native;
    if (D.21625 == 26) goto <D.21629>; else goto <D.21630>;
    <D.21629>:
    get_idispatch_for_object_internal.100 = get_idispatch_for_object_internal;
    mono_mb_emit_managed_call (mb, get_idispatch_for_object_internal.100, 0B);
    goto <D.21631>;
    <D.21630>:
    if (klass == 0B) goto <D.21634>; else goto <D.21632>;
    <D.21634>:
    D.21625 = spec->native;
    if (D.21625 == 28) goto <D.21635>; else goto <D.21632>;
    <D.21635>:
    get_iunknown_for_object_internal.98 = get_iunknown_for_object_internal;
    mono_mb_emit_managed_call (mb, get_iunknown_for_object_internal.98, 0B);
    goto <D.21633>;
    <D.21632>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "cominterop.c", 1128);
    <D.21633>:
    <D.21631>:
    <D.21628>:
    <D.21621>:
    conv_arg.106 = (unsigned int) conv_arg;
    mono_mb_emit_stloc (mb, conv_arg.106);
    mono_mb_patch_short_branch (mb, pos_null);
    goto <D.19544>;
  }
  <D.19545>:
  D.21607 = BIT_FIELD_REF <*t, 64, 64>;
  D.21608 = D.21607 & 1073741824;
  if (D.21608 != 0) goto <D.21636>; else goto <D.21637>;
  <D.21636>:
  D.21611 = t->attrs;
  D.21612 = (int) D.21611;
  D.21613 = D.21612 & 2;
  if (D.21613 != 0) goto <D.21638>; else goto <D.21639>;
  <D.21638>:
  {
    int ccw_obj;
    guint32 pos_null;
    guint32 pos_ccw;
    guint32 pos_end;

    pos_null = 0;
    pos_ccw = 0;
    pos_end = 0;
    D.21623 = mono_defaults.object_class;
    D.21640 = &D.21623->byval_arg;
    ccw_obj = mono_mb_add_local (mb, D.21640);
    argnum.107 = (unsigned int) argnum;
    mono_mb_emit_ldarg (mb, argnum.107);
    mono_mb_emit_byte (mb, 20);
    mono_mb_emit_byte (mb, 81);
    conv_arg.106 = (unsigned int) conv_arg;
    mono_mb_emit_ldloc (mb, conv_arg.106);
    pos_null = mono_mb_emit_short_branch (mb, 44);
    conv_arg.106 = (unsigned int) conv_arg;
    mono_mb_emit_ldloc (mb, conv_arg.106);
    mono_mb_emit_icon (mb, 1);
    mono_mb_emit_icall (mb, cominterop_get_ccw_object);
    ccw_obj.108 = (unsigned int) ccw_obj;
    mono_mb_emit_stloc (mb, ccw_obj.108);
    ccw_obj.108 = (unsigned int) ccw_obj;
    mono_mb_emit_ldloc (mb, ccw_obj.108);
    pos_ccw = mono_mb_emit_short_branch (mb, 45);
    argnum.107 = (unsigned int) argnum;
    mono_mb_emit_ldarg (mb, argnum.107);
    conv_arg.106 = (unsigned int) conv_arg;
    mono_mb_emit_ldloc (mb, conv_arg.106);
    get_object_for_iunknown.96 = get_object_for_iunknown;
    mono_mb_emit_managed_call (mb, get_object_for_iunknown.96, 0B);
    if (klass != 0B) goto <D.21642>; else goto <D.21643>;
    <D.21642>:
    D.21623 = mono_defaults.object_class;
    if (D.21623 != klass) goto <D.21644>; else goto <D.21645>;
    <D.21644>:
    mono_mb_emit_op (mb, 116, klass);
    <D.21645>:
    <D.21643>:
    mono_mb_emit_byte (mb, 81);
    pos_end = mono_mb_emit_short_branch (mb, 43);
    mono_mb_patch_short_branch (mb, pos_ccw);
    argnum.107 = (unsigned int) argnum;
    mono_mb_emit_ldarg (mb, argnum.107);
    ccw_obj.108 = (unsigned int) ccw_obj;
    mono_mb_emit_ldloc (mb, ccw_obj.108);
    if (klass != 0B) goto <D.21646>; else goto <D.21647>;
    <D.21646>:
    D.21623 = mono_defaults.object_class;
    if (D.21623 != klass) goto <D.21648>; else goto <D.21649>;
    <D.21648>:
    mono_mb_emit_op (mb, 116, klass);
    <D.21649>:
    <D.21647>:
    mono_mb_emit_byte (mb, 81);
    mono_mb_patch_short_branch (mb, pos_end);
    conv_arg.106 = (unsigned int) conv_arg;
    mono_mb_emit_ldloc (mb, conv_arg.106);
    marshal_release.104 = marshal_release;
    mono_mb_emit_managed_call (mb, marshal_release.104, 0B);
    mono_mb_emit_byte (mb, 38);
    mono_mb_patch_short_branch (mb, pos_null);
  }
  <D.21639>:
  <D.21637>:
  goto <D.19544>;
  <D.19550>:
  D.21607 = BIT_FIELD_REF <*t, 64, 64>;
  D.21608 = D.21607 & 1073741824;
  if (D.21608 != 0) goto <D.21650>; else goto <D.21651>;
  <D.21650>:
  conv_arg.106 = (unsigned int) conv_arg;
  mono_mb_emit_ldloc_addr (mb, conv_arg.106);
  goto <D.21652>;
  <D.21651>:
  conv_arg.106 = (unsigned int) conv_arg;
  mono_mb_emit_ldloc (mb, conv_arg.106);
  <D.21652>:
  goto <D.19544>;
  <D.19551>:
  {
    int ccw_obj;
    int ret_ptr;
    guint32 pos_null;
    guint32 pos_ccw;
    guint32 pos_end;

    pos_null = 0;
    pos_ccw = 0;
    pos_end = 0;
    D.21623 = mono_defaults.object_class;
    D.21640 = &D.21623->byval_arg;
    ccw_obj = mono_mb_add_local (mb, D.21640);
    D.21604 = mono_defaults.int_class;
    D.21605 = &D.21604->byval_arg;
    ret_ptr = mono_mb_add_local (mb, D.21605);
    ret_ptr.109 = (unsigned int) ret_ptr;
    mono_mb_emit_stloc (mb, ret_ptr.109);
    ret_ptr.109 = (unsigned int) ret_ptr;
    mono_mb_emit_ldloc (mb, ret_ptr.109);
    pos_null = mono_mb_emit_short_branch (mb, 44);
    ret_ptr.109 = (unsigned int) ret_ptr;
    mono_mb_emit_ldloc (mb, ret_ptr.109);
    mono_mb_emit_icon (mb, 1);
    mono_mb_emit_icall (mb, cominterop_get_ccw_object);
    ccw_obj.110 = (unsigned int) ccw_obj;
    mono_mb_emit_stloc (mb, ccw_obj.110);
    ccw_obj.110 = (unsigned int) ccw_obj;
    mono_mb_emit_ldloc (mb, ccw_obj.110);
    pos_ccw = mono_mb_emit_short_branch (mb, 45);
    ret_ptr.109 = (unsigned int) ret_ptr;
    mono_mb_emit_ldloc (mb, ret_ptr.109);
    get_object_for_iunknown.96 = get_object_for_iunknown;
    mono_mb_emit_managed_call (mb, get_object_for_iunknown.96, 0B);
    if (klass != 0B) goto <D.21655>; else goto <D.21656>;
    <D.21655>:
    D.21623 = mono_defaults.object_class;
    if (D.21623 != klass) goto <D.21657>; else goto <D.21658>;
    <D.21657>:
    mono_mb_emit_op (mb, 116, klass);
    <D.21658>:
    <D.21656>:
    mono_mb_emit_stloc (mb, 3);
    pos_end = mono_mb_emit_short_branch (mb, 43);
    mono_mb_patch_short_branch (mb, pos_ccw);
    ccw_obj.110 = (unsigned int) ccw_obj;
    mono_mb_emit_ldloc (mb, ccw_obj.110);
    if (klass != 0B) goto <D.21659>; else goto <D.21660>;
    <D.21659>:
    D.21623 = mono_defaults.object_class;
    if (D.21623 != klass) goto <D.21661>; else goto <D.21662>;
    <D.21661>:
    mono_mb_emit_op (mb, 116, klass);
    <D.21662>:
    <D.21660>:
    mono_mb_emit_stloc (mb, 3);
    mono_mb_patch_short_branch (mb, pos_end);
    ret_ptr.109 = (unsigned int) ret_ptr;
    mono_mb_emit_ldloc (mb, ret_ptr.109);
    marshal_release.104 = marshal_release;
    mono_mb_emit_managed_call (mb, marshal_release.104, 0B);
    mono_mb_emit_byte (mb, 38);
    mono_mb_patch_short_branch (mb, pos_null);
    goto <D.19544>;
  }
  <D.19557>:
  {
    int ccw_obj;
    guint32 pos_null;
    guint32 pos_ccw;
    guint32 pos_end;

    pos_null = 0;
    pos_ccw = 0;
    pos_end = 0;
    D.21623 = mono_defaults.object_class;
    D.21640 = &D.21623->byval_arg;
    ccw_obj = mono_mb_add_local (mb, D.21640);
    klass = mono_class_from_mono_type (t);
    D.21663 = &klass->byval_arg;
    conv_arg = mono_mb_add_local (mb, D.21663);
    D.21604 = mono_defaults.int_class;
    D.21605 = &D.21604->byval_arg;
    *conv_arg_type = D.21605;
    mono_mb_emit_byte (mb, 20);
    conv_arg.106 = (unsigned int) conv_arg;
    mono_mb_emit_stloc (mb, conv_arg.106);
    D.21611 = t->attrs;
    D.21612 = (int) D.21611;
    D.21613 = D.21612 & 2;
    if (D.21613 != 0) goto <D.19544>; else goto <D.21664>;
    <D.21664>:
    argnum.107 = (unsigned int) argnum;
    mono_mb_emit_ldarg (mb, argnum.107);
    D.21607 = BIT_FIELD_REF <*t, 64, 64>;
    D.21608 = D.21607 & 1073741824;
    if (D.21608 != 0) goto <D.21665>; else goto <D.21666>;
    <D.21665>:
    mono_mb_emit_byte (mb, 80);
    <D.21666>:
    pos_null = mono_mb_emit_short_branch (mb, 44);
    argnum.107 = (unsigned int) argnum;
    mono_mb_emit_ldarg (mb, argnum.107);
    D.21607 = BIT_FIELD_REF <*t, 64, 64>;
    D.21608 = D.21607 & 1073741824;
    if (D.21608 != 0) goto <D.21667>; else goto <D.21668>;
    <D.21667>:
    mono_mb_emit_byte (mb, 80);
    <D.21668>:
    mono_mb_emit_icon (mb, 1);
    mono_mb_emit_icall (mb, cominterop_get_ccw_object);
    ccw_obj.111 = (unsigned int) ccw_obj;
    mono_mb_emit_stloc (mb, ccw_obj.111);
    ccw_obj.111 = (unsigned int) ccw_obj;
    mono_mb_emit_ldloc (mb, ccw_obj.111);
    pos_ccw = mono_mb_emit_short_branch (mb, 45);
    argnum.107 = (unsigned int) argnum;
    mono_mb_emit_ldarg (mb, argnum.107);
    D.21607 = BIT_FIELD_REF <*t, 64, 64>;
    D.21608 = D.21607 & 1073741824;
    if (D.21608 != 0) goto <D.21670>; else goto <D.21671>;
    <D.21670>:
    mono_mb_emit_byte (mb, 80);
    <D.21671>:
    get_object_for_iunknown.96 = get_object_for_iunknown;
    mono_mb_emit_managed_call (mb, get_object_for_iunknown.96, 0B);
    if (klass != 0B) goto <D.21672>; else goto <D.21673>;
    <D.21672>:
    D.21623 = mono_defaults.object_class;
    if (D.21623 != klass) goto <D.21674>; else goto <D.21675>;
    <D.21674>:
    mono_mb_emit_op (mb, 116, klass);
    <D.21675>:
    <D.21673>:
    conv_arg.106 = (unsigned int) conv_arg;
    mono_mb_emit_stloc (mb, conv_arg.106);
    pos_end = mono_mb_emit_short_branch (mb, 43);
    mono_mb_patch_short_branch (mb, pos_ccw);
    ccw_obj.111 = (unsigned int) ccw_obj;
    mono_mb_emit_ldloc (mb, ccw_obj.111);
    if (klass != 0B) goto <D.21676>; else goto <D.21677>;
    <D.21676>:
    D.21623 = mono_defaults.object_class;
    if (D.21623 != klass) goto <D.21678>; else goto <D.21679>;
    <D.21678>:
    mono_mb_emit_op (mb, 116, klass);
    <D.21679>:
    <D.21677>:
    conv_arg.106 = (unsigned int) conv_arg;
    mono_mb_emit_stloc (mb, conv_arg.106);
    mono_mb_patch_short_branch (mb, pos_end);
    mono_mb_patch_short_branch (mb, pos_null);
    goto <D.19544>;
  }
  <D.19562>:
  D.21607 = BIT_FIELD_REF <*t, 64, 64>;
  D.21608 = D.21607 & 1073741824;
  if (D.21608 != 0) goto <D.21680>; else goto <D.21681>;
  <D.21680>:
  D.21611 = t->attrs;
  D.21612 = (int) D.21611;
  D.21613 = D.21612 & 2;
  if (D.21613 != 0) goto <D.21682>; else goto <D.21683>;
  <D.21682>:
  {
    guint32 pos_null;

    pos_null = 0;
    AddRef.112 = AddRef;
    if (AddRef.112 == 0B) goto <D.21685>; else goto <D.21686>;
    <D.21685>:
    D.21586 = mono_defaults.marshal_class;
    AddRef.113 = mono_class_get_method_from_name (D.21586, "AddRef", 1);
    AddRef = AddRef.113;
    <D.21686>:
    argnum.107 = (unsigned int) argnum;
    mono_mb_emit_ldarg (mb, argnum.107);
    mono_mb_emit_byte (mb, 22);
    mono_mb_emit_byte (mb, 223);
    conv_arg.106 = (unsigned int) conv_arg;
    mono_mb_emit_ldloc (mb, conv_arg.106);
    pos_null = mono_mb_emit_short_branch (mb, 44);
    argnum.107 = (unsigned int) argnum;
    mono_mb_emit_ldarg (mb, argnum.107);
    conv_arg.106 = (unsigned int) conv_arg;
    mono_mb_emit_ldloc (mb, conv_arg.106);
    if (klass != 0B) goto <D.21690>; else goto <D.21688>;
    <D.21690>:
    D.21623 = mono_defaults.object_class;
    if (D.21623 != klass) goto <D.21691>; else goto <D.21688>;
    <D.21691>:
    mono_mb_emit_ptr (mb, t);
    mono_mb_emit_icall (mb, cominterop_type_from_handle);
    get_com_interface_for_object_internal.102 = get_com_interface_for_object_internal;
    mono_mb_emit_managed_call (mb, get_com_interface_for_object_internal.102, 0B);
    goto <D.21689>;
    <D.21688>:
    D.21625 = spec->native;
    if (D.21625 == 25) goto <D.21692>; else goto <D.21693>;
    <D.21692>:
    get_iunknown_for_object_internal.98 = get_iunknown_for_object_internal;
    mono_mb_emit_managed_call (mb, get_iunknown_for_object_internal.98, 0B);
    goto <D.21694>;
    <D.21693>:
    D.21625 = spec->native;
    if (D.21625 == 26) goto <D.21695>; else goto <D.21696>;
    <D.21695>:
    get_idispatch_for_object_internal.100 = get_idispatch_for_object_internal;
    mono_mb_emit_managed_call (mb, get_idispatch_for_object_internal.100, 0B);
    goto <D.21697>;
    <D.21696>:
    if (klass == 0B) goto <D.21700>; else goto <D.21698>;
    <D.21700>:
    D.21625 = spec->native;
    if (D.21625 == 28) goto <D.21701>; else goto <D.21698>;
    <D.21701>:
    get_iunknown_for_object_internal.98 = get_iunknown_for_object_internal;
    mono_mb_emit_managed_call (mb, get_iunknown_for_object_internal.98, 0B);
    goto <D.21699>;
    <D.21698>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "cominterop.c", 1321);
    <D.21699>:
    <D.21697>:
    <D.21694>:
    <D.21689>:
    mono_mb_emit_byte (mb, 223);
    argnum.107 = (unsigned int) argnum;
    mono_mb_emit_ldarg (mb, argnum.107);
    mono_mb_emit_byte (mb, 77);
    AddRef.112 = AddRef;
    mono_mb_emit_managed_call (mb, AddRef.112, 0B);
    mono_mb_emit_byte (mb, 38);
    mono_mb_patch_short_branch (mb, pos_null);
  }
  <D.21683>:
  <D.21681>:
  goto <D.19544>;
  <D.19564>:
  {
    guint32 pos_null;
    int ccw_obj;

    pos_null = 0;
    D.21623 = mono_defaults.object_class;
    D.21640 = &D.21623->byval_arg;
    ccw_obj = mono_mb_add_local (mb, D.21640);
    AddRef.112 = AddRef;
    if (AddRef.112 == 0B) goto <D.21702>; else goto <D.21703>;
    <D.21702>:
    D.21586 = mono_defaults.marshal_class;
    AddRef.114 = mono_class_get_method_from_name (D.21586, "AddRef", 1);
    AddRef = AddRef.114;
    <D.21703>:
    ccw_obj.115 = (unsigned int) ccw_obj;
    mono_mb_emit_stloc (mb, ccw_obj.115);
    ccw_obj.115 = (unsigned int) ccw_obj;
    mono_mb_emit_ldloc (mb, ccw_obj.115);
    pos_null = mono_mb_emit_short_branch (mb, 44);
    ccw_obj.115 = (unsigned int) ccw_obj;
    mono_mb_emit_ldloc (mb, ccw_obj.115);
    if (klass != 0B) goto <D.21708>; else goto <D.21706>;
    <D.21708>:
    D.21623 = mono_defaults.object_class;
    if (D.21623 != klass) goto <D.21709>; else goto <D.21706>;
    <D.21709>:
    mono_mb_emit_ptr (mb, t);
    mono_mb_emit_icall (mb, cominterop_type_from_handle);
    get_com_interface_for_object_internal.102 = get_com_interface_for_object_internal;
    mono_mb_emit_managed_call (mb, get_com_interface_for_object_internal.102, 0B);
    goto <D.21707>;
    <D.21706>:
    D.21625 = spec->native;
    if (D.21625 == 25) goto <D.21710>; else goto <D.21711>;
    <D.21710>:
    get_iunknown_for_object_internal.98 = get_iunknown_for_object_internal;
    mono_mb_emit_managed_call (mb, get_iunknown_for_object_internal.98, 0B);
    goto <D.21712>;
    <D.21711>:
    D.21625 = spec->native;
    if (D.21625 == 26) goto <D.21713>; else goto <D.21714>;
    <D.21713>:
    get_idispatch_for_object_internal.100 = get_idispatch_for_object_internal;
    mono_mb_emit_managed_call (mb, get_idispatch_for_object_internal.100, 0B);
    goto <D.21715>;
    <D.21714>:
    if (klass == 0B) goto <D.21718>; else goto <D.21716>;
    <D.21718>:
    D.21625 = spec->native;
    if (D.21625 == 28) goto <D.21719>; else goto <D.21716>;
    <D.21719>:
    get_iunknown_for_object_internal.98 = get_iunknown_for_object_internal;
    mono_mb_emit_managed_call (mb, get_iunknown_for_object_internal.98, 0B);
    goto <D.21717>;
    <D.21716>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "cominterop.c", 1364);
    <D.21717>:
    <D.21715>:
    <D.21712>:
    <D.21707>:
    mono_mb_emit_stloc (mb, 3);
    mono_mb_emit_ldloc (mb, 3);
    AddRef.112 = AddRef;
    mono_mb_emit_managed_call (mb, AddRef.112, 0B);
    mono_mb_emit_byte (mb, 38);
    mono_mb_patch_short_branch (mb, pos_null);
    goto <D.19544>;
  }
  <D.19567>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "cominterop.c", 1376);
  <D.19544>:
  D.21720 = conv_arg;
  return D.21720;
}


ves_icall_System_Runtime_InteropServices_Marshal_AddRefInternal (void * pUnk)
{
  _Bool D.21722;
  long int D.21723;
  long int D.21724;
  int D.21727;
  struct MonoIUnknown * D.21728;
  int (*<T3258>) (void *) D.21729;

  D.21722 = pUnk == 0B;
  D.21723 = (long int) D.21722;
  D.21724 = __builtin_expect (D.21723, 0);
  if (D.21724 != 0) goto <D.21725>; else goto <D.21726>;
  <D.21725>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "cominterop.c", 1399, "pUnk");
  <D.21726>:
  D.21728 = MEM[(struct MonoIUnknown * *)pUnk];
  D.21729 = D.21728->AddRef;
  D.21727 = D.21729 (pUnk);
  return D.21727;
}


ves_icall_System_Runtime_InteropServices_Marshal_QueryInterfaceInternal (void * pUnk, void * riid, void * * ppv)
{
  _Bool D.21731;
  long int D.21732;
  long int D.21733;
  int D.21736;
  struct MonoIUnknown * D.21737;
  int (*<T307f>) (void *, void *, void * *) D.21738;

  D.21731 = pUnk == 0B;
  D.21732 = (long int) D.21731;
  D.21733 = __builtin_expect (D.21732, 0);
  if (D.21733 != 0) goto <D.21734>; else goto <D.21735>;
  <D.21734>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "cominterop.c", 1406, "pUnk");
  <D.21735>:
  D.21737 = MEM[(struct MonoIUnknown * *)pUnk];
  D.21738 = D.21737->QueryInterface;
  D.21736 = D.21738 (pUnk, riid, ppv);
  return D.21736;
}


ves_icall_System_Runtime_InteropServices_Marshal_ReleaseInternal (void * pUnk)
{
  _Bool D.21740;
  long int D.21741;
  long int D.21742;
  int D.21745;
  struct MonoIUnknown * D.21746;
  int (*<T3258>) (void *) D.21747;

  D.21740 = pUnk == 0B;
  D.21741 = (long int) D.21740;
  D.21742 = __builtin_expect (D.21741, 0);
  if (D.21742 != 0) goto <D.21743>; else goto <D.21744>;
  <D.21743>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "cominterop.c", 1413, "pUnk");
  <D.21744>:
  D.21746 = MEM[(struct MonoIUnknown * *)pUnk];
  D.21747 = D.21746->Release;
  D.21745 = D.21747 (pUnk);
  return D.21745;
}


ves_icall_System_Runtime_InteropServices_Marshal_GetIUnknownForObjectInternal (struct MonoObject * object)
{
  void * D.21751;
  int D.21752;
  struct MonoVTable * D.21757;
  struct MonoClass * D.21758;
  struct MonoVTable * D.21763;
  struct MonoClass * D.21764;
  struct MonoComObject * D.21767;
  struct MonoClass * D.21770;

  if (object == 0B) goto <D.21749>; else goto <D.21750>;
  <D.21749>:
  D.21751 = 0B;
  return D.21751;
  <D.21750>:
  D.21752 = cominterop_object_is_rcw (object);
  if (D.21752 != 0) goto <D.21753>; else goto <D.21754>;
  <D.21753>:
  {
    struct MonoClass * klass;
    struct MonoRealProxy * real_proxy;

    klass = 0B;
    real_proxy = 0B;
    if (object == 0B) goto <D.21755>; else goto <D.21756>;
    <D.21755>:
    D.21751 = 0B;
    return D.21751;
    <D.21756>:
    D.21757 = object->vtable;
    klass = D.21757->klass;
    D.21758 = mono_defaults.transparent_proxy_class;
    if (D.21758 != klass) goto <D.21759>; else goto <D.21760>;
    <D.21759>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "cominterop.c", 1460);
    D.21751 = 0B;
    return D.21751;
    <D.21760>:
    real_proxy = MEM[(struct MonoTransparentProxy *)object].rp;
    if (real_proxy == 0B) goto <D.21761>; else goto <D.21762>;
    <D.21761>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "cominterop.c", 1466);
    D.21751 = 0B;
    return D.21751;
    <D.21762>:
    D.21763 = MEM[(struct MonoObject *)real_proxy].vtable;
    klass = D.21763->klass;
    D.21764 = mono_class_get_interop_proxy_class ();
    if (D.21764 != klass) goto <D.21765>; else goto <D.21766>;
    <D.21765>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "cominterop.c", 1472);
    D.21751 = 0B;
    return D.21751;
    <D.21766>:
    D.21767 = MEM[(struct MonoComInteropProxy *)real_proxy].com_object;
    if (D.21767 == 0B) goto <D.21768>; else goto <D.21769>;
    <D.21768>:
    monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "cominterop.c", 1477);
    D.21751 = 0B;
    return D.21751;
    <D.21769>:
    D.21767 = MEM[(struct MonoComInteropProxy *)real_proxy].com_object;
    D.21751 = D.21767->iunknown;
    return D.21751;
  }
  <D.21754>:
  D.21770 = mono_class_get_iunknown_class ();
  D.21751 = cominterop_get_ccw (object, D.21770);
  return D.21751;
}


ves_icall_System_Runtime_InteropServices_Marshal_GetObjectForCCW (void * pUnk)
{
  struct MonoObject * D.21774;
  struct MonoObject * object;

  object = 0B;
  if (pUnk == 0B) goto <D.21772>; else goto <D.21773>;
  <D.21772>:
  D.21774 = 0B;
  return D.21774;
  <D.21773>:
  object = cominterop_get_ccw_object (pUnk, 1);
  D.21774 = object;
  return D.21774;
}


ves_icall_System_Runtime_InteropServices_Marshal_GetIDispatchForObjectInternal (struct MonoObject * object)
{
  void * D.21776;

  D.21776 = cominterop_get_idispatch_for_object (object);
  return D.21776;
}


cominterop_get_idispatch_for_object (struct MonoObject * object)
{
  void * D.21780;
  int D.21781;
  struct MonoRealProxy * D.21784;
  struct MonoComObject * D.21785;
  struct MonoClass * D.21786;
  struct MonoVTable * D.21787;
  int D.21788;
  struct MonoClass * D.21791;

  if (object == 0B) goto <D.21778>; else goto <D.21779>;
  <D.21778>:
  D.21780 = 0B;
  return D.21780;
  <D.21779>:
  D.21781 = cominterop_object_is_rcw (object);
  if (D.21781 != 0) goto <D.21782>; else goto <D.21783>;
  <D.21782>:
  D.21784 = MEM[(struct MonoTransparentProxy *)object].rp;
  D.21785 = MEM[(struct MonoComInteropProxy *)D.21784].com_object;
  D.21786 = mono_class_get_idispatch_class ();
  D.21780 = cominterop_get_interface (D.21785, D.21786, 1);
  return D.21780;
  <D.21783>:
  {
    struct MonoClass * klass;

    D.21787 = object->vtable;
    klass = D.21787->klass;
    D.21788 = cominterop_can_support_dispatch (klass);
    if (D.21788 == 0) goto <D.21789>; else goto <D.21790>;
    <D.21789>:
    cominterop_raise_hr_exception (-2147467262);
    <D.21790>:
    D.21791 = mono_class_get_idispatch_class ();
    D.21780 = cominterop_get_ccw (object, D.21791);
    return D.21780;
  }
}


ves_icall_System_Runtime_InteropServices_Marshal_GetCCW (struct MonoObject * object, struct MonoReflectionType * type)
{
  _Bool D.21793;
  long int D.21794;
  long int D.21795;
  struct MonoType * D.21798;
  _Bool D.21799;
  long int D.21800;
  long int D.21801;
  _Bool D.21804;
  long int D.21805;
  long int D.21806;
  int D.21809;
  struct MonoException * D.21812;
  _Bool D.21813;
  long int D.21814;
  long int D.21815;
  void * D.21818;
  struct MonoClass * klass;
  void * itf;

  klass = 0B;
  itf = 0B;
  D.21793 = type == 0B;
  D.21794 = (long int) D.21793;
  D.21795 = __builtin_expect (D.21794, 0);
  if (D.21795 != 0) goto <D.21796>; else goto <D.21797>;
  <D.21796>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "cominterop.c", 1525, "type");
  <D.21797>:
  D.21798 = type->type;
  D.21799 = D.21798 == 0B;
  D.21800 = (long int) D.21799;
  D.21801 = __builtin_expect (D.21800, 0);
  if (D.21801 != 0) goto <D.21802>; else goto <D.21803>;
  <D.21802>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "cominterop.c", 1526, "type->type");
  <D.21803>:
  D.21798 = type->type;
  klass = mono_type_get_class (D.21798);
  D.21804 = klass == 0B;
  D.21805 = (long int) D.21804;
  D.21806 = __builtin_expect (D.21805, 0);
  if (D.21806 != 0) goto <D.21807>; else goto <D.21808>;
  <D.21807>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "cominterop.c", 1528, "klass");
  <D.21808>:
  D.21809 = mono_class_init (klass);
  if (D.21809 == 0) goto <D.21810>; else goto <D.21811>;
  <D.21810>:
  D.21812 = mono_class_get_exception_for_failure (klass);
  mono_raise_exception (D.21812);
  <D.21811>:
  itf = cominterop_get_ccw (object, klass);
  D.21813 = itf == 0B;
  D.21814 = (long int) D.21813;
  D.21815 = __builtin_expect (D.21814, 0);
  if (D.21815 != 0) goto <D.21816>; else goto <D.21817>;
  <D.21816>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "cominterop.c", 1533, "itf");
  <D.21817>:
  D.21818 = itf;
  return D.21818;
}


ves_icall_System_Runtime_InteropServices_Marshal_IsComObject (struct MonoObject * object)
{
  MonoBoolean D.21820;
  int D.21821;

  D.21821 = cominterop_object_is_rcw (object);
  D.21820 = (MonoBoolean) D.21821;
  return D.21820;
}


ves_icall_System_Runtime_InteropServices_Marshal_ReleaseComObjectInternal (struct MonoObject * object)
{
  _Bool D.21823;
  long int D.21824;
  long int D.21825;
  int D.21828;
  _Bool D.21829;
  long int D.21830;
  long int D.21831;
  _Bool D.21834;
  long int D.21835;
  long int D.21836;
  int D.21839;
  gint32 D.21842;
  gint32 * D.21843;
  _Bool D.21844;
  long int D.21845;
  long int D.21846;
  struct MonoComObject * D.21851;
  struct MonoComInteropProxy * proxy;
  gint32 ref_count;

  proxy = 0B;
  ref_count = 0;
  D.21823 = object == 0B;
  D.21824 = (long int) D.21823;
  D.21825 = __builtin_expect (D.21824, 0);
  if (D.21825 != 0) goto <D.21826>; else goto <D.21827>;
  <D.21826>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "cominterop.c", 1558, "object");
  <D.21827>:
  D.21828 = cominterop_object_is_rcw (object);
  D.21829 = D.21828 == 0;
  D.21830 = (long int) D.21829;
  D.21831 = __builtin_expect (D.21830, 0);
  if (D.21831 != 0) goto <D.21832>; else goto <D.21833>;
  <D.21832>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "cominterop.c", 1559, "cominterop_object_is_rcw (object)");
  <D.21833>:
  proxy = MEM[(struct MonoTransparentProxy *)object].rp;
  D.21834 = proxy == 0B;
  D.21835 = (long int) D.21834;
  D.21836 = __builtin_expect (D.21835, 0);
  if (D.21836 != 0) goto <D.21837>; else goto <D.21838>;
  <D.21837>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "cominterop.c", 1562, "proxy");
  <D.21838>:
  D.21839 = proxy->ref_count;
  if (D.21839 == 0) goto <D.21840>; else goto <D.21841>;
  <D.21840>:
  D.21842 = -1;
  return D.21842;
  <D.21841>:
  D.21843 = &proxy->ref_count;
  ref_count = InterlockedDecrement (D.21843);
  D.21844 = ref_count < 0;
  D.21845 = (long int) D.21844;
  D.21846 = __builtin_expect (D.21845, 0);
  if (D.21846 != 0) goto <D.21847>; else goto <D.21848>;
  <D.21847>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "cominterop.c", 1569, "ref_count >= 0");
  <D.21848>:
  if (ref_count == 0) goto <D.21849>; else goto <D.21850>;
  <D.21849>:
  D.21851 = proxy->com_object;
  ves_icall_System_ComObject_ReleaseInterfaces (D.21851);
  <D.21850>:
  D.21842 = ref_count;
  return D.21842;
}


ves_icall_System_Runtime_InteropServices_Marshal_GetComSlotForMethodInfoInternal (struct MonoReflectionMethod * m)
{
  guint32 D.21853;
  struct MonoMethod * D.21854;
  int D.21855;

  D.21854 = m->method;
  D.21855 = cominterop_get_com_slot_for_method (D.21854);
  D.21853 = (guint32) D.21855;
  return D.21853;
}


ves_icall_System_ComObject_CreateRCW (struct MonoReflectionType * type)
{
  struct MonoVTable * D.21857;
  struct MonoType * D.21858;
  struct MonoVTable * D.21859;
  struct MonoObject * D.21860;
  struct MonoClass * klass;
  struct MonoDomain * domain;
  struct MonoObject * obj;

  D.21857 = MEM[(struct MonoObject *)type].vtable;
  domain = D.21857->domain;
  D.21858 = type->type;
  klass = mono_class_from_mono_type (D.21858);
  D.21859 = mono_class_vtable_full (domain, klass, 1);
  obj = mono_object_new_alloc_specific (D.21859);
  D.21860 = obj;
  return D.21860;
}


ves_icall_System_ComObject_ReleaseInterfaces (struct MonoComObject * obj)
{
  _Bool D.21862;
  long int D.21863;
  long int D.21864;
  struct GHashTable * D.21867;
  _Bool D.21872;
  long int D.21873;
  long int D.21874;
  struct GHashTable * rcw_hash.116;
  void * D.21878;
  void * D.21879;
  long int D.21880;
  _Bool D.21885;
  long int D.21886;
  long int D.21887;

  D.21862 = obj == 0B;
  D.21863 = (long int) D.21862;
  D.21864 = __builtin_expect (D.21863, 0);
  if (D.21864 != 0) goto <D.21865>; else goto <D.21866>;
  <D.21865>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "cominterop.c", 1625, "obj");
  <D.21866>:
  D.21867 = obj->itf_hash;
  if (D.21867 != 0B) goto <D.21868>; else goto <D.21869>;
  <D.21868>:
  {
    guint32 gchandle;

    gchandle = 0;
    {
      int ret;

      ret = pthread_mutex_lock (&cominterop_mutex.mutex);
      if (ret != 0) goto <D.21870>; else goto <D.21871>;
      <D.21870>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
      <D.21871>:
      D.21872 = ret != 0;
      D.21873 = (long int) D.21872;
      D.21874 = __builtin_expect (D.21873, 0);
      if (D.21874 != 0) goto <D.21875>; else goto <D.21876>;
      <D.21875>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "cominterop.c", 1628, "ret == 0");
      <D.21876>:
    }
    rcw_hash.116 = rcw_hash;
    D.21878 = obj->iunknown;
    D.21879 = monoeg_g_hash_table_lookup (rcw_hash.116, D.21878);
    D.21880 = (long int) D.21879;
    gchandle = (guint32) D.21880;
    if (gchandle != 0) goto <D.21881>; else goto <D.21882>;
    <D.21881>:
    mono_gchandle_free (gchandle);
    rcw_hash.116 = rcw_hash;
    D.21878 = obj->iunknown;
    monoeg_g_hash_table_remove (rcw_hash.116, D.21878);
    <D.21882>:
    D.21867 = obj->itf_hash;
    monoeg_g_hash_table_foreach_remove (D.21867, cominterop_rcw_interface_finalizer, 0B);
    D.21867 = obj->itf_hash;
    monoeg_g_hash_table_destroy (D.21867);
    D.21878 = obj->iunknown;
    ves_icall_System_Runtime_InteropServices_Marshal_ReleaseInternal (D.21878);
    obj->iunknown = 0B;
    obj->itf_hash = 0B;
    {
      int ret;

      ret = pthread_mutex_unlock (&cominterop_mutex.mutex);
      if (ret != 0) goto <D.21883>; else goto <D.21884>;
      <D.21883>:
      monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
      <D.21884>:
      D.21885 = ret != 0;
      D.21886 = (long int) D.21885;
      D.21887 = __builtin_expect (D.21886, 0);
      if (D.21887 != 0) goto <D.21888>; else goto <D.21889>;
      <D.21888>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "cominterop.c", 1639, "ret == 0");
      <D.21889>:
    }
  }
  <D.21869>:
}


cominterop_rcw_interface_finalizer (void * key, void * value, void * user_data)
{
  gboolean D.21890;

  ves_icall_System_Runtime_InteropServices_Marshal_ReleaseInternal (value);
  D.21890 = 1;
  return D.21890;
}


cominterop_release_all_rcws ()
{
  struct GHashTable * rcw_hash.117;
  _Bool D.21897;
  long int D.21898;
  long int D.21899;
  _Bool D.21904;
  long int D.21905;
  long int D.21906;

  rcw_hash.117 = rcw_hash;
  if (rcw_hash.117 == 0B) goto <D.21893>; else goto <D.21894>;
  <D.21893>:
  return;
  <D.21894>:
  {
    int ret;

    ret = pthread_mutex_lock (&cominterop_mutex.mutex);
    if (ret != 0) goto <D.21895>; else goto <D.21896>;
    <D.21895>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.21896>:
    D.21897 = ret != 0;
    D.21898 = (long int) D.21897;
    D.21899 = __builtin_expect (D.21898, 0);
    if (D.21899 != 0) goto <D.21900>; else goto <D.21901>;
    <D.21900>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "cominterop.c", 1674, "ret == 0");
    <D.21901>:
  }
  rcw_hash.117 = rcw_hash;
  monoeg_g_hash_table_foreach_remove (rcw_hash.117, cominterop_rcw_finalizer, 0B);
  rcw_hash.117 = rcw_hash;
  monoeg_g_hash_table_destroy (rcw_hash.117);
  rcw_hash = 0B;
  {
    int ret;

    ret = pthread_mutex_unlock (&cominterop_mutex.mutex);
    if (ret != 0) goto <D.21902>; else goto <D.21903>;
    <D.21902>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.21903>:
    D.21904 = ret != 0;
    D.21905 = (long int) D.21904;
    D.21906 = __builtin_expect (D.21905, 0);
    if (D.21906 != 0) goto <D.21907>; else goto <D.21908>;
    <D.21907>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "cominterop.c", 1680, "ret == 0");
    <D.21908>:
  }
}


cominterop_rcw_finalizer (void * key, void * value, void * user_data)
{
  long int value.118;
  struct MonoComObject * D.21915;
  struct GHashTable * D.21916;
  void * D.21919;
  gboolean D.21922;
  guint32 gchandle;

  gchandle = 0;
  value.118 = (long int) value;
  gchandle = (guint32) value.118;
  if (gchandle != 0) goto <D.21911>; else goto <D.21912>;
  <D.21911>:
  {
    struct MonoComInteropProxy * proxy;

    proxy = mono_gchandle_get_target (gchandle);
    if (proxy != 0B) goto <D.21913>; else goto <D.21914>;
    <D.21913>:
    D.21915 = proxy->com_object;
    D.21916 = D.21915->itf_hash;
    if (D.21916 != 0B) goto <D.21917>; else goto <D.21918>;
    <D.21917>:
    D.21915 = proxy->com_object;
    D.21916 = D.21915->itf_hash;
    monoeg_g_hash_table_foreach_remove (D.21916, cominterop_rcw_interface_finalizer, 0B);
    D.21915 = proxy->com_object;
    D.21916 = D.21915->itf_hash;
    monoeg_g_hash_table_destroy (D.21916);
    <D.21918>:
    D.21915 = proxy->com_object;
    D.21919 = D.21915->iunknown;
    if (D.21919 != 0B) goto <D.21920>; else goto <D.21921>;
    <D.21920>:
    D.21915 = proxy->com_object;
    D.21919 = D.21915->iunknown;
    ves_icall_System_Runtime_InteropServices_Marshal_ReleaseInternal (D.21919);
    <D.21921>:
    D.21915 = proxy->com_object;
    D.21915->iunknown = 0B;
    D.21915 = proxy->com_object;
    D.21915->itf_hash = 0B;
    <D.21914>:
    mono_gchandle_free (gchandle);
  }
  <D.21912>:
  D.21922 = 1;
  return D.21922;
}


ves_icall_System_ComObject_GetInterfaceInternal (struct MonoComObject * obj, struct MonoReflectionType * type, MonoBoolean throw_exception)
{
  struct MonoType * D.21924;
  int D.21925;
  struct MonoException * D.21928;
  void * D.21929;
  int D.21930;
  struct MonoClass * class;

  D.21924 = type->type;
  class = mono_type_get_class (D.21924);
  D.21925 = mono_class_init (class);
  if (D.21925 == 0) goto <D.21926>; else goto <D.21927>;
  <D.21926>:
  D.21928 = mono_class_get_exception_for_failure (class);
  mono_raise_exception (D.21928);
  <D.21927>:
  D.21930 = (int) throw_exception;
  D.21929 = cominterop_get_interface (obj, class, D.21930);
  return D.21929;
}


ves_icall_Mono_Interop_ComInteropProxy_AddProxy (void * pUnk, struct MonoComInteropProxy * proxy)
{
  struct GHashTable * rcw_hash.119;
  _Bool D.21937;
  long int D.21938;
  long int D.21939;
  struct GHashTable * rcw_hash.120;
  _Bool D.21945;
  long int D.21946;
  long int D.21947;
  _Bool D.21952;
  long int D.21953;
  long int D.21954;
  long unsigned int D.21957;
  void * D.21958;
  _Bool D.21961;
  long int D.21962;
  long int D.21963;
  guint32 gchandle;

  gchandle = 0;
  rcw_hash.119 = rcw_hash;
  if (rcw_hash.119 == 0B) goto <D.21933>; else goto <D.21934>;
  <D.21933>:
  {
    int ret;

    ret = pthread_mutex_lock (&cominterop_mutex.mutex);
    if (ret != 0) goto <D.21935>; else goto <D.21936>;
    <D.21935>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.21936>:
    D.21937 = ret != 0;
    D.21938 = (long int) D.21937;
    D.21939 = __builtin_expect (D.21938, 0);
    if (D.21939 != 0) goto <D.21940>; else goto <D.21941>;
    <D.21940>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "cominterop.c", 1703, "ret == 0");
    <D.21941>:
  }
  rcw_hash.120 = monoeg_g_hash_table_new (mono_aligned_addr_hash, 0B);
  rcw_hash = rcw_hash.120;
  {
    int ret;

    ret = pthread_mutex_unlock (&cominterop_mutex.mutex);
    if (ret != 0) goto <D.21943>; else goto <D.21944>;
    <D.21943>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.21944>:
    D.21945 = ret != 0;
    D.21946 = (long int) D.21945;
    D.21947 = __builtin_expect (D.21946, 0);
    if (D.21947 != 0) goto <D.21948>; else goto <D.21949>;
    <D.21948>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "cominterop.c", 1705, "ret == 0");
    <D.21949>:
  }
  <D.21934>:
  gchandle = mono_gchandle_new_weakref (proxy, 0);
  {
    int ret;

    ret = pthread_mutex_lock (&cominterop_mutex.mutex);
    if (ret != 0) goto <D.21950>; else goto <D.21951>;
    <D.21950>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.21951>:
    D.21952 = ret != 0;
    D.21953 = (long int) D.21952;
    D.21954 = __builtin_expect (D.21953, 0);
    if (D.21954 != 0) goto <D.21955>; else goto <D.21956>;
    <D.21955>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "cominterop.c", 1710, "ret == 0");
    <D.21956>:
  }
  rcw_hash.119 = rcw_hash;
  D.21957 = (long unsigned int) gchandle;
  D.21958 = (void *) D.21957;
  monoeg_g_hash_table_insert_replace (rcw_hash.119, pUnk, D.21958, 0);
  {
    int ret;

    ret = pthread_mutex_unlock (&cominterop_mutex.mutex);
    if (ret != 0) goto <D.21959>; else goto <D.21960>;
    <D.21959>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.21960>:
    D.21961 = ret != 0;
    D.21962 = (long int) D.21961;
    D.21963 = __builtin_expect (D.21962, 0);
    if (D.21963 != 0) goto <D.21964>; else goto <D.21965>;
    <D.21964>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "cominterop.c", 1712, "ret == 0");
    <D.21965>:
  }
}


ves_icall_Mono_Interop_ComInteropProxy_FindProxy (void * pUnk)
{
  _Bool D.21968;
  long int D.21969;
  long int D.21970;
  struct GHashTable * rcw_hash.121;
  void * D.21976;
  long int D.21977;
  _Bool D.21980;
  long int D.21981;
  long int D.21982;
  struct MonoComInteropProxy * D.21989;
  struct MonoComInteropProxy * proxy;
  guint32 gchandle;

  proxy = 0B;
  gchandle = 0;
  {
    int ret;

    ret = pthread_mutex_lock (&cominterop_mutex.mutex);
    if (ret != 0) goto <D.21966>; else goto <D.21967>;
    <D.21966>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.21967>:
    D.21968 = ret != 0;
    D.21969 = (long int) D.21968;
    D.21970 = __builtin_expect (D.21969, 0);
    if (D.21970 != 0) goto <D.21971>; else goto <D.21972>;
    <D.21971>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "cominterop.c", 1725, "ret == 0");
    <D.21972>:
  }
  rcw_hash.121 = rcw_hash;
  if (rcw_hash.121 != 0B) goto <D.21974>; else goto <D.21975>;
  <D.21974>:
  rcw_hash.121 = rcw_hash;
  D.21976 = monoeg_g_hash_table_lookup (rcw_hash.121, pUnk);
  D.21977 = (long int) D.21976;
  gchandle = (guint32) D.21977;
  <D.21975>:
  {
    int ret;

    ret = pthread_mutex_unlock (&cominterop_mutex.mutex);
    if (ret != 0) goto <D.21978>; else goto <D.21979>;
    <D.21978>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.21979>:
    D.21980 = ret != 0;
    D.21981 = (long int) D.21980;
    D.21982 = __builtin_expect (D.21981, 0);
    if (D.21982 != 0) goto <D.21983>; else goto <D.21984>;
    <D.21983>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "cominterop.c", 1728, "ret == 0");
    <D.21984>:
  }
  if (gchandle != 0) goto <D.21985>; else goto <D.21986>;
  <D.21985>:
  proxy = mono_gchandle_get_target (gchandle);
  if (proxy == 0B) goto <D.21987>; else goto <D.21988>;
  <D.21987>:
  mono_gchandle_free (gchandle);
  rcw_hash.121 = rcw_hash;
  monoeg_g_hash_table_remove (rcw_hash.121, pUnk);
  <D.21988>:
  <D.21986>:
  D.21989 = proxy;
  return D.21989;
}


mono_marshal_free_ccw (struct MonoObject * object)
{
  struct GHashTable * ccw_hash.122;
  unsigned int D.21995;
  gboolean D.21996;
  _Bool D.21999;
  long int D.22000;
  long int D.22001;
  int D.22004;
  long int D.22005;
  const void * D.22006;
  _Bool D.22009;
  long int D.22010;
  long int D.22011;
  unsigned int D.22016;
  struct GHashTable * D.22021;
  struct GList * iftmp.123;
  struct GList * iftmp.124;
  unsigned int D.22030;
  int D.22033;
  long int D.22034;
  const void * D.22035;
  struct GList * ccw_list;
  struct GList * ccw_list_orig;
  struct GList * ccw_list_item;

  ccw_hash.122 = ccw_hash;
  if (ccw_hash.122 == 0B) goto <D.21991>; else goto <D.21994>;
  <D.21994>:
  ccw_hash.122 = ccw_hash;
  D.21995 = monoeg_g_hash_table_size (ccw_hash.122);
  if (D.21995 == 0) goto <D.21991>; else goto <D.21992>;
  <D.21991>:
  D.21996 = 0;
  return D.21996;
  <D.21992>:
  {
    int ret;

    ret = pthread_mutex_lock (&cominterop_mutex.mutex);
    if (ret != 0) goto <D.21997>; else goto <D.21998>;
    <D.21997>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.21998>:
    D.21999 = ret != 0;
    D.22000 = (long int) D.21999;
    D.22001 = __builtin_expect (D.22000, 0);
    if (D.22001 != 0) goto <D.22002>; else goto <D.22003>;
    <D.22002>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "cominterop.c", 2050, "ret == 0");
    <D.22003>:
  }
  ccw_hash.122 = ccw_hash;
  D.22004 = mono_object_hash (object);
  D.22005 = (long int) D.22004;
  D.22006 = (const void *) D.22005;
  ccw_list_orig = monoeg_g_hash_table_lookup (ccw_hash.122, D.22006);
  ccw_list = ccw_list_orig;
  {
    int ret;

    ret = pthread_mutex_unlock (&cominterop_mutex.mutex);
    if (ret != 0) goto <D.22007>; else goto <D.22008>;
    <D.22007>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.22008>:
    D.22009 = ret != 0;
    D.22010 = (long int) D.22009;
    D.22011 = __builtin_expect (D.22010, 0);
    if (D.22011 != 0) goto <D.22012>; else goto <D.22013>;
    <D.22012>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "cominterop.c", 2052, "ret == 0");
    <D.22013>:
  }
  if (ccw_list == 0B) goto <D.22014>; else goto <D.22015>;
  <D.22014>:
  D.21996 = 0;
  return D.21996;
  <D.22015>:
  ccw_list_item = ccw_list;
  goto <D.19752>;
  <D.19751>:
  {
    struct MonoCCW * ccw_iter;
    struct MonoObject * handle_target;

    ccw_iter = ccw_list_item->data;
    D.22016 = ccw_iter->gc_handle;
    handle_target = mono_gchandle_get_target (D.22016);
    if (handle_target == 0B) goto <D.22017>; else goto <D.22020>;
    <D.22020>:
    if (handle_target == object) goto <D.22017>; else goto <D.22018>;
    <D.22017>:
    D.22021 = ccw_iter->vtable_hash;
    monoeg_g_hash_table_foreach_remove (D.22021, mono_marshal_free_ccw_entry, 0B);
    D.22021 = ccw_iter->vtable_hash;
    monoeg_g_hash_table_destroy (D.22021);
    if (ccw_list_item != 0B) goto <D.22023>; else goto <D.22024>;
    <D.22023>:
    iftmp.123 = ccw_list_item->next;
    goto <D.22025>;
    <D.22024>:
    iftmp.123 = 0B;
    <D.22025>:
    ccw_list_item = iftmp.123;
    ccw_list = monoeg_g_list_remove (ccw_list, ccw_iter);
    monoeg_g_free (ccw_iter);
    goto <D.22019>;
    <D.22018>:
    if (ccw_list_item != 0B) goto <D.22027>; else goto <D.22028>;
    <D.22027>:
    iftmp.124 = ccw_list_item->next;
    goto <D.22029>;
    <D.22028>:
    iftmp.124 = 0B;
    <D.22029>:
    ccw_list_item = iftmp.124;
    <D.22019>:
  }
  <D.19752>:
  if (ccw_list_item != 0B) goto <D.19751>; else goto <D.19753>;
  <D.19753>:
  D.22030 = monoeg_g_list_length (ccw_list);
  if (D.22030 == 0) goto <D.22031>; else goto <D.22032>;
  <D.22031>:
  ccw_hash.122 = ccw_hash;
  D.22033 = mono_object_hash (object);
  D.22034 = (long int) D.22033;
  D.22035 = (const void *) D.22034;
  monoeg_g_hash_table_remove (ccw_hash.122, D.22035);
  <D.22032>:
  D.21996 = 1;
  return D.21996;
}


mono_marshal_free_ccw_entry (void * key, void * value, void * user_data)
{
  struct GHashTable * ccw_interface_hash.125;
  _Bool D.22038;
  long int D.22039;
  long int D.22040;
  gboolean D.22043;

  ccw_interface_hash.125 = ccw_interface_hash;
  monoeg_g_hash_table_remove (ccw_interface_hash.125, value);
  D.22038 = value == 0B;
  D.22039 = (long int) D.22038;
  D.22040 = __builtin_expect (D.22039, 0);
  if (D.22040 != 0) goto <D.22041>; else goto <D.22042>;
  <D.22041>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "cominterop.c", 2030, "value");
  <D.22042>:
  monoeg_g_free (value);
  D.22043 = 1;
  return D.22043;
}


mono_string_to_bstr (struct MonoString * string_obj)
{
  void * D.22047;
  <unnamed type> com_provider.126;
  int D.22051;
  long unsigned int D.22052;
  long unsigned int D.22053;
  long unsigned int D.22054;
  char * D.22057;
  mono_unichar2 * D.22058;
  long unsigned int D.22059;
  long unsigned int D.22060;
  unsigned int D.22061;
  unsigned int D.22062;
  long unsigned int D.22063;
  long unsigned int D.22064;
  char * D.22065;
  long unsigned int D.22066;
  char * D.22067;
  int D.22070;
  int D.22072;
  mono_unichar2 * D.22073;
  long int D.22074;
  void * (*<T3452>) (gunichar *, guint32) sys_alloc_string_len_ms.127;

  if (string_obj == 0B) goto <D.22045>; else goto <D.22046>;
  <D.22045>:
  D.22047 = 0B;
  return D.22047;
  <D.22046>:
  com_provider.126 = com_provider;
  if (com_provider.126 == 0) goto <D.22049>; else goto <D.22050>;
  <D.22049>:
  {
    int slen;
    char * ret;

    slen = mono_string_length (string_obj);
    D.22051 = slen + 1;
    D.22052 = (long unsigned int) D.22051;
    D.22053 = D.22052 + 2;
    D.22054 = D.22053 * 2;
    ret = monoeg_malloc (D.22054);
    if (ret == 0B) goto <D.22055>; else goto <D.22056>;
    <D.22055>:
    D.22047 = 0B;
    return D.22047;
    <D.22056>:
    D.22057 = ret + 4;
    D.22058 = mono_string_chars (string_obj);
    D.22059 = (long unsigned int) slen;
    D.22060 = D.22059 * 2;
    memcpy (D.22057, D.22058, D.22060);
    D.22059 = (long unsigned int) slen;
    D.22061 = (unsigned int) D.22059;
    D.22062 = D.22061 * 2;
    MEM[(guint32 *)ret] = D.22062;
    D.22059 = (long unsigned int) slen;
    D.22063 = D.22059 + 2;
    D.22064 = D.22063 * 2;
    D.22065 = ret + D.22064;
    *D.22065 = 0;
    D.22059 = (long unsigned int) slen;
    D.22060 = D.22059 * 2;
    D.22066 = D.22060 + 5;
    D.22067 = ret + D.22066;
    *D.22067 = 0;
    D.22047 = ret + 4;
    return D.22047;
  }
  <D.22050>:
  com_provider.126 = com_provider;
  if (com_provider.126 == 1) goto <D.22069>; else goto <D.22068>;
  <D.22069>:
  D.22070 = init_com_provider_ms ();
  if (D.22070 != 0) goto <D.22071>; else goto <D.22068>;
  <D.22071>:
  {
    void * ret;
    gunichar * str;
    guint32 len;

    ret = 0B;
    str = 0B;
    D.22072 = mono_string_length (string_obj);
    len = (guint32) D.22072;
    D.22073 = mono_string_chars (string_obj);
    D.22074 = (long int) len;
    str = monoeg_g_utf16_to_ucs4 (D.22073, D.22074, 0B, 0B, 0B);
    sys_alloc_string_len_ms.127 = sys_alloc_string_len_ms;
    ret = sys_alloc_string_len_ms.127 (str, len);
    monoeg_g_free (str);
    D.22047 = ret;
    return D.22047;
  }
  <D.22068>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "cominterop.c", 2605);
}


mono_string_from_bstr (void * bstr)
{
  struct MonoString * D.22079;
  <unnamed type> com_provider.128;
  struct MonoDomain * D.22083;
  guint32 * D.22084;
  unsigned int D.22085;
  unsigned int D.22086;
  int D.22087;
  int D.22090;
  guint32 (*<T184b>) (void *) sys_string_len_ms.129;
  unsigned int D.22093;
  long int D.22094;
  struct MonoDomain * D.22095;
  long int written.130;
  int D.22097;

  if (bstr == 0B) goto <D.22077>; else goto <D.22078>;
  <D.22077>:
  D.22079 = 0B;
  return D.22079;
  <D.22078>:
  com_provider.128 = com_provider;
  if (com_provider.128 == 0) goto <D.22081>; else goto <D.22082>;
  <D.22081>:
  D.22083 = mono_domain_get ();
  D.22084 = bstr + 18446744073709551612;
  D.22085 = *D.22084;
  D.22086 = D.22085 / 2;
  D.22087 = (int) D.22086;
  D.22079 = mono_string_new_utf16 (D.22083, bstr, D.22087);
  return D.22079;
  <D.22082>:
  com_provider.128 = com_provider;
  if (com_provider.128 == 1) goto <D.22089>; else goto <D.22088>;
  <D.22089>:
  D.22090 = init_com_provider_ms ();
  if (D.22090 != 0) goto <D.22091>; else goto <D.22088>;
  <D.22091>:
  {
    struct MonoString * str;
    glong written;
    gunichar2 * utf16;

    try
      {
        str = 0B;
        written = 0;
        utf16 = 0B;
        sys_string_len_ms.129 = sys_string_len_ms;
        D.22093 = sys_string_len_ms.129 (bstr);
        D.22094 = (long int) D.22093;
        utf16 = monoeg_g_ucs4_to_utf16 (bstr, D.22094, 0B, &written, 0B);
        D.22095 = mono_domain_get ();
        written.130 = written;
        D.22097 = (int) written.130;
        str = mono_string_new_utf16 (D.22095, utf16, D.22097);
        monoeg_g_free (utf16);
        D.22079 = str;
        return D.22079;
      }
    finally
      {
        written = {CLOBBER};
      }
  }
  <D.22088>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "cominterop.c", 2630);
}


mono_free_bstr (void * bstr)
{
  <unnamed type> com_provider.131;
  void * D.22105;
  int D.22110;
  void (*<T345a>) (gunichar *) sys_free_string_ms.132;

  if (bstr == 0B) goto <D.22100>; else goto <D.22101>;
  <D.22100>:
  return;
  <D.22101>:
  com_provider.131 = com_provider;
  if (com_provider.131 == 0) goto <D.22103>; else goto <D.22104>;
  <D.22103>:
  D.22105 = bstr + 18446744073709551612;
  monoeg_g_free (D.22105);
  goto <D.22106>;
  <D.22104>:
  com_provider.131 = com_provider;
  if (com_provider.131 == 1) goto <D.22109>; else goto <D.22107>;
  <D.22109>:
  D.22110 = init_com_provider_ms ();
  if (D.22110 != 0) goto <D.22111>; else goto <D.22107>;
  <D.22111>:
  sys_free_string_ms.132 = sys_free_string_ms;
  sys_free_string_ms.132 (bstr);
  goto <D.22108>;
  <D.22107>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "cominterop.c", 2649);
  <D.22108>:
  <D.22106>:
}


mono_cominterop_emit_marshal_safearray (struct EmitMarshalContext * m, int argnum, struct MonoType * t, struct MonoMarshalSpec * spec, int conv_arg, struct MonoType * * conv_arg_type, MarshalAction action)
{
  short unsigned int D.22114;
  int D.22115;
  int D.22116;
  struct MonoClass * D.22119;
  struct MonoType * D.22120;
  struct MonoClass * D.22121;
  struct MonoType * D.22122;
  long unsigned int D.22123;
  long unsigned int D.22124;
  unsigned int argnum.133;
  unsigned int safearray_var.134;
  unsigned int indices_var.135;
  unsigned int empty_var.136;
  struct MonoClass * D.22132;
  struct MonoType * D.22133;
  unsigned int index_var.137;
  int D.22135;
  struct MonoMethod * get_value_impl.138;
  struct MonoClass * D.22139;
  struct MonoMethod * get_value_impl.139;
  _Bool D.22141;
  long int D.22142;
  long int D.22143;
  struct MonoMethod * get_native_variant_for_object.140;
  struct MonoClass * D.22152;
  struct MonoMethod * get_native_variant_for_object.141;
  _Bool D.22154;
  long int D.22155;
  long int D.22156;
  struct MonoClass * D.22159;
  struct MonoType * D.22160;
  unsigned int elem_var.142;
  struct MonoMethod * variant_clear.143;
  struct MonoClass * D.22165;
  struct MonoMethod * variant_clear.144;
  short unsigned int D.22167;
  unsigned int conv_arg.145;
  int D.22172;
  int iftmp.146;
  unsigned int result_var.147;
  unsigned int indices_var.148;
  unsigned int empty_var.149;
  unsigned int index_var.150;
  int D.22187;
  struct MonoMethod * get_object_for_native_variant.151;
  struct MonoMethod * get_object_for_native_variant.152;
  _Bool D.22194;
  long int D.22195;
  long int D.22196;
  struct MonoMethod * set_value_impl.153;
  struct MonoMethod * set_value_impl.154;
  _Bool D.22203;
  long int D.22204;
  long int D.22205;
  unsigned int elem_var.155;
  short unsigned int D.22211;
  int D.22214;
  struct MonoMethodBuilder * mb;

  mb = m->mb;
  switch (action) <default: <D.19973>, case 0: <D.19946>, case 1: <D.19959>, case 2: <D.19960>>
  <D.19946>:
  D.22114 = t->attrs;
  D.22115 = (int) D.22114;
  D.22116 = D.22115 & 1;
  if (D.22116 != 0) goto <D.22117>; else goto <D.22118>;
  <D.22117>:
  {
    int safearray_var;
    int indices_var;
    int empty_var;
    int elem_var;
    int index_var;
    guint32 label1;
    guint32 label2;
    guint32 label3;
    static struct MonoMethod * get_native_variant_for_object = 0B;
    static struct MonoMethod * get_value_impl = 0B;
    static struct MonoMethod * variant_clear = 0B;

    label1 = 0;
    label2 = 0;
    label3 = 0;
    D.22119 = mono_defaults.object_class;
    D.22120 = &D.22119->byval_arg;
    safearray_var = mono_mb_add_local (mb, D.22120);
    conv_arg = safearray_var;
    D.22121 = mono_defaults.int_class;
    D.22122 = &D.22121->byval_arg;
    indices_var = mono_mb_add_local (mb, D.22122);
    D.22121 = mono_defaults.int_class;
    D.22122 = &D.22121->byval_arg;
    empty_var = mono_mb_add_local (mb, D.22122);
    D.22123 = BIT_FIELD_REF <*t, 64, 64>;
    D.22124 = D.22123 & 1073741824;
    if (D.22124 != 0) goto <D.22125>; else goto <D.22126>;
    <D.22125>:
    argnum.133 = (unsigned int) argnum;
    mono_mb_emit_ldarg (mb, argnum.133);
    mono_mb_emit_byte (mb, 80);
    goto <D.22128>;
    <D.22126>:
    argnum.133 = (unsigned int) argnum;
    mono_mb_emit_ldarg (mb, argnum.133);
    <D.22128>:
    safearray_var.134 = (unsigned int) safearray_var;
    mono_mb_emit_ldloc_addr (mb, safearray_var.134);
    indices_var.135 = (unsigned int) indices_var;
    mono_mb_emit_ldloc_addr (mb, indices_var.135);
    empty_var.136 = (unsigned int) empty_var;
    mono_mb_emit_ldloc_addr (mb, empty_var.136);
    mono_mb_emit_icall (mb, mono_marshal_safearray_create);
    label1 = mono_mb_emit_short_branch (mb, 44);
    empty_var.136 = (unsigned int) empty_var;
    mono_mb_emit_ldloc (mb, empty_var.136);
    label2 = mono_mb_emit_short_branch (mb, 45);
    D.22132 = mono_defaults.int32_class;
    D.22133 = &D.22132->byval_arg;
    index_var = mono_mb_add_local (mb, D.22133);
    mono_mb_emit_byte (mb, 22);
    index_var.137 = (unsigned int) index_var;
    mono_mb_emit_stloc (mb, index_var.137);
    D.22135 = mono_mb_get_label (mb);
    label3 = (guint32) D.22135;
    get_value_impl.138 = get_value_impl;
    if (get_value_impl.138 == 0B) goto <D.22137>; else goto <D.22138>;
    <D.22137>:
    D.22139 = mono_defaults.array_class;
    get_value_impl.139 = mono_class_get_method_from_name (D.22139, "GetValueImpl", 1);
    get_value_impl = get_value_impl.139;
    <D.22138>:
    get_value_impl.138 = get_value_impl;
    D.22141 = get_value_impl.138 == 0B;
    D.22142 = (long int) D.22141;
    D.22143 = __builtin_expect (D.22142, 0);
    if (D.22143 != 0) goto <D.22144>; else goto <D.22145>;
    <D.22144>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "cominterop.c", 2725, "get_value_impl");
    <D.22145>:
    D.22123 = BIT_FIELD_REF <*t, 64, 64>;
    D.22124 = D.22123 & 1073741824;
    if (D.22124 != 0) goto <D.22146>; else goto <D.22147>;
    <D.22146>:
    argnum.133 = (unsigned int) argnum;
    mono_mb_emit_ldarg (mb, argnum.133);
    mono_mb_emit_byte (mb, 80);
    goto <D.22148>;
    <D.22147>:
    argnum.133 = (unsigned int) argnum;
    mono_mb_emit_ldarg (mb, argnum.133);
    <D.22148>:
    index_var.137 = (unsigned int) index_var;
    mono_mb_emit_ldloc (mb, index_var.137);
    get_value_impl.138 = get_value_impl;
    mono_mb_emit_managed_call (mb, get_value_impl.138, 0B);
    get_native_variant_for_object.140 = get_native_variant_for_object;
    if (get_native_variant_for_object.140 == 0B) goto <D.22150>; else goto <D.22151>;
    <D.22150>:
    D.22152 = mono_defaults.marshal_class;
    get_native_variant_for_object.141 = mono_class_get_method_from_name (D.22152, "GetNativeVariantForObject", 2);
    get_native_variant_for_object = get_native_variant_for_object.141;
    <D.22151>:
    get_native_variant_for_object.140 = get_native_variant_for_object;
    D.22154 = get_native_variant_for_object.140 == 0B;
    D.22155 = (long int) D.22154;
    D.22156 = __builtin_expect (D.22155, 0);
    if (D.22156 != 0) goto <D.22157>; else goto <D.22158>;
    <D.22157>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "cominterop.c", 2739, "get_native_variant_for_object");
    <D.22158>:
    D.22159 = mono_class_get_variant_class ();
    D.22160 = &D.22159->byval_arg;
    elem_var = mono_mb_add_local (mb, D.22160);
    elem_var.142 = (unsigned int) elem_var;
    mono_mb_emit_ldloc_addr (mb, elem_var.142);
    get_native_variant_for_object.140 = get_native_variant_for_object;
    mono_mb_emit_managed_call (mb, get_native_variant_for_object.140, 0B);
    safearray_var.134 = (unsigned int) safearray_var;
    mono_mb_emit_ldloc (mb, safearray_var.134);
    indices_var.135 = (unsigned int) indices_var;
    mono_mb_emit_ldloc (mb, indices_var.135);
    elem_var.142 = (unsigned int) elem_var;
    mono_mb_emit_ldloc_addr (mb, elem_var.142);
    mono_mb_emit_icall (mb, mono_marshal_safearray_set_value);
    variant_clear.143 = variant_clear;
    if (variant_clear.143 == 0B) goto <D.22163>; else goto <D.22164>;
    <D.22163>:
    D.22165 = mono_class_get_variant_class ();
    variant_clear.144 = mono_class_get_method_from_name (D.22165, "Clear", 0);
    variant_clear = variant_clear.144;
    <D.22164>:
    elem_var.142 = (unsigned int) elem_var;
    mono_mb_emit_ldloc_addr (mb, elem_var.142);
    variant_clear.143 = variant_clear;
    mono_mb_emit_managed_call (mb, variant_clear.143, 0B);
    D.22167 = (short unsigned int) index_var;
    mono_mb_emit_add_to_local (mb, D.22167, 1);
    safearray_var.134 = (unsigned int) safearray_var;
    mono_mb_emit_ldloc (mb, safearray_var.134);
    indices_var.135 = (unsigned int) indices_var;
    mono_mb_emit_ldloc (mb, indices_var.135);
    mono_mb_emit_icall (mb, mono_marshal_safearray_next);
    mono_mb_emit_branch_label (mb, 58, label3);
    mono_mb_patch_short_branch (mb, label2);
    indices_var.135 = (unsigned int) indices_var;
    mono_mb_emit_ldloc (mb, indices_var.135);
    mono_mb_emit_icall (mb, mono_marshal_safearray_free_indices);
    mono_mb_patch_short_branch (mb, label1);
  }
  <D.22118>:
  goto <D.19958>;
  <D.19959>:
  D.22123 = BIT_FIELD_REF <*t, 64, 64>;
  D.22124 = D.22123 & 1073741824;
  if (D.22124 != 0) goto <D.22168>; else goto <D.22169>;
  <D.22168>:
  conv_arg.145 = (unsigned int) conv_arg;
  mono_mb_emit_ldloc_addr (mb, conv_arg.145);
  goto <D.22171>;
  <D.22169>:
  conv_arg.145 = (unsigned int) conv_arg;
  mono_mb_emit_ldloc (mb, conv_arg.145);
  <D.22171>:
  goto <D.19958>;
  <D.19960>:
  D.22114 = t->attrs;
  D.22115 = (int) D.22114;
  D.22172 = D.22115 & 2;
  if (D.22172 != 0) goto <D.22173>; else goto <D.22174>;
  <D.22173>:
  {
    int result_var;
    int indices_var;
    int empty_var;
    int elem_var;
    int index_var;
    guint32 label1;
    guint32 label2;
    guint32 label3;
    guint32 label4;
    static struct MonoMethod * get_object_for_native_variant = 0B;
    static struct MonoMethod * set_value_impl = 0B;
    gboolean byValue;

    label1 = 0;
    label2 = 0;
    label3 = 0;
    label4 = 0;
    D.22123 = BIT_FIELD_REF <*t, 64, 64>;
    D.22124 = D.22123 & 1073741824;
    if (D.22124 == 0) goto <D.22178>; else goto <D.22176>;
    <D.22178>:
    D.22114 = t->attrs;
    D.22115 = (int) D.22114;
    D.22116 = D.22115 & 1;
    if (D.22116 != 0) goto <D.22179>; else goto <D.22176>;
    <D.22179>:
    iftmp.146 = 1;
    goto <D.22177>;
    <D.22176>:
    iftmp.146 = 0;
    <D.22177>:
    byValue = iftmp.146;
    D.22119 = mono_defaults.object_class;
    D.22120 = &D.22119->byval_arg;
    result_var = mono_mb_add_local (mb, D.22120);
    D.22121 = mono_defaults.int_class;
    D.22122 = &D.22121->byval_arg;
    indices_var = mono_mb_add_local (mb, D.22122);
    D.22121 = mono_defaults.int_class;
    D.22122 = &D.22121->byval_arg;
    empty_var = mono_mb_add_local (mb, D.22122);
    conv_arg.145 = (unsigned int) conv_arg;
    mono_mb_emit_ldloc (mb, conv_arg.145);
    result_var.147 = (unsigned int) result_var;
    mono_mb_emit_ldloc_addr (mb, result_var.147);
    indices_var.148 = (unsigned int) indices_var;
    mono_mb_emit_ldloc_addr (mb, indices_var.148);
    empty_var.149 = (unsigned int) empty_var;
    mono_mb_emit_ldloc_addr (mb, empty_var.149);
    argnum.133 = (unsigned int) argnum;
    mono_mb_emit_ldarg (mb, argnum.133);
    if (byValue != 0) goto <D.22183>; else goto <D.22184>;
    <D.22183>:
    mono_mb_emit_byte (mb, 22);
    goto <D.22185>;
    <D.22184>:
    mono_mb_emit_byte (mb, 23);
    <D.22185>:
    mono_mb_emit_icall (mb, mono_marshal_safearray_begin);
    label1 = mono_mb_emit_short_branch (mb, 44);
    empty_var.149 = (unsigned int) empty_var;
    mono_mb_emit_ldloc (mb, empty_var.149);
    label2 = mono_mb_emit_short_branch (mb, 45);
    D.22121 = mono_defaults.int_class;
    D.22122 = &D.22121->byval_arg;
    index_var = mono_mb_add_local (mb, D.22122);
    mono_mb_emit_byte (mb, 22);
    index_var.150 = (unsigned int) index_var;
    mono_mb_emit_stloc (mb, index_var.150);
    D.22187 = mono_mb_get_label (mb);
    label3 = (guint32) D.22187;
    if (byValue != 0) goto <D.22188>; else goto <D.22189>;
    <D.22188>:
    index_var.150 = (unsigned int) index_var;
    mono_mb_emit_ldloc (mb, index_var.150);
    argnum.133 = (unsigned int) argnum;
    mono_mb_emit_ldarg (mb, argnum.133);
    mono_mb_emit_byte (mb, 142);
    label4 = mono_mb_emit_branch (mb, 60);
    <D.22189>:
    conv_arg.145 = (unsigned int) conv_arg;
    mono_mb_emit_ldloc (mb, conv_arg.145);
    indices_var.148 = (unsigned int) indices_var;
    mono_mb_emit_ldloc (mb, indices_var.148);
    mono_mb_emit_icall (mb, mono_marshal_safearray_get_value);
    get_object_for_native_variant.151 = get_object_for_native_variant;
    if (get_object_for_native_variant.151 == 0B) goto <D.22191>; else goto <D.22192>;
    <D.22191>:
    D.22152 = mono_defaults.marshal_class;
    get_object_for_native_variant.152 = mono_class_get_method_from_name (D.22152, "GetObjectForNativeVariant", 1);
    get_object_for_native_variant = get_object_for_native_variant.152;
    <D.22192>:
    get_object_for_native_variant.151 = get_object_for_native_variant;
    D.22194 = get_object_for_native_variant.151 == 0B;
    D.22195 = (long int) D.22194;
    D.22196 = __builtin_expect (D.22195, 0);
    if (D.22196 != 0) goto <D.22197>; else goto <D.22198>;
    <D.22197>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "cominterop.c", 2854, "get_object_for_native_variant");
    <D.22198>:
    set_value_impl.153 = set_value_impl;
    if (set_value_impl.153 == 0B) goto <D.22200>; else goto <D.22201>;
    <D.22200>:
    D.22139 = mono_defaults.array_class;
    set_value_impl.154 = mono_class_get_method_from_name (D.22139, "SetValueImpl", 2);
    set_value_impl = set_value_impl.154;
    <D.22201>:
    set_value_impl.153 = set_value_impl;
    D.22203 = set_value_impl.153 == 0B;
    D.22204 = (long int) D.22203;
    D.22205 = __builtin_expect (D.22204, 0);
    if (D.22205 != 0) goto <D.22206>; else goto <D.22207>;
    <D.22206>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "cominterop.c", 2858, "set_value_impl");
    <D.22207>:
    D.22119 = mono_defaults.object_class;
    D.22120 = &D.22119->byval_arg;
    elem_var = mono_mb_add_local (mb, D.22120);
    get_object_for_native_variant.151 = get_object_for_native_variant;
    mono_mb_emit_managed_call (mb, get_object_for_native_variant.151, 0B);
    elem_var.155 = (unsigned int) elem_var;
    mono_mb_emit_stloc (mb, elem_var.155);
    result_var.147 = (unsigned int) result_var;
    mono_mb_emit_ldloc (mb, result_var.147);
    elem_var.155 = (unsigned int) elem_var;
    mono_mb_emit_ldloc (mb, elem_var.155);
    index_var.150 = (unsigned int) index_var;
    mono_mb_emit_ldloc (mb, index_var.150);
    set_value_impl.153 = set_value_impl;
    mono_mb_emit_managed_call (mb, set_value_impl.153, 0B);
    if (byValue != 0) goto <D.22209>; else goto <D.22210>;
    <D.22209>:
    mono_mb_patch_short_branch (mb, label4);
    <D.22210>:
    D.22211 = (short unsigned int) index_var;
    mono_mb_emit_add_to_local (mb, D.22211, 1);
    conv_arg.145 = (unsigned int) conv_arg;
    mono_mb_emit_ldloc (mb, conv_arg.145);
    indices_var.148 = (unsigned int) indices_var;
    mono_mb_emit_ldloc (mb, indices_var.148);
    mono_mb_emit_icall (mb, mono_marshal_safearray_next);
    mono_mb_emit_branch_label (mb, 58, label3);
    mono_mb_patch_short_branch (mb, label2);
    conv_arg.145 = (unsigned int) conv_arg;
    mono_mb_emit_ldloc (mb, conv_arg.145);
    indices_var.148 = (unsigned int) indices_var;
    mono_mb_emit_ldloc (mb, indices_var.148);
    mono_mb_emit_icall (mb, mono_marshal_safearray_end);
    mono_mb_patch_short_branch (mb, label1);
    if (byValue == 0) goto <D.22212>; else goto <D.22213>;
    <D.22212>:
    argnum.133 = (unsigned int) argnum;
    mono_mb_emit_ldarg (mb, argnum.133);
    result_var.147 = (unsigned int) result_var;
    mono_mb_emit_ldloc (mb, result_var.147);
    mono_mb_emit_byte (mb, 81);
    <D.22213>:
  }
  <D.22174>:
  goto <D.19958>;
  <D.19973>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "cominterop.c", 2898);
  <D.19958>:
  D.22214 = conv_arg;
  return D.22214;
}


ves_icall_System_Runtime_InteropServices_Marshal_PtrToStringBSTR (void * ptr)
{
  struct MonoString * D.22216;

  D.22216 = mono_string_from_bstr (ptr);
  return D.22216;
}


ves_icall_System_Runtime_InteropServices_Marshal_StringToBSTR (struct MonoString * ptr)
{
  void * D.22218;

  D.22218 = mono_string_to_bstr (ptr);
  return D.22218;
}


ves_icall_System_Runtime_InteropServices_Marshal_FreeBSTR (void * ptr)
{
  mono_free_bstr (ptr);
}