mono_create_static_rgctx_trampoline (struct MonoMethod * m, void * addr)
{
  union mono_mutex_t * D.22323;
  _Bool D.22326;
  long int D.22327;
  long int D.22328;
  void * D.22331;
  struct GHashTable * D.22332;
  struct GHashTable * D.22335;
  _Bool D.22338;
  long int D.22339;
  long int D.22340;
  void * D.22345;
  int mono_aot_only.0;
  _Bool D.22352;
  long int D.22353;
  long int D.22354;
  _Bool D.22359;
  long int D.22360;
  long int D.22361;
  unsigned int static_rgctx_trampolines.1;
  unsigned int static_rgctx_trampolines.2;
  void * ctx;
  void * res;
  struct MonoDomain * domain;
  struct RgctxTrampInfo tmp_info;
  struct RgctxTrampInfo * info;

  try
    {
      ctx = mini_method_get_rgctx (m);
      domain = mono_domain_get ();
      {
        int ret;

        D.22323 = &domain->lock.mutex;
        ret = pthread_mutex_lock (D.22323);
        if (ret != 0) goto <D.22324>; else goto <D.22325>;
        <D.22324>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.22325>:
        D.22326 = ret != 0;
        D.22327 = (long int) D.22326;
        D.22328 = __builtin_expect (D.22327, 0);
        if (D.22328 != 0) goto <D.22329>; else goto <D.22330>;
        <D.22329>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 96, "ret == 0");
        <D.22330>:
      }
      D.22331 = domain->runtime_info;
      D.22332 = MEM[(struct MonoJitDomainInfo *)D.22331].static_rgctx_trampoline_hash;
      if (D.22332 == 0B) goto <D.22333>; else goto <D.22334>;
      <D.22333>:
      D.22331 = domain->runtime_info;
      D.22335 = monoeg_g_hash_table_new (rgctx_tramp_info_hash, rgctx_tramp_info_equal);
      MEM[(struct MonoJitDomainInfo *)D.22331].static_rgctx_trampoline_hash = D.22335;
      <D.22334>:
      tmp_info.m = m;
      tmp_info.addr = addr;
      D.22331 = domain->runtime_info;
      D.22332 = MEM[(struct MonoJitDomainInfo *)D.22331].static_rgctx_trampoline_hash;
      res = monoeg_g_hash_table_lookup (D.22332, &tmp_info);
      {
        int ret;

        D.22323 = &domain->lock.mutex;
        ret = pthread_mutex_unlock (D.22323);
        if (ret != 0) goto <D.22336>; else goto <D.22337>;
        <D.22336>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.22337>:
        D.22338 = ret != 0;
        D.22339 = (long int) D.22338;
        D.22340 = __builtin_expect (D.22339, 0);
        if (D.22340 != 0) goto <D.22341>; else goto <D.22342>;
        <D.22341>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 103, "ret == 0");
        <D.22342>:
      }
      if (res != 0B) goto <D.22343>; else goto <D.22344>;
      <D.22343>:
      D.22345 = res;
      return D.22345;
      <D.22344>:
      mono_aot_only.0 = mono_aot_only;
      if (mono_aot_only.0 != 0) goto <D.22347>; else goto <D.22348>;
      <D.22347>:
      res = mono_aot_get_static_rgctx_trampoline (ctx, addr);
      goto <D.22349>;
      <D.22348>:
      res = mono_arch_get_static_rgctx_trampoline (m, ctx, addr);
      <D.22349>:
      {
        int ret;

        D.22323 = &domain->lock.mutex;
        ret = pthread_mutex_lock (D.22323);
        if (ret != 0) goto <D.22350>; else goto <D.22351>;
        <D.22350>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.22351>:
        D.22352 = ret != 0;
        D.22353 = (long int) D.22352;
        D.22354 = __builtin_expect (D.22353, 0);
        if (D.22354 != 0) goto <D.22355>; else goto <D.22356>;
        <D.22355>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 112, "ret == 0");
        <D.22356>:
      }
      info = mono_domain_alloc (domain, 8);
      info->m = m;
      info->addr = addr;
      D.22331 = domain->runtime_info;
      D.22332 = MEM[(struct MonoJitDomainInfo *)D.22331].static_rgctx_trampoline_hash;
      monoeg_g_hash_table_insert_replace (D.22332, info, res, 0);
      {
        int ret;

        D.22323 = &domain->lock.mutex;
        ret = pthread_mutex_unlock (D.22323);
        if (ret != 0) goto <D.22357>; else goto <D.22358>;
        <D.22357>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.22358>:
        D.22359 = ret != 0;
        D.22360 = (long int) D.22359;
        D.22361 = __builtin_expect (D.22360, 0);
        if (D.22361 != 0) goto <D.22362>; else goto <D.22363>;
        <D.22362>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 118, "ret == 0");
        <D.22363>:
      }
      static_rgctx_trampolines.1 = static_rgctx_trampolines;
      static_rgctx_trampolines.2 = static_rgctx_trampolines.1 + 1;
      static_rgctx_trampolines = static_rgctx_trampolines.2;
      D.22345 = res;
      return D.22345;
    }
  finally
    {
      tmp_info = {CLOBBER};
    }
}


rgctx_tramp_info_equal (const void * ka, const void * kb)
{
  struct MonoMethod * D.22369;
  struct MonoMethod * D.22370;
  void * D.22372;
  void * D.22373;
  gint D.22375;
  const struct RgctxTrampInfo * i1;
  const struct RgctxTrampInfo * i2;

  i1 = ka;
  i2 = kb;
  D.22369 = i1->m;
  D.22370 = i2->m;
  if (D.22369 == D.22370) goto <D.22371>; else goto <D.22368>;
  <D.22371>:
  D.22372 = i1->addr;
  D.22373 = i2->addr;
  if (D.22372 == D.22373) goto <D.22374>; else goto <D.22368>;
  <D.22374>:
  D.22375 = 1;
  return D.22375;
  <D.22368>:
  D.22375 = 0;
  return D.22375;
}


rgctx_tramp_info_hash (const void * data)
{
  guint D.22377;
  struct MonoMethod * D.22378;
  unsigned int D.22379;
  void * D.22380;
  unsigned int D.22381;
  const struct RgctxTrampInfo * info;

  info = data;
  D.22378 = info->m;
  D.22379 = (unsigned int) D.22378;
  D.22380 = info->addr;
  D.22381 = (unsigned int) D.22380;
  D.22377 = D.22379 ^ D.22381;
  return D.22377;
}


mini_jit_info_is_gsharedvt (struct MonoJitInfo * ji)
{
  unsigned char D.22386;
  unsigned char D.22387;
  struct MonoGenericSharingContext * D.22389;
  gboolean * D.22390;
  struct MonoGenericSharingContext * D.22392;
  gboolean * D.22393;
  gboolean D.22394;

  if (ji != 0B) goto <D.22385>; else goto <D.22383>;
  <D.22385>:
  D.22386 = BIT_FIELD_REF <*ji, 8, 176>;
  D.22387 = D.22386 & 2;
  if (D.22387 != 0) goto <D.22388>; else goto <D.22383>;
  <D.22388>:
  D.22389 = mono_jit_info_get_generic_sharing_context (ji);
  D.22390 = D.22389->var_is_vt;
  if (D.22390 != 0B) goto <D.22384>; else goto <D.22391>;
  <D.22391>:
  D.22392 = mono_jit_info_get_generic_sharing_context (ji);
  D.22393 = D.22392->mvar_is_vt;
  if (D.22393 != 0B) goto <D.22384>; else goto <D.22383>;
  <D.22384>:
  D.22394 = 1;
  return D.22394;
  <D.22383>:
  D.22394 = 0;
  return D.22394;
}


mini_add_method_trampoline (struct MonoMethod * orig_method, struct MonoMethod * m, void * compiled_method, gboolean add_static_rgctx_tramp, gboolean add_unbox_tramp)
{
  void * D.22396;
  struct MonoDomain * D.22397;
  unsigned char D.22398;
  unsigned char D.22399;
  <unnamed type> D.22404;
  <unnamed type> D.22412;
  unsigned char D.22419;
  unsigned char D.22420;
  _Bool D.22421;
  long int D.22422;
  long int D.22423;
  int mono_aot_only.3;
  unsigned int unbox_trampolines.4;
  unsigned int unbox_trampolines.5;
  struct MonoMethodSignature * D.22438;
  int D.22439;
  _Bool D.22442;
  _Bool D.22443;
  _Bool D.22444;
  void * D.22447;
  void * addr;
  gboolean callee_gsharedvt;
  gboolean callee_array_helper;
  struct MonoMethod * jmethod;
  struct MonoJitInfo * ji;

  addr = compiled_method;
  jmethod = 0B;
  D.22396 = mono_get_addr_from_ftnptr (compiled_method);
  D.22397 = mono_domain_get ();
  ji = mini_jit_info_table_find (D.22397, D.22396, 0B);
  callee_gsharedvt = mini_jit_info_is_gsharedvt (ji);
  callee_array_helper = 0;
  D.22398 = BIT_FIELD_REF <*m, 8, 160>;
  D.22399 = D.22398 & 124;
  if (D.22399 == 28) goto <D.22400>; else goto <D.22401>;
  <D.22400>:
  {
    struct WrapperInfo * info;

    info = mono_marshal_get_wrapper_info (m);
    if (info != 0B) goto <D.22402>; else goto <D.22403>;
    <D.22402>:
    D.22404 = info->subtype;
    if (D.22404 == 21) goto <D.22405>; else goto <D.22406>;
    <D.22405>:
    callee_array_helper = 1;
    m = info->d.generic_array_helper.method;
    <D.22406>:
    <D.22403>:
  }
  goto <D.22407>;
  <D.22401>:
  D.22398 = BIT_FIELD_REF <*m, 8, 160>;
  D.22399 = D.22398 & 124;
  if (D.22399 == 100) goto <D.22408>; else goto <D.22409>;
  <D.22408>:
  {
    struct WrapperInfo * info;

    info = mono_marshal_get_wrapper_info (m);
    if (info != 0B) goto <D.22410>; else goto <D.22411>;
    <D.22410>:
    D.22412 = info->subtype;
    if (D.22412 == 17) goto <D.22413>; else goto <D.22414>;
    <D.22413>:
    m = info->d.synchronized_inner.method;
    <D.22414>:
    <D.22411>:
  }
  <D.22409>:
  <D.22407>:
  if (orig_method == 0B) goto <D.22415>; else goto <D.22416>;
  <D.22415>:
  orig_method = m;
  <D.22416>:
  if (callee_gsharedvt != 0) goto <D.22417>; else goto <D.22418>;
  <D.22417>:
  D.22419 = BIT_FIELD_REF <*m, 8, 168>;
  D.22420 = D.22419 & 16;
  D.22421 = D.22420 == 0;
  D.22422 = (long int) D.22421;
  D.22423 = __builtin_expect (D.22422, 0);
  if (D.22423 != 0) goto <D.22424>; else goto <D.22425>;
  <D.22424>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 324, "m->is_inflated");
  <D.22425>:
  <D.22418>:
  addr = compiled_method;
  if (add_unbox_tramp != 0) goto <D.22426>; else goto <D.22427>;
  <D.22426>:
  mono_aot_only.3 = mono_aot_only;
  if (mono_aot_only.3 != 0) goto <D.22429>; else goto <D.22430>;
  <D.22429>:
  addr = mono_aot_get_unbox_trampoline (m);
  goto <D.22431>;
  <D.22430>:
  unbox_trampolines.4 = unbox_trampolines;
  unbox_trampolines.5 = unbox_trampolines.4 + 1;
  unbox_trampolines = unbox_trampolines.5;
  addr = mono_arch_get_unbox_trampoline (m, addr);
  <D.22431>:
  <D.22427>:
  if (ji != 0B) goto <D.22434>; else goto <D.22435>;
  <D.22434>:
  jmethod = jinfo_get_method (ji);
  <D.22435>:
  if (callee_gsharedvt != 0) goto <D.22436>; else goto <D.22437>;
  <D.22436>:
  D.22438 = mono_method_signature (jmethod);
  D.22439 = mini_is_gsharedvt_variable_signature (D.22438);
  if (D.22439 != 0) goto <D.22440>; else goto <D.22441>;
  <D.22440>:
  {
    struct MonoGenericSharingContext * gsctx;
    struct MonoMethodSignature * sig;
    struct MonoMethodSignature * gsig;

    gsctx = mono_jit_info_get_generic_sharing_context (ji);
    sig = mono_method_signature (m);
    gsig = mono_method_signature (jmethod);
    addr = mini_get_gsharedvt_wrapper (1, addr, sig, gsig, gsctx, -1, 0);
  }
  <D.22441>:
  <D.22437>:
  D.22442 = add_static_rgctx_tramp != 0;
  D.22443 = callee_array_helper == 0;
  D.22444 = D.22442 & D.22443;
  if (D.22444 != 0) goto <D.22445>; else goto <D.22446>;
  <D.22445>:
  addr = mono_create_static_rgctx_trampoline (m, addr);
  <D.22446>:
  D.22447 = addr;
  return D.22447;
}


jinfo_get_method (struct MonoJitInfo * ji)
{
  struct MonoMethod * D.22449;

  D.22449 = mono_jit_info_get_method (ji);
  return D.22449;
}


mono_magic_trampoline (mgreg_t * regs, guint8 * code, void * arg, guint8 * tramp)
{
  unsigned int trampoline_calls.6;
  unsigned int trampoline_calls.7;
  void * D.22453;

  trampoline_calls.6 = trampoline_calls;
  trampoline_calls.7 = trampoline_calls.6 + 1;
  trampoline_calls = trampoline_calls.7;
  D.22453 = common_call_trampoline (regs, code, arg, tramp, 0B, 0B, 0);
  return D.22453;
}


