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.17704>; else goto <D.17705>;
  <D.17704>:
  return;
  <D.17705>:
  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.17707;

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


sgen_is_bridge_object (struct MonoObject * obj)
{
  struct MonoVTable * D.17710;
  <unnamed-unsigned:4> D.17711;
  int D.17712;
  int D.17713;
  gboolean D.17716;
  mono_bool (*<T2e2c>) (struct MonoObject *) D.17717;

  D.17710 = obj->vtable;
  D.17711 = D.17710->gc_bits;
  D.17712 = (int) D.17711;
  D.17713 = D.17712 & 1;
  if (D.17713 == 0) goto <D.17714>; else goto <D.17715>;
  <D.17714>:
  D.17716 = 0;
  return D.17716;
  <D.17715>:
  D.17717 = bridge_callbacks.is_bridge_object;
  D.17716 = D.17717 (obj);
  return D.17716;
}


sgen_is_bridge_class (struct MonoClass * class)
{
  gboolean D.17719;
  mono_bool (*<T2e28>) (struct MonoClass *) D.17720;

  D.17720 = bridge_callbacks.is_bridge_class;
  D.17719 = D.17720 (class);
  return D.17719;
}


sgen_need_bridge_processing ()
{
  gboolean D.17722;
  void (*<T2e36>) (int, struct MonoGCBridgeSCC * *, int, struct MonoGCBridgeXRef *) D.17723;
  _Bool D.17724;

  D.17723 = bridge_callbacks.cross_references;
  D.17724 = D.17723 != 0B;
  D.17722 = (gboolean) D.17724;
  return D.17722;
}


sgen_bridge_register_finalized_object (struct MonoObject * obj)
{
  int D.17726;
  _Bool D.17727;
  long int D.17728;
  long int D.17729;

  D.17726 = sgen_need_bridge_processing ();
  D.17727 = D.17726 == 0;
  D.17728 = (long int) D.17727;
  D.17729 = __builtin_expect (D.17728, 0);
  if (D.17729 != 0) goto <D.17730>; else goto <D.17731>;
  <D.17730>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-bridge.c", 537, "sgen_need_bridge_processing ()");
  <D.17731>:
  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.17732;
  int D.17733;
  char * D.17734;
  int D.17735;
  int D.17736;
  sizetype D.17737;
  void * D.17738;
  void * p;

  D.17732 = da->size;
  D.17733 = D.17732 + 1;
  dyn_array_ensure_capacity (da, D.17733);
  D.17734 = da->data;
  D.17732 = da->size;
  D.17735 = da->elem_size;
  D.17736 = D.17732 * D.17735;
  D.17737 = (sizetype) D.17736;
  p = D.17734 + D.17737;
  D.17732 = da->size;
  D.17733 = D.17732 + 1;
  da->size = D.17733;
  D.17738 = p;
  return D.17738;
}


dyn_array_ensure_capacity (struct DynArray * da, int capacity)
{
  int D.17742;
  int D.17745;
  int D.17746;
  int D.17747;
  unsigned int D.17748;
  char * D.17749;
  int D.17750;
  int D.17751;
  unsigned int D.17752;
  int D.17753;
  unsigned int D.17754;
  int old_capacity;
  char * new_data;

  old_capacity = da->capacity;
  if (capacity <= old_capacity) goto <D.17740>; else goto <D.17741>;
  <D.17740>:
  return;
  <D.17741>:
  D.17742 = da->capacity;
  if (D.17742 == 0) goto <D.17743>; else goto <D.17744>;
  <D.17743>:
  da->capacity = 2;
  <D.17744>:
  goto <D.17212>;
  <D.17211>:
  D.17742 = da->capacity;
  D.17745 = D.17742 * 2;
  da->capacity = D.17745;
  <D.17212>:
  D.17742 = da->capacity;
  if (D.17742 < capacity) goto <D.17211>; else goto <D.17213>;
  <D.17213>:
  D.17746 = da->elem_size;
  D.17742 = da->capacity;
  D.17747 = D.17746 * D.17742;
  D.17748 = (unsigned int) D.17747;
  new_data = sgen_alloc_internal_dynamic (D.17748, 21, 1);
  D.17749 = da->data;
  D.17746 = da->elem_size;
  D.17750 = da->size;
  D.17751 = D.17746 * D.17750;
  D.17752 = (unsigned int) D.17751;
  memcpy (new_data, D.17749, D.17752);
  D.17749 = da->data;
  D.17746 = da->elem_size;
  D.17753 = D.17746 * old_capacity;
  D.17754 = (unsigned int) D.17753;
  sgen_free_internal_dynamic (D.17749, D.17754, 21);
  da->data = new_data;
}


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

  D.17757 = __builtin_object_size (__dest, 0);
  D.17756 = __builtin___memcpy_chk (__dest, __src, __len, D.17757);
  return D.17756;
}


sgen_bridge_reset_data ()
{
  registered_bridges.size = 0;
}


sgen_bridge_processing_stw_step ()
{
  int D.17759;
  char * D.17762;
  unsigned int i.1;
  unsigned int D.17764;
  void * * D.17765;
  void * D.17766;
  struct HashEntry * D.17767;
  long long int D.17768;
  long long int D.17769;
  long unsigned int step_2.2;
  int i;
  gint64 atv;
  gint64 btv;

  D.17759 = registered_bridges.size;
  if (D.17759 == 0) goto <D.17760>; else goto <D.17761>;
  <D.17760>:
  return;
  <D.17761>:
  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.17507>;
  <D.17506>:
  D.17762 = registered_bridges.data;
  i.1 = (unsigned int) i;
  D.17764 = i.1 * 4;
  D.17765 = D.17762 + D.17764;
  D.17766 = *D.17765;
  register_bridge_object (D.17766);
  i = i + 1;
  <D.17507>:
  D.17759 = registered_bridges.size;
  if (D.17759 > i) goto <D.17506>; else goto <D.17508>;
  <D.17508>:
  i = 0;
  goto <D.17510>;
  <D.17509>:
  D.17762 = registered_bridges.data;
  i.1 = (unsigned int) i;
  D.17764 = i.1 * 4;
  D.17765 = D.17762 + D.17764;
  D.17766 = *D.17765;
  D.17767 = get_hash_entry (D.17766, 0B);
  dfs1 (D.17767, 0B);
  i = i + 1;
  <D.17510>:
  D.17759 = registered_bridges.size;
  if (D.17759 > i) goto <D.17509>; else goto <D.17511>;
  <D.17511>:
  atv = mono_100ns_ticks ();
  D.17768 = atv - btv;
  D.17769 = D.17768 / 10;
  step_2.2 = (long unsigned int) D.17769;
  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.17772;
  struct HashEntry * entry;

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


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

  try
    {
      entry = sgen_hash_table_lookup (&hash_table, obj);
      if (entry != 0B) goto <D.17774>; else goto <D.17775>;
      <D.17774>:
      if (existing != 0B) goto <D.17776>; else goto <D.17777>;
      <D.17776>:
      *existing = 1;
      <D.17777>:
      D.17778 = entry;
      return D.17778;
      <D.17775>:
      if (existing != 0B) goto <D.17779>; else goto <D.17780>;
      <D.17779>:
      *existing = 0;
      <D.17780>:
      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.17778 = sgen_hash_table_lookup (&hash_table, obj);
      return D.17778;
    }
  finally
    {
      new_entry = {CLOBBER};
    }
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.17785;
  int D.17790;
  void * D.17792;
  unsigned int D.17793;

  D.17785 = __builtin_constant_p (__len);
  if (D.17785 != 0) goto <D.17786>; else goto <D.17787>;
  <D.17786>:
  if (__len == 0) goto <D.17788>; else goto <D.17789>;
  <D.17788>:
  D.17790 = __builtin_constant_p (__ch);
  if (D.17790 == 0) goto <D.17783>; else goto <D.17791>;
  <D.17791>:
  if (__ch != 0) goto <D.17783>; else goto <D.17784>;
  <D.17783>:
  __warn_memset_zero_len ();
  D.17792 = __dest;
  return D.17792;
  <D.17784>:
  <D.17789>:
  <D.17787>:
  D.17793 = __builtin_object_size (__dest, 0);
  D.17792 = __builtin___memset_chk (__dest, __ch, __len, D.17793);
  return D.17792;
}


