mono_create_static_rgctx_trampoline (struct MonoMethod * m, void * addr)
{
  void * * D.22822;
  void * D.22823;
  _Bool D.22824;
  long int D.22825;
  long int D.22826;
  union mono_mutex_t * D.22829;
  _Bool D.22832;
  long int D.22833;
  long int D.22834;
  void * D.22837;
  struct GHashTable * D.22838;
  struct GHashTable * D.22841;
  _Bool D.22844;
  long int D.22845;
  long int D.22846;
  void * D.22851;
  int mono_aot_only.0;
  _Bool D.22858;
  long int D.22859;
  long int D.22860;
  _Bool D.22865;
  long int D.22866;
  long int D.22867;
  unsigned int static_rgctx_trampolines.1;
  unsigned int static_rgctx_trampolines.2;
  void * ctx;
  void * res;
  struct MonoDomain * domain;
  struct RgctxTrampInfo tmp_info;
  struct RgctxTrampInfo * info;

  try
    {
      D.22822 = addr + 16;
      D.22823 = *D.22822;
      D.22824 = D.22823 != 0B;
      D.22825 = (long int) D.22824;
      D.22826 = __builtin_expect (D.22825, 0);
      if (D.22826 != 0) goto <D.22827>; else goto <D.22828>;
      <D.22827>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 85, "((gpointer*)addr) [2] == 0");
      <D.22828>:
      ctx = mini_method_get_rgctx (m);
      domain = mono_domain_get ();
      {
        int ret;

        D.22829 = &domain->lock.mutex;
        ret = pthread_mutex_lock (D.22829);
        if (ret != 0) goto <D.22830>; else goto <D.22831>;
        <D.22830>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.22831>:
        D.22832 = ret != 0;
        D.22833 = (long int) D.22832;
        D.22834 = __builtin_expect (D.22833, 0);
        if (D.22834 != 0) goto <D.22835>; else goto <D.22836>;
        <D.22835>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 96, "ret == 0");
        <D.22836>:
      }
      D.22837 = domain->runtime_info;
      D.22838 = MEM[(struct MonoJitDomainInfo *)D.22837].static_rgctx_trampoline_hash;
      if (D.22838 == 0B) goto <D.22839>; else goto <D.22840>;
      <D.22839>:
      D.22837 = domain->runtime_info;
      D.22841 = monoeg_g_hash_table_new (rgctx_tramp_info_hash, rgctx_tramp_info_equal);
      MEM[(struct MonoJitDomainInfo *)D.22837].static_rgctx_trampoline_hash = D.22841;
      <D.22840>:
      tmp_info.m = m;
      tmp_info.addr = addr;
      D.22837 = domain->runtime_info;
      D.22838 = MEM[(struct MonoJitDomainInfo *)D.22837].static_rgctx_trampoline_hash;
      res = monoeg_g_hash_table_lookup (D.22838, &tmp_info);
      {
        int ret;

        D.22829 = &domain->lock.mutex;
        ret = pthread_mutex_unlock (D.22829);
        if (ret != 0) goto <D.22842>; else goto <D.22843>;
        <D.22842>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.22843>:
        D.22844 = ret != 0;
        D.22845 = (long int) D.22844;
        D.22846 = __builtin_expect (D.22845, 0);
        if (D.22846 != 0) goto <D.22847>; else goto <D.22848>;
        <D.22847>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 103, "ret == 0");
        <D.22848>:
      }
      if (res != 0B) goto <D.22849>; else goto <D.22850>;
      <D.22849>:
      D.22851 = res;
      return D.22851;
      <D.22850>:
      mono_aot_only.0 = mono_aot_only;
      if (mono_aot_only.0 != 0) goto <D.22853>; else goto <D.22854>;
      <D.22853>:
      res = mono_aot_get_static_rgctx_trampoline (ctx, addr);
      goto <D.22855>;
      <D.22854>:
      res = mono_arch_get_static_rgctx_trampoline (m, ctx, addr);
      <D.22855>:
      {
        int ret;

        D.22829 = &domain->lock.mutex;
        ret = pthread_mutex_lock (D.22829);
        if (ret != 0) goto <D.22856>; else goto <D.22857>;
        <D.22856>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.22857>:
        D.22858 = ret != 0;
        D.22859 = (long int) D.22858;
        D.22860 = __builtin_expect (D.22859, 0);
        if (D.22860 != 0) goto <D.22861>; else goto <D.22862>;
        <D.22861>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 112, "ret == 0");
        <D.22862>:
      }
      info = mono_domain_alloc (domain, 16);
      info->m = m;
      info->addr = addr;
      D.22837 = domain->runtime_info;
      D.22838 = MEM[(struct MonoJitDomainInfo *)D.22837].static_rgctx_trampoline_hash;
      monoeg_g_hash_table_insert_replace (D.22838, info, res, 0);
      {
        int ret;

        D.22829 = &domain->lock.mutex;
        ret = pthread_mutex_unlock (D.22829);
        if (ret != 0) goto <D.22863>; else goto <D.22864>;
        <D.22863>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.22864>:
        D.22865 = ret != 0;
        D.22866 = (long int) D.22865;
        D.22867 = __builtin_expect (D.22866, 0);
        if (D.22867 != 0) goto <D.22868>; else goto <D.22869>;
        <D.22868>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 118, "ret == 0");
        <D.22869>:
      }
      static_rgctx_trampolines.1 = static_rgctx_trampolines;
      static_rgctx_trampolines.2 = static_rgctx_trampolines.1 + 1;
      static_rgctx_trampolines = static_rgctx_trampolines.2;
      D.22851 = res;
      return D.22851;
    }
  finally
    {
      tmp_info = {CLOBBER};
    }
}


rgctx_tramp_info_equal (const void * ka, const void * kb)
{
  struct MonoMethod * D.22875;
  struct MonoMethod * D.22876;
  void * D.22878;
  void * D.22879;
  gint D.22881;
  const struct RgctxTrampInfo * i1;
  const struct RgctxTrampInfo * i2;

  i1 = ka;
  i2 = kb;
  D.22875 = i1->m;
  D.22876 = i2->m;
  if (D.22875 == D.22876) goto <D.22877>; else goto <D.22874>;
  <D.22877>:
  D.22878 = i1->addr;
  D.22879 = i2->addr;
  if (D.22878 == D.22879) goto <D.22880>; else goto <D.22874>;
  <D.22880>:
  D.22881 = 1;
  return D.22881;
  <D.22874>:
  D.22881 = 0;
  return D.22881;
}


rgctx_tramp_info_hash (const void * data)
{
  guint D.22883;
  struct MonoMethod * D.22884;
  long int D.22885;
  unsigned int D.22886;
  void * D.22887;
  long int D.22888;
  unsigned int D.22889;
  const struct RgctxTrampInfo * info;

  info = data;
  D.22884 = info->m;
  D.22885 = (long int) D.22884;
  D.22886 = (unsigned int) D.22885;
  D.22887 = info->addr;
  D.22888 = (long int) D.22887;
  D.22889 = (unsigned int) D.22888;
  D.22883 = D.22886 ^ D.22889;
  return D.22883;
}


