__attribute__((visibility ("hidden")))
mono_create_static_rgctx_trampoline (struct MonoMethod * m, void * addr)
{
  union mono_mutex_t * D.22631;
  _Bool D.22634;
  long int D.22635;
  long int D.22636;
  void * D.22639;
  struct GHashTable * D.22640;
  struct GHashTable * D.22643;
  _Bool D.22646;
  long int D.22647;
  long int D.22648;
  void * D.22653;
  int mono_aot_only.0;
  _Bool D.22660;
  long int D.22661;
  long int D.22662;
  _Bool D.22667;
  long int D.22668;
  long int D.22669;
  unsigned int static_rgctx_trampolines.1;
  unsigned int D.22673;
  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.22631 = &domain->lock.mutex;
        ret = pthread_mutex_lock (D.22631);
        if (ret != 0) goto <D.22632>; else goto <D.22633>;
        <D.22632>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.22633>:
        D.22634 = ret != 0;
        D.22635 = (long int) D.22634;
        D.22636 = __builtin_expect (D.22635, 0);
        if (D.22636 != 0) goto <D.22637>; else goto <D.22638>;
        <D.22637>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 96, "ret == 0");
        <D.22638>:
      }
      D.22639 = domain->runtime_info;
      D.22640 = MEM[(struct MonoJitDomainInfo *)D.22639].static_rgctx_trampoline_hash;
      if (D.22640 == 0B) goto <D.22641>; else goto <D.22642>;
      <D.22641>:
      D.22639 = domain->runtime_info;
      D.22643 = monoeg_g_hash_table_new (rgctx_tramp_info_hash, rgctx_tramp_info_equal);
      MEM[(struct MonoJitDomainInfo *)D.22639].static_rgctx_trampoline_hash = D.22643;
      <D.22642>:
      tmp_info.m = m;
      tmp_info.addr = addr;
      D.22639 = domain->runtime_info;
      D.22640 = MEM[(struct MonoJitDomainInfo *)D.22639].static_rgctx_trampoline_hash;
      res = monoeg_g_hash_table_lookup (D.22640, &tmp_info);
      {
        int ret;

        D.22631 = &domain->lock.mutex;
        ret = pthread_mutex_unlock (D.22631);
        if (ret != 0) goto <D.22644>; else goto <D.22645>;
        <D.22644>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.22645>:
        D.22646 = ret != 0;
        D.22647 = (long int) D.22646;
        D.22648 = __builtin_expect (D.22647, 0);
        if (D.22648 != 0) goto <D.22649>; else goto <D.22650>;
        <D.22649>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 103, "ret == 0");
        <D.22650>:
      }
      if (res != 0B) goto <D.22651>; else goto <D.22652>;
      <D.22651>:
      D.22653 = res;
      return D.22653;
      <D.22652>:
      mono_aot_only.0 = mono_aot_only;
      if (mono_aot_only.0 != 0) goto <D.22655>; else goto <D.22656>;
      <D.22655>:
      res = mono_aot_get_static_rgctx_trampoline (ctx, addr);
      goto <D.22657>;
      <D.22656>:
      res = mono_arch_get_static_rgctx_trampoline (m, ctx, addr);
      <D.22657>:
      {
        int ret;

        D.22631 = &domain->lock.mutex;
        ret = pthread_mutex_lock (D.22631);
        if (ret != 0) goto <D.22658>; else goto <D.22659>;
        <D.22658>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.22659>:
        D.22660 = ret != 0;
        D.22661 = (long int) D.22660;
        D.22662 = __builtin_expect (D.22661, 0);
        if (D.22662 != 0) goto <D.22663>; else goto <D.22664>;
        <D.22663>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 112, "ret == 0");
        <D.22664>:
      }
      info = mono_domain_alloc (domain, 16);
      info->m = m;
      info->addr = addr;
      D.22639 = domain->runtime_info;
      D.22640 = MEM[(struct MonoJitDomainInfo *)D.22639].static_rgctx_trampoline_hash;
      monoeg_g_hash_table_insert_replace (D.22640, info, res, 0);
      {
        int ret;

        D.22631 = &domain->lock.mutex;
        ret = pthread_mutex_unlock (D.22631);
        if (ret != 0) goto <D.22665>; else goto <D.22666>;
        <D.22665>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.22666>:
        D.22667 = ret != 0;
        D.22668 = (long int) D.22667;
        D.22669 = __builtin_expect (D.22668, 0);
        if (D.22669 != 0) goto <D.22670>; else goto <D.22671>;
        <D.22670>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 118, "ret == 0");
        <D.22671>:
      }
      static_rgctx_trampolines.1 = static_rgctx_trampolines;
      D.22673 = static_rgctx_trampolines.1 + 1;
      static_rgctx_trampolines = D.22673;
      D.22653 = res;
      return D.22653;
    }
  finally
    {
      tmp_info = {CLOBBER};
    }
}


rgctx_tramp_info_equal (const void * ka, const void * kb)
{
  struct MonoMethod * D.22677;
  struct MonoMethod * D.22678;
  void * D.22680;
  void * D.22681;
  gint D.22683;
  const struct RgctxTrampInfo * i1;
  const struct RgctxTrampInfo * i2;

  i1 = ka;
  i2 = kb;
  D.22677 = i1->m;
  D.22678 = i2->m;
  if (D.22677 == D.22678) goto <D.22679>; else goto <D.22676>;
  <D.22679>:
  D.22680 = i1->addr;
  D.22681 = i2->addr;
  if (D.22680 == D.22681) goto <D.22682>; else goto <D.22676>;
  <D.22682>:
  D.22683 = 1;
  return D.22683;
  <D.22676>:
  D.22683 = 0;
  return D.22683;
}


rgctx_tramp_info_hash (const void * data)
{
  guint D.22685;
  struct MonoMethod * D.22686;
  long int D.22687;
  unsigned int D.22688;
  void * D.22689;
  long int D.22690;
  unsigned int D.22691;
  const struct RgctxTrampInfo * info;

  info = data;
  D.22686 = info->m;
  D.22687 = (long int) D.22686;
  D.22688 = (unsigned int) D.22687;
  D.22689 = info->addr;
  D.22690 = (long int) D.22689;
  D.22691 = (unsigned int) D.22690;
  D.22685 = D.22688 ^ D.22691;
  return D.22685;
}


__attribute__((visibility ("hidden")))
mini_jit_info_is_gsharedvt (struct MonoJitInfo * ji)
{
  long unsigned int D.22696;
  long unsigned int D.22697;
  struct MonoGenericSharingContext * D.22699;
  gboolean * D.22700;
  struct MonoGenericSharingContext * D.22702;
  gboolean * D.22703;
  gboolean D.22704;

  if (ji != 0B) goto <D.22695>; else goto <D.22693>;
  <D.22695>:
  D.22696 = BIT_FIELD_REF <*ji, 64, 256>;
  D.22697 = D.22696 & 70368744177664;
  if (D.22697 != 0) goto <D.22698>; else goto <D.22693>;
  <D.22698>:
  D.22699 = mono_jit_info_get_generic_sharing_context (ji);
  D.22700 = D.22699->var_is_vt;
  if (D.22700 != 0B) goto <D.22694>; else goto <D.22701>;
  <D.22701>:
  D.22702 = mono_jit_info_get_generic_sharing_context (ji);
  D.22703 = D.22702->mvar_is_vt;
  if (D.22703 != 0B) goto <D.22694>; else goto <D.22693>;
  <D.22694>:
  D.22704 = 1;
  return D.22704;
  <D.22693>:
  D.22704 = 0;
  return D.22704;
}


__attribute__((visibility ("hidden")))
mini_add_method_trampoline (struct MonoMethod * orig_method, struct MonoMethod * m, void * compiled_method, gboolean add_static_rgctx_tramp, gboolean add_unbox_tramp)
{
  struct MonoDomain * D.22706;
  void * D.22707;
  long unsigned int D.22708;
  long unsigned int D.22709;
  <unnamed type> D.22714;
  <unnamed type> D.22722;
  long unsigned int D.22729;
  _Bool D.22730;
  long int D.22731;
  long int D.22732;
  int mono_aot_only.2;
  unsigned int unbox_trampolines.3;
  unsigned int D.22742;
  struct MonoMethodSignature * D.22747;
  int D.22748;
  void * D.22755;
  void * addr;
  gboolean callee_gsharedvt;
  gboolean callee_array_helper;
  struct MonoMethod * jmethod;
  struct MonoJitInfo * ji;

  addr = compiled_method;
  jmethod = 0B;
  D.22706 = mono_domain_get ();
  D.22707 = mono_get_addr_from_ftnptr (compiled_method);
  ji = mini_jit_info_table_find (D.22706, D.22707, 0B);
  callee_gsharedvt = mini_jit_info_is_gsharedvt (ji);
  callee_array_helper = 0;
  D.22708 = BIT_FIELD_REF <*m, 64, 256>;
  D.22709 = D.22708 & 4467570830351532032;
  if (D.22709 == 1008806316530991104) goto <D.22710>; else goto <D.22711>;
  <D.22710>:
  {
    struct WrapperInfo * info;

    info = mono_marshal_get_wrapper_info (m);
    if (info != 0B) goto <D.22712>; else goto <D.22713>;
    <D.22712>:
    D.22714 = info->subtype;
    if (D.22714 == 21) goto <D.22715>; else goto <D.22716>;
    <D.22715>:
    callee_array_helper = 1;
    m = info->d.generic_array_helper.method;
    <D.22716>:
    <D.22713>:
  }
  goto <D.22717>;
  <D.22711>:
  D.22708 = BIT_FIELD_REF <*m, 64, 256>;
  D.22709 = D.22708 & 4467570830351532032;
  if (D.22709 == 3602879701896396800) goto <D.22718>; else goto <D.22719>;
  <D.22718>:
  {
    struct WrapperInfo * info;

    info = mono_marshal_get_wrapper_info (m);
    if (info != 0B) goto <D.22720>; else goto <D.22721>;
    <D.22720>:
    D.22722 = info->subtype;
    if (D.22722 == 17) goto <D.22723>; else goto <D.22724>;
    <D.22723>:
    m = info->d.synchronized_inner.method;
    <D.22724>:
    <D.22721>:
  }
  <D.22719>:
  <D.22717>:
  if (orig_method == 0B) goto <D.22725>; else goto <D.22726>;
  <D.22725>:
  orig_method = m;
  <D.22726>:
  if (callee_gsharedvt != 0) goto <D.22727>; else goto <D.22728>;
  <D.22727>:
  D.22708 = BIT_FIELD_REF <*m, 64, 256>;
  D.22729 = D.22708 & 2251799813685248;
  D.22730 = D.22729 == 0;
  D.22731 = (long int) D.22730;
  D.22732 = __builtin_expect (D.22731, 0);
  if (D.22732 != 0) goto <D.22733>; else goto <D.22734>;
  <D.22733>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 324, "m->is_inflated");
  <D.22734>:
  <D.22728>:
  addr = compiled_method;
  if (add_unbox_tramp != 0) goto <D.22735>; else goto <D.22736>;
  <D.22735>:
  mono_aot_only.2 = mono_aot_only;
  if (mono_aot_only.2 != 0) goto <D.22738>; else goto <D.22739>;
  <D.22738>:
  addr = mono_aot_get_unbox_trampoline (m);
  goto <D.22740>;
  <D.22739>:
  unbox_trampolines.3 = unbox_trampolines;
  D.22742 = unbox_trampolines.3 + 1;
  unbox_trampolines = D.22742;
  addr = mono_arch_get_unbox_trampoline (m, addr);
  <D.22740>:
  <D.22736>:
  if (ji != 0B) goto <D.22743>; else goto <D.22744>;
  <D.22743>:
  jmethod = jinfo_get_method (ji);
  <D.22744>:
  if (callee_gsharedvt != 0) goto <D.22745>; else goto <D.22746>;
  <D.22745>:
  D.22747 = mono_method_signature (jmethod);
  D.22748 = mini_is_gsharedvt_variable_signature (D.22747);
  if (D.22748 != 0) goto <D.22749>; else goto <D.22750>;
  <D.22749>:
  {
    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.22750>:
  <D.22746>:
  if (add_static_rgctx_tramp != 0) goto <D.22751>; else goto <D.22752>;
  <D.22751>:
  if (callee_array_helper == 0) goto <D.22753>; else goto <D.22754>;
  <D.22753>:
  addr = mono_create_static_rgctx_trampoline (m, addr);
  <D.22754>:
  <D.22752>:
  D.22755 = addr;
  return D.22755;
}


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

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