dfs1 (struct HashEntry * obj_entry, struct HashEntry * src)
{
  int D.17795;
  _Bool D.17796;
  long int D.17797;
  long int D.17798;
  int dsf1_passes.3;
  int dsf1_passes.4;
  int D.17808;
  unsigned int D.17811;
  unsigned int D.17812;
  unsigned int D.17813;
  unsigned int D.17814;
  unsigned int D.17817;
  unsigned int D.17818;
  unsigned int D.17819;
  unsigned int D.17820;
  unsigned int D.17821;
  void * dst.5;
  struct MonoObject * dst.6;
  int D.17826;
  struct HashEntry * D.17829;
  struct MonoObject * dst.7;
  int D.17833;
  struct HashEntry * D.17836;
  unsigned int _index.8;
  unsigned int D.17838;
  int D.17839;
  void * dst.9;
  struct MonoObject * dst.10;
  int D.17844;
  struct HashEntry * D.17847;
  unsigned int _index.11;
  unsigned int D.17849;
  int D.17850;
  struct MonoObject * dst.12;
  int D.17854;
  struct HashEntry * D.17857;
  unsigned int D.17858;
  unsigned int D.17861;
  int D.17862;
  int desc.13;
  unsigned int D.17866;
  unsigned int el_size.14;
  unsigned int D.17868;
  void * dst.15;
  struct MonoObject * dst.16;
  int D.17873;
  struct HashEntry * D.17876;
  int D.17880;
  unsigned int offset.17;
  unsigned int D.17882;
  unsigned int i.18;
  unsigned int D.17884;
  void * * D.17885;
  void * dst.19;
  struct MonoObject * dst.20;
  int D.17890;
  struct HashEntry * D.17893;
  sizetype el_size.21;
  unsigned int D.17898;
  void * dst.22;
  struct MonoObject * dst.23;
  int D.17905;
  struct HashEntry * D.17908;
  unsigned int D.17909;
  void * dst.24;
  struct MonoObject * dst.25;
  int D.17916;
  struct HashEntry * D.17919;
  unsigned int D.17920;
  unsigned int D.17921;
  struct MonoVTable * D.17924;
  struct MonoClass * D.17925;
  const char * D.17926;
  const char * D.17927;
  gsize * bitmap_data.26;
  unsigned int D.17929;
  void * dst.27;
  struct MonoObject * dst.28;
  int D.17936;
  struct HashEntry * D.17939;
  int bwords.29;
  unsigned int D.17941;
  gsize * mbitmap_data.30;
  unsigned int D.17943;
  unsigned int D.17944;
  struct MonoClass * D.17945;
  unsigned int el_size.31;
  unsigned int D.17947;
  const char * D.17950;
  const char * D.17951;
  gsize * bitmap_data.32;
  unsigned int D.17953;
  void * dst.33;
  struct MonoObject * dst.34;
  int D.17960;
  struct HashEntry * D.17963;
  unsigned int bwords.35;
  sizetype el_size.36;
  int current_time.37;
  int current_time.38;
  int current_time.39;

  D.17795 = dfs_stack.size;
  D.17796 = D.17795 != 0;
  D.17797 = (long int) D.17796;
  D.17798 = __builtin_expect (D.17797, 0);
  if (D.17798 != 0) goto <D.17799>; else goto <D.17800>;
  <D.17799>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-bridge.c", 423, "dfs_stack.size == 0");
  <D.17800>:
  dyn_array_ptr_add (&dfs_stack, src);
  dyn_array_ptr_add (&dfs_stack, obj_entry);
  <D.17450>:
  {
    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.17803>; else goto <D.17804>;
    <D.17803>:
    src = dyn_array_ptr_pop (&dfs_stack);
    obj = obj_entry->obj;
    start = obj;
    if (src != 0B) goto <D.17805>; else goto <D.17806>;
    <D.17805>:
    add_source (obj_entry, src);
    goto <D.17807>;
    <D.17806>:
    <D.17807>:
    D.17808 = obj_entry->is_visited;
    if (D.17808 != 0) goto <D.17809>; else goto <D.17810>;
    <D.17809>:
    // predicted unlikely by continue predictor.
    goto <D.17351>;
    <D.17810>:
    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.17811 = MEM[(mword *)start];
      D.17812 = D.17811 & 4294967292;
      vt = (struct GCVTable *) D.17812;
      desc = vt->desc;
      D.17813 = desc & 7;
      switch (D.17813) <default: <D.17449>, case 1: <D.17354>, case 2: <D.17363>, case 3: <D.17413>, case 4: <D.17373>, case 5: <D.17406>, case 6: <D.17427>, case 7: <D.17448>>
      <D.17354>:
      D.17814 = desc & 4294901760;
      if (D.17814 != 0) goto <D.17815>; else goto <D.17816>;
      <D.17815>:
      {
        void * * _objptr_end;
        void * * _objptr;

        _objptr = start;
        D.17817 = desc >> 16;
        D.17818 = D.17817 & 255;
        D.17819 = D.17818 * 4;
        _objptr = _objptr + D.17819;
        D.17820 = desc >> 24;
        D.17821 = D.17820 * 4;
        _objptr_end = _objptr + D.17821;
        {
          struct MonoObject * dst;

          try
            {
              dst.5 = *_objptr;
              dst = dst.5;
              dst.6 = dst;
              if (dst.6 != 0B) goto <D.17824>; else goto <D.17825>;
              <D.17824>:
              D.17826 = object_is_live (&dst);
              if (D.17826 == 0) goto <D.17827>; else goto <D.17828>;
              <D.17827>:
              dyn_array_ptr_add (&dfs_stack, obj_entry);
              dst.6 = dst;
              D.17829 = get_hash_entry (dst.6, 0B);
              dyn_array_ptr_add (&dfs_stack, D.17829);
              <D.17828>:
              <D.17825>:
            }
          finally
            {
              dst = {CLOBBER};
            }
        }
        _objptr = _objptr + 4;
        goto <D.17360>;
        <D.17359>:
        {
          struct MonoObject * dst;

          try
            {
              dst.5 = *_objptr;
              dst = dst.5;
              dst.7 = dst;
              if (dst.7 != 0B) goto <D.17831>; else goto <D.17832>;
              <D.17831>:
              D.17833 = object_is_live (&dst);
              if (D.17833 == 0) goto <D.17834>; else goto <D.17835>;
              <D.17834>:
              dyn_array_ptr_add (&dfs_stack, obj_entry);
              dst.7 = dst;
              D.17836 = get_hash_entry (dst.7, 0B);
              dyn_array_ptr_add (&dfs_stack, D.17836);
              <D.17835>:
              <D.17832>:
            }
          finally
            {
              dst = {CLOBBER};
            }
        }
        _objptr = _objptr + 4;
        <D.17360>:
        if (_objptr < _objptr_end) goto <D.17359>; else goto <D.17361>;
        <D.17361>:
      }
      <D.17816>:
      goto <D.17362>;
      <D.17363>:
      {
        void * * _objptr;
        gsize _bmap;

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

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

            try
              {
                dst.9 = *_objptr;
                dst = dst.9;
                dst.10 = dst;
                if (dst.10 != 0B) goto <D.17842>; else goto <D.17843>;
                <D.17842>:
                D.17844 = object_is_live (&dst);
                if (D.17844 == 0) goto <D.17845>; else goto <D.17846>;
                <D.17845>:
                dyn_array_ptr_add (&dfs_stack, obj_entry);
                dst.10 = dst;
                D.17847 = get_hash_entry (dst.10, 0B);
                dyn_array_ptr_add (&dfs_stack, D.17847);
                <D.17846>:
                <D.17843>:
              }
            finally
              {
                dst = {CLOBBER};
              }
          }
          _objptr = _objptr + 4;
        }
        goto <D.17371>;
        <D.17370>:
        {
          int _index;

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

            try
              {
                dst.9 = *_objptr;
                dst = dst.9;
                dst.12 = dst;
                if (dst.12 != 0B) goto <D.17852>; else goto <D.17853>;
                <D.17852>:
                D.17854 = object_is_live (&dst);
                if (D.17854 == 0) goto <D.17855>; else goto <D.17856>;
                <D.17855>:
                dyn_array_ptr_add (&dfs_stack, obj_entry);
                dst.12 = dst;
                D.17857 = get_hash_entry (dst.12, 0B);
                dyn_array_ptr_add (&dfs_stack, D.17857);
                <D.17856>:
                <D.17853>:
              }
            finally
              {
                dst = {CLOBBER};
              }
          }
          _objptr = _objptr + 4;
        }
        <D.17371>:
        if (_bmap != 0) goto <D.17370>; else goto <D.17372>;
        <D.17372>:
      }
      goto <D.17362>;
      <D.17373>:
      D.17858 = desc & 4294950912;
      if (D.17858 != 0) goto <D.17859>; else goto <D.17860>;
      <D.17859>:
      {
        int el_size;
        int etype;

        D.17861 = desc >> 3;
        D.17862 = (int) D.17861;
        el_size = D.17862 & 1023;
        desc.13 = (int) desc;
        etype = desc.13 & 49152;
        if (etype == 16384) goto <D.17864>; else goto <D.17865>;
        <D.17864>:
        {
          void * * p;
          void * * end_refs;

          p = start + 16;
          D.17866 = MEM[(struct MonoArray *)start].max_length;
          el_size.14 = (unsigned int) el_size;
          D.17868 = D.17866 * el_size.14;
          end_refs = p + D.17868;
          goto <D.17380>;
          <D.17379>:
          {
            struct MonoObject * dst;

            try
              {
                dst.15 = *p;
                dst = dst.15;
                dst.16 = dst;
                if (dst.16 != 0B) goto <D.17871>; else goto <D.17872>;
                <D.17871>:
                D.17873 = object_is_live (&dst);
                if (D.17873 == 0) goto <D.17874>; else goto <D.17875>;
                <D.17874>:
                dyn_array_ptr_add (&dfs_stack, obj_entry);
                dst.16 = dst;
                D.17876 = get_hash_entry (dst.16, 0B);
                dyn_array_ptr_add (&dfs_stack, D.17876);
                <D.17875>:
                <D.17872>:
              }
            finally
              {
                dst = {CLOBBER};
              }
          }
          p = p + 4;
          <D.17380>:
          if (p < end_refs) goto <D.17379>; else goto <D.17381>;
          <D.17381>:
        }
        goto <D.17877>;
        <D.17865>:
        if (etype == 32768) goto <D.17878>; else goto <D.17879>;
        <D.17878>:
        {
          int offset;
          int num_refs;
          char * e_start;
          char * e_end;

          D.17817 = desc >> 16;
          D.17880 = (int) D.17817;
          offset = D.17880 & 255;
          D.17820 = desc >> 24;
          num_refs = (int) D.17820;
          e_start = start + 16;
          D.17866 = MEM[(struct MonoArray *)start].max_length;
          el_size.14 = (unsigned int) el_size;
          D.17868 = D.17866 * el_size.14;
          e_end = e_start + D.17868;
          goto <D.17393>;
          <D.17392>:
          {
            void * * p;
            int i;

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

              try
                {
                  i.18 = (unsigned int) i;
                  D.17884 = i.18 * 4;
                  D.17885 = p + D.17884;
                  dst.19 = *D.17885;
                  dst = dst.19;
                  dst.20 = dst;
                  if (dst.20 != 0B) goto <D.17888>; else goto <D.17889>;
                  <D.17888>:
                  D.17890 = object_is_live (&dst);
                  if (D.17890 == 0) goto <D.17891>; else goto <D.17892>;
                  <D.17891>:
                  dyn_array_ptr_add (&dfs_stack, obj_entry);
                  dst.20 = dst;
                  D.17893 = get_hash_entry (dst.20, 0B);
                  dyn_array_ptr_add (&dfs_stack, D.17893);
                  <D.17892>:
                  <D.17889>:
                }
              finally
                {
                  dst = {CLOBBER};
                }
            }
            i = i + 1;
            <D.17390>:
            if (i < num_refs) goto <D.17389>; else goto <D.17391>;
            <D.17391>:
            el_size.21 = (sizetype) el_size;
            e_start = e_start + el_size.21;
          }
          <D.17393>:
          if (e_start < e_end) goto <D.17392>; else goto <D.17394>;
          <D.17394>:
        }
        goto <D.17895>;
        <D.17879>:
        if (etype == 49152) goto <D.17896>; else goto <D.17897>;
        <D.17896>:
        {
          char * e_start;
          char * e_end;

          e_start = start + 16;
          D.17866 = MEM[(struct MonoArray *)start].max_length;
          el_size.14 = (unsigned int) el_size;
          D.17868 = D.17866 * el_size.14;
          e_end = e_start + D.17868;
          goto <D.17404>;
          <D.17403>:
          {
            void * * p;
            gsize _bmap;

            p = e_start;
            _bmap = desc >> 16;
            goto <D.17401>;
            <D.17400>:
            D.17898 = _bmap & 1;
            if (D.17898 != 0) goto <D.17899>; else goto <D.17900>;
            <D.17899>:
            {
              struct MonoObject * dst;

              try
                {
                  dst.22 = *p;
                  dst = dst.22;
                  dst.23 = dst;
                  if (dst.23 != 0B) goto <D.17903>; else goto <D.17904>;
                  <D.17903>:
                  D.17905 = object_is_live (&dst);
                  if (D.17905 == 0) goto <D.17906>; else goto <D.17907>;
                  <D.17906>:
                  dyn_array_ptr_add (&dfs_stack, obj_entry);
                  dst.23 = dst;
                  D.17908 = get_hash_entry (dst.23, 0B);
                  dyn_array_ptr_add (&dfs_stack, D.17908);
                  <D.17907>:
                  <D.17904>:
                }
              finally
                {
                  dst = {CLOBBER};
                }
            }
            <D.17900>:
            _bmap = _bmap >> 1;
            p = p + 4;
            <D.17401>:
            if (_bmap != 0) goto <D.17400>; else goto <D.17402>;
            <D.17402>:
            el_size.21 = (sizetype) el_size;
            e_start = e_start + el_size.21;
          }
          <D.17404>:
          if (e_start < e_end) goto <D.17403>; else goto <D.17405>;
          <D.17405>:
        }
        <D.17897>:
        <D.17895>:
        <D.17877>:
      }
      <D.17860>:
      goto <D.17362>;
      <D.17406>:
      {
        void * * _objptr;
        gsize _bmap;

        _objptr = start;
        _bmap = desc >> 3;
        _objptr = _objptr + 8;
        goto <D.17411>;
        <D.17410>:
        D.17909 = _bmap & 1;
        if (D.17909 != 0) goto <D.17910>; else goto <D.17911>;
        <D.17910>:
        {
          struct MonoObject * dst;

          try
            {
              dst.24 = *_objptr;
              dst = dst.24;
              dst.25 = dst;
              if (dst.25 != 0B) goto <D.17914>; else goto <D.17915>;
              <D.17914>:
              D.17916 = object_is_live (&dst);
              if (D.17916 == 0) goto <D.17917>; else goto <D.17918>;
              <D.17917>:
              dyn_array_ptr_add (&dfs_stack, obj_entry);
              dst.25 = dst;
              D.17919 = get_hash_entry (dst.25, 0B);
              dyn_array_ptr_add (&dfs_stack, D.17919);
              <D.17918>:
              <D.17915>:
            }
          finally
            {
              dst = {CLOBBER};
            }
        }
        <D.17911>:
        _bmap = _bmap >> 1;
        _objptr = _objptr + 4;
        <D.17411>:
        if (_bmap != 0) goto <D.17410>; else goto <D.17412>;
        <D.17412>:
      }
      goto <D.17362>;
      <D.17413>:
      {
        void * * _objptr;
        gsize * bitmap_data;
        int bwords;
        void * * start_run;

        _objptr = start;
        bitmap_data = sgen_get_complex_descriptor (desc);
        D.17920 = *bitmap_data;
        D.17921 = D.17920 + 4294967295;
        bwords = (int) D.17921;
        start_run = _objptr;
        bitmap_data = bitmap_data + 4;
        if (0 != 0) goto <D.17922>; else goto <D.17923>;
        <D.17922>:
        {
          struct MonoObject * myobj;

          myobj = start;
          D.17924 = myobj->vtable;
          D.17925 = D.17924->klass;
          D.17926 = D.17925->name_space;
          D.17924 = myobj->vtable;
          D.17925 = D.17924->klass;
          D.17927 = D.17925->name;
          monoeg_g_print ("found %d at %p (0x%zx): %s.%s\n", bwords, start, desc, D.17926, D.17927);
        }
        <D.17923>:
        goto <D.17425>;
        <D.17424>:
        {
          gsize _bmap;

          bitmap_data.26 = bitmap_data;
          bitmap_data = bitmap_data.26 + 4;
          _bmap = *bitmap_data.26;
          _objptr = start_run;
          goto <D.17422>;
          <D.17421>:
          D.17929 = _bmap & 1;
          if (D.17929 != 0) goto <D.17930>; else goto <D.17931>;
          <D.17930>:
          {
            struct MonoObject * dst;

            try
              {
                dst.27 = *_objptr;
                dst = dst.27;
                dst.28 = dst;
                if (dst.28 != 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.28 = dst;
                D.17939 = get_hash_entry (dst.28, 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.17422>:
          if (_bmap != 0) goto <D.17421>; else goto <D.17423>;
          <D.17423>:
          start_run = start_run + 128;
        }
        <D.17425>:
        bwords.29 = bwords;
        bwords = bwords.29 + -1;
        if (bwords.29 > 0) goto <D.17424>; else goto <D.17426>;
        <D.17426>:
      }
      goto <D.17362>;
      <D.17427>:
      {
        gsize * mbitmap_data;
        int mbwords;
        int el_size;
        char * e_start;
        char * e_end;

        D.17941 = vt->desc;
        mbitmap_data = sgen_get_complex_descriptor (D.17941);
        mbitmap_data.30 = mbitmap_data;
        mbitmap_data = mbitmap_data.30 + 4;
        D.17943 = *mbitmap_data.30;
        D.17944 = D.17943 + 4294967295;
        mbwords = (int) D.17944;
        D.17945 = vt->klass;
        el_size = mono_array_element_size (D.17945);
        e_start = start + 16;
        D.17866 = MEM[(struct MonoArray *)start].max_length;
        el_size.31 = (unsigned int) el_size;
        D.17947 = D.17866 * el_size.31;
        e_end = e_start + D.17947;
        if (0 != 0) goto <D.17948>; else goto <D.17949>;
        <D.17948>:
        D.17941 = vt->desc;
        D.17945 = vt->klass;
        D.17950 = D.17945->name_space;
        D.17945 = vt->klass;
        D.17951 = D.17945->name;
        monoeg_g_print ("found %d at %p (0x%zx): %s.%s\n", mbwords, start, D.17941, D.17950, D.17951);
        <D.17949>:
        goto <D.17446>;
        <D.17445>:
        {
          void * * _objptr;
          gsize * bitmap_data;
          unsigned int bwords;

          _objptr = e_start;
          bitmap_data = mbitmap_data;
          bwords = (unsigned int) mbwords;
          goto <D.17443>;
          <D.17442>:
          {
            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.17440>;
            <D.17439>:
            D.17953 = _bmap & 1;
            if (D.17953 != 0) goto <D.17954>; else goto <D.17955>;
            <D.17954>:
            {
              struct MonoObject * dst;

              try
                {
                  dst.33 = *_objptr;
                  dst = dst.33;
                  dst.34 = dst;
                  if (dst.34 != 0B) goto <D.17958>; else goto <D.17959>;
                  <D.17958>:
                  D.17960 = object_is_live (&dst);
                  if (D.17960 == 0) goto <D.17961>; else goto <D.17962>;
                  <D.17961>:
                  dyn_array_ptr_add (&dfs_stack, obj_entry);
                  dst.34 = dst;
                  D.17963 = get_hash_entry (dst.34, 0B);
                  dyn_array_ptr_add (&dfs_stack, D.17963);
                  <D.17962>:
                  <D.17959>:
                }
              finally
                {
                  dst = {CLOBBER};
                }
            }
            <D.17955>:
            _bmap = _bmap >> 1;
            _objptr = _objptr + 4;
            <D.17440>:
            if (_bmap != 0) goto <D.17439>; else goto <D.17441>;
            <D.17441>:
            _objptr = start_run + 128;
          }
          <D.17443>:
          bwords.35 = bwords;
          bwords = bwords.35 + 4294967295;
          if (bwords.35 != 0) goto <D.17442>; else goto <D.17444>;
          <D.17444>:
          el_size.36 = (sizetype) el_size;
          e_start = e_start + el_size.36;
        }
        <D.17446>:
        if (e_start < e_end) goto <D.17445>; else goto <D.17447>;
        <D.17447>:
      }
      goto <D.17362>;
      <D.17448>:
      goto <D.17362>;
      <D.17449>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "sgen-scan-object.h", 111);
      <D.17362>:
    }
    goto <D.17966>;
    <D.17804>:
    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.17966>:
  }
  <D.17351>:
  D.17795 = dfs_stack.size;
  if (D.17795 > 0) goto <D.17450>; else goto <D.17451>;
  <D.17451>:
}


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

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


