mono_gc_wait_for_bridge_processing ()
{
  int bridge_processing_in_progress.0;

  bridge_processing_in_progress.0 = bridge_processing_in_progress;
  if (bridge_processing_in_progress.0 == 0) goto <D.17724>; else goto <D.17725>;
  <D.17724>:
  return;
  <D.17725>:
  mono_trace (64, 8, "GC_BRIDGE waiting for bridge processing to finish");
  sgen_gc_lock ();
  sgen_gc_unlock ();
}


mono_gc_register_bridge_callbacks (struct MonoGCBridgeCallbacks * callbacks)
{
  int D.17727;

  D.17727 = callbacks->bridge_version;
  if (D.17727 != 3) goto <D.17728>; else goto <D.17729>;
  <D.17728>:
  D.17727 = callbacks->bridge_version;
  monoeg_g_log (0B, 4, "Invalid bridge callback version. Expected %d but got %d\n", 3, D.17727);
  <D.17309>:
  goto <D.17309>;
  <D.17729>:
  bridge_callbacks = *callbacks;
}


sgen_is_bridge_object (struct MonoObject * obj)
{
  struct MonoVTable * D.17730;
  <unnamed-unsigned:4> D.17731;
  int D.17732;
  int D.17733;
  gboolean D.17736;
  mono_bool (*<T2e32>) (struct MonoObject *) D.17737;

  D.17730 = obj->vtable;
  D.17731 = D.17730->gc_bits;
  D.17732 = (int) D.17731;
  D.17733 = D.17732 & 1;
  if (D.17733 == 0) goto <D.17734>; else goto <D.17735>;
  <D.17734>:
  D.17736 = 0;
  return D.17736;
  <D.17735>:
  D.17737 = bridge_callbacks.is_bridge_object;
  D.17736 = D.17737 (obj);
  return D.17736;
}


sgen_is_bridge_class (struct MonoClass * class)
{
  gboolean D.17739;
  mono_bool (*<T2e2e>) (struct MonoClass *) D.17740;

  D.17740 = bridge_callbacks.is_bridge_class;
  D.17739 = D.17740 (class);
  return D.17739;
}


sgen_need_bridge_processing ()
{
  gboolean D.17742;
  void (*<T2e3c>) (int, struct MonoGCBridgeSCC * *, int, struct MonoGCBridgeXRef *) D.17743;
  _Bool D.17744;

  D.17743 = bridge_callbacks.cross_references;
  D.17744 = D.17743 != 0B;
  D.17742 = (gboolean) D.17744;
  return D.17742;
}


sgen_bridge_register_finalized_object (struct MonoObject * obj)
{
  int D.17746;
  _Bool D.17747;
  long int D.17748;
  long int D.17749;

  D.17746 = sgen_need_bridge_processing ();
  D.17747 = D.17746 == 0;
  D.17748 = (long int) D.17747;
  D.17749 = __builtin_expect (D.17748, 0);
  if (D.17749 != 0) goto <D.17750>; else goto <D.17751>;
  <D.17750>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-bridge.c", 537, "sgen_need_bridge_processing ()");
  <D.17751>:
  dyn_array_ptr_add (&registered_bridges, obj);
}


dyn_array_ptr_add (struct DynArray * da, void * ptr)
{
  void * * p;

  p = dyn_array_add (da);
  *p = ptr;
}


dyn_array_add (struct DynArray * da)
{
  int D.17752;
  int D.17753;
  char * D.17754;
  int D.17755;
  int D.17756;
  sizetype D.17757;
  void * D.17758;
  void * p;

  D.17752 = da->size;
  D.17753 = D.17752 + 1;
  dyn_array_ensure_capacity (da, D.17753);
  D.17754 = da->data;
  D.17752 = da->size;
  D.17755 = da->elem_size;
  D.17756 = D.17752 * D.17755;
  D.17757 = (sizetype) D.17756;
  p = D.17754 + D.17757;
  D.17752 = da->size;
  D.17753 = D.17752 + 1;
  da->size = D.17753;
  D.17758 = p;
  return D.17758;
}


dyn_array_ensure_capacity (struct DynArray * da, int capacity)
{
  int D.17762;
  int D.17765;
  int D.17766;
  int D.17767;
  unsigned int D.17768;
  int D.17769;
  int D.17770;
  unsigned int D.17771;
  char * D.17772;
  int D.17773;
  unsigned int D.17774;
  int old_capacity;
  char * new_data;

  old_capacity = da->capacity;
  if (capacity <= old_capacity) goto <D.17760>; else goto <D.17761>;
  <D.17760>:
  return;
  <D.17761>:
  D.17762 = da->capacity;
  if (D.17762 == 0) goto <D.17763>; else goto <D.17764>;
  <D.17763>:
  da->capacity = 2;
  <D.17764>:
  goto <D.17232>;
  <D.17231>:
  D.17762 = da->capacity;
  D.17765 = D.17762 * 2;
  da->capacity = D.17765;
  <D.17232>:
  D.17762 = da->capacity;
  if (D.17762 < capacity) goto <D.17231>; else goto <D.17233>;
  <D.17233>:
  D.17766 = da->elem_size;
  D.17762 = da->capacity;
  D.17767 = D.17766 * D.17762;
  D.17768 = (unsigned int) D.17767;
  new_data = sgen_alloc_internal_dynamic (D.17768, 21, 1);
  D.17766 = da->elem_size;
  D.17769 = da->size;
  D.17770 = D.17766 * D.17769;
  D.17771 = (unsigned int) D.17770;
  D.17772 = da->data;
  memcpy (new_data, D.17772, D.17771);
  D.17766 = da->elem_size;
  D.17773 = D.17766 * old_capacity;
  D.17774 = (unsigned int) D.17773;
  D.17772 = da->data;
  sgen_free_internal_dynamic (D.17772, D.17774, 21);
  da->data = new_data;
}


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

  D.17777 = __builtin_object_size (__dest, 0);
  D.17776 = __builtin___memcpy_chk (__dest, __src, __len, D.17777);
  return D.17776;
}


sgen_bridge_reset_data ()
{
  registered_bridges.size = 0;
}


sgen_bridge_processing_stw_step ()
{
  int D.17779;
  char * D.17782;
  unsigned int i.1;
  unsigned int D.17784;
  void * * D.17785;
  void * D.17786;
  struct HashEntry * D.17787;
  long long int D.17788;
  long long int D.17789;
  long unsigned int step_2.2;
  int i;
  gint64 atv;
  gint64 btv;

  D.17779 = registered_bridges.size;
  if (D.17779 == 0) goto <D.17780>; else goto <D.17781>;
  <D.17780>:
  return;
  <D.17781>:
  bridge_processing_in_progress = 1;
  btv = mono_100ns_ticks ();
  dyn_array_ptr_init (&dfs_stack);
  dyn_array_int_init (&merge_array);
  current_time = 0;
  i = 0;
  goto <D.17527>;
  <D.17526>:
  D.17782 = registered_bridges.data;
  i.1 = (unsigned int) i;
  D.17784 = i.1 * 4;
  D.17785 = D.17782 + D.17784;
  D.17786 = *D.17785;
  register_bridge_object (D.17786);
  i = i + 1;
  <D.17527>:
  D.17779 = registered_bridges.size;
  if (D.17779 > i) goto <D.17526>; else goto <D.17528>;
  <D.17528>:
  i = 0;
  goto <D.17530>;
  <D.17529>:
  D.17782 = registered_bridges.data;
  i.1 = (unsigned int) i;
  D.17784 = i.1 * 4;
  D.17785 = D.17782 + D.17784;
  D.17786 = *D.17785;
  D.17787 = get_hash_entry (D.17786, 0B);
  dfs1 (D.17787, 0B);
  i = i + 1;
  <D.17530>:
  D.17779 = registered_bridges.size;
  if (D.17779 > i) goto <D.17529>; else goto <D.17531>;
  <D.17531>:
  atv = mono_100ns_ticks ();
  D.17788 = atv - btv;
  D.17789 = D.17788 / 10;
  step_2.2 = (long unsigned int) D.17789;
  step_2 = step_2.2;
}


dyn_array_ptr_init (struct DynArray * da)
{
  dyn_array_init (da, 4);
}


dyn_array_init (struct DynArray * da, int elem_size)
{
  da->size = 0;
  da->elem_size = elem_size;
  da->capacity = 0;
  da->data = 0B;
}


dyn_array_int_init (struct DynArray * da)
{
  dyn_array_init (da, 4);
}


register_bridge_object (struct MonoObject * obj)
{
  struct HashEntry * D.17792;
  struct HashEntry * entry;

  entry = get_hash_entry (obj, 0B);
  entry->is_bridge = 1;
  D.17792 = entry;
  return D.17792;
}


get_hash_entry (struct MonoObject * obj, gboolean * existing)
{
  struct HashEntry * D.17798;
  struct HashEntry * entry;
  struct HashEntry new_entry;

  try
    {
      entry = sgen_hash_table_lookup (&hash_table, obj);
      if (entry != 0B) goto <D.17794>; else goto <D.17795>;
      <D.17794>:
      if (existing != 0B) goto <D.17796>; else goto <D.17797>;
      <D.17796>:
      *existing = 1;
      <D.17797>:
      D.17798 = entry;
      return D.17798;
      <D.17795>:
      if (existing != 0B) goto <D.17799>; else goto <D.17800>;
      <D.17799>:
      *existing = 0;
      <D.17800>:
      memset (&new_entry, 0, 36);
      new_entry.obj = obj;
      dyn_array_ptr_init (&new_entry.srcs);
      new_entry.finishing_time = -1;
      new_entry.scc_index = -1;
      sgen_hash_table_replace (&hash_table, obj, &new_entry, 0B);
      D.17798 = sgen_hash_table_lookup (&hash_table, obj);
      return D.17798;
    }
  finally
    {
      new_entry = {CLOBBER};
    }
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.17805;
  int D.17810;
  void * D.17812;
  unsigned int D.17813;

  D.17805 = __builtin_constant_p (__len);
  if (D.17805 != 0) goto <D.17806>; else goto <D.17807>;
  <D.17806>:
  if (__len == 0) goto <D.17808>; else goto <D.17809>;
  <D.17808>:
  D.17810 = __builtin_constant_p (__ch);
  if (D.17810 == 0) goto <D.17803>; else goto <D.17811>;
  <D.17811>:
  if (__ch != 0) goto <D.17803>; else goto <D.17804>;
  <D.17803>:
  __warn_memset_zero_len ();
  D.17812 = __dest;
  return D.17812;
  <D.17804>:
  <D.17809>:
  <D.17807>:
  D.17813 = __builtin_object_size (__dest, 0);
  D.17812 = __builtin___memset_chk (__dest, __ch, __len, D.17813);
  return D.17812;
}