__attribute__((visibility ("hidden")))
mono_magic_trampoline (mgreg_t * regs, guint8 * code, void * arg, guint8 * tramp)
{
  unsigned int trampoline_calls.4;
  unsigned int D.22760;
  void * D.22761;

  trampoline_calls.4 = trampoline_calls;
  D.22760 = trampoline_calls.4 + 1;
  trampoline_calls = D.22760;
  D.22761 = common_call_trampoline (regs, code, arg, tramp, 0B, 0B, 0);
  return D.22761;
}


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.22763;
  _Bool D.22768;
  long int D.22769;
  long int D.22770;
  struct MonoVTable * D.22773;
  struct MonoClass * D.22774;
  struct MonoClass * D.22775;
  long unsigned int D.22781;
  long unsigned int D.22782;
  struct MonoGenericInst * D.22784;
  int variance_used.5;
  struct MonoClass * D.22789;
  int D.22790;
  _Bool D.22793;
  _Bool D.22794;
  _Bool D.22795;
  void * addr.6;
  struct MonoDomain * D.22799;
  int D.22800;
  void * D.22803;
  struct MonoDomain * D.22804;
  int D.22808;
  struct MonoGenericClass * D.22813;
  struct MonoGenericInst * D.22816;
  struct MonoGenericContainer * D.22818;
  _Bool D.22819;
  long int D.22820;
  long int D.22821;
  long unsigned int D.22826;
  long unsigned int D.22827;
  _Bool D.22828;
  long int D.22829;
  long int D.22830;
  struct MonoGenericInst * D.22833;
  _Bool D.22836;
  long int D.22837;
  long int D.22838;
  struct MonoGenericContext * D.22844;
  struct MonoGenericInst * D.22845;
  struct MonoVTable * D.22847;
  short unsigned int D.22851;
  int D.22852;
  int D.22853;
  long unsigned int D.22855;
  long unsigned int D.22856;
  struct MonoVTable * D.22857;
  struct MonoClass * D.22858;
  long unsigned int D.22859;
  signed long D.22860;
  _Bool D.22861;
  long int D.22862;
  long int D.22863;
  struct MonoClass * * D.22868;
  short unsigned int D.22869;
  long unsigned int D.22870;
  long unsigned int D.22871;
  sizetype D.22872;
  struct MonoClass * * D.22873;
  int iftmp.7;
  _Bool D.22879;
  long int D.22880;
  long int D.22881;
  long int vtable_slot.8;
  long int vt.9;
  long int D.22888;
  long int D.22889;
  _Bool D.22890;
  long int D.22891;
  long int D.22892;
  struct MonoClass * D.22895;
  struct MonoMethod * * D.22896;
  long unsigned int D.22897;
  long unsigned int D.22898;
  struct MonoMethod * * D.22899;
  long unsigned int D.22904;
  struct MonoGenericClass * D.22908;
  struct MonoGenericInst * D.22911;
  struct MonoGenericContainer * D.22913;
  struct MonoGenericInst * D.22916;
  _Bool D.22917;
  long int D.22918;
  long int D.22919;
  _Bool D.22922;
  long int D.22923;
  long int D.22924;
  struct MonoClass * D.22927;
  _Bool D.22928;
  long int D.22929;
  long int D.22930;
  long unsigned int D.22933;
  long unsigned int D.22934;
  short unsigned int D.22938;
  int D.22939;
  int D.22940;
  int D.22945;
  _Bool D.22948;
  long int D.22949;
  long int D.22950;
  struct MonoClass * D.22957;
  long unsigned int D.22958;
  long unsigned int D.22959;
  int need_rgctx_tramp.10;
  void * addr.11;
  struct MonoMethod * iftmp.12;
  struct MonoDomain * D.22977;
  void * D.22980;
  struct GHashTable * D.22981;
  union mono_mutex_t * D.22984;
  _Bool D.22987;
  long int D.22988;
  long int D.22989;
  _Bool D.22996;
  long int D.22997;
  long int D.22998;
  int D.23007;
  struct MonoDomain * D.23009;
  int D.23010;
  void * D.23011;
  _Bool D.23012;
  long int D.23013;
  long int D.23014;
  void * D.23017;
  struct MonoDomain * D.23023;
  void * D.23024;
  struct MonoDomain * D.23027;
  long unsigned int D.23034;
  long unsigned int D.23035;
  long unsigned int D.23038;
  long unsigned int D.23039;
  struct MonoDomain * D.23049;
  void * D.23050;
  struct MonoDomain * D.23053;
  int D.23066;
  void * D.23069;
  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.22763 = vtable_slot > vt;
      virtual = (gboolean) D.22763;
      orig_vtable_slot = vtable_slot;
      vtable_slot_to_patch = vtable_slot;
      if (vt != 0B) goto <D.22764>; else goto <D.22765>;
      <D.22764>:
      if (vtable_slot < vt) goto <D.22766>; else goto <D.22767>;
      <D.22766>:
      {
        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.22768 = vtable_slot == 0B;
            D.22769 = (long int) D.22768;
            D.22770 = __builtin_expect (D.22769, 0);
            if (D.22770 != 0) goto <D.22771>; else goto <D.22772>;
            <D.22771>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 401, "vtable_slot");
            <D.22772>:
            orig_method = m;
            this_arg = mono_arch_get_this_arg_from_call (regs, code);
            D.22773 = this_arg->vtable;
            D.22774 = D.22773->klass;
            D.22775 = mono_defaults.transparent_proxy_class;
            if (D.22774 == D.22775) goto <D.22776>; else goto <D.22777>;
            <D.22776>:
            m = mono_object_get_virtual_method (this_arg, m);
            vtable_slot_to_patch = 0B;
            goto <D.22778>;
            <D.22777>:
            {
              gboolean lookup_aot;

              D.22781 = BIT_FIELD_REF <*m, 64, 256>;
              D.22782 = D.22781 & 2251799813685248;
              if (D.22782 != 0) goto <D.22783>; else goto <D.22779>;
              <D.22783>:
              D.22784 = MEM[(struct MonoMethodInflated *)m].context.method_inst;
              if (D.22784 != 0B) goto <D.22785>; else goto <D.22779>;
              <D.22785>:
              generic_virtual = m;
              need_rgctx_tramp = 1;
              goto <D.22780>;
              <D.22779>:
              variance_used.5 = variance_used;
              if (variance_used.5 != 0) goto <D.22787>; else goto <D.22788>;
              <D.22787>:
              D.22789 = m->klass;
              D.22790 = mono_class_has_variant_generic_params (D.22789);
              if (D.22790 != 0) goto <D.22791>; else goto <D.22792>;
              <D.22791>:
              variant_iface = m;
              <D.22792>:
              <D.22788>:
              <D.22780>:
              addr = 0B;
              D.22793 = generic_virtual == 0B;
              D.22794 = variant_iface == 0B;
              D.22795 = D.22793 & D.22794;
              lookup_aot = (gboolean) D.22795;
              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.6 = addr;
              if (addr.6 != 0B) goto <D.22797>; else goto <D.22798>;
              <D.22797>:
              D.22799 = mono_domain_get ();
              D.22800 = mono_domain_owns_vtable_slot (D.22799, vtable_slot);
              if (D.22800 != 0) goto <D.22801>; else goto <D.22802>;
              <D.22801>:
              addr.6 = addr;
              *vtable_slot = addr.6;
              <D.22802>:
              D.22804 = mono_domain_get ();
              addr.6 = addr;
              D.22803 = mono_create_ftnptr (D.22804, addr.6);
              return D.22803;
              <D.22798>:
              m = impl_method;
            }
            <D.22778>:
          }
        finally
          {
            impl_method = {CLOBBER};
          }
      }
      <D.22767>:
      <D.22765>:
      if (virtual != 0) goto <D.22807>; else goto <D.22805>;
      <D.22807>:
      D.22808 = is_generic_method_definition (m);
      if (D.22808 != 0) goto <D.22809>; else goto <D.22805>;
      <D.22809>:
      {
        struct MonoGenericContext context;
        struct MonoMethod * declaring;

        try
          {
            context.class_inst = 0B;
            context.method_inst = 0B;
            D.22781 = BIT_FIELD_REF <*m, 64, 256>;
            D.22782 = D.22781 & 2251799813685248;
            if (D.22782 != 0) goto <D.22810>; else goto <D.22811>;
            <D.22810>:
            declaring = mono_method_get_declaring_generic_method (m);
            goto <D.22812>;
            <D.22811>:
            declaring = m;
            <D.22812>:
            D.22789 = m->klass;
            D.22813 = D.22789->generic_class;
            if (D.22813 != 0B) goto <D.22814>; else goto <D.22815>;
            <D.22814>:
            D.22789 = m->klass;
            D.22813 = D.22789->generic_class;
            D.22816 = D.22813->context.class_inst;
            context.class_inst = D.22816;
            goto <D.22817>;
            <D.22815>:
            D.22789 = m->klass;
            D.22818 = D.22789->generic_container;
            D.22819 = D.22818 != 0B;
            D.22820 = (long int) D.22819;
            D.22821 = __builtin_expect (D.22820, 0);
            if (D.22821 != 0) goto <D.22822>; else goto <D.22823>;
            <D.22822>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 464, "!m->klass->generic_container");
            <D.22823>:
            <D.22817>:
            generic_virtual = mono_arch_find_imt_method (regs, code);
            if (generic_virtual != 0B) goto <D.22824>; else goto <D.22825>;
            <D.22824>:
            D.22826 = BIT_FIELD_REF <*generic_virtual, 64, 256>;
            D.22827 = D.22826 & 2251799813685248;
            D.22828 = D.22827 == 0;
            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", 470, "generic_virtual->is_inflated");
            <D.22832>:
            D.22833 = MEM[(struct MonoMethodInflated *)generic_virtual].context.method_inst;
            context.method_inst = D.22833;
            <D.22825>:
            m = mono_class_inflate_generic_method (declaring, &context);
            need_rgctx_tramp = 1;
          }
        finally
          {
            context = {CLOBBER};
          }
      }
      goto <D.22806>;
      <D.22805>:
      context_used = mono_method_check_context_used (m);
      if (context_used != 0) goto <D.22834>; else goto <D.22835>;
      <D.22834>:
      {
        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.22836 = code == 0B;
        D.22837 = (long int) D.22836;
        D.22838 = __builtin_expect (D.22837, 0);
        if (D.22838 != 0) goto <D.22839>; else goto <D.22840>;
        <D.22839>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 486, "code");
        <D.22840>:
        D.22781 = BIT_FIELD_REF <*m, 64, 256>;
        D.22782 = D.22781 & 2251799813685248;
        if (D.22782 != 0) goto <D.22843>; else goto <D.22841>;
        <D.22843>:
        D.22844 = mono_method_get_context (m);
        D.22845 = D.22844->method_inst;
        if (D.22845 != 0B) goto <D.22846>; else goto <D.22841>;
        <D.22846>:
        {
          struct MonoMethodRuntimeGenericContext * mrgctx;

          mrgctx = mono_arch_find_static_call_vtable (regs, code);
          D.22847 = mrgctx->class_vtable;
          klass = D.22847->klass;
          method_inst = mrgctx->method_inst;
        }
        goto <D.22842>;
        <D.22841>:
        D.22851 = m->flags;
        D.22852 = (int) D.22851;
        D.22853 = D.22852 & 16;
        if (D.22853 != 0) goto <D.22848>; else goto <D.22854>;
        <D.22854>:
        D.22789 = m->klass;
        D.22855 = BIT_FIELD_REF <*D.22789, 64, 256>;
        D.22856 = D.22855 & 1152921504606846976;
        if (D.22856 != 0) goto <D.22848>; else goto <D.22849>;
        <D.22848>:
        {
          struct MonoVTable * vtable;

          vtable = mono_arch_find_static_call_vtable (regs, code);
          klass = vtable->klass;
        }
        goto <D.22850>;
        <D.22849>:
        {
          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.22857 = this_argument->vtable;
          D.22858 = D.22857->klass;
          D.22859 = BIT_FIELD_REF <*D.22858, 64, 256>;
          D.22860 = (signed long) D.22859;
          D.22861 = D.22860 >= 0;
          D.22862 = (long int) D.22861;
          D.22863 = __builtin_expect (D.22862, 0);
          if (D.22863 != 0) goto <D.22864>; else goto <D.22865>;
          <D.22864>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 512, "this_argument->vtable->klass->inited");
          <D.22865>:
          if (vtable_slot == 0B) goto <D.22866>; else goto <D.22867>;
          <D.22866>:
          D.22857 = this_argument->vtable;
          D.22858 = D.22857->klass;
          mono_class_setup_supertypes (D.22858);
          D.22857 = this_argument->vtable;
          D.22858 = D.22857->klass;
          D.22868 = D.22858->supertypes;
          D.22789 = m->klass;
          D.22869 = D.22789->idepth;
          D.22870 = (long unsigned int) D.22869;
          D.22871 = D.22870 * 8;
          D.22872 = D.22871 + 18446744073709551608;
          D.22873 = D.22868 + D.22872;
          klass = *D.22873;
          <D.22867>:
        }
        <D.22850>:
        <D.22842>:
        if (vtable_slot == 0B) goto <D.22877>; else goto <D.22875>;
        <D.22877>:
        if (klass == 0B) goto <D.22878>; else goto <D.22875>;
        <D.22878>:
        iftmp.7 = 1;
        goto <D.22876>;
        <D.22875>:
        iftmp.7 = 0;
        <D.22876>:
        D.22879 = iftmp.7 != 0;
        D.22880 = (long int) D.22879;
        D.22881 = __builtin_expect (D.22880, 0);
        if (D.22881 != 0) goto <D.22882>; else goto <D.22883>;
        <D.22882>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 524, "vtable_slot || klass");
        <D.22883>:
        if (vtable_slot != 0B) goto <D.22884>; else goto <D.22885>;
        <D.22884>:
        {
          int displacement;

          vtable_slot.8 = (long int) vtable_slot;
          vt.9 = (long int) vt;
          D.22888 = vtable_slot.8 - vt.9;
          D.22889 = D.22888 /[ex] 8;
          displacement = (int) D.22889;
          monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-trampolines.c", 529);
          D.22890 = displacement <= 0;
          D.22891 = (long int) D.22890;
          D.22892 = __builtin_expect (D.22891, 0);
          if (D.22892 != 0) goto <D.22893>; else goto <D.22894>;
          <D.22893>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 531, "displacement > 0");
          <D.22894>:
          D.22895 = vt->klass;
          D.22896 = D.22895->vtable;
          D.22897 = (long unsigned int) displacement;
          D.22898 = D.22897 * 8;
          D.22899 = D.22896 + D.22898;
          actual_method = *D.22899;
        }
        <D.22885>:
        if (method_inst != 0B) goto <D.22900>; else goto <D.22903>;
        <D.22903>:
        D.22781 = BIT_FIELD_REF <*m, 64, 256>;
        D.22904 = D.22781 & 4467570830351532032;
        if (D.22904 != 0) goto <D.22900>; else goto <D.22901>;
        <D.22900>:
        {
          struct MonoGenericContext context;

          try
            {
              context.class_inst = 0B;
              context.method_inst = 0B;
              D.22781 = BIT_FIELD_REF <*m, 64, 256>;
              D.22782 = D.22781 & 2251799813685248;
              if (D.22782 != 0) goto <D.22905>; else goto <D.22906>;
              <D.22905>:
              declaring = mono_method_get_declaring_generic_method (m);
              goto <D.22907>;
              <D.22906>:
              declaring = m;
              <D.22907>:
              D.22908 = klass->generic_class;
              if (D.22908 != 0B) goto <D.22909>; else goto <D.22910>;
              <D.22909>:
              D.22908 = klass->generic_class;
              D.22911 = D.22908->context.class_inst;
              context.class_inst = D.22911;
              goto <D.22912>;
              <D.22910>:
              D.22913 = klass->generic_container;
              if (D.22913 != 0B) goto <D.22914>; else goto <D.22915>;
              <D.22914>:
              D.22913 = klass->generic_container;
              D.22916 = D.22913->context.class_inst;
              context.class_inst = D.22916;
              <D.22915>:
              <D.22912>:
              context.method_inst = method_inst;
              actual_method = mono_class_inflate_generic_method (declaring, &context);
            }
          finally
            {
              context = {CLOBBER};
            }
        }
        goto <D.22902>;
        <D.22901>:
        actual_method = mono_class_get_method_generic (klass, m);
        <D.22902>:
        D.22917 = klass == 0B;
        D.22918 = (long int) D.22917;
        D.22919 = __builtin_expect (D.22918, 0);
        if (D.22919 != 0) goto <D.22920>; else goto <D.22921>;
        <D.22920>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 555, "klass");
        <D.22921>:
        D.22922 = actual_method == 0B;
        D.22923 = (long int) D.22922;
        D.22924 = __builtin_expect (D.22923, 0);
        if (D.22924 != 0) goto <D.22925>; else goto <D.22926>;
        <D.22925>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 556, "actual_method");
        <D.22926>:
        D.22927 = actual_method->klass;
        D.22928 = D.22927 != klass;
        D.22929 = (long int) D.22928;
        D.22930 = __builtin_expect (D.22929, 0);
        if (D.22930 != 0) goto <D.22931>; else goto <D.22932>;
        <D.22931>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 557, "actual_method->klass == klass");
        <D.22932>:
        D.22933 = BIT_FIELD_REF <*actual_method, 64, 256>;
        D.22934 = D.22933 & 2251799813685248;
        if (D.22934 != 0) goto <D.22935>; else goto <D.22936>;
        <D.22935>:
        declaring = mono_method_get_declaring_generic_method (actual_method);
        goto <D.22937>;
        <D.22936>:
        declaring = 0B;
        <D.22937>:
        m = actual_method;
      }
      <D.22835>:
      <D.22806>:
      D.22938 = m->iflags;
      D.22939 = (int) D.22938;
      D.22940 = D.22939 & 32;
      if (D.22940 != 0) goto <D.22941>; else goto <D.22942>;
      <D.22941>:
      m = mono_marshal_get_synchronized_wrapper (m);
      need_rgctx_tramp = 0;
      <D.22942>:
      if (code == 0B) goto <D.22943>; else goto <D.22944>;
      <D.22943>:
      D.22945 = mono_method_needs_static_rgctx_invoke (m, 0);
      if (D.22945 != 0) goto <D.22946>; else goto <D.22947>;
      <D.22946>:
      need_rgctx_tramp = 1;
      <D.22947>:
      <D.22944>:
      compiled_method = mono_compile_method (m);
      addr = compiled_method;
      addr.6 = addr;
      D.22948 = addr.6 == 0B;
      D.22949 = (long int) D.22948;
      D.22950 = __builtin_expect (D.22949, 0);
      if (D.22950 != 0) goto <D.22951>; else goto <D.22952>;
      <D.22951>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 577, "addr");
      <D.22952>:
      if (generic_virtual != 0B) goto <D.22953>; else goto <D.22956>;
      <D.22956>:
      if (variant_iface != 0B) goto <D.22953>; else goto <D.22954>;
      <D.22953>:
      D.22957 = vt->klass;
      D.22958 = BIT_FIELD_REF <*D.22957, 64, 256>;
      D.22959 = D.22958 & 1152921504606846976;
      if (D.22959 != 0) goto <D.22960>; else goto <D.22961>;
      <D.22960>:
      need_unbox_tramp = 1;
      <D.22961>:
      goto <D.22955>;
      <D.22954>:
      if (orig_vtable_slot != 0B) goto <D.22962>; else goto <D.22963>;
      <D.22962>:
      D.22789 = m->klass;
      D.22855 = BIT_FIELD_REF <*D.22789, 64, 256>;
      D.22856 = D.22855 & 1152921504606846976;
      if (D.22856 != 0) goto <D.22964>; else goto <D.22965>;
      <D.22964>:
      need_unbox_tramp = 1;
      <D.22965>:
      <D.22963>:
      <D.22955>:
      need_rgctx_tramp.10 = need_rgctx_tramp;
      addr.11 = mini_add_method_trampoline (orig_method, m, compiled_method, need_rgctx_tramp.10, need_unbox_tramp);
      addr = addr.11;
      if (generic_virtual != 0B) goto <D.22968>; else goto <D.22970>;
      <D.22970>:
      if (variant_iface != 0B) goto <D.22968>; else goto <D.22969>;
      <D.22968>:
      {
        struct MonoMethod * target;

        if (generic_virtual != 0B) goto <D.22972>; else goto <D.22973>;
        <D.22972>:
        iftmp.12 = generic_virtual;
        goto <D.22974>;
        <D.22973>:
        iftmp.12 = variant_iface;
        <D.22974>:
        target = iftmp.12;
        vtable_slot = orig_vtable_slot;
        D.22768 = vtable_slot == 0B;
        D.22769 = (long int) D.22768;
        D.22770 = __builtin_expect (D.22769, 0);
        if (D.22770 != 0) goto <D.22975>; else goto <D.22976>;
        <D.22975>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 593, "vtable_slot");
        <D.22976>:
        D.22977 = mono_domain_get ();
        addr.6 = addr;
        mono_method_add_generic_virtual_invocation (D.22977, vt, vtable_slot, target, addr.6);
        D.22803 = addr;
        return D.22803;
      }
      <D.22969>:
      if (code == 0B) goto <D.22978>; else goto <D.22979>;
      <D.22978>:
      {
        struct MonoDomain * domain;

        domain = mono_domain_get ();
        D.22980 = domain->runtime_info;
        D.22981 = MEM[(struct MonoJitDomainInfo *)D.22980].jump_target_got_slot_hash;
        if (D.22981 != 0B) goto <D.22982>; else goto <D.22983>;
        <D.22982>:
        {
          struct GSList * list;
          struct GSList * tmp;

          {
            int ret;

            D.22984 = &domain->lock.mutex;
            ret = pthread_mutex_lock (D.22984);
            if (ret != 0) goto <D.22985>; else goto <D.22986>;
            <D.22985>:
            monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
            <D.22986>:
            D.22987 = ret != 0;
            D.22988 = (long int) D.22987;
            D.22989 = __builtin_expect (D.22988, 0);
            if (D.22989 != 0) goto <D.22990>; else goto <D.22991>;
            <D.22990>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 614, "ret == 0");
            <D.22991>:
          }
          D.22980 = domain->runtime_info;
          D.22981 = MEM[(struct MonoJitDomainInfo *)D.22980].jump_target_got_slot_hash;
          list = monoeg_g_hash_table_lookup (D.22981, m);
          if (list != 0B) goto <D.22992>; else goto <D.22993>;
          <D.22992>:
          tmp = list;
          goto <D.22389>;
          <D.22388>:
          {
            void * * got_slot;

            got_slot = tmp->data;
            addr.6 = addr;
            *got_slot = addr.6;
          }
          tmp = tmp->next;
          <D.22389>:
          if (tmp != 0B) goto <D.22388>; else goto <D.22390>;
          <D.22390>:
          D.22980 = domain->runtime_info;
          D.22981 = MEM[(struct MonoJitDomainInfo *)D.22980].jump_target_got_slot_hash;
          monoeg_g_hash_table_remove (D.22981, m);
          monoeg_g_slist_free (list);
          <D.22993>:
          {
            int ret;

            D.22984 = &domain->lock.mutex;
            ret = pthread_mutex_unlock (D.22984);
            if (ret != 0) goto <D.22994>; else goto <D.22995>;
            <D.22994>:
            monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
            <D.22995>:
            D.22996 = ret != 0;
            D.22997 = (long int) D.22996;
            D.22998 = __builtin_expect (D.22997, 0);
            if (D.22998 != 0) goto <D.22999>; else goto <D.23000>;
            <D.22999>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 624, "ret == 0");
            <D.23000>:
          }
        }
        <D.22983>:
        D.22803 = addr;
        return D.22803;
      }
      <D.22979>:
      vtable_slot = orig_vtable_slot;
      if (vtable_slot != 0B) goto <D.23001>; else goto <D.23002>;
      <D.23001>:
      if (vtable_slot_to_patch != 0B) goto <D.23005>; else goto <D.23006>;
      <D.23005>:
      D.23007 = mono_aot_is_got_entry (code, vtable_slot_to_patch);
      if (D.23007 != 0) goto <D.23003>; else goto <D.23008>;
      <D.23008>:
      D.23009 = mono_domain_get ();
      D.23010 = mono_domain_owns_vtable_slot (D.23009, vtable_slot_to_patch);
      if (D.23010 != 0) goto <D.23003>; else goto <D.23004>;
      <D.23003>:
      D.23011 = *vtable_slot_to_patch;
      D.23012 = D.23011 == 0B;
      D.23013 = (long int) D.23012;
      D.23014 = __builtin_expect (D.23013, 0);
      if (D.23014 != 0) goto <D.23015>; else goto <D.23016>;
      <D.23015>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 634, "*vtable_slot_to_patch");
      <D.23016>:
      addr.6 = addr;
      D.23017 = mono_get_addr_from_ftnptr (addr.6);
      *vtable_slot_to_patch = D.23017;
      <D.23004>:
      <D.23006>:
      goto <D.23018>;
      <D.23002>:
      {
        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.23019>; else goto <D.23020>;
        <D.23019>:
        if (generic_shared != 0) goto <D.23021>; else goto <D.23022>;
        <D.23021>:
        D.23023 = mono_domain_get ();
        D.23024 = mono_get_addr_from_ftnptr (compiled_method);
        target_ji = mini_jit_info_table_find (D.23023, D.23024, 0B);
        if (ji == 0B) goto <D.23025>; else goto <D.23026>;
        <D.23025>:
        D.23027 = mono_domain_get ();
        ji = mini_jit_info_table_find (D.23027, code, 0B);
        <D.23026>:
        if (ji != 0B) goto <D.23028>; else goto <D.23029>;
        <D.23028>:
        if (target_ji != 0B) goto <D.23030>; else goto <D.23031>;
        <D.23030>:
        if (generic_shared != 0) goto <D.23032>; else goto <D.23033>;
        <D.23032>:
        D.23034 = BIT_FIELD_REF <*ji, 64, 256>;
        D.23035 = D.23034 & 70368744177664;
        if (D.23035 != 0) goto <D.23036>; else goto <D.23037>;
        <D.23036>:
        D.23038 = BIT_FIELD_REF <*target_ji, 64, 256>;
        D.23039 = D.23038 & 70368744177664;
        if (D.23039 == 0) goto <D.23040>; else goto <D.23041>;
        <D.23040>:
        no_patch = 1;
        <D.23041>:
        <D.23037>:
        <D.23033>:
        <D.23031>:
        <D.23029>:
        <D.23022>:
        if (no_patch == 0) goto <D.23042>; else goto <D.23043>;
        <D.23042>:
        addr.6 = addr;
        mono_aot_patch_plt_entry (plt_entry, 0B, regs, addr.6);
        <D.23043>:
        goto <D.23044>;
        <D.23020>:
        if (generic_shared != 0) goto <D.23045>; else goto <D.23046>;
        <D.23045>:
        D.22781 = BIT_FIELD_REF <*m, 64, 256>;
        D.22904 = D.22781 & 4467570830351532032;
        if (D.22904 != 0) goto <D.23047>; else goto <D.23048>;
        <D.23047>:
        m = mono_marshal_method_from_wrapper (m);
        <D.23048>:
        <D.23046>:
        D.23049 = mono_domain_get ();
        D.23050 = mono_get_addr_from_ftnptr (compiled_method);
        target_ji = mini_jit_info_table_find (D.23049, D.23050, 0B);
        if (ji == 0B) goto <D.23051>; else goto <D.23052>;
        <D.23051>:
        D.23053 = mono_domain_get ();
        ji = mini_jit_info_table_find (D.23053, code, 0B);
        <D.23052>:
        if (ji != 0B) goto <D.23054>; else goto <D.23055>;
        <D.23054>:
        if (target_ji != 0B) goto <D.23056>; else goto <D.23057>;
        <D.23056>:
        if (generic_shared != 0) goto <D.23058>; else goto <D.23059>;
        <D.23058>:
        D.23034 = BIT_FIELD_REF <*ji, 64, 256>;
        D.23035 = D.23034 & 70368744177664;
        if (D.23035 != 0) goto <D.23060>; else goto <D.23061>;
        <D.23060>:
        D.23038 = BIT_FIELD_REF <*target_ji, 64, 256>;
        D.23039 = D.23038 & 70368744177664;
        if (D.23039 == 0) goto <D.23062>; else goto <D.23063>;
        <D.23062>:
        no_patch = 1;
        <D.23063>:
        <D.23061>:
        <D.23059>:
        <D.23057>:
        <D.23055>:
        if (no_patch == 0) goto <D.23064>; else goto <D.23065>;
        <D.23064>:
        D.23066 = mono_method_same_domain (ji, target_ji);
        if (D.23066 != 0) goto <D.23067>; else goto <D.23068>;
        <D.23067>:
        D.23069 = ji->code_start;
        addr.6 = addr;
        mono_arch_patch_callsite (D.23069, code, addr.6);
        <D.23068>:
        <D.23065>:
        <D.23044>:
      }
      <D.23018>:
      D.22803 = addr;
      return D.22803;
    }
  finally
    {
      addr = {CLOBBER};
      variance_used = {CLOBBER};
    }
}