common_call_trampoline (mgreg_t * regs, guint8 * code, struct MonoMethod * m, guint8 * tramp, struct MonoVTable * vt, void * * vtable_slot, gboolean need_rgctx_tramp)
{
  _Bool D.22455;
  _Bool D.22456;
  _Bool D.22457;
  _Bool D.22458;
  _Bool D.22461;
  long int D.22462;
  long int D.22463;
  struct MonoVTable * D.22466;
  struct MonoClass * D.22467;
  struct MonoClass * D.22468;
  unsigned char D.22474;
  unsigned char D.22475;
  struct MonoGenericInst * D.22477;
  int variance_used.8;
  struct MonoClass * D.22482;
  int D.22483;
  _Bool D.22486;
  _Bool D.22487;
  _Bool D.22488;
  void * addr.9;
  struct MonoDomain * D.22492;
  int D.22493;
  void * D.22496;
  struct MonoDomain * D.22497;
  int D.22501;
  struct MonoGenericClass * D.22506;
  struct MonoGenericInst * D.22509;
  struct MonoGenericContainer * D.22511;
  _Bool D.22512;
  long int D.22513;
  long int D.22514;
  unsigned char D.22519;
  unsigned char D.22520;
  _Bool D.22521;
  long int D.22522;
  long int D.22523;
  struct MonoGenericInst * D.22526;
  _Bool D.22529;
  long int D.22530;
  long int D.22531;
  struct MonoGenericContext * D.22537;
  struct MonoGenericInst * D.22538;
  struct MonoVTable * D.22540;
  short unsigned int D.22544;
  int D.22545;
  int D.22546;
  unsigned char D.22548;
  unsigned char D.22549;
  struct MonoVTable * D.22550;
  struct MonoClass * D.22551;
  unsigned char D.22552;
  unsigned char D.22553;
  _Bool D.22554;
  long int D.22555;
  long int D.22556;
  struct MonoClass * * D.22561;
  short unsigned int D.22562;
  sizetype D.22563;
  sizetype D.22564;
  sizetype D.22565;
  struct MonoClass * * D.22566;
  _Bool D.22567;
  _Bool D.22568;
  int D.22569;
  _Bool D.22570;
  long int D.22571;
  long int D.22572;
  int vtable_slot.10;
  int vt.11;
  int D.22579;
  _Bool D.22580;
  long int D.22581;
  long int D.22582;
  struct MonoClass * D.22585;
  struct MonoMethod * * D.22586;
  unsigned int displacement.12;
  unsigned int D.22588;
  struct MonoMethod * * D.22589;
  unsigned char D.22594;
  unsigned char D.22595;
  struct MonoGenericClass * D.22599;
  struct MonoGenericInst * D.22602;
  struct MonoGenericContainer * D.22604;
  struct MonoGenericInst * D.22607;
  long int D.22608;
  long int D.22609;
  _Bool D.22612;
  long int D.22613;
  long int D.22614;
  struct MonoClass * D.22617;
  _Bool D.22618;
  long int D.22619;
  long int D.22620;
  unsigned char D.22623;
  unsigned char D.22624;
  short unsigned int D.22628;
  int D.22629;
  int D.22630;
  int D.22635;
  _Bool D.22638;
  long int D.22639;
  long int D.22640;
  _Bool D.22643;
  _Bool D.22644;
  _Bool D.22645;
  struct MonoClass * D.22648;
  unsigned char D.22649;
  unsigned char D.22650;
  int need_rgctx_tramp.13;
  void * addr.14;
  struct MonoMethod * iftmp.15;
  struct MonoDomain * D.22668;
  void * D.22671;
  struct GHashTable * D.22672;
  union mono_mutex_t * D.22675;
  _Bool D.22678;
  long int D.22679;
  long int D.22680;
  _Bool D.22687;
  long int D.22688;
  long int D.22689;
  int D.22698;
  struct MonoDomain * D.22700;
  int D.22701;
  void * D.22702;
  _Bool D.22703;
  long int D.22704;
  long int D.22705;
  void * D.22708;
  void * D.22714;
  struct MonoDomain * D.22715;
  struct MonoDomain * D.22718;
  _Bool D.22719;
  _Bool D.22720;
  _Bool D.22721;
  unsigned char D.22726;
  unsigned char D.22727;
  unsigned char D.22730;
  unsigned char D.22731;
  void * D.22741;
  struct MonoDomain * D.22742;
  struct MonoDomain * D.22745;
  int D.22756;
  void * D.22759;
  void * addr;
  void * compiled_method;
  gboolean generic_shared;
  gboolean need_unbox_tramp;
  struct MonoMethod * declaring;
  struct MonoMethod * generic_virtual;
  struct MonoMethod * variant_iface;
  struct MonoMethod * orig_method;
  int context_used;
  gboolean virtual;
  gboolean variance_used;
  void * * orig_vtable_slot;
  void * * vtable_slot_to_patch;
  struct MonoJitInfo * ji;

  try
    {
      generic_shared = 0;
      need_unbox_tramp = 0;
      declaring = 0B;
      generic_virtual = 0B;
      variant_iface = 0B;
      orig_method = 0B;
      variance_used = 0;
      vtable_slot_to_patch = 0B;
      ji = 0B;
      D.22455 = vtable_slot > vt;
      virtual = (gboolean) D.22455;
      orig_vtable_slot = vtable_slot;
      vtable_slot_to_patch = vtable_slot;
      D.22456 = vt != 0B;
      D.22457 = vtable_slot < vt;
      D.22458 = D.22456 & D.22457;
      if (D.22458 != 0) goto <D.22459>; else goto <D.22460>;
      <D.22459>:
      {
        struct MonoMethod * impl_method;
        struct MonoObject * this_arg;

        try
          {
            impl_method = 0B;
            m = mono_arch_find_imt_method (regs, code);
            vtable_slot = orig_vtable_slot;
            D.22461 = vtable_slot == 0B;
            D.22462 = (long int) D.22461;
            D.22463 = __builtin_expect (D.22462, 0);
            if (D.22463 != 0) goto <D.22464>; else goto <D.22465>;
            <D.22464>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 401, "vtable_slot");
            <D.22465>:
            orig_method = m;
            this_arg = mono_arch_get_this_arg_from_call (regs, code);
            D.22466 = this_arg->vtable;
            D.22467 = D.22466->klass;
            D.22468 = mono_defaults.transparent_proxy_class;
            if (D.22467 == D.22468) goto <D.22469>; else goto <D.22470>;
            <D.22469>:
            m = mono_object_get_virtual_method (this_arg, m);
            vtable_slot_to_patch = 0B;
            goto <D.22471>;
            <D.22470>:
            {
              gboolean lookup_aot;

              D.22474 = BIT_FIELD_REF <*m, 8, 168>;
              D.22475 = D.22474 & 16;
              if (D.22475 != 0) goto <D.22476>; else goto <D.22472>;
              <D.22476>:
              D.22477 = MEM[(struct MonoMethodInflated *)m].context.method_inst;
              if (D.22477 != 0B) goto <D.22478>; else goto <D.22472>;
              <D.22478>:
              generic_virtual = m;
              need_rgctx_tramp = 1;
              goto <D.22473>;
              <D.22472>:
              variance_used.8 = variance_used;
              if (variance_used.8 != 0) goto <D.22480>; else goto <D.22481>;
              <D.22480>:
              D.22482 = m->klass;
              D.22483 = mono_class_has_variant_generic_params (D.22482);
              if (D.22483 != 0) goto <D.22484>; else goto <D.22485>;
              <D.22484>:
              variant_iface = m;
              <D.22485>:
              <D.22481>:
              <D.22473>:
              addr = 0B;
              D.22486 = generic_virtual == 0B;
              D.22487 = variant_iface == 0B;
              D.22488 = D.22486 & D.22487;
              lookup_aot = (gboolean) D.22488;
              vtable_slot = mono_convert_imt_slot_to_vtable_slot (vtable_slot, regs, code, m, lookup_aot, &impl_method, &need_rgctx_tramp, &variance_used, &addr);
              vtable_slot_to_patch = vtable_slot;
              addr.9 = addr;
              if (addr.9 != 0B) goto <D.22490>; else goto <D.22491>;
              <D.22490>:
              D.22492 = mono_domain_get ();
              D.22493 = mono_domain_owns_vtable_slot (D.22492, vtable_slot);
              if (D.22493 != 0) goto <D.22494>; else goto <D.22495>;
              <D.22494>:
              addr.9 = addr;
              *vtable_slot = addr.9;
              <D.22495>:
              addr.9 = addr;
              D.22497 = mono_domain_get ();
              D.22496 = mono_create_ftnptr (D.22497, addr.9);
              return D.22496;
              <D.22491>:
              m = impl_method;
            }
            <D.22471>:
          }
        finally
          {
            impl_method = {CLOBBER};
          }
      }
      <D.22460>:
      if (virtual != 0) goto <D.22500>; else goto <D.22498>;
      <D.22500>:
      D.22501 = is_generic_method_definition (m);
      if (D.22501 != 0) goto <D.22502>; else goto <D.22498>;
      <D.22502>:
      {
        struct MonoGenericContext context;
        struct MonoMethod * declaring;

        try
          {
            context.class_inst = 0B;
            context.method_inst = 0B;
            D.22474 = BIT_FIELD_REF <*m, 8, 168>;
            D.22475 = D.22474 & 16;
            if (D.22475 != 0) goto <D.22503>; else goto <D.22504>;
            <D.22503>:
            declaring = mono_method_get_declaring_generic_method (m);
            goto <D.22505>;
            <D.22504>:
            declaring = m;
            <D.22505>:
            D.22482 = m->klass;
            D.22506 = D.22482->generic_class;
            if (D.22506 != 0B) goto <D.22507>; else goto <D.22508>;
            <D.22507>:
            D.22482 = m->klass;
            D.22506 = D.22482->generic_class;
            D.22509 = D.22506->context.class_inst;
            context.class_inst = D.22509;
            goto <D.22510>;
            <D.22508>:
            D.22482 = m->klass;
            D.22511 = D.22482->generic_container;
            D.22512 = D.22511 != 0B;
            D.22513 = (long int) D.22512;
            D.22514 = __builtin_expect (D.22513, 0);
            if (D.22514 != 0) goto <D.22515>; else goto <D.22516>;
            <D.22515>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 464, "!m->klass->generic_container");
            <D.22516>:
            <D.22510>:
            generic_virtual = mono_arch_find_imt_method (regs, code);
            if (generic_virtual != 0B) goto <D.22517>; else goto <D.22518>;
            <D.22517>:
            D.22519 = BIT_FIELD_REF <*generic_virtual, 8, 168>;
            D.22520 = D.22519 & 16;
            D.22521 = D.22520 == 0;
            D.22522 = (long int) D.22521;
            D.22523 = __builtin_expect (D.22522, 0);
            if (D.22523 != 0) goto <D.22524>; else goto <D.22525>;
            <D.22524>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 470, "generic_virtual->is_inflated");
            <D.22525>:
            D.22526 = MEM[(struct MonoMethodInflated *)generic_virtual].context.method_inst;
            context.method_inst = D.22526;
            <D.22518>:
            m = mono_class_inflate_generic_method (declaring, &context);
            need_rgctx_tramp = 1;
          }
        finally
          {
            context = {CLOBBER};
          }
      }
      goto <D.22499>;
      <D.22498>:
      context_used = mono_method_check_context_used (m);
      if (context_used != 0) goto <D.22527>; else goto <D.22528>;
      <D.22527>:
      {
        struct MonoClass * klass;
        struct MonoMethod * actual_method;
        struct MonoVTable * vt;
        struct MonoGenericInst * method_inst;

        klass = 0B;
        actual_method = 0B;
        vt = 0B;
        method_inst = 0B;
        vtable_slot = 0B;
        generic_shared = 1;
        D.22529 = code == 0B;
        D.22530 = (long int) D.22529;
        D.22531 = __builtin_expect (D.22530, 0);
        if (D.22531 != 0) goto <D.22532>; else goto <D.22533>;
        <D.22532>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 486, "code");
        <D.22533>:
        D.22474 = BIT_FIELD_REF <*m, 8, 168>;
        D.22475 = D.22474 & 16;
        if (D.22475 != 0) goto <D.22536>; else goto <D.22534>;
        <D.22536>:
        D.22537 = mono_method_get_context (m);
        D.22538 = D.22537->method_inst;
        if (D.22538 != 0B) goto <D.22539>; else goto <D.22534>;
        <D.22539>:
        {
          struct MonoMethodRuntimeGenericContext * mrgctx;

          mrgctx = mono_arch_find_static_call_vtable (regs, code);
          D.22540 = mrgctx->class_vtable;
          klass = D.22540->klass;
          method_inst = mrgctx->method_inst;
        }
        goto <D.22535>;
        <D.22534>:
        D.22544 = m->flags;
        D.22545 = (int) D.22544;
        D.22546 = D.22545 & 16;
        if (D.22546 != 0) goto <D.22541>; else goto <D.22547>;
        <D.22547>:
        D.22482 = m->klass;
        D.22548 = BIT_FIELD_REF <*D.22482, 8, 160>;
        D.22549 = D.22548 & 8;
        if (D.22549 != 0) goto <D.22541>; else goto <D.22542>;
        <D.22541>:
        {
          struct MonoVTable * vtable;

          vtable = mono_arch_find_static_call_vtable (regs, code);
          klass = vtable->klass;
        }
        goto <D.22543>;
        <D.22542>:
        {
          struct MonoObject * this_argument;

          this_argument = mono_arch_get_this_arg_from_call (regs, code);
          vt = this_argument->vtable;
          vtable_slot = orig_vtable_slot;
          D.22550 = this_argument->vtable;
          D.22551 = D.22550->klass;
          D.22552 = BIT_FIELD_REF <*D.22551, 8, 160>;
          D.22553 = D.22552 & 1;
          D.22554 = D.22553 == 0;
          D.22555 = (long int) D.22554;
          D.22556 = __builtin_expect (D.22555, 0);
          if (D.22556 != 0) goto <D.22557>; else goto <D.22558>;
          <D.22557>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 512, "this_argument->vtable->klass->inited");
          <D.22558>:
          if (vtable_slot == 0B) goto <D.22559>; else goto <D.22560>;
          <D.22559>:
          D.22550 = this_argument->vtable;
          D.22551 = D.22550->klass;
          mono_class_setup_supertypes (D.22551);
          D.22550 = this_argument->vtable;
          D.22551 = D.22550->klass;
          D.22561 = D.22551->supertypes;
          D.22482 = m->klass;
          D.22562 = D.22482->idepth;
          D.22563 = (sizetype) D.22562;
          D.22564 = D.22563 + 1073741823;
          D.22565 = D.22564 * 4;
          D.22566 = D.22561 + D.22565;
          klass = *D.22566;
          <D.22560>:
        }
        <D.22543>:
        <D.22535>:
        D.22461 = vtable_slot == 0B;
        D.22567 = klass == 0B;
        D.22568 = D.22461 & D.22567;
        D.22569 = (int) D.22568;
        D.22570 = D.22569 != 0;
        D.22571 = (long int) D.22570;
        D.22572 = __builtin_expect (D.22571, 0);
        if (D.22572 != 0) goto <D.22573>; else goto <D.22574>;
        <D.22573>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 524, "vtable_slot || klass");
        <D.22574>:
        if (vtable_slot != 0B) goto <D.22575>; else goto <D.22576>;
        <D.22575>:
        {
          int displacement;

          vtable_slot.10 = (int) vtable_slot;
          vt.11 = (int) vt;
          D.22579 = vtable_slot.10 - vt.11;
          displacement = D.22579 /[ex] 4;
          monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-trampolines.c", 529);
          D.22580 = displacement <= 0;
          D.22581 = (long int) D.22580;
          D.22582 = __builtin_expect (D.22581, 0);
          if (D.22582 != 0) goto <D.22583>; else goto <D.22584>;
          <D.22583>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 531, "displacement > 0");
          <D.22584>:
          D.22585 = vt->klass;
          D.22586 = D.22585->vtable;
          displacement.12 = (unsigned int) displacement;
          D.22588 = displacement.12 * 4;
          D.22589 = D.22586 + D.22588;
          actual_method = *D.22589;
        }
        <D.22576>:
        if (method_inst != 0B) goto <D.22590>; else goto <D.22593>;
        <D.22593>:
        D.22594 = BIT_FIELD_REF <*m, 8, 160>;
        D.22595 = D.22594 & 124;
        if (D.22595 != 0) goto <D.22590>; else goto <D.22591>;
        <D.22590>:
        {
          struct MonoGenericContext context;

          try
            {
              context.class_inst = 0B;
              context.method_inst = 0B;
              D.22474 = BIT_FIELD_REF <*m, 8, 168>;
              D.22475 = D.22474 & 16;
              if (D.22475 != 0) goto <D.22596>; else goto <D.22597>;
              <D.22596>:
              declaring = mono_method_get_declaring_generic_method (m);
              goto <D.22598>;
              <D.22597>:
              declaring = m;
              <D.22598>:
              D.22599 = klass->generic_class;
              if (D.22599 != 0B) goto <D.22600>; else goto <D.22601>;
              <D.22600>:
              D.22599 = klass->generic_class;
              D.22602 = D.22599->context.class_inst;
              context.class_inst = D.22602;
              goto <D.22603>;
              <D.22601>:
              D.22604 = klass->generic_container;
              if (D.22604 != 0B) goto <D.22605>; else goto <D.22606>;
              <D.22605>:
              D.22604 = klass->generic_container;
              D.22607 = D.22604->context.class_inst;
              context.class_inst = D.22607;
              <D.22606>:
              <D.22603>:
              context.method_inst = method_inst;
              actual_method = mono_class_inflate_generic_method (declaring, &context);
            }
          finally
            {
              context = {CLOBBER};
            }
        }
        goto <D.22592>;
        <D.22591>:
        actual_method = mono_class_get_method_generic (klass, m);
        <D.22592>:
        D.22567 = klass == 0B;
        D.22608 = (long int) D.22567;
        D.22609 = __builtin_expect (D.22608, 0);
        if (D.22609 != 0) goto <D.22610>; else goto <D.22611>;
        <D.22610>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 555, "klass");
        <D.22611>:
        D.22612 = actual_method == 0B;
        D.22613 = (long int) D.22612;
        D.22614 = __builtin_expect (D.22613, 0);
        if (D.22614 != 0) goto <D.22615>; else goto <D.22616>;
        <D.22615>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 556, "actual_method");
        <D.22616>:
        D.22617 = actual_method->klass;
        D.22618 = D.22617 != klass;
        D.22619 = (long int) D.22618;
        D.22620 = __builtin_expect (D.22619, 0);
        if (D.22620 != 0) goto <D.22621>; else goto <D.22622>;
        <D.22621>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 557, "actual_method->klass == klass");
        <D.22622>:
        D.22623 = BIT_FIELD_REF <*actual_method, 8, 168>;
        D.22624 = D.22623 & 16;
        if (D.22624 != 0) goto <D.22625>; else goto <D.22626>;
        <D.22625>:
        declaring = mono_method_get_declaring_generic_method (actual_method);
        goto <D.22627>;
        <D.22626>:
        declaring = 0B;
        <D.22627>:
        m = actual_method;
      }
      <D.22528>:
      <D.22499>:
      D.22628 = m->iflags;
      D.22629 = (int) D.22628;
      D.22630 = D.22629 & 32;
      if (D.22630 != 0) goto <D.22631>; else goto <D.22632>;
      <D.22631>:
      m = mono_marshal_get_synchronized_wrapper (m);
      need_rgctx_tramp = 0;
      <D.22632>:
      if (code == 0B) goto <D.22633>; else goto <D.22634>;
      <D.22633>:
      D.22635 = mono_method_needs_static_rgctx_invoke (m, 0);
      if (D.22635 != 0) goto <D.22636>; else goto <D.22637>;
      <D.22636>:
      need_rgctx_tramp = 1;
      <D.22637>:
      <D.22634>:
      compiled_method = mono_compile_method (m);
      addr = compiled_method;
      addr.9 = addr;
      D.22638 = addr.9 == 0B;
      D.22639 = (long int) D.22638;
      D.22640 = __builtin_expect (D.22639, 0);
      if (D.22640 != 0) goto <D.22641>; else goto <D.22642>;
      <D.22641>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 577, "addr");
      <D.22642>:
      D.22643 = generic_virtual != 0B;
      D.22644 = variant_iface != 0B;
      D.22645 = D.22643 | D.22644;
      if (D.22645 != 0) goto <D.22646>; else goto <D.22647>;
      <D.22646>:
      D.22648 = vt->klass;
      D.22649 = BIT_FIELD_REF <*D.22648, 8, 160>;
      D.22650 = D.22649 & 8;
      if (D.22650 != 0) goto <D.22651>; else goto <D.22652>;
      <D.22651>:
      need_unbox_tramp = 1;
      <D.22652>:
      goto <D.22653>;
      <D.22647>:
      if (orig_vtable_slot != 0B) goto <D.22654>; else goto <D.22655>;
      <D.22654>:
      D.22482 = m->klass;
      D.22548 = BIT_FIELD_REF <*D.22482, 8, 160>;
      D.22549 = D.22548 & 8;
      if (D.22549 != 0) goto <D.22656>; else goto <D.22657>;
      <D.22656>:
      need_unbox_tramp = 1;
      <D.22657>:
      <D.22655>:
      <D.22653>:
      need_rgctx_tramp.13 = need_rgctx_tramp;
      addr.14 = mini_add_method_trampoline (orig_method, m, compiled_method, need_rgctx_tramp.13, need_unbox_tramp);
      addr = addr.14;
      D.22643 = generic_virtual != 0B;
      D.22644 = variant_iface != 0B;
      D.22645 = D.22643 | D.22644;
      if (D.22645 != 0) goto <D.22660>; else goto <D.22661>;
      <D.22660>:
      {
        struct MonoMethod * target;

        if (generic_virtual != 0B) goto <D.22663>; else goto <D.22664>;
        <D.22663>:
        iftmp.15 = generic_virtual;
        goto <D.22665>;
        <D.22664>:
        iftmp.15 = variant_iface;
        <D.22665>:
        target = iftmp.15;
        vtable_slot = orig_vtable_slot;
        D.22461 = vtable_slot == 0B;
        D.22462 = (long int) D.22461;
        D.22463 = __builtin_expect (D.22462, 0);
        if (D.22463 != 0) goto <D.22666>; else goto <D.22667>;
        <D.22666>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 593, "vtable_slot");
        <D.22667>:
        addr.9 = addr;
        D.22668 = mono_domain_get ();
        mono_method_add_generic_virtual_invocation (D.22668, vt, vtable_slot, target, addr.9);
        D.22496 = addr;
        return D.22496;
      }
      <D.22661>:
      if (code == 0B) goto <D.22669>; else goto <D.22670>;
      <D.22669>:
      {
        struct MonoDomain * domain;

        domain = mono_domain_get ();
        D.22671 = domain->runtime_info;
        D.22672 = MEM[(struct MonoJitDomainInfo *)D.22671].jump_target_got_slot_hash;
        if (D.22672 != 0B) goto <D.22673>; else goto <D.22674>;
        <D.22673>:
        {
          struct GSList * list;
          struct GSList * tmp;

          {
            int ret;

            D.22675 = &domain->lock.mutex;
            ret = pthread_mutex_lock (D.22675);
            if (ret != 0) goto <D.22676>; else goto <D.22677>;
            <D.22676>:
            monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
            <D.22677>:
            D.22678 = ret != 0;
            D.22679 = (long int) D.22678;
            D.22680 = __builtin_expect (D.22679, 0);
            if (D.22680 != 0) goto <D.22681>; else goto <D.22682>;
            <D.22681>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 614, "ret == 0");
            <D.22682>:
          }
          D.22671 = domain->runtime_info;
          D.22672 = MEM[(struct MonoJitDomainInfo *)D.22671].jump_target_got_slot_hash;
          list = monoeg_g_hash_table_lookup (D.22672, m);
          if (list != 0B) goto <D.22683>; else goto <D.22684>;
          <D.22683>:
          tmp = list;
          goto <D.22031>;
          <D.22030>:
          {
            void * * got_slot;

            got_slot = tmp->data;
            addr.9 = addr;
            *got_slot = addr.9;
          }
          tmp = tmp->next;
          <D.22031>:
          if (tmp != 0B) goto <D.22030>; else goto <D.22032>;
          <D.22032>:
          D.22671 = domain->runtime_info;
          D.22672 = MEM[(struct MonoJitDomainInfo *)D.22671].jump_target_got_slot_hash;
          monoeg_g_hash_table_remove (D.22672, m);
          monoeg_g_slist_free (list);
          <D.22684>:
          {
            int ret;

            D.22675 = &domain->lock.mutex;
            ret = pthread_mutex_unlock (D.22675);
            if (ret != 0) goto <D.22685>; else goto <D.22686>;
            <D.22685>:
            monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
            <D.22686>:
            D.22687 = ret != 0;
            D.22688 = (long int) D.22687;
            D.22689 = __builtin_expect (D.22688, 0);
            if (D.22689 != 0) goto <D.22690>; else goto <D.22691>;
            <D.22690>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 624, "ret == 0");
            <D.22691>:
          }
        }
        <D.22674>:
        D.22496 = addr;
        return D.22496;
      }
      <D.22670>:
      vtable_slot = orig_vtable_slot;
      if (vtable_slot != 0B) goto <D.22692>; else goto <D.22693>;
      <D.22692>:
      if (vtable_slot_to_patch != 0B) goto <D.22696>; else goto <D.22697>;
      <D.22696>:
      D.22698 = mono_aot_is_got_entry (code, vtable_slot_to_patch);
      if (D.22698 != 0) goto <D.22694>; else goto <D.22699>;
      <D.22699>:
      D.22700 = mono_domain_get ();
      D.22701 = mono_domain_owns_vtable_slot (D.22700, vtable_slot_to_patch);
      if (D.22701 != 0) goto <D.22694>; else goto <D.22695>;
      <D.22694>:
      D.22702 = *vtable_slot_to_patch;
      D.22703 = D.22702 == 0B;
      D.22704 = (long int) D.22703;
      D.22705 = __builtin_expect (D.22704, 0);
      if (D.22705 != 0) goto <D.22706>; else goto <D.22707>;
      <D.22706>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 634, "*vtable_slot_to_patch");
      <D.22707>:
      addr.9 = addr;
      D.22708 = mono_get_addr_from_ftnptr (addr.9);
      *vtable_slot_to_patch = D.22708;
      <D.22695>:
      <D.22697>:
      goto <D.22709>;
      <D.22693>:
      {
        guint8 * plt_entry;
        gboolean no_patch;
        struct MonoJitInfo * target_ji;

        plt_entry = mono_aot_get_plt_entry (code);
        no_patch = 0;
        if (plt_entry != 0B) goto <D.22710>; else goto <D.22711>;
        <D.22710>:
        if (generic_shared != 0) goto <D.22712>; else goto <D.22713>;
        <D.22712>:
        D.22714 = mono_get_addr_from_ftnptr (compiled_method);
        D.22715 = mono_domain_get ();
        target_ji = mini_jit_info_table_find (D.22715, D.22714, 0B);
        if (ji == 0B) goto <D.22716>; else goto <D.22717>;
        <D.22716>:
        D.22718 = mono_domain_get ();
        ji = mini_jit_info_table_find (D.22718, code, 0B);
        <D.22717>:
        D.22719 = ji != 0B;
        D.22720 = target_ji != 0B;
        D.22721 = D.22719 & D.22720;
        if (D.22721 != 0) goto <D.22722>; else goto <D.22723>;
        <D.22722>:
        if (generic_shared != 0) goto <D.22724>; else goto <D.22725>;
        <D.22724>:
        D.22726 = BIT_FIELD_REF <*ji, 8, 176>;
        D.22727 = D.22726 & 2;
        if (D.22727 != 0) goto <D.22728>; else goto <D.22729>;
        <D.22728>:
        D.22730 = BIT_FIELD_REF <*target_ji, 8, 176>;
        D.22731 = D.22730 & 2;
        if (D.22731 == 0) goto <D.22732>; else goto <D.22733>;
        <D.22732>:
        no_patch = 1;
        <D.22733>:
        <D.22729>:
        <D.22725>:
        <D.22723>:
        <D.22713>:
        if (no_patch == 0) goto <D.22734>; else goto <D.22735>;
        <D.22734>:
        addr.9 = addr;
        mono_aot_patch_plt_entry (plt_entry, 0B, regs, addr.9);
        <D.22735>:
        goto <D.22736>;
        <D.22711>:
        if (generic_shared != 0) goto <D.22737>; else goto <D.22738>;
        <D.22737>:
        D.22594 = BIT_FIELD_REF <*m, 8, 160>;
        D.22595 = D.22594 & 124;
        if (D.22595 != 0) goto <D.22739>; else goto <D.22740>;
        <D.22739>:
        m = mono_marshal_method_from_wrapper (m);
        <D.22740>:
        <D.22738>:
        D.22741 = mono_get_addr_from_ftnptr (compiled_method);
        D.22742 = mono_domain_get ();
        target_ji = mini_jit_info_table_find (D.22742, D.22741, 0B);
        if (ji == 0B) goto <D.22743>; else goto <D.22744>;
        <D.22743>:
        D.22745 = mono_domain_get ();
        ji = mini_jit_info_table_find (D.22745, code, 0B);
        <D.22744>:
        D.22719 = ji != 0B;
        D.22720 = target_ji != 0B;
        D.22721 = D.22719 & D.22720;
        if (D.22721 != 0) goto <D.22746>; else goto <D.22747>;
        <D.22746>:
        if (generic_shared != 0) goto <D.22748>; else goto <D.22749>;
        <D.22748>:
        D.22726 = BIT_FIELD_REF <*ji, 8, 176>;
        D.22727 = D.22726 & 2;
        if (D.22727 != 0) goto <D.22750>; else goto <D.22751>;
        <D.22750>:
        D.22730 = BIT_FIELD_REF <*target_ji, 8, 176>;
        D.22731 = D.22730 & 2;
        if (D.22731 == 0) goto <D.22752>; else goto <D.22753>;
        <D.22752>:
        no_patch = 1;
        <D.22753>:
        <D.22751>:
        <D.22749>:
        <D.22747>:
        if (no_patch == 0) goto <D.22754>; else goto <D.22755>;
        <D.22754>:
        D.22756 = mono_method_same_domain (ji, target_ji);
        if (D.22756 != 0) goto <D.22757>; else goto <D.22758>;
        <D.22757>:
        addr.9 = addr;
        D.22759 = ji->code_start;
        mono_arch_patch_callsite (D.22759, code, addr.9);
        <D.22758>:
        <D.22755>:
        <D.22736>:
      }
      <D.22709>:
      D.22496 = addr;
      return D.22496;
    }
  finally
    {
      addr = {CLOBBER};
      variance_used = {CLOBBER};
    }
}