object_is_live (struct MonoObject * * objp)
{
  struct MonoObject * iftmp.40;
  unsigned int D.17974;
  unsigned int D.17975;
  unsigned int D.17978;
  gboolean D.17982;
  void * D.17983;
  _Bool D.17984;
  int D.17985;
  void * D.17988;
  _Bool D.17989;
  struct MonoObject * obj;
  struct MonoObject * fwd;

  obj = *objp;
  D.17974 = MEM[(mword *)obj];
  D.17975 = D.17974 & 1;
  if (D.17975 != 0) goto <D.17976>; else goto <D.17977>;
  <D.17976>:
  D.17974 = MEM[(mword *)obj];
  D.17978 = D.17974 & 4294967292;
  iftmp.40 = (struct MonoObject *) D.17978;
  goto <D.17979>;
  <D.17977>:
  iftmp.40 = 0B;
  <D.17979>:
  fwd = iftmp.40;
  if (fwd != 0B) goto <D.17980>; else goto <D.17981>;
  <D.17980>:
  *objp = fwd;
  D.17983 = sgen_hash_table_lookup (&hash_table, fwd);
  D.17984 = D.17983 == 0B;
  D.17982 = (gboolean) D.17984;
  return D.17982;
  <D.17981>:
  D.17985 = sgen_object_is_live (obj);
  if (D.17985 == 0) goto <D.17986>; else goto <D.17987>;
  <D.17986>:
  D.17982 = 0;
  return D.17982;
  <D.17987>:
  D.17988 = sgen_hash_table_lookup (&hash_table, obj);
  D.17989 = D.17988 == 0B;
  D.17982 = (gboolean) D.17989;
  return D.17982;
}


dyn_array_ptr_pop (struct DynArray * da)
{
  int D.17991;
  _Bool D.17992;
  long int D.17993;
  long int D.17994;
  char * D.17997;
  sizetype D.17998;
  sizetype D.17999;
  sizetype D.18000;
  void * * D.18001;
  int D.18002;
  void * D.18003;
  void * p;

  D.17991 = da->size;
  D.17992 = D.17991 <= 0;
  D.17993 = (long int) D.17992;
  D.17994 = __builtin_expect (D.17993, 0);
  if (D.17994 != 0) goto <D.17995>; else goto <D.17996>;
  <D.17995>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-bridge.c", 142, "da->size > 0");
  <D.17996>:
  D.17997 = da->data;
  D.17991 = da->size;
  D.17998 = (sizetype) D.17991;
  D.17999 = D.17998 + 1073741823;
  D.18000 = D.17999 * 4;
  D.18001 = D.17997 + D.18000;
  p = *D.18001;
  D.17991 = da->size;
  D.18002 = D.17991 + -1;
  da->size = D.18002;
  D.18003 = p;
  return D.18003;
}


register_finishing_time (struct HashEntry * entry, int t)
{
  int D.18005;
  _Bool D.18006;
  long int D.18007;
  long int D.18008;

  D.18005 = entry->finishing_time;
  D.18006 = D.18005 >= 0;
  D.18007 = (long int) D.18006;
  D.18008 = __builtin_expect (D.18007, 0);
  if (D.18008 != 0) goto <D.18009>; else goto <D.18010>;
  <D.18009>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-bridge.c", 387, "entry->finishing_time < 0");
  <D.18010>:
  entry->finishing_time = t;
}