__attribute__((noinline))
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)
{
  long int slot.13;
  long int vt.14;
  long int D.23076;
  long int D.23077;
  void * * D.23080;
  struct MonoClass * D.23081;
  struct MonoClass * D.23082;
  struct MonoType * D.23085;
  char * D.23086;
  struct MonoType * D.23087;
  char * D.23088;
  unsigned int D.23089;
  int D.23090;
  long unsigned int D.23093;
  long unsigned int D.23094;
  struct MonoGenericInst * D.23096;
  struct MonoMethod * D.23098;
  short int D.23099;
  int D.23100;
  int D.23101;
  struct MonoClass * D.23102;
  struct MonoGenericClass * D.23103;
  struct MonoGenericInst * D.23106;
  long unsigned int D.23110;
  long unsigned int D.23111;
  struct MonoDomain * D.23113;
  int D.23114;
  int D.23115;
  void * D.23116;
  void * D.23117;
  int D.23121;
  int D.23122;
  int D.23125;
  long unsigned int D.23130;
  long unsigned int D.23131;
  <unnamed type> D.23136;
  _Bool D.23139;
  long int D.23140;
  long int D.23141;
  unsigned int D.23144;
  int D.23145;
  unsigned int D.23146;
  unsigned int D.23147;
  _Bool D.23150;
  long int D.23151;
  long int D.23152;
  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.13 = (long int) slot;
  vt.14 = (long int) vt;
  D.23076 = slot.13 - vt.14;
  D.23077 = D.23076 /[ex] 8;
  displacement = (int) D.23077;
  if (displacement > 0) goto <D.23078>; else goto <D.23079>;
  <D.23078>:
  D.23080 = slot;
  return D.23080;
  <D.23079>:
  {
    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.23081 = vt->klass;
    D.23082 = imt_method->klass;
    interface_offset = mono_class_interface_offset_with_variance (D.23081, D.23082, variance_used);
    if (interface_offset < 0) goto <D.23083>; else goto <D.23084>;
    <D.23083>:
    D.23081 = vt->klass;
    D.23085 = &D.23081->byval_arg;
    D.23086 = mono_type_get_name_full (D.23085, 0);
    D.23082 = imt_method->klass;
    D.23087 = &D.23082->byval_arg;
    D.23088 = mono_type_get_name_full (D.23087, 0);
    monoeg_g_log (0B, 4, "%s doesn\'t implement interface %s\n", D.23086, D.23088);
    <D.22315>:
    goto <D.22315>;
    <D.23084>:
    D.23089 = mono_method_get_imt_slot (imt_method);
    D.23090 = (int) D.23089;
    mono_vtable_build_imt_slot (vt, D.23090);
    D.23093 = BIT_FIELD_REF <*imt_method, 64, 256>;
    D.23094 = D.23093 & 2251799813685248;
    if (D.23094 != 0) goto <D.23095>; else goto <D.23091>;
    <D.23095>:
    D.23096 = MEM[(struct MonoMethodInflated *)imt_method].context.method_inst;
    if (D.23096 != 0B) goto <D.23097>; else goto <D.23091>;
    <D.23097>:
    {
      struct MonoGenericContext context;

      try
        {
          context.class_inst = 0B;
          context.method_inst = 0B;
          D.23081 = vt->klass;
          D.23098 = mono_method_get_declaring_generic_method (imt_method);
          D.23099 = D.23098->slot;
          D.23100 = (int) D.23099;
          D.23101 = D.23100 + interface_offset;
          impl = mono_class_get_vtable_entry (D.23081, D.23101);
          D.23102 = impl->klass;
          D.23103 = D.23102->generic_class;
          if (D.23103 != 0B) goto <D.23104>; else goto <D.23105>;
          <D.23104>:
          D.23102 = impl->klass;
          D.23103 = D.23102->generic_class;
          D.23106 = D.23103->context.class_inst;
          context.class_inst = D.23106;
          <D.23105>:
          D.23096 = MEM[(struct MonoMethodInflated *)imt_method].context.method_inst;
          context.method_inst = D.23096;
          impl = mono_class_inflate_generic_method (impl, &context);
        }
      finally
        {
          context = {CLOBBER};
        }
    }
    goto <D.23092>;
    <D.23091>:
    if (lookup_aot != 0) goto <D.23109>; else goto <D.23107>;
    <D.23109>:
    D.23081 = vt->klass;
    D.23110 = BIT_FIELD_REF <*D.23081, 64, 256>;
    D.23111 = D.23110 & 1152921504606846976;
    if (D.23111 == 0) goto <D.23112>; else goto <D.23107>;
    <D.23112>:
    D.23113 = mono_domain_get ();
    D.23114 = mono_method_get_vtable_slot (imt_method);
    D.23115 = D.23114 + interface_offset;
    D.23116 = mono_aot_get_method_from_vt_slot (D.23113, vt, D.23115);
    *aot_addr = D.23116;
    goto <D.23108>;
    <D.23107>:
    *aot_addr = 0B;
    <D.23108>:
    D.23117 = *aot_addr;
    if (D.23117 != 0B) goto <D.23118>; else goto <D.23119>;
    <D.23118>:
    impl = 0B;
    goto <D.23120>;
    <D.23119>:
    D.23081 = vt->klass;
    D.23121 = mono_method_get_vtable_slot (imt_method);
    D.23122 = D.23121 + interface_offset;
    impl = mono_class_get_vtable_entry (D.23081, D.23122);
    <D.23120>:
    <D.23092>:
    if (impl != 0B) goto <D.23123>; else goto <D.23124>;
    <D.23123>:
    D.23125 = mono_method_needs_static_rgctx_invoke (impl, 0);
    if (D.23125 != 0) goto <D.23126>; else goto <D.23127>;
    <D.23126>:
    *need_rgctx_tramp = 1;
    <D.23127>:
    <D.23124>:
    if (impl != 0B) goto <D.23128>; else goto <D.23129>;
    <D.23128>:
    D.23130 = BIT_FIELD_REF <*impl, 64, 256>;
    D.23131 = D.23130 & 4467570830351532032;
    if (D.23131 == 1008806316530991104) goto <D.23132>; else goto <D.23133>;
    <D.23132>:
    {
      struct WrapperInfo * info;

      info = mono_marshal_get_wrapper_info (impl);
      if (info != 0B) goto <D.23134>; else goto <D.23135>;
      <D.23134>:
      D.23136 = info->subtype;
      if (D.23136 == 21) goto <D.23137>; else goto <D.23138>;
      <D.23137>:
      *need_rgctx_tramp = 1;
      <D.23138>:
      <D.23135>:
    }
    <D.23133>:
    <D.23129>:
    *impl_method = impl;
    D.23139 = imt_slot > 18;
    D.23140 = (long int) D.23139;
    D.23141 = __builtin_expect (D.23140, 0);
    if (D.23141 != 0) goto <D.23142>; else goto <D.23143>;
    <D.23142>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 223, "imt_slot < MONO_IMT_SIZE");
    <D.23143>:
    D.23144 = vt->imt_collisions_bitmap;
    D.23145 = 1 << imt_slot;
    D.23146 = (unsigned int) D.23145;
    D.23147 = D.23144 & D.23146;
    if (D.23147 != 0) goto <D.23148>; else goto <D.23149>;
    <D.23148>:
    {
      int slot;
      int vtable_offset;
      void * * vtable_slot;

      slot = mono_method_get_vtable_index (imt_method);
      D.23150 = slot == -1;
      D.23151 = (long int) D.23150;
      D.23152 = __builtin_expect (D.23151, 0);
      if (D.23152 != 0) goto <D.23153>; else goto <D.23154>;
      <D.23153>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 229, "slot != -1");
      <D.23154>:
      vtable_offset = interface_offset + slot;
      vtable_slot = &vt->vtable[vtable_offset];
      D.23080 = vtable_slot;
      return D.23080;
    }
    <D.23149>:
    D.23080 = slot;
    return D.23080;
  }
}