mini_jit_info_is_gsharedvt (struct MonoJitInfo * ji)
{
  long unsigned int D.22894;
  long unsigned int D.22895;
  struct MonoGenericSharingContext * D.22897;
  gboolean * D.22898;
  struct MonoGenericSharingContext * D.22900;
  gboolean * D.22901;
  gboolean D.22902;

  if (ji != 0B) goto <D.22893>; else goto <D.22891>;
  <D.22893>:
  D.22894 = BIT_FIELD_REF <*ji, 64, 256>;
  D.22895 = D.22894 & 131072;
  if (D.22895 != 0) goto <D.22896>; else goto <D.22891>;
  <D.22896>:
  D.22897 = mono_jit_info_get_generic_sharing_context (ji);
  D.22898 = D.22897->var_is_vt;
  if (D.22898 != 0B) goto <D.22892>; else goto <D.22899>;
  <D.22899>:
  D.22900 = mono_jit_info_get_generic_sharing_context (ji);
  D.22901 = D.22900->mvar_is_vt;
  if (D.22901 != 0B) goto <D.22892>; else goto <D.22891>;
  <D.22892>:
  D.22902 = 1;
  return D.22902;
  <D.22891>:
  D.22902 = 0;
  return D.22902;
}


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.22904;
  void * D.22905;
  long unsigned int D.22906;
  long unsigned int D.22907;
  <unnamed type> D.22912;
  <unnamed type> D.22920;
  long unsigned int D.22927;
  _Bool D.22928;
  long int D.22929;
  long int D.22930;
  int mono_aot_only.3;
  unsigned int unbox_trampolines.4;
  unsigned int unbox_trampolines.5;
  struct MonoMethodSignature * D.22945;
  int D.22946;
  void * D.22953;
  void * addr;
  gboolean callee_gsharedvt;
  gboolean callee_array_helper;
  struct MonoMethod * jmethod;
  struct MonoJitInfo * ji;

  addr = compiled_method;
  jmethod = 0B;
  D.22904 = mono_domain_get ();
  D.22905 = mono_get_addr_from_ftnptr (compiled_method);
  ji = mini_jit_info_table_find (D.22904, D.22905, 0B);
  callee_gsharedvt = mini_jit_info_is_gsharedvt (ji);
  callee_array_helper = 0;
  D.22906 = BIT_FIELD_REF <*m, 64, 256>;
  D.22907 = D.22906 & 124;
  if (D.22907 == 28) goto <D.22908>; else goto <D.22909>;
  <D.22908>:
  {
    struct WrapperInfo * info;

    info = mono_marshal_get_wrapper_info (m);
    if (info != 0B) goto <D.22910>; else goto <D.22911>;
    <D.22910>:
    D.22912 = info->subtype;
    if (D.22912 == 21) goto <D.22913>; else goto <D.22914>;
    <D.22913>:
    callee_array_helper = 1;
    m = info->d.generic_array_helper.method;
    <D.22914>:
    <D.22911>:
  }
  goto <D.22915>;
  <D.22909>:
  D.22906 = BIT_FIELD_REF <*m, 64, 256>;
  D.22907 = D.22906 & 124;
  if (D.22907 == 100) goto <D.22916>; else goto <D.22917>;
  <D.22916>:
  {
    struct WrapperInfo * info;

    info = mono_marshal_get_wrapper_info (m);
    if (info != 0B) goto <D.22918>; else goto <D.22919>;
    <D.22918>:
    D.22920 = info->subtype;
    if (D.22920 == 17) goto <D.22921>; else goto <D.22922>;
    <D.22921>:
    m = info->d.synchronized_inner.method;
    <D.22922>:
    <D.22919>:
  }
  <D.22917>:
  <D.22915>:
  if (orig_method == 0B) goto <D.22923>; else goto <D.22924>;
  <D.22923>:
  orig_method = m;
  <D.22924>:
  if (callee_gsharedvt != 0) goto <D.22925>; else goto <D.22926>;
  <D.22925>:
  D.22906 = BIT_FIELD_REF <*m, 64, 256>;
  D.22927 = D.22906 & 4096;
  D.22928 = D.22927 == 0;
  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", 324, "m->is_inflated");
  <D.22932>:
  <D.22926>:
  addr = compiled_method;
  if (add_unbox_tramp != 0) goto <D.22933>; else goto <D.22934>;
  <D.22933>:
  mono_aot_only.3 = mono_aot_only;
  if (mono_aot_only.3 != 0) goto <D.22936>; else goto <D.22937>;
  <D.22936>:
  addr = mono_aot_get_unbox_trampoline (m);
  goto <D.22938>;
  <D.22937>:
  unbox_trampolines.4 = unbox_trampolines;
  unbox_trampolines.5 = unbox_trampolines.4 + 1;
  unbox_trampolines = unbox_trampolines.5;
  addr = mono_arch_get_unbox_trampoline (m, addr);
  <D.22938>:
  <D.22934>:
  if (ji != 0B) goto <D.22941>; else goto <D.22942>;
  <D.22941>:
  jmethod = jinfo_get_method (ji);
  <D.22942>:
  if (callee_gsharedvt != 0) goto <D.22943>; else goto <D.22944>;
  <D.22943>:
  D.22945 = mono_method_signature (jmethod);
  D.22946 = mini_is_gsharedvt_variable_signature (D.22945);
  if (D.22946 != 0) goto <D.22947>; else goto <D.22948>;
  <D.22947>:
  {
    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.22948>:
  <D.22944>:
  if (add_static_rgctx_tramp != 0) goto <D.22949>; else goto <D.22950>;
  <D.22949>:
  if (callee_array_helper == 0) goto <D.22951>; else goto <D.22952>;
  <D.22951>:
  addr = mono_create_static_rgctx_trampoline (m, addr);
  <D.22952>:
  <D.22950>:
  D.22953 = addr;
  return D.22953;
}


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

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


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

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


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.22961;
  _Bool D.22966;
  long int D.22967;
  long int D.22968;
  struct MonoVTable * D.22971;
  struct MonoClass * D.22972;
  struct MonoClass * D.22973;
  long unsigned int D.22979;
  long unsigned int D.22980;
  struct MonoGenericInst * D.22982;
  int variance_used.8;
  struct MonoClass * D.22987;
  int D.22988;
  _Bool D.22991;
  _Bool D.22992;
  _Bool D.22993;
  void * addr.9;
  struct MonoDomain * D.22997;
  int D.22998;
  void * D.23001;
  struct MonoDomain * D.23002;
  int D.23006;
  struct MonoGenericClass * D.23011;
  struct MonoGenericInst * D.23014;
  struct MonoGenericContainer * D.23016;
  _Bool D.23017;
  long int D.23018;
  long int D.23019;
  long unsigned int D.23024;
  long unsigned int D.23025;
  _Bool D.23026;
  long int D.23027;
  long int D.23028;
  struct MonoGenericInst * D.23031;
  _Bool D.23034;
  long int D.23035;
  long int D.23036;
  struct MonoGenericContext * D.23042;
  struct MonoGenericInst * D.23043;
  struct MonoVTable * D.23045;
  short unsigned int D.23049;
  int D.23050;
  int D.23051;
  long unsigned int D.23053;
  long unsigned int D.23054;
  struct MonoVTable * D.23055;
  struct MonoClass * D.23056;
  long unsigned int D.23057;
  long unsigned int D.23058;
  _Bool D.23059;
  long int D.23060;
  long int D.23061;
  struct MonoClass * * D.23066;
  short unsigned int D.23067;
  long unsigned int D.23068;
  long unsigned int D.23069;
  sizetype D.23070;
  struct MonoClass * * D.23071;
  int iftmp.10;
  _Bool D.23077;
  long int D.23078;
  long int D.23079;
  long int vtable_slot.11;
  long int vt.12;
  long int D.23086;
  long int D.23087;
  _Bool D.23088;
  long int D.23089;
  long int D.23090;
  struct MonoClass * D.23093;
  struct MonoMethod * * D.23094;
  long unsigned int D.23095;
  long unsigned int D.23096;
  struct MonoMethod * * D.23097;
  long unsigned int D.23102;
  struct MonoGenericClass * D.23106;
  struct MonoGenericInst * D.23109;
  struct MonoGenericContainer * D.23111;
  struct MonoGenericInst * D.23114;
  _Bool D.23115;
  long int D.23116;
  long int D.23117;
  _Bool D.23120;
  long int D.23121;
  long int D.23122;
  struct MonoClass * D.23125;
  _Bool D.23126;
  long int D.23127;
  long int D.23128;
  long unsigned int D.23131;
  long unsigned int D.23132;
  short unsigned int D.23136;
  int D.23137;
  int D.23138;
  int D.23143;
  _Bool D.23146;
  long int D.23147;
  long int D.23148;
  struct MonoClass * D.23155;
  long unsigned int D.23156;
  long unsigned int D.23157;
  int need_rgctx_tramp.13;
  void * addr.14;
  struct MonoMethod * iftmp.15;
  struct MonoDomain * D.23175;
  void * D.23178;
  struct GHashTable * D.23179;
  union mono_mutex_t * D.23182;
  _Bool D.23185;
  long int D.23186;
  long int D.23187;
  _Bool D.23194;
  long int D.23195;
  long int D.23196;
  int D.23205;
  struct MonoDomain * D.23207;
  int D.23208;
  void * D.23209;
  _Bool D.23210;
  long int D.23211;
  long int D.23212;
  void * D.23215;
  struct MonoDomain * D.23221;
  void * D.23222;
  struct MonoDomain * D.23225;
  long unsigned int D.23232;
  long unsigned int D.23233;
  long unsigned int D.23236;
  long unsigned int D.23237;
  struct MonoDomain * D.23247;
  void * D.23248;
  struct MonoDomain * D.23251;
  int D.23264;
  void * D.23267;
  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.22961 = vtable_slot > vt;
      virtual = (gboolean) D.22961;
      orig_vtable_slot = vtable_slot;
      vtable_slot_to_patch = vtable_slot;
      if (vt != 0B) goto <D.22962>; else goto <D.22963>;
      <D.22962>:
      if (vtable_slot < vt) goto <D.22964>; else goto <D.22965>;
      <D.22964>:
      {
        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.22966 = vtable_slot == 0B;
            D.22967 = (long int) D.22966;
            D.22968 = __builtin_expect (D.22967, 0);
            if (D.22968 != 0) goto <D.22969>; else goto <D.22970>;
            <D.22969>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 401, "vtable_slot");
            <D.22970>:
            orig_method = m;
            this_arg = mono_arch_get_this_arg_from_call (regs, code);
            D.22971 = this_arg->vtable;
            D.22972 = D.22971->klass;
            D.22973 = mono_defaults.transparent_proxy_class;
            if (D.22972 == D.22973) goto <D.22974>; else goto <D.22975>;
            <D.22974>:
            m = mono_object_get_virtual_method (this_arg, m);
            vtable_slot_to_patch = 0B;
            goto <D.22976>;
            <D.22975>:
            {
              gboolean lookup_aot;

              D.22979 = BIT_FIELD_REF <*m, 64, 256>;
              D.22980 = D.22979 & 4096;
              if (D.22980 != 0) goto <D.22981>; else goto <D.22977>;
              <D.22981>:
              D.22982 = MEM[(struct MonoMethodInflated *)m].context.method_inst;
              if (D.22982 != 0B) goto <D.22983>; else goto <D.22977>;
              <D.22983>:
              generic_virtual = m;
              need_rgctx_tramp = 1;
              goto <D.22978>;
              <D.22977>:
              variance_used.8 = variance_used;
              if (variance_used.8 != 0) goto <D.22985>; else goto <D.22986>;
              <D.22985>:
              D.22987 = m->klass;
              D.22988 = mono_class_has_variant_generic_params (D.22987);
              if (D.22988 != 0) goto <D.22989>; else goto <D.22990>;
              <D.22989>:
              variant_iface = m;
              <D.22990>:
              <D.22986>:
              <D.22978>:
              addr = 0B;
              D.22991 = generic_virtual == 0B;
              D.22992 = variant_iface == 0B;
              D.22993 = D.22991 & D.22992;
              lookup_aot = (gboolean) D.22993;
              vtable_slot = mono_convert_imt_slot_to_vtable_slot (vtable_slot, regs, code, m, lookup_aot, &impl_method, &need_rgctx_tramp, &variance_used, &addr);
              vtable_slot_to_patch = vtable_slot;
              addr.9 = addr;
              if (addr.9 != 0B) goto <D.22995>; else goto <D.22996>;
              <D.22995>:
              D.22997 = mono_domain_get ();
              D.22998 = mono_domain_owns_vtable_slot (D.22997, vtable_slot);
              if (D.22998 != 0) goto <D.22999>; else goto <D.23000>;
              <D.22999>:
              addr.9 = addr;
              *vtable_slot = addr.9;
              <D.23000>:
              D.23002 = mono_domain_get ();
              addr.9 = addr;
              D.23001 = mono_create_ftnptr (D.23002, addr.9);
              return D.23001;
              <D.22996>:
              m = impl_method;
            }
            <D.22976>:
          }
        finally
          {
            impl_method = {CLOBBER};
          }
      }
      <D.22965>:
      <D.22963>:
      if (virtual != 0) goto <D.23005>; else goto <D.23003>;
      <D.23005>:
      D.23006 = is_generic_method_definition (m);
      if (D.23006 != 0) goto <D.23007>; else goto <D.23003>;
      <D.23007>:
      {
        struct MonoGenericContext context;
        struct MonoMethod * declaring;

        try
          {
            context.class_inst = 0B;
            context.method_inst = 0B;
            D.22979 = BIT_FIELD_REF <*m, 64, 256>;
            D.22980 = D.22979 & 4096;
            if (D.22980 != 0) goto <D.23008>; else goto <D.23009>;
            <D.23008>:
            declaring = mono_method_get_declaring_generic_method (m);
            goto <D.23010>;
            <D.23009>:
            declaring = m;
            <D.23010>:
            D.22987 = m->klass;
            D.23011 = D.22987->generic_class;
            if (D.23011 != 0B) goto <D.23012>; else goto <D.23013>;
            <D.23012>:
            D.22987 = m->klass;
            D.23011 = D.22987->generic_class;
            D.23014 = D.23011->context.class_inst;
            context.class_inst = D.23014;
            goto <D.23015>;
            <D.23013>:
            D.22987 = m->klass;
            D.23016 = D.22987->generic_container;
            D.23017 = D.23016 != 0B;
            D.23018 = (long int) D.23017;
            D.23019 = __builtin_expect (D.23018, 0);
            if (D.23019 != 0) goto <D.23020>; else goto <D.23021>;
            <D.23020>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 464, "!m->klass->generic_container");
            <D.23021>:
            <D.23015>:
            generic_virtual = mono_arch_find_imt_method (regs, code);
            if (generic_virtual != 0B) goto <D.23022>; else goto <D.23023>;
            <D.23022>:
            D.23024 = BIT_FIELD_REF <*generic_virtual, 64, 256>;
            D.23025 = D.23024 & 4096;
            D.23026 = D.23025 == 0;
            D.23027 = (long int) D.23026;
            D.23028 = __builtin_expect (D.23027, 0);
            if (D.23028 != 0) goto <D.23029>; else goto <D.23030>;
            <D.23029>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 470, "generic_virtual->is_inflated");
            <D.23030>:
            D.23031 = MEM[(struct MonoMethodInflated *)generic_virtual].context.method_inst;
            context.method_inst = D.23031;
            <D.23023>:
            m = mono_class_inflate_generic_method (declaring, &context);
            need_rgctx_tramp = 1;
          }
        finally
          {
            context = {CLOBBER};
          }
      }
      goto <D.23004>;
      <D.23003>:
      context_used = mono_method_check_context_used (m);
      if (context_used != 0) goto <D.23032>; else goto <D.23033>;
      <D.23032>:
      {
        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.23034 = code == 0B;
        D.23035 = (long int) D.23034;
        D.23036 = __builtin_expect (D.23035, 0);
        if (D.23036 != 0) goto <D.23037>; else goto <D.23038>;
        <D.23037>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 486, "code");
        <D.23038>:
        D.22979 = BIT_FIELD_REF <*m, 64, 256>;
        D.22980 = D.22979 & 4096;
        if (D.22980 != 0) goto <D.23041>; else goto <D.23039>;
        <D.23041>:
        D.23042 = mono_method_get_context (m);
        D.23043 = D.23042->method_inst;
        if (D.23043 != 0B) goto <D.23044>; else goto <D.23039>;
        <D.23044>:
        {
          struct MonoMethodRuntimeGenericContext * mrgctx;

          mrgctx = mono_arch_find_static_call_vtable (regs, code);
          D.23045 = mrgctx->class_vtable;
          klass = D.23045->klass;
          method_inst = mrgctx->method_inst;
        }
        goto <D.23040>;
        <D.23039>:
        D.23049 = m->flags;
        D.23050 = (int) D.23049;
        D.23051 = D.23050 & 16;
        if (D.23051 != 0) goto <D.23046>; else goto <D.23052>;
        <D.23052>:
        D.22987 = m->klass;
        D.23053 = BIT_FIELD_REF <*D.22987, 64, 256>;
        D.23054 = D.23053 & 8;
        if (D.23054 != 0) goto <D.23046>; else goto <D.23047>;
        <D.23046>:
        {
          struct MonoVTable * vtable;

          vtable = mono_arch_find_static_call_vtable (regs, code);
          klass = vtable->klass;
        }
        goto <D.23048>;
        <D.23047>:
        {
          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.23055 = this_argument->vtable;
          D.23056 = D.23055->klass;
          D.23057 = BIT_FIELD_REF <*D.23056, 64, 256>;
          D.23058 = D.23057 & 1;
          D.23059 = D.23058 == 0;
          D.23060 = (long int) D.23059;
          D.23061 = __builtin_expect (D.23060, 0);
          if (D.23061 != 0) goto <D.23062>; else goto <D.23063>;
          <D.23062>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 512, "this_argument->vtable->klass->inited");
          <D.23063>:
          if (vtable_slot == 0B) goto <D.23064>; else goto <D.23065>;
          <D.23064>:
          D.23055 = this_argument->vtable;
          D.23056 = D.23055->klass;
          mono_class_setup_supertypes (D.23056);
          D.23055 = this_argument->vtable;
          D.23056 = D.23055->klass;
          D.23066 = D.23056->supertypes;
          D.22987 = m->klass;
          D.23067 = D.22987->idepth;
          D.23068 = (long unsigned int) D.23067;
          D.23069 = D.23068 * 8;
          D.23070 = D.23069 + 18446744073709551608;
          D.23071 = D.23066 + D.23070;
          klass = *D.23071;
          <D.23065>:
        }
        <D.23048>:
        <D.23040>:
        if (vtable_slot == 0B) goto <D.23075>; else goto <D.23073>;
        <D.23075>:
        if (klass == 0B) goto <D.23076>; else goto <D.23073>;
        <D.23076>:
        iftmp.10 = 1;
        goto <D.23074>;
        <D.23073>:
        iftmp.10 = 0;
        <D.23074>:
        D.23077 = iftmp.10 != 0;
        D.23078 = (long int) D.23077;
        D.23079 = __builtin_expect (D.23078, 0);
        if (D.23079 != 0) goto <D.23080>; else goto <D.23081>;
        <D.23080>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 524, "vtable_slot || klass");
        <D.23081>:
        if (vtable_slot != 0B) goto <D.23082>; else goto <D.23083>;
        <D.23082>:
        {
          int displacement;

          vtable_slot.11 = (long int) vtable_slot;
          vt.12 = (long int) vt;
          D.23086 = vtable_slot.11 - vt.12;
          D.23087 = D.23086 /[ex] 8;
          displacement = (int) D.23087;
          monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-trampolines.c", 529);
          D.23088 = displacement <= 0;
          D.23089 = (long int) D.23088;
          D.23090 = __builtin_expect (D.23089, 0);
          if (D.23090 != 0) goto <D.23091>; else goto <D.23092>;
          <D.23091>:
          monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 531, "displacement > 0");
          <D.23092>:
          D.23093 = vt->klass;
          D.23094 = D.23093->vtable;
          D.23095 = (long unsigned int) displacement;
          D.23096 = D.23095 * 8;
          D.23097 = D.23094 + D.23096;
          actual_method = *D.23097;
        }
        <D.23083>:
        if (method_inst != 0B) goto <D.23098>; else goto <D.23101>;
        <D.23101>:
        D.22979 = BIT_FIELD_REF <*m, 64, 256>;
        D.23102 = D.22979 & 124;
        if (D.23102 != 0) goto <D.23098>; else goto <D.23099>;
        <D.23098>:
        {
          struct MonoGenericContext context;

          try
            {
              context.class_inst = 0B;
              context.method_inst = 0B;
              D.22979 = BIT_FIELD_REF <*m, 64, 256>;
              D.22980 = D.22979 & 4096;
              if (D.22980 != 0) goto <D.23103>; else goto <D.23104>;
              <D.23103>:
              declaring = mono_method_get_declaring_generic_method (m);
              goto <D.23105>;
              <D.23104>:
              declaring = m;
              <D.23105>:
              D.23106 = klass->generic_class;
              if (D.23106 != 0B) goto <D.23107>; else goto <D.23108>;
              <D.23107>:
              D.23106 = klass->generic_class;
              D.23109 = D.23106->context.class_inst;
              context.class_inst = D.23109;
              goto <D.23110>;
              <D.23108>:
              D.23111 = klass->generic_container;
              if (D.23111 != 0B) goto <D.23112>; else goto <D.23113>;
              <D.23112>:
              D.23111 = klass->generic_container;
              D.23114 = D.23111->context.class_inst;
              context.class_inst = D.23114;
              <D.23113>:
              <D.23110>:
              context.method_inst = method_inst;
              actual_method = mono_class_inflate_generic_method (declaring, &context);
            }
          finally
            {
              context = {CLOBBER};
            }
        }
        goto <D.23100>;
        <D.23099>:
        actual_method = mono_class_get_method_generic (klass, m);
        <D.23100>:
        D.23115 = klass == 0B;
        D.23116 = (long int) D.23115;
        D.23117 = __builtin_expect (D.23116, 0);
        if (D.23117 != 0) goto <D.23118>; else goto <D.23119>;
        <D.23118>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 555, "klass");
        <D.23119>:
        D.23120 = actual_method == 0B;
        D.23121 = (long int) D.23120;
        D.23122 = __builtin_expect (D.23121, 0);
        if (D.23122 != 0) goto <D.23123>; else goto <D.23124>;
        <D.23123>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 556, "actual_method");
        <D.23124>:
        D.23125 = actual_method->klass;
        D.23126 = D.23125 != klass;
        D.23127 = (long int) D.23126;
        D.23128 = __builtin_expect (D.23127, 0);
        if (D.23128 != 0) goto <D.23129>; else goto <D.23130>;
        <D.23129>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 557, "actual_method->klass == klass");
        <D.23130>:
        D.23131 = BIT_FIELD_REF <*actual_method, 64, 256>;
        D.23132 = D.23131 & 4096;
        if (D.23132 != 0) goto <D.23133>; else goto <D.23134>;
        <D.23133>:
        declaring = mono_method_get_declaring_generic_method (actual_method);
        goto <D.23135>;
        <D.23134>:
        declaring = 0B;
        <D.23135>:
        m = actual_method;
      }
      <D.23033>:
      <D.23004>:
      D.23136 = m->iflags;
      D.23137 = (int) D.23136;
      D.23138 = D.23137 & 32;
      if (D.23138 != 0) goto <D.23139>; else goto <D.23140>;
      <D.23139>:
      m = mono_marshal_get_synchronized_wrapper (m);
      need_rgctx_tramp = 0;
      <D.23140>:
      if (code == 0B) goto <D.23141>; else goto <D.23142>;
      <D.23141>:
      D.23143 = mono_method_needs_static_rgctx_invoke (m, 0);
      if (D.23143 != 0) goto <D.23144>; else goto <D.23145>;
      <D.23144>:
      need_rgctx_tramp = 1;
      <D.23145>:
      <D.23142>:
      compiled_method = mono_compile_method (m);
      addr = compiled_method;
      addr.9 = addr;
      D.23146 = addr.9 == 0B;
      D.23147 = (long int) D.23146;
      D.23148 = __builtin_expect (D.23147, 0);
      if (D.23148 != 0) goto <D.23149>; else goto <D.23150>;
      <D.23149>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 577, "addr");
      <D.23150>:
      if (generic_virtual != 0B) goto <D.23151>; else goto <D.23154>;
      <D.23154>:
      if (variant_iface != 0B) goto <D.23151>; else goto <D.23152>;
      <D.23151>:
      D.23155 = vt->klass;
      D.23156 = BIT_FIELD_REF <*D.23155, 64, 256>;
      D.23157 = D.23156 & 8;
      if (D.23157 != 0) goto <D.23158>; else goto <D.23159>;
      <D.23158>:
      need_unbox_tramp = 1;
      <D.23159>:
      goto <D.23153>;
      <D.23152>:
      if (orig_vtable_slot != 0B) goto <D.23160>; else goto <D.23161>;
      <D.23160>:
      D.22987 = m->klass;
      D.23053 = BIT_FIELD_REF <*D.22987, 64, 256>;
      D.23054 = D.23053 & 8;
      if (D.23054 != 0) goto <D.23162>; else goto <D.23163>;
      <D.23162>:
      need_unbox_tramp = 1;
      <D.23163>:
      <D.23161>:
      <D.23153>:
      need_rgctx_tramp.13 = need_rgctx_tramp;
      addr.14 = mini_add_method_trampoline (orig_method, m, compiled_method, need_rgctx_tramp.13, need_unbox_tramp);
      addr = addr.14;
      if (generic_virtual != 0B) goto <D.23166>; else goto <D.23168>;
      <D.23168>:
      if (variant_iface != 0B) goto <D.23166>; else goto <D.23167>;
      <D.23166>:
      {
        struct MonoMethod * target;

        if (generic_virtual != 0B) goto <D.23170>; else goto <D.23171>;
        <D.23170>:
        iftmp.15 = generic_virtual;
        goto <D.23172>;
        <D.23171>:
        iftmp.15 = variant_iface;
        <D.23172>:
        target = iftmp.15;
        vtable_slot = orig_vtable_slot;
        D.22966 = vtable_slot == 0B;
        D.22967 = (long int) D.22966;
        D.22968 = __builtin_expect (D.22967, 0);
        if (D.22968 != 0) goto <D.23173>; else goto <D.23174>;
        <D.23173>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 593, "vtable_slot");
        <D.23174>:
        D.23175 = mono_domain_get ();
        addr.9 = addr;
        mono_method_add_generic_virtual_invocation (D.23175, vt, vtable_slot, target, addr.9);
        D.23001 = addr;
        return D.23001;
      }
      <D.23167>:
      if (code == 0B) goto <D.23176>; else goto <D.23177>;
      <D.23176>:
      {
        struct MonoDomain * domain;

        domain = mono_domain_get ();
        D.23178 = domain->runtime_info;
        D.23179 = MEM[(struct MonoJitDomainInfo *)D.23178].jump_target_got_slot_hash;
        if (D.23179 != 0B) goto <D.23180>; else goto <D.23181>;
        <D.23180>:
        {
          struct GSList * list;
          struct GSList * tmp;

          {
            int ret;

            D.23182 = &domain->lock.mutex;
            ret = pthread_mutex_lock (D.23182);
            if (ret != 0) goto <D.23183>; else goto <D.23184>;
            <D.23183>:
            monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
            <D.23184>:
            D.23185 = ret != 0;
            D.23186 = (long int) D.23185;
            D.23187 = __builtin_expect (D.23186, 0);
            if (D.23187 != 0) goto <D.23188>; else goto <D.23189>;
            <D.23188>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 614, "ret == 0");
            <D.23189>:
          }
          D.23178 = domain->runtime_info;
          D.23179 = MEM[(struct MonoJitDomainInfo *)D.23178].jump_target_got_slot_hash;
          list = monoeg_g_hash_table_lookup (D.23179, m);
          if (list != 0B) goto <D.23190>; else goto <D.23191>;
          <D.23190>:
          tmp = list;
          goto <D.22559>;
          <D.22558>:
          {
            void * * got_slot;

            got_slot = tmp->data;
            addr.9 = addr;
            *got_slot = addr.9;
          }
          tmp = tmp->next;
          <D.22559>:
          if (tmp != 0B) goto <D.22558>; else goto <D.22560>;
          <D.22560>:
          D.23178 = domain->runtime_info;
          D.23179 = MEM[(struct MonoJitDomainInfo *)D.23178].jump_target_got_slot_hash;
          monoeg_g_hash_table_remove (D.23179, m);
          monoeg_g_slist_free (list);
          <D.23191>:
          {
            int ret;

            D.23182 = &domain->lock.mutex;
            ret = pthread_mutex_unlock (D.23182);
            if (ret != 0) goto <D.23192>; else goto <D.23193>;
            <D.23192>:
            monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
            <D.23193>:
            D.23194 = ret != 0;
            D.23195 = (long int) D.23194;
            D.23196 = __builtin_expect (D.23195, 0);
            if (D.23196 != 0) goto <D.23197>; else goto <D.23198>;
            <D.23197>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 624, "ret == 0");
            <D.23198>:
          }
        }
        <D.23181>:
        D.23001 = addr;
        return D.23001;
      }
      <D.23177>:
      vtable_slot = orig_vtable_slot;
      if (vtable_slot != 0B) goto <D.23199>; else goto <D.23200>;
      <D.23199>:
      if (vtable_slot_to_patch != 0B) goto <D.23203>; else goto <D.23204>;
      <D.23203>:
      D.23205 = mono_aot_is_got_entry (code, vtable_slot_to_patch);
      if (D.23205 != 0) goto <D.23201>; else goto <D.23206>;
      <D.23206>:
      D.23207 = mono_domain_get ();
      D.23208 = mono_domain_owns_vtable_slot (D.23207, vtable_slot_to_patch);
      if (D.23208 != 0) goto <D.23201>; else goto <D.23202>;
      <D.23201>:
      D.23209 = *vtable_slot_to_patch;
      D.23210 = D.23209 == 0B;
      D.23211 = (long int) D.23210;
      D.23212 = __builtin_expect (D.23211, 0);
      if (D.23212 != 0) goto <D.23213>; else goto <D.23214>;
      <D.23213>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 634, "*vtable_slot_to_patch");
      <D.23214>:
      addr.9 = addr;
      D.23215 = mono_get_addr_from_ftnptr (addr.9);
      *vtable_slot_to_patch = D.23215;
      <D.23202>:
      <D.23204>:
      goto <D.23216>;
      <D.23200>:
      {
        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.23217>; else goto <D.23218>;
        <D.23217>:
        if (generic_shared != 0) goto <D.23219>; else goto <D.23220>;
        <D.23219>:
        D.23221 = mono_domain_get ();
        D.23222 = mono_get_addr_from_ftnptr (compiled_method);
        target_ji = mini_jit_info_table_find (D.23221, D.23222, 0B);
        if (ji == 0B) goto <D.23223>; else goto <D.23224>;
        <D.23223>:
        D.23225 = mono_domain_get ();
        ji = mini_jit_info_table_find (D.23225, code, 0B);
        <D.23224>:
        if (ji != 0B) goto <D.23226>; else goto <D.23227>;
        <D.23226>:
        if (target_ji != 0B) goto <D.23228>; else goto <D.23229>;
        <D.23228>:
        if (generic_shared != 0) goto <D.23230>; else goto <D.23231>;
        <D.23230>:
        D.23232 = BIT_FIELD_REF <*ji, 64, 256>;
        D.23233 = D.23232 & 131072;
        if (D.23233 != 0) goto <D.23234>; else goto <D.23235>;
        <D.23234>:
        D.23236 = BIT_FIELD_REF <*target_ji, 64, 256>;
        D.23237 = D.23236 & 131072;
        if (D.23237 == 0) goto <D.23238>; else goto <D.23239>;
        <D.23238>:
        no_patch = 1;
        <D.23239>:
        <D.23235>:
        <D.23231>:
        <D.23229>:
        <D.23227>:
        <D.23220>:
        if (no_patch == 0) goto <D.23240>; else goto <D.23241>;
        <D.23240>:
        addr.9 = addr;
        mono_aot_patch_plt_entry (plt_entry, 0B, regs, addr.9);
        <D.23241>:
        goto <D.23242>;
        <D.23218>:
        if (generic_shared != 0) goto <D.23243>; else goto <D.23244>;
        <D.23243>:
        D.22979 = BIT_FIELD_REF <*m, 64, 256>;
        D.23102 = D.22979 & 124;
        if (D.23102 != 0) goto <D.23245>; else goto <D.23246>;
        <D.23245>:
        m = mono_marshal_method_from_wrapper (m);
        <D.23246>:
        <D.23244>:
        D.23247 = mono_domain_get ();
        D.23248 = mono_get_addr_from_ftnptr (compiled_method);
        target_ji = mini_jit_info_table_find (D.23247, D.23248, 0B);
        if (ji == 0B) goto <D.23249>; else goto <D.23250>;
        <D.23249>:
        D.23251 = mono_domain_get ();
        ji = mini_jit_info_table_find (D.23251, code, 0B);
        <D.23250>:
        if (ji != 0B) goto <D.23252>; else goto <D.23253>;
        <D.23252>:
        if (target_ji != 0B) goto <D.23254>; else goto <D.23255>;
        <D.23254>:
        if (generic_shared != 0) goto <D.23256>; else goto <D.23257>;
        <D.23256>:
        D.23232 = BIT_FIELD_REF <*ji, 64, 256>;
        D.23233 = D.23232 & 131072;
        if (D.23233 != 0) goto <D.23258>; else goto <D.23259>;
        <D.23258>:
        D.23236 = BIT_FIELD_REF <*target_ji, 64, 256>;
        D.23237 = D.23236 & 131072;
        if (D.23237 == 0) goto <D.23260>; else goto <D.23261>;
        <D.23260>:
        no_patch = 1;
        <D.23261>:
        <D.23259>:
        <D.23257>:
        <D.23255>:
        <D.23253>:
        if (no_patch == 0) goto <D.23262>; else goto <D.23263>;
        <D.23262>:
        D.23264 = mono_method_same_domain (ji, target_ji);
        if (D.23264 != 0) goto <D.23265>; else goto <D.23266>;
        <D.23265>:
        D.23267 = ji->code_start;
        addr.9 = addr;
        mono_arch_patch_callsite (D.23267, code, addr.9);
        <D.23266>:
        <D.23263>:
        <D.23242>:
      }
      <D.23216>:
      D.23001 = addr;
      return D.23001;
    }
  finally
    {
      addr = {CLOBBER};
      variance_used = {CLOBBER};
    }
}