dfs1 (struct HashEntry * obj_entry, struct HashEntry * src)
{
  int D.17815;
  _Bool D.17816;
  long int D.17817;
  long int D.17818;
  int dsf1_passes.3;
  int dsf1_passes.4;
  int D.17828;
  unsigned int D.17831;
  unsigned int D.17832;
  unsigned int D.17833;
  unsigned int D.17834;
  unsigned int D.17837;
  unsigned int D.17838;
  unsigned int D.17839;
  unsigned int D.17840;
  unsigned int D.17841;
  void * dst.5;
  struct MonoObject * dst.6;
  int D.17846;
  struct HashEntry * D.17849;
  struct MonoObject * dst.7;
  int D.17853;
  struct HashEntry * D.17856;
  unsigned int _index.8;
  unsigned int D.17858;
  int D.17859;
  void * dst.9;
  struct MonoObject * dst.10;
  int D.17864;
  struct HashEntry * D.17867;
  unsigned int _index.11;
  unsigned int D.17869;
  int D.17870;
  struct MonoObject * dst.12;
  int D.17874;
  struct HashEntry * D.17877;
  unsigned int D.17878;
  unsigned int D.17881;
  int D.17882;
  int desc.13;
  unsigned int D.17886;
  unsigned int el_size.14;
  unsigned int D.17888;
  void * dst.15;
  struct MonoObject * dst.16;
  int D.17893;
  struct HashEntry * D.17896;
  int D.17900;
  unsigned int offset.17;
  unsigned int D.17902;
  unsigned int i.18;
  unsigned int D.17904;
  void * * D.17905;
  void * dst.19;
  struct MonoObject * dst.20;
  int D.17910;
  struct HashEntry * D.17913;
  sizetype el_size.21;
  unsigned int D.17918;
  void * dst.22;
  struct MonoObject * dst.23;
  int D.17925;
  struct HashEntry * D.17928;
  unsigned int D.17929;
  void * dst.24;
  struct MonoObject * dst.25;
  int D.17936;
  struct HashEntry * D.17939;
  unsigned int D.17940;
  unsigned int D.17941;
  struct MonoVTable * D.17944;
  struct MonoClass * D.17945;
  const char * D.17946;
  const char * D.17947;
  gsize * bitmap_data.26;
  unsigned int D.17949;
  void * dst.27;
  struct MonoObject * dst.28;
  int D.17956;
  struct HashEntry * D.17959;
  int bwords.29;
  unsigned int D.17961;
  gsize * mbitmap_data.30;
  unsigned int D.17963;
  unsigned int D.17964;
  struct MonoClass * D.17965;
  unsigned int el_size.31;
  unsigned int D.17967;
  const char * D.17970;
  const char * D.17971;
  gsize * bitmap_data.32;
  unsigned int D.17973;
  void * dst.33;
  struct MonoObject * dst.34;
  int D.17980;
  struct HashEntry * D.17983;
  unsigned int bwords.35;
  sizetype el_size.36;
  int current_time.37;
  int current_time.38;
  int current_time.39;

  D.17815 = dfs_stack.size;
  D.17816 = D.17815 != 0;
  D.17817 = (long int) D.17816;
  D.17818 = __builtin_expect (D.17817, 0);
  if (D.17818 != 0) goto <D.17819>; else goto <D.17820>;
  <D.17819>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-bridge.c", 423, "dfs_stack.size == 0");
  <D.17820>:
  dyn_array_ptr_add (&dfs_stack, src);
  dyn_array_ptr_add (&dfs_stack, obj_entry);
  <D.17470>:
  {
    struct MonoObject * obj;
    char * start;

    dsf1_passes.3 = dsf1_passes;
    dsf1_passes.4 = dsf1_passes.3 + 1;
    dsf1_passes = dsf1_passes.4;
    obj_entry = dyn_array_ptr_pop (&dfs_stack);
    if (obj_entry != 0B) goto <D.17823>; else goto <D.17824>;
    <D.17823>:
    src = dyn_array_ptr_pop (&dfs_stack);
    obj = obj_entry->obj;
    start = obj;
    if (src != 0B) goto <D.17825>; else goto <D.17826>;
    <D.17825>:
    add_source (obj_entry, src);
    goto <D.17827>;
    <D.17826>:
    <D.17827>:
    D.17828 = obj_entry->is_visited;
    if (D.17828 != 0) goto <D.17829>; else goto <D.17830>;
    <D.17829>:
    // predicted unlikely by continue predictor.
    goto <D.17371>;
    <D.17830>:
    obj_entry->is_visited = 1;
    dyn_array_ptr_add (&dfs_stack, obj_entry);
    dyn_array_ptr_add (&dfs_stack, 0B);
    {
      struct GCVTable * vt;
      mword desc;

      D.17831 = MEM[(mword *)start];
      D.17832 = D.17831 & 4294967292;
      vt = (struct GCVTable *) D.17832;
      desc = vt->desc;
      D.17833 = desc & 7;
      switch (D.17833) <default: <D.17469>, case 1: <D.17374>, case 2: <D.17383>, case 3: <D.17433>, case 4: <D.17393>, case 5: <D.17426>, case 6: <D.17447>, case 7: <D.17468>>
      <D.17374>:
      D.17834 = desc & 4294901760;
      if (D.17834 != 0) goto <D.17835>; else goto <D.17836>;
      <D.17835>:
      {
        void * * _objptr_end;
        void * * _objptr;

        _objptr = start;
        D.17837 = desc >> 16;
        D.17838 = D.17837 & 255;
        D.17839 = D.17838 * 4;
        _objptr = _objptr + D.17839;
        D.17840 = desc >> 24;
        D.17841 = D.17840 * 4;
        _objptr_end = _objptr + D.17841;
        {
          struct MonoObject * dst;

          try
            {
              dst.5 = *_objptr;
              dst = dst.5;
              dst.6 = dst;
              if (dst.6 != 0B) goto <D.17844>; else goto <D.17845>;
              <D.17844>:
              D.17846 = object_is_live (&dst);
              if (D.17846 == 0) goto <D.17847>; else goto <D.17848>;
              <D.17847>:
              dyn_array_ptr_add (&dfs_stack, obj_entry);
              dst.6 = dst;
              D.17849 = get_hash_entry (dst.6, 0B);
              dyn_array_ptr_add (&dfs_stack, D.17849);
              <D.17848>:
              <D.17845>:
            }
          finally
            {
              dst = {CLOBBER};
            }
        }
        _objptr = _objptr + 4;
        goto <D.17380>;
        <D.17379>:
        {
          struct MonoObject * dst;

          try
            {
              dst.5 = *_objptr;
              dst = dst.5;
              dst.7 = dst;
              if (dst.7 != 0B) goto <D.17851>; else goto <D.17852>;
              <D.17851>:
              D.17853 = object_is_live (&dst);
              if (D.17853 == 0) goto <D.17854>; else goto <D.17855>;
              <D.17854>:
              dyn_array_ptr_add (&dfs_stack, obj_entry);
              dst.7 = dst;
              D.17856 = get_hash_entry (dst.7, 0B);
              dyn_array_ptr_add (&dfs_stack, D.17856);
              <D.17855>:
              <D.17852>:
            }
          finally
            {
              dst = {CLOBBER};
            }
        }
        _objptr = _objptr + 4;
        <D.17380>:
        if (_objptr < _objptr_end) goto <D.17379>; else goto <D.17381>;
        <D.17381>:
      }
      <D.17836>:
      goto <D.17382>;
      <D.17383>:
      {
        void * * _objptr;
        gsize _bmap;

        _objptr = start;
        _bmap = desc >> 16;
        _objptr = _objptr + 8;
        {
          int _index;

          _index = __builtin_ctz (_bmap);
          _index.8 = (unsigned int) _index;
          D.17858 = _index.8 * 4;
          _objptr = _objptr + D.17858;
          D.17859 = _index + 1;
          _bmap = _bmap >> D.17859;
          {
            struct MonoObject * dst;

            try
              {
                dst.9 = *_objptr;
                dst = dst.9;
                dst.10 = dst;
                if (dst.10 != 0B) goto <D.17862>; else goto <D.17863>;
                <D.17862>:
                D.17864 = object_is_live (&dst);
                if (D.17864 == 0) goto <D.17865>; else goto <D.17866>;
                <D.17865>:
                dyn_array_ptr_add (&dfs_stack, obj_entry);
                dst.10 = dst;
                D.17867 = get_hash_entry (dst.10, 0B);
                dyn_array_ptr_add (&dfs_stack, D.17867);
                <D.17866>:
                <D.17863>:
              }
            finally
              {
                dst = {CLOBBER};
              }
          }
          _objptr = _objptr + 4;
        }
        goto <D.17391>;
        <D.17390>:
        {
          int _index;

          _index = __builtin_ctz (_bmap);
          _index.11 = (unsigned int) _index;
          D.17869 = _index.11 * 4;
          _objptr = _objptr + D.17869;
          D.17870 = _index + 1;
          _bmap = _bmap >> D.17870;
          {
            struct MonoObject * dst;

            try
              {
                dst.9 = *_objptr;
                dst = dst.9;
                dst.12 = dst;
                if (dst.12 != 0B) goto <D.17872>; else goto <D.17873>;
                <D.17872>:
                D.17874 = object_is_live (&dst);
                if (D.17874 == 0) goto <D.17875>; else goto <D.17876>;
                <D.17875>:
                dyn_array_ptr_add (&dfs_stack, obj_entry);
                dst.12 = dst;
                D.17877 = get_hash_entry (dst.12, 0B);
                dyn_array_ptr_add (&dfs_stack, D.17877);
                <D.17876>:
                <D.17873>:
              }
            finally
              {
                dst = {CLOBBER};
              }
          }
          _objptr = _objptr + 4;
        }
        <D.17391>:
        if (_bmap != 0) goto <D.17390>; else goto <D.17392>;
        <D.17392>:
      }
      goto <D.17382>;
      <D.17393>:
      D.17878 = desc & 4294950912;
      if (D.17878 != 0) goto <D.17879>; else goto <D.17880>;
      <D.17879>:
      {
        int el_size;
        int etype;

        D.17881 = desc >> 3;
        D.17882 = (int) D.17881;
        el_size = D.17882 & 1023;
        desc.13 = (int) desc;
        etype = desc.13 & 49152;
        if (etype == 16384) goto <D.17884>; else goto <D.17885>;
        <D.17884>:
        {
          void * * p;
          void * * end_refs;

          p = start + 16;
          D.17886 = MEM[(struct MonoArray *)start].max_length;
          el_size.14 = (unsigned int) el_size;
          D.17888 = D.17886 * el_size.14;
          end_refs = p + D.17888;
          goto <D.17400>;
          <D.17399>:
          {
            struct MonoObject * dst;

            try
              {
                dst.15 = *p;
                dst = dst.15;
                dst.16 = dst;
                if (dst.16 != 0B) goto <D.17891>; else goto <D.17892>;
                <D.17891>:
                D.17893 = object_is_live (&dst);
                if (D.17893 == 0) goto <D.17894>; else goto <D.17895>;
                <D.17894>:
                dyn_array_ptr_add (&dfs_stack, obj_entry);
                dst.16 = dst;
                D.17896 = get_hash_entry (dst.16, 0B);
                dyn_array_ptr_add (&dfs_stack, D.17896);
                <D.17895>:
                <D.17892>:
              }
            finally
              {
                dst = {CLOBBER};
              }
          }
          p = p + 4;
          <D.17400>:
          if (p < end_refs) goto <D.17399>; else goto <D.17401>;
          <D.17401>:
        }
        goto <D.17897>;
        <D.17885>:
        if (etype == 32768) goto <D.17898>; else goto <D.17899>;
        <D.17898>:
        {
          int offset;
          int num_refs;
          char * e_start;
          char * e_end;

          D.17837 = desc >> 16;
          D.17900 = (int) D.17837;
          offset = D.17900 & 255;
          D.17840 = desc >> 24;
          num_refs = (int) D.17840;
          e_start = start + 16;
          D.17886 = MEM[(struct MonoArray *)start].max_length;
          el_size.14 = (unsigned int) el_size;
          D.17888 = D.17886 * el_size.14;
          e_end = e_start + D.17888;
          goto <D.17413>;
          <D.17412>:
          {
            void * * p;
            int i;

            p = e_start;
            offset.17 = (unsigned int) offset;
            D.17902 = offset.17 * 4;
            p = p + D.17902;
            i = 0;
            goto <D.17410>;
            <D.17409>:
            {
              struct MonoObject * dst;

              try
                {
                  i.18 = (unsigned int) i;
                  D.17904 = i.18 * 4;
                  D.17905 = p + D.17904;
                  dst.19 = *D.17905;
                  dst = dst.19;
                  dst.20 = dst;
                  if (dst.20 != 0B) goto <D.17908>; else goto <D.17909>;
                  <D.17908>:
                  D.17910 = object_is_live (&dst);
                  if (D.17910 == 0) goto <D.17911>; else goto <D.17912>;
                  <D.17911>:
                  dyn_array_ptr_add (&dfs_stack, obj_entry);
                  dst.20 = dst;
                  D.17913 = get_hash_entry (dst.20, 0B);
                  dyn_array_ptr_add (&dfs_stack, D.17913);
                  <D.17912>:
                  <D.17909>:
                }
              finally
                {
                  dst = {CLOBBER};
                }
            }
            i = i + 1;
            <D.17410>:
            if (i < num_refs) goto <D.17409>; else goto <D.17411>;
            <D.17411>:
            el_size.21 = (sizetype) el_size;
            e_start = e_start + el_size.21;
          }
          <D.17413>:
          if (e_start < e_end) goto <D.17412>; else goto <D.17414>;
          <D.17414>:
        }
        goto <D.17915>;
        <D.17899>:
        if (etype == 49152) goto <D.17916>; else goto <D.17917>;
        <D.17916>:
        {
          char * e_start;
          char * e_end;

          e_start = start + 16;
          D.17886 = MEM[(struct MonoArray *)start].max_length;
          el_size.14 = (unsigned int) el_size;
          D.17888 = D.17886 * el_size.14;
          e_end = e_start + D.17888;
          goto <D.17424>;
          <D.17423>:
          {
            void * * p;
            gsize _bmap;

            p = e_start;
            _bmap = desc >> 16;
            goto <D.17421>;
            <D.17420>:
            D.17918 = _bmap & 1;
            if (D.17918 != 0) goto <D.17919>; else goto <D.17920>;
            <D.17919>:
            {
              struct MonoObject * dst;

              try
                {
                  dst.22 = *p;
                  dst = dst.22;
                  dst.23 = dst;
                  if (dst.23 != 0B) goto <D.17923>; else goto <D.17924>;
                  <D.17923>:
                  D.17925 = object_is_live (&dst);
                  if (D.17925 == 0) goto <D.17926>; else goto <D.17927>;
                  <D.17926>:
                  dyn_array_ptr_add (&dfs_stack, obj_entry);
                  dst.23 = dst;
                  D.17928 = get_hash_entry (dst.23, 0B);
                  dyn_array_ptr_add (&dfs_stack, D.17928);
                  <D.17927>:
                  <D.17924>:
                }
              finally
                {
                  dst = {CLOBBER};
                }
            }
            <D.17920>:
            _bmap = _bmap >> 1;
            p = p + 4;
            <D.17421>:
            if (_bmap != 0) goto <D.17420>; else goto <D.17422>;
            <D.17422>:
            el_size.21 = (sizetype) el_size;
            e_start = e_start + el_size.21;
          }
          <D.17424>:
          if (e_start < e_end) goto <D.17423>; else goto <D.17425>;
          <D.17425>:
        }
        <D.17917>:
        <D.17915>:
        <D.17897>:
      }
      <D.17880>:
      goto <D.17382>;
      <D.17426>:
      {
        void * * _objptr;
        gsize _bmap;

        _objptr = start;
        _bmap = desc >> 3;
        _objptr = _objptr + 8;
        goto <D.17431>;
        <D.17430>:
        D.17929 = _bmap & 1;
        if (D.17929 != 0) goto <D.17930>; else goto <D.17931>;
        <D.17930>:
        {
          struct MonoObject * dst;

          try
            {
              dst.24 = *_objptr;
              dst = dst.24;
              dst.25 = dst;
              if (dst.25 != 0B) goto <D.17934>; else goto <D.17935>;
              <D.17934>:
              D.17936 = object_is_live (&dst);
              if (D.17936 == 0) goto <D.17937>; else goto <D.17938>;
              <D.17937>:
              dyn_array_ptr_add (&dfs_stack, obj_entry);
              dst.25 = dst;
              D.17939 = get_hash_entry (dst.25, 0B);
              dyn_array_ptr_add (&dfs_stack, D.17939);
              <D.17938>:
              <D.17935>:
            }
          finally
            {
              dst = {CLOBBER};
            }
        }
        <D.17931>:
        _bmap = _bmap >> 1;
        _objptr = _objptr + 4;
        <D.17431>:
        if (_bmap != 0) goto <D.17430>; else goto <D.17432>;
        <D.17432>:
      }
      goto <D.17382>;
      <D.17433>:
      {
        void * * _objptr;
        gsize * bitmap_data;
        int bwords;
        void * * start_run;

        _objptr = start;
        bitmap_data = sgen_get_complex_descriptor (desc);
        D.17940 = *bitmap_data;
        D.17941 = D.17940 + 4294967295;
        bwords = (int) D.17941;
        start_run = _objptr;
        bitmap_data = bitmap_data + 4;
        if (0 != 0) goto <D.17942>; else goto <D.17943>;
        <D.17942>:
        {
          struct MonoObject * myobj;

          myobj = start;
          D.17944 = myobj->vtable;
          D.17945 = D.17944->klass;
          D.17946 = D.17945->name;
          D.17944 = myobj->vtable;
          D.17945 = D.17944->klass;
          D.17947 = D.17945->name_space;
          monoeg_g_print ("found %d at %p (0x%zx): %s.%s\n", bwords, start, desc, D.17947, D.17946);
        }
        <D.17943>:
        goto <D.17445>;
        <D.17444>:
        {
          gsize _bmap;

          bitmap_data.26 = bitmap_data;
          bitmap_data = bitmap_data.26 + 4;
          _bmap = *bitmap_data.26;
          _objptr = start_run;
          goto <D.17442>;
          <D.17441>:
          D.17949 = _bmap & 1;
          if (D.17949 != 0) goto <D.17950>; else goto <D.17951>;
          <D.17950>:
          {
            struct MonoObject * dst;

            try
              {
                dst.27 = *_objptr;
                dst = dst.27;
                dst.28 = dst;
                if (dst.28 != 0B) goto <D.17954>; else goto <D.17955>;
                <D.17954>:
                D.17956 = object_is_live (&dst);
                if (D.17956 == 0) goto <D.17957>; else goto <D.17958>;
                <D.17957>:
                dyn_array_ptr_add (&dfs_stack, obj_entry);
                dst.28 = dst;
                D.17959 = get_hash_entry (dst.28, 0B);
                dyn_array_ptr_add (&dfs_stack, D.17959);
                <D.17958>:
                <D.17955>:
              }
            finally
              {
                dst = {CLOBBER};
              }
          }
          <D.17951>:
          _bmap = _bmap >> 1;
          _objptr = _objptr + 4;
          <D.17442>:
          if (_bmap != 0) goto <D.17441>; else goto <D.17443>;
          <D.17443>:
          start_run = start_run + 128;
        }
        <D.17445>:
        bwords.29 = bwords;
        bwords = bwords.29 + -1;
        if (bwords.29 > 0) goto <D.17444>; else goto <D.17446>;
        <D.17446>:
      }
      goto <D.17382>;
      <D.17447>:
      {
        gsize * mbitmap_data;
        int mbwords;
        int el_size;
        char * e_start;
        char * e_end;

        D.17961 = vt->desc;
        mbitmap_data = sgen_get_complex_descriptor (D.17961);
        mbitmap_data.30 = mbitmap_data;
        mbitmap_data = mbitmap_data.30 + 4;
        D.17963 = *mbitmap_data.30;
        D.17964 = D.17963 + 4294967295;
        mbwords = (int) D.17964;
        D.17965 = vt->klass;
        el_size = mono_array_element_size (D.17965);
        e_start = start + 16;
        D.17886 = MEM[(struct MonoArray *)start].max_length;
        el_size.31 = (unsigned int) el_size;
        D.17967 = D.17886 * el_size.31;
        e_end = e_start + D.17967;
        if (0 != 0) goto <D.17968>; else goto <D.17969>;
        <D.17968>:
        D.17965 = vt->klass;
        D.17970 = D.17965->name;
        D.17965 = vt->klass;
        D.17971 = D.17965->name_space;
        D.17961 = vt->desc;
        monoeg_g_print ("found %d at %p (0x%zx): %s.%s\n", mbwords, start, D.17961, D.17971, D.17970);
        <D.17969>:
        goto <D.17466>;
        <D.17465>:
        {
          void * * _objptr;
          gsize * bitmap_data;
          unsigned int bwords;

          _objptr = e_start;
          bitmap_data = mbitmap_data;
          bwords = (unsigned int) mbwords;
          goto <D.17463>;
          <D.17462>:
          {
            gsize _bmap;
            void * * start_run;

            bitmap_data.32 = bitmap_data;
            bitmap_data = bitmap_data.32 + 4;
            _bmap = *bitmap_data.32;
            start_run = _objptr;
            goto <D.17460>;
            <D.17459>:
            D.17973 = _bmap & 1;
            if (D.17973 != 0) goto <D.17974>; else goto <D.17975>;
            <D.17974>:
            {
              struct MonoObject * dst;

              try
                {
                  dst.33 = *_objptr;
                  dst = dst.33;
                  dst.34 = dst;
                  if (dst.34 != 0B) goto <D.17978>; else goto <D.17979>;
                  <D.17978>:
                  D.17980 = object_is_live (&dst);
                  if (D.17980 == 0) goto <D.17981>; else goto <D.17982>;
                  <D.17981>:
                  dyn_array_ptr_add (&dfs_stack, obj_entry);
                  dst.34 = dst;
                  D.17983 = get_hash_entry (dst.34, 0B);
                  dyn_array_ptr_add (&dfs_stack, D.17983);
                  <D.17982>:
                  <D.17979>:
                }
              finally
                {
                  dst = {CLOBBER};
                }
            }
            <D.17975>:
            _bmap = _bmap >> 1;
            _objptr = _objptr + 4;
            <D.17460>:
            if (_bmap != 0) goto <D.17459>; else goto <D.17461>;
            <D.17461>:
            _objptr = start_run + 128;
          }
          <D.17463>:
          bwords.35 = bwords;
          bwords = bwords.35 + 4294967295;
          if (bwords.35 != 0) goto <D.17462>; else goto <D.17464>;
          <D.17464>:
          el_size.36 = (sizetype) el_size;
          e_start = e_start + el_size.36;
        }
        <D.17466>:
        if (e_start < e_end) goto <D.17465>; else goto <D.17467>;
        <D.17467>:
      }
      goto <D.17382>;
      <D.17468>:
      goto <D.17382>;
      <D.17469>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "sgen-scan-object.h", 111);
      <D.17382>:
    }
    goto <D.17986>;
    <D.17824>:
    obj_entry = dyn_array_ptr_pop (&dfs_stack);
    current_time.37 = current_time;
    current_time.38 = current_time.37;
    current_time.39 = current_time.38 + 1;
    current_time = current_time.39;
    register_finishing_time (obj_entry, current_time.38);
    <D.17986>:
  }
  <D.17371>:
  D.17815 = dfs_stack.size;
  if (D.17815 > 0) goto <D.17470>; else goto <D.17471>;
  <D.17471>:
}