is_generic_method_definition (struct MonoMethod * m)
{
  long unsigned int D.23156;
  long unsigned int D.23157;
  gboolean D.23160;
  long unsigned int D.23161;
  struct MonoGenericInst * D.23164;
  struct MonoMethod * D.23167;
  struct MonoGenericContainer * D.23168;
  struct MonoGenericInst * D.23169;
  struct MonoGenericContext * context;

  D.23156 = BIT_FIELD_REF <*m, 64, 256>;
  D.23157 = D.23156 & 4503599627370496;
  if (D.23157 != 0) goto <D.23158>; else goto <D.23159>;
  <D.23158>:
  D.23160 = 1;
  return D.23160;
  <D.23159>:
  D.23156 = BIT_FIELD_REF <*m, 64, 256>;
  D.23161 = D.23156 & 2251799813685248;
  if (D.23161 == 0) goto <D.23162>; else goto <D.23163>;
  <D.23162>:
  D.23160 = 0;
  return D.23160;
  <D.23163>:
  context = mono_method_get_context (m);
  D.23164 = context->method_inst;
  if (D.23164 == 0B) goto <D.23165>; else goto <D.23166>;
  <D.23165>:
  D.23160 = 0;
  return D.23160;
  <D.23166>:
  D.23164 = context->method_inst;
  D.23167 = MEM[(struct MonoMethodInflated *)m].declaring;
  D.23168 = mono_method_get_generic_container (D.23167);
  D.23169 = D.23168->context.method_inst;
  if (D.23164 == D.23169) goto <D.23170>; else goto <D.23171>;
  <D.23170>:
  D.23160 = 1;
  return D.23160;
  <D.23171>:
  D.23160 = 0;
  return D.23160;
}


__attribute__((visibility ("hidden")))
mono_generic_virtual_remoting_trampoline (mgreg_t * regs, guint8 * code, struct MonoMethod * m, guint8 * tramp)
{
  unsigned int trampoline_calls.15;
  unsigned int D.23174;
  long unsigned int D.23175;
  long unsigned int D.23176;
  _Bool D.23177;
  long int D.23178;
  long int D.23179;
  long unsigned int D.23182;
  struct MonoClass * D.23186;
  struct MonoGenericClass * D.23187;
  struct MonoGenericInst * D.23190;
  struct MonoGenericContainer * D.23192;
  _Bool D.23193;
  long int D.23194;
  long int D.23195;
  long unsigned int D.23198;
  long unsigned int D.23199;
  struct MonoGenericInst * D.23202;
  _Bool D.23203;
  long int D.23204;
  long int D.23205;
  void * D.23208;
  struct MonoGenericContext context;
  struct MonoMethod * imt_method;
  struct MonoMethod * declaring;
  void * addr;

  try
    {
      context.class_inst = 0B;
      context.method_inst = 0B;
      trampoline_calls.15 = trampoline_calls;
      D.23174 = trampoline_calls.15 + 1;
      trampoline_calls = D.23174;
      D.23175 = BIT_FIELD_REF <*m, 64, 256>;
      D.23176 = D.23175 & 4503599627370496;
      D.23177 = D.23176 == 0;
      D.23178 = (long int) D.23177;
      D.23179 = __builtin_expect (D.23178, 0);
      if (D.23179 != 0) goto <D.23180>; else goto <D.23181>;
      <D.23180>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 786, "m->is_generic");
      <D.23181>:
      D.23175 = BIT_FIELD_REF <*m, 64, 256>;
      D.23182 = D.23175 & 2251799813685248;
      if (D.23182 != 0) goto <D.23183>; else goto <D.23184>;
      <D.23183>:
      declaring = mono_method_get_declaring_generic_method (m);
      goto <D.23185>;
      <D.23184>:
      declaring = m;
      <D.23185>:
      D.23186 = m->klass;
      D.23187 = D.23186->generic_class;
      if (D.23187 != 0B) goto <D.23188>; else goto <D.23189>;
      <D.23188>:
      D.23186 = m->klass;
      D.23187 = D.23186->generic_class;
      D.23190 = D.23187->context.class_inst;
      context.class_inst = D.23190;
      goto <D.23191>;
      <D.23189>:
      D.23186 = m->klass;
      D.23192 = D.23186->generic_container;
      D.23193 = D.23192 != 0B;
      D.23194 = (long int) D.23193;
      D.23195 = __builtin_expect (D.23194, 0);
      if (D.23195 != 0) goto <D.23196>; else goto <D.23197>;
      <D.23196>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 796, "!m->klass->generic_container");
      <D.23197>:
      <D.23191>:
      imt_method = mono_arch_find_imt_method (regs, code);
      D.23198 = BIT_FIELD_REF <*imt_method, 64, 256>;
      D.23199 = D.23198 & 2251799813685248;
      if (D.23199 != 0) goto <D.23200>; else goto <D.23201>;
      <D.23200>:
      D.23202 = MEM[(struct MonoMethodInflated *)imt_method].context.method_inst;
      context.method_inst = D.23202;
      <D.23201>:
      m = mono_class_inflate_generic_method (declaring, &context);
      m = mono_marshal_get_remoting_invoke_with_check (m);
      addr = mono_compile_method (m);
      D.23203 = addr == 0B;
      D.23204 = (long int) D.23203;
      D.23205 = __builtin_expect (D.23204, 0);
      if (D.23205 != 0) goto <D.23206>; else goto <D.23207>;
      <D.23206>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 807, "addr");
      <D.23207>:
      D.23208 = addr;
      return D.23208;
    }
  finally
    {
      context = {CLOBBER};
    }
}


__attribute__((visibility ("hidden")))
mono_class_init_trampoline (mgreg_t * regs, guint8 * code, struct MonoVTable * vtable, guint8 * tramp)
{
  unsigned int trampoline_calls.16;
  unsigned int D.23212;
  long unsigned int D.23213;
  long unsigned int D.23214;
  guint8 * plt_entry;

  plt_entry = mono_aot_get_plt_entry (code);
  trampoline_calls.16 = trampoline_calls;
  D.23212 = trampoline_calls.16 + 1;
  trampoline_calls = D.23212;
  mono_runtime_class_init (vtable);
  D.23213 = BIT_FIELD_REF <*vtable, 64, 320>;
  D.23214 = D.23213 & 274877906944;
  if (D.23214 != 0) goto <D.23215>; else goto <D.23216>;
  <D.23215>:
  if (plt_entry != 0B) goto <D.23217>; else goto <D.23218>;
  <D.23217>:
  mono_arch_nullify_plt_entry (plt_entry, regs);
  goto <D.23219>;
  <D.23218>:
  mono_arch_nullify_class_init_trampoline (code, regs);
  <D.23219>:
  <D.23216>:
}


__attribute__((visibility ("hidden")))
mono_generic_class_init_trampoline (mgreg_t * regs, guint8 * code, struct MonoVTable * vtable, guint8 * tramp)
{
  unsigned int trampoline_calls.17;
  unsigned int D.23221;

  trampoline_calls.17 = trampoline_calls;
  D.23221 = trampoline_calls.17 + 1;
  trampoline_calls = D.23221;
  mono_runtime_class_init (vtable);
}


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


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