mono_convert_imt_slot_to_vtable_slot (void * * slot, mgreg_t * regs, guint8 * code, struct MonoMethod * method, gboolean lookup_aot, struct MonoMethod * * impl_method, gboolean * need_rgctx_tramp, gboolean * variance_used, void * * aot_addr)
{
  long int slot.16;
  long int vt.17;
  long int D.23274;
  long int D.23275;
  void * * D.23278;
  struct MonoClass * D.23279;
  struct MonoClass * D.23280;
  struct MonoType * D.23283;
  char * D.23284;
  struct MonoType * D.23285;
  char * D.23286;
  unsigned int D.23287;
  int D.23288;
  long unsigned int D.23291;
  long unsigned int D.23292;
  struct MonoGenericInst * D.23294;
  struct MonoMethod * D.23296;
  short int D.23297;
  int D.23298;
  int D.23299;
  struct MonoClass * D.23300;
  struct MonoGenericClass * D.23301;
  struct MonoGenericInst * D.23304;
  long unsigned int D.23308;
  long unsigned int D.23309;
  struct MonoDomain * D.23311;
  int D.23312;
  int D.23313;
  void * D.23314;
  void * D.23315;
  int D.23319;
  int D.23320;
  int D.23323;
  long unsigned int D.23328;
  long unsigned int D.23329;
  <unnamed type> D.23334;
  _Bool D.23337;
  long int D.23338;
  long int D.23339;
  unsigned int D.23342;
  int D.23343;
  unsigned int D.23344;
  unsigned int D.23345;
  _Bool D.23348;
  long int D.23349;
  long int D.23350;
  struct MonoObject * this_argument;
  struct MonoVTable * vt;
  int displacement;

  this_argument = mono_arch_get_this_arg_from_call (regs, code);
  vt = this_argument->vtable;
  slot.16 = (long int) slot;
  vt.17 = (long int) vt;
  D.23274 = slot.16 - vt.17;
  D.23275 = D.23274 /[ex] 8;
  displacement = (int) D.23275;
  if (displacement > 0) goto <D.23276>; else goto <D.23277>;
  <D.23276>:
  D.23278 = slot;
  return D.23278;
  <D.23277>:
  {
    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.23279 = vt->klass;
    D.23280 = imt_method->klass;
    interface_offset = mono_class_interface_offset_with_variance (D.23279, D.23280, variance_used);
    if (interface_offset < 0) goto <D.23281>; else goto <D.23282>;
    <D.23281>:
    D.23279 = vt->klass;
    D.23283 = &D.23279->byval_arg;
    D.23284 = mono_type_get_name_full (D.23283, 0);
    D.23280 = imt_method->klass;
    D.23285 = &D.23280->byval_arg;
    D.23286 = mono_type_get_name_full (D.23285, 0);
    monoeg_g_log (0B, 4, "%s doesn\'t implement interface %s\n", D.23284, D.23286);
    <D.22485>:
    goto <D.22485>;
    <D.23282>:
    D.23287 = mono_method_get_imt_slot (imt_method);
    D.23288 = (int) D.23287;
    mono_vtable_build_imt_slot (vt, D.23288);
    D.23291 = BIT_FIELD_REF <*imt_method, 64, 256>;
    D.23292 = D.23291 & 4096;
    if (D.23292 != 0) goto <D.23293>; else goto <D.23289>;
    <D.23293>:
    D.23294 = MEM[(struct MonoMethodInflated *)imt_method].context.method_inst;
    if (D.23294 != 0B) goto <D.23295>; else goto <D.23289>;
    <D.23295>:
    {
      struct MonoGenericContext context;

      try
        {
          context.class_inst = 0B;
          context.method_inst = 0B;
          D.23279 = vt->klass;
          D.23296 = mono_method_get_declaring_generic_method (imt_method);
          D.23297 = D.23296->slot;
          D.23298 = (int) D.23297;
          D.23299 = D.23298 + interface_offset;
          impl = mono_class_get_vtable_entry (D.23279, D.23299);
          D.23300 = impl->klass;
          D.23301 = D.23300->generic_class;
          if (D.23301 != 0B) goto <D.23302>; else goto <D.23303>;
          <D.23302>:
          D.23300 = impl->klass;
          D.23301 = D.23300->generic_class;
          D.23304 = D.23301->context.class_inst;
          context.class_inst = D.23304;
          <D.23303>:
          D.23294 = MEM[(struct MonoMethodInflated *)imt_method].context.method_inst;
          context.method_inst = D.23294;
          impl = mono_class_inflate_generic_method (impl, &context);
        }
      finally
        {
          context = {CLOBBER};
        }
    }
    goto <D.23290>;
    <D.23289>:
    if (lookup_aot != 0) goto <D.23307>; else goto <D.23305>;
    <D.23307>:
    D.23279 = vt->klass;
    D.23308 = BIT_FIELD_REF <*D.23279, 64, 256>;
    D.23309 = D.23308 & 8;
    if (D.23309 == 0) goto <D.23310>; else goto <D.23305>;
    <D.23310>:
    D.23311 = mono_domain_get ();
    D.23312 = mono_method_get_vtable_slot (imt_method);
    D.23313 = D.23312 + interface_offset;
    D.23314 = mono_aot_get_method_from_vt_slot (D.23311, vt, D.23313);
    *aot_addr = D.23314;
    goto <D.23306>;
    <D.23305>:
    *aot_addr = 0B;
    <D.23306>:
    D.23315 = *aot_addr;
    if (D.23315 != 0B) goto <D.23316>; else goto <D.23317>;
    <D.23316>:
    impl = 0B;
    goto <D.23318>;
    <D.23317>:
    D.23279 = vt->klass;
    D.23319 = mono_method_get_vtable_slot (imt_method);
    D.23320 = D.23319 + interface_offset;
    impl = mono_class_get_vtable_entry (D.23279, D.23320);
    <D.23318>:
    <D.23290>:
    if (impl != 0B) goto <D.23321>; else goto <D.23322>;
    <D.23321>:
    D.23323 = mono_method_needs_static_rgctx_invoke (impl, 0);
    if (D.23323 != 0) goto <D.23324>; else goto <D.23325>;
    <D.23324>:
    *need_rgctx_tramp = 1;
    <D.23325>:
    <D.23322>:
    if (impl != 0B) goto <D.23326>; else goto <D.23327>;
    <D.23326>:
    D.23328 = BIT_FIELD_REF <*impl, 64, 256>;
    D.23329 = D.23328 & 124;
    if (D.23329 == 28) goto <D.23330>; else goto <D.23331>;
    <D.23330>:
    {
      struct WrapperInfo * info;

      info = mono_marshal_get_wrapper_info (impl);
      if (info != 0B) goto <D.23332>; else goto <D.23333>;
      <D.23332>:
      D.23334 = info->subtype;
      if (D.23334 == 21) goto <D.23335>; else goto <D.23336>;
      <D.23335>:
      *need_rgctx_tramp = 1;
      <D.23336>:
      <D.23333>:
    }
    <D.23331>:
    <D.23327>:
    *impl_method = impl;
    D.23337 = imt_slot > 18;
    D.23338 = (long int) D.23337;
    D.23339 = __builtin_expect (D.23338, 0);
    if (D.23339 != 0) goto <D.23340>; else goto <D.23341>;
    <D.23340>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 223, "imt_slot < MONO_IMT_SIZE");
    <D.23341>:
    D.23342 = vt->imt_collisions_bitmap;
    D.23343 = 1 << imt_slot;
    D.23344 = (unsigned int) D.23343;
    D.23345 = D.23342 & D.23344;
    if (D.23345 != 0) goto <D.23346>; else goto <D.23347>;
    <D.23346>:
    {
      int slot;
      int vtable_offset;
      void * * vtable_slot;

      slot = mono_method_get_vtable_index (imt_method);
      D.23348 = slot == -1;
      D.23349 = (long int) D.23348;
      D.23350 = __builtin_expect (D.23349, 0);
      if (D.23350 != 0) goto <D.23351>; else goto <D.23352>;
      <D.23351>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 229, "slot != -1");
      <D.23352>:
      vtable_offset = interface_offset + slot;
      vtable_slot = &vt->vtable[vtable_offset];
      D.23278 = vtable_slot;
      return D.23278;
    }
    <D.23347>:
    D.23278 = slot;
    return D.23278;
  }
}