add_source (struct HashEntry * entry, struct HashEntry * src)
{
  struct DynArray * D.17992;

  D.17992 = &entry->srcs;
  dyn_array_ptr_add (D.17992, src);
}


object_is_live (struct MonoObject * * objp)
{
  struct MonoObject * iftmp.40;
  unsigned int D.17994;
  unsigned int D.17995;
  unsigned int D.17998;
  gboolean D.18002;
  void * D.18003;
  _Bool D.18004;
  int D.18005;
  void * D.18008;
  _Bool D.18009;
  struct MonoObject * obj;
  struct MonoObject * fwd;

  obj = *objp;
  D.17994 = MEM[(mword *)obj];
  D.17995 = D.17994 & 1;
  if (D.17995 != 0) goto <D.17996>; else goto <D.17997>;
  <D.17996>:
  D.17994 = MEM[(mword *)obj];
  D.17998 = D.17994 & 4294967292;
  iftmp.40 = (struct MonoObject *) D.17998;
  goto <D.17999>;
  <D.17997>:
  iftmp.40 = 0B;
  <D.17999>:
  fwd = iftmp.40;
  if (fwd != 0B) goto <D.18000>; else goto <D.18001>;
  <D.18000>:
  *objp = fwd;
  D.18003 = sgen_hash_table_lookup (&hash_table, fwd);
  D.18004 = D.18003 == 0B;
  D.18002 = (gboolean) D.18004;
  return D.18002;
  <D.18001>:
  D.18005 = sgen_object_is_live (obj);
  if (D.18005 == 0) goto <D.18006>; else goto <D.18007>;
  <D.18006>:
  D.18002 = 0;
  return D.18002;
  <D.18007>:
  D.18008 = sgen_hash_table_lookup (&hash_table, obj);
  D.18009 = D.18008 == 0B;
  D.18002 = (gboolean) D.18009;
  return D.18002;
}


dyn_array_ptr_pop (struct DynArray * da)
{
  int D.18011;
  _Bool D.18012;
  long int D.18013;
  long int D.18014;
  char * D.18017;
  sizetype D.18018;
  sizetype D.18019;
  sizetype D.18020;
  void * * D.18021;
  int D.18022;
  void * D.18023;
  void * p;

  D.18011 = da->size;
  D.18012 = D.18011 <= 0;
  D.18013 = (long int) D.18012;
  D.18014 = __builtin_expect (D.18013, 0);
  if (D.18014 != 0) goto <D.18015>; else goto <D.18016>;
  <D.18015>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-bridge.c", 142, "da->size > 0");
  <D.18016>:
  D.18017 = da->data;
  D.18011 = da->size;
  D.18018 = (sizetype) D.18011;
  D.18019 = D.18018 + 1073741823;
  D.18020 = D.18019 * 4;
  D.18021 = D.18017 + D.18020;
  p = *D.18021;
  D.18011 = da->size;
  D.18022 = D.18011 + -1;
  da->size = D.18022;
  D.18023 = p;
  return D.18023;
}