mono_convert_imt_slot_to_vtable_slot (void * * slot, mgreg_t * regs, guint8 * code, struct MonoMethod * method, gboolean lookup_aot, struct MonoMethod * * impl_method, gboolean * need_rgctx_tramp, gboolean * variance_used, void * * aot_addr)
{
  int slot.16;
  int vt.17;
  int D.22766;
  void * * D.22769;
  struct MonoClass * D.22770;
  struct MonoClass * D.22771;
  struct MonoType * D.22774;
  char * D.22775;
  struct MonoType * D.22776;
  char * D.22777;
  unsigned int D.22778;
  int D.22779;
  unsigned char D.22782;
  unsigned char D.22783;
  struct MonoGenericInst * D.22785;
  struct MonoMethod * D.22787;
  short int D.22788;
  int D.22789;
  int D.22790;
  struct MonoClass * D.22791;
  struct MonoGenericClass * D.22792;
  struct MonoGenericInst * D.22795;
  unsigned char D.22799;
  unsigned char D.22800;
  int D.22802;
  int D.22803;
  struct MonoDomain * D.22804;
  void * D.22805;
  void * D.22806;
  int D.22810;
  int D.22811;
  int D.22814;
  unsigned char D.22819;
  unsigned char D.22820;
  <unnamed type> D.22825;
  _Bool D.22828;
  long int D.22829;
  long int D.22830;
  unsigned int D.22833;
  int D.22834;
  unsigned int D.22835;
  unsigned int D.22836;
  _Bool D.22839;
  long int D.22840;
  long int D.22841;
  struct MonoObject * this_argument;
  struct MonoVTable * vt;
  int displacement;

  this_argument = mono_arch_get_this_arg_from_call (regs, code);
  vt = this_argument->vtable;
  slot.16 = (int) slot;
  vt.17 = (int) vt;
  D.22766 = slot.16 - vt.17;
  displacement = D.22766 /[ex] 4;
  if (displacement > 0) goto <D.22767>; else goto <D.22768>;
  <D.22767>:
  D.22769 = slot;
  return D.22769;
  <D.22768>:
  {
    struct MonoMethod * imt_method;
    struct MonoMethod * impl;
    int interface_offset;
    int imt_slot;

    imt_method = mono_arch_find_imt_method (regs, code);
    imt_slot = displacement + 19;
    D.22770 = imt_method->klass;
    D.22771 = vt->klass;
    interface_offset = mono_class_interface_offset_with_variance (D.22771, D.22770, variance_used);
    if (interface_offset < 0) goto <D.22772>; else goto <D.22773>;
    <D.22772>:
    D.22770 = imt_method->klass;
    D.22774 = &D.22770->byval_arg;
    D.22775 = mono_type_get_name_full (D.22774, 0);
    D.22771 = vt->klass;
    D.22776 = &D.22771->byval_arg;
    D.22777 = mono_type_get_name_full (D.22776, 0);
    monoeg_g_log (0B, 4, "%s doesn\'t implement interface %s\n", D.22777, D.22775);
    <D.21957>:
    goto <D.21957>;
    <D.22773>:
    D.22778 = mono_method_get_imt_slot (imt_method);
    D.22779 = (int) D.22778;
    mono_vtable_build_imt_slot (vt, D.22779);
    D.22782 = BIT_FIELD_REF <*imt_method, 8, 168>;
    D.22783 = D.22782 & 16;
    if (D.22783 != 0) goto <D.22784>; else goto <D.22780>;
    <D.22784>:
    D.22785 = MEM[(struct MonoMethodInflated *)imt_method].context.method_inst;
    if (D.22785 != 0B) goto <D.22786>; else goto <D.22780>;
    <D.22786>:
    {
      struct MonoGenericContext context;

      try
        {
          context.class_inst = 0B;
          context.method_inst = 0B;
          D.22787 = mono_method_get_declaring_generic_method (imt_method);
          D.22788 = D.22787->slot;
          D.22789 = (int) D.22788;
          D.22790 = D.22789 + interface_offset;
          D.22771 = vt->klass;
          impl = mono_class_get_vtable_entry (D.22771, D.22790);
          D.22791 = impl->klass;
          D.22792 = D.22791->generic_class;
          if (D.22792 != 0B) goto <D.22793>; else goto <D.22794>;
          <D.22793>:
          D.22791 = impl->klass;
          D.22792 = D.22791->generic_class;
          D.22795 = D.22792->context.class_inst;
          context.class_inst = D.22795;
          <D.22794>:
          D.22785 = MEM[(struct MonoMethodInflated *)imt_method].context.method_inst;
          context.method_inst = D.22785;
          impl = mono_class_inflate_generic_method (impl, &context);
        }
      finally
        {
          context = {CLOBBER};
        }
    }
    goto <D.22781>;
    <D.22780>:
    if (lookup_aot != 0) goto <D.22798>; else goto <D.22796>;
    <D.22798>:
    D.22771 = vt->klass;
    D.22799 = BIT_FIELD_REF <*D.22771, 8, 160>;
    D.22800 = D.22799 & 8;
    if (D.22800 == 0) goto <D.22801>; else goto <D.22796>;
    <D.22801>:
    D.22802 = mono_method_get_vtable_slot (imt_method);
    D.22803 = D.22802 + interface_offset;
    D.22804 = mono_domain_get ();
    D.22805 = mono_aot_get_method_from_vt_slot (D.22804, vt, D.22803);
    *aot_addr = D.22805;
    goto <D.22797>;
    <D.22796>:
    *aot_addr = 0B;
    <D.22797>:
    D.22806 = *aot_addr;
    if (D.22806 != 0B) goto <D.22807>; else goto <D.22808>;
    <D.22807>:
    impl = 0B;
    goto <D.22809>;
    <D.22808>:
    D.22810 = mono_method_get_vtable_slot (imt_method);
    D.22811 = D.22810 + interface_offset;
    D.22771 = vt->klass;
    impl = mono_class_get_vtable_entry (D.22771, D.22811);
    <D.22809>:
    <D.22781>:
    if (impl != 0B) goto <D.22812>; else goto <D.22813>;
    <D.22812>:
    D.22814 = mono_method_needs_static_rgctx_invoke (impl, 0);
    if (D.22814 != 0) goto <D.22815>; else goto <D.22816>;
    <D.22815>:
    *need_rgctx_tramp = 1;
    <D.22816>:
    <D.22813>:
    if (impl != 0B) goto <D.22817>; else goto <D.22818>;
    <D.22817>:
    D.22819 = BIT_FIELD_REF <*impl, 8, 160>;
    D.22820 = D.22819 & 124;
    if (D.22820 == 28) goto <D.22821>; else goto <D.22822>;
    <D.22821>:
    {
      struct WrapperInfo * info;

      info = mono_marshal_get_wrapper_info (impl);
      if (info != 0B) goto <D.22823>; else goto <D.22824>;
      <D.22823>:
      D.22825 = info->subtype;
      if (D.22825 == 21) goto <D.22826>; else goto <D.22827>;
      <D.22826>:
      *need_rgctx_tramp = 1;
      <D.22827>:
      <D.22824>:
    }
    <D.22822>:
    <D.22818>:
    *impl_method = impl;
    D.22828 = imt_slot > 18;
    D.22829 = (long int) D.22828;
    D.22830 = __builtin_expect (D.22829, 0);
    if (D.22830 != 0) goto <D.22831>; else goto <D.22832>;
    <D.22831>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 223, "imt_slot < MONO_IMT_SIZE");
    <D.22832>:
    D.22833 = vt->imt_collisions_bitmap;
    D.22834 = 1 << imt_slot;
    D.22835 = (unsigned int) D.22834;
    D.22836 = D.22833 & D.22835;
    if (D.22836 != 0) goto <D.22837>; else goto <D.22838>;
    <D.22837>:
    {
      int slot;
      int vtable_offset;
      void * * vtable_slot;

      slot = mono_method_get_vtable_index (imt_method);
      D.22839 = slot == -1;
      D.22840 = (long int) D.22839;
      D.22841 = __builtin_expect (D.22840, 0);
      if (D.22841 != 0) goto <D.22842>; else goto <D.22843>;
      <D.22842>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 229, "slot != -1");
      <D.22843>:
      vtable_offset = interface_offset + slot;
      vtable_slot = &vt->vtable[vtable_offset];
      D.22769 = vtable_slot;
      return D.22769;
    }
    <D.22838>:
    D.22769 = slot;
    return D.22769;
  }
}