sgen_bridge_processing_finish (int generation)
{
  int D.18011;
  int bridge_processing_in_progress.41;
  _Bool D.18015;
  long int D.18016;
  long int D.18017;
  unsigned int D.18020;
  unsigned int D.18021;
  unsigned int D.18022;
  int D.18023;
  _Bool D.18024;
  long int D.18025;
  long int D.18026;
  int j.42;
  unsigned int j.43;
  unsigned int D.18031;
  struct HashEntry * * D.18032;
  int D.18033;
  int fist_pass_links.44;
  int fist_pass_links.45;
  struct SgenHashTableEntry * D.18036;
  unsigned int D.18037;
  unsigned int j.46;
  _Bool D.18039;
  long int D.18040;
  long int D.18041;
  long long int D.18044;
  long long int D.18045;
  long unsigned int step_3.47;
  unsigned int i.48;
  unsigned int D.18048;
  struct HashEntry * * D.18049;
  int D.18050;
  void * current_scc.49;
  struct SCC * current_scc.50;
  struct DynArray * D.18055;
  unsigned int i.51;
  int D.18057;
  int second_pass_links.52;
  int second_pass_links.53;
  long long int D.18060;
  long long int D.18061;
  long unsigned int step_4.54;
  char * D.18063;
  int D.18064;
  int D.18065;
  sizetype D.18066;
  int D.18067;
  _Bool D.18068;
  long int D.18069;
  long int D.18070;
  int D.18073;
  int D.18076;
  int sccs_links.55;
  int sccs_links.56;
  int max_sccs_links.57;
  int max_sccs_links.58;
  int D.18081;
  unsigned int num_sccs.59;
  unsigned int D.18083;
  int D.18084;
  unsigned int j.60;
  unsigned int D.18088;
  struct MonoGCBridgeSCC * * D.18089;
  unsigned int D.18090;
  unsigned int D.18091;
  unsigned int D.18092;
  void * D.18093;
  struct MonoGCBridgeSCC * D.18094;
  int j.61;
  int D.18096;
  unsigned int D.18097;
  int D.18098;
  int D.18101;
  int D.18102;
  sizetype D.18103;
  int D.18104;
  unsigned int D.18105;
  unsigned int D.18106;
  struct MonoGCBridgeSCC * * D.18107;
  struct MonoGCBridgeSCC * D.18108;
  int D.18109;
  int D.18110;
  int D.18111;
  struct MonoObject * D.18112;
  struct SgenHashTableEntry * D.18113;
  unsigned int num_xrefs.62;
  unsigned int D.18115;
  int D.18116;
  char * D.18119;
  unsigned int k.63;
  unsigned int D.18121;
  int * D.18122;
  int D.18123;
  int D.18124;
  sizetype D.18125;
  int D.18126;
  unsigned int D.18129;
  struct MonoGCBridgeXRef * D.18130;
  int D.18131;
  int D.18132;
  int D.18133;
  int D.18134;
  int D.18139;
  struct DynArray * D.18142;
  void (*<T2e36>) (int, struct MonoGCBridgeSCC * *, int, struct MonoGCBridgeXRef *) D.18143;
  struct MonoGCBridgeSCC * * D.18144;
  struct MonoGCBridgeSCC * D.18145;
  int D.18146;
  _Bool D.18147;
  unsigned char alive.64;
  struct MonoObject * D.18149;
  int D.18152;
  unsigned int D.18155;
  unsigned int D.18156;
  unsigned int D.18157;
  long unsigned int step_1.65;
  float D.18159;
  float D.18160;
  double D.18161;
  long unsigned int step_2.66;
  float D.18163;
  float D.18164;
  double D.18165;
  long unsigned int step_3.67;
  float D.18167;
  float D.18168;
  double D.18169;
  long unsigned int step_4.68;
  float D.18171;
  float D.18172;
  double D.18173;
  long unsigned int step_5.69;
  float D.18175;
  float D.18176;
  double D.18177;
  long unsigned int step_6.70;
  float D.18179;
  float D.18180;
  double D.18181;
  long unsigned int step_7.71;
  float D.18183;
  float D.18184;
  double D.18185;
  long unsigned int step_8.72;
  float D.18187;
  float D.18188;
  double D.18189;
  int dsf1_passes.73;
  int dsf2_passes.74;
  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.18011 = registered_bridges.size;
      if (D.18011 == 0) goto <D.18012>; else goto <D.18013>;
      <D.18012>:
      return;
      <D.18013>:
      bridge_processing_in_progress.41 = bridge_processing_in_progress;
      D.18015 = bridge_processing_in_progress.41 == 0;
      D.18016 = (long int) D.18015;
      D.18017 = __builtin_expect (D.18016, 0);
      if (D.18017 != 0) goto <D.18018>; else goto <D.18019>;
      <D.18018>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-bridge.c", 620, "bridge_processing_in_progress");
      <D.18019>:
      atv = mono_100ns_ticks ();
      D.18020 = hash_table.num_entries;
      D.18021 = D.18020 * 4;
      all_entries = sgen_alloc_internal_dynamic (D.18021, 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.17548>;
        <D.17547>:
        {
          struct SgenHashTableEntry * * __iter;
          struct SgenHashTableEntry * * __next;

          D.18022 = __i * 4;
          __iter = __table + D.18022;
          goto <D.17545>;
          <D.17544>:
          {
            struct SgenHashTableEntry * __entry;

            __entry = *__iter;
            __next = &__entry->next;
            obj = __entry->key;
            entry = &__entry->data;
            D.18023 = entry->finishing_time;
            D.18024 = D.18023 < 0;
            D.18025 = (long int) D.18024;
            D.18026 = __builtin_expect (D.18025, 0);
            if (D.18026 != 0) goto <D.18027>; else goto <D.18028>;
            <D.18027>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-bridge.c", 630, "entry->finishing_time >= 0");
            <D.18028>:
            j.42 = j;
            j = j.42 + 1;
            j.43 = (unsigned int) j.42;
            D.18031 = j.43 * 4;
            D.18032 = all_entries + D.18031;
            *D.18032 = entry;
            D.18033 = entry->srcs.size;
            fist_pass_links.44 = fist_pass_links;
            fist_pass_links.45 = D.18033 + fist_pass_links.44;
            fist_pass_links = fist_pass_links.45;
          }
          __iter = __next;
          <D.17545>:
          D.18036 = *__iter;
          if (D.18036 != 0B) goto <D.17544>; else goto <D.17546>;
          <D.17546>:
        }
        __i = __i + 1;
        <D.17548>:
        D.18037 = hash_table.size;
        if (D.18037 > __i) goto <D.17547>; else goto <D.17549>;
        <D.17549>:
      }
      j.46 = (unsigned int) j;
      D.18020 = hash_table.num_entries;
      D.18039 = j.46 != D.18020;
      D.18040 = (long int) D.18039;
      D.18041 = __builtin_expect (D.18040, 0);
      if (D.18041 != 0) goto <D.18042>; else goto <D.18043>;
      <D.18042>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-bridge.c", 634, "j == hash_table.num_entries");
      <D.18043>:
      D.18020 = hash_table.num_entries;
      hash_table_size = (int) D.18020;
      D.18020 = hash_table.num_entries;
      sgen_qsort (all_entries, D.18020, 4, compare_hash_entries);
      btv = mono_100ns_ticks ();
      D.18044 = btv - atv;
      D.18045 = D.18044 / 10;
      step_3.47 = (long unsigned int) D.18045;
      step_3 = step_3.47;
      dyn_array_init (&sccs, 28);
      i = 0;
      goto <D.17553>;
      <D.17552>:
      {
        struct HashEntry * entry;

        i.48 = (unsigned int) i;
        D.18048 = i.48 * 4;
        D.18049 = all_entries + D.18048;
        entry = *D.18049;
        D.18050 = entry->scc_index;
        if (D.18050 < 0) goto <D.18051>; else goto <D.18052>;
        <D.18051>:
        {
          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.18055 = &current_scc.50->xrefs;
          dyn_array_int_init (D.18055);
          dfs2 (entry);
        }
        <D.18052>:
      }
      i = i + 1;
      <D.17553>:
      i.51 = (unsigned int) i;
      D.18020 = hash_table.num_entries;
      if (i.51 < D.18020) goto <D.17552>; else goto <D.17554>;
      <D.17554>:
      sccs_size = sccs.size;
      i = 0;
      goto <D.17557>;
      <D.17556>:
      {
        struct HashEntry * entry;

        i.48 = (unsigned int) i;
        D.18048 = i.48 * 4;
        D.18049 = all_entries + D.18048;
        entry = *D.18049;
        D.18057 = entry->srcs.size;
        second_pass_links.52 = second_pass_links;
        second_pass_links.53 = D.18057 + second_pass_links.52;
        second_pass_links = second_pass_links.53;
      }
      i = i + 1;
      <D.17557>:
      i.51 = (unsigned int) i;
      D.18020 = hash_table.num_entries;
      if (i.51 < D.18020) goto <D.17556>; else goto <D.17558>;
      <D.17558>:
      atv = mono_100ns_ticks ();
      D.18060 = atv - btv;
      D.18061 = D.18060 / 10;
      step_4.54 = (long unsigned int) D.18061;
      step_4 = step_4.54;
      dyn_array_uninit (&dfs_stack);
      num_sccs = 0;
      i = 0;
      goto <D.17561>;
      <D.17560>:
      {
        struct SCC * scc;

        D.18063 = sccs.data;
        D.18064 = sccs.elem_size;
        D.18065 = D.18064 * i;
        D.18066 = (sizetype) D.18065;
        scc = D.18063 + D.18066;
        D.18067 = scc->index;
        D.18068 = D.18067 != i;
        D.18069 = (long int) D.18068;
        D.18070 = __builtin_expect (D.18069, 0);
        if (D.18070 != 0) goto <D.18071>; else goto <D.18072>;
        <D.18071>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-bridge.c", 680, "scc->index == i");
        <D.18072>:
        D.18073 = scc->num_bridge_entries;
        if (D.18073 != 0) goto <D.18074>; else goto <D.18075>;
        <D.18074>:
        num_sccs = num_sccs + 1;
        <D.18075>:
        D.18076 = scc->xrefs.size;
        sccs_links.55 = sccs_links;
        sccs_links.56 = D.18076 + sccs_links.55;
        sccs_links = sccs_links.56;
        D.18076 = scc->xrefs.size;
        max_sccs_links.57 = max_sccs_links;
        max_sccs_links.58 = MAX_EXPR <D.18076, max_sccs_links.57>;
        max_sccs_links = max_sccs_links.58;
      }
      i = i + 1;
      <D.17561>:
      D.18081 = sccs.size;
      if (D.18081 > i) goto <D.17560>; else goto <D.17562>;
      <D.17562>:
      num_sccs.59 = (unsigned int) num_sccs;
      D.18083 = num_sccs.59 * 4;
      api_sccs = sgen_alloc_internal_dynamic (D.18083, 21, 1);
      num_xrefs = 0;
      j = 0;
      i = 0;
      goto <D.17566>;
      <D.17565>:
      {
        struct SCC * scc;

        D.18063 = sccs.data;
        D.18064 = sccs.elem_size;
        D.18065 = D.18064 * i;
        D.18066 = (sizetype) D.18065;
        scc = D.18063 + D.18066;
        D.18084 = scc->num_bridge_entries;
        if (D.18084 == 0) goto <D.18085>; else goto <D.18086>;
        <D.18085>:
        // predicted unlikely by continue predictor.
        goto <D.17564>;
        <D.18086>:
        j.60 = (unsigned int) j;
        D.18088 = j.60 * 4;
        D.18089 = api_sccs + D.18088;
        D.18084 = scc->num_bridge_entries;
        D.18090 = (unsigned int) D.18084;
        D.18091 = D.18090 + 2;
        D.18092 = D.18091 * 4;
        D.18093 = sgen_alloc_internal_dynamic (D.18092, 21, 1);
        *D.18089 = D.18093;
        j.60 = (unsigned int) j;
        D.18088 = j.60 * 4;
        D.18089 = api_sccs + D.18088;
        D.18094 = *D.18089;
        D.18094->is_alive = 0;
        j.60 = (unsigned int) j;
        D.18088 = j.60 * 4;
        D.18089 = api_sccs + D.18088;
        D.18094 = *D.18089;
        D.18084 = scc->num_bridge_entries;
        D.18094->num_objs = D.18084;
        scc->num_bridge_entries = 0;
        j.61 = j;
        j = j.61 + 1;
        scc->api_index = j.61;
        D.18096 = scc->xrefs.size;
        num_xrefs = D.18096 + num_xrefs;
      }
      <D.17564>:
      i = i + 1;
      <D.17566>:
      D.18081 = sccs.size;
      if (D.18081 > i) goto <D.17565>; else goto <D.17567>;
      <D.17567>:
      {
        struct SgenHashTable * __hash_table;
        struct SgenHashTableEntry * * __table;
        guint __i;

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

          D.18097 = __i * 4;
          __iter = __table + D.18097;
          goto <D.17576>;
          <D.17575>:
          {
            struct SgenHashTableEntry * __entry;

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

              D.18063 = sccs.data;
              D.18101 = entry->scc_index;
              D.18064 = sccs.elem_size;
              D.18102 = D.18101 * D.18064;
              D.18103 = (sizetype) D.18102;
              scc = D.18063 + D.18103;
              D.18104 = scc->api_index;
              D.18105 = (unsigned int) D.18104;
              D.18106 = D.18105 * 4;
              D.18107 = api_sccs + D.18106;
              D.18108 = *D.18107;
              D.18109 = scc->num_bridge_entries;
              D.18110 = D.18109;
              D.18111 = D.18110 + 1;
              scc->num_bridge_entries = D.18111;
              D.18112 = entry->obj;
              D.18108->objs[D.18110] = D.18112;
            }
            <D.18100>:
          }
          __iter = __next;
          <D.17576>:
          D.18113 = *__iter;
          if (D.18113 != 0B) goto <D.17575>; else goto <D.17577>;
          <D.17577>:
        }
        __i = __i + 1;
        <D.17579>:
        D.18037 = hash_table.size;
        if (D.18037 > __i) goto <D.17578>; else goto <D.17580>;
        <D.17580>:
      }
      num_xrefs.62 = (unsigned int) num_xrefs;
      D.18115 = num_xrefs.62 * 8;
      api_xrefs = sgen_alloc_internal_dynamic (D.18115, 21, 1);
      j = 0;
      i = 0;
      goto <D.17590>;
      <D.17589>:
      {
        int k;
        struct SCC * scc;

        D.18063 = sccs.data;
        D.18064 = sccs.elem_size;
        D.18065 = D.18064 * i;
        D.18066 = (sizetype) D.18065;
        scc = D.18063 + D.18066;
        D.18116 = scc->num_bridge_entries;
        if (D.18116 == 0) goto <D.18117>; else goto <D.18118>;
        <D.18117>:
        // predicted unlikely by continue predictor.
        goto <D.17583>;
        <D.18118>:
        k = 0;
        goto <D.17587>;
        <D.17586>:
        {
          struct SCC * src_scc;

          D.18063 = sccs.data;
          D.18119 = scc->xrefs.data;
          k.63 = (unsigned int) k;
          D.18121 = k.63 * 4;
          D.18122 = D.18119 + D.18121;
          D.18123 = *D.18122;
          D.18064 = sccs.elem_size;
          D.18124 = D.18123 * D.18064;
          D.18125 = (sizetype) D.18124;
          src_scc = D.18063 + D.18125;
          D.18126 = src_scc->num_bridge_entries;
          if (D.18126 == 0) goto <D.18127>; else goto <D.18128>;
          <D.18127>:
          // predicted unlikely by continue predictor.
          goto <D.17585>;
          <D.18128>:
          j.60 = (unsigned int) j;
          D.18129 = j.60 * 8;
          D.18130 = api_xrefs + D.18129;
          D.18131 = src_scc->api_index;
          D.18130->src_scc_index = D.18131;
          j.60 = (unsigned int) j;
          D.18129 = j.60 * 8;
          D.18130 = api_xrefs + D.18129;
          D.18132 = scc->api_index;
          D.18130->dst_scc_index = D.18132;
          j = j + 1;
        }
        <D.17585>:
        k = k + 1;
        <D.17587>:
        D.18133 = scc->xrefs.size;
        if (D.18133 > k) goto <D.17586>; else goto <D.17588>;
        <D.17588>:
      }
      <D.17583>:
      i = i + 1;
      <D.17590>:
      D.18081 = sccs.size;
      if (D.18081 > i) goto <D.17589>; else goto <D.17591>;
      <D.17591>:
      btv = mono_100ns_ticks ();
      D.18044 = btv - atv;
      D.18045 = D.18044 / 10;
      step_3.47 = (long unsigned int) D.18045;
      step_5 = step_3.47;
      j = 0;
      max_xrefs = 0;
      max_entries = max_xrefs;
      i = 0;
      goto <D.17594>;
      <D.17593>:
      {
        struct SCC * scc;

        D.18063 = sccs.data;
        D.18064 = sccs.elem_size;
        D.18065 = D.18064 * i;
        D.18066 = (sizetype) D.18065;
        scc = D.18063 + D.18066;
        D.18134 = scc->num_bridge_entries;
        if (D.18134 != 0) goto <D.18135>; else goto <D.18136>;
        <D.18135>:
        j = j + 1;
        <D.18136>:
        D.18134 = scc->num_bridge_entries;
        if (D.18134 > max_entries) goto <D.18137>; else goto <D.18138>;
        <D.18137>:
        max_entries = scc->num_bridge_entries;
        <D.18138>:
        D.18139 = scc->xrefs.size;
        if (D.18139 > max_xrefs) goto <D.18140>; else goto <D.18141>;
        <D.18140>:
        max_xrefs = scc->xrefs.size;
        <D.18141>:
        D.18142 = &scc->xrefs;
        dyn_array_uninit (D.18142);
      }
      i = i + 1;
      <D.17594>:
      D.18081 = sccs.size;
      if (D.18081 > i) goto <D.17593>; else goto <D.17595>;
      <D.17595>:
      dyn_array_uninit (&sccs);
      D.18020 = hash_table.num_entries;
      D.18021 = D.18020 * 4;
      sgen_free_internal_dynamic (all_entries, D.18021, 21);
      free_data ();
      num_registered_bridges = registered_bridges.size;
      registered_bridges.size = 0;
      atv = mono_100ns_ticks ();
      D.18060 = atv - btv;
      D.18061 = D.18060 / 10;
      step_4.54 = (long unsigned int) D.18061;
      step_6 = step_4.54;
      D.18143 = bridge_callbacks.cross_references;
      D.18143 (num_sccs, api_sccs, num_xrefs, api_xrefs);
      btv = mono_100ns_ticks ();
      D.18044 = btv - atv;
      D.18045 = D.18044 / 10;
      step_3.47 = (long unsigned int) D.18045;
      step_7 = step_3.47;
      i = 0;
      goto <D.17601>;
      <D.17600>:
      {
        unsigned char alive;

        try
          {
            i.48 = (unsigned int) i;
            D.18048 = i.48 * 4;
            D.18144 = api_sccs + D.18048;
            D.18145 = *D.18144;
            D.18146 = D.18145->is_alive;
            D.18147 = D.18146 != 0;
            alive.64 = (unsigned char) D.18147;
            alive = alive.64;
            j = 0;
            goto <D.17598>;
            <D.17597>:
            i.48 = (unsigned int) i;
            D.18048 = i.48 * 4;
            D.18144 = api_sccs + D.18048;
            D.18145 = *D.18144;
            D.18149 = D.18145->objs[j];
            sgen_hash_table_replace (&alive_hash, D.18149, &alive, 0B);
            i.48 = (unsigned int) i;
            D.18048 = i.48 * 4;
            D.18144 = api_sccs + D.18048;
            D.18145 = *D.18144;
            D.18146 = D.18145->is_alive;
            if (D.18146 == 0) goto <D.18150>; else goto <D.18151>;
            <D.18150>:
            i.48 = (unsigned int) i;
            D.18048 = i.48 * 4;
            D.18144 = api_sccs + D.18048;
            D.18145 = *D.18144;
            D.18149 = D.18145->objs[j];
            sgen_mark_bridge_object (D.18149);
            <D.18151>:
            j = j + 1;
            <D.17598>:
            i.48 = (unsigned int) i;
            D.18048 = i.48 * 4;
            D.18144 = api_sccs + D.18048;
            D.18145 = *D.18144;
            D.18152 = D.18145->num_objs;
            if (D.18152 > j) goto <D.17597>; else goto <D.17599>;
            <D.17599>:
          }
        finally
          {
            alive = {CLOBBER};
          }
      }
      i = i + 1;
      <D.17601>:
      if (i < num_sccs) goto <D.17600>; else goto <D.17602>;
      <D.17602>:
      sgen_null_links_with_predicate (0, is_bridge_object_alive, &alive_hash);
      if (generation == 1) goto <D.18153>; else goto <D.18154>;
      <D.18153>:
      sgen_null_links_with_predicate (1, is_bridge_object_alive, &alive_hash);
      <D.18154>:
      sgen_hash_table_clean (&alive_hash);
      i = 0;
      goto <D.17604>;
      <D.17603>:
      i.48 = (unsigned int) i;
      D.18048 = i.48 * 4;
      D.18144 = api_sccs + D.18048;
      D.18145 = *D.18144;
      i.48 = (unsigned int) i;
      D.18048 = i.48 * 4;
      D.18144 = api_sccs + D.18048;
      D.18145 = *D.18144;
      D.18152 = D.18145->num_objs;
      D.18155 = (unsigned int) D.18152;
      D.18156 = D.18155 + 2;
      D.18157 = D.18156 * 4;
      sgen_free_internal_dynamic (D.18145, D.18157, 21);
      i = i + 1;
      <D.17604>:
      if (i < num_sccs) goto <D.17603>; else goto <D.17605>;
      <D.17605>:
      num_sccs.59 = (unsigned int) num_sccs;
      D.18083 = num_sccs.59 * 4;
      sgen_free_internal_dynamic (api_sccs, D.18083, 21);
      num_xrefs.62 = (unsigned int) num_xrefs;
      D.18115 = num_xrefs.62 * 8;
      sgen_free_internal_dynamic (api_xrefs, D.18115, 21);
      atv = mono_100ns_ticks ();
      D.18060 = atv - btv;
      D.18061 = D.18060 / 10;
      step_4.54 = (long unsigned int) D.18061;
      step_8 = step_4.54;
      D.18081 = sccs.size;
      step_1.65 = step_1;
      D.18159 = (float) step_1.65;
      D.18160 = D.18159 / 1.0e+3;
      D.18161 = (double) D.18160;
      step_2.66 = step_2;
      D.18163 = (float) step_2.66;
      D.18164 = D.18163 / 1.0e+3;
      D.18165 = (double) D.18164;
      step_3.67 = step_3;
      D.18167 = (float) step_3.67;
      D.18168 = D.18167 / 1.0e+3;
      D.18169 = (double) D.18168;
      step_4.68 = step_4;
      D.18171 = (float) step_4.68;
      D.18172 = D.18171 / 1.0e+3;
      D.18173 = (double) D.18172;
      step_5.69 = step_5;
      D.18175 = (float) step_5.69;
      D.18176 = D.18175 / 1.0e+3;
      D.18177 = (double) D.18176;
      step_6.70 = step_6;
      D.18179 = (float) step_6.70;
      D.18180 = D.18179 / 1.0e+3;
      D.18181 = (double) D.18180;
      step_7.71 = step_7;
      D.18183 = (float) step_7.71;
      D.18184 = D.18183 / 1.0e+3;
      D.18185 = (double) D.18184;
      step_8.72 = step_8;
      D.18187 = (float) step_8.72;
      D.18188 = D.18187 / 1.0e+3;
      D.18189 = (double) D.18188;
      fist_pass_links.44 = fist_pass_links;
      second_pass_links.52 = second_pass_links;
      sccs_links.55 = sccs_links;
      max_sccs_links.57 = max_sccs_links;
      dsf1_passes.73 = dsf1_passes;
      dsf2_passes.74 = dsf2_passes;
      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.18081, D.18161, D.18165, D.18169, D.18173, D.18177, D.18181, D.18185, D.18189, fist_pass_links.44, second_pass_links.52, sccs_links.55, max_sccs_links.57, dsf1_passes.73, dsf2_passes.74);
      step_1 = 0;
      bridge_processing_in_progress = 0;
    }
  finally
    {
      alive_hash = {CLOBBER};
    }
}


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

  table = data;
  value = sgen_hash_table_lookup (table, obj);
  if (value == 0B) goto <D.18195>; else goto <D.18196>;
  <D.18195>:
  D.18197 = 1;
  return D.18197;
  <D.18196>:
  D.18198 = *value;
  D.18197 = (mono_bool) D.18198;
  return D.18197;
}