register_finishing_time (struct HashEntry * entry, int t)
{
  int D.18025;
  _Bool D.18026;
  long int D.18027;
  long int D.18028;

  D.18025 = entry->finishing_time;
  D.18026 = D.18025 >= 0;
  D.18027 = (long int) D.18026;
  D.18028 = __builtin_expect (D.18027, 0);
  if (D.18028 != 0) goto <D.18029>; else goto <D.18030>;
  <D.18029>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-bridge.c", 387, "entry->finishing_time < 0");
  <D.18030>:
  entry->finishing_time = t;
}


sgen_bridge_processing_finish (int generation)
{
  int D.18031;
  int bridge_processing_in_progress.41;
  _Bool D.18035;
  long int D.18036;
  long int D.18037;
  unsigned int D.18040;
  unsigned int D.18041;
  unsigned int D.18042;
  int D.18043;
  _Bool D.18044;
  long int D.18045;
  long int D.18046;
  int j.42;
  unsigned int j.43;
  unsigned int D.18051;
  struct HashEntry * * D.18052;
  int D.18053;
  int fist_pass_links.44;
  int fist_pass_links.45;
  struct SgenHashTableEntry * D.18056;
  unsigned int D.18057;
  unsigned int j.46;
  _Bool D.18059;
  long int D.18060;
  long int D.18061;
  long long int D.18064;
  long long int D.18065;
  long unsigned int step_3.47;
  unsigned int i.48;
  unsigned int D.18068;
  struct HashEntry * * D.18069;
  int D.18070;
  void * current_scc.49;
  struct SCC * current_scc.50;
  struct DynArray * D.18075;
  unsigned int i.51;
  int D.18077;
  int second_pass_links.52;
  int second_pass_links.53;
  long long int D.18080;
  long long int D.18081;
  long unsigned int step_4.54;
  char * D.18083;
  int D.18084;
  int D.18085;
  sizetype D.18086;
  int D.18087;
  _Bool D.18088;
  long int D.18089;
  long int D.18090;
  int D.18093;
  int D.18096;
  int sccs_links.55;
  int sccs_links.56;
  int max_sccs_links.57;
  int max_sccs_links.58;
  int D.18101;
  unsigned int num_sccs.59;
  unsigned int D.18103;
  int D.18104;
  unsigned int j.60;
  unsigned int D.18108;
  struct MonoGCBridgeSCC * * D.18109;
  unsigned int D.18110;
  unsigned int D.18111;
  unsigned int D.18112;
  void * D.18113;
  struct MonoGCBridgeSCC * D.18114;
  int j.61;
  int D.18116;
  unsigned int D.18117;
  int D.18118;
  int D.18121;
  int D.18122;
  sizetype D.18123;
  int D.18124;
  unsigned int D.18125;
  unsigned int D.18126;
  struct MonoGCBridgeSCC * * D.18127;
  struct MonoGCBridgeSCC * D.18128;
  int D.18129;
  int D.18130;
  int D.18131;
  struct MonoObject * D.18132;
  struct SgenHashTableEntry * D.18133;
  unsigned int num_xrefs.62;
  unsigned int D.18135;
  int D.18136;
  char * D.18139;
  unsigned int k.63;
  unsigned int D.18141;
  int * D.18142;
  int D.18143;
  int D.18144;
  sizetype D.18145;
  int D.18146;
  unsigned int D.18149;
  struct MonoGCBridgeXRef * D.18150;
  int D.18151;
  int D.18152;
  int D.18153;
  int D.18154;
  int D.18159;
  struct DynArray * D.18162;
  void (*<T2e3c>) (int, struct MonoGCBridgeSCC * *, int, struct MonoGCBridgeXRef *) D.18163;
  struct MonoGCBridgeSCC * * D.18164;
  struct MonoGCBridgeSCC * D.18165;
  int D.18166;
  _Bool D.18167;
  unsigned char alive.64;
  struct MonoObject * D.18169;
  int D.18172;
  unsigned int D.18175;
  unsigned int D.18176;
  unsigned int D.18177;
  int dsf2_passes.65;
  int dsf1_passes.66;
  long unsigned int step_8.67;
  float D.18181;
  float D.18182;
  double D.18183;
  long unsigned int step_7.68;
  float D.18185;
  float D.18186;
  double D.18187;
  long unsigned int step_6.69;
  float D.18189;
  float D.18190;
  double D.18191;
  long unsigned int step_5.70;
  float D.18193;
  float D.18194;
  double D.18195;
  long unsigned int step_4.71;
  float D.18197;
  float D.18198;
  double D.18199;
  long unsigned int step_3.72;
  float D.18201;
  float D.18202;
  double D.18203;
  long unsigned int step_2.73;
  float D.18205;
  float D.18206;
  double D.18207;
  long unsigned int step_1.74;
  float D.18209;
  float D.18210;
  double D.18211;
  int i;
  int j;
  int num_sccs;
  int num_xrefs;
  int max_entries;
  int max_xrefs;
  int hash_table_size;
  int sccs_size;
  struct MonoObject * obj;
  struct HashEntry * entry;
  int num_registered_bridges;
  struct HashEntry * * all_entries;
  struct MonoGCBridgeSCC * * api_sccs;
  struct MonoGCBridgeXRef * api_xrefs;
  struct SgenHashTable alive_hash;
  gint64 atv;
  gint64 btv;

  try
    {
      alive_hash.table_mem_type = 24;
      alive_hash.entry_mem_type = 25;
      alive_hash.data_size = 1;
      alive_hash.hash_func = mono_aligned_addr_hash;
      alive_hash.equal_func = 0B;
      alive_hash.table = 0B;
      alive_hash.size = 0;
      alive_hash.num_entries = 0;
      D.18031 = registered_bridges.size;
      if (D.18031 == 0) goto <D.18032>; else goto <D.18033>;
      <D.18032>:
      return;
      <D.18033>:
      bridge_processing_in_progress.41 = bridge_processing_in_progress;
      D.18035 = bridge_processing_in_progress.41 == 0;
      D.18036 = (long int) D.18035;
      D.18037 = __builtin_expect (D.18036, 0);
      if (D.18037 != 0) goto <D.18038>; else goto <D.18039>;
      <D.18038>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-bridge.c", 620, "bridge_processing_in_progress");
      <D.18039>:
      atv = mono_100ns_ticks ();
      D.18040 = hash_table.num_entries;
      D.18041 = D.18040 * 4;
      all_entries = sgen_alloc_internal_dynamic (D.18041, 21, 1);
      j = 0;
      {
        struct SgenHashTable * __hash_table;
        struct SgenHashTableEntry * * __table;
        guint __i;

        __hash_table = &hash_table;
        __table = __hash_table->table;
        __i = 0;
        goto <D.17568>;
        <D.17567>:
        {
          struct SgenHashTableEntry * * __iter;
          struct SgenHashTableEntry * * __next;

          D.18042 = __i * 4;
          __iter = __table + D.18042;
          goto <D.17565>;
          <D.17564>:
          {
            struct SgenHashTableEntry * __entry;

            __entry = *__iter;
            __next = &__entry->next;
            obj = __entry->key;
            entry = &__entry->data;
            D.18043 = entry->finishing_time;
            D.18044 = D.18043 < 0;
            D.18045 = (long int) D.18044;
            D.18046 = __builtin_expect (D.18045, 0);
            if (D.18046 != 0) goto <D.18047>; else goto <D.18048>;
            <D.18047>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-bridge.c", 630, "entry->finishing_time >= 0");
            <D.18048>:
            j.42 = j;
            j = j.42 + 1;
            j.43 = (unsigned int) j.42;
            D.18051 = j.43 * 4;
            D.18052 = all_entries + D.18051;
            *D.18052 = entry;
            D.18053 = entry->srcs.size;
            fist_pass_links.44 = fist_pass_links;
            fist_pass_links.45 = D.18053 + fist_pass_links.44;
            fist_pass_links = fist_pass_links.45;
          }
          __iter = __next;
          <D.17565>:
          D.18056 = *__iter;
          if (D.18056 != 0B) goto <D.17564>; else goto <D.17566>;
          <D.17566>:
        }
        __i = __i + 1;
        <D.17568>:
        D.18057 = hash_table.size;
        if (D.18057 > __i) goto <D.17567>; else goto <D.17569>;
        <D.17569>:
      }
      j.46 = (unsigned int) j;
      D.18040 = hash_table.num_entries;
      D.18059 = j.46 != D.18040;
      D.18060 = (long int) D.18059;
      D.18061 = __builtin_expect (D.18060, 0);
      if (D.18061 != 0) goto <D.18062>; else goto <D.18063>;
      <D.18062>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-bridge.c", 634, "j == hash_table.num_entries");
      <D.18063>:
      D.18040 = hash_table.num_entries;
      hash_table_size = (int) D.18040;
      D.18040 = hash_table.num_entries;
      sgen_qsort (all_entries, D.18040, 4, compare_hash_entries);
      btv = mono_100ns_ticks ();
      D.18064 = btv - atv;
      D.18065 = D.18064 / 10;
      step_3.47 = (long unsigned int) D.18065;
      step_3 = step_3.47;
      dyn_array_init (&sccs, 28);
      i = 0;
      goto <D.17573>;
      <D.17572>:
      {
        struct HashEntry * entry;

        i.48 = (unsigned int) i;
        D.18068 = i.48 * 4;
        D.18069 = all_entries + D.18068;
        entry = *D.18069;
        D.18070 = entry->scc_index;
        if (D.18070 < 0) goto <D.18071>; else goto <D.18072>;
        <D.18071>:
        {
          int index;

          index = sccs.size;
          current_scc.49 = dyn_array_add (&sccs);
          current_scc = current_scc.49;
          current_scc.50 = current_scc;
          current_scc.50->index = index;
          current_scc.50 = current_scc;
          current_scc.50->num_bridge_entries = 0;
          current_scc.50 = current_scc;
          current_scc.50->api_index = -1;
          current_scc.50 = current_scc;
          D.18075 = &current_scc.50->xrefs;
          dyn_array_int_init (D.18075);
          dfs2 (entry);
        }
        <D.18072>:
      }
      i = i + 1;
      <D.17573>:
      i.51 = (unsigned int) i;
      D.18040 = hash_table.num_entries;
      if (i.51 < D.18040) goto <D.17572>; else goto <D.17574>;
      <D.17574>:
      sccs_size = sccs.size;
      i = 0;
      goto <D.17577>;
      <D.17576>:
      {
        struct HashEntry * entry;

        i.48 = (unsigned int) i;
        D.18068 = i.48 * 4;
        D.18069 = all_entries + D.18068;
        entry = *D.18069;
        D.18077 = entry->srcs.size;
        second_pass_links.52 = second_pass_links;
        second_pass_links.53 = D.18077 + second_pass_links.52;
        second_pass_links = second_pass_links.53;
      }
      i = i + 1;
      <D.17577>:
      i.51 = (unsigned int) i;
      D.18040 = hash_table.num_entries;
      if (i.51 < D.18040) goto <D.17576>; else goto <D.17578>;
      <D.17578>:
      atv = mono_100ns_ticks ();
      D.18080 = atv - btv;
      D.18081 = D.18080 / 10;
      step_4.54 = (long unsigned int) D.18081;
      step_4 = step_4.54;
      dyn_array_uninit (&dfs_stack);
      num_sccs = 0;
      i = 0;
      goto <D.17581>;
      <D.17580>:
      {
        struct SCC * scc;

        D.18083 = sccs.data;
        D.18084 = sccs.elem_size;
        D.18085 = D.18084 * i;
        D.18086 = (sizetype) D.18085;
        scc = D.18083 + D.18086;
        D.18087 = scc->index;
        D.18088 = D.18087 != i;
        D.18089 = (long int) D.18088;
        D.18090 = __builtin_expect (D.18089, 0);
        if (D.18090 != 0) goto <D.18091>; else goto <D.18092>;
        <D.18091>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-bridge.c", 680, "scc->index == i");
        <D.18092>:
        D.18093 = scc->num_bridge_entries;
        if (D.18093 != 0) goto <D.18094>; else goto <D.18095>;
        <D.18094>:
        num_sccs = num_sccs + 1;
        <D.18095>:
        D.18096 = scc->xrefs.size;
        sccs_links.55 = sccs_links;
        sccs_links.56 = D.18096 + sccs_links.55;
        sccs_links = sccs_links.56;
        D.18096 = scc->xrefs.size;
        max_sccs_links.57 = max_sccs_links;
        max_sccs_links.58 = MAX_EXPR <D.18096, max_sccs_links.57>;
        max_sccs_links = max_sccs_links.58;
      }
      i = i + 1;
      <D.17581>:
      D.18101 = sccs.size;
      if (D.18101 > i) goto <D.17580>; else goto <D.17582>;
      <D.17582>:
      num_sccs.59 = (unsigned int) num_sccs;
      D.18103 = num_sccs.59 * 4;
      api_sccs = sgen_alloc_internal_dynamic (D.18103, 21, 1);
      num_xrefs = 0;
      j = 0;
      i = 0;
      goto <D.17586>;
      <D.17585>:
      {
        struct SCC * scc;

        D.18083 = sccs.data;
        D.18084 = sccs.elem_size;
        D.18085 = D.18084 * i;
        D.18086 = (sizetype) D.18085;
        scc = D.18083 + D.18086;
        D.18104 = scc->num_bridge_entries;
        if (D.18104 == 0) goto <D.18105>; else goto <D.18106>;
        <D.18105>:
        // predicted unlikely by continue predictor.
        goto <D.17584>;
        <D.18106>:
        j.60 = (unsigned int) j;
        D.18108 = j.60 * 4;
        D.18109 = api_sccs + D.18108;
        D.18104 = scc->num_bridge_entries;
        D.18110 = (unsigned int) D.18104;
        D.18111 = D.18110 + 2;
        D.18112 = D.18111 * 4;
        D.18113 = sgen_alloc_internal_dynamic (D.18112, 21, 1);
        *D.18109 = D.18113;
        j.60 = (unsigned int) j;
        D.18108 = j.60 * 4;
        D.18109 = api_sccs + D.18108;
        D.18114 = *D.18109;
        D.18114->is_alive = 0;
        j.60 = (unsigned int) j;
        D.18108 = j.60 * 4;
        D.18109 = api_sccs + D.18108;
        D.18114 = *D.18109;
        D.18104 = scc->num_bridge_entries;
        D.18114->num_objs = D.18104;
        scc->num_bridge_entries = 0;
        j.61 = j;
        j = j.61 + 1;
        scc->api_index = j.61;
        D.18116 = scc->xrefs.size;
        num_xrefs = D.18116 + num_xrefs;
      }
      <D.17584>:
      i = i + 1;
      <D.17586>:
      D.18101 = sccs.size;
      if (D.18101 > i) goto <D.17585>; else goto <D.17587>;
      <D.17587>:
      {
        struct SgenHashTable * __hash_table;
        struct SgenHashTableEntry * * __table;
        guint __i;

        __hash_table = &hash_table;
        __table = __hash_table->table;
        __i = 0;
        goto <D.17599>;
        <D.17598>:
        {
          struct SgenHashTableEntry * * __iter;
          struct SgenHashTableEntry * * __next;

          D.18117 = __i * 4;
          __iter = __table + D.18117;
          goto <D.17596>;
          <D.17595>:
          {
            struct SgenHashTableEntry * __entry;

            __entry = *__iter;
            __next = &__entry->next;
            obj = __entry->key;
            entry = &__entry->data;
            D.18118 = entry->is_bridge;
            if (D.18118 != 0) goto <D.18119>; else goto <D.18120>;
            <D.18119>:
            {
              struct SCC * scc;

              D.18083 = sccs.data;
              D.18121 = entry->scc_index;
              D.18084 = sccs.elem_size;
              D.18122 = D.18121 * D.18084;
              D.18123 = (sizetype) D.18122;
              scc = D.18083 + D.18123;
              D.18124 = scc->api_index;
              D.18125 = (unsigned int) D.18124;
              D.18126 = D.18125 * 4;
              D.18127 = api_sccs + D.18126;
              D.18128 = *D.18127;
              D.18129 = scc->num_bridge_entries;
              D.18130 = D.18129;
              D.18131 = D.18130 + 1;
              scc->num_bridge_entries = D.18131;
              D.18132 = entry->obj;
              D.18128->objs[D.18130] = D.18132;
            }
            <D.18120>:
          }
          __iter = __next;
          <D.17596>:
          D.18133 = *__iter;
          if (D.18133 != 0B) goto <D.17595>; else goto <D.17597>;
          <D.17597>:
        }
        __i = __i + 1;
        <D.17599>:
        D.18057 = hash_table.size;
        if (D.18057 > __i) goto <D.17598>; else goto <D.17600>;
        <D.17600>:
      }
      num_xrefs.62 = (unsigned int) num_xrefs;
      D.18135 = num_xrefs.62 * 8;
      api_xrefs = sgen_alloc_internal_dynamic (D.18135, 21, 1);
      j = 0;
      i = 0;
      goto <D.17610>;
      <D.17609>:
      {
        int k;
        struct SCC * scc;

        D.18083 = sccs.data;
        D.18084 = sccs.elem_size;
        D.18085 = D.18084 * i;
        D.18086 = (sizetype) D.18085;
        scc = D.18083 + D.18086;
        D.18136 = scc->num_bridge_entries;
        if (D.18136 == 0) goto <D.18137>; else goto <D.18138>;
        <D.18137>:
        // predicted unlikely by continue predictor.
        goto <D.17603>;
        <D.18138>:
        k = 0;
        goto <D.17607>;
        <D.17606>:
        {
          struct SCC * src_scc;

          D.18083 = sccs.data;
          D.18139 = scc->xrefs.data;
          k.63 = (unsigned int) k;
          D.18141 = k.63 * 4;
          D.18142 = D.18139 + D.18141;
          D.18143 = *D.18142;
          D.18084 = sccs.elem_size;
          D.18144 = D.18143 * D.18084;
          D.18145 = (sizetype) D.18144;
          src_scc = D.18083 + D.18145;
          D.18146 = src_scc->num_bridge_entries;
          if (D.18146 == 0) goto <D.18147>; else goto <D.18148>;
          <D.18147>:
          // predicted unlikely by continue predictor.
          goto <D.17605>;
          <D.18148>:
          j.60 = (unsigned int) j;
          D.18149 = j.60 * 8;
          D.18150 = api_xrefs + D.18149;
          D.18151 = src_scc->api_index;
          D.18150->src_scc_index = D.18151;
          j.60 = (unsigned int) j;
          D.18149 = j.60 * 8;
          D.18150 = api_xrefs + D.18149;
          D.18152 = scc->api_index;
          D.18150->dst_scc_index = D.18152;
          j = j + 1;
        }
        <D.17605>:
        k = k + 1;
        <D.17607>:
        D.18153 = scc->xrefs.size;
        if (D.18153 > k) goto <D.17606>; else goto <D.17608>;
        <D.17608>:
      }
      <D.17603>:
      i = i + 1;
      <D.17610>:
      D.18101 = sccs.size;
      if (D.18101 > i) goto <D.17609>; else goto <D.17611>;
      <D.17611>:
      btv = mono_100ns_ticks ();
      D.18064 = btv - atv;
      D.18065 = D.18064 / 10;
      step_3.47 = (long unsigned int) D.18065;
      step_5 = step_3.47;
      j = 0;
      max_xrefs = 0;
      max_entries = max_xrefs;
      i = 0;
      goto <D.17614>;
      <D.17613>:
      {
        struct SCC * scc;

        D.18083 = sccs.data;
        D.18084 = sccs.elem_size;
        D.18085 = D.18084 * i;
        D.18086 = (sizetype) D.18085;
        scc = D.18083 + D.18086;
        D.18154 = scc->num_bridge_entries;
        if (D.18154 != 0) goto <D.18155>; else goto <D.18156>;
        <D.18155>:
        j = j + 1;
        <D.18156>:
        D.18154 = scc->num_bridge_entries;
        if (D.18154 > max_entries) goto <D.18157>; else goto <D.18158>;
        <D.18157>:
        max_entries = scc->num_bridge_entries;
        <D.18158>:
        D.18159 = scc->xrefs.size;
        if (D.18159 > max_xrefs) goto <D.18160>; else goto <D.18161>;
        <D.18160>:
        max_xrefs = scc->xrefs.size;
        <D.18161>:
        D.18162 = &scc->xrefs;
        dyn_array_uninit (D.18162);
      }
      i = i + 1;
      <D.17614>:
      D.18101 = sccs.size;
      if (D.18101 > i) goto <D.17613>; else goto <D.17615>;
      <D.17615>:
      dyn_array_uninit (&sccs);
      D.18040 = hash_table.num_entries;
      D.18041 = D.18040 * 4;
      sgen_free_internal_dynamic (all_entries, D.18041, 21);
      free_data ();
      num_registered_bridges = registered_bridges.size;
      registered_bridges.size = 0;
      atv = mono_100ns_ticks ();
      D.18080 = atv - btv;
      D.18081 = D.18080 / 10;
      step_4.54 = (long unsigned int) D.18081;
      step_6 = step_4.54;
      D.18163 = bridge_callbacks.cross_references;
      D.18163 (num_sccs, api_sccs, num_xrefs, api_xrefs);
      btv = mono_100ns_ticks ();
      D.18064 = btv - atv;
      D.18065 = D.18064 / 10;
      step_3.47 = (long unsigned int) D.18065;
      step_7 = step_3.47;
      i = 0;
      goto <D.17621>;
      <D.17620>:
      {
        unsigned char alive;

        try
          {
            i.48 = (unsigned int) i;
            D.18068 = i.48 * 4;
            D.18164 = api_sccs + D.18068;
            D.18165 = *D.18164;
            D.18166 = D.18165->is_alive;
            D.18167 = D.18166 != 0;
            alive.64 = (unsigned char) D.18167;
            alive = alive.64;
            j = 0;
            goto <D.17618>;
            <D.17617>:
            i.48 = (unsigned int) i;
            D.18068 = i.48 * 4;
            D.18164 = api_sccs + D.18068;
            D.18165 = *D.18164;
            D.18169 = D.18165->objs[j];
            sgen_hash_table_replace (&alive_hash, D.18169, &alive, 0B);
            i.48 = (unsigned int) i;
            D.18068 = i.48 * 4;
            D.18164 = api_sccs + D.18068;
            D.18165 = *D.18164;
            D.18166 = D.18165->is_alive;
            if (D.18166 == 0) goto <D.18170>; else goto <D.18171>;
            <D.18170>:
            i.48 = (unsigned int) i;
            D.18068 = i.48 * 4;
            D.18164 = api_sccs + D.18068;
            D.18165 = *D.18164;
            D.18169 = D.18165->objs[j];
            sgen_mark_bridge_object (D.18169);
            <D.18171>:
            j = j + 1;
            <D.17618>:
            i.48 = (unsigned int) i;
            D.18068 = i.48 * 4;
            D.18164 = api_sccs + D.18068;
            D.18165 = *D.18164;
            D.18172 = D.18165->num_objs;
            if (D.18172 > j) goto <D.17617>; else goto <D.17619>;
            <D.17619>:
          }
        finally
          {
            alive = {CLOBBER};
          }
      }
      i = i + 1;
      <D.17621>:
      if (i < num_sccs) goto <D.17620>; else goto <D.17622>;
      <D.17622>:
      sgen_null_links_with_predicate (0, is_bridge_object_alive, &alive_hash);
      if (generation == 1) goto <D.18173>; else goto <D.18174>;
      <D.18173>:
      sgen_null_links_with_predicate (1, is_bridge_object_alive, &alive_hash);
      <D.18174>:
      sgen_hash_table_clean (&alive_hash);
      i = 0;
      goto <D.17624>;
      <D.17623>:
      i.48 = (unsigned int) i;
      D.18068 = i.48 * 4;
      D.18164 = api_sccs + D.18068;
      D.18165 = *D.18164;
      D.18172 = D.18165->num_objs;
      D.18175 = (unsigned int) D.18172;
      D.18176 = D.18175 + 2;
      D.18177 = D.18176 * 4;
      i.48 = (unsigned int) i;
      D.18068 = i.48 * 4;
      D.18164 = api_sccs + D.18068;
      D.18165 = *D.18164;
      sgen_free_internal_dynamic (D.18165, D.18177, 21);
      i = i + 1;
      <D.17624>:
      if (i < num_sccs) goto <D.17623>; else goto <D.17625>;
      <D.17625>:
      num_sccs.59 = (unsigned int) num_sccs;
      D.18103 = num_sccs.59 * 4;
      sgen_free_internal_dynamic (api_sccs, D.18103, 21);
      num_xrefs.62 = (unsigned int) num_xrefs;
      D.18135 = num_xrefs.62 * 8;
      sgen_free_internal_dynamic (api_xrefs, D.18135, 21);
      atv = mono_100ns_ticks ();
      D.18080 = atv - btv;
      D.18081 = D.18080 / 10;
      step_4.54 = (long unsigned int) D.18081;
      step_8 = step_4.54;
      dsf2_passes.65 = dsf2_passes;
      dsf1_passes.66 = dsf1_passes;
      max_sccs_links.57 = max_sccs_links;
      sccs_links.55 = sccs_links;
      second_pass_links.52 = second_pass_links;
      fist_pass_links.44 = fist_pass_links;
      step_8.67 = step_8;
      D.18181 = (float) step_8.67;
      D.18182 = D.18181 / 1.0e+3;
      D.18183 = (double) D.18182;
      step_7.68 = step_7;
      D.18185 = (float) step_7.68;
      D.18186 = D.18185 / 1.0e+3;
      D.18187 = (double) D.18186;
      step_6.69 = step_6;
      D.18189 = (float) step_6.69;
      D.18190 = D.18189 / 1.0e+3;
      D.18191 = (double) D.18190;
      step_5.70 = step_5;
      D.18193 = (float) step_5.70;
      D.18194 = D.18193 / 1.0e+3;
      D.18195 = (double) D.18194;
      step_4.71 = step_4;
      D.18197 = (float) step_4.71;
      D.18198 = D.18197 / 1.0e+3;
      D.18199 = (double) D.18198;
      step_3.72 = step_3;
      D.18201 = (float) step_3.72;
      D.18202 = D.18201 / 1.0e+3;
      D.18203 = (double) D.18202;
      step_2.73 = step_2;
      D.18205 = (float) step_2.73;
      D.18206 = D.18205 / 1.0e+3;
      D.18207 = (double) D.18206;
      step_1.74 = step_1;
      D.18209 = (float) step_1.74;
      D.18210 = D.18209 / 1.0e+3;
      D.18211 = (double) D.18210;
      D.18101 = sccs.size;
      mono_trace (64, 8, "GC_BRIDGE num-objects %d num_hash_entries %d sccs size %d init %.2fms df1 %.2fms sort %.2fms dfs2 %.2fms setup-cb %.2fms free-data %.2fms user-cb %.2fms clenanup %.2fms links %d/%d/%d/%d dfs passes %d/%d", num_registered_bridges, hash_table_size, D.18101, D.18211, D.18207, D.18203, D.18199, D.18195, D.18191, D.18187, D.18183, fist_pass_links.44, second_pass_links.52, sccs_links.55, max_sccs_links.57, dsf1_passes.66, dsf2_passes.65);
      step_1 = 0;
      bridge_processing_in_progress = 0;
    }
  finally
    {
      alive_hash = {CLOBBER};
    }
}