is_generic_method_definition (struct MonoMethod * m)
{
  unsigned char D.22845;
  unsigned char D.22846;
  gboolean D.22849;
  unsigned char D.22850;
  struct MonoGenericInst * D.22853;
  struct MonoMethod * D.22856;
  struct MonoGenericContainer * D.22857;
  struct MonoGenericInst * D.22858;
  struct MonoGenericContext * context;

  D.22845 = BIT_FIELD_REF <*m, 8, 168>;
  D.22846 = D.22845 & 8;
  if (D.22846 != 0) goto <D.22847>; else goto <D.22848>;
  <D.22847>:
  D.22849 = 1;
  return D.22849;
  <D.22848>:
  D.22845 = BIT_FIELD_REF <*m, 8, 168>;
  D.22850 = D.22845 & 16;
  if (D.22850 == 0) goto <D.22851>; else goto <D.22852>;
  <D.22851>:
  D.22849 = 0;
  return D.22849;
  <D.22852>:
  context = mono_method_get_context (m);
  D.22853 = context->method_inst;
  if (D.22853 == 0B) goto <D.22854>; else goto <D.22855>;
  <D.22854>:
  D.22849 = 0;
  return D.22849;
  <D.22855>:
  D.22853 = context->method_inst;
  D.22856 = MEM[(struct MonoMethodInflated *)m].declaring;
  D.22857 = mono_method_get_generic_container (D.22856);
  D.22858 = D.22857->context.method_inst;
  if (D.22853 == D.22858) goto <D.22859>; else goto <D.22860>;
  <D.22859>:
  D.22849 = 1;
  return D.22849;
  <D.22860>:
  D.22849 = 0;
  return D.22849;
}


mono_generic_virtual_remoting_trampoline (mgreg_t * regs, guint8 * code, struct MonoMethod * m, guint8 * tramp)
{
  unsigned int trampoline_calls.18;
  unsigned int trampoline_calls.19;
  unsigned char D.22864;
  unsigned char D.22865;
  _Bool D.22866;
  long int D.22867;
  long int D.22868;
  unsigned char D.22871;
  struct MonoClass * D.22875;
  struct MonoGenericClass * D.22876;
  struct MonoGenericInst * D.22879;
  struct MonoGenericContainer * D.22881;
  _Bool D.22882;
  long int D.22883;
  long int D.22884;
  unsigned char D.22887;
  unsigned char D.22888;
  struct MonoGenericInst * D.22891;
  _Bool D.22892;
  long int D.22893;
  long int D.22894;
  void * D.22897;
  struct MonoGenericContext context;
  struct MonoMethod * imt_method;
  struct MonoMethod * declaring;
  void * addr;

  try
    {
      context.class_inst = 0B;
      context.method_inst = 0B;
      trampoline_calls.18 = trampoline_calls;
      trampoline_calls.19 = trampoline_calls.18 + 1;
      trampoline_calls = trampoline_calls.19;
      D.22864 = BIT_FIELD_REF <*m, 8, 168>;
      D.22865 = D.22864 & 8;
      D.22866 = D.22865 == 0;
      D.22867 = (long int) D.22866;
      D.22868 = __builtin_expect (D.22867, 0);
      if (D.22868 != 0) goto <D.22869>; else goto <D.22870>;
      <D.22869>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 786, "m->is_generic");
      <D.22870>:
      D.22864 = BIT_FIELD_REF <*m, 8, 168>;
      D.22871 = D.22864 & 16;
      if (D.22871 != 0) goto <D.22872>; else goto <D.22873>;
      <D.22872>:
      declaring = mono_method_get_declaring_generic_method (m);
      goto <D.22874>;
      <D.22873>:
      declaring = m;
      <D.22874>:
      D.22875 = m->klass;
      D.22876 = D.22875->generic_class;
      if (D.22876 != 0B) goto <D.22877>; else goto <D.22878>;
      <D.22877>:
      D.22875 = m->klass;
      D.22876 = D.22875->generic_class;
      D.22879 = D.22876->context.class_inst;
      context.class_inst = D.22879;
      goto <D.22880>;
      <D.22878>:
      D.22875 = m->klass;
      D.22881 = D.22875->generic_container;
      D.22882 = D.22881 != 0B;
      D.22883 = (long int) D.22882;
      D.22884 = __builtin_expect (D.22883, 0);
      if (D.22884 != 0) goto <D.22885>; else goto <D.22886>;
      <D.22885>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 796, "!m->klass->generic_container");
      <D.22886>:
      <D.22880>:
      imt_method = mono_arch_find_imt_method (regs, code);
      D.22887 = BIT_FIELD_REF <*imt_method, 8, 168>;
      D.22888 = D.22887 & 16;
      if (D.22888 != 0) goto <D.22889>; else goto <D.22890>;
      <D.22889>:
      D.22891 = MEM[(struct MonoMethodInflated *)imt_method].context.method_inst;
      context.method_inst = D.22891;
      <D.22890>:
      m = mono_class_inflate_generic_method (declaring, &context);
      m = mono_marshal_get_remoting_invoke_with_check (m);
      addr = mono_compile_method (m);
      D.22892 = addr == 0B;
      D.22893 = (long int) D.22892;
      D.22894 = __builtin_expect (D.22893, 0);
      if (D.22894 != 0) goto <D.22895>; else goto <D.22896>;
      <D.22895>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 807, "addr");
      <D.22896>:
      D.22897 = addr;
      return D.22897;
    }
  finally
    {
      context = {CLOBBER};
    }
}


mono_aot_trampoline (mgreg_t * regs, guint8 * code, guint8 * token_info, guint8 * tramp)
{
  unsigned int trampoline_calls.20;
  unsigned int trampoline_calls.21;
  struct MonoDomain * D.22902;
  _Bool D.22905;
  long int D.22906;
  long int D.22907;
  void * D.22910;
  struct MonoDomain * D.22911;
  _Bool D.22912;
  long int D.22913;
  long int D.22914;
  struct MonoImage * image;
  guint32 token;
  struct MonoMethod * method;
  void * addr;
  guint8 * plt_entry;

  method = 0B;
  trampoline_calls.20 = trampoline_calls;
  trampoline_calls.21 = trampoline_calls.20 + 1;
  trampoline_calls = trampoline_calls.21;
  image = MEM[(void * *)token_info];
  token_info = token_info + 4;
  token = MEM[(guint32 *)token_info];
  D.22902 = mono_domain_get ();
  addr = mono_aot_get_method_from_token (D.22902, image, token);
  if (addr == 0B) goto <D.22903>; else goto <D.22904>;
  <D.22903>:
  method = mono_get_method (image, token, 0B);
  D.22905 = method == 0B;
  D.22906 = (long int) D.22905;
  D.22907 = __builtin_expect (D.22906, 0);
  if (D.22907 != 0) goto <D.22908>; else goto <D.22909>;
  <D.22908>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 839, "method");
  <D.22909>:
  D.22910 = mono_magic_trampoline (regs, code, method, tramp);
  return D.22910;
  <D.22904>:
  D.22911 = mono_domain_get ();
  addr = mono_create_ftnptr (D.22911, addr);
  plt_entry = mono_aot_get_plt_entry (code);
  D.22912 = plt_entry == 0B;
  D.22913 = (long int) D.22912;
  D.22914 = __builtin_expect (D.22913, 0);
  if (D.22914 != 0) goto <D.22915>; else goto <D.22916>;
  <D.22915>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 849, "plt_entry");
  <D.22916>:
  mono_aot_patch_plt_entry (plt_entry, 0B, regs, addr);
  D.22910 = addr;
  return D.22910;
}


mono_aot_plt_trampoline (mgreg_t * regs, guint8 * code, guint8 * aot_module, guint8 * tramp)
{
  unsigned int trampoline_calls.22;
  unsigned int trampoline_calls.23;
  struct MonoLoaderError * D.22922;
  struct MonoLoaderError * D.22925;
  struct MonoException * D.22926;
  _Bool D.22927;
  long int D.22928;
  long int D.22929;
  void * D.22932;
  guint32 plt_info_offset;
  void * res;

  plt_info_offset = mono_aot_get_plt_info_offset (regs, code);
  trampoline_calls.22 = trampoline_calls;
  trampoline_calls.23 = trampoline_calls.22 + 1;
  trampoline_calls = trampoline_calls.23;
  res = mono_aot_plt_resolve (aot_module, plt_info_offset, code);
  if (res == 0B) goto <D.22920>; else goto <D.22921>;
  <D.22920>:
  D.22922 = mono_loader_get_last_error ();
  if (D.22922 != 0B) goto <D.22923>; else goto <D.22924>;
  <D.22923>:
  D.22925 = mono_loader_get_last_error ();
  D.22926 = mono_loader_error_prepare_exception (D.22925);
  mono_raise_exception (D.22926);
  <D.22924>:
  D.22927 = res == 0B;
  D.22928 = (long int) D.22927;
  D.22929 = __builtin_expect (D.22928, 0);
  if (D.22929 != 0) goto <D.22930>; else goto <D.22931>;
  <D.22930>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 875, "res");
  <D.22931>:
  <D.22921>:
  D.22932 = res;
  return D.22932;
}


mono_class_init_trampoline (mgreg_t * regs, guint8 * code, struct MonoVTable * vtable, guint8 * tramp)
{
  unsigned int trampoline_calls.24;
  unsigned int trampoline_calls.25;
  unsigned char D.22936;
  unsigned char D.22937;
  guint8 * plt_entry;

  plt_entry = mono_aot_get_plt_entry (code);
  trampoline_calls.24 = trampoline_calls;
  trampoline_calls.25 = trampoline_calls.24 + 1;
  trampoline_calls = trampoline_calls.25;
  mono_runtime_class_init (vtable);
  D.22936 = BIT_FIELD_REF <*vtable, 8, 184>;
  D.22937 = D.22936 & 2;
  if (D.22937 != 0) goto <D.22938>; else goto <D.22939>;
  <D.22938>:
  if (plt_entry != 0B) goto <D.22940>; else goto <D.22941>;
  <D.22940>:
  mono_arch_nullify_plt_entry (plt_entry, regs);
  goto <D.22942>;
  <D.22941>:
  mono_arch_nullify_class_init_trampoline (code, regs);
  <D.22942>:
  <D.22939>:
}


mono_generic_class_init_trampoline (mgreg_t * regs, guint8 * code, struct MonoVTable * vtable, guint8 * tramp)
{
  unsigned int trampoline_calls.26;
  unsigned int trampoline_calls.27;

  trampoline_calls.26 = trampoline_calls;
  trampoline_calls.27 = trampoline_calls.26 + 1;
  trampoline_calls = trampoline_calls.27;
  mono_runtime_class_init (vtable);
}


mono_monitor_enter_trampoline (mgreg_t * regs, guint8 * code, struct MonoObject * obj, guint8 * tramp)
{
  mono_monitor_enter (obj);
}


mono_monitor_exit_trampoline (mgreg_t * regs, guint8 * code, struct MonoObject * obj, guint8 * tramp)
{
  mono_monitor_exit (obj);
}