compare_hash_entries (const void * ep1, const void * ep2)
{
  int D.18200;
  int D.18201;
  int D.18202;
  struct HashEntry * e1;
  struct HashEntry * e2;

  e1 = MEM[(struct HashEntry * *)ep1];
  e2 = MEM[(struct HashEntry * *)ep2];
  D.18201 = e2->finishing_time;
  D.18202 = e1->finishing_time;
  D.18200 = D.18201 - D.18202;
  return D.18200;
}


dfs2 (struct HashEntry * entry)
{
  int D.18204;
  _Bool D.18205;
  long int D.18206;
  long int D.18207;
  int dsf2_passes.75;
  int dsf2_passes.76;
  int D.18212;
  struct SCC * current_scc.77;
  int D.18216;
  char * D.18219;
  int D.18220;
  int D.18221;
  sizetype D.18222;
  struct SCC * D.18223;
  char * D.18224;
  unsigned int i.78;
  unsigned int D.18226;
  void * * D.18227;
  void * D.18228;
  int D.18229;
  int i;

  D.18204 = dfs_stack.size;
  D.18205 = D.18204 != 0;
  D.18206 = (long int) D.18205;
  D.18207 = __builtin_expect (D.18206, 0);
  if (D.18207 != 0) goto <D.18208>; else goto <D.18209>;
  <D.18208>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-bridge.c", 501, "dfs_stack.size == 0");
  <D.18209>:
  dyn_array_ptr_add (&dfs_stack, entry);
  <D.17474>:
  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.18212 = entry->scc_index;
  if (D.18212 >= 0) goto <D.18213>; else goto <D.18214>;
  <D.18213>:
  D.18212 = entry->scc_index;
  current_scc.77 = current_scc;
  D.18216 = current_scc.77->index;
  if (D.18212 != D.18216) goto <D.18217>; else goto <D.18218>;
  <D.18217>:
  D.18219 = sccs.data;
  D.18212 = entry->scc_index;
  D.18220 = sccs.elem_size;
  D.18221 = D.18212 * D.18220;
  D.18222 = (sizetype) D.18221;
  D.18223 = D.18219 + D.18222;
  current_scc.77 = current_scc;
  scc_add_xref (D.18223, current_scc.77);
  <D.18218>:
  // predicted unlikely by continue predictor.
  goto <D.17470>;
  <D.18214>:
  current_scc.77 = current_scc;
  scc_add_entry (current_scc.77, entry);
  i = 0;
  goto <D.17472>;
  <D.17471>:
  D.18224 = entry->srcs.data;
  i.78 = (unsigned int) i;
  D.18226 = i.78 * 4;
  D.18227 = D.18224 + D.18226;
  D.18228 = *D.18227;
  dyn_array_ptr_add (&dfs_stack, D.18228);
  i = i + 1;
  <D.17472>:
  D.18229 = entry->srcs.size;
  if (D.18229 > i) goto <D.17471>; else goto <D.17473>;
  <D.17473>:
  <D.17470>:
  D.18204 = dfs_stack.size;
  if (D.18204 > 0) goto <D.17474>; else goto <D.17475>;
  <D.17475>:
}