is_bridge_object_alive (struct MonoObject * obj, void * data)
{
  mono_bool D.18217;
  unsigned char D.18218;
  struct SgenHashTable * table;
  unsigned char * value;

  table = data;
  value = sgen_hash_table_lookup (table, obj);
  if (value == 0B) goto <D.18215>; else goto <D.18216>;
  <D.18215>:
  D.18217 = 1;
  return D.18217;
  <D.18216>:
  D.18218 = *value;
  D.18217 = (mono_bool) D.18218;
  return D.18217;
}


compare_hash_entries (const void * ep1, const void * ep2)
{
  int D.18220;
  int D.18221;
  int D.18222;
  struct HashEntry * e1;
  struct HashEntry * e2;

  e1 = MEM[(struct HashEntry * *)ep1];
  e2 = MEM[(struct HashEntry * *)ep2];
  D.18221 = e2->finishing_time;
  D.18222 = e1->finishing_time;
  D.18220 = D.18221 - D.18222;
  return D.18220;
}


dfs2 (struct HashEntry * entry)
{
  int D.18224;
  _Bool D.18225;
  long int D.18226;
  long int D.18227;
  int dsf2_passes.75;
  int dsf2_passes.76;
  int D.18232;
  struct SCC * current_scc.77;
  int D.18236;
  char * D.18239;
  int D.18240;
  int D.18241;
  sizetype D.18242;
  struct SCC * D.18243;
  char * D.18244;
  unsigned int i.78;
  unsigned int D.18246;
  void * * D.18247;
  void * D.18248;
  int D.18249;
  int i;

  D.18224 = dfs_stack.size;
  D.18225 = D.18224 != 0;
  D.18226 = (long int) D.18225;
  D.18227 = __builtin_expect (D.18226, 0);
  if (D.18227 != 0) goto <D.18228>; else goto <D.18229>;
  <D.18228>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-bridge.c", 501, "dfs_stack.size == 0");
  <D.18229>:
  dyn_array_ptr_add (&dfs_stack, entry);
  <D.17494>:
  entry = dyn_array_ptr_pop (&dfs_stack);
  dsf2_passes.75 = dsf2_passes;
  dsf2_passes.76 = dsf2_passes.75 + 1;
  dsf2_passes = dsf2_passes.76;
  D.18232 = entry->scc_index;
  if (D.18232 >= 0) goto <D.18233>; else goto <D.18234>;
  <D.18233>:
  D.18232 = entry->scc_index;
  current_scc.77 = current_scc;
  D.18236 = current_scc.77->index;
  if (D.18232 != D.18236) goto <D.18237>; else goto <D.18238>;
  <D.18237>:
  current_scc.77 = current_scc;
  D.18239 = sccs.data;
  D.18232 = entry->scc_index;
  D.18240 = sccs.elem_size;
  D.18241 = D.18232 * D.18240;
  D.18242 = (sizetype) D.18241;
  D.18243 = D.18239 + D.18242;
  scc_add_xref (D.18243, current_scc.77);
  <D.18238>:
  // predicted unlikely by continue predictor.
  goto <D.17490>;
  <D.18234>:
  current_scc.77 = current_scc;
  scc_add_entry (current_scc.77, entry);
  i = 0;
  goto <D.17492>;
  <D.17491>:
  D.18244 = entry->srcs.data;
  i.78 = (unsigned int) i;
  D.18246 = i.78 * 4;
  D.18247 = D.18244 + D.18246;
  D.18248 = *D.18247;
  dyn_array_ptr_add (&dfs_stack, D.18248);
  i = i + 1;
  <D.17492>:
  D.18249 = entry->srcs.size;
  if (D.18249 > i) goto <D.17491>; else goto <D.17493>;
  <D.17493>:
  <D.17490>:
  D.18224 = dfs_stack.size;
  if (D.18224 > 0) goto <D.17494>; else goto <D.17495>;
  <D.17495>:
}