mono_delegate_trampoline (mgreg_t * regs, guint8 * code, void * * tramp_data, guint8 * tramp)
{
  unsigned int trampoline_calls.28;
  unsigned int trampoline_calls.29;
  struct MonoMethod * D.22947;
  struct MonoObject * D.22952;
  struct MonoVTable * D.22954;
  struct MonoClass * D.22955;
  struct MonoClass * D.22956;
  struct MonoRemoteClass * D.22958;
  struct MonoClass * D.22959;
  struct MonoClass * D.22960;
  unsigned char D.22963;
  unsigned char D.22964;
  unsigned char D.22969;
  unsigned char D.22970;
  struct MonoClass * D.22973;
  unsigned char D.22974;
  unsigned char D.22975;
  int mono_aot_only.30;
  void * D.22983;
  void * D.22984;
  int iftmp.31;
  short unsigned int D.22998;
  unsigned int D.22999;
  unsigned int D.23000;
  unsigned int D.23003;
  unsigned int D.23004;
  short unsigned int D.23009;
  int D.23010;
  int D.23011;
  int D.23016;
  _Bool D.23019;
  _Bool D.23020;
  _Bool D.23021;
  guint8 * * D.23027;
  guint8 * D.23029;
  void * D.23038;
  struct MonoMulticastDelegate * D.23039;
  _Bool D.23040;
  int D.23041;
  int D.23047;
  int D.23048;
  struct MonoMethodSignature * D.23050;
  short unsigned int D.23051;
  int D.23052;
  struct MonoMethodSignature * D.23053;
  short unsigned int D.23054;
  int D.23055;
  int D.23056;
  guint8 * iftmp.32;
  void * D.23064;
  void * D.23065;
  int D.23066;
  void * D.23067;
  struct MonoDomain * domain;
  struct MonoDelegate * delegate;
  struct MonoJitInfo * ji;
  struct MonoMethod * m;
  struct MonoMethod * method;
  gboolean multicast;
  gboolean callvirt;
  gboolean need_rgctx_tramp;
  gboolean need_unbox_tramp;
  gboolean enable_caching;
  struct MonoMethod * invoke;
  guint8 * impl_this;
  guint8 * impl_nothis;
  struct MonoError err;
  struct MonoMethodSignature * sig;
  void * addr;
  void * compiled_method;

  try
    {
      domain = mono_domain_get ();
      method = 0B;
      callvirt = 0;
      need_rgctx_tramp = 0;
      need_unbox_tramp = 0;
      enable_caching = 1;
      invoke = *tramp_data;
      impl_this = MEM[(void * *)tramp_data + 4B];
      impl_nothis = MEM[(void * *)tramp_data + 8B];
      trampoline_calls.28 = trampoline_calls;
      trampoline_calls.29 = trampoline_calls.28 + 1;
      trampoline_calls = trampoline_calls.29;
      delegate = mono_arch_get_this_arg_from_call (regs, code);
      D.22947 = delegate->method;
      if (D.22947 != 0B) goto <D.22948>; else goto <D.22949>;
      <D.22948>:
      method = delegate->method;
      D.22952 = delegate->target;
      if (D.22952 != 0B) goto <D.22953>; else goto <D.22950>;
      <D.22953>:
      D.22952 = delegate->target;
      D.22954 = D.22952->vtable;
      D.22955 = D.22954->klass;
      D.22956 = mono_defaults.transparent_proxy_class;
      if (D.22955 == D.22956) goto <D.22957>; else goto <D.22950>;
      <D.22957>:
      D.22952 = delegate->target;
      D.22958 = MEM[(struct MonoTransparentProxy *)D.22952].remote_class;
      D.22959 = D.22958->proxy_class;
      D.22960 = mono_class_get_com_object_class ();
      if (D.22959 != D.22960) goto <D.22961>; else goto <D.22962>;
      <D.22961>:
      D.22952 = delegate->target;
      D.22958 = MEM[(struct MonoTransparentProxy *)D.22952].remote_class;
      D.22959 = D.22958->proxy_class;
      D.22963 = BIT_FIELD_REF <*D.22959, 8, 184>;
      D.22964 = D.22963 & 64;
      if (D.22964 == 0) goto <D.22965>; else goto <D.22966>;
      <D.22965>:
      method = mono_marshal_get_remoting_invoke (method);
      <D.22966>:
      <D.22962>:
      goto <D.22951>;
      <D.22950>:
      mono_error_init (&err);
      sig = mono_method_signature_checked (method, &err);
      if (sig == 0B) goto <D.22967>; else goto <D.22968>;
      <D.22967>:
      mono_error_raise_exception (&err);
      <D.22968>:
      D.22969 = BIT_FIELD_REF <*sig, 8, 80>;
      D.22970 = D.22969 & 64;
      if (D.22970 != 0) goto <D.22971>; else goto <D.22972>;
      <D.22971>:
      D.22973 = method->klass;
      D.22974 = BIT_FIELD_REF <*D.22973, 8, 160>;
      D.22975 = D.22974 & 8;
      if (D.22975 != 0) goto <D.22976>; else goto <D.22977>;
      <D.22976>:
      mono_aot_only.30 = mono_aot_only;
      if (mono_aot_only.30 != 0) goto <D.22979>; else goto <D.22980>;
      <D.22979>:
      need_unbox_tramp = 1;
      goto <D.22981>;
      <D.22980>:
      method = mono_marshal_get_unbox_wrapper (method);
      <D.22981>:
      <D.22977>:
      <D.22972>:
      <D.22951>:
      goto <D.22982>;
      <D.22949>:
      D.22983 = delegate->method_ptr;
      D.22984 = mono_get_addr_from_ftnptr (D.22983);
      ji = mono_jit_info_table_find (domain, D.22984);
      if (ji != 0B) goto <D.22985>; else goto <D.22986>;
      <D.22985>:
      method = jinfo_get_method (ji);
      <D.22986>:
      <D.22982>:
      if (method != 0B) goto <D.22987>; else goto <D.22988>;
      <D.22987>:
      mono_error_init (&err);
      sig = mono_method_signature_checked (method, &err);
      if (sig == 0B) goto <D.22989>; else goto <D.22990>;
      <D.22989>:
      mono_error_raise_exception (&err);
      <D.22990>:
      D.22952 = delegate->target;
      if (D.22952 == 0B) goto <D.22994>; else goto <D.22992>;
      <D.22994>:
      D.22969 = BIT_FIELD_REF <*sig, 8, 80>;
      D.22970 = D.22969 & 64;
      if (D.22970 != 0) goto <D.22995>; else goto <D.22992>;
      <D.22995>:
      iftmp.31 = 1;
      goto <D.22993>;
      <D.22992>:
      iftmp.31 = 0;
      <D.22993>:
      callvirt = iftmp.31;
      D.22952 = delegate->target;
      if (D.22952 != 0B) goto <D.22996>; else goto <D.22997>;
      <D.22996>:
      D.22998 = method->flags;
      D.22999 = (unsigned int) D.22998;
      D.23000 = D.22999 & 1088;
      if (D.23000 == 1088) goto <D.23001>; else goto <D.23002>;
      <D.23001>:
      D.22973 = method->klass;
      D.23003 = D.22973->flags;
      D.23004 = D.23003 & 128;
      if (D.23004 != 0) goto <D.23005>; else goto <D.23006>;
      <D.23005>:
      D.22952 = delegate->target;
      method = mono_object_get_virtual_method (D.22952, method);
      enable_caching = 0;
      <D.23006>:
      <D.23002>:
      <D.22997>:
      <D.22988>:
      if (method != 0B) goto <D.23007>; else goto <D.23008>;
      <D.23007>:
      D.23009 = method->iflags;
      D.23010 = (int) D.23009;
      D.23011 = D.23010 & 32;
      if (D.23011 != 0) goto <D.23012>; else goto <D.23013>;
      <D.23012>:
      method = mono_marshal_get_synchronized_wrapper (method);
      <D.23013>:
      <D.23008>:
      if (method != 0B) goto <D.23014>; else goto <D.23015>;
      <D.23014>:
      D.23016 = mono_method_needs_static_rgctx_invoke (method, 0);
      if (D.23016 != 0) goto <D.23017>; else goto <D.23018>;
      <D.23017>:
      need_rgctx_tramp = 1;
      <D.23018>:
      <D.23015>:
      D.23019 = method != 0B;
      D.23020 = callvirt == 0;
      D.23021 = D.23019 & D.23020;
      if (D.23021 != 0) goto <D.23022>; else goto <D.23023>;
      <D.23022>:
      if (enable_caching != 0) goto <D.23026>; else goto <D.23024>;
      <D.23026>:
      D.23027 = delegate->method_code;
      if (D.23027 != 0B) goto <D.23028>; else goto <D.23024>;
      <D.23028>:
      D.23027 = delegate->method_code;
      D.23029 = *D.23027;
      if (D.23029 != 0B) goto <D.23030>; else goto <D.23024>;
      <D.23030>:
      D.23027 = delegate->method_code;
      D.23029 = *D.23027;
      delegate->method_ptr = D.23029;
      goto <D.23025>;
      <D.23024>:
      addr = mono_compile_method (method);
      compiled_method = addr;
      addr = mini_add_method_trampoline (0B, method, compiled_method, need_rgctx_tramp, need_unbox_tramp);
      delegate->method_ptr = addr;
      if (enable_caching != 0) goto <D.23031>; else goto <D.23032>;
      <D.23031>:
      D.23027 = delegate->method_code;
      if (D.23027 != 0B) goto <D.23033>; else goto <D.23034>;
      <D.23033>:
      D.23027 = delegate->method_code;
      D.22983 = delegate->method_ptr;
      *D.23027 = D.22983;
      <D.23034>:
      <D.23032>:
      <D.23025>:
      goto <D.23035>;
      <D.23023>:
      if (need_rgctx_tramp != 0) goto <D.23036>; else goto <D.23037>;
      <D.23036>:
      D.22983 = delegate->method_ptr;
      D.23038 = mono_create_static_rgctx_trampoline (method, D.22983);
      delegate->method_ptr = D.23038;
      <D.23037>:
      <D.23035>:
      D.23039 = MEM[(struct MonoMulticastDelegate *)delegate].prev;
      D.23040 = D.23039 != 0B;
      multicast = (gboolean) D.23040;
      D.23041 = multicast | callvirt;
      if (D.23041 == 0) goto <D.23042>; else goto <D.23043>;
      <D.23042>:
      if (method != 0B) goto <D.23046>; else goto <D.23044>;
      <D.23046>:
      D.22998 = method->flags;
      D.23047 = (int) D.22998;
      D.23048 = D.23047 & 16;
      if (D.23048 != 0) goto <D.23049>; else goto <D.23044>;
      <D.23049>:
      D.23050 = mono_method_signature (method);
      D.23051 = D.23050->param_count;
      D.23052 = (int) D.23051;
      D.23053 = mono_method_signature (invoke);
      D.23054 = D.23053->param_count;
      D.23055 = (int) D.23054;
      D.23056 = D.23055 + 1;
      if (D.23052 == D.23056) goto <D.23057>; else goto <D.23044>;
      <D.23057>:
      code = impl_this;
      goto <D.23045>;
      <D.23044>:
      D.22952 = delegate->target;
      if (D.22952 != 0B) goto <D.23059>; else goto <D.23060>;
      <D.23059>:
      iftmp.32 = impl_this;
      goto <D.23061>;
      <D.23060>:
      iftmp.32 = impl_nothis;
      <D.23061>:
      code = iftmp.32;
      <D.23045>:
      if (code != 0B) goto <D.23062>; else goto <D.23063>;
      <D.23062>:
      D.23064 = mono_get_addr_from_ftnptr (code);
      delegate->invoke_impl = D.23064;
      D.23065 = code;
      return D.23065;
      <D.23063>:
      <D.23043>:
      m = mono_marshal_get_delegate_invoke (invoke, delegate);
      code = mono_compile_method (m);
      D.23066 = mono_method_needs_static_rgctx_invoke (m, 0);
      code = mini_add_method_trampoline (0B, m, code, D.23066, 0);
      D.23067 = mono_get_addr_from_ftnptr (code);
      delegate->invoke_impl = D.23067;
      D.23065 = code;
      return D.23065;
    }
  finally
    {
      err = {CLOBBER};
    }
}


mono_create_handler_block_trampoline ()
{
  void * code.33;
  void * D.23073;
  int mono_aot_only.34;
  _Bool D.23081;
  long int D.23082;
  long int D.23083;
  _Bool D.23090;
  long int D.23091;
  long int D.23092;
  static void * code;

  code.33 = code;
  if (code.33 != 0B) goto <D.23071>; else goto <D.23072>;
  <D.23071>:
  mono_memory_barrier ();
  D.23073 = code;
  return D.23073;
  <D.23072>:
  mono_aot_only.34 = mono_aot_only;
  if (mono_aot_only.34 != 0) goto <D.23075>; else goto <D.23076>;
  <D.23075>:
  if (1 != 0) goto <D.23077>; else goto <D.23078>;
  <D.23077>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1137, "0");
  <D.23078>:
  D.23073 = code;
  return D.23073;
  <D.23076>:
  {
    int ret;

    ret = pthread_mutex_lock (&trampolines_mutex.mutex);
    if (ret != 0) goto <D.23079>; else goto <D.23080>;
    <D.23079>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.23080>:
    D.23081 = ret != 0;
    D.23082 = (long int) D.23081;
    D.23083 = __builtin_expect (D.23082, 0);
    if (D.23083 != 0) goto <D.23084>; else goto <D.23085>;
    <D.23084>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1141, "ret == 0");
    <D.23085>:
  }
  code.33 = code;
  if (code.33 == 0B) goto <D.23086>; else goto <D.23087>;
  <D.23086>:
  {
    void * tmp;

    tmp = mono_arch_create_handler_block_trampoline ();
    mono_memory_barrier ();
    code = tmp;
  }
  <D.23087>:
  {
    int ret;

    ret = pthread_mutex_unlock (&trampolines_mutex.mutex);
    if (ret != 0) goto <D.23088>; else goto <D.23089>;
    <D.23088>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.23089>:
    D.23090 = ret != 0;
    D.23091 = (long int) D.23090;
    D.23092 = __builtin_expect (D.23091, 0);
    if (D.23092 != 0) goto <D.23093>; else goto <D.23094>;
    <D.23093>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1148, "ret == 0");
    <D.23094>:
  }
  D.23073 = code;
  return D.23073;
}


mono_memory_barrier ()
{
  __sync_synchronize ();
}


mono_get_trampoline_func (MonoTrampolineType tramp_type)
{
  const void * D.23096;

  switch (tramp_type) <default: <D.22179>, case 0: <D.22165>, case 1: <D.22166>, case 2: <D.22167>, case 3: <D.22168>, case 4: <D.22169>, case 5: <D.22170>, case 6: <D.22171>, case 7: <D.22172>, case 8: <D.22173>, case 9: <D.22174>, case 10: <D.22175>, case 11: <D.22176>, case 12: <D.22177>, case 13: <D.22178>>
  <D.22165>:
  <D.22166>:
  D.23096 = mono_magic_trampoline;
  return D.23096;
  <D.22167>:
  D.23096 = mono_class_init_trampoline;
  return D.23096;
  <D.22168>:
  D.23096 = mono_generic_class_init_trampoline;
  return D.23096;
  <D.22169>:
  D.23096 = mono_rgctx_lazy_fetch_trampoline;
  return D.23096;
  <D.22170>:
  D.23096 = mono_aot_trampoline;
  return D.23096;
  <D.22171>:
  D.23096 = mono_aot_plt_trampoline;
  return D.23096;
  <D.22172>:
  D.23096 = mono_delegate_trampoline;
  return D.23096;
  <D.22173>:
  D.23096 = mono_altstack_restore_prot;
  return D.23096;
  <D.22174>:
  D.23096 = mono_generic_virtual_remoting_trampoline;
  return D.23096;
  <D.22175>:
  D.23096 = mono_monitor_enter_trampoline;
  return D.23096;
  <D.22176>:
  D.23096 = mono_monitor_exit_trampoline;
  return D.23096;
  <D.22177>:
  D.23096 = mono_vcall_trampoline;
  return D.23096;
  <D.22178>:
  D.23096 = mono_handler_block_guard_trampoline;
  return D.23096;
  <D.22179>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-trampolines.c", 1200);
  D.23096 = 0B;
  return D.23096;
}


mono_handler_block_guard_trampoline (mgreg_t * regs, guint8 * code, void * * tramp_data, guint8 * tramp)
{
  unsigned int mono_jit_tls_id.35;
  struct MonoContext * D.23099;
  void * D.23100;
  int D.23101;
  void * D.23107;
  struct MonoContext ctx;
  struct MonoException * exc;
  struct MonoJitTlsData * jit_tls;
  void * resume_ip;

  try
    {
      mono_jit_tls_id.35 = mono_jit_tls_id;
      jit_tls = pthread_getspecific (mono_jit_tls_id.35);
      resume_ip = jit_tls->handler_block_return_address;
      D.23099 = &jit_tls->handler_block_context;
      memcpy (&ctx, D.23099, 36);
      D.23100 = jit_tls->handler_block_return_address;
      D.23101 = (int) D.23100;
      ctx.eip = D.23101;
      jit_tls->handler_block_return_address = 0B;
      jit_tls->handler_block = 0B;
      if (resume_ip == 0B) goto <D.23102>; else goto <D.23103>;
      <D.23102>:
      exc = mono_get_exception_execution_engine ("Invalid internal state, resuming abort after handler block but no resume ip found");
      goto <D.23104>;
      <D.23103>:
      exc = mono_thread_resume_interruption ();
      <D.23104>:
      if (exc != 0B) goto <D.23105>; else goto <D.23106>;
      <D.23105>:
      mono_handle_exception (&ctx, exc);
      mono_restore_context (&ctx);
      <D.23106>:
      D.23107 = resume_ip;
      return D.23107;
    }
  finally
    {
      ctx = {CLOBBER};
    }
}


memcpy (void * restrict __dest, const void * restrict __src, size_t __len)
{
  void * D.23110;
  unsigned int D.23111;

  D.23111 = __builtin_object_size (__dest, 0);
  D.23110 = __builtin___memcpy_chk (__dest, __src, __len, D.23111);
  return D.23110;
}


mono_vcall_trampoline (mgreg_t * regs, guint8 * code, int slot, guint8 * tramp)
{
  unsigned int trampoline_calls.36;
  unsigned int trampoline_calls.37;
  _Bool D.23115;
  long int D.23116;
  long int D.23117;
  struct MonoDomain * D.23122;
  struct MonoClass * D.23125;
  unsigned char D.23126;
  unsigned char D.23127;
  struct MonoDomain * D.23130;
  int D.23131;
  void * D.23134;
  struct MonoDomain * D.23135;
  unsigned int slot.38;
  unsigned int D.23138;
  struct MonoObject * this;
  struct MonoVTable * vt;
  void * * vtable_slot;
  struct MonoMethod * m;
  gboolean need_rgctx_tramp;
  void * addr;

  need_rgctx_tramp = 0;
  trampoline_calls.36 = trampoline_calls;
  trampoline_calls.37 = trampoline_calls.36 + 1;
  trampoline_calls = trampoline_calls.37;
  this = mono_arch_get_this_arg_from_call (regs, code);
  D.23115 = this == 0B;
  D.23116 = (long int) D.23115;
  D.23117 = __builtin_expect (D.23116, 0);
  if (D.23117 != 0) goto <D.23118>; else goto <D.23119>;
  <D.23118>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 732, "this");
  <D.23119>:
  vt = this->vtable;
  if (slot >= 0) goto <D.23120>; else goto <D.23121>;
  <D.23120>:
  vtable_slot = &vt->vtable[slot];
  D.23122 = mono_domain_get ();
  addr = mono_aot_get_method_from_vt_slot (D.23122, vt, slot);
  if (addr != 0B) goto <D.23123>; else goto <D.23124>;
  <D.23123>:
  D.23125 = vt->klass;
  D.23126 = BIT_FIELD_REF <*D.23125, 8, 160>;
  D.23127 = D.23126 & 8;
  if (D.23127 == 0) goto <D.23128>; else goto <D.23129>;
  <D.23128>:
  D.23130 = mono_domain_get ();
  D.23131 = mono_domain_owns_vtable_slot (D.23130, vtable_slot);
  if (D.23131 != 0) goto <D.23132>; else goto <D.23133>;
  <D.23132>:
  *vtable_slot = addr;
  <D.23133>:
  D.23135 = mono_domain_get ();
  D.23134 = mono_create_ftnptr (D.23135, addr);
  return D.23134;
  <D.23129>:
  <D.23124>:
  D.23125 = vt->klass;
  m = mono_class_get_vtable_entry (D.23125, slot);
  need_rgctx_tramp = mono_method_needs_static_rgctx_invoke (m, 0);
  goto <D.23136>;
  <D.23121>:
  slot.38 = (unsigned int) slot;
  D.23138 = slot.38 * 4;
  vtable_slot = vt + D.23138;
  m = 0B;
  need_rgctx_tramp = 0;
  <D.23136>:
  D.23134 = common_call_trampoline (regs, code, m, tramp, vt, vtable_slot, need_rgctx_tramp);
  return D.23134;
}