is_generic_method_definition (struct MonoMethod * m)
{
  long unsigned int D.23354;
  long unsigned int D.23355;
  gboolean D.23358;
  long unsigned int D.23359;
  struct MonoGenericInst * D.23362;
  struct MonoMethod * D.23365;
  struct MonoGenericContainer * D.23366;
  struct MonoGenericInst * D.23367;
  struct MonoGenericContext * context;

  D.23354 = BIT_FIELD_REF <*m, 64, 256>;
  D.23355 = D.23354 & 2048;
  if (D.23355 != 0) goto <D.23356>; else goto <D.23357>;
  <D.23356>:
  D.23358 = 1;
  return D.23358;
  <D.23357>:
  D.23354 = BIT_FIELD_REF <*m, 64, 256>;
  D.23359 = D.23354 & 4096;
  if (D.23359 == 0) goto <D.23360>; else goto <D.23361>;
  <D.23360>:
  D.23358 = 0;
  return D.23358;
  <D.23361>:
  context = mono_method_get_context (m);
  D.23362 = context->method_inst;
  if (D.23362 == 0B) goto <D.23363>; else goto <D.23364>;
  <D.23363>:
  D.23358 = 0;
  return D.23358;
  <D.23364>:
  D.23362 = context->method_inst;
  D.23365 = MEM[(struct MonoMethodInflated *)m].declaring;
  D.23366 = mono_method_get_generic_container (D.23365);
  D.23367 = D.23366->context.method_inst;
  if (D.23362 == D.23367) goto <D.23368>; else goto <D.23369>;
  <D.23368>:
  D.23358 = 1;
  return D.23358;
  <D.23369>:
  D.23358 = 0;
  return D.23358;
}


mono_generic_virtual_remoting_trampoline (mgreg_t * regs, guint8 * code, struct MonoMethod * m, guint8 * tramp)
{
  unsigned int trampoline_calls.18;
  unsigned int trampoline_calls.19;
  long unsigned int D.23373;
  long unsigned int D.23374;
  _Bool D.23375;
  long int D.23376;
  long int D.23377;
  long unsigned int D.23380;
  struct MonoClass * D.23384;
  struct MonoGenericClass * D.23385;
  struct MonoGenericInst * D.23388;
  struct MonoGenericContainer * D.23390;
  _Bool D.23391;
  long int D.23392;
  long int D.23393;
  long unsigned int D.23396;
  long unsigned int D.23397;
  struct MonoGenericInst * D.23400;
  _Bool D.23401;
  long int D.23402;
  long int D.23403;
  void * D.23406;
  struct MonoGenericContext context;
  struct MonoMethod * imt_method;
  struct MonoMethod * declaring;
  void * addr;

  try
    {
      context.class_inst = 0B;
      context.method_inst = 0B;
      trampoline_calls.18 = trampoline_calls;
      trampoline_calls.19 = trampoline_calls.18 + 1;
      trampoline_calls = trampoline_calls.19;
      D.23373 = BIT_FIELD_REF <*m, 64, 256>;
      D.23374 = D.23373 & 2048;
      D.23375 = D.23374 == 0;
      D.23376 = (long int) D.23375;
      D.23377 = __builtin_expect (D.23376, 0);
      if (D.23377 != 0) goto <D.23378>; else goto <D.23379>;
      <D.23378>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 786, "m->is_generic");
      <D.23379>:
      D.23373 = BIT_FIELD_REF <*m, 64, 256>;
      D.23380 = D.23373 & 4096;
      if (D.23380 != 0) goto <D.23381>; else goto <D.23382>;
      <D.23381>:
      declaring = mono_method_get_declaring_generic_method (m);
      goto <D.23383>;
      <D.23382>:
      declaring = m;
      <D.23383>:
      D.23384 = m->klass;
      D.23385 = D.23384->generic_class;
      if (D.23385 != 0B) goto <D.23386>; else goto <D.23387>;
      <D.23386>:
      D.23384 = m->klass;
      D.23385 = D.23384->generic_class;
      D.23388 = D.23385->context.class_inst;
      context.class_inst = D.23388;
      goto <D.23389>;
      <D.23387>:
      D.23384 = m->klass;
      D.23390 = D.23384->generic_container;
      D.23391 = D.23390 != 0B;
      D.23392 = (long int) D.23391;
      D.23393 = __builtin_expect (D.23392, 0);
      if (D.23393 != 0) goto <D.23394>; else goto <D.23395>;
      <D.23394>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 796, "!m->klass->generic_container");
      <D.23395>:
      <D.23389>:
      imt_method = mono_arch_find_imt_method (regs, code);
      D.23396 = BIT_FIELD_REF <*imt_method, 64, 256>;
      D.23397 = D.23396 & 4096;
      if (D.23397 != 0) goto <D.23398>; else goto <D.23399>;
      <D.23398>:
      D.23400 = MEM[(struct MonoMethodInflated *)imt_method].context.method_inst;
      context.method_inst = D.23400;
      <D.23399>:
      m = mono_class_inflate_generic_method (declaring, &context);
      m = mono_marshal_get_remoting_invoke_with_check (m);
      addr = mono_compile_method (m);
      D.23401 = addr == 0B;
      D.23402 = (long int) D.23401;
      D.23403 = __builtin_expect (D.23402, 0);
      if (D.23403 != 0) goto <D.23404>; else goto <D.23405>;
      <D.23404>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 807, "addr");
      <D.23405>:
      D.23406 = addr;
      return D.23406;
    }
  finally
    {
      context = {CLOBBER};
    }
}


mono_aot_trampoline (mgreg_t * regs, guint8 * code, guint8 * token_info, guint8 * tramp)
{
  unsigned int trampoline_calls.20;
  unsigned int trampoline_calls.21;
  struct MonoDomain * D.23411;
  _Bool D.23414;
  long int D.23415;
  long int D.23416;
  void * D.23419;
  struct MonoDomain * D.23420;
  _Bool D.23421;
  long int D.23422;
  long int D.23423;
  struct MonoImage * image;
  guint32 token;
  struct MonoMethod * method;
  void * addr;
  guint8 * plt_entry;

  method = 0B;
  trampoline_calls.20 = trampoline_calls;
  trampoline_calls.21 = trampoline_calls.20 + 1;
  trampoline_calls = trampoline_calls.21;
  image = MEM[(void * *)token_info];
  token_info = token_info + 8;
  token = MEM[(guint32 *)token_info];
  D.23411 = mono_domain_get ();
  addr = mono_aot_get_method_from_token (D.23411, image, token);
  if (addr == 0B) goto <D.23412>; else goto <D.23413>;
  <D.23412>:
  method = mono_get_method (image, token, 0B);
  D.23414 = method == 0B;
  D.23415 = (long int) D.23414;
  D.23416 = __builtin_expect (D.23415, 0);
  if (D.23416 != 0) goto <D.23417>; else goto <D.23418>;
  <D.23417>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 839, "method");
  <D.23418>:
  D.23419 = mono_magic_trampoline (regs, code, method, tramp);
  return D.23419;
  <D.23413>:
  D.23420 = mono_domain_get ();
  addr = mono_create_ftnptr (D.23420, addr);
  plt_entry = mono_aot_get_plt_entry (code);
  D.23421 = plt_entry == 0B;
  D.23422 = (long int) D.23421;
  D.23423 = __builtin_expect (D.23422, 0);
  if (D.23423 != 0) goto <D.23424>; else goto <D.23425>;
  <D.23424>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 849, "plt_entry");
  <D.23425>:
  mono_aot_patch_plt_entry (plt_entry, 0B, regs, addr);
  D.23419 = addr;
  return D.23419;
}


mono_aot_plt_trampoline (mgreg_t * regs, guint8 * code, guint8 * aot_module, guint8 * tramp)
{
  unsigned int trampoline_calls.22;
  unsigned int trampoline_calls.23;
  struct MonoLoaderError * D.23431;
  struct MonoLoaderError * D.23434;
  struct MonoException * D.23435;
  _Bool D.23436;
  long int D.23437;
  long int D.23438;
  void * D.23441;
  guint32 plt_info_offset;
  void * res;

  plt_info_offset = mono_aot_get_plt_info_offset (regs, code);
  trampoline_calls.22 = trampoline_calls;
  trampoline_calls.23 = trampoline_calls.22 + 1;
  trampoline_calls = trampoline_calls.23;
  res = mono_aot_plt_resolve (aot_module, plt_info_offset, code);
  if (res == 0B) goto <D.23429>; else goto <D.23430>;
  <D.23429>:
  D.23431 = mono_loader_get_last_error ();
  if (D.23431 != 0B) goto <D.23432>; else goto <D.23433>;
  <D.23432>:
  D.23434 = mono_loader_get_last_error ();
  D.23435 = mono_loader_error_prepare_exception (D.23434);
  mono_raise_exception (D.23435);
  <D.23433>:
  D.23436 = res == 0B;
  D.23437 = (long int) D.23436;
  D.23438 = __builtin_expect (D.23437, 0);
  if (D.23438 != 0) goto <D.23439>; else goto <D.23440>;
  <D.23439>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 875, "res");
  <D.23440>:
  <D.23430>:
  D.23441 = res;
  return D.23441;
}


mono_class_init_trampoline (mgreg_t * regs, guint8 * code, struct MonoVTable * vtable, guint8 * tramp)
{
  unsigned int trampoline_calls.24;
  unsigned int trampoline_calls.25;
  long unsigned int D.23445;
  long unsigned int D.23446;
  guint8 * plt_entry;

  plt_entry = mono_aot_get_plt_entry (code);
  trampoline_calls.24 = trampoline_calls;
  trampoline_calls.25 = trampoline_calls.24 + 1;
  trampoline_calls = trampoline_calls.25;
  mono_runtime_class_init (vtable);
  D.23445 = BIT_FIELD_REF <*vtable, 64, 320>;
  D.23446 = D.23445 & 33554432;
  if (D.23446 != 0) goto <D.23447>; else goto <D.23448>;
  <D.23447>:
  if (plt_entry != 0B) goto <D.23449>; else goto <D.23450>;
  <D.23449>:
  mono_arch_nullify_plt_entry (plt_entry, regs);
  goto <D.23451>;
  <D.23450>:
  mono_arch_nullify_class_init_trampoline (code, regs);
  <D.23451>:
  <D.23448>:
}


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

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


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


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