__attribute__((visibility ("hidden")))
mono_delegate_trampoline (mgreg_t * regs, guint8 * code, void * * tramp_data, guint8 * tramp)
{
  unsigned int trampoline_calls.18;
  unsigned int D.23223;
  struct MonoMethod * D.23224;
  struct MonoObject * D.23229;
  struct MonoVTable * D.23231;
  struct MonoClass * D.23232;
  struct MonoClass * D.23233;
  struct MonoRemoteClass * D.23235;
  struct MonoClass * D.23236;
  struct MonoClass * D.23237;
  long unsigned int D.23240;
  long unsigned int D.23241;
  long unsigned int D.23246;
  long unsigned int D.23247;
  struct MonoClass * D.23250;
  long unsigned int D.23251;
  long unsigned int D.23252;
  int mono_aot_only.19;
  void * D.23260;
  void * D.23261;
  int iftmp.20;
  short unsigned int D.23275;
  unsigned int D.23276;
  unsigned int D.23277;
  unsigned int D.23280;
  unsigned int D.23281;
  short unsigned int D.23286;
  int D.23287;
  int D.23288;
  int D.23293;
  guint8 * * D.23303;
  guint8 * D.23305;
  void * D.23313;
  struct MonoMulticastDelegate * D.23314;
  _Bool D.23315;
  int D.23323;
  int D.23324;
  struct MonoMethodSignature * D.23326;
  short unsigned int D.23327;
  int D.23328;
  struct MonoMethodSignature * D.23329;
  short unsigned int D.23330;
  int D.23331;
  int D.23332;
  guint8 * iftmp.21;
  void * D.23340;
  void * D.23341;
  int D.23342;
  void * D.23343;
  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 + 8B];
      impl_nothis = MEM[(void * *)tramp_data + 16B];
      trampoline_calls.18 = trampoline_calls;
      D.23223 = trampoline_calls.18 + 1;
      trampoline_calls = D.23223;
      delegate = mono_arch_get_this_arg_from_call (regs, code);
      D.23224 = delegate->method;
      if (D.23224 != 0B) goto <D.23225>; else goto <D.23226>;
      <D.23225>:
      method = delegate->method;
      D.23229 = delegate->target;
      if (D.23229 != 0B) goto <D.23230>; else goto <D.23227>;
      <D.23230>:
      D.23229 = delegate->target;
      D.23231 = D.23229->vtable;
      D.23232 = D.23231->klass;
      D.23233 = mono_defaults.transparent_proxy_class;
      if (D.23232 == D.23233) goto <D.23234>; else goto <D.23227>;
      <D.23234>:
      D.23229 = delegate->target;
      D.23235 = MEM[(struct MonoTransparentProxy *)D.23229].remote_class;
      D.23236 = D.23235->proxy_class;
      D.23237 = mono_class_get_com_object_class ();
      if (D.23236 != D.23237) goto <D.23238>; else goto <D.23239>;
      <D.23238>:
      D.23229 = delegate->target;
      D.23235 = MEM[(struct MonoTransparentProxy *)D.23229].remote_class;
      D.23236 = D.23235->proxy_class;
      D.23240 = BIT_FIELD_REF <*D.23236, 64, 256>;
      D.23241 = D.23240 & 8589934592;
      if (D.23241 == 0) goto <D.23242>; else goto <D.23243>;
      <D.23242>:
      method = mono_marshal_get_remoting_invoke (method);
      <D.23243>:
      <D.23239>:
      goto <D.23228>;
      <D.23227>:
      mono_error_init (&err);
      sig = mono_method_signature_checked (method, &err);
      if (sig == 0B) goto <D.23244>; else goto <D.23245>;
      <D.23244>:
      mono_error_raise_exception (&err);
      <D.23245>:
      D.23246 = BIT_FIELD_REF <*sig, 64, 64>;
      D.23247 = D.23246 & 512;
      if (D.23247 != 0) goto <D.23248>; else goto <D.23249>;
      <D.23248>:
      D.23250 = method->klass;
      D.23251 = BIT_FIELD_REF <*D.23250, 64, 256>;
      D.23252 = D.23251 & 1152921504606846976;
      if (D.23252 != 0) goto <D.23253>; else goto <D.23254>;
      <D.23253>:
      mono_aot_only.19 = mono_aot_only;
      if (mono_aot_only.19 != 0) goto <D.23256>; else goto <D.23257>;
      <D.23256>:
      need_unbox_tramp = 1;
      goto <D.23258>;
      <D.23257>:
      method = mono_marshal_get_unbox_wrapper (method);
      <D.23258>:
      <D.23254>:
      <D.23249>:
      <D.23228>:
      goto <D.23259>;
      <D.23226>:
      D.23260 = delegate->method_ptr;
      D.23261 = mono_get_addr_from_ftnptr (D.23260);
      ji = mono_jit_info_table_find (domain, D.23261);
      if (ji != 0B) goto <D.23262>; else goto <D.23263>;
      <D.23262>:
      method = jinfo_get_method (ji);
      <D.23263>:
      <D.23259>:
      if (method != 0B) goto <D.23264>; else goto <D.23265>;
      <D.23264>:
      mono_error_init (&err);
      sig = mono_method_signature_checked (method, &err);
      if (sig == 0B) goto <D.23266>; else goto <D.23267>;
      <D.23266>:
      mono_error_raise_exception (&err);
      <D.23267>:
      D.23229 = delegate->target;
      if (D.23229 == 0B) goto <D.23271>; else goto <D.23269>;
      <D.23271>:
      D.23246 = BIT_FIELD_REF <*sig, 64, 64>;
      D.23247 = D.23246 & 512;
      if (D.23247 != 0) goto <D.23272>; else goto <D.23269>;
      <D.23272>:
      iftmp.20 = 1;
      goto <D.23270>;
      <D.23269>:
      iftmp.20 = 0;
      <D.23270>:
      callvirt = iftmp.20;
      D.23229 = delegate->target;
      if (D.23229 != 0B) goto <D.23273>; else goto <D.23274>;
      <D.23273>:
      D.23275 = method->flags;
      D.23276 = (unsigned int) D.23275;
      D.23277 = D.23276 & 1088;
      if (D.23277 == 1088) goto <D.23278>; else goto <D.23279>;
      <D.23278>:
      D.23250 = method->klass;
      D.23280 = D.23250->flags;
      D.23281 = D.23280 & 128;
      if (D.23281 != 0) goto <D.23282>; else goto <D.23283>;
      <D.23282>:
      D.23229 = delegate->target;
      method = mono_object_get_virtual_method (D.23229, method);
      enable_caching = 0;
      <D.23283>:
      <D.23279>:
      <D.23274>:
      <D.23265>:
      if (method != 0B) goto <D.23284>; else goto <D.23285>;
      <D.23284>:
      D.23286 = method->iflags;
      D.23287 = (int) D.23286;
      D.23288 = D.23287 & 32;
      if (D.23288 != 0) goto <D.23289>; else goto <D.23290>;
      <D.23289>:
      method = mono_marshal_get_synchronized_wrapper (method);
      <D.23290>:
      <D.23285>:
      if (method != 0B) goto <D.23291>; else goto <D.23292>;
      <D.23291>:
      D.23293 = mono_method_needs_static_rgctx_invoke (method, 0);
      if (D.23293 != 0) goto <D.23294>; else goto <D.23295>;
      <D.23294>:
      need_rgctx_tramp = 1;
      <D.23295>:
      <D.23292>:
      if (method != 0B) goto <D.23298>; else goto <D.23296>;
      <D.23298>:
      if (callvirt == 0) goto <D.23299>; else goto <D.23296>;
      <D.23299>:
      if (enable_caching != 0) goto <D.23302>; else goto <D.23300>;
      <D.23302>:
      D.23303 = delegate->method_code;
      if (D.23303 != 0B) goto <D.23304>; else goto <D.23300>;
      <D.23304>:
      D.23303 = delegate->method_code;
      D.23305 = *D.23303;
      if (D.23305 != 0B) goto <D.23306>; else goto <D.23300>;
      <D.23306>:
      D.23303 = delegate->method_code;
      D.23305 = *D.23303;
      delegate->method_ptr = D.23305;
      goto <D.23301>;
      <D.23300>:
      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.23307>; else goto <D.23308>;
      <D.23307>:
      D.23303 = delegate->method_code;
      if (D.23303 != 0B) goto <D.23309>; else goto <D.23310>;
      <D.23309>:
      D.23303 = delegate->method_code;
      D.23260 = delegate->method_ptr;
      *D.23303 = D.23260;
      <D.23310>:
      <D.23308>:
      <D.23301>:
      goto <D.23297>;
      <D.23296>:
      if (need_rgctx_tramp != 0) goto <D.23311>; else goto <D.23312>;
      <D.23311>:
      D.23260 = delegate->method_ptr;
      D.23313 = mono_create_static_rgctx_trampoline (method, D.23260);
      delegate->method_ptr = D.23313;
      <D.23312>:
      <D.23297>:
      D.23314 = MEM[(struct MonoMulticastDelegate *)delegate].prev;
      D.23315 = D.23314 != 0B;
      multicast = (gboolean) D.23315;
      if (multicast == 0) goto <D.23316>; else goto <D.23317>;
      <D.23316>:
      if (callvirt == 0) goto <D.23318>; else goto <D.23319>;
      <D.23318>:
      if (method != 0B) goto <D.23322>; else goto <D.23320>;
      <D.23322>:
      D.23275 = method->flags;
      D.23323 = (int) D.23275;
      D.23324 = D.23323 & 16;
      if (D.23324 != 0) goto <D.23325>; else goto <D.23320>;
      <D.23325>:
      D.23326 = mono_method_signature (method);
      D.23327 = D.23326->param_count;
      D.23328 = (int) D.23327;
      D.23329 = mono_method_signature (invoke);
      D.23330 = D.23329->param_count;
      D.23331 = (int) D.23330;
      D.23332 = D.23331 + 1;
      if (D.23328 == D.23332) goto <D.23333>; else goto <D.23320>;
      <D.23333>:
      code = impl_this;
      goto <D.23321>;
      <D.23320>:
      D.23229 = delegate->target;
      if (D.23229 != 0B) goto <D.23335>; else goto <D.23336>;
      <D.23335>:
      iftmp.21 = impl_this;
      goto <D.23337>;
      <D.23336>:
      iftmp.21 = impl_nothis;
      <D.23337>:
      code = iftmp.21;
      <D.23321>:
      if (code != 0B) goto <D.23338>; else goto <D.23339>;
      <D.23338>:
      D.23340 = mono_get_addr_from_ftnptr (code);
      delegate->invoke_impl = D.23340;
      D.23341 = code;
      return D.23341;
      <D.23339>:
      <D.23319>:
      <D.23317>:
      m = mono_marshal_get_delegate_invoke (invoke, delegate);
      code = mono_compile_method (m);
      D.23342 = mono_method_needs_static_rgctx_invoke (m, 0);
      code = mini_add_method_trampoline (0B, m, code, D.23342, 0);
      D.23343 = mono_get_addr_from_ftnptr (code);
      delegate->invoke_impl = D.23343;
      D.23341 = code;
      return D.23341;
    }
  finally
    {
      err = {CLOBBER};
    }
}


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

  switch (tramp_type) <default: <D.22498>, case 0: <D.22487>, case 1: <D.22488>, case 2: <D.22489>, case 3: <D.22490>, case 4: <D.22491>, case 7: <D.22492>, case 8: <D.22493>, case 9: <D.22494>, case 10: <D.22495>, case 11: <D.22496>, case 12: <D.22497>>
  <D.22487>:
  <D.22488>:
  D.23346 = mono_magic_trampoline;
  return D.23346;
  <D.22489>:
  D.23346 = mono_class_init_trampoline;
  return D.23346;
  <D.22490>:
  D.23346 = mono_generic_class_init_trampoline;
  return D.23346;
  <D.22491>:
  D.23346 = mono_rgctx_lazy_fetch_trampoline;
  return D.23346;
  <D.22492>:
  D.23346 = mono_delegate_trampoline;
  return D.23346;
  <D.22493>:
  D.23346 = mono_altstack_restore_prot;
  return D.23346;
  <D.22494>:
  D.23346 = mono_generic_virtual_remoting_trampoline;
  return D.23346;
  <D.22495>:
  D.23346 = mono_monitor_enter_trampoline;
  return D.23346;
  <D.22496>:
  D.23346 = mono_monitor_exit_trampoline;
  return D.23346;
  <D.22497>:
  D.23346 = mono_vcall_trampoline;
  return D.23346;
  <D.22498>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-trampolines.c", 1200);
  D.23346 = 0B;
  return D.23346;
}


mono_vcall_trampoline (mgreg_t * regs, guint8 * code, int slot, guint8 * tramp)
{
  unsigned int trampoline_calls.22;
  unsigned int D.23349;
  _Bool D.23350;
  long int D.23351;
  long int D.23352;
  struct MonoDomain * D.23357;
  struct MonoClass * D.23360;
  long unsigned int D.23361;
  long unsigned int D.23362;
  struct MonoDomain * D.23365;
  int D.23366;
  void * D.23369;
  struct MonoDomain * D.23370;
  long unsigned int D.23372;
  long unsigned int D.23373;
  struct MonoObject * this;
  struct MonoVTable * vt;
  void * * vtable_slot;
  struct MonoMethod * m;
  gboolean need_rgctx_tramp;
  void * addr;

  need_rgctx_tramp = 0;
  trampoline_calls.22 = trampoline_calls;
  D.23349 = trampoline_calls.22 + 1;
  trampoline_calls = D.23349;
  this = mono_arch_get_this_arg_from_call (regs, code);
  D.23350 = this == 0B;
  D.23351 = (long int) D.23350;
  D.23352 = __builtin_expect (D.23351, 0);
  if (D.23352 != 0) goto <D.23353>; else goto <D.23354>;
  <D.23353>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 732, "this");
  <D.23354>:
  vt = this->vtable;
  if (slot >= 0) goto <D.23355>; else goto <D.23356>;
  <D.23355>:
  vtable_slot = &vt->vtable[slot];
  D.23357 = mono_domain_get ();
  addr = mono_aot_get_method_from_vt_slot (D.23357, vt, slot);
  if (addr != 0B) goto <D.23358>; else goto <D.23359>;
  <D.23358>:
  D.23360 = vt->klass;
  D.23361 = BIT_FIELD_REF <*D.23360, 64, 256>;
  D.23362 = D.23361 & 1152921504606846976;
  if (D.23362 == 0) goto <D.23363>; else goto <D.23364>;
  <D.23363>:
  D.23365 = mono_domain_get ();
  D.23366 = mono_domain_owns_vtable_slot (D.23365, vtable_slot);
  if (D.23366 != 0) goto <D.23367>; else goto <D.23368>;
  <D.23367>:
  *vtable_slot = addr;
  <D.23368>:
  D.23370 = mono_domain_get ();
  D.23369 = mono_create_ftnptr (D.23370, addr);
  return D.23369;
  <D.23364>:
  <D.23359>:
  D.23360 = vt->klass;
  m = mono_class_get_vtable_entry (D.23360, slot);
  need_rgctx_tramp = mono_method_needs_static_rgctx_invoke (m, 0);
  goto <D.23371>;
  <D.23356>:
  D.23372 = (long unsigned int) slot;
  D.23373 = D.23372 * 8;
  vtable_slot = vt + D.23373;
  m = 0B;
  need_rgctx_tramp = 0;
  <D.23371>:
  D.23369 = common_call_trampoline (regs, code, m, tramp, vt, vtable_slot, need_rgctx_tramp);
  return D.23369;
}