mono_rgctx_lazy_fetch_trampoline (mgreg_t * regs, guint8 * code, void * data, guint8 * tramp)
{
  mgreg_t * D.23140;
  int D.23141;
  signed int slot.39;
  _Bool D.23143;
  unsigned int trampoline_calls.40;
  unsigned int trampoline_calls.41;
  int inited.42;
  int num_lookups.43;
  int num_lookups.44;
  void * D.23153;
  static gboolean inited = 0;
  static int num_lookups = 0;
  guint32 slot;
  mgreg_t * r;
  void * arg;
  guint32 index;
  gboolean mrgctx;

  slot = (guint32) data;
  r = regs;
  D.23140 = r + 8;
  D.23141 = *D.23140;
  arg = (void *) D.23141;
  index = slot & 2147483647;
  slot.39 = (signed int) slot;
  D.23143 = slot.39 < 0;
  mrgctx = (gboolean) D.23143;
  trampoline_calls.40 = trampoline_calls;
  trampoline_calls.41 = trampoline_calls.40 + 1;
  trampoline_calls = trampoline_calls.41;
  inited.42 = inited;
  if (inited.42 == 0) goto <D.23147>; else goto <D.23148>;
  <D.23147>:
  mono_counters_register ("RGCTX unmanaged lookups", 2048, &num_lookups);
  inited = 1;
  <D.23148>:
  num_lookups.43 = num_lookups;
  num_lookups.44 = num_lookups.43 + 1;
  num_lookups = num_lookups.44;
  if (mrgctx != 0) goto <D.23151>; else goto <D.23152>;
  <D.23151>:
  D.23153 = mono_method_fill_runtime_generic_context (arg, code, index);
  return D.23153;
  <D.23152>:
  D.23153 = mono_class_fill_runtime_generic_context (arg, code, index);
  return D.23153;
}


mono_trampolines_init ()
{
  int mono_aot_only.45;
  guchar * D.23158;
  guchar * D.23159;
  guchar * D.23160;
  guchar * D.23161;
  guchar * D.23162;
  guchar * D.23163;
  guchar * D.23164;
  guchar * D.23165;
  guchar * D.23166;
  guchar * D.23167;
  guchar * D.23168;
  guchar * D.23169;
  guchar * D.23170;
  guchar * D.23171;

  InitializeCriticalSection (&trampolines_mutex);
  mono_aot_only.45 = mono_aot_only;
  if (mono_aot_only.45 != 0) goto <D.23156>; else goto <D.23157>;
  <D.23156>:
  return;
  <D.23157>:
  D.23158 = create_trampoline_code (0);
  mono_trampoline_code[0] = D.23158;
  D.23159 = create_trampoline_code (1);
  mono_trampoline_code[1] = D.23159;
  D.23160 = create_trampoline_code (2);
  mono_trampoline_code[2] = D.23160;
  D.23161 = create_trampoline_code (3);
  mono_trampoline_code[3] = D.23161;
  D.23162 = create_trampoline_code (4);
  mono_trampoline_code[4] = D.23162;
  D.23163 = create_trampoline_code (5);
  mono_trampoline_code[5] = D.23163;
  D.23164 = create_trampoline_code (6);
  mono_trampoline_code[6] = D.23164;
  D.23165 = create_trampoline_code (7);
  mono_trampoline_code[7] = D.23165;
  D.23166 = create_trampoline_code (8);
  mono_trampoline_code[8] = D.23166;
  D.23167 = create_trampoline_code (9);
  mono_trampoline_code[9] = D.23167;
  D.23168 = create_trampoline_code (10);
  mono_trampoline_code[10] = D.23168;
  D.23169 = create_trampoline_code (11);
  mono_trampoline_code[11] = D.23169;
  D.23170 = create_trampoline_code (12);
  mono_trampoline_code[12] = D.23170;
  D.23171 = create_trampoline_code (13);
  mono_trampoline_code[13] = D.23171;
  mono_create_handler_block_trampoline ();
  mono_counters_register ("Calls to trampolines", 256, &trampoline_calls);
  mono_counters_register ("JIT trampolines", 256, &jit_trampolines);
  mono_counters_register ("Unbox trampolines", 256, &unbox_trampolines);
  mono_counters_register ("Static rgctx trampolines", 256, &static_rgctx_trampolines);
}


create_trampoline_code (MonoTrampolineType tramp_type)
{
  struct MonoTrampInfo * info.46;
  guchar * D.23174;
  struct MonoTrampInfo * info;
  guchar * code;

  try
    {
      code = mono_arch_create_generic_trampoline (tramp_type, &info, 0);
      info.46 = info;
      mono_tramp_info_register (info.46);
      D.23174 = code;
      return D.23174;
    }
  finally
    {
      info = {CLOBBER};
    }
}


mono_trampolines_cleanup ()
{
  struct GHashTable * class_init_hash_addr.47;
  struct GHashTable * rgctx_lazy_fetch_trampoline_hash.48;
  struct GHashTable * rgctx_lazy_fetch_trampoline_hash_addr.49;

  class_init_hash_addr.47 = class_init_hash_addr;
  if (class_init_hash_addr.47 != 0B) goto <D.23178>; else goto <D.23179>;
  <D.23178>:
  class_init_hash_addr.47 = class_init_hash_addr;
  monoeg_g_hash_table_destroy (class_init_hash_addr.47);
  <D.23179>:
  rgctx_lazy_fetch_trampoline_hash.48 = rgctx_lazy_fetch_trampoline_hash;
  if (rgctx_lazy_fetch_trampoline_hash.48 != 0B) goto <D.23181>; else goto <D.23182>;
  <D.23181>:
  rgctx_lazy_fetch_trampoline_hash.48 = rgctx_lazy_fetch_trampoline_hash;
  monoeg_g_hash_table_destroy (rgctx_lazy_fetch_trampoline_hash.48);
  <D.23182>:
  rgctx_lazy_fetch_trampoline_hash_addr.49 = rgctx_lazy_fetch_trampoline_hash_addr;
  if (rgctx_lazy_fetch_trampoline_hash_addr.49 != 0B) goto <D.23184>; else goto <D.23185>;
  <D.23184>:
  rgctx_lazy_fetch_trampoline_hash_addr.49 = rgctx_lazy_fetch_trampoline_hash_addr;
  monoeg_g_hash_table_destroy (rgctx_lazy_fetch_trampoline_hash_addr.49);
  <D.23185>:
  DeleteCriticalSection (&trampolines_mutex);
}


mono_get_trampoline_code (MonoTrampolineType tramp_type)
{
  guint8 * D.23186;
  _Bool D.23187;
  long int D.23188;
  long int D.23189;
  guint8 * D.23192;

  D.23186 = mono_trampoline_code[tramp_type];
  D.23187 = D.23186 == 0B;
  D.23188 = (long int) D.23187;
  D.23189 = __builtin_expect (D.23188, 0);
  if (D.23189 != 0) goto <D.23190>; else goto <D.23191>;
  <D.23190>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1271, "mono_trampoline_code [tramp_type]");
  <D.23191>:
  D.23192 = mono_trampoline_code[tramp_type];
  return D.23192;
}


mono_create_specific_trampoline (void * arg1, MonoTrampolineType tramp_type, struct MonoDomain * domain, guint32 * code_len)
{
  int mono_aot_only.50;
  void * D.23197;
  struct MonoImage * D.23198;

  mono_aot_only.50 = mono_aot_only;
  if (mono_aot_only.50 != 0) goto <D.23195>; else goto <D.23196>;
  <D.23195>:
  D.23198 = mono_defaults.corlib;
  D.23197 = mono_aot_create_specific_trampoline (D.23198, arg1, tramp_type, domain, code_len);
  return D.23197;
  <D.23196>:
  D.23197 = mono_arch_create_specific_trampoline (arg1, tramp_type, domain, code_len);
  return D.23197;
}


mono_create_class_init_trampoline (struct MonoVTable * vtable)
{
  struct MonoClass * D.23200;
  struct MonoGenericContainer * D.23201;
  _Bool D.23202;
  long int D.23203;
  long int D.23204;
  union mono_mutex_t * D.23207;
  _Bool D.23210;
  long int D.23211;
  long int D.23212;
  void * D.23215;
  struct GHashTable * D.23216;
  _Bool D.23219;
  long int D.23220;
  long int D.23221;
  void * D.23226;
  _Bool D.23229;
  long int D.23230;
  long int D.23231;
  _Bool D.23236;
  long int D.23237;
  long int D.23238;
  _Bool D.23243;
  long int D.23244;
  long int D.23245;
  struct GHashTable * class_init_hash_addr.51;
  struct GHashTable * class_init_hash_addr.52;
  _Bool D.23254;
  long int D.23255;
  long int D.23256;
  void * code;
  void * ptr;
  struct MonoDomain * domain;

  domain = vtable->domain;
  D.23200 = vtable->klass;
  D.23201 = D.23200->generic_container;
  D.23202 = D.23201 != 0B;
  D.23203 = (long int) D.23202;
  D.23204 = __builtin_expect (D.23203, 0);
  if (D.23204 != 0) goto <D.23205>; else goto <D.23206>;
  <D.23205>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1291, "!vtable->klass->generic_container");
  <D.23206>:
  {
    int ret;

    D.23207 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.23207);
    if (ret != 0) goto <D.23208>; else goto <D.23209>;
    <D.23208>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.23209>:
    D.23210 = ret != 0;
    D.23211 = (long int) D.23210;
    D.23212 = __builtin_expect (D.23211, 0);
    if (D.23212 != 0) goto <D.23213>; else goto <D.23214>;
    <D.23213>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1294, "ret == 0");
    <D.23214>:
  }
  D.23215 = domain->runtime_info;
  D.23216 = MEM[(struct MonoJitDomainInfo *)D.23215].class_init_trampoline_hash;
  ptr = monoeg_g_hash_table_lookup (D.23216, vtable);
  {
    int ret;

    D.23207 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.23207);
    if (ret != 0) goto <D.23217>; else goto <D.23218>;
    <D.23217>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.23218>:
    D.23219 = ret != 0;
    D.23220 = (long int) D.23219;
    D.23221 = __builtin_expect (D.23220, 0);
    if (D.23221 != 0) goto <D.23222>; else goto <D.23223>;
    <D.23222>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1298, "ret == 0");
    <D.23223>:
  }
  if (ptr != 0B) goto <D.23224>; else goto <D.23225>;
  <D.23224>:
  D.23226 = ptr;
  return D.23226;
  <D.23225>:
  code = mono_create_specific_trampoline (vtable, 2, domain, 0B);
  ptr = mono_create_ftnptr (domain, code);
  {
    int ret;

    D.23207 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.23207);
    if (ret != 0) goto <D.23227>; else goto <D.23228>;
    <D.23227>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.23228>:
    D.23229 = ret != 0;
    D.23230 = (long int) D.23229;
    D.23231 = __builtin_expect (D.23230, 0);
    if (D.23231 != 0) goto <D.23232>; else goto <D.23233>;
    <D.23232>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1307, "ret == 0");
    <D.23233>:
  }
  D.23215 = domain->runtime_info;
  D.23216 = MEM[(struct MonoJitDomainInfo *)D.23215].class_init_trampoline_hash;
  monoeg_g_hash_table_insert_replace (D.23216, vtable, ptr, 0);
  {
    int ret;

    D.23207 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.23207);
    if (ret != 0) goto <D.23234>; else goto <D.23235>;
    <D.23234>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.23235>:
    D.23236 = ret != 0;
    D.23237 = (long int) D.23236;
    D.23238 = __builtin_expect (D.23237, 0);
    if (D.23238 != 0) goto <D.23239>; else goto <D.23240>;
    <D.23239>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1310, "ret == 0");
    <D.23240>:
  }
  {
    int ret;

    ret = pthread_mutex_lock (&trampolines_mutex.mutex);
    if (ret != 0) goto <D.23241>; else goto <D.23242>;
    <D.23241>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.23242>:
    D.23243 = ret != 0;
    D.23244 = (long int) D.23243;
    D.23245 = __builtin_expect (D.23244, 0);
    if (D.23245 != 0) goto <D.23246>; else goto <D.23247>;
    <D.23246>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1312, "ret == 0");
    <D.23247>:
  }
  class_init_hash_addr.51 = class_init_hash_addr;
  if (class_init_hash_addr.51 == 0B) goto <D.23249>; else goto <D.23250>;
  <D.23249>:
  class_init_hash_addr.52 = monoeg_g_hash_table_new (0B, 0B);
  class_init_hash_addr = class_init_hash_addr.52;
  <D.23250>:
  class_init_hash_addr.51 = class_init_hash_addr;
  monoeg_g_hash_table_insert_replace (class_init_hash_addr.51, ptr, vtable, 0);
  {
    int ret;

    ret = pthread_mutex_unlock (&trampolines_mutex.mutex);
    if (ret != 0) goto <D.23252>; else goto <D.23253>;
    <D.23252>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.23253>:
    D.23254 = ret != 0;
    D.23255 = (long int) D.23254;
    D.23256 = __builtin_expect (D.23255, 0);
    if (D.23256 != 0) goto <D.23257>; else goto <D.23258>;
    <D.23257>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1316, "ret == 0");
    <D.23258>:
  }
  D.23226 = ptr;
  return D.23226;
}


mono_create_generic_class_init_trampoline ()
{
  _Bool D.23262;
  long int D.23263;
  long int D.23264;
  void * code.53;
  int mono_aot_only.54;
  void * D.23273;
  void * code.55;
  void * code.56;
  struct MonoTrampInfo * info.57;
  _Bool D.23280;
  long int D.23281;
  long int D.23282;
  void * D.23285;
  static void * code;
  struct MonoTrampInfo * info;

  try
    {
      {
        int ret;

        ret = pthread_mutex_lock (&trampolines_mutex.mutex);
        if (ret != 0) goto <D.23260>; else goto <D.23261>;
        <D.23260>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.23261>:
        D.23262 = ret != 0;
        D.23263 = (long int) D.23262;
        D.23264 = __builtin_expect (D.23263, 0);
        if (D.23264 != 0) goto <D.23265>; else goto <D.23266>;
        <D.23265>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1328, "ret == 0");
        <D.23266>:
      }
      code.53 = code;
      if (code.53 == 0B) goto <D.23268>; else goto <D.23269>;
      <D.23268>:
      mono_aot_only.54 = mono_aot_only;
      if (mono_aot_only.54 != 0) goto <D.23271>; else goto <D.23272>;
      <D.23271>:
      D.23273 = mono_aot_get_trampoline ("generic_class_init_trampoline");
      code.55 = mono_get_addr_from_ftnptr (D.23273);
      code = code.55;
      goto <D.23275>;
      <D.23272>:
      code.56 = mono_arch_create_generic_class_init_trampoline (&info, 0);
      code = code.56;
      info.57 = info;
      mono_tramp_info_register (info.57);
      <D.23275>:
      <D.23269>:
      {
        int ret;

        ret = pthread_mutex_unlock (&trampolines_mutex.mutex);
        if (ret != 0) goto <D.23278>; else goto <D.23279>;
        <D.23278>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.23279>:
        D.23280 = ret != 0;
        D.23281 = (long int) D.23280;
        D.23282 = __builtin_expect (D.23281, 0);
        if (D.23282 != 0) goto <D.23283>; else goto <D.23284>;
        <D.23283>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1340, "ret == 0");
        <D.23284>:
      }
      D.23285 = code;
      return D.23285;
    }
  finally
    {
      info = {CLOBBER};
    }
}