mono_delegate_trampoline (mgreg_t * regs, guint8 * code, void * * tramp_data, guint8 * tramp)
{
  unsigned int trampoline_calls.28;
  unsigned int trampoline_calls.29;
  struct MonoMethod * D.23456;
  struct MonoObject * D.23461;
  struct MonoVTable * D.23463;
  struct MonoClass * D.23464;
  struct MonoClass * D.23465;
  struct MonoRemoteClass * D.23467;
  struct MonoClass * D.23468;
  struct MonoClass * D.23469;
  long unsigned int D.23472;
  long unsigned int D.23473;
  long unsigned int D.23478;
  long unsigned int D.23479;
  struct MonoClass * D.23482;
  long unsigned int D.23483;
  long unsigned int D.23484;
  int mono_aot_only.30;
  void * D.23492;
  void * D.23493;
  int iftmp.31;
  short unsigned int D.23507;
  unsigned int D.23508;
  unsigned int D.23509;
  unsigned int D.23512;
  unsigned int D.23513;
  short unsigned int D.23518;
  int D.23519;
  int D.23520;
  int D.23525;
  guint8 * * D.23535;
  guint8 * D.23537;
  void * D.23545;
  struct MonoMulticastDelegate * D.23546;
  _Bool D.23547;
  int D.23548;
  int D.23554;
  int D.23555;
  struct MonoMethodSignature * D.23557;
  short unsigned int D.23558;
  int D.23559;
  struct MonoMethodSignature * D.23560;
  short unsigned int D.23561;
  int D.23562;
  int D.23563;
  guint8 * iftmp.32;
  void * D.23571;
  void * D.23572;
  int D.23573;
  void * D.23574;
  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.28 = trampoline_calls;
      trampoline_calls.29 = trampoline_calls.28 + 1;
      trampoline_calls = trampoline_calls.29;
      delegate = mono_arch_get_this_arg_from_call (regs, code);
      D.23456 = delegate->method;
      if (D.23456 != 0B) goto <D.23457>; else goto <D.23458>;
      <D.23457>:
      method = delegate->method;
      D.23461 = delegate->target;
      if (D.23461 != 0B) goto <D.23462>; else goto <D.23459>;
      <D.23462>:
      D.23461 = delegate->target;
      D.23463 = D.23461->vtable;
      D.23464 = D.23463->klass;
      D.23465 = mono_defaults.transparent_proxy_class;
      if (D.23464 == D.23465) goto <D.23466>; else goto <D.23459>;
      <D.23466>:
      D.23461 = delegate->target;
      D.23467 = MEM[(struct MonoTransparentProxy *)D.23461].remote_class;
      D.23468 = D.23467->proxy_class;
      D.23469 = mono_class_get_com_object_class ();
      if (D.23468 != D.23469) goto <D.23470>; else goto <D.23471>;
      <D.23470>:
      D.23461 = delegate->target;
      D.23467 = MEM[(struct MonoTransparentProxy *)D.23461].remote_class;
      D.23468 = D.23467->proxy_class;
      D.23472 = BIT_FIELD_REF <*D.23468, 64, 256>;
      D.23473 = D.23472 & 1073741824;
      if (D.23473 == 0) goto <D.23474>; else goto <D.23475>;
      <D.23474>:
      method = mono_marshal_get_remoting_invoke (method);
      <D.23475>:
      <D.23471>:
      goto <D.23460>;
      <D.23459>:
      mono_error_init (&err);
      sig = mono_method_signature_checked (method, &err);
      if (sig == 0B) goto <D.23476>; else goto <D.23477>;
      <D.23476>:
      mono_error_raise_exception (&err);
      <D.23477>:
      D.23478 = BIT_FIELD_REF <*sig, 64, 64>;
      D.23479 = D.23478 & 18014398509481984;
      if (D.23479 != 0) goto <D.23480>; else goto <D.23481>;
      <D.23480>:
      D.23482 = method->klass;
      D.23483 = BIT_FIELD_REF <*D.23482, 64, 256>;
      D.23484 = D.23483 & 8;
      if (D.23484 != 0) goto <D.23485>; else goto <D.23486>;
      <D.23485>:
      mono_aot_only.30 = mono_aot_only;
      if (mono_aot_only.30 != 0) goto <D.23488>; else goto <D.23489>;
      <D.23488>:
      need_unbox_tramp = 1;
      goto <D.23490>;
      <D.23489>:
      method = mono_marshal_get_unbox_wrapper (method);
      <D.23490>:
      <D.23486>:
      <D.23481>:
      <D.23460>:
      goto <D.23491>;
      <D.23458>:
      D.23492 = delegate->method_ptr;
      D.23493 = mono_get_addr_from_ftnptr (D.23492);
      ji = mono_jit_info_table_find (domain, D.23493);
      if (ji != 0B) goto <D.23494>; else goto <D.23495>;
      <D.23494>:
      method = jinfo_get_method (ji);
      <D.23495>:
      <D.23491>:
      if (method != 0B) goto <D.23496>; else goto <D.23497>;
      <D.23496>:
      mono_error_init (&err);
      sig = mono_method_signature_checked (method, &err);
      if (sig == 0B) goto <D.23498>; else goto <D.23499>;
      <D.23498>:
      mono_error_raise_exception (&err);
      <D.23499>:
      D.23461 = delegate->target;
      if (D.23461 == 0B) goto <D.23503>; else goto <D.23501>;
      <D.23503>:
      D.23478 = BIT_FIELD_REF <*sig, 64, 64>;
      D.23479 = D.23478 & 18014398509481984;
      if (D.23479 != 0) goto <D.23504>; else goto <D.23501>;
      <D.23504>:
      iftmp.31 = 1;
      goto <D.23502>;
      <D.23501>:
      iftmp.31 = 0;
      <D.23502>:
      callvirt = iftmp.31;
      D.23461 = delegate->target;
      if (D.23461 != 0B) goto <D.23505>; else goto <D.23506>;
      <D.23505>:
      D.23507 = method->flags;
      D.23508 = (unsigned int) D.23507;
      D.23509 = D.23508 & 1088;
      if (D.23509 == 1088) goto <D.23510>; else goto <D.23511>;
      <D.23510>:
      D.23482 = method->klass;
      D.23512 = D.23482->flags;
      D.23513 = D.23512 & 128;
      if (D.23513 != 0) goto <D.23514>; else goto <D.23515>;
      <D.23514>:
      D.23461 = delegate->target;
      method = mono_object_get_virtual_method (D.23461, method);
      enable_caching = 0;
      <D.23515>:
      <D.23511>:
      <D.23506>:
      <D.23497>:
      if (method != 0B) goto <D.23516>; else goto <D.23517>;
      <D.23516>:
      D.23518 = method->iflags;
      D.23519 = (int) D.23518;
      D.23520 = D.23519 & 32;
      if (D.23520 != 0) goto <D.23521>; else goto <D.23522>;
      <D.23521>:
      method = mono_marshal_get_synchronized_wrapper (method);
      <D.23522>:
      <D.23517>:
      if (method != 0B) goto <D.23523>; else goto <D.23524>;
      <D.23523>:
      D.23525 = mono_method_needs_static_rgctx_invoke (method, 0);
      if (D.23525 != 0) goto <D.23526>; else goto <D.23527>;
      <D.23526>:
      need_rgctx_tramp = 1;
      <D.23527>:
      <D.23524>:
      if (method != 0B) goto <D.23530>; else goto <D.23528>;
      <D.23530>:
      if (callvirt == 0) goto <D.23531>; else goto <D.23528>;
      <D.23531>:
      if (enable_caching != 0) goto <D.23534>; else goto <D.23532>;
      <D.23534>:
      D.23535 = delegate->method_code;
      if (D.23535 != 0B) goto <D.23536>; else goto <D.23532>;
      <D.23536>:
      D.23535 = delegate->method_code;
      D.23537 = *D.23535;
      if (D.23537 != 0B) goto <D.23538>; else goto <D.23532>;
      <D.23538>:
      D.23535 = delegate->method_code;
      D.23537 = *D.23535;
      delegate->method_ptr = D.23537;
      goto <D.23533>;
      <D.23532>:
      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.23539>; else goto <D.23540>;
      <D.23539>:
      D.23535 = delegate->method_code;
      if (D.23535 != 0B) goto <D.23541>; else goto <D.23542>;
      <D.23541>:
      D.23535 = delegate->method_code;
      D.23492 = delegate->method_ptr;
      *D.23535 = D.23492;
      <D.23542>:
      <D.23540>:
      <D.23533>:
      goto <D.23529>;
      <D.23528>:
      if (need_rgctx_tramp != 0) goto <D.23543>; else goto <D.23544>;
      <D.23543>:
      D.23492 = delegate->method_ptr;
      D.23545 = mono_create_static_rgctx_trampoline (method, D.23492);
      delegate->method_ptr = D.23545;
      <D.23544>:
      <D.23529>:
      D.23546 = MEM[(struct MonoMulticastDelegate *)delegate].prev;
      D.23547 = D.23546 != 0B;
      multicast = (gboolean) D.23547;
      D.23548 = multicast | callvirt;
      if (D.23548 == 0) goto <D.23549>; else goto <D.23550>;
      <D.23549>:
      if (method != 0B) goto <D.23553>; else goto <D.23551>;
      <D.23553>:
      D.23507 = method->flags;
      D.23554 = (int) D.23507;
      D.23555 = D.23554 & 16;
      if (D.23555 != 0) goto <D.23556>; else goto <D.23551>;
      <D.23556>:
      D.23557 = mono_method_signature (method);
      D.23558 = D.23557->param_count;
      D.23559 = (int) D.23558;
      D.23560 = mono_method_signature (invoke);
      D.23561 = D.23560->param_count;
      D.23562 = (int) D.23561;
      D.23563 = D.23562 + 1;
      if (D.23559 == D.23563) goto <D.23564>; else goto <D.23551>;
      <D.23564>:
      code = impl_this;
      goto <D.23552>;
      <D.23551>:
      D.23461 = delegate->target;
      if (D.23461 != 0B) goto <D.23566>; else goto <D.23567>;
      <D.23566>:
      iftmp.32 = impl_this;
      goto <D.23568>;
      <D.23567>:
      iftmp.32 = impl_nothis;
      <D.23568>:
      code = iftmp.32;
      <D.23552>:
      if (code != 0B) goto <D.23569>; else goto <D.23570>;
      <D.23569>:
      D.23571 = mono_get_addr_from_ftnptr (code);
      delegate->invoke_impl = D.23571;
      D.23572 = code;
      return D.23572;
      <D.23570>:
      <D.23550>:
      m = mono_marshal_get_delegate_invoke (invoke, delegate);
      code = mono_compile_method (m);
      D.23573 = mono_method_needs_static_rgctx_invoke (m, 0);
      code = mini_add_method_trampoline (0B, m, code, D.23573, 0);
      D.23574 = mono_get_addr_from_ftnptr (code);
      delegate->invoke_impl = D.23574;
      D.23572 = code;
      return D.23572;
    }
  finally
    {
      err = {CLOBBER};
    }
}


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

  switch (tramp_type) <default: <D.22689>, case 0: <D.22676>, case 1: <D.22677>, case 2: <D.22678>, case 3: <D.22679>, case 4: <D.22680>, case 5: <D.22681>, case 6: <D.22682>, case 7: <D.22683>, case 8: <D.22684>, case 9: <D.22685>, case 10: <D.22686>, case 11: <D.22687>, case 12: <D.22688>>
  <D.22676>:
  <D.22677>:
  D.23577 = mono_magic_trampoline;
  return D.23577;
  <D.22678>:
  D.23577 = mono_class_init_trampoline;
  return D.23577;
  <D.22679>:
  D.23577 = mono_generic_class_init_trampoline;
  return D.23577;
  <D.22680>:
  D.23577 = mono_rgctx_lazy_fetch_trampoline;
  return D.23577;
  <D.22681>:
  D.23577 = mono_aot_trampoline;
  return D.23577;
  <D.22682>:
  D.23577 = mono_aot_plt_trampoline;
  return D.23577;
  <D.22683>:
  D.23577 = mono_delegate_trampoline;
  return D.23577;
  <D.22684>:
  D.23577 = mono_altstack_restore_prot;
  return D.23577;
  <D.22685>:
  D.23577 = mono_generic_virtual_remoting_trampoline;
  return D.23577;
  <D.22686>:
  D.23577 = mono_monitor_enter_trampoline;
  return D.23577;
  <D.22687>:
  D.23577 = mono_monitor_exit_trampoline;
  return D.23577;
  <D.22688>:
  D.23577 = mono_vcall_trampoline;
  return D.23577;
  <D.22689>:
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-trampolines.c", 1200);
  D.23577 = 0B;
  return D.23577;
}


mono_vcall_trampoline (mgreg_t * regs, guint8 * code, int slot, guint8 * tramp)
{
  unsigned int trampoline_calls.33;
  unsigned int trampoline_calls.34;
  _Bool D.23581;
  long int D.23582;
  long int D.23583;
  struct MonoDomain * D.23588;
  struct MonoClass * D.23591;
  long unsigned int D.23592;
  long unsigned int D.23593;
  struct MonoDomain * D.23596;
  int D.23597;
  void * D.23600;
  struct MonoDomain * D.23601;
  long unsigned int D.23603;
  long unsigned int D.23604;
  struct MonoObject * this;
  struct MonoVTable * vt;
  void * * vtable_slot;
  struct MonoMethod * m;
  gboolean need_rgctx_tramp;
  void * addr;

  need_rgctx_tramp = 0;
  trampoline_calls.33 = trampoline_calls;
  trampoline_calls.34 = trampoline_calls.33 + 1;
  trampoline_calls = trampoline_calls.34;
  this = mono_arch_get_this_arg_from_call (regs, code);
  D.23581 = this == 0B;
  D.23582 = (long int) D.23581;
  D.23583 = __builtin_expect (D.23582, 0);
  if (D.23583 != 0) goto <D.23584>; else goto <D.23585>;
  <D.23584>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 732, "this");
  <D.23585>:
  vt = this->vtable;
  if (slot >= 0) goto <D.23586>; else goto <D.23587>;
  <D.23586>:
  vtable_slot = &vt->vtable[slot];
  D.23588 = mono_domain_get ();
  addr = mono_aot_get_method_from_vt_slot (D.23588, vt, slot);
  if (addr != 0B) goto <D.23589>; else goto <D.23590>;
  <D.23589>:
  D.23591 = vt->klass;
  D.23592 = BIT_FIELD_REF <*D.23591, 64, 256>;
  D.23593 = D.23592 & 8;
  if (D.23593 == 0) goto <D.23594>; else goto <D.23595>;
  <D.23594>:
  D.23596 = mono_domain_get ();
  D.23597 = mono_domain_owns_vtable_slot (D.23596, vtable_slot);
  if (D.23597 != 0) goto <D.23598>; else goto <D.23599>;
  <D.23598>:
  *vtable_slot = addr;
  <D.23599>:
  D.23601 = mono_domain_get ();
  D.23600 = mono_create_ftnptr (D.23601, addr);
  return D.23600;
  <D.23595>:
  <D.23590>:
  D.23591 = vt->klass;
  m = mono_class_get_vtable_entry (D.23591, slot);
  need_rgctx_tramp = mono_method_needs_static_rgctx_invoke (m, 0);
  goto <D.23602>;
  <D.23587>:
  D.23603 = (long unsigned int) slot;
  D.23604 = D.23603 * 8;
  vtable_slot = vt + D.23604;
  m = 0B;
  need_rgctx_tramp = 0;
  <D.23602>:
  D.23600 = common_call_trampoline (regs, code, m, tramp, vt, vtable_slot, need_rgctx_tramp);
  return D.23600;
}