scc_add_xref (struct SCC * src, struct SCC * dst)
{
  _Bool D.18250;
  long int D.18251;
  long int D.18252;
  int D.18255;
  int D.18256;
  _Bool D.18257;
  long int D.18258;
  long int D.18259;
  struct DynArray * D.18262;
  int D.18263;
  int D.18266;
  struct DynArray * D.18270;
  char * D.18271;
  unsigned int i.79;
  unsigned int D.18273;
  int * D.18274;
  int D.18275;
  _Bool D.18276;
  long int D.18277;
  long int D.18278;
  int D.18281;

  D.18250 = src == dst;
  D.18251 = (long int) D.18250;
  D.18252 = __builtin_expect (D.18251, 0);
  if (D.18252 != 0) goto <D.18253>; else goto <D.18254>;
  <D.18253>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-bridge.c", 469, "src != dst");
  <D.18254>:
  D.18255 = src->index;
  D.18256 = dst->index;
  D.18257 = D.18255 == D.18256;
  D.18258 = (long int) D.18257;
  D.18259 = __builtin_expect (D.18258, 0);
  if (D.18259 != 0) goto <D.18260>; else goto <D.18261>;
  <D.18260>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-bridge.c", 470, "src->index != dst->index");
  <D.18261>:
  D.18255 = src->index;
  D.18262 = &dst->xrefs;
  D.18263 = dyn_array_int_contains (D.18262, D.18255);
  if (D.18263 != 0) goto <D.18264>; else goto <D.18265>;
  <D.18264>:
  return;
  <D.18265>:
  D.18266 = src->num_bridge_entries;
  if (D.18266 != 0) goto <D.18267>; else goto <D.18268>;
  <D.18267>:
  D.18255 = src->index;
  D.18262 = &dst->xrefs;
  dyn_array_int_merge_one (D.18262, D.18255);
  goto <D.18269>;
  <D.18268>:
  {
    int i;

    D.18270 = &src->xrefs;
    D.18262 = &dst->xrefs;
    dyn_array_int_merge (D.18262, D.18270);
    i = 0;
    goto <D.17478>;
    <D.17477>:
    D.18271 = dst->xrefs.data;
    i.79 = (unsigned int) i;
    D.18273 = i.79 * 4;
    D.18274 = D.18271 + D.18273;
    D.18275 = *D.18274;
    D.18256 = dst->index;
    D.18276 = D.18275 == D.18256;
    D.18277 = (long int) D.18276;
    D.18278 = __builtin_expect (D.18277, 0);
    if (D.18278 != 0) goto <D.18279>; else goto <D.18280>;
    <D.18279>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-bridge.c", 480, "DYN_ARRAY_INT_REF (&dst->xrefs, i) != dst->index");
    <D.18280>:
    i = i + 1;
    <D.17478>:
    D.18281 = dst->xrefs.size;
    if (D.18281 > i) goto <D.17477>; else goto <D.17479>;
    <D.17479>:
  }
  <D.18269>:
}


dyn_array_int_contains (struct DynArray * da, int x)
{
  char * D.18283;
  unsigned int i.80;
  unsigned int D.18285;
  int * D.18286;
  int D.18287;
  gboolean D.18290;
  int D.18291;
  int i;

  i = 0;
  goto <D.17258>;
  <D.17257>:
  D.18283 = da->data;
  i.80 = (unsigned int) i;
  D.18285 = i.80 * 4;
  D.18286 = D.18283 + D.18285;
  D.18287 = *D.18286;
  if (D.18287 == x) goto <D.18288>; else goto <D.18289>;
  <D.18288>:
  D.18290 = 1;
  return D.18290;
  <D.18289>:
  i = i + 1;
  <D.17258>:
  D.18291 = da->size;
  if (D.18291 > i) goto <D.17257>; else goto <D.17259>;
  <D.17259>:
  D.18290 = 0;
  return D.18290;
}


dyn_array_int_merge_one (struct DynArray * array, int value)
{
  char * D.18293;
  unsigned int i.81;
  unsigned int D.18295;
  int * D.18296;
  int D.18297;
  int D.18301;
  int D.18302;
  sizetype i.82;
  sizetype D.18306;
  sizetype D.18307;
  int * D.18308;
  sizetype end.83;
  sizetype D.18310;
  sizetype D.18311;
  int * D.18312;
  unsigned int end.84;
  unsigned int D.18315;
  int * D.18316;
  int i;
  int tmp;
  int end;

  end = array->size;
  i = 0;
  goto <D.17281>;
  <D.17280>:
  D.18293 = array->data;
  i.81 = (unsigned int) i;
  D.18295 = i.81 * 4;
  D.18296 = D.18293 + D.18295;
  D.18297 = *D.18296;
  if (D.18297 == value) goto <D.18298>; else goto <D.18299>;
  <D.18298>:
  return;
  <D.18299>:
  D.18293 = array->data;
  i.81 = (unsigned int) i;
  D.18295 = i.81 * 4;
  D.18296 = D.18293 + D.18295;
  D.18297 = *D.18296;
  if (D.18297 > value) goto <D.17279>; else goto <D.18300>;
  <D.18300>:
  i = i + 1;
  <D.17281>:
  if (i < end) goto <D.17280>; else goto <D.17279>;
  <D.17279>:
  D.18301 = array->size;
  D.18302 = D.18301 + 1;
  dyn_array_ensure_capacity (array, D.18302);
  if (i < end) goto <D.18303>; else goto <D.18304>;
  <D.18303>:
  D.18293 = array->data;
  i.81 = (unsigned int) i;
  D.18295 = i.81 * 4;
  D.18296 = D.18293 + D.18295;
  tmp = *D.18296;
  goto <D.17283>;
  <D.17282>:
  D.18293 = array->data;
  i.81 = (unsigned int) i;
  D.18295 = i.81 * 4;
  D.18296 = D.18293 + D.18295;
  *D.18296 = value;
  value = tmp;
  D.18293 = array->data;
  i.82 = (sizetype) i;
  D.18306 = i.82 + 1;
  D.18307 = D.18306 * 4;
  D.18308 = D.18293 + D.18307;
  tmp = *D.18308;
  i = i + 1;
  <D.17283>:
  if (i <= end) goto <D.17282>; else goto <D.17284>;
  <D.17284>:
  D.18293 = array->data;
  end.83 = (sizetype) end;
  D.18310 = end.83 + 1;
  D.18311 = D.18310 * 4;
  D.18312 = D.18293 + D.18311;
  *D.18312 = tmp;
  goto <D.18313>;
  <D.18304>:
  D.18293 = array->data;
  end.84 = (unsigned int) end;
  D.18315 = end.84 * 4;
  D.18316 = D.18293 + D.18315;
  *D.18316 = value;
  <D.18313>:
  D.18301 = array->size;
  D.18302 = D.18301 + 1;
  array->size = D.18302;
}