scc_add_xref (struct SCC * src, struct SCC * dst)
{
  _Bool D.18230;
  long int D.18231;
  long int D.18232;
  int D.18235;
  int D.18236;
  _Bool D.18237;
  long int D.18238;
  long int D.18239;
  struct DynArray * D.18242;
  int D.18243;
  int D.18246;
  struct DynArray * D.18250;
  char * D.18251;
  unsigned int i.79;
  unsigned int D.18253;
  int * D.18254;
  int D.18255;
  _Bool D.18256;
  long int D.18257;
  long int D.18258;
  int D.18261;

  D.18230 = src == dst;
  D.18231 = (long int) D.18230;
  D.18232 = __builtin_expect (D.18231, 0);
  if (D.18232 != 0) goto <D.18233>; else goto <D.18234>;
  <D.18233>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-bridge.c", 469, "src != dst");
  <D.18234>:
  D.18235 = src->index;
  D.18236 = dst->index;
  D.18237 = D.18235 == D.18236;
  D.18238 = (long int) D.18237;
  D.18239 = __builtin_expect (D.18238, 0);
  if (D.18239 != 0) goto <D.18240>; else goto <D.18241>;
  <D.18240>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-bridge.c", 470, "src->index != dst->index");
  <D.18241>:
  D.18242 = &dst->xrefs;
  D.18235 = src->index;
  D.18243 = dyn_array_int_contains (D.18242, D.18235);
  if (D.18243 != 0) goto <D.18244>; else goto <D.18245>;
  <D.18244>:
  return;
  <D.18245>:
  D.18246 = src->num_bridge_entries;
  if (D.18246 != 0) goto <D.18247>; else goto <D.18248>;
  <D.18247>:
  D.18242 = &dst->xrefs;
  D.18235 = src->index;
  dyn_array_int_merge_one (D.18242, D.18235);
  goto <D.18249>;
  <D.18248>:
  {
    int i;

    D.18242 = &dst->xrefs;
    D.18250 = &src->xrefs;
    dyn_array_int_merge (D.18242, D.18250);
    i = 0;
    goto <D.17458>;
    <D.17457>:
    D.18251 = dst->xrefs.data;
    i.79 = (unsigned int) i;
    D.18253 = i.79 * 4;
    D.18254 = D.18251 + D.18253;
    D.18255 = *D.18254;
    D.18236 = dst->index;
    D.18256 = D.18255 == D.18236;
    D.18257 = (long int) D.18256;
    D.18258 = __builtin_expect (D.18257, 0);
    if (D.18258 != 0) goto <D.18259>; else goto <D.18260>;
    <D.18259>:
    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.18260>:
    i = i + 1;
    <D.17458>:
    D.18261 = dst->xrefs.size;
    if (D.18261 > i) goto <D.17457>; else goto <D.17459>;
    <D.17459>:
  }
  <D.18249>:
}


dyn_array_int_contains (struct DynArray * da, int x)
{
  char * D.18263;
  unsigned int i.80;
  unsigned int D.18265;
  int * D.18266;
  int D.18267;
  gboolean D.18270;
  int D.18271;
  int i;

  i = 0;
  goto <D.17238>;
  <D.17237>:
  D.18263 = da->data;
  i.80 = (unsigned int) i;
  D.18265 = i.80 * 4;
  D.18266 = D.18263 + D.18265;
  D.18267 = *D.18266;
  if (D.18267 == x) goto <D.18268>; else goto <D.18269>;
  <D.18268>:
  D.18270 = 1;
  return D.18270;
  <D.18269>:
  i = i + 1;
  <D.17238>:
  D.18271 = da->size;
  if (D.18271 > i) goto <D.17237>; else goto <D.17239>;
  <D.17239>:
  D.18270 = 0;
  return D.18270;
}


dyn_array_int_merge_one (struct DynArray * array, int value)
{
  char * D.18273;
  unsigned int i.81;
  unsigned int D.18275;
  int * D.18276;
  int D.18277;
  int D.18281;
  int D.18282;
  sizetype i.82;
  sizetype D.18286;
  sizetype D.18287;
  int * D.18288;
  sizetype end.83;
  sizetype D.18290;
  sizetype D.18291;
  int * D.18292;
  unsigned int end.84;
  unsigned int D.18295;
  int * D.18296;
  int i;
  int tmp;
  int end;

  end = array->size;
  i = 0;
  goto <D.17261>;
  <D.17260>:
  D.18273 = array->data;
  i.81 = (unsigned int) i;
  D.18275 = i.81 * 4;
  D.18276 = D.18273 + D.18275;
  D.18277 = *D.18276;
  if (D.18277 == value) goto <D.18278>; else goto <D.18279>;
  <D.18278>:
  return;
  <D.18279>:
  D.18273 = array->data;
  i.81 = (unsigned int) i;
  D.18275 = i.81 * 4;
  D.18276 = D.18273 + D.18275;
  D.18277 = *D.18276;
  if (D.18277 > value) goto <D.17259>; else goto <D.18280>;
  <D.18280>:
  i = i + 1;
  <D.17261>:
  if (i < end) goto <D.17260>; else goto <D.17259>;
  <D.17259>:
  D.18281 = array->size;
  D.18282 = D.18281 + 1;
  dyn_array_ensure_capacity (array, D.18282);
  if (i < end) goto <D.18283>; else goto <D.18284>;
  <D.18283>:
  D.18273 = array->data;
  i.81 = (unsigned int) i;
  D.18275 = i.81 * 4;
  D.18276 = D.18273 + D.18275;
  tmp = *D.18276;
  goto <D.17263>;
  <D.17262>:
  D.18273 = array->data;
  i.81 = (unsigned int) i;
  D.18275 = i.81 * 4;
  D.18276 = D.18273 + D.18275;
  *D.18276 = value;
  value = tmp;
  D.18273 = array->data;
  i.82 = (sizetype) i;
  D.18286 = i.82 + 1;
  D.18287 = D.18286 * 4;
  D.18288 = D.18273 + D.18287;
  tmp = *D.18288;
  i = i + 1;
  <D.17263>:
  if (i <= end) goto <D.17262>; else goto <D.17264>;
  <D.17264>:
  D.18273 = array->data;
  end.83 = (sizetype) end;
  D.18290 = end.83 + 1;
  D.18291 = D.18290 * 4;
  D.18292 = D.18273 + D.18291;
  *D.18292 = tmp;
  goto <D.18293>;
  <D.18284>:
  D.18273 = array->data;
  end.84 = (unsigned int) end;
  D.18295 = end.84 * 4;
  D.18296 = D.18273 + D.18295;
  *D.18296 = value;
  <D.18293>:
  D.18281 = array->size;
  D.18282 = D.18281 + 1;
  array->size = D.18282;
}