mono_rgctx_lazy_fetch_trampoline (mgreg_t * regs, guint8 * code, void * data, guint8 * tramp)
{
  long int data.35;
  mgreg_t * D.23607;
  long int D.23608;
  signed int slot.36;
  _Bool D.23610;
  unsigned int trampoline_calls.37;
  unsigned int trampoline_calls.38;
  int inited.39;
  int num_lookups.40;
  int num_lookups.41;
  void * D.23620;
  static gboolean inited = 0;
  static int num_lookups = 0;
  guint32 slot;
  mgreg_t * r;
  void * arg;
  guint32 index;
  gboolean mrgctx;

  data.35 = (long int) data;
  slot = (guint32) data.35;
  r = regs;
  D.23607 = r + 96;
  D.23608 = *D.23607;
  arg = (void *) D.23608;
  index = slot & 2147483647;
  slot.36 = (signed int) slot;
  D.23610 = slot.36 < 0;
  mrgctx = (gboolean) D.23610;
  trampoline_calls.37 = trampoline_calls;
  trampoline_calls.38 = trampoline_calls.37 + 1;
  trampoline_calls = trampoline_calls.38;
  inited.39 = inited;
  if (inited.39 == 0) goto <D.23614>; else goto <D.23615>;
  <D.23614>:
  mono_counters_register ("RGCTX unmanaged lookups", 2048, &num_lookups);
  inited = 1;
  <D.23615>:
  num_lookups.40 = num_lookups;
  num_lookups.41 = num_lookups.40 + 1;
  num_lookups = num_lookups.41;
  if (mrgctx != 0) goto <D.23618>; else goto <D.23619>;
  <D.23618>:
  D.23620 = mono_method_fill_runtime_generic_context (arg, code, index);
  return D.23620;
  <D.23619>:
  D.23620 = mono_class_fill_runtime_generic_context (arg, code, index);
  return D.23620;
}


mono_trampolines_init ()
{
  int mono_aot_only.42;
  guchar * D.23625;
  guchar * D.23626;
  guchar * D.23627;
  guchar * D.23628;
  guchar * D.23629;
  guchar * D.23630;
  guchar * D.23631;
  guchar * D.23632;
  guchar * D.23633;
  guchar * D.23634;
  guchar * D.23635;
  guchar * D.23636;
  guchar * D.23637;

  InitializeCriticalSection (&trampolines_mutex);
  mono_aot_only.42 = mono_aot_only;
  if (mono_aot_only.42 != 0) goto <D.23623>; else goto <D.23624>;
  <D.23623>:
  return;
  <D.23624>:
  D.23625 = create_trampoline_code (0);
  mono_trampoline_code[0] = D.23625;
  D.23626 = create_trampoline_code (1);
  mono_trampoline_code[1] = D.23626;
  D.23627 = create_trampoline_code (2);
  mono_trampoline_code[2] = D.23627;
  D.23628 = create_trampoline_code (3);
  mono_trampoline_code[3] = D.23628;
  D.23629 = create_trampoline_code (4);
  mono_trampoline_code[4] = D.23629;
  D.23630 = create_trampoline_code (5);
  mono_trampoline_code[5] = D.23630;
  D.23631 = create_trampoline_code (6);
  mono_trampoline_code[6] = D.23631;
  D.23632 = create_trampoline_code (7);
  mono_trampoline_code[7] = D.23632;
  D.23633 = create_trampoline_code (8);
  mono_trampoline_code[8] = D.23633;
  D.23634 = create_trampoline_code (9);
  mono_trampoline_code[9] = D.23634;
  D.23635 = create_trampoline_code (10);
  mono_trampoline_code[10] = D.23635;
  D.23636 = create_trampoline_code (11);
  mono_trampoline_code[11] = D.23636;
  D.23637 = create_trampoline_code (12);
  mono_trampoline_code[12] = D.23637;
  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.43;
  guchar * D.23640;
  struct MonoTrampInfo * info;
  guchar * code;

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


mono_trampolines_cleanup ()
{
  struct GHashTable * class_init_hash_addr.44;
  struct GHashTable * rgctx_lazy_fetch_trampoline_hash.45;
  struct GHashTable * rgctx_lazy_fetch_trampoline_hash_addr.46;

  class_init_hash_addr.44 = class_init_hash_addr;
  if (class_init_hash_addr.44 != 0B) goto <D.23644>; else goto <D.23645>;
  <D.23644>:
  class_init_hash_addr.44 = class_init_hash_addr;
  monoeg_g_hash_table_destroy (class_init_hash_addr.44);
  <D.23645>:
  rgctx_lazy_fetch_trampoline_hash.45 = rgctx_lazy_fetch_trampoline_hash;
  if (rgctx_lazy_fetch_trampoline_hash.45 != 0B) goto <D.23647>; else goto <D.23648>;
  <D.23647>:
  rgctx_lazy_fetch_trampoline_hash.45 = rgctx_lazy_fetch_trampoline_hash;
  monoeg_g_hash_table_destroy (rgctx_lazy_fetch_trampoline_hash.45);
  <D.23648>:
  rgctx_lazy_fetch_trampoline_hash_addr.46 = rgctx_lazy_fetch_trampoline_hash_addr;
  if (rgctx_lazy_fetch_trampoline_hash_addr.46 != 0B) goto <D.23650>; else goto <D.23651>;
  <D.23650>:
  rgctx_lazy_fetch_trampoline_hash_addr.46 = rgctx_lazy_fetch_trampoline_hash_addr;
  monoeg_g_hash_table_destroy (rgctx_lazy_fetch_trampoline_hash_addr.46);
  <D.23651>:
  DeleteCriticalSection (&trampolines_mutex);
}


mono_get_trampoline_code (MonoTrampolineType tramp_type)
{
  guint8 * D.23652;
  _Bool D.23653;
  long int D.23654;
  long int D.23655;
  guint8 * D.23658;

  D.23652 = mono_trampoline_code[tramp_type];
  D.23653 = D.23652 == 0B;
  D.23654 = (long int) D.23653;
  D.23655 = __builtin_expect (D.23654, 0);
  if (D.23655 != 0) goto <D.23656>; else goto <D.23657>;
  <D.23656>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1271, "mono_trampoline_code [tramp_type]");
  <D.23657>:
  D.23658 = mono_trampoline_code[tramp_type];
  return D.23658;
}


mono_create_specific_trampoline (void * arg1, MonoTrampolineType tramp_type, struct MonoDomain * domain, guint32 * code_len)
{
  int mono_aot_only.47;
  void * D.23663;
  struct MonoImage * D.23664;

  mono_aot_only.47 = mono_aot_only;
  if (mono_aot_only.47 != 0) goto <D.23661>; else goto <D.23662>;
  <D.23661>:
  D.23664 = mono_defaults.corlib;
  D.23663 = mono_aot_create_specific_trampoline (D.23664, arg1, tramp_type, domain, code_len);
  return D.23663;
  <D.23662>:
  D.23663 = mono_arch_create_specific_trampoline (arg1, tramp_type, domain, code_len);
  return D.23663;
}


mono_create_class_init_trampoline (struct MonoVTable * vtable)
{
  struct MonoClass * D.23666;
  struct MonoGenericContainer * D.23667;
  _Bool D.23668;
  long int D.23669;
  long int D.23670;
  union mono_mutex_t * D.23673;
  _Bool D.23676;
  long int D.23677;
  long int D.23678;
  void * D.23681;
  struct GHashTable * D.23682;
  _Bool D.23685;
  long int D.23686;
  long int D.23687;
  void * D.23692;
  _Bool D.23695;
  long int D.23696;
  long int D.23697;
  _Bool D.23702;
  long int D.23703;
  long int D.23704;
  _Bool D.23709;
  long int D.23710;
  long int D.23711;
  struct GHashTable * class_init_hash_addr.48;
  struct GHashTable * class_init_hash_addr.49;
  _Bool D.23720;
  long int D.23721;
  long int D.23722;
  void * code;
  void * ptr;
  struct MonoDomain * domain;

  domain = vtable->domain;
  D.23666 = vtable->klass;
  D.23667 = D.23666->generic_container;
  D.23668 = D.23667 != 0B;
  D.23669 = (long int) D.23668;
  D.23670 = __builtin_expect (D.23669, 0);
  if (D.23670 != 0) goto <D.23671>; else goto <D.23672>;
  <D.23671>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1291, "!vtable->klass->generic_container");
  <D.23672>:
  {
    int ret;

    D.23673 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.23673);
    if (ret != 0) goto <D.23674>; else goto <D.23675>;
    <D.23674>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.23675>:
    D.23676 = ret != 0;
    D.23677 = (long int) D.23676;
    D.23678 = __builtin_expect (D.23677, 0);
    if (D.23678 != 0) goto <D.23679>; else goto <D.23680>;
    <D.23679>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1294, "ret == 0");
    <D.23680>:
  }
  D.23681 = domain->runtime_info;
  D.23682 = MEM[(struct MonoJitDomainInfo *)D.23681].class_init_trampoline_hash;
  ptr = monoeg_g_hash_table_lookup (D.23682, vtable);
  {
    int ret;

    D.23673 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.23673);
    if (ret != 0) goto <D.23683>; else goto <D.23684>;
    <D.23683>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.23684>:
    D.23685 = ret != 0;
    D.23686 = (long int) D.23685;
    D.23687 = __builtin_expect (D.23686, 0);
    if (D.23687 != 0) goto <D.23688>; else goto <D.23689>;
    <D.23688>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1298, "ret == 0");
    <D.23689>:
  }
  if (ptr != 0B) goto <D.23690>; else goto <D.23691>;
  <D.23690>:
  D.23692 = ptr;
  return D.23692;
  <D.23691>:
  code = mono_create_specific_trampoline (vtable, 2, domain, 0B);
  ptr = mono_create_ftnptr (domain, code);
  {
    int ret;

    D.23673 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.23673);
    if (ret != 0) goto <D.23693>; else goto <D.23694>;
    <D.23693>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.23694>:
    D.23695 = ret != 0;
    D.23696 = (long int) D.23695;
    D.23697 = __builtin_expect (D.23696, 0);
    if (D.23697 != 0) goto <D.23698>; else goto <D.23699>;
    <D.23698>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1307, "ret == 0");
    <D.23699>:
  }
  D.23681 = domain->runtime_info;
  D.23682 = MEM[(struct MonoJitDomainInfo *)D.23681].class_init_trampoline_hash;
  monoeg_g_hash_table_insert_replace (D.23682, vtable, ptr, 0);
  {
    int ret;

    D.23673 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.23673);
    if (ret != 0) goto <D.23700>; else goto <D.23701>;
    <D.23700>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.23701>:
    D.23702 = ret != 0;
    D.23703 = (long int) D.23702;
    D.23704 = __builtin_expect (D.23703, 0);
    if (D.23704 != 0) goto <D.23705>; else goto <D.23706>;
    <D.23705>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1310, "ret == 0");
    <D.23706>:
  }
  {
    int ret;

    ret = pthread_mutex_lock (&trampolines_mutex.mutex);
    if (ret != 0) goto <D.23707>; else goto <D.23708>;
    <D.23707>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.23708>:
    D.23709 = ret != 0;
    D.23710 = (long int) D.23709;
    D.23711 = __builtin_expect (D.23710, 0);
    if (D.23711 != 0) goto <D.23712>; else goto <D.23713>;
    <D.23712>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1312, "ret == 0");
    <D.23713>:
  }
  class_init_hash_addr.48 = class_init_hash_addr;
  if (class_init_hash_addr.48 == 0B) goto <D.23715>; else goto <D.23716>;
  <D.23715>:
  class_init_hash_addr.49 = monoeg_g_hash_table_new (0B, 0B);
  class_init_hash_addr = class_init_hash_addr.49;
  <D.23716>:
  class_init_hash_addr.48 = class_init_hash_addr;
  monoeg_g_hash_table_insert_replace (class_init_hash_addr.48, ptr, vtable, 0);
  {
    int ret;

    ret = pthread_mutex_unlock (&trampolines_mutex.mutex);
    if (ret != 0) goto <D.23718>; else goto <D.23719>;
    <D.23718>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.23719>:
    D.23720 = ret != 0;
    D.23721 = (long int) D.23720;
    D.23722 = __builtin_expect (D.23721, 0);
    if (D.23722 != 0) goto <D.23723>; else goto <D.23724>;
    <D.23723>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1316, "ret == 0");
    <D.23724>:
  }
  D.23692 = ptr;
  return D.23692;
}


mono_create_generic_class_init_trampoline ()
{
  _Bool D.23728;
  long int D.23729;
  long int D.23730;
  void * code.50;
  int mono_aot_only.51;
  void * D.23739;
  void * code.52;
  void * code.53;
  struct MonoTrampInfo * info.54;
  _Bool D.23746;
  long int D.23747;
  long int D.23748;
  void * D.23751;
  static void * code;
  struct MonoTrampInfo * info;

  try
    {
      {
        int ret;

        ret = pthread_mutex_lock (&trampolines_mutex.mutex);
        if (ret != 0) goto <D.23726>; else goto <D.23727>;
        <D.23726>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.23727>:
        D.23728 = ret != 0;
        D.23729 = (long int) D.23728;
        D.23730 = __builtin_expect (D.23729, 0);
        if (D.23730 != 0) goto <D.23731>; else goto <D.23732>;
        <D.23731>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1328, "ret == 0");
        <D.23732>:
      }
      code.50 = code;
      if (code.50 == 0B) goto <D.23734>; else goto <D.23735>;
      <D.23734>:
      mono_aot_only.51 = mono_aot_only;
      if (mono_aot_only.51 != 0) goto <D.23737>; else goto <D.23738>;
      <D.23737>:
      D.23739 = mono_aot_get_trampoline ("generic_class_init_trampoline");
      code.52 = mono_get_addr_from_ftnptr (D.23739);
      code = code.52;
      goto <D.23741>;
      <D.23738>:
      code.53 = mono_arch_create_generic_class_init_trampoline (&info, 0);
      code = code.53;
      info.54 = info;
      mono_tramp_info_register (info.54);
      <D.23741>:
      <D.23735>:
      {
        int ret;

        ret = pthread_mutex_unlock (&trampolines_mutex.mutex);
        if (ret != 0) goto <D.23744>; else goto <D.23745>;
        <D.23744>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.23745>:
        D.23746 = ret != 0;
        D.23747 = (long int) D.23746;
        D.23748 = __builtin_expect (D.23747, 0);
        if (D.23748 != 0) goto <D.23749>; else goto <D.23750>;
        <D.23749>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1340, "ret == 0");
        <D.23750>:
      }
      D.23751 = code;
      return D.23751;
    }
  finally
    {
      info = {CLOBBER};
    }
}