mono_create_jump_trampoline (struct MonoDomain * domain, struct MonoMethod * method, gboolean add_sync_wrapper)
{
  struct MonoJitInfo * ji.58;
  unsigned char D.23291;
  unsigned char D.23292;
  short unsigned int D.23295;
  int D.23296;
  int D.23297;
  void * D.23300;
  union mono_mutex_t * D.23301;
  _Bool D.23304;
  long int D.23305;
  long int D.23306;
  void * D.23309;
  struct GHashTable * D.23310;
  _Bool D.23313;
  long int D.23314;
  long int D.23315;
  struct MonoDomain * D.23320;
  unsigned int code_size.59;
  _Bool D.23322;
  long int D.23323;
  long int D.23324;
  void * ji.60;
  int code_size.61;
  _Bool D.23331;
  long int D.23332;
  long int D.23333;
  void * D.23336;
  _Bool D.23339;
  long int D.23340;
  long int D.23341;
  struct MonoJitInfo * ji;
  void * code;
  guint32 code_size;

  try
    {
      code_size = 0;
      code = mono_jit_find_compiled_method_with_jit_info (domain, method, &ji);
      if (code != 0B) goto <D.23288>; else goto <D.23289>;
      <D.23288>:
      ji.58 = ji;
      D.23291 = BIT_FIELD_REF <*ji.58, 8, 176>;
      D.23292 = D.23291 & 2;
      if (D.23292 == 0) goto <D.23293>; else goto <D.23294>;
      <D.23293>:
      D.23295 = method->iflags;
      D.23296 = (int) D.23295;
      D.23297 = D.23296 & 32;
      if (D.23297 == 0) goto <D.23298>; else goto <D.23299>;
      <D.23298>:
      D.23300 = code;
      return D.23300;
      <D.23299>:
      <D.23294>:
      <D.23289>:
      {
        int ret;

        D.23301 = &domain->lock.mutex;
        ret = pthread_mutex_lock (D.23301);
        if (ret != 0) goto <D.23302>; else goto <D.23303>;
        <D.23302>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.23303>:
        D.23304 = ret != 0;
        D.23305 = (long int) D.23304;
        D.23306 = __builtin_expect (D.23305, 0);
        if (D.23306 != 0) goto <D.23307>; else goto <D.23308>;
        <D.23307>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1365, "ret == 0");
        <D.23308>:
      }
      D.23309 = domain->runtime_info;
      D.23310 = MEM[(struct MonoJitDomainInfo *)D.23309].jump_trampoline_hash;
      code = monoeg_g_hash_table_lookup (D.23310, method);
      {
        int ret;

        D.23301 = &domain->lock.mutex;
        ret = pthread_mutex_unlock (D.23301);
        if (ret != 0) goto <D.23311>; else goto <D.23312>;
        <D.23311>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.23312>:
        D.23313 = ret != 0;
        D.23314 = (long int) D.23313;
        D.23315 = __builtin_expect (D.23314, 0);
        if (D.23315 != 0) goto <D.23316>; else goto <D.23317>;
        <D.23316>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1367, "ret == 0");
        <D.23317>:
      }
      if (code != 0B) goto <D.23318>; else goto <D.23319>;
      <D.23318>:
      D.23300 = code;
      return D.23300;
      <D.23319>:
      D.23320 = mono_domain_get ();
      code = mono_create_specific_trampoline (method, 1, D.23320, &code_size);
      code_size.59 = code_size;
      D.23322 = code_size.59 == 0;
      D.23323 = (long int) D.23322;
      D.23324 = __builtin_expect (D.23323, 0);
      if (D.23324 != 0) goto <D.23325>; else goto <D.23326>;
      <D.23325>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1372, "code_size");
      <D.23326>:
      ji.60 = mono_domain_alloc0 (domain, 28);
      ji = ji.60;
      ji.58 = ji;
      ji.58->code_start = code;
      ji.58 = ji;
      code_size.59 = code_size;
      code_size.61 = (int) code_size.59;
      ji.58->code_size = code_size.61;
      ji.58 = ji;
      ji.58->d.method = method;
      ji.58 = ji;
      mono_jit_info_table_add (domain, ji.58);
      {
        int ret;

        D.23301 = &domain->lock.mutex;
        ret = pthread_mutex_lock (D.23301);
        if (ret != 0) goto <D.23329>; else goto <D.23330>;
        <D.23329>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.23330>:
        D.23331 = ret != 0;
        D.23332 = (long int) D.23331;
        D.23333 = __builtin_expect (D.23332, 0);
        if (D.23333 != 0) goto <D.23334>; else goto <D.23335>;
        <D.23334>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1386, "ret == 0");
        <D.23335>:
      }
      ji.58 = ji;
      D.23336 = ji.58->code_start;
      D.23309 = domain->runtime_info;
      D.23310 = MEM[(struct MonoJitDomainInfo *)D.23309].jump_trampoline_hash;
      monoeg_g_hash_table_insert_replace (D.23310, method, D.23336, 0);
      {
        int ret;

        D.23301 = &domain->lock.mutex;
        ret = pthread_mutex_unlock (D.23301);
        if (ret != 0) goto <D.23337>; else goto <D.23338>;
        <D.23337>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.23338>:
        D.23339 = ret != 0;
        D.23340 = (long int) D.23339;
        D.23341 = __builtin_expect (D.23340, 0);
        if (D.23341 != 0) goto <D.23342>; else goto <D.23343>;
        <D.23342>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1388, "ret == 0");
        <D.23343>:
      }
      ji.58 = ji;
      D.23300 = ji.58->code_start;
      return D.23300;
    }
  finally
    {
      ji = {CLOBBER};
      code_size = {CLOBBER};
    }
}


mono_create_jit_trampoline_in_domain (struct MonoDomain * domain, struct MonoMethod * method)
{
  int mono_aot_only.62;
  void * D.23351;
  union mono_mutex_t * D.23352;
  _Bool D.23355;
  long int D.23356;
  long int D.23357;
  void * D.23360;
  struct GHashTable * D.23361;
  _Bool D.23364;
  long int D.23365;
  long int D.23366;
  _Bool D.23373;
  long int D.23374;
  long int D.23375;
  _Bool D.23380;
  long int D.23381;
  long int D.23382;
  unsigned int jit_trampolines.63;
  unsigned int jit_trampolines.64;
  void * tramp;

  mono_aot_only.62 = mono_aot_only;
  if (mono_aot_only.62 != 0) goto <D.23347>; else goto <D.23348>;
  <D.23347>:
  {
    void * code;

    code = mono_jit_find_compiled_method (domain, method);
    if (code != 0B) goto <D.23349>; else goto <D.23350>;
    <D.23349>:
    D.23351 = code;
    return D.23351;
    <D.23350>:
  }
  <D.23348>:
  {
    int ret;

    D.23352 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.23352);
    if (ret != 0) goto <D.23353>; else goto <D.23354>;
    <D.23353>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.23354>:
    D.23355 = ret != 0;
    D.23356 = (long int) D.23355;
    D.23357 = __builtin_expect (D.23356, 0);
    if (D.23357 != 0) goto <D.23358>; else goto <D.23359>;
    <D.23358>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1406, "ret == 0");
    <D.23359>:
  }
  D.23360 = domain->runtime_info;
  D.23361 = MEM[(struct MonoJitDomainInfo *)D.23360].jit_trampoline_hash;
  tramp = monoeg_g_hash_table_lookup (D.23361, method);
  {
    int ret;

    D.23352 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.23352);
    if (ret != 0) goto <D.23362>; else goto <D.23363>;
    <D.23362>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.23363>:
    D.23364 = ret != 0;
    D.23365 = (long int) D.23364;
    D.23366 = __builtin_expect (D.23365, 0);
    if (D.23366 != 0) goto <D.23367>; else goto <D.23368>;
    <D.23367>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1408, "ret == 0");
    <D.23368>:
  }
  if (tramp != 0B) goto <D.23369>; else goto <D.23370>;
  <D.23369>:
  D.23351 = tramp;
  return D.23351;
  <D.23370>:
  tramp = mono_create_specific_trampoline (method, 0, domain, 0B);
  {
    int ret;

    D.23352 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.23352);
    if (ret != 0) goto <D.23371>; else goto <D.23372>;
    <D.23371>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.23372>:
    D.23373 = ret != 0;
    D.23374 = (long int) D.23373;
    D.23375 = __builtin_expect (D.23374, 0);
    if (D.23375 != 0) goto <D.23376>; else goto <D.23377>;
    <D.23376>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1414, "ret == 0");
    <D.23377>:
  }
  D.23360 = domain->runtime_info;
  D.23361 = MEM[(struct MonoJitDomainInfo *)D.23360].jit_trampoline_hash;
  monoeg_g_hash_table_insert_replace (D.23361, method, tramp, 0);
  {
    int ret;

    D.23352 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.23352);
    if (ret != 0) goto <D.23378>; else goto <D.23379>;
    <D.23378>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.23379>:
    D.23380 = ret != 0;
    D.23381 = (long int) D.23380;
    D.23382 = __builtin_expect (D.23381, 0);
    if (D.23382 != 0) goto <D.23383>; else goto <D.23384>;
    <D.23383>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1416, "ret == 0");
    <D.23384>:
  }
  jit_trampolines.63 = jit_trampolines;
  jit_trampolines.64 = jit_trampolines.63 + 1;
  jit_trampolines = jit_trampolines.64;
  D.23351 = tramp;
  return D.23351;
}


mono_create_jit_trampoline (struct MonoMethod * method)
{
  void * D.23388;
  struct MonoDomain * D.23389;

  D.23389 = mono_domain_get ();
  D.23388 = mono_create_jit_trampoline_in_domain (D.23389, method);
  return D.23388;
}


mono_create_jit_trampoline_from_token (struct MonoImage * image, guint32 token)
{
  unsigned int jit_trampolines.65;
  unsigned int jit_trampolines.66;
  void * D.23393;
  void * tramp;
  struct MonoDomain * domain;
  guint8 * buf;
  guint8 * start;

  domain = mono_domain_get ();
  start = mono_domain_alloc0 (domain, 8);
  buf = start;
  MEM[(void * *)buf] = image;
  buf = buf + 4;
  MEM[(guint32 *)buf] = token;
  tramp = mono_create_specific_trampoline (start, 5, domain, 0B);
  jit_trampolines.65 = jit_trampolines;
  jit_trampolines.66 = jit_trampolines.65 + 1;
  jit_trampolines = jit_trampolines.66;
  D.23393 = tramp;
  return D.23393;
}


mono_create_delegate_trampoline (struct MonoDomain * domain, struct MonoClass * klass)
{
  union mono_mutex_t * D.23395;
  _Bool D.23398;
  long int D.23399;
  long int D.23400;
  void * D.23403;
  struct GHashTable * D.23404;
  _Bool D.23407;
  long int D.23408;
  long int D.23409;
  void * D.23414;
  _Bool D.23415;
  long int D.23416;
  long int D.23417;
  void * * D.23420;
  struct MonoMethodSignature * D.23421;
  void * D.23422;
  void * * D.23423;
  struct MonoMethodSignature * D.23424;
  void * D.23425;
  unsigned int code_size.67;
  _Bool D.23427;
  long int D.23428;
  long int D.23429;
  _Bool D.23434;
  long int D.23435;
  long int D.23436;
  _Bool D.23441;
  long int D.23442;
  long int D.23443;
  void * ptr;
  guint32 code_size;
  void * * tramp_data;
  struct MonoMethod * invoke;

  try
    {
      code_size = 0;
      {
        int ret;

        D.23395 = &domain->lock.mutex;
        ret = pthread_mutex_lock (D.23395);
        if (ret != 0) goto <D.23396>; else goto <D.23397>;
        <D.23396>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.23397>:
        D.23398 = ret != 0;
        D.23399 = (long int) D.23398;
        D.23400 = __builtin_expect (D.23399, 0);
        if (D.23400 != 0) goto <D.23401>; else goto <D.23402>;
        <D.23401>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1459, "ret == 0");
        <D.23402>:
      }
      D.23403 = domain->runtime_info;
      D.23404 = MEM[(struct MonoJitDomainInfo *)D.23403].delegate_trampoline_hash;
      ptr = monoeg_g_hash_table_lookup (D.23404, klass);
      {
        int ret;

        D.23395 = &domain->lock.mutex;
        ret = pthread_mutex_unlock (D.23395);
        if (ret != 0) goto <D.23405>; else goto <D.23406>;
        <D.23405>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.23406>:
        D.23407 = ret != 0;
        D.23408 = (long int) D.23407;
        D.23409 = __builtin_expect (D.23408, 0);
        if (D.23409 != 0) goto <D.23410>; else goto <D.23411>;
        <D.23410>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1461, "ret == 0");
        <D.23411>:
      }
      if (ptr != 0B) goto <D.23412>; else goto <D.23413>;
      <D.23412>:
      D.23414 = ptr;
      return D.23414;
      <D.23413>:
      invoke = mono_get_delegate_invoke (klass);
      D.23415 = invoke == 0B;
      D.23416 = (long int) D.23415;
      D.23417 = __builtin_expect (D.23416, 0);
      if (D.23417 != 0) goto <D.23418>; else goto <D.23419>;
      <D.23418>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1467, "invoke");
      <D.23419>:
      tramp_data = mono_domain_alloc (domain, 12);
      *tramp_data = invoke;
      D.23420 = tramp_data + 4;
      D.23421 = mono_method_signature (invoke);
      D.23422 = mono_arch_get_delegate_invoke_impl (D.23421, 1);
      *D.23420 = D.23422;
      D.23423 = tramp_data + 8;
      D.23424 = mono_method_signature (invoke);
      D.23425 = mono_arch_get_delegate_invoke_impl (D.23424, 0);
      *D.23423 = D.23425;
      ptr = mono_create_specific_trampoline (tramp_data, 7, domain, &code_size);
      code_size.67 = code_size;
      D.23427 = code_size.67 == 0;
      D.23428 = (long int) D.23427;
      D.23429 = __builtin_expect (D.23428, 0);
      if (D.23429 != 0) goto <D.23430>; else goto <D.23431>;
      <D.23430>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1475, "code_size");
      <D.23431>:
      {
        int ret;

        D.23395 = &domain->lock.mutex;
        ret = pthread_mutex_lock (D.23395);
        if (ret != 0) goto <D.23432>; else goto <D.23433>;
        <D.23432>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.23433>:
        D.23434 = ret != 0;
        D.23435 = (long int) D.23434;
        D.23436 = __builtin_expect (D.23435, 0);
        if (D.23436 != 0) goto <D.23437>; else goto <D.23438>;
        <D.23437>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1478, "ret == 0");
        <D.23438>:
      }
      D.23403 = domain->runtime_info;
      D.23404 = MEM[(struct MonoJitDomainInfo *)D.23403].delegate_trampoline_hash;
      monoeg_g_hash_table_insert_replace (D.23404, klass, ptr, 0);
      {
        int ret;

        D.23395 = &domain->lock.mutex;
        ret = pthread_mutex_unlock (D.23395);
        if (ret != 0) goto <D.23439>; else goto <D.23440>;
        <D.23439>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.23440>:
        D.23441 = ret != 0;
        D.23442 = (long int) D.23441;
        D.23443 = __builtin_expect (D.23442, 0);
        if (D.23443 != 0) goto <D.23444>; else goto <D.23445>;
        <D.23444>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1481, "ret == 0");
        <D.23445>:
      }
      D.23414 = ptr;
      return D.23414;
    }
  finally
    {
      code_size = {CLOBBER};
    }
}