dyn_array_int_merge (struct DynArray * dst, struct DynArray * src)
{
  int D.18298;
  int D.18299;
  int D.18300;
  char * D.18305;
  unsigned int i.85;
  unsigned int D.18307;
  int * D.18308;
  char * D.18309;
  unsigned int j.86;
  unsigned int D.18311;
  int * D.18312;
  int D.18321;
  int D.18323;
  int D.18325;
  char * D.18328;
  int D.18329;
  int D.18330;
  unsigned int D.18331;
  int i;
  int j;

  D.18298 = dst->size;
  D.18299 = src->size;
  D.18300 = D.18298 + D.18299;
  dyn_array_ensure_capacity (&merge_array, D.18300);
  merge_array.size = 0;
  j = 0;
  i = j;
  goto <D.17250>;
  <D.17249>:
  D.18298 = dst->size;
  if (D.18298 > i) goto <D.18303>; else goto <D.18301>;
  <D.18303>:
  D.18299 = src->size;
  if (D.18299 > j) goto <D.18304>; else goto <D.18301>;
  <D.18304>:
  {
    int a;
    int b;

    D.18305 = dst->data;
    i.85 = (unsigned int) i;
    D.18307 = i.85 * 4;
    D.18308 = D.18305 + D.18307;
    a = *D.18308;
    D.18309 = src->data;
    j.86 = (unsigned int) j;
    D.18311 = j.86 * 4;
    D.18312 = D.18309 + D.18311;
    b = *D.18312;
    if (a < b) goto <D.18313>; else goto <D.18314>;
    <D.18313>:
    dyn_array_int_add (&merge_array, a);
    i = i + 1;
    goto <D.18315>;
    <D.18314>:
    if (a == b) goto <D.18316>; else goto <D.18317>;
    <D.18316>:
    dyn_array_int_add (&merge_array, a);
    i = i + 1;
    j = j + 1;
    goto <D.18318>;
    <D.18317>:
    dyn_array_int_add (&merge_array, b);
    j = j + 1;
    <D.18318>:
    <D.18315>:
  }
  goto <D.18302>;
  <D.18301>:
  D.18298 = dst->size;
  if (D.18298 > i) goto <D.18319>; else goto <D.18320>;
  <D.18319>:
  D.18305 = dst->data;
  i.85 = (unsigned int) i;
  D.18307 = i.85 * 4;
  D.18308 = D.18305 + D.18307;
  D.18321 = *D.18308;
  dyn_array_int_add (&merge_array, D.18321);
  i = i + 1;
  goto <D.18322>;
  <D.18320>:
  D.18309 = src->data;
  j.86 = (unsigned int) j;
  D.18311 = j.86 * 4;
  D.18312 = D.18309 + D.18311;
  D.18323 = *D.18312;
  dyn_array_int_add (&merge_array, D.18323);
  j = j + 1;
  <D.18322>:
  <D.18302>:
  <D.17250>:
  D.18298 = dst->size;
  if (D.18298 > i) goto <D.17249>; else goto <D.18324>;
  <D.18324>:
  D.18299 = src->size;
  if (D.18299 > j) goto <D.17249>; else goto <D.17251>;
  <D.17251>:
  D.18325 = merge_array.size;
  D.18298 = dst->size;
  if (D.18325 > D.18298) goto <D.18326>; else goto <D.18327>;
  <D.18326>:
  D.18325 = merge_array.size;
  dyn_array_ensure_capacity (dst, D.18325);
  D.18305 = dst->data;
  D.18328 = merge_array.data;
  D.18325 = merge_array.size;
  D.18329 = merge_array.elem_size;
  D.18330 = D.18325 * D.18329;
  D.18331 = (unsigned int) D.18330;
  memcpy (D.18305, D.18328, D.18331);
  D.18325 = merge_array.size;
  dst->size = D.18325;
  <D.18327>:
}


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.18332;
  _Bool D.18333;
  long int D.18334;
  long int D.18335;
  int D.18338;
  int D.18339;
  int D.18342;
  int D.18343;

  D.18332 = entry->scc_index;
  D.18333 = D.18332 >= 0;
  D.18334 = (long int) D.18333;
  D.18335 = __builtin_expect (D.18334, 0);
  if (D.18335 != 0) goto <D.18336>; else goto <D.18337>;
  <D.18336>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-bridge.c", 487, "entry->scc_index < 0");
  <D.18337>:
  D.18338 = scc->index;
  entry->scc_index = D.18338;
  D.18339 = entry->is_bridge;
  if (D.18339 != 0) goto <D.18340>; else goto <D.18341>;
  <D.18340>:
  D.18342 = scc->num_bridge_entries;
  D.18343 = D.18342 + 1;
  scc->num_bridge_entries = D.18343;
  <D.18341>:
}


dyn_array_uninit (struct DynArray * da)
{
  int D.18344;
  char * D.18347;
  int D.18348;
  int D.18349;
  unsigned int D.18350;

  D.18344 = da->capacity;
  if (D.18344 <= 0) goto <D.18345>; else goto <D.18346>;
  <D.18345>:
  return;
  <D.18346>:
  D.18347 = da->data;
  D.18348 = da->elem_size;
  D.18344 = da->capacity;
  D.18349 = D.18348 * D.18344;
  D.18350 = (unsigned int) D.18349;
  sgen_free_internal_dynamic (D.18347, D.18350, 21);
  da->data = 0B;
}


free_data ()
{
  unsigned int D.18352;
  int D.18353;
  struct DynArray * D.18356;
  struct SgenHashTableEntry * D.18357;
  unsigned int D.18358;
  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.17326>;
    <D.17325>:
    {
      struct SgenHashTableEntry * * __iter;
      struct SgenHashTableEntry * * __next;

      D.18352 = __i * 4;
      __iter = __table + D.18352;
      goto <D.17323>;
      <D.17322>:
      {
        struct SgenHashTableEntry * __entry;

        __entry = *__iter;
        __next = &__entry->next;
        obj = __entry->key;
        entry = &__entry->data;
        D.18353 = entry->srcs.size;
        total_srcs = D.18353 + total_srcs;
        D.18353 = entry->srcs.size;
        if (D.18353 > max_srcs) goto <D.18354>; else goto <D.18355>;
        <D.18354>:
        max_srcs = entry->srcs.size;
        <D.18355>:
        D.18356 = &entry->srcs;
        dyn_array_uninit (D.18356);
      }
      __iter = __next;
      <D.17323>:
      D.18357 = *__iter;
      if (D.18357 != 0B) goto <D.17322>; else goto <D.17324>;
      <D.17324>:
    }
    __i = __i + 1;
    <D.17326>:
    D.18358 = hash_table.size;
    if (D.18358 > __i) goto <D.17325>; else goto <D.17327>;
    <D.17327>:
  }
  sgen_hash_table_clean (&hash_table);
  dyn_array_uninit (&merge_array);
}


sgen_bridge_describe_pointer (struct MonoObject * obj)
{
  char * D.18359;
  unsigned int i.87;
  unsigned int D.18361;
  void * * D.18362;
  void * D.18363;
  int D.18366;
  int D.18369;
  int D.18370;
  struct HashEntry * entry;
  int i;

  i = 0;
  goto <D.17613>;
  <D.17612>:
  D.18359 = registered_bridges.data;
  i.87 = (unsigned int) i;
  D.18361 = i.87 * 4;
  D.18362 = D.18359 + D.18361;
  D.18363 = *D.18362;
  if (D.18363 == obj) goto <D.18364>; else goto <D.18365>;
  <D.18364>:
  printf ("Pointer is a registered bridge object.\n");
  goto <D.17611>;
  <D.18365>:
  i = i + 1;
  <D.17613>:
  D.18366 = registered_bridges.size;
  if (D.18366 > i) goto <D.17612>; else goto <D.17611>;
  <D.17611>:
  entry = sgen_hash_table_lookup (&hash_table, obj);
  if (entry == 0B) goto <D.18367>; else goto <D.18368>;
  <D.18367>:
  return;
  <D.18368>:
  printf ("Bridge hash table entry %p:\n", entry);
  D.18369 = entry->is_bridge;
  printf ("  is bridge: %d\n", D.18369);
  D.18370 = entry->is_visited;
  printf ("  is visited: %d\n", D.18370);
}


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

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