dyn_array_int_merge (struct DynArray * dst, struct DynArray * src)
{
  int D.18318;
  int D.18319;
  int D.18320;
  char * D.18325;
  unsigned int i.85;
  unsigned int D.18327;
  int * D.18328;
  char * D.18329;
  unsigned int j.86;
  unsigned int D.18331;
  int * D.18332;
  int D.18341;
  int D.18343;
  int D.18345;
  int D.18348;
  int D.18349;
  unsigned int D.18350;
  char * D.18351;
  int i;
  int j;

  D.18318 = dst->size;
  D.18319 = src->size;
  D.18320 = D.18318 + D.18319;
  dyn_array_ensure_capacity (&merge_array, D.18320);
  merge_array.size = 0;
  j = 0;
  i = j;
  goto <D.17270>;
  <D.17269>:
  D.18318 = dst->size;
  if (D.18318 > i) goto <D.18323>; else goto <D.18321>;
  <D.18323>:
  D.18319 = src->size;
  if (D.18319 > j) goto <D.18324>; else goto <D.18321>;
  <D.18324>:
  {
    int a;
    int b;

    D.18325 = dst->data;
    i.85 = (unsigned int) i;
    D.18327 = i.85 * 4;
    D.18328 = D.18325 + D.18327;
    a = *D.18328;
    D.18329 = src->data;
    j.86 = (unsigned int) j;
    D.18331 = j.86 * 4;
    D.18332 = D.18329 + D.18331;
    b = *D.18332;
    if (a < b) goto <D.18333>; else goto <D.18334>;
    <D.18333>:
    dyn_array_int_add (&merge_array, a);
    i = i + 1;
    goto <D.18335>;
    <D.18334>:
    if (a == b) goto <D.18336>; else goto <D.18337>;
    <D.18336>:
    dyn_array_int_add (&merge_array, a);
    i = i + 1;
    j = j + 1;
    goto <D.18338>;
    <D.18337>:
    dyn_array_int_add (&merge_array, b);
    j = j + 1;
    <D.18338>:
    <D.18335>:
  }
  goto <D.18322>;
  <D.18321>:
  D.18318 = dst->size;
  if (D.18318 > i) goto <D.18339>; else goto <D.18340>;
  <D.18339>:
  D.18325 = dst->data;
  i.85 = (unsigned int) i;
  D.18327 = i.85 * 4;
  D.18328 = D.18325 + D.18327;
  D.18341 = *D.18328;
  dyn_array_int_add (&merge_array, D.18341);
  i = i + 1;
  goto <D.18342>;
  <D.18340>:
  D.18329 = src->data;
  j.86 = (unsigned int) j;
  D.18331 = j.86 * 4;
  D.18332 = D.18329 + D.18331;
  D.18343 = *D.18332;
  dyn_array_int_add (&merge_array, D.18343);
  j = j + 1;
  <D.18342>:
  <D.18322>:
  <D.17270>:
  D.18318 = dst->size;
  if (D.18318 > i) goto <D.17269>; else goto <D.18344>;
  <D.18344>:
  D.18319 = src->size;
  if (D.18319 > j) goto <D.17269>; else goto <D.17271>;
  <D.17271>:
  D.18345 = merge_array.size;
  D.18318 = dst->size;
  if (D.18345 > D.18318) goto <D.18346>; else goto <D.18347>;
  <D.18346>:
  D.18345 = merge_array.size;
  dyn_array_ensure_capacity (dst, D.18345);
  D.18345 = merge_array.size;
  D.18348 = merge_array.elem_size;
  D.18349 = D.18345 * D.18348;
  D.18350 = (unsigned int) D.18349;
  D.18351 = merge_array.data;
  D.18325 = dst->data;
  memcpy (D.18325, D.18351, D.18350);
  D.18345 = merge_array.size;
  dst->size = D.18345;
  <D.18347>:
}


dyn_array_int_add (struct DynArray * da, int x)
{
  int * p;

  p = dyn_array_add (da);
  *p = x;
}


scc_add_entry (struct SCC * scc, struct HashEntry * entry)
{
  int D.18352;
  _Bool D.18353;
  long int D.18354;
  long int D.18355;
  int D.18358;
  int D.18359;
  int D.18362;
  int D.18363;

  D.18352 = entry->scc_index;
  D.18353 = D.18352 >= 0;
  D.18354 = (long int) D.18353;
  D.18355 = __builtin_expect (D.18354, 0);
  if (D.18355 != 0) goto <D.18356>; else goto <D.18357>;
  <D.18356>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-bridge.c", 487, "entry->scc_index < 0");
  <D.18357>:
  D.18358 = scc->index;
  entry->scc_index = D.18358;
  D.18359 = entry->is_bridge;
  if (D.18359 != 0) goto <D.18360>; else goto <D.18361>;
  <D.18360>:
  D.18362 = scc->num_bridge_entries;
  D.18363 = D.18362 + 1;
  scc->num_bridge_entries = D.18363;
  <D.18361>:
}


dyn_array_uninit (struct DynArray * da)
{
  int D.18364;
  int D.18367;
  int D.18368;
  unsigned int D.18369;
  char * D.18370;

  D.18364 = da->capacity;
  if (D.18364 <= 0) goto <D.18365>; else goto <D.18366>;
  <D.18365>:
  return;
  <D.18366>:
  D.18367 = da->elem_size;
  D.18364 = da->capacity;
  D.18368 = D.18367 * D.18364;
  D.18369 = (unsigned int) D.18368;
  D.18370 = da->data;
  sgen_free_internal_dynamic (D.18370, D.18369, 21);
  da->data = 0B;
}


free_data ()
{
  unsigned int D.18372;
  int D.18373;
  struct DynArray * D.18376;
  struct SgenHashTableEntry * D.18377;
  unsigned int D.18378;
  struct MonoObject * obj;
  struct HashEntry * entry;
  int total_srcs;
  int max_srcs;

  total_srcs = 0;
  max_srcs = 0;
  {
    struct SgenHashTable * __hash_table;
    struct SgenHashTableEntry * * __table;
    guint __i;

    __hash_table = &hash_table;
    __table = __hash_table->table;
    __i = 0;
    goto <D.17346>;
    <D.17345>:
    {
      struct SgenHashTableEntry * * __iter;
      struct SgenHashTableEntry * * __next;

      D.18372 = __i * 4;
      __iter = __table + D.18372;
      goto <D.17343>;
      <D.17342>:
      {
        struct SgenHashTableEntry * __entry;

        __entry = *__iter;
        __next = &__entry->next;
        obj = __entry->key;
        entry = &__entry->data;
        D.18373 = entry->srcs.size;
        total_srcs = D.18373 + total_srcs;
        D.18373 = entry->srcs.size;
        if (D.18373 > max_srcs) goto <D.18374>; else goto <D.18375>;
        <D.18374>:
        max_srcs = entry->srcs.size;
        <D.18375>:
        D.18376 = &entry->srcs;
        dyn_array_uninit (D.18376);
      }
      __iter = __next;
      <D.17343>:
      D.18377 = *__iter;
      if (D.18377 != 0B) goto <D.17342>; else goto <D.17344>;
      <D.17344>:
    }
    __i = __i + 1;
    <D.17346>:
    D.18378 = hash_table.size;
    if (D.18378 > __i) goto <D.17345>; else goto <D.17347>;
    <D.17347>:
  }
  sgen_hash_table_clean (&hash_table);
  dyn_array_uninit (&merge_array);
}


sgen_bridge_describe_pointer (struct MonoObject * obj)
{
  char * D.18379;
  unsigned int i.87;
  unsigned int D.18381;
  void * * D.18382;
  void * D.18383;
  int D.18386;
  int D.18389;
  int D.18390;
  struct HashEntry * entry;
  int i;

  i = 0;
  goto <D.17633>;
  <D.17632>:
  D.18379 = registered_bridges.data;
  i.87 = (unsigned int) i;
  D.18381 = i.87 * 4;
  D.18382 = D.18379 + D.18381;
  D.18383 = *D.18382;
  if (D.18383 == obj) goto <D.18384>; else goto <D.18385>;
  <D.18384>:
  printf ("Pointer is a registered bridge object.\n");
  goto <D.17631>;
  <D.18385>:
  i = i + 1;
  <D.17633>:
  D.18386 = registered_bridges.size;
  if (D.18386 > i) goto <D.17632>; else goto <D.17631>;
  <D.17631>:
  entry = sgen_hash_table_lookup (&hash_table, obj);
  if (entry == 0B) goto <D.18387>; else goto <D.18388>;
  <D.18387>:
  return;
  <D.18388>:
  printf ("Bridge hash table entry %p:\n", entry);
  D.18389 = entry->is_bridge;
  printf ("  is bridge: %d\n", D.18389);
  D.18390 = entry->is_visited;
  printf ("  is visited: %d\n", D.18390);
}