mono_rgctx_lazy_fetch_trampoline (mgreg_t * regs, guint8 * code, void * data, guint8 * tramp)
{
  long int data.23;
  mgreg_t * D.23376;
  long int D.23377;
  signed int slot.24;
  _Bool D.23379;
  unsigned int trampoline_calls.25;
  unsigned int D.23381;
  int inited.26;
  int num_lookups.27;
  int num_lookups.28;
  void * D.23389;
  static gboolean inited = 0;
  static int num_lookups = 0;
  guint32 slot;
  mgreg_t * r;
  void * arg;
  guint32 index;
  gboolean mrgctx;

  data.23 = (long int) data;
  slot = (guint32) data.23;
  r = regs;
  D.23376 = r + 72;
  D.23377 = *D.23376;
  arg = (void *) D.23377;
  index = slot & 2147483647;
  slot.24 = (signed int) slot;
  D.23379 = slot.24 < 0;
  mrgctx = (gboolean) D.23379;
  trampoline_calls.25 = trampoline_calls;
  D.23381 = trampoline_calls.25 + 1;
  trampoline_calls = D.23381;
  inited.26 = inited;
  if (inited.26 == 0) goto <D.23383>; else goto <D.23384>;
  <D.23383>:
  mono_counters_register ("RGCTX unmanaged lookups", 2048, &num_lookups);
  inited = 1;
  <D.23384>:
  num_lookups.27 = num_lookups;
  num_lookups.28 = num_lookups.27 + 1;
  num_lookups = num_lookups.28;
  if (mrgctx != 0) goto <D.23387>; else goto <D.23388>;
  <D.23387>:
  D.23389 = mono_method_fill_runtime_generic_context (arg, code, index);
  return D.23389;
  <D.23388>:
  D.23389 = mono_class_fill_runtime_generic_context (arg, code, index);
  return D.23389;
}


__attribute__((visibility ("hidden")))
mono_trampolines_init ()
{
  int mono_aot_only.29;
  guchar * D.23394;
  guchar * D.23395;
  guchar * D.23396;
  guchar * D.23397;
  guchar * D.23398;
  guchar * D.23399;
  guchar * D.23400;
  guchar * D.23401;
  guchar * D.23402;
  guchar * D.23403;
  guchar * D.23404;

  InitializeCriticalSection (&trampolines_mutex);
  mono_aot_only.29 = mono_aot_only;
  if (mono_aot_only.29 != 0) goto <D.23392>; else goto <D.23393>;
  <D.23392>:
  return;
  <D.23393>:
  D.23394 = create_trampoline_code (0);
  mono_trampoline_code[0] = D.23394;
  D.23395 = create_trampoline_code (1);
  mono_trampoline_code[1] = D.23395;
  D.23396 = create_trampoline_code (2);
  mono_trampoline_code[2] = D.23396;
  D.23397 = create_trampoline_code (3);
  mono_trampoline_code[3] = D.23397;
  D.23398 = create_trampoline_code (4);
  mono_trampoline_code[4] = D.23398;
  D.23399 = create_trampoline_code (7);
  mono_trampoline_code[7] = D.23399;
  D.23400 = create_trampoline_code (8);
  mono_trampoline_code[8] = D.23400;
  D.23401 = create_trampoline_code (9);
  mono_trampoline_code[9] = D.23401;
  D.23402 = create_trampoline_code (10);
  mono_trampoline_code[10] = D.23402;
  D.23403 = create_trampoline_code (11);
  mono_trampoline_code[11] = D.23403;
  D.23404 = create_trampoline_code (12);
  mono_trampoline_code[12] = D.23404;
  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.30;
  guchar * D.23407;
  struct MonoTrampInfo * info;
  guchar * code;

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


__attribute__((visibility ("hidden")))
mono_trampolines_cleanup ()
{
  struct GHashTable * class_init_hash_addr.31;
  struct GHashTable * rgctx_lazy_fetch_trampoline_hash.32;
  struct GHashTable * rgctx_lazy_fetch_trampoline_hash_addr.33;

  class_init_hash_addr.31 = class_init_hash_addr;
  if (class_init_hash_addr.31 != 0B) goto <D.23411>; else goto <D.23412>;
  <D.23411>:
  class_init_hash_addr.31 = class_init_hash_addr;
  monoeg_g_hash_table_destroy (class_init_hash_addr.31);
  <D.23412>:
  rgctx_lazy_fetch_trampoline_hash.32 = rgctx_lazy_fetch_trampoline_hash;
  if (rgctx_lazy_fetch_trampoline_hash.32 != 0B) goto <D.23414>; else goto <D.23415>;
  <D.23414>:
  rgctx_lazy_fetch_trampoline_hash.32 = rgctx_lazy_fetch_trampoline_hash;
  monoeg_g_hash_table_destroy (rgctx_lazy_fetch_trampoline_hash.32);
  <D.23415>:
  rgctx_lazy_fetch_trampoline_hash_addr.33 = rgctx_lazy_fetch_trampoline_hash_addr;
  if (rgctx_lazy_fetch_trampoline_hash_addr.33 != 0B) goto <D.23417>; else goto <D.23418>;
  <D.23417>:
  rgctx_lazy_fetch_trampoline_hash_addr.33 = rgctx_lazy_fetch_trampoline_hash_addr;
  monoeg_g_hash_table_destroy (rgctx_lazy_fetch_trampoline_hash_addr.33);
  <D.23418>:
  DeleteCriticalSection (&trampolines_mutex);
}


__attribute__((visibility ("hidden")))
mono_get_trampoline_code (MonoTrampolineType tramp_type)
{
  guint8 * D.23419;
  _Bool D.23420;
  long int D.23421;
  long int D.23422;
  guint8 * D.23425;

  D.23419 = mono_trampoline_code[tramp_type];
  D.23420 = D.23419 == 0B;
  D.23421 = (long int) D.23420;
  D.23422 = __builtin_expect (D.23421, 0);
  if (D.23422 != 0) goto <D.23423>; else goto <D.23424>;
  <D.23423>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1271, "mono_trampoline_code [tramp_type]");
  <D.23424>:
  D.23425 = mono_trampoline_code[tramp_type];
  return D.23425;
}


__attribute__((visibility ("hidden")))
mono_create_specific_trampoline (void * arg1, MonoTrampolineType tramp_type, struct MonoDomain * domain, guint32 * code_len)
{
  int mono_aot_only.34;
  void * D.23430;
  struct MonoImage * D.23431;

  mono_aot_only.34 = mono_aot_only;
  if (mono_aot_only.34 != 0) goto <D.23428>; else goto <D.23429>;
  <D.23428>:
  D.23431 = mono_defaults.corlib;
  D.23430 = mono_aot_create_specific_trampoline (D.23431, arg1, tramp_type, domain, code_len);
  return D.23430;
  <D.23429>:
  D.23430 = mono_arch_create_specific_trampoline (arg1, tramp_type, domain, code_len);
  return D.23430;
}


__attribute__((visibility ("hidden")))
mono_create_class_init_trampoline (struct MonoVTable * vtable)
{
  struct MonoClass * D.23433;
  struct MonoGenericContainer * D.23434;
  _Bool D.23435;
  long int D.23436;
  long int D.23437;
  union mono_mutex_t * D.23440;
  _Bool D.23443;
  long int D.23444;
  long int D.23445;
  void * D.23448;
  struct GHashTable * D.23449;
  _Bool D.23452;
  long int D.23453;
  long int D.23454;
  void * D.23459;
  _Bool D.23462;
  long int D.23463;
  long int D.23464;
  _Bool D.23469;
  long int D.23470;
  long int D.23471;
  _Bool D.23476;
  long int D.23477;
  long int D.23478;
  struct GHashTable * class_init_hash_addr.35;
  struct GHashTable * D.23484;
  _Bool D.23487;
  long int D.23488;
  long int D.23489;
  void * code;
  void * ptr;
  struct MonoDomain * domain;

  domain = vtable->domain;
  D.23433 = vtable->klass;
  D.23434 = D.23433->generic_container;
  D.23435 = D.23434 != 0B;
  D.23436 = (long int) D.23435;
  D.23437 = __builtin_expect (D.23436, 0);
  if (D.23437 != 0) goto <D.23438>; else goto <D.23439>;
  <D.23438>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1291, "!vtable->klass->generic_container");
  <D.23439>:
  {
    int ret;

    D.23440 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.23440);
    if (ret != 0) goto <D.23441>; else goto <D.23442>;
    <D.23441>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.23442>:
    D.23443 = ret != 0;
    D.23444 = (long int) D.23443;
    D.23445 = __builtin_expect (D.23444, 0);
    if (D.23445 != 0) goto <D.23446>; else goto <D.23447>;
    <D.23446>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1294, "ret == 0");
    <D.23447>:
  }
  D.23448 = domain->runtime_info;
  D.23449 = MEM[(struct MonoJitDomainInfo *)D.23448].class_init_trampoline_hash;
  ptr = monoeg_g_hash_table_lookup (D.23449, vtable);
  {
    int ret;

    D.23440 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.23440);
    if (ret != 0) goto <D.23450>; else goto <D.23451>;
    <D.23450>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.23451>:
    D.23452 = ret != 0;
    D.23453 = (long int) D.23452;
    D.23454 = __builtin_expect (D.23453, 0);
    if (D.23454 != 0) goto <D.23455>; else goto <D.23456>;
    <D.23455>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1298, "ret == 0");
    <D.23456>:
  }
  if (ptr != 0B) goto <D.23457>; else goto <D.23458>;
  <D.23457>:
  D.23459 = ptr;
  return D.23459;
  <D.23458>:
  code = mono_create_specific_trampoline (vtable, 2, domain, 0B);
  ptr = mono_create_ftnptr (domain, code);
  {
    int ret;

    D.23440 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.23440);
    if (ret != 0) goto <D.23460>; else goto <D.23461>;
    <D.23460>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock 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", 1307, "ret == 0");
    <D.23466>:
  }
  D.23448 = domain->runtime_info;
  D.23449 = MEM[(struct MonoJitDomainInfo *)D.23448].class_init_trampoline_hash;
  monoeg_g_hash_table_insert_replace (D.23449, vtable, ptr, 0);
  {
    int ret;

    D.23440 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.23440);
    if (ret != 0) goto <D.23467>; else goto <D.23468>;
    <D.23467>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.23468>:
    D.23469 = ret != 0;
    D.23470 = (long int) D.23469;
    D.23471 = __builtin_expect (D.23470, 0);
    if (D.23471 != 0) goto <D.23472>; else goto <D.23473>;
    <D.23472>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1310, "ret == 0");
    <D.23473>:
  }
  {
    int ret;

    ret = pthread_mutex_lock (&trampolines_mutex.mutex);
    if (ret != 0) goto <D.23474>; else goto <D.23475>;
    <D.23474>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.23475>:
    D.23476 = ret != 0;
    D.23477 = (long int) D.23476;
    D.23478 = __builtin_expect (D.23477, 0);
    if (D.23478 != 0) goto <D.23479>; else goto <D.23480>;
    <D.23479>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1312, "ret == 0");
    <D.23480>:
  }
  class_init_hash_addr.35 = class_init_hash_addr;
  if (class_init_hash_addr.35 == 0B) goto <D.23482>; else goto <D.23483>;
  <D.23482>:
  D.23484 = monoeg_g_hash_table_new (0B, 0B);
  class_init_hash_addr = D.23484;
  <D.23483>:
  class_init_hash_addr.35 = class_init_hash_addr;
  monoeg_g_hash_table_insert_replace (class_init_hash_addr.35, ptr, vtable, 0);
  {
    int ret;

    ret = pthread_mutex_unlock (&trampolines_mutex.mutex);
    if (ret != 0) goto <D.23485>; else goto <D.23486>;
    <D.23485>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.23486>:
    D.23487 = ret != 0;
    D.23488 = (long int) D.23487;
    D.23489 = __builtin_expect (D.23488, 0);
    if (D.23489 != 0) goto <D.23490>; else goto <D.23491>;
    <D.23490>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1316, "ret == 0");
    <D.23491>:
  }
  D.23459 = ptr;
  return D.23459;
}


__attribute__((visibility ("hidden")))
mono_create_generic_class_init_trampoline ()
{
  _Bool D.23495;
  long int D.23496;
  long int D.23497;
  void * code.36;
  int mono_aot_only.37;
  void * D.23506;
  void * code.38;
  void * code.39;
  struct MonoTrampInfo * info.40;
  _Bool D.23513;
  long int D.23514;
  long int D.23515;
  void * D.23518;
  static void * code;
  struct MonoTrampInfo * info;

  try
    {
      {
        int ret;

        ret = pthread_mutex_lock (&trampolines_mutex.mutex);
        if (ret != 0) goto <D.23493>; else goto <D.23494>;
        <D.23493>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.23494>:
        D.23495 = ret != 0;
        D.23496 = (long int) D.23495;
        D.23497 = __builtin_expect (D.23496, 0);
        if (D.23497 != 0) goto <D.23498>; else goto <D.23499>;
        <D.23498>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1328, "ret == 0");
        <D.23499>:
      }
      code.36 = code;
      if (code.36 == 0B) goto <D.23501>; else goto <D.23502>;
      <D.23501>:
      mono_aot_only.37 = mono_aot_only;
      if (mono_aot_only.37 != 0) goto <D.23504>; else goto <D.23505>;
      <D.23504>:
      D.23506 = mono_aot_get_trampoline ("generic_class_init_trampoline");
      code.38 = mono_get_addr_from_ftnptr (D.23506);
      code = code.38;
      goto <D.23508>;
      <D.23505>:
      code.39 = mono_arch_create_generic_class_init_trampoline (&info, 0);
      code = code.39;
      info.40 = info;
      mono_tramp_info_register (info.40);
      <D.23508>:
      <D.23502>:
      {
        int ret;

        ret = pthread_mutex_unlock (&trampolines_mutex.mutex);
        if (ret != 0) goto <D.23511>; else goto <D.23512>;
        <D.23511>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.23512>:
        D.23513 = ret != 0;
        D.23514 = (long int) D.23513;
        D.23515 = __builtin_expect (D.23514, 0);
        if (D.23515 != 0) goto <D.23516>; else goto <D.23517>;
        <D.23516>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1340, "ret == 0");
        <D.23517>:
      }
      D.23518 = code;
      return D.23518;
    }
  finally
    {
      info = {CLOBBER};
    }
}