mono_create_jump_trampoline (struct MonoDomain * domain, struct MonoMethod * method, gboolean add_sync_wrapper)
{
  struct MonoJitInfo * ji.55;
  long unsigned int D.23757;
  long unsigned int D.23758;
  short unsigned int D.23761;
  int D.23762;
  int D.23763;
  void * D.23766;
  union mono_mutex_t * D.23767;
  _Bool D.23770;
  long int D.23771;
  long int D.23772;
  void * D.23775;
  struct GHashTable * D.23776;
  _Bool D.23779;
  long int D.23780;
  long int D.23781;
  struct MonoDomain * D.23786;
  unsigned int code_size.56;
  _Bool D.23788;
  long int D.23789;
  long int D.23790;
  void * ji.57;
  int code_size.58;
  _Bool D.23797;
  long int D.23798;
  long int D.23799;
  void * D.23802;
  _Bool D.23805;
  long int D.23806;
  long int D.23807;
  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.23754>; else goto <D.23755>;
      <D.23754>:
      ji.55 = ji;
      D.23757 = BIT_FIELD_REF <*ji.55, 64, 256>;
      D.23758 = D.23757 & 131072;
      if (D.23758 == 0) goto <D.23759>; else goto <D.23760>;
      <D.23759>:
      D.23761 = method->iflags;
      D.23762 = (int) D.23761;
      D.23763 = D.23762 & 32;
      if (D.23763 == 0) goto <D.23764>; else goto <D.23765>;
      <D.23764>:
      D.23766 = code;
      return D.23766;
      <D.23765>:
      <D.23760>:
      <D.23755>:
      {
        int ret;

        D.23767 = &domain->lock.mutex;
        ret = pthread_mutex_lock (D.23767);
        if (ret != 0) goto <D.23768>; else goto <D.23769>;
        <D.23768>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.23769>:
        D.23770 = ret != 0;
        D.23771 = (long int) D.23770;
        D.23772 = __builtin_expect (D.23771, 0);
        if (D.23772 != 0) goto <D.23773>; else goto <D.23774>;
        <D.23773>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1365, "ret == 0");
        <D.23774>:
      }
      D.23775 = domain->runtime_info;
      D.23776 = MEM[(struct MonoJitDomainInfo *)D.23775].jump_trampoline_hash;
      code = monoeg_g_hash_table_lookup (D.23776, method);
      {
        int ret;

        D.23767 = &domain->lock.mutex;
        ret = pthread_mutex_unlock (D.23767);
        if (ret != 0) goto <D.23777>; else goto <D.23778>;
        <D.23777>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.23778>:
        D.23779 = ret != 0;
        D.23780 = (long int) D.23779;
        D.23781 = __builtin_expect (D.23780, 0);
        if (D.23781 != 0) goto <D.23782>; else goto <D.23783>;
        <D.23782>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1367, "ret == 0");
        <D.23783>:
      }
      if (code != 0B) goto <D.23784>; else goto <D.23785>;
      <D.23784>:
      D.23766 = code;
      return D.23766;
      <D.23785>:
      D.23786 = mono_domain_get ();
      code = mono_create_specific_trampoline (method, 1, D.23786, &code_size);
      code_size.56 = code_size;
      D.23788 = code_size.56 == 0;
      D.23789 = (long int) D.23788;
      D.23790 = __builtin_expect (D.23789, 0);
      if (D.23790 != 0) goto <D.23791>; else goto <D.23792>;
      <D.23791>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1372, "code_size");
      <D.23792>:
      ji.57 = mono_domain_alloc0 (domain, 48);
      ji = ji.57;
      ji.55 = ji;
      ji.55->code_start = code;
      ji.55 = ji;
      code_size.56 = code_size;
      code_size.58 = (int) code_size.56;
      ji.55->code_size = code_size.58;
      ji.55 = ji;
      ji.55->d.method = method;
      ji.55 = ji;
      mono_jit_info_table_add (domain, ji.55);
      {
        int ret;

        D.23767 = &domain->lock.mutex;
        ret = pthread_mutex_lock (D.23767);
        if (ret != 0) goto <D.23795>; else goto <D.23796>;
        <D.23795>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.23796>:
        D.23797 = ret != 0;
        D.23798 = (long int) D.23797;
        D.23799 = __builtin_expect (D.23798, 0);
        if (D.23799 != 0) goto <D.23800>; else goto <D.23801>;
        <D.23800>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1386, "ret == 0");
        <D.23801>:
      }
      D.23775 = domain->runtime_info;
      D.23776 = MEM[(struct MonoJitDomainInfo *)D.23775].jump_trampoline_hash;
      ji.55 = ji;
      D.23802 = ji.55->code_start;
      monoeg_g_hash_table_insert_replace (D.23776, method, D.23802, 0);
      {
        int ret;

        D.23767 = &domain->lock.mutex;
        ret = pthread_mutex_unlock (D.23767);
        if (ret != 0) goto <D.23803>; else goto <D.23804>;
        <D.23803>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.23804>:
        D.23805 = ret != 0;
        D.23806 = (long int) D.23805;
        D.23807 = __builtin_expect (D.23806, 0);
        if (D.23807 != 0) goto <D.23808>; else goto <D.23809>;
        <D.23808>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1388, "ret == 0");
        <D.23809>:
      }
      ji.55 = ji;
      D.23766 = ji.55->code_start;
      return D.23766;
    }
  finally
    {
      ji = {CLOBBER};
      code_size = {CLOBBER};
    }
}


mono_create_jit_trampoline_in_domain (struct MonoDomain * domain, struct MonoMethod * method)
{
  int mono_aot_only.59;
  void * D.23817;
  union mono_mutex_t * D.23818;
  _Bool D.23821;
  long int D.23822;
  long int D.23823;
  void * D.23826;
  struct GHashTable * D.23827;
  _Bool D.23830;
  long int D.23831;
  long int D.23832;
  _Bool D.23839;
  long int D.23840;
  long int D.23841;
  _Bool D.23846;
  long int D.23847;
  long int D.23848;
  unsigned int jit_trampolines.60;
  unsigned int jit_trampolines.61;
  void * tramp;

  mono_aot_only.59 = mono_aot_only;
  if (mono_aot_only.59 != 0) goto <D.23813>; else goto <D.23814>;
  <D.23813>:
  {
    void * code;

    code = mono_jit_find_compiled_method (domain, method);
    if (code != 0B) goto <D.23815>; else goto <D.23816>;
    <D.23815>:
    D.23817 = code;
    return D.23817;
    <D.23816>:
  }
  <D.23814>:
  {
    int ret;

    D.23818 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.23818);
    if (ret != 0) goto <D.23819>; else goto <D.23820>;
    <D.23819>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.23820>:
    D.23821 = ret != 0;
    D.23822 = (long int) D.23821;
    D.23823 = __builtin_expect (D.23822, 0);
    if (D.23823 != 0) goto <D.23824>; else goto <D.23825>;
    <D.23824>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1406, "ret == 0");
    <D.23825>:
  }
  D.23826 = domain->runtime_info;
  D.23827 = MEM[(struct MonoJitDomainInfo *)D.23826].jit_trampoline_hash;
  tramp = monoeg_g_hash_table_lookup (D.23827, method);
  {
    int ret;

    D.23818 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.23818);
    if (ret != 0) goto <D.23828>; else goto <D.23829>;
    <D.23828>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.23829>:
    D.23830 = ret != 0;
    D.23831 = (long int) D.23830;
    D.23832 = __builtin_expect (D.23831, 0);
    if (D.23832 != 0) goto <D.23833>; else goto <D.23834>;
    <D.23833>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1408, "ret == 0");
    <D.23834>:
  }
  if (tramp != 0B) goto <D.23835>; else goto <D.23836>;
  <D.23835>:
  D.23817 = tramp;
  return D.23817;
  <D.23836>:
  tramp = mono_create_specific_trampoline (method, 0, domain, 0B);
  {
    int ret;

    D.23818 = &domain->lock.mutex;
    ret = pthread_mutex_lock (D.23818);
    if (ret != 0) goto <D.23837>; else goto <D.23838>;
    <D.23837>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.23838>:
    D.23839 = ret != 0;
    D.23840 = (long int) D.23839;
    D.23841 = __builtin_expect (D.23840, 0);
    if (D.23841 != 0) goto <D.23842>; else goto <D.23843>;
    <D.23842>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1414, "ret == 0");
    <D.23843>:
  }
  D.23826 = domain->runtime_info;
  D.23827 = MEM[(struct MonoJitDomainInfo *)D.23826].jit_trampoline_hash;
  monoeg_g_hash_table_insert_replace (D.23827, method, tramp, 0);
  {
    int ret;

    D.23818 = &domain->lock.mutex;
    ret = pthread_mutex_unlock (D.23818);
    if (ret != 0) goto <D.23844>; else goto <D.23845>;
    <D.23844>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.23845>:
    D.23846 = ret != 0;
    D.23847 = (long int) D.23846;
    D.23848 = __builtin_expect (D.23847, 0);
    if (D.23848 != 0) goto <D.23849>; else goto <D.23850>;
    <D.23849>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1416, "ret == 0");
    <D.23850>:
  }
  jit_trampolines.60 = jit_trampolines;
  jit_trampolines.61 = jit_trampolines.60 + 1;
  jit_trampolines = jit_trampolines.61;
  D.23817 = tramp;
  return D.23817;
}


mono_create_jit_trampoline (struct MonoMethod * method)
{
  void * D.23854;
  struct MonoDomain * D.23855;

  D.23855 = mono_domain_get ();
  D.23854 = mono_create_jit_trampoline_in_domain (D.23855, method);
  return D.23854;
}


mono_create_jit_trampoline_from_token (struct MonoImage * image, guint32 token)
{
  unsigned int jit_trampolines.62;
  unsigned int jit_trampolines.63;
  void * D.23859;
  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.62 = jit_trampolines;
  jit_trampolines.63 = jit_trampolines.62 + 1;
  jit_trampolines = jit_trampolines.63;
  D.23859 = tramp;
  return D.23859;
}


mono_create_delegate_trampoline (struct MonoDomain * domain, struct MonoClass * klass)
{
  union mono_mutex_t * D.23861;
  _Bool D.23864;
  long int D.23865;
  long int D.23866;
  void * D.23869;
  struct GHashTable * D.23870;
  _Bool D.23873;
  long int D.23874;
  long int D.23875;
  void * D.23880;
  _Bool D.23881;
  long int D.23882;
  long int D.23883;
  void * * D.23886;
  struct MonoMethodSignature * D.23887;
  void * D.23888;
  void * * D.23889;
  struct MonoMethodSignature * D.23890;
  void * D.23891;
  unsigned int code_size.64;
  _Bool D.23893;
  long int D.23894;
  long int D.23895;
  _Bool D.23900;
  long int D.23901;
  long int D.23902;
  _Bool D.23907;
  long int D.23908;
  long int D.23909;
  void * ptr;
  guint32 code_size;
  void * * tramp_data;
  struct MonoMethod * invoke;

  try
    {
      code_size = 0;
      {
        int ret;

        D.23861 = &domain->lock.mutex;
        ret = pthread_mutex_lock (D.23861);
        if (ret != 0) goto <D.23862>; else goto <D.23863>;
        <D.23862>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.23863>:
        D.23864 = ret != 0;
        D.23865 = (long int) D.23864;
        D.23866 = __builtin_expect (D.23865, 0);
        if (D.23866 != 0) goto <D.23867>; else goto <D.23868>;
        <D.23867>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1459, "ret == 0");
        <D.23868>:
      }
      D.23869 = domain->runtime_info;
      D.23870 = MEM[(struct MonoJitDomainInfo *)D.23869].delegate_trampoline_hash;
      ptr = monoeg_g_hash_table_lookup (D.23870, klass);
      {
        int ret;

        D.23861 = &domain->lock.mutex;
        ret = pthread_mutex_unlock (D.23861);
        if (ret != 0) goto <D.23871>; else goto <D.23872>;
        <D.23871>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.23872>:
        D.23873 = ret != 0;
        D.23874 = (long int) D.23873;
        D.23875 = __builtin_expect (D.23874, 0);
        if (D.23875 != 0) goto <D.23876>; else goto <D.23877>;
        <D.23876>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1461, "ret == 0");
        <D.23877>:
      }
      if (ptr != 0B) goto <D.23878>; else goto <D.23879>;
      <D.23878>:
      D.23880 = ptr;
      return D.23880;
      <D.23879>:
      invoke = mono_get_delegate_invoke (klass);
      D.23881 = invoke == 0B;
      D.23882 = (long int) D.23881;
      D.23883 = __builtin_expect (D.23882, 0);
      if (D.23883 != 0) goto <D.23884>; else goto <D.23885>;
      <D.23884>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1467, "invoke");
      <D.23885>:
      tramp_data = mono_domain_alloc (domain, 24);
      *tramp_data = invoke;
      D.23886 = tramp_data + 8;
      D.23887 = mono_method_signature (invoke);
      D.23888 = mono_arch_get_delegate_invoke_impl (D.23887, 1);
      *D.23886 = D.23888;
      D.23889 = tramp_data + 16;
      D.23890 = mono_method_signature (invoke);
      D.23891 = mono_arch_get_delegate_invoke_impl (D.23890, 0);
      *D.23889 = D.23891;
      ptr = mono_create_specific_trampoline (tramp_data, 7, domain, &code_size);
      code_size.64 = code_size;
      D.23893 = code_size.64 == 0;
      D.23894 = (long int) D.23893;
      D.23895 = __builtin_expect (D.23894, 0);
      if (D.23895 != 0) goto <D.23896>; else goto <D.23897>;
      <D.23896>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1475, "code_size");
      <D.23897>:
      {
        int ret;

        D.23861 = &domain->lock.mutex;
        ret = pthread_mutex_lock (D.23861);
        if (ret != 0) goto <D.23898>; else goto <D.23899>;
        <D.23898>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.23899>:
        D.23900 = ret != 0;
        D.23901 = (long int) D.23900;
        D.23902 = __builtin_expect (D.23901, 0);
        if (D.23902 != 0) goto <D.23903>; else goto <D.23904>;
        <D.23903>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1478, "ret == 0");
        <D.23904>:
      }
      D.23869 = domain->runtime_info;
      D.23870 = MEM[(struct MonoJitDomainInfo *)D.23869].delegate_trampoline_hash;
      monoeg_g_hash_table_insert_replace (D.23870, klass, ptr, 0);
      {
        int ret;

        D.23861 = &domain->lock.mutex;
        ret = pthread_mutex_unlock (D.23861);
        if (ret != 0) goto <D.23905>; else goto <D.23906>;
        <D.23905>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.23906>:
        D.23907 = ret != 0;
        D.23908 = (long int) D.23907;
        D.23909 = __builtin_expect (D.23908, 0);
        if (D.23909 != 0) goto <D.23910>; else goto <D.23911>;
        <D.23910>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1481, "ret == 0");
        <D.23911>:
      }
      D.23880 = ptr;
      return D.23880;
    }
  finally
    {
      code_size = {CLOBBER};
    }
}