printf (const char * restrict __fmt)
{
  int D.18392;

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


sgen_register_test_bridge_callbacks (const char * bridge_class_name)
{
  void (*<T2e3c>) (int, struct MonoGCBridgeSCC * *, int, struct MonoGCBridgeXRef *) iftmp.88;
  char D.18395;
  sizetype iftmp.89;
  const char * bridge_class.90;
  struct MonoGCBridgeCallbacks callbacks;

  try
    {
      callbacks.bridge_version = 3;
      callbacks.is_bridge_class = bridge_test_is_bridge_class;
      callbacks.is_bridge_object = bridge_test_is_bridge_object;
      D.18395 = *bridge_class_name;
      if (D.18395 == 50) goto <D.18396>; else goto <D.18397>;
      <D.18396>:
      iftmp.88 = bridge_test_cross_reference2;
      goto <D.18398>;
      <D.18397>:
      iftmp.88 = bridge_test_cross_reference;
      <D.18398>:
      callbacks.cross_references = iftmp.88;
      mono_gc_register_bridge_callbacks (&callbacks);
      D.18395 = *bridge_class_name;
      if (D.18395 == 50) goto <D.18400>; else goto <D.18401>;
      <D.18400>:
      iftmp.89 = 1;
      goto <D.18402>;
      <D.18401>:
      iftmp.89 = 0;
      <D.18402>:
      bridge_class.90 = bridge_class_name + iftmp.89;
      bridge_class = bridge_class.90;
    }
  finally
    {
      callbacks = {CLOBBER};
    }
}


bridge_test_cross_reference (int num_sccs, struct MonoGCBridgeSCC * * sccs, int num_xrefs, struct MonoGCBridgeXRef * xrefs)
{
  int D.18404;
  unsigned int i.91;
  unsigned int D.18408;
  struct MonoGCBridgeSCC * * D.18409;
  struct MonoGCBridgeSCC * D.18410;
  int D.18411;
  int iftmp.92;
  unsigned int D.18416;
  struct MonoGCBridgeXRef * D.18417;
  int D.18418;
  _Bool D.18420;
  long int D.18421;
  long int D.18422;
  int iftmp.93;
  int D.18429;
  _Bool D.18431;
  long int D.18432;
  long int D.18433;
  int i;

  i = 0;
  goto <D.17662>;
  <D.17661>:
  {
    int j;

    j = 0;
    goto <D.17659>;
    <D.17658>:
    D.18404 = i & 1;
    if (D.18404 != 0) goto <D.18405>; else goto <D.18406>;
    <D.18405>:
    i.91 = (unsigned int) i;
    D.18408 = i.91 * 4;
    D.18409 = sccs + D.18408;
    D.18410 = *D.18409;
    D.18410->is_alive = 1;
    <D.18406>:
    j = j + 1;
    <D.17659>:
    i.91 = (unsigned int) i;
    D.18408 = i.91 * 4;
    D.18409 = sccs + D.18408;
    D.18410 = *D.18409;
    D.18411 = D.18410->num_objs;
    if (D.18411 > j) goto <D.17658>; else goto <D.17660>;
    <D.17660>:
  }
  i = i + 1;
  <D.17662>:
  if (i < num_sccs) goto <D.17661>; else goto <D.17663>;
  <D.17663>:
  i = 0;
  goto <D.17665>;
  <D.17664>:
  i.91 = (unsigned int) i;
  D.18416 = i.91 * 8;
  D.18417 = xrefs + D.18416;
  D.18418 = D.18417->src_scc_index;
  if (D.18418 < 0) goto <D.18413>; else goto <D.18419>;
  <D.18419>:
  i.91 = (unsigned int) i;
  D.18416 = i.91 * 8;
  D.18417 = xrefs + D.18416;
  D.18418 = D.18417->src_scc_index;
  if (D.18418 >= num_sccs) goto <D.18413>; else goto <D.18414>;
  <D.18413>:
  iftmp.92 = 1;
  goto <D.18415>;
  <D.18414>:
  iftmp.92 = 0;
  <D.18415>:
  D.18420 = iftmp.92 != 0;
  D.18421 = (long int) D.18420;
  D.18422 = __builtin_expect (D.18421, 0);
  if (D.18422 != 0) goto <D.18423>; else goto <D.18424>;
  <D.18423>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-bridge.c", 869, "xrefs [i].src_scc_index >= 0 && xrefs [i].src_scc_index < num_sccs");
  <D.18424>:
  i.91 = (unsigned int) i;
  D.18416 = i.91 * 8;
  D.18417 = xrefs + D.18416;
  D.18429 = D.18417->dst_scc_index;
  if (D.18429 < 0) goto <D.18426>; else goto <D.18430>;
  <D.18430>:
  i.91 = (unsigned int) i;
  D.18416 = i.91 * 8;
  D.18417 = xrefs + D.18416;
  D.18429 = D.18417->dst_scc_index;
  if (D.18429 >= num_sccs) goto <D.18426>; else goto <D.18427>;
  <D.18426>:
  iftmp.93 = 1;
  goto <D.18428>;
  <D.18427>:
  iftmp.93 = 0;
  <D.18428>:
  D.18431 = iftmp.93 != 0;
  D.18432 = (long int) D.18431;
  D.18433 = __builtin_expect (D.18432, 0);
  if (D.18433 != 0) goto <D.18434>; else goto <D.18435>;
  <D.18434>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-bridge.c", 870, "xrefs [i].dst_scc_index >= 0 && xrefs [i].dst_scc_index < num_sccs");
  <D.18435>:
  i = i + 1;
  <D.17665>:
  if (i < num_xrefs) goto <D.17664>; else goto <D.17666>;
  <D.17666>:
}


bridge_test_cross_reference2 (int num_sccs, struct MonoGCBridgeSCC * * sccs, int num_xrefs, struct MonoGCBridgeXRef * xrefs)
{
  struct MonoClassField * mono_bridge_test_field.94;
  struct MonoGCBridgeSCC * D.18439;
  struct MonoObject * D.18440;
  struct MonoClass * D.18441;
  struct MonoClassField * mono_bridge_test_field.95;
  _Bool D.18443;
  long int D.18444;
  long int D.18445;
  unsigned int i.96;
  unsigned int D.18449;
  struct MonoGCBridgeSCC * * D.18450;
  struct MonoGCBridgeSCC * D.18451;
  int D.18452;
  int D.18455;
  int D.18458;
  struct MonoObject * D.18461;
  unsigned int D.18462;
  struct MonoGCBridgeXRef * D.18463;
  int D.18464;
  unsigned int D.18465;
  unsigned int D.18466;
  struct MonoGCBridgeSCC * * D.18467;
  struct MonoGCBridgeSCC * D.18468;
  int D.18469;
  int D.18472;
  unsigned int D.18473;
  unsigned int D.18474;
  struct MonoGCBridgeSCC * * D.18475;
  struct MonoGCBridgeSCC * D.18476;
  int D.18477;
  int i;
  gboolean modified;

  mono_bridge_test_field.94 = mono_bridge_test_field;
  if (mono_bridge_test_field.94 == 0B) goto <D.18437>; else goto <D.18438>;
  <D.18437>:
  D.18439 = *sccs;
  D.18440 = D.18439->objs[0];
  D.18441 = mono_object_get_class (D.18440);
  mono_bridge_test_field.95 = mono_class_get_field_from_name (D.18441, "__test");
  mono_bridge_test_field = mono_bridge_test_field.95;
  mono_bridge_test_field.94 = mono_bridge_test_field;
  D.18443 = mono_bridge_test_field.94 == 0B;
  D.18444 = (long int) D.18443;
  D.18445 = __builtin_expect (D.18444, 0);
  if (D.18445 != 0) goto <D.18446>; else goto <D.18447>;
  <D.18446>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-bridge.c", 912, "mono_bridge_test_field");
  <D.18447>:
  <D.18438>:
  i = 0;
  goto <D.17706>;
  <D.17705>:
  {
    int j;
    gboolean live;

    live = 0;
    j = 0;
    goto <D.17699>;
    <D.17698>:
    i.96 = (unsigned int) i;
    D.18449 = i.96 * 4;
    D.18450 = sccs + D.18449;
    D.18451 = *D.18450;
    D.18452 = test_scc (D.18451, j);
    if (D.18452 != 0) goto <D.18453>; else goto <D.18454>;
    <D.18453>:
    live = 1;
    goto <D.17697>;
    <D.18454>:
    j = j + 1;
    <D.17699>:
    i.96 = (unsigned int) i;
    D.18449 = i.96 * 4;
    D.18450 = sccs + D.18449;
    D.18451 = *D.18450;
    D.18455 = D.18451->num_objs;
    if (D.18455 > j) goto <D.17698>; else goto <D.17697>;
    <D.17697>:
    if (live == 0) goto <D.18456>; else goto <D.18457>;
    <D.18456>:
    // predicted unlikely by continue predictor.
    goto <D.17700>;
    <D.18457>:
    j = 0;
    goto <D.17703>;
    <D.17702>:
    i.96 = (unsigned int) i;
    D.18449 = i.96 * 4;
    D.18450 = sccs + D.18449;
    D.18451 = *D.18450;
    D.18458 = test_scc (D.18451, j);
    if (D.18458 == 0) goto <D.18459>; else goto <D.18460>;
    <D.18459>:
    {
      int status;

      try
        {
          status = 2;
          mono_bridge_test_field.94 = mono_bridge_test_field;
          i.96 = (unsigned int) i;
          D.18449 = i.96 * 4;
          D.18450 = sccs + D.18449;
          D.18451 = *D.18450;
          D.18461 = D.18451->objs[j];
          mono_field_set_value (D.18461, mono_bridge_test_field.94, &status);
        }
      finally
        {
          status = {CLOBBER};
        }
    }
    <D.18460>:
    j = j + 1;
    <D.17703>:
    i.96 = (unsigned int) i;
    D.18449 = i.96 * 4;
    D.18450 = sccs + D.18449;
    D.18451 = *D.18450;
    D.18455 = D.18451->num_objs;
    if (D.18455 > j) goto <D.17702>; else goto <D.17704>;
    <D.17704>:
  }
  <D.17700>:
  i = i + 1;
  <D.17706>:
  if (i < num_sccs) goto <D.17705>; else goto <D.17707>;
  <D.17707>:
  modified = 1;
  goto <D.17713>;
  <D.17712>:
  modified = 0;
  i = 0;
  goto <D.17710>;
  <D.17709>:
  {
    struct MonoGCBridgeXRef ref;

    try
      {
        i.96 = (unsigned int) i;
        D.18462 = i.96 * 8;
        D.18463 = xrefs + D.18462;
        ref = *D.18463;
        D.18464 = ref.src_scc_index;
        D.18465 = (unsigned int) D.18464;
        D.18466 = D.18465 * 4;
        D.18467 = sccs + D.18466;
        D.18468 = *D.18467;
        D.18469 = test_scc (D.18468, 0);
        if (D.18469 != 0) goto <D.18470>; else goto <D.18471>;
        <D.18470>:
        D.18472 = ref.dst_scc_index;
        D.18473 = (unsigned int) D.18472;
        D.18474 = D.18473 * 4;
        D.18475 = sccs + D.18474;
        D.18476 = *D.18475;
        D.18477 = test_scc (D.18476, 0);
        if (D.18477 == 0) goto <D.18478>; else goto <D.18479>;
        <D.18478>:
        modified = 1;
        D.18472 = ref.dst_scc_index;
        D.18473 = (unsigned int) D.18472;
        D.18474 = D.18473 * 4;
        D.18475 = sccs + D.18474;
        D.18476 = *D.18475;
        mark_scc (D.18476, 3);
        <D.18479>:
        <D.18471>:
      }
    finally
      {
        ref = {CLOBBER};
      }
  }
  i = i + 1;
  <D.17710>:
  if (i < num_xrefs) goto <D.17709>; else goto <D.17711>;
  <D.17711>:
  <D.17713>:
  if (modified != 0) goto <D.17712>; else goto <D.17714>;
  <D.17714>:
  i = 0;
  goto <D.17716>;
  <D.17715>:
  i.96 = (unsigned int) i;
  D.18449 = i.96 * 4;
  D.18450 = sccs + D.18449;
  D.18451 = *D.18450;
  D.18451->is_alive = 1;
  i = i + 1;
  <D.17716>:
  if (i < num_sccs) goto <D.17715>; else goto <D.17717>;
  <D.17717>:
}


test_scc (struct MonoGCBridgeSCC * scc, int i)
{
  struct MonoClassField * mono_bridge_test_field.97;
  struct MonoObject * D.18481;
  gboolean D.18482;
  int status.98;
  _Bool D.18484;
  int status;

  try
    {
      status = 0;
      mono_bridge_test_field.97 = mono_bridge_test_field;
      D.18481 = scc->objs[i];
      mono_field_get_value (D.18481, mono_bridge_test_field.97, &status);
      status.98 = status;
      D.18484 = status.98 > 0;
      D.18482 = (gboolean) D.18484;
      return D.18482;
    }
  finally
    {
      status = {CLOBBER};
    }
}


mark_scc (struct MonoGCBridgeSCC * scc, int value)
{
  int D.18487;
  struct MonoClassField * mono_bridge_test_field.99;
  struct MonoObject * D.18491;
  int D.18492;
  int i;

  i = 0;
  goto <D.17685>;
  <D.17684>:
  D.18487 = test_scc (scc, i);
  if (D.18487 == 0) goto <D.18488>; else goto <D.18489>;
  <D.18488>:
  {
    int status;

    try
      {
        status = value;
        mono_bridge_test_field.99 = mono_bridge_test_field;
        D.18491 = scc->objs[i];
        mono_field_set_value (D.18491, mono_bridge_test_field.99, &status);
      }
    finally
      {
        status = {CLOBBER};
      }
  }
  <D.18489>:
  i = i + 1;
  <D.17685>:
  D.18492 = scc->num_objs;
  if (D.18492 > i) goto <D.17684>; else goto <D.17686>;
  <D.17686>:
}


bridge_test_is_bridge_object (struct MonoObject * object)
{
  gboolean D.18493;

  D.18493 = 1;
  return D.18493;
}


bridge_test_is_bridge_class (struct MonoClass * class)
{
  gboolean D.18495;
  int D.17646;
  const char * D.18496;
  const char * bridge_class.100;
  _Bool D.18498;

  {
    size_t __s1_len;
    size_t __s2_len;

    D.18496 = class->name;
    bridge_class.100 = bridge_class;
    D.17646 = __builtin_strcmp (bridge_class.100, D.18496);
  }
  D.18498 = D.17646 == 0;
  D.18495 = (gboolean) D.18498;
  return D.18495;
}