sgen_register_test_bridge_callbacks (const char * bridge_class_name)
{
  void (*<T2e36>) (int, struct MonoGCBridgeSCC * *, int, struct MonoGCBridgeXRef *) iftmp.88;
  char D.18375;
  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.18375 = *bridge_class_name;
      if (D.18375 == 50) goto <D.18376>; else goto <D.18377>;
      <D.18376>:
      iftmp.88 = bridge_test_cross_reference2;
      goto <D.18378>;
      <D.18377>:
      iftmp.88 = bridge_test_cross_reference;
      <D.18378>:
      callbacks.cross_references = iftmp.88;
      mono_gc_register_bridge_callbacks (&callbacks);
      D.18375 = *bridge_class_name;
      if (D.18375 == 50) goto <D.18380>; else goto <D.18381>;
      <D.18380>:
      iftmp.89 = 1;
      goto <D.18382>;
      <D.18381>:
      iftmp.89 = 0;
      <D.18382>:
      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.18384;
  unsigned int i.91;
  unsigned int D.18388;
  struct MonoGCBridgeSCC * * D.18389;
  struct MonoGCBridgeSCC * D.18390;
  int D.18391;
  int iftmp.92;
  unsigned int D.18396;
  struct MonoGCBridgeXRef * D.18397;
  int D.18398;
  _Bool D.18400;
  long int D.18401;
  long int D.18402;
  int iftmp.93;
  int D.18409;
  _Bool D.18411;
  long int D.18412;
  long int D.18413;
  int i;

  i = 0;
  goto <D.17642>;
  <D.17641>:
  {
    int j;

    j = 0;
    goto <D.17639>;
    <D.17638>:
    D.18384 = i & 1;
    if (D.18384 != 0) goto <D.18385>; else goto <D.18386>;
    <D.18385>:
    i.91 = (unsigned int) i;
    D.18388 = i.91 * 4;
    D.18389 = sccs + D.18388;
    D.18390 = *D.18389;
    D.18390->is_alive = 1;
    <D.18386>:
    j = j + 1;
    <D.17639>:
    i.91 = (unsigned int) i;
    D.18388 = i.91 * 4;
    D.18389 = sccs + D.18388;
    D.18390 = *D.18389;
    D.18391 = D.18390->num_objs;
    if (D.18391 > j) goto <D.17638>; else goto <D.17640>;
    <D.17640>:
  }
  i = i + 1;
  <D.17642>:
  if (i < num_sccs) goto <D.17641>; else goto <D.17643>;
  <D.17643>:
  i = 0;
  goto <D.17645>;
  <D.17644>:
  i.91 = (unsigned int) i;
  D.18396 = i.91 * 8;
  D.18397 = xrefs + D.18396;
  D.18398 = D.18397->src_scc_index;
  if (D.18398 < 0) goto <D.18393>; else goto <D.18399>;
  <D.18399>:
  i.91 = (unsigned int) i;
  D.18396 = i.91 * 8;
  D.18397 = xrefs + D.18396;
  D.18398 = D.18397->src_scc_index;
  if (D.18398 >= num_sccs) goto <D.18393>; else goto <D.18394>;
  <D.18393>:
  iftmp.92 = 1;
  goto <D.18395>;
  <D.18394>:
  iftmp.92 = 0;
  <D.18395>:
  D.18400 = iftmp.92 != 0;
  D.18401 = (long int) D.18400;
  D.18402 = __builtin_expect (D.18401, 0);
  if (D.18402 != 0) goto <D.18403>; else goto <D.18404>;
  <D.18403>:
  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.18404>:
  i.91 = (unsigned int) i;
  D.18396 = i.91 * 8;
  D.18397 = xrefs + D.18396;
  D.18409 = D.18397->dst_scc_index;
  if (D.18409 < 0) goto <D.18406>; else goto <D.18410>;
  <D.18410>:
  i.91 = (unsigned int) i;
  D.18396 = i.91 * 8;
  D.18397 = xrefs + D.18396;
  D.18409 = D.18397->dst_scc_index;
  if (D.18409 >= num_sccs) goto <D.18406>; else goto <D.18407>;
  <D.18406>:
  iftmp.93 = 1;
  goto <D.18408>;
  <D.18407>:
  iftmp.93 = 0;
  <D.18408>:
  D.18411 = iftmp.93 != 0;
  D.18412 = (long int) D.18411;
  D.18413 = __builtin_expect (D.18412, 0);
  if (D.18413 != 0) goto <D.18414>; else goto <D.18415>;
  <D.18414>:
  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.18415>:
  i = i + 1;
  <D.17645>:
  if (i < num_xrefs) goto <D.17644>; else goto <D.17646>;
  <D.17646>:
}


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.18419;
  struct MonoObject * D.18420;
  struct MonoClass * D.18421;
  struct MonoClassField * mono_bridge_test_field.95;
  _Bool D.18423;
  long int D.18424;
  long int D.18425;
  unsigned int i.96;
  unsigned int D.18429;
  struct MonoGCBridgeSCC * * D.18430;
  struct MonoGCBridgeSCC * D.18431;
  int D.18432;
  int D.18435;
  int D.18438;
  struct MonoObject * D.18441;
  unsigned int D.18442;
  struct MonoGCBridgeXRef * D.18443;
  int D.18444;
  unsigned int D.18445;
  unsigned int D.18446;
  struct MonoGCBridgeSCC * * D.18447;
  struct MonoGCBridgeSCC * D.18448;
  int D.18449;
  int D.18452;
  unsigned int D.18453;
  unsigned int D.18454;
  struct MonoGCBridgeSCC * * D.18455;
  struct MonoGCBridgeSCC * D.18456;
  int D.18457;
  int i;
  gboolean modified;

  mono_bridge_test_field.94 = mono_bridge_test_field;
  if (mono_bridge_test_field.94 == 0B) goto <D.18417>; else goto <D.18418>;
  <D.18417>:
  D.18419 = *sccs;
  D.18420 = D.18419->objs[0];
  D.18421 = mono_object_get_class (D.18420);
  mono_bridge_test_field.95 = mono_class_get_field_from_name (D.18421, "__test");
  mono_bridge_test_field = mono_bridge_test_field.95;
  mono_bridge_test_field.94 = mono_bridge_test_field;
  D.18423 = mono_bridge_test_field.94 == 0B;
  D.18424 = (long int) D.18423;
  D.18425 = __builtin_expect (D.18424, 0);
  if (D.18425 != 0) goto <D.18426>; else goto <D.18427>;
  <D.18426>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-bridge.c", 912, "mono_bridge_test_field");
  <D.18427>:
  <D.18418>:
  i = 0;
  goto <D.17686>;
  <D.17685>:
  {
    int j;
    gboolean live;

    live = 0;
    j = 0;
    goto <D.17679>;
    <D.17678>:
    i.96 = (unsigned int) i;
    D.18429 = i.96 * 4;
    D.18430 = sccs + D.18429;
    D.18431 = *D.18430;
    D.18432 = test_scc (D.18431, j);
    if (D.18432 != 0) goto <D.18433>; else goto <D.18434>;
    <D.18433>:
    live = 1;
    goto <D.17677>;
    <D.18434>:
    j = j + 1;
    <D.17679>:
    i.96 = (unsigned int) i;
    D.18429 = i.96 * 4;
    D.18430 = sccs + D.18429;
    D.18431 = *D.18430;
    D.18435 = D.18431->num_objs;
    if (D.18435 > j) goto <D.17678>; else goto <D.17677>;
    <D.17677>:
    if (live == 0) goto <D.18436>; else goto <D.18437>;
    <D.18436>:
    // predicted unlikely by continue predictor.
    goto <D.17680>;
    <D.18437>:
    j = 0;
    goto <D.17683>;
    <D.17682>:
    i.96 = (unsigned int) i;
    D.18429 = i.96 * 4;
    D.18430 = sccs + D.18429;
    D.18431 = *D.18430;
    D.18438 = test_scc (D.18431, j);
    if (D.18438 == 0) goto <D.18439>; else goto <D.18440>;
    <D.18439>:
    {
      int status;

      try
        {
          status = 2;
          i.96 = (unsigned int) i;
          D.18429 = i.96 * 4;
          D.18430 = sccs + D.18429;
          D.18431 = *D.18430;
          D.18441 = D.18431->objs[j];
          mono_bridge_test_field.94 = mono_bridge_test_field;
          mono_field_set_value (D.18441, mono_bridge_test_field.94, &status);
        }
      finally
        {
          status = {CLOBBER};
        }
    }
    <D.18440>:
    j = j + 1;
    <D.17683>:
    i.96 = (unsigned int) i;
    D.18429 = i.96 * 4;
    D.18430 = sccs + D.18429;
    D.18431 = *D.18430;
    D.18435 = D.18431->num_objs;
    if (D.18435 > j) goto <D.17682>; else goto <D.17684>;
    <D.17684>:
  }
  <D.17680>:
  i = i + 1;
  <D.17686>:
  if (i < num_sccs) goto <D.17685>; else goto <D.17687>;
  <D.17687>:
  modified = 1;
  goto <D.17693>;
  <D.17692>:
  modified = 0;
  i = 0;
  goto <D.17690>;
  <D.17689>:
  {
    struct MonoGCBridgeXRef ref;

    try
      {
        i.96 = (unsigned int) i;
        D.18442 = i.96 * 8;
        D.18443 = xrefs + D.18442;
        ref = *D.18443;
        D.18444 = ref.src_scc_index;
        D.18445 = (unsigned int) D.18444;
        D.18446 = D.18445 * 4;
        D.18447 = sccs + D.18446;
        D.18448 = *D.18447;
        D.18449 = test_scc (D.18448, 0);
        if (D.18449 != 0) goto <D.18450>; else goto <D.18451>;
        <D.18450>:
        D.18452 = ref.dst_scc_index;
        D.18453 = (unsigned int) D.18452;
        D.18454 = D.18453 * 4;
        D.18455 = sccs + D.18454;
        D.18456 = *D.18455;
        D.18457 = test_scc (D.18456, 0);
        if (D.18457 == 0) goto <D.18458>; else goto <D.18459>;
        <D.18458>:
        modified = 1;
        D.18452 = ref.dst_scc_index;
        D.18453 = (unsigned int) D.18452;
        D.18454 = D.18453 * 4;
        D.18455 = sccs + D.18454;
        D.18456 = *D.18455;
        mark_scc (D.18456, 3);
        <D.18459>:
        <D.18451>:
      }
    finally
      {
        ref = {CLOBBER};
      }
  }
  i = i + 1;
  <D.17690>:
  if (i < num_xrefs) goto <D.17689>; else goto <D.17691>;
  <D.17691>:
  <D.17693>:
  if (modified != 0) goto <D.17692>; else goto <D.17694>;
  <D.17694>:
  i = 0;
  goto <D.17696>;
  <D.17695>:
  i.96 = (unsigned int) i;
  D.18429 = i.96 * 4;
  D.18430 = sccs + D.18429;
  D.18431 = *D.18430;
  D.18431->is_alive = 1;
  i = i + 1;
  <D.17696>:
  if (i < num_sccs) goto <D.17695>; else goto <D.17697>;
  <D.17697>:
}


test_scc (struct MonoGCBridgeSCC * scc, int i)
{
  struct MonoObject * D.18460;
  struct MonoClassField * mono_bridge_test_field.97;
  gboolean D.18462;
  int status.98;
  _Bool D.18464;
  int status;

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


mark_scc (struct MonoGCBridgeSCC * scc, int value)
{
  int D.18467;
  struct MonoObject * D.18470;
  struct MonoClassField * mono_bridge_test_field.99;
  int D.18472;
  int i;

  i = 0;
  goto <D.17665>;
  <D.17664>:
  D.18467 = test_scc (scc, i);
  if (D.18467 == 0) goto <D.18468>; else goto <D.18469>;
  <D.18468>:
  {
    int status;

    try
      {
        status = value;
        D.18470 = scc->objs[i];
        mono_bridge_test_field.99 = mono_bridge_test_field;
        mono_field_set_value (D.18470, mono_bridge_test_field.99, &status);
      }
    finally
      {
        status = {CLOBBER};
      }
  }
  <D.18469>:
  i = i + 1;
  <D.17665>:
  D.18472 = scc->num_objs;
  if (D.18472 > i) goto <D.17664>; else goto <D.17666>;
  <D.17666>:
}


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

  D.18473 = 1;
  return D.18473;
}


bridge_test_is_bridge_class (struct MonoClass * class)
{
  gboolean D.18475;
  int D.17626;
  const char * bridge_class.100;
  const char * D.18477;
  _Bool D.18478;

  {
    size_t __s1_len;
    size_t __s2_len;

    bridge_class.100 = bridge_class;
    D.18477 = class->name;
    D.17626 = __builtin_strcmp (bridge_class.100, D.18477);
  }
  D.18478 = D.17626 == 0;
  D.18475 = (gboolean) D.18478;
  return D.18475;
}