mono_create_rgctx_lazy_fetch_trampoline (guint32 offset)
{
  _Bool D.23916;
  long int D.23917;
  long int D.23918;
  struct GHashTable * rgctx_lazy_fetch_trampoline_hash.65;
  long unsigned int D.23924;
  const void * D.23925;
  _Bool D.23929;
  long int D.23930;
  long int D.23931;
  void * D.23936;
  int mono_aot_only.66;
  struct MonoTrampInfo * info.67;
  struct MonoDomain * D.23942;
  _Bool D.23945;
  long int D.23946;
  long int D.23947;
  struct GHashTable * rgctx_lazy_fetch_trampoline_hash.68;
  struct GHashTable * rgctx_lazy_fetch_trampoline_hash_addr.69;
  void * D.23954;
  _Bool D.23955;
  long int D.23956;
  long int D.23957;
  struct GHashTable * rgctx_lazy_fetch_trampoline_hash_addr.70;
  unsigned int D.23961;
  long unsigned int D.23962;
  void * D.23963;
  _Bool D.23966;
  long int D.23967;
  long int D.23968;
  int inited.71;
  int num_trampolines.72;
  int num_trampolines.73;
  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.23914>; else goto <D.23915>;
        <D.23914>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.23915>:
        D.23916 = ret != 0;
        D.23917 = (long int) D.23916;
        D.23918 = __builtin_expect (D.23917, 0);
        if (D.23918 != 0) goto <D.23919>; else goto <D.23920>;
        <D.23919>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1498, "ret == 0");
        <D.23920>:
      }
      rgctx_lazy_fetch_trampoline_hash.65 = rgctx_lazy_fetch_trampoline_hash;
      if (rgctx_lazy_fetch_trampoline_hash.65 != 0B) goto <D.23922>; else goto <D.23923>;
      <D.23922>:
      rgctx_lazy_fetch_trampoline_hash.65 = rgctx_lazy_fetch_trampoline_hash;
      D.23924 = (long unsigned int) offset;
      D.23925 = (const void *) D.23924;
      tramp = monoeg_g_hash_table_lookup (rgctx_lazy_fetch_trampoline_hash.65, D.23925);
      goto <D.23926>;
      <D.23923>:
      tramp = 0B;
      <D.23926>:
      {
        int ret;

        ret = pthread_mutex_unlock (&trampolines_mutex.mutex);
        if (ret != 0) goto <D.23927>; else goto <D.23928>;
        <D.23927>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.23928>:
        D.23929 = ret != 0;
        D.23930 = (long int) D.23929;
        D.23931 = __builtin_expect (D.23930, 0);
        if (D.23931 != 0) goto <D.23932>; else goto <D.23933>;
        <D.23932>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1503, "ret == 0");
        <D.23933>:
      }
      if (tramp != 0B) goto <D.23934>; else goto <D.23935>;
      <D.23934>:
      D.23936 = tramp;
      return D.23936;
      <D.23935>:
      mono_aot_only.66 = mono_aot_only;
      if (mono_aot_only.66 != 0) goto <D.23938>; else goto <D.23939>;
      <D.23938>:
      ptr = mono_aot_get_lazy_fetch_trampoline (offset);
      goto <D.23940>;
      <D.23939>:
      tramp = mono_arch_create_rgctx_lazy_fetch_trampoline (offset, &info, 0);
      info.67 = info;
      mono_tramp_info_register (info.67);
      D.23942 = mono_get_root_domain ();
      ptr = mono_create_ftnptr (D.23942, tramp);
      <D.23940>:
      {
        int ret;

        ret = pthread_mutex_lock (&trampolines_mutex.mutex);
        if (ret != 0) goto <D.23943>; else goto <D.23944>;
        <D.23943>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
        <D.23944>:
        D.23945 = ret != 0;
        D.23946 = (long int) D.23945;
        D.23947 = __builtin_expect (D.23946, 0);
        if (D.23947 != 0) goto <D.23948>; else goto <D.23949>;
        <D.23948>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1515, "ret == 0");
        <D.23949>:
      }
      rgctx_lazy_fetch_trampoline_hash.65 = rgctx_lazy_fetch_trampoline_hash;
      if (rgctx_lazy_fetch_trampoline_hash.65 == 0B) goto <D.23950>; else goto <D.23951>;
      <D.23950>:
      rgctx_lazy_fetch_trampoline_hash.68 = monoeg_g_hash_table_new (0B, 0B);
      rgctx_lazy_fetch_trampoline_hash = rgctx_lazy_fetch_trampoline_hash.68;
      rgctx_lazy_fetch_trampoline_hash_addr.69 = monoeg_g_hash_table_new (0B, 0B);
      rgctx_lazy_fetch_trampoline_hash_addr = rgctx_lazy_fetch_trampoline_hash_addr.69;
      <D.23951>:
      rgctx_lazy_fetch_trampoline_hash.65 = rgctx_lazy_fetch_trampoline_hash;
      D.23924 = (long unsigned int) offset;
      D.23954 = (void *) D.23924;
      monoeg_g_hash_table_insert_replace (rgctx_lazy_fetch_trampoline_hash.65, D.23954, ptr, 0);
      D.23955 = offset == 4294967295;
      D.23956 = (long int) D.23955;
      D.23957 = __builtin_expect (D.23956, 0);
      if (D.23957 != 0) goto <D.23958>; else goto <D.23959>;
      <D.23958>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1521, "offset != -1");
      <D.23959>:
      rgctx_lazy_fetch_trampoline_hash_addr.70 = rgctx_lazy_fetch_trampoline_hash_addr;
      D.23961 = offset + 1;
      D.23962 = (long unsigned int) D.23961;
      D.23963 = (void *) D.23962;
      monoeg_g_hash_table_insert_replace (rgctx_lazy_fetch_trampoline_hash_addr.70, ptr, D.23963, 0);
      {
        int ret;

        ret = pthread_mutex_unlock (&trampolines_mutex.mutex);
        if (ret != 0) goto <D.23964>; else goto <D.23965>;
        <D.23964>:
        monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
        <D.23965>:
        D.23966 = ret != 0;
        D.23967 = (long int) D.23966;
        D.23968 = __builtin_expect (D.23967, 0);
        if (D.23968 != 0) goto <D.23969>; else goto <D.23970>;
        <D.23969>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1523, "ret == 0");
        <D.23970>:
      }
      inited.71 = inited;
      if (inited.71 == 0) goto <D.23972>; else goto <D.23973>;
      <D.23972>:
      mono_counters_register ("RGCTX num lazy fetch trampolines", 2048, &num_trampolines);
      inited = 1;
      <D.23973>:
      num_trampolines.72 = num_trampolines;
      num_trampolines.73 = num_trampolines.72 + 1;
      num_trampolines = num_trampolines.73;
      D.23936 = ptr;
      return D.23936;
    }
  finally
    {
      info = {CLOBBER};
    }
}


mono_create_monitor_enter_trampoline ()
{
  int mono_aot_only.74;
  void * code.75;
  void * code.76;
  void * D.23985;
  static void * code;

  mono_aot_only.74 = mono_aot_only;
  if (mono_aot_only.74 != 0) goto <D.23979>; else goto <D.23980>;
  <D.23979>:
  code.75 = code;
  if (code.75 == 0B) goto <D.23982>; else goto <D.23983>;
  <D.23982>:
  code.76 = mono_aot_get_trampoline ("monitor_enter_trampoline");
  code = code.76;
  <D.23983>:
  D.23985 = code;
  return D.23985;
  <D.23980>:
  code = 0B;
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-trampolines.c", 1559);
  D.23985 = code;
  return D.23985;
}


mono_create_monitor_exit_trampoline ()
{
  int mono_aot_only.77;
  void * code.78;
  void * code.79;
  void * D.23994;
  static void * code;

  mono_aot_only.77 = mono_aot_only;
  if (mono_aot_only.77 != 0) goto <D.23988>; else goto <D.23989>;
  <D.23988>:
  code.78 = code;
  if (code.78 == 0B) goto <D.23991>; else goto <D.23992>;
  <D.23991>:
  code.79 = mono_aot_get_trampoline ("monitor_exit_trampoline");
  code = code.79;
  <D.23992>:
  D.23994 = code;
  return D.23994;
  <D.23989>:
  code = 0B;
  monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "mini-trampolines.c", 1589);
  D.23994 = code;
  return D.23994;
}


mono_find_class_init_trampoline_by_addr (const void * addr)
{
  _Bool D.23998;
  long int D.23999;
  long int D.24000;
  struct GHashTable * class_init_hash_addr.80;
  _Bool D.24009;
  long int D.24010;
  long int D.24011;
  struct MonoVTable * D.24014;
  struct MonoVTable * res;

  {
    int ret;

    ret = pthread_mutex_lock (&trampolines_mutex.mutex);
    if (ret != 0) goto <D.23996>; else goto <D.23997>;
    <D.23996>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.23997>:
    D.23998 = ret != 0;
    D.23999 = (long int) D.23998;
    D.24000 = __builtin_expect (D.23999, 0);
    if (D.24000 != 0) goto <D.24001>; else goto <D.24002>;
    <D.24001>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1619, "ret == 0");
    <D.24002>:
  }
  class_init_hash_addr.80 = class_init_hash_addr;
  if (class_init_hash_addr.80 != 0B) goto <D.24004>; else goto <D.24005>;
  <D.24004>:
  class_init_hash_addr.80 = class_init_hash_addr;
  res = monoeg_g_hash_table_lookup (class_init_hash_addr.80, addr);
  goto <D.24006>;
  <D.24005>:
  res = 0B;
  <D.24006>:
  {
    int ret;

    ret = pthread_mutex_unlock (&trampolines_mutex.mutex);
    if (ret != 0) goto <D.24007>; else goto <D.24008>;
    <D.24007>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.24008>:
    D.24009 = ret != 0;
    D.24010 = (long int) D.24009;
    D.24011 = __builtin_expect (D.24010, 0);
    if (D.24011 != 0) goto <D.24012>; else goto <D.24013>;
    <D.24012>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1624, "ret == 0");
    <D.24013>:
  }
  D.24014 = res;
  return D.24014;
}


mono_find_rgctx_lazy_fetch_trampoline_by_addr (const void * addr)
{
  _Bool D.24018;
  long int D.24019;
  long int D.24020;
  struct GHashTable * rgctx_lazy_fetch_trampoline_hash_addr.81;
  void * D.24026;
  long int D.24027;
  _Bool D.24034;
  long int D.24035;
  long int D.24036;
  guint32 D.24039;
  int offset;

  {
    int ret;

    ret = pthread_mutex_lock (&trampolines_mutex.mutex);
    if (ret != 0) goto <D.24016>; else goto <D.24017>;
    <D.24016>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.24017>:
    D.24018 = ret != 0;
    D.24019 = (long int) D.24018;
    D.24020 = __builtin_expect (D.24019, 0);
    if (D.24020 != 0) goto <D.24021>; else goto <D.24022>;
    <D.24021>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1633, "ret == 0");
    <D.24022>:
  }
  rgctx_lazy_fetch_trampoline_hash_addr.81 = rgctx_lazy_fetch_trampoline_hash_addr;
  if (rgctx_lazy_fetch_trampoline_hash_addr.81 != 0B) goto <D.24024>; else goto <D.24025>;
  <D.24024>:
  rgctx_lazy_fetch_trampoline_hash_addr.81 = rgctx_lazy_fetch_trampoline_hash_addr;
  D.24026 = monoeg_g_hash_table_lookup (rgctx_lazy_fetch_trampoline_hash_addr.81, addr);
  D.24027 = (long int) D.24026;
  offset = (int) D.24027;
  if (offset != 0) goto <D.24028>; else goto <D.24029>;
  <D.24028>:
  offset = offset + -1;
  goto <D.24030>;
  <D.24029>:
  offset = -1;
  <D.24030>:
  goto <D.24031>;
  <D.24025>:
  offset = -1;
  <D.24031>:
  {
    int ret;

    ret = pthread_mutex_unlock (&trampolines_mutex.mutex);
    if (ret != 0) goto <D.24032>; else goto <D.24033>;
    <D.24032>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.24033>:
    D.24034 = ret != 0;
    D.24035 = (long int) D.24034;
    D.24036 = __builtin_expect (D.24035, 0);
    if (D.24036 != 0) goto <D.24037>; else goto <D.24038>;
    <D.24037>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mini-trampolines.c", 1644, "ret == 0");
    <D.24038>:
  }
  D.24039 = (guint32) offset;
  return D.24039;
}


mono_get_generic_trampoline_name (MonoTrampolineType tramp_type)
{
  char * D.24041;
  const char * D.24042;

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


mono_get_rgctx_fetch_trampoline_name (int slot)
{
  _Bool D.24044;
  char * D.24045;
  const char * iftmp.82;
  gboolean mrgctx;
  int index;

  D.24044 = slot < 0;
  mrgctx = (gboolean) D.24044;
  index = slot & 2147483647;
  if (mrgctx != 0) goto <D.24047>; else goto <D.24048>;
  <D.24047>:
  iftmp.82 = "mrgctx";
  goto <D.24049>;
  <D.24048>:
  iftmp.82 = "rgctx";
  <D.24049>:
  D.24045 = monoeg_g_strdup_printf ("rgctx_fetch_trampoline_%s_%d", iftmp.82, index);
  return D.24045;
}


mini_get_nullified_class_init_trampoline ()
{
  void * nullified_class_init_trampoline.83;
  int mono_aot_only.84;
  struct MonoTrampInfo * info.85;
  void * D.24059;
  static void * nullified_class_init_trampoline;

  nullified_class_init_trampoline.83 = nullified_class_init_trampoline;
  if (nullified_class_init_trampoline.83 == 0B) goto <D.24052>; else goto <D.24053>;
  <D.24052>:
  {
    void * tramp;
    struct MonoTrampInfo * info;

    try
      {
        mono_aot_only.84 = mono_aot_only;
        if (mono_aot_only.84 != 0) goto <D.24055>; else goto <D.24056>;
        <D.24055>:
        tramp = mono_aot_get_trampoline ("nullified_class_init_trampoline");
        goto <D.24057>;
        <D.24056>:
        tramp = mono_arch_get_nullified_class_init_trampoline (&info);
        info.85 = info;
        mono_tramp_info_register (info.85);
        <D.24057>:
        mono_memory_barrier ();
        nullified_class_init_trampoline = tramp;
      }
    finally
      {
        info = {CLOBBER};
      }
  }
  <D.24053>:
  D.24059 = nullified_class_init_trampoline;
  return D.24059;
}


mono_memory_barrier ()
{
  __sync_synchronize ();
}