mono_create_rgctx_lazy_fetch_trampoline (guint32 offset)
{
  _Bool D.23450;
  long int D.23451;
  long int D.23452;
  struct GHashTable * rgctx_lazy_fetch_trampoline_hash.68;
  const void * offset.69;
  _Bool D.23462;
  long int D.23463;
  long int D.23464;
  void * D.23469;
  int mono_aot_only.70;
  struct MonoTrampInfo * info.71;
  struct MonoDomain * D.23475;
  _Bool D.23478;
  long int D.23479;
  long int D.23480;
  struct GHashTable * rgctx_lazy_fetch_trampoline_hash.72;
  struct GHashTable * rgctx_lazy_fetch_trampoline_hash_addr.73;
  void * offset.74;
  _Bool D.23488;
  long int D.23489;
  long int D.23490;
  unsigned int D.23493;
  void * D.23494;
  struct GHashTable * rgctx_lazy_fetch_trampoline_hash_addr.75;
  _Bool D.23498;
  long int D.23499;
  long int D.23500;
  int inited.76;
  int num_trampolines.77;
  int num_trampolines.78;
  static gboolean inited = 0;
  static int num_trampolines = 0;
  struct MonoTrampInfo * info;
  void * tramp;
  void * ptr;

  try
    {
      {
        int ret;

        ret = pthread_mutex_lock (&trampolines_mutex.mutex);
        if (ret != 0) goto <D.23448>; else goto <D.23449>;
        <D.23448>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.23449>:
        D.23450 = ret != 0;
        D.23451 = (long int) D.23450;
        D.23452 = __builtin_expect (D.23451, 0);
        if (D.23452 != 0) goto <D.23453>; else goto <D.23454>;
        <D.23453>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1498, "ret == 0");
        <D.23454>:
      }
      rgctx_lazy_fetch_trampoline_hash.68 = rgctx_lazy_fetch_trampoline_hash;
      if (rgctx_lazy_fetch_trampoline_hash.68 != 0B) goto <D.23456>; else goto <D.23457>;
      <D.23456>:
      offset.69 = (const void *) offset;
      rgctx_lazy_fetch_trampoline_hash.68 = rgctx_lazy_fetch_trampoline_hash;
      tramp = monoeg_g_hash_table_lookup (rgctx_lazy_fetch_trampoline_hash.68, offset.69);
      goto <D.23459>;
      <D.23457>:
      tramp = 0B;
      <D.23459>:
      {
        int ret;

        ret = pthread_mutex_unlock (&trampolines_mutex.mutex);
        if (ret != 0) goto <D.23460>; else goto <D.23461>;
        <D.23460>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.23461>:
        D.23462 = ret != 0;
        D.23463 = (long int) D.23462;
        D.23464 = __builtin_expect (D.23463, 0);
        if (D.23464 != 0) goto <D.23465>; else goto <D.23466>;
        <D.23465>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1503, "ret == 0");
        <D.23466>:
      }
      if (tramp != 0B) goto <D.23467>; else goto <D.23468>;
      <D.23467>:
      D.23469 = tramp;
      return D.23469;
      <D.23468>:
      mono_aot_only.70 = mono_aot_only;
      if (mono_aot_only.70 != 0) goto <D.23471>; else goto <D.23472>;
      <D.23471>:
      ptr = mono_aot_get_lazy_fetch_trampoline (offset);
      goto <D.23473>;
      <D.23472>:
      tramp = mono_arch_create_rgctx_lazy_fetch_trampoline (offset, &info, 0);
      info.71 = info;
      mono_tramp_info_register (info.71);
      D.23475 = mono_get_root_domain ();
      ptr = mono_create_ftnptr (D.23475, tramp);
      <D.23473>:
      {
        int ret;

        ret = pthread_mutex_lock (&trampolines_mutex.mutex);
        if (ret != 0) goto <D.23476>; else goto <D.23477>;
        <D.23476>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.23477>:
        D.23478 = ret != 0;
        D.23479 = (long int) D.23478;
        D.23480 = __builtin_expect (D.23479, 0);
        if (D.23480 != 0) goto <D.23481>; else goto <D.23482>;
        <D.23481>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1515, "ret == 0");
        <D.23482>:
      }
      rgctx_lazy_fetch_trampoline_hash.68 = rgctx_lazy_fetch_trampoline_hash;
      if (rgctx_lazy_fetch_trampoline_hash.68 == 0B) goto <D.23483>; else goto <D.23484>;
      <D.23483>:
      rgctx_lazy_fetch_trampoline_hash.72 = monoeg_g_hash_table_new (0B, 0B);
      rgctx_lazy_fetch_trampoline_hash = rgctx_lazy_fetch_trampoline_hash.72;
      rgctx_lazy_fetch_trampoline_hash_addr.73 = monoeg_g_hash_table_new (0B, 0B);
      rgctx_lazy_fetch_trampoline_hash_addr = rgctx_lazy_fetch_trampoline_hash_addr.73;
      <D.23484>:
      offset.74 = (void *) offset;
      rgctx_lazy_fetch_trampoline_hash.68 = rgctx_lazy_fetch_trampoline_hash;
      monoeg_g_hash_table_insert_replace (rgctx_lazy_fetch_trampoline_hash.68, offset.74, ptr, 0);
      D.23488 = offset == 4294967295;
      D.23489 = (long int) D.23488;
      D.23490 = __builtin_expect (D.23489, 0);
      if (D.23490 != 0) goto <D.23491>; else goto <D.23492>;
      <D.23491>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1521, "offset != -1");
      <D.23492>:
      D.23493 = offset + 1;
      D.23494 = (void *) D.23493;
      rgctx_lazy_fetch_trampoline_hash_addr.75 = rgctx_lazy_fetch_trampoline_hash_addr;
      monoeg_g_hash_table_insert_replace (rgctx_lazy_fetch_trampoline_hash_addr.75, ptr, D.23494, 0);
      {
        int ret;

        ret = pthread_mutex_unlock (&trampolines_mutex.mutex);
        if (ret != 0) goto <D.23496>; else goto <D.23497>;
        <D.23496>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.23497>:
        D.23498 = ret != 0;
        D.23499 = (long int) D.23498;
        D.23500 = __builtin_expect (D.23499, 0);
        if (D.23500 != 0) goto <D.23501>; else goto <D.23502>;
        <D.23501>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1523, "ret == 0");
        <D.23502>:
      }
      inited.76 = inited;
      if (inited.76 == 0) goto <D.23504>; else goto <D.23505>;
      <D.23504>:
      mono_counters_register ("RGCTX num lazy fetch trampolines", 2048, &num_trampolines);
      inited = 1;
      <D.23505>:
      num_trampolines.77 = num_trampolines;
      num_trampolines.78 = num_trampolines.77 + 1;
      num_trampolines = num_trampolines.78;
      D.23469 = ptr;
      return D.23469;
    }
  finally
    {
      info = {CLOBBER};
    }
}


mono_create_monitor_enter_trampoline ()
{
  int mono_aot_only.79;
  void * code.80;
  void * code.81;
  void * D.23517;
  _Bool D.23520;
  long int D.23521;
  long int D.23522;
  void * code.82;
  struct MonoTrampInfo * info.83;
  _Bool D.23531;
  long int D.23532;
  long int D.23533;
  static void * code;

  mono_aot_only.79 = mono_aot_only;
  if (mono_aot_only.79 != 0) goto <D.23511>; else goto <D.23512>;
  <D.23511>:
  code.80 = code;
  if (code.80 == 0B) goto <D.23514>; else goto <D.23515>;
  <D.23514>:
  code.81 = mono_aot_get_trampoline ("monitor_enter_trampoline");
  code = code.81;
  <D.23515>:
  D.23517 = code;
  return D.23517;
  <D.23512>:
  {
    int ret;

    ret = pthread_mutex_lock (&trampolines_mutex.mutex);
    if (ret != 0) goto <D.23518>; else goto <D.23519>;
    <D.23518>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.23519>:
    D.23520 = ret != 0;
    D.23521 = (long int) D.23520;
    D.23522 = __builtin_expect (D.23521, 0);
    if (D.23522 != 0) goto <D.23523>; else goto <D.23524>;
    <D.23523>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1547, "ret == 0");
    <D.23524>:
  }
  code.80 = code;
  if (code.80 == 0B) goto <D.23525>; else goto <D.23526>;
  <D.23525>:
  {
    struct MonoTrampInfo * info;

    try
      {
        code.82 = mono_arch_create_monitor_enter_trampoline (&info, 0);
        code = code.82;
        info.83 = info;
        mono_tramp_info_register (info.83);
      }
    finally
      {
        info = {CLOBBER};
      }
  }
  <D.23526>:
  {
    int ret;

    ret = pthread_mutex_unlock (&trampolines_mutex.mutex);
    if (ret != 0) goto <D.23529>; else goto <D.23530>;
    <D.23529>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.23530>:
    D.23531 = ret != 0;
    D.23532 = (long int) D.23531;
    D.23533 = __builtin_expect (D.23532, 0);
    if (D.23533 != 0) goto <D.23534>; else goto <D.23535>;
    <D.23534>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1556, "ret == 0");
    <D.23535>:
  }
  D.23517 = code;
  return D.23517;
}


mono_create_monitor_exit_trampoline ()
{
  int mono_aot_only.84;
  void * code.85;
  void * code.86;
  void * D.23544;
  _Bool D.23547;
  long int D.23548;
  long int D.23549;
  void * code.87;
  struct MonoTrampInfo * info.88;
  _Bool D.23558;
  long int D.23559;
  long int D.23560;
  static void * code;

  mono_aot_only.84 = mono_aot_only;
  if (mono_aot_only.84 != 0) goto <D.23538>; else goto <D.23539>;
  <D.23538>:
  code.85 = code;
  if (code.85 == 0B) goto <D.23541>; else goto <D.23542>;
  <D.23541>:
  code.86 = mono_aot_get_trampoline ("monitor_exit_trampoline");
  code = code.86;
  <D.23542>:
  D.23544 = code;
  return D.23544;
  <D.23539>:
  {
    int ret;

    ret = pthread_mutex_lock (&trampolines_mutex.mutex);
    if (ret != 0) goto <D.23545>; else goto <D.23546>;
    <D.23545>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.23546>:
    D.23547 = ret != 0;
    D.23548 = (long int) D.23547;
    D.23549 = __builtin_expect (D.23548, 0);
    if (D.23549 != 0) goto <D.23550>; else goto <D.23551>;
    <D.23550>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1577, "ret == 0");
    <D.23551>:
  }
  code.85 = code;
  if (code.85 == 0B) goto <D.23552>; else goto <D.23553>;
  <D.23552>:
  {
    struct MonoTrampInfo * info;

    try
      {
        code.87 = mono_arch_create_monitor_exit_trampoline (&info, 0);
        code = code.87;
        info.88 = info;
        mono_tramp_info_register (info.88);
      }
    finally
      {
        info = {CLOBBER};
      }
  }
  <D.23553>:
  {
    int ret;

    ret = pthread_mutex_unlock (&trampolines_mutex.mutex);
    if (ret != 0) goto <D.23556>; else goto <D.23557>;
    <D.23556>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.23557>:
    D.23558 = ret != 0;
    D.23559 = (long int) D.23558;
    D.23560 = __builtin_expect (D.23559, 0);
    if (D.23560 != 0) goto <D.23561>; else goto <D.23562>;
    <D.23561>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1586, "ret == 0");
    <D.23562>:
  }
  D.23544 = code;
  return D.23544;
}


mono_create_llvm_imt_trampoline (struct MonoDomain * domain, struct MonoMethod * m, int vt_offset)
{
  void * D.23564;

  D.23564 = mono_arch_get_llvm_imt_trampoline (domain, m, vt_offset);
  return D.23564;
}


mono_find_class_init_trampoline_by_addr (const void * addr)
{
  _Bool D.23568;
  long int D.23569;
  long int D.23570;
  struct GHashTable * class_init_hash_addr.89;
  _Bool D.23579;
  long int D.23580;
  long int D.23581;
  struct MonoVTable * D.23584;
  struct MonoVTable * res;

  {
    int ret;

    ret = pthread_mutex_lock (&trampolines_mutex.mutex);
    if (ret != 0) goto <D.23566>; else goto <D.23567>;
    <D.23566>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.23567>:
    D.23568 = ret != 0;
    D.23569 = (long int) D.23568;
    D.23570 = __builtin_expect (D.23569, 0);
    if (D.23570 != 0) goto <D.23571>; else goto <D.23572>;
    <D.23571>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1619, "ret == 0");
    <D.23572>:
  }
  class_init_hash_addr.89 = class_init_hash_addr;
  if (class_init_hash_addr.89 != 0B) goto <D.23574>; else goto <D.23575>;
  <D.23574>:
  class_init_hash_addr.89 = class_init_hash_addr;
  res = monoeg_g_hash_table_lookup (class_init_hash_addr.89, addr);
  goto <D.23576>;
  <D.23575>:
  res = 0B;
  <D.23576>:
  {
    int ret;

    ret = pthread_mutex_unlock (&trampolines_mutex.mutex);
    if (ret != 0) goto <D.23577>; else goto <D.23578>;
    <D.23577>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.23578>:
    D.23579 = ret != 0;
    D.23580 = (long int) D.23579;
    D.23581 = __builtin_expect (D.23580, 0);
    if (D.23581 != 0) goto <D.23582>; else goto <D.23583>;
    <D.23582>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1624, "ret == 0");
    <D.23583>:
  }
  D.23584 = res;
  return D.23584;
}


mono_find_rgctx_lazy_fetch_trampoline_by_addr (const void * addr)
{
  _Bool D.23588;
  long int D.23589;
  long int D.23590;
  struct GHashTable * rgctx_lazy_fetch_trampoline_hash_addr.90;
  void * D.23596;
  _Bool D.23603;
  long int D.23604;
  long int D.23605;
  guint32 D.23608;
  int offset;

  {
    int ret;

    ret = pthread_mutex_lock (&trampolines_mutex.mutex);
    if (ret != 0) goto <D.23586>; else goto <D.23587>;
    <D.23586>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.23587>:
    D.23588 = ret != 0;
    D.23589 = (long int) D.23588;
    D.23590 = __builtin_expect (D.23589, 0);
    if (D.23590 != 0) goto <D.23591>; else goto <D.23592>;
    <D.23591>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1633, "ret == 0");
    <D.23592>:
  }
  rgctx_lazy_fetch_trampoline_hash_addr.90 = rgctx_lazy_fetch_trampoline_hash_addr;
  if (rgctx_lazy_fetch_trampoline_hash_addr.90 != 0B) goto <D.23594>; else goto <D.23595>;
  <D.23594>:
  rgctx_lazy_fetch_trampoline_hash_addr.90 = rgctx_lazy_fetch_trampoline_hash_addr;
  D.23596 = monoeg_g_hash_table_lookup (rgctx_lazy_fetch_trampoline_hash_addr.90, addr);
  offset = (int) D.23596;
  if (offset != 0) goto <D.23597>; else goto <D.23598>;
  <D.23597>:
  offset = offset + -1;
  goto <D.23599>;
  <D.23598>:
  offset = -1;
  <D.23599>:
  goto <D.23600>;
  <D.23595>:
  offset = -1;
  <D.23600>:
  {
    int ret;

    ret = pthread_mutex_unlock (&trampolines_mutex.mutex);
    if (ret != 0) goto <D.23601>; else goto <D.23602>;
    <D.23601>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.23602>:
    D.23603 = ret != 0;
    D.23604 = (long int) D.23603;
    D.23605 = __builtin_expect (D.23604, 0);
    if (D.23605 != 0) goto <D.23606>; else goto <D.23607>;
    <D.23606>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1644, "ret == 0");
    <D.23607>:
  }
  D.23608 = (guint32) offset;
  return D.23608;
}


mono_get_generic_trampoline_name (MonoTrampolineType tramp_type)
{
  char * D.23610;
  const char * D.23611;

  D.23611 = tramp_names[tramp_type];
  D.23610 = monoeg_g_strdup_printf ("generic_trampoline_%s", D.23611);
  return D.23610;
}


mono_get_rgctx_fetch_trampoline_name (int slot)
{
  _Bool D.23613;
  char * D.23614;
  const char * iftmp.91;
  gboolean mrgctx;
  int index;

  D.23613 = slot < 0;
  mrgctx = (gboolean) D.23613;
  index = slot & 2147483647;
  if (mrgctx != 0) goto <D.23616>; else goto <D.23617>;
  <D.23616>:
  iftmp.91 = "mrgctx";
  goto <D.23618>;
  <D.23617>:
  iftmp.91 = "rgctx";
  <D.23618>:
  D.23614 = monoeg_g_strdup_printf ("rgctx_fetch_trampoline_%s_%d", iftmp.91, index);
  return D.23614;
}


mini_get_nullified_class_init_trampoline ()
{
  void * nullified_class_init_trampoline.92;
  int mono_aot_only.93;
  struct MonoTrampInfo * info.94;
  void * D.23628;
  static void * nullified_class_init_trampoline;

  nullified_class_init_trampoline.92 = nullified_class_init_trampoline;
  if (nullified_class_init_trampoline.92 == 0B) goto <D.23621>; else goto <D.23622>;
  <D.23621>:
  {
    void * tramp;
    struct MonoTrampInfo * info;

    try
      {
        mono_aot_only.93 = mono_aot_only;
        if (mono_aot_only.93 != 0) goto <D.23624>; else goto <D.23625>;
        <D.23624>:
        tramp = mono_aot_get_trampoline ("nullified_class_init_trampoline");
        goto <D.23626>;
        <D.23625>:
        tramp = mono_arch_get_nullified_class_init_trampoline (&info);
        info.94 = info;
        mono_tramp_info_register (info.94);
        <D.23626>:
        mono_memory_barrier ();
        nullified_class_init_trampoline = tramp;
      }
    finally
      {
        info = {CLOBBER};
      }
  }
  <D.23622>:
  D.23628 = nullified_class_init_trampoline;
  return D.23628;
}