__attribute__((visibility ("hidden")))
mono_create_jump_trampoline (struct MonoDomain * domain, struct MonoMethod * method, gboolean add_sync_wrapper)
{
  struct MonoJitInfo * ji.41;
  long unsigned int D.23524;
  long unsigned int D.23525;
  short unsigned int D.23528;
  int D.23529;
  int D.23530;
  void * D.23533;
  union mono_mutex_t * D.23534;
  _Bool D.23537;
  long int D.23538;
  long int D.23539;
  void * D.23542;
  struct GHashTable * D.23543;
  _Bool D.23546;
  long int D.23547;
  long int D.23548;
  struct MonoDomain * D.23553;
  unsigned int code_size.42;
  _Bool D.23555;
  long int D.23556;
  long int D.23557;
  void * ji.43;
  int code_size.44;
  _Bool D.23564;
  long int D.23565;
  long int D.23566;
  void * D.23569;
  _Bool D.23572;
  long int D.23573;
  long int D.23574;
  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.23521>; else goto <D.23522>;
      <D.23521>:
      ji.41 = ji;
      D.23524 = BIT_FIELD_REF <*ji.41, 64, 256>;
      D.23525 = D.23524 & 70368744177664;
      if (D.23525 == 0) goto <D.23526>; else goto <D.23527>;
      <D.23526>:
      D.23528 = method->iflags;
      D.23529 = (int) D.23528;
      D.23530 = D.23529 & 32;
      if (D.23530 == 0) goto <D.23531>; else goto <D.23532>;
      <D.23531>:
      D.23533 = code;
      return D.23533;
      <D.23532>:
      <D.23527>:
      <D.23522>:
      {
        int ret;

        D.23534 = &domain->lock.mutex;
        ret = pthread_mutex_lock (D.23534);
        if (ret != 0) goto <D.23535>; else goto <D.23536>;
        <D.23535>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.23536>:
        D.23537 = ret != 0;
        D.23538 = (long int) D.23537;
        D.23539 = __builtin_expect (D.23538, 0);
        if (D.23539 != 0) goto <D.23540>; else goto <D.23541>;
        <D.23540>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1365, "ret == 0");
        <D.23541>:
      }
      D.23542 = domain->runtime_info;
      D.23543 = MEM[(struct MonoJitDomainInfo *)D.23542].jump_trampoline_hash;
      code = monoeg_g_hash_table_lookup (D.23543, method);
      {
        int ret;

        D.23534 = &domain->lock.mutex;
        ret = pthread_mutex_unlock (D.23534);
        if (ret != 0) goto <D.23544>; else goto <D.23545>;
        <D.23544>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.23545>:
        D.23546 = ret != 0;
        D.23547 = (long int) D.23546;
        D.23548 = __builtin_expect (D.23547, 0);
        if (D.23548 != 0) goto <D.23549>; else goto <D.23550>;
        <D.23549>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1367, "ret == 0");
        <D.23550>:
      }
      if (code != 0B) goto <D.23551>; else goto <D.23552>;
      <D.23551>:
      D.23533 = code;
      return D.23533;
      <D.23552>:
      D.23553 = mono_domain_get ();
      code = mono_create_specific_trampoline (method, 1, D.23553, &code_size);
      code_size.42 = code_size;
      D.23555 = code_size.42 == 0;
      D.23556 = (long int) D.23555;
      D.23557 = __builtin_expect (D.23556, 0);
      if (D.23557 != 0) goto <D.23558>; else goto <D.23559>;
      <D.23558>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1372, "code_size");
      <D.23559>:
      ji.43 = mono_domain_alloc0 (domain, 48);
      ji = ji.43;
      ji.41 = ji;
      ji.41->code_start = code;
      ji.41 = ji;
      code_size.42 = code_size;
      code_size.44 = (int) code_size.42;
      ji.41->code_size = code_size.44;
      ji.41 = ji;
      ji.41->d.method = method;
      ji.41 = ji;
      mono_jit_info_table_add (domain, ji.41);
      {
        int ret;

        D.23534 = &domain->lock.mutex;
        ret = pthread_mutex_lock (D.23534);
        if (ret != 0) goto <D.23562>; else goto <D.23563>;
        <D.23562>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.23563>:
        D.23564 = ret != 0;
        D.23565 = (long int) D.23564;
        D.23566 = __builtin_expect (D.23565, 0);
        if (D.23566 != 0) goto <D.23567>; else goto <D.23568>;
        <D.23567>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1386, "ret == 0");
        <D.23568>:
      }
      D.23542 = domain->runtime_info;
      D.23543 = MEM[(struct MonoJitDomainInfo *)D.23542].jump_trampoline_hash;
      ji.41 = ji;
      D.23569 = ji.41->code_start;
      monoeg_g_hash_table_insert_replace (D.23543, method, D.23569, 0);
      {
        int ret;

        D.23534 = &domain->lock.mutex;
        ret = pthread_mutex_unlock (D.23534);
        if (ret != 0) goto <D.23570>; else goto <D.23571>;
        <D.23570>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.23571>:
        D.23572 = ret != 0;
        D.23573 = (long int) D.23572;
        D.23574 = __builtin_expect (D.23573, 0);
        if (D.23574 != 0) goto <D.23575>; else goto <D.23576>;
        <D.23575>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1388, "ret == 0");
        <D.23576>:
      }
      ji.41 = ji;
      D.23533 = ji.41->code_start;
      return D.23533;
    }
  finally
    {
      ji = {CLOBBER};
      code_size = {CLOBBER};
    }
}


__attribute__((visibility ("hidden")))
mono_create_jit_trampoline_in_domain (struct MonoDomain * domain, struct MonoMethod * method)
{
  int mono_aot_only.45;
  void * D.23584;
  union mono_mutex_t * D.23585;
  _Bool D.23588;
  long int D.23589;
  long int D.23590;
  void * D.23593;
  struct GHashTable * D.23594;
  _Bool D.23597;
  long int D.23598;
  long int D.23599;
  _Bool D.23606;
  long int D.23607;
  long int D.23608;
  _Bool D.23613;
  long int D.23614;
  long int D.23615;
  unsigned int jit_trampolines.46;
  unsigned int D.23619;
  void * tramp;

  mono_aot_only.45 = mono_aot_only;
  if (mono_aot_only.45 != 0) goto <D.23580>; else goto <D.23581>;
  <D.23580>:
  {
    void * code;

    code = mono_jit_find_compiled_method (domain, method);
    if (code != 0B) goto <D.23582>; else goto <D.23583>;
    <D.23582>:
    D.23584 = code;
    return D.23584;
    <D.23583>:
  }
  <D.23581>:
  {
    int ret;

    D.23585 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.23585);
    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", 1406, "ret == 0");
    <D.23592>:
  }
  D.23593 = domain->runtime_info;
  D.23594 = MEM[(struct MonoJitDomainInfo *)D.23593].jit_trampoline_hash;
  tramp = monoeg_g_hash_table_lookup (D.23594, method);
  {
    int ret;

    D.23585 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.23585);
    if (ret != 0) goto <D.23595>; else goto <D.23596>;
    <D.23595>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.23596>:
    D.23597 = ret != 0;
    D.23598 = (long int) D.23597;
    D.23599 = __builtin_expect (D.23598, 0);
    if (D.23599 != 0) goto <D.23600>; else goto <D.23601>;
    <D.23600>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1408, "ret == 0");
    <D.23601>:
  }
  if (tramp != 0B) goto <D.23602>; else goto <D.23603>;
  <D.23602>:
  D.23584 = tramp;
  return D.23584;
  <D.23603>:
  tramp = mono_create_specific_trampoline (method, 0, domain, 0B);
  {
    int ret;

    D.23585 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.23585);
    if (ret != 0) goto <D.23604>; else goto <D.23605>;
    <D.23604>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.23605>:
    D.23606 = ret != 0;
    D.23607 = (long int) D.23606;
    D.23608 = __builtin_expect (D.23607, 0);
    if (D.23608 != 0) goto <D.23609>; else goto <D.23610>;
    <D.23609>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1414, "ret == 0");
    <D.23610>:
  }
  D.23593 = domain->runtime_info;
  D.23594 = MEM[(struct MonoJitDomainInfo *)D.23593].jit_trampoline_hash;
  monoeg_g_hash_table_insert_replace (D.23594, method, tramp, 0);
  {
    int ret;

    D.23585 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.23585);
    if (ret != 0) goto <D.23611>; else goto <D.23612>;
    <D.23611>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.23612>:
    D.23613 = ret != 0;
    D.23614 = (long int) D.23613;
    D.23615 = __builtin_expect (D.23614, 0);
    if (D.23615 != 0) goto <D.23616>; else goto <D.23617>;
    <D.23616>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1416, "ret == 0");
    <D.23617>:
  }
  jit_trampolines.46 = jit_trampolines;
  D.23619 = jit_trampolines.46 + 1;
  jit_trampolines = D.23619;
  D.23584 = tramp;
  return D.23584;
}


__attribute__((visibility ("hidden")))
mono_create_jit_trampoline (struct MonoMethod * method)
{
  void * D.23621;
  struct MonoDomain * D.23622;

  D.23622 = mono_domain_get ();
  D.23621 = mono_create_jit_trampoline_in_domain (D.23622, method);
  return D.23621;
}


__attribute__((visibility ("hidden")))
mono_create_jit_trampoline_from_token (struct MonoImage * image, guint32 token)
{
  unsigned int jit_trampolines.47;
  unsigned int D.23625;
  void * D.23626;
  void * tramp;
  struct MonoDomain * domain;
  guint8 * buf;
  guint8 * start;

  domain = mono_domain_get ();
  start = mono_domain_alloc0 (domain, 16);
  buf = start;
  MEM[(void * *)buf] = image;
  buf = buf + 8;
  MEM[(guint32 *)buf] = token;
  tramp = mono_create_specific_trampoline (start, 5, domain, 0B);
  jit_trampolines.47 = jit_trampolines;
  D.23625 = jit_trampolines.47 + 1;
  jit_trampolines = D.23625;
  D.23626 = tramp;
  return D.23626;
}


__attribute__((visibility ("hidden")))
mono_create_delegate_trampoline (struct MonoDomain * domain, struct MonoClass * klass)
{
  union mono_mutex_t * D.23628;
  _Bool D.23631;
  long int D.23632;
  long int D.23633;
  void * D.23636;
  struct GHashTable * D.23637;
  _Bool D.23640;
  long int D.23641;
  long int D.23642;
  void * D.23647;
  _Bool D.23648;
  long int D.23649;
  long int D.23650;
  void * * D.23653;
  struct MonoMethodSignature * D.23654;
  void * D.23655;
  void * * D.23656;
  struct MonoMethodSignature * D.23657;
  void * D.23658;
  unsigned int code_size.48;
  _Bool D.23660;
  long int D.23661;
  long int D.23662;
  _Bool D.23667;
  long int D.23668;
  long int D.23669;
  _Bool D.23674;
  long int D.23675;
  long int D.23676;
  void * ptr;
  guint32 code_size;
  void * * tramp_data;
  struct MonoMethod * invoke;

  try
    {
      code_size = 0;
      {
        int ret;

        D.23628 = &domain->lock.mutex;
        ret = pthread_mutex_lock (D.23628);
        if (ret != 0) goto <D.23629>; else goto <D.23630>;
        <D.23629>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.23630>:
        D.23631 = ret != 0;
        D.23632 = (long int) D.23631;
        D.23633 = __builtin_expect (D.23632, 0);
        if (D.23633 != 0) goto <D.23634>; else goto <D.23635>;
        <D.23634>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1459, "ret == 0");
        <D.23635>:
      }
      D.23636 = domain->runtime_info;
      D.23637 = MEM[(struct MonoJitDomainInfo *)D.23636].delegate_trampoline_hash;
      ptr = monoeg_g_hash_table_lookup (D.23637, klass);
      {
        int ret;

        D.23628 = &domain->lock.mutex;
        ret = pthread_mutex_unlock (D.23628);
        if (ret != 0) goto <D.23638>; else goto <D.23639>;
        <D.23638>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.23639>:
        D.23640 = ret != 0;
        D.23641 = (long int) D.23640;
        D.23642 = __builtin_expect (D.23641, 0);
        if (D.23642 != 0) goto <D.23643>; else goto <D.23644>;
        <D.23643>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1461, "ret == 0");
        <D.23644>:
      }
      if (ptr != 0B) goto <D.23645>; else goto <D.23646>;
      <D.23645>:
      D.23647 = ptr;
      return D.23647;
      <D.23646>:
      invoke = mono_get_delegate_invoke (klass);
      D.23648 = invoke == 0B;
      D.23649 = (long int) D.23648;
      D.23650 = __builtin_expect (D.23649, 0);
      if (D.23650 != 0) goto <D.23651>; else goto <D.23652>;
      <D.23651>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1467, "invoke");
      <D.23652>:
      tramp_data = mono_domain_alloc (domain, 24);
      *tramp_data = invoke;
      D.23653 = tramp_data + 8;
      D.23654 = mono_method_signature (invoke);
      D.23655 = mono_arch_get_delegate_invoke_impl (D.23654, 1);
      *D.23653 = D.23655;
      D.23656 = tramp_data + 16;
      D.23657 = mono_method_signature (invoke);
      D.23658 = mono_arch_get_delegate_invoke_impl (D.23657, 0);
      *D.23656 = D.23658;
      ptr = mono_create_specific_trampoline (tramp_data, 7, domain, &code_size);
      code_size.48 = code_size;
      D.23660 = code_size.48 == 0;
      D.23661 = (long int) D.23660;
      D.23662 = __builtin_expect (D.23661, 0);
      if (D.23662 != 0) goto <D.23663>; else goto <D.23664>;
      <D.23663>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1475, "code_size");
      <D.23664>:
      {
        int ret;

        D.23628 = &domain->lock.mutex;
        ret = pthread_mutex_lock (D.23628);
        if (ret != 0) goto <D.23665>; else goto <D.23666>;
        <D.23665>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.23666>:
        D.23667 = ret != 0;
        D.23668 = (long int) D.23667;
        D.23669 = __builtin_expect (D.23668, 0);
        if (D.23669 != 0) goto <D.23670>; else goto <D.23671>;
        <D.23670>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1478, "ret == 0");
        <D.23671>:
      }
      D.23636 = domain->runtime_info;
      D.23637 = MEM[(struct MonoJitDomainInfo *)D.23636].delegate_trampoline_hash;
      monoeg_g_hash_table_insert_replace (D.23637, klass, ptr, 0);
      {
        int ret;

        D.23628 = &domain->lock.mutex;
        ret = pthread_mutex_unlock (D.23628);
        if (ret != 0) goto <D.23672>; else goto <D.23673>;
        <D.23672>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.23673>:
        D.23674 = ret != 0;
        D.23675 = (long int) D.23674;
        D.23676 = __builtin_expect (D.23675, 0);
        if (D.23676 != 0) goto <D.23677>; else goto <D.23678>;
        <D.23677>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1481, "ret == 0");
        <D.23678>:
      }
      D.23647 = ptr;
      return D.23647;
    }
  finally
    {
      code_size = {CLOBBER};
    }
}


__attribute__((visibility ("hidden")))
mono_create_rgctx_lazy_fetch_trampoline (guint32 offset)
{
  _Bool D.23683;
  long int D.23684;
  long int D.23685;
  struct GHashTable * rgctx_lazy_fetch_trampoline_hash.49;
  long unsigned int D.23691;
  const void * D.23692;
  _Bool D.23696;
  long int D.23697;
  long int D.23698;
  void * D.23703;
  int mono_aot_only.50;
  struct MonoTrampInfo * info.51;
  struct MonoDomain * D.23709;
  _Bool D.23712;
  long int D.23713;
  long int D.23714;
  struct GHashTable * D.23719;
  struct GHashTable * D.23720;
  void * D.23721;
  _Bool D.23722;
  long int D.23723;
  long int D.23724;
  struct GHashTable * rgctx_lazy_fetch_trampoline_hash_addr.52;
  unsigned int D.23728;
  long unsigned int D.23729;
  void * D.23730;
  _Bool D.23733;
  long int D.23734;
  long int D.23735;
  int inited.53;
  int num_trampolines.54;
  int num_trampolines.55;
  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.23681>; else goto <D.23682>;
        <D.23681>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.23682>:
        D.23683 = ret != 0;
        D.23684 = (long int) D.23683;
        D.23685 = __builtin_expect (D.23684, 0);
        if (D.23685 != 0) goto <D.23686>; else goto <D.23687>;
        <D.23686>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1498, "ret == 0");
        <D.23687>:
      }
      rgctx_lazy_fetch_trampoline_hash.49 = rgctx_lazy_fetch_trampoline_hash;
      if (rgctx_lazy_fetch_trampoline_hash.49 != 0B) goto <D.23689>; else goto <D.23690>;
      <D.23689>:
      rgctx_lazy_fetch_trampoline_hash.49 = rgctx_lazy_fetch_trampoline_hash;
      D.23691 = (long unsigned int) offset;
      D.23692 = (const void *) D.23691;
      tramp = monoeg_g_hash_table_lookup (rgctx_lazy_fetch_trampoline_hash.49, D.23692);
      goto <D.23693>;
      <D.23690>:
      tramp = 0B;
      <D.23693>:
      {
        int ret;

        ret = pthread_mutex_unlock (&trampolines_mutex.mutex);
        if (ret != 0) goto <D.23694>; else goto <D.23695>;
        <D.23694>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.23695>:
        D.23696 = ret != 0;
        D.23697 = (long int) D.23696;
        D.23698 = __builtin_expect (D.23697, 0);
        if (D.23698 != 0) goto <D.23699>; else goto <D.23700>;
        <D.23699>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1503, "ret == 0");
        <D.23700>:
      }
      if (tramp != 0B) goto <D.23701>; else goto <D.23702>;
      <D.23701>:
      D.23703 = tramp;
      return D.23703;
      <D.23702>:
      mono_aot_only.50 = mono_aot_only;
      if (mono_aot_only.50 != 0) goto <D.23705>; else goto <D.23706>;
      <D.23705>:
      ptr = mono_aot_get_lazy_fetch_trampoline (offset);
      goto <D.23707>;
      <D.23706>:
      tramp = mono_arch_create_rgctx_lazy_fetch_trampoline (offset, &info, 0);
      info.51 = info;
      mono_tramp_info_register (info.51);
      D.23709 = mono_get_root_domain ();
      ptr = mono_create_ftnptr (D.23709, tramp);
      <D.23707>:
      {
        int ret;

        ret = pthread_mutex_lock (&trampolines_mutex.mutex);
        if (ret != 0) goto <D.23710>; else goto <D.23711>;
        <D.23710>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.23711>:
        D.23712 = ret != 0;
        D.23713 = (long int) D.23712;
        D.23714 = __builtin_expect (D.23713, 0);
        if (D.23714 != 0) goto <D.23715>; else goto <D.23716>;
        <D.23715>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1515, "ret == 0");
        <D.23716>:
      }
      rgctx_lazy_fetch_trampoline_hash.49 = rgctx_lazy_fetch_trampoline_hash;
      if (rgctx_lazy_fetch_trampoline_hash.49 == 0B) goto <D.23717>; else goto <D.23718>;
      <D.23717>:
      D.23719 = monoeg_g_hash_table_new (0B, 0B);
      rgctx_lazy_fetch_trampoline_hash = D.23719;
      D.23720 = monoeg_g_hash_table_new (0B, 0B);
      rgctx_lazy_fetch_trampoline_hash_addr = D.23720;
      <D.23718>:
      rgctx_lazy_fetch_trampoline_hash.49 = rgctx_lazy_fetch_trampoline_hash;
      D.23691 = (long unsigned int) offset;
      D.23721 = (void *) D.23691;
      monoeg_g_hash_table_insert_replace (rgctx_lazy_fetch_trampoline_hash.49, D.23721, ptr, 0);
      D.23722 = offset == 4294967295;
      D.23723 = (long int) D.23722;
      D.23724 = __builtin_expect (D.23723, 0);
      if (D.23724 != 0) goto <D.23725>; else goto <D.23726>;
      <D.23725>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1521, "offset != -1");
      <D.23726>:
      rgctx_lazy_fetch_trampoline_hash_addr.52 = rgctx_lazy_fetch_trampoline_hash_addr;
      D.23728 = offset + 1;
      D.23729 = (long unsigned int) D.23728;
      D.23730 = (void *) D.23729;
      monoeg_g_hash_table_insert_replace (rgctx_lazy_fetch_trampoline_hash_addr.52, ptr, D.23730, 0);
      {
        int ret;

        ret = pthread_mutex_unlock (&trampolines_mutex.mutex);
        if (ret != 0) goto <D.23731>; else goto <D.23732>;
        <D.23731>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.23732>:
        D.23733 = ret != 0;
        D.23734 = (long int) D.23733;
        D.23735 = __builtin_expect (D.23734, 0);
        if (D.23735 != 0) goto <D.23736>; else goto <D.23737>;
        <D.23736>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1523, "ret == 0");
        <D.23737>:
      }
      inited.53 = inited;
      if (inited.53 == 0) goto <D.23739>; else goto <D.23740>;
      <D.23739>:
      mono_counters_register ("RGCTX num lazy fetch trampolines", 2048, &num_trampolines);
      inited = 1;
      <D.23740>:
      num_trampolines.54 = num_trampolines;
      num_trampolines.55 = num_trampolines.54 + 1;
      num_trampolines = num_trampolines.55;
      D.23703 = ptr;
      return D.23703;
    }
  finally
    {
      info = {CLOBBER};
    }
}


__attribute__((visibility ("hidden")))
mono_create_monitor_enter_trampoline ()
{
  int mono_aot_only.56;
  void * code.57;
  void * code.58;
  void * D.23752;
  static void * code;

  mono_aot_only.56 = mono_aot_only;
  if (mono_aot_only.56 != 0) goto <D.23746>; else goto <D.23747>;
  <D.23746>:
  code.57 = code;
  if (code.57 == 0B) goto <D.23749>; else goto <D.23750>;
  <D.23749>:
  code.58 = mono_aot_get_trampoline ("monitor_enter_trampoline");
  code = code.58;
  <D.23750>:
  D.23752 = code;
  return D.23752;
  <D.23747>:
  code = 0B;
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-trampolines.c", 1559);
  D.23752 = code;
  return D.23752;
}


__attribute__((visibility ("hidden")))
mono_create_monitor_exit_trampoline ()
{
  int mono_aot_only.59;
  void * code.60;
  void * code.61;
  void * D.23761;
  static void * code;

  mono_aot_only.59 = mono_aot_only;
  if (mono_aot_only.59 != 0) goto <D.23755>; else goto <D.23756>;
  <D.23755>:
  code.60 = code;
  if (code.60 == 0B) goto <D.23758>; else goto <D.23759>;
  <D.23758>:
  code.61 = mono_aot_get_trampoline ("monitor_exit_trampoline");
  code = code.61;
  <D.23759>:
  D.23761 = code;
  return D.23761;
  <D.23756>:
  code = 0B;
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-trampolines.c", 1589);
  D.23761 = code;
  return D.23761;
}


__attribute__((visibility ("hidden")))
mono_find_class_init_trampoline_by_addr (const void * addr)
{
  _Bool D.23765;
  long int D.23766;
  long int D.23767;
  struct GHashTable * class_init_hash_addr.62;
  _Bool D.23776;
  long int D.23777;
  long int D.23778;
  struct MonoVTable * D.23781;
  struct MonoVTable * res;

  {
    int ret;

    ret = pthread_mutex_lock (&trampolines_mutex.mutex);
    if (ret != 0) goto <D.23763>; else goto <D.23764>;
    <D.23763>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.23764>:
    D.23765 = ret != 0;
    D.23766 = (long int) D.23765;
    D.23767 = __builtin_expect (D.23766, 0);
    if (D.23767 != 0) goto <D.23768>; else goto <D.23769>;
    <D.23768>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1619, "ret == 0");
    <D.23769>:
  }
  class_init_hash_addr.62 = class_init_hash_addr;
  if (class_init_hash_addr.62 != 0B) goto <D.23771>; else goto <D.23772>;
  <D.23771>:
  class_init_hash_addr.62 = class_init_hash_addr;
  res = monoeg_g_hash_table_lookup (class_init_hash_addr.62, addr);
  goto <D.23773>;
  <D.23772>:
  res = 0B;
  <D.23773>:
  {
    int ret;

    ret = pthread_mutex_unlock (&trampolines_mutex.mutex);
    if (ret != 0) goto <D.23774>; else goto <D.23775>;
    <D.23774>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.23775>:
    D.23776 = ret != 0;
    D.23777 = (long int) D.23776;
    D.23778 = __builtin_expect (D.23777, 0);
    if (D.23778 != 0) goto <D.23779>; else goto <D.23780>;
    <D.23779>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1624, "ret == 0");
    <D.23780>:
  }
  D.23781 = res;
  return D.23781;
}


__attribute__((visibility ("hidden")))
mono_find_rgctx_lazy_fetch_trampoline_by_addr (const void * addr)
{
  _Bool D.23785;
  long int D.23786;
  long int D.23787;
  struct GHashTable * rgctx_lazy_fetch_trampoline_hash_addr.63;
  void * D.23793;
  long int D.23794;
  _Bool D.23801;
  long int D.23802;
  long int D.23803;
  guint32 D.23806;
  int offset;

  {
    int ret;

    ret = pthread_mutex_lock (&trampolines_mutex.mutex);
    if (ret != 0) goto <D.23783>; else goto <D.23784>;
    <D.23783>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.23784>:
    D.23785 = ret != 0;
    D.23786 = (long int) D.23785;
    D.23787 = __builtin_expect (D.23786, 0);
    if (D.23787 != 0) goto <D.23788>; else goto <D.23789>;
    <D.23788>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1633, "ret == 0");
    <D.23789>:
  }
  rgctx_lazy_fetch_trampoline_hash_addr.63 = rgctx_lazy_fetch_trampoline_hash_addr;
  if (rgctx_lazy_fetch_trampoline_hash_addr.63 != 0B) goto <D.23791>; else goto <D.23792>;
  <D.23791>:
  rgctx_lazy_fetch_trampoline_hash_addr.63 = rgctx_lazy_fetch_trampoline_hash_addr;
  D.23793 = monoeg_g_hash_table_lookup (rgctx_lazy_fetch_trampoline_hash_addr.63, addr);
  D.23794 = (long int) D.23793;
  offset = (int) D.23794;
  if (offset != 0) goto <D.23795>; else goto <D.23796>;
  <D.23795>:
  offset = offset + -1;
  goto <D.23797>;
  <D.23796>:
  offset = -1;
  <D.23797>:
  goto <D.23798>;
  <D.23792>:
  offset = -1;
  <D.23798>:
  {
    int ret;

    ret = pthread_mutex_unlock (&trampolines_mutex.mutex);
    if (ret != 0) goto <D.23799>; else goto <D.23800>;
    <D.23799>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.23800>:
    D.23801 = ret != 0;
    D.23802 = (long int) D.23801;
    D.23803 = __builtin_expect (D.23802, 0);
    if (D.23803 != 0) goto <D.23804>; else goto <D.23805>;
    <D.23804>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1644, "ret == 0");
    <D.23805>:
  }
  D.23806 = (guint32) offset;
  return D.23806;
}


__attribute__((visibility ("hidden")))
mono_get_generic_trampoline_name (MonoTrampolineType tramp_type)
{
  char * D.23808;
  const char * D.23809;

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


__attribute__((visibility ("hidden")))
mono_get_rgctx_fetch_trampoline_name (int slot)
{
  _Bool D.23811;
  char * D.23812;
  const char * iftmp.64;
  gboolean mrgctx;
  int index;

  D.23811 = slot < 0;
  mrgctx = (gboolean) D.23811;
  index = slot & 2147483647;
  if (mrgctx != 0) goto <D.23814>; else goto <D.23815>;
  <D.23814>:
  iftmp.64 = "mrgctx";
  goto <D.23816>;
  <D.23815>:
  iftmp.64 = "rgctx";
  <D.23816>:
  D.23812 = monoeg_g_strdup_printf ("rgctx_fetch_trampoline_%s_%d", iftmp.64, index);
  return D.23812;
}


__attribute__((visibility ("hidden")))
mini_get_nullified_class_init_trampoline ()
{
  void * nullified_class_init_trampoline.65;
  int mono_aot_only.66;
  struct MonoTrampInfo * info.67;
  void * D.23826;
  static void * nullified_class_init_trampoline;

  nullified_class_init_trampoline.65 = nullified_class_init_trampoline;
  if (nullified_class_init_trampoline.65 == 0B) goto <D.23819>; else goto <D.23820>;
  <D.23819>:
  {
    void * tramp;
    struct MonoTrampInfo * info;

    try
      {
        mono_aot_only.66 = mono_aot_only;
        if (mono_aot_only.66 != 0) goto <D.23822>; else goto <D.23823>;
        <D.23822>:
        tramp = mono_aot_get_trampoline ("nullified_class_init_trampoline");
        goto <D.23824>;
        <D.23823>:
        tramp = mono_arch_get_nullified_class_init_trampoline (&info);
        info.67 = info;
        mono_tramp_info_register (info.67);
        <D.23824>:
        mono_memory_barrier ();
        nullified_class_init_trampoline = tramp;
      }
    finally
      {
        info = {CLOBBER};
      }
  }
  <D.23820>:
  D.23826 = nullified_class_init_trampoline;
  return D.23826;
}


mono_memory_barrier ()
{
  __sync_synchronize ();
}