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.18087>; else goto <D.18088>;
  <D.18087>:
  return;
  <D.18088>:
  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.18090;

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


sgen_is_bridge_object (struct MonoObject * obj)
{
  struct MonoVTable * D.18093;
  <unnamed-unsigned:4> D.18094;
  int D.18095;
  int D.18096;
  gboolean D.18099;
  mono_bool (*<T2edf>) (struct MonoObject *) D.18100;

  D.18093 = obj->vtable;
  D.18094 = D.18093->gc_bits;
  D.18095 = (int) D.18094;
  D.18096 = D.18095 & 1;
  if (D.18096 == 0) goto <D.18097>; else goto <D.18098>;
  <D.18097>:
  D.18099 = 0;
  return D.18099;
  <D.18098>:
  D.18100 = bridge_callbacks.is_bridge_object;
  D.18099 = D.18100 (obj);
  return D.18099;
}


sgen_is_bridge_class (struct MonoClass * class)
{
  gboolean D.18102;
  mono_bool (*<T2edb>) (struct MonoClass *) D.18103;

  D.18103 = bridge_callbacks.is_bridge_class;
  D.18102 = D.18103 (class);
  return D.18102;
}


sgen_need_bridge_processing ()
{
  gboolean D.18105;
  void (*<T2ee9>) (int, struct MonoGCBridgeSCC * *, int, struct MonoGCBridgeXRef *) D.18106;
  _Bool D.18107;

  D.18106 = bridge_callbacks.cross_references;
  D.18107 = D.18106 != 0B;
  D.18105 = (gboolean) D.18107;
  return D.18105;
}


sgen_bridge_register_finalized_object (struct MonoObject * obj)
{
  int D.18109;
  _Bool D.18110;
  long int D.18111;
  long int D.18112;

  D.18109 = sgen_need_bridge_processing ();
  D.18110 = D.18109 == 0;
  D.18111 = (long int) D.18110;
  D.18112 = __builtin_expect (D.18111, 0);
  if (D.18112 != 0) goto <D.18113>; else goto <D.18114>;
  <D.18113>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-bridge.c", 537, "sgen_need_bridge_processing ()");
  <D.18114>:
  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.18115;
  int D.18116;
  char * D.18117;
  int D.18118;
  int D.18119;
  sizetype D.18120;
  void * D.18121;
  void * p;

  D.18115 = da->size;
  D.18116 = D.18115 + 1;
  dyn_array_ensure_capacity (da, D.18116);
  D.18117 = da->data;
  D.18115 = da->size;
  D.18118 = da->elem_size;
  D.18119 = D.18115 * D.18118;
  D.18120 = (sizetype) D.18119;
  p = D.18117 + D.18120;
  D.18115 = da->size;
  D.18116 = D.18115 + 1;
  da->size = D.18116;
  D.18121 = p;
  return D.18121;
}


dyn_array_ensure_capacity (struct DynArray * da, int capacity)
{
  int D.18125;
  int D.18128;
  int D.18129;
  int D.18130;
  long unsigned int D.18131;
  int D.18132;
  int D.18133;
  long unsigned int D.18134;
  char * D.18135;
  int D.18136;
  long unsigned int D.18137;
  int old_capacity;
  char * new_data;

  old_capacity = da->capacity;
  if (capacity <= old_capacity) goto <D.18123>; else goto <D.18124>;
  <D.18123>:
  return;
  <D.18124>:
  D.18125 = da->capacity;
  if (D.18125 == 0) goto <D.18126>; else goto <D.18127>;
  <D.18126>:
  da->capacity = 2;
  <D.18127>:
  goto <D.17595>;
  <D.17594>:
  D.18125 = da->capacity;
  D.18128 = D.18125 * 2;
  da->capacity = D.18128;
  <D.17595>:
  D.18125 = da->capacity;
  if (D.18125 < capacity) goto <D.17594>; else goto <D.17596>;
  <D.17596>:
  D.18129 = da->elem_size;
  D.18125 = da->capacity;
  D.18130 = D.18129 * D.18125;
  D.18131 = (long unsigned int) D.18130;
  new_data = sgen_alloc_internal_dynamic (D.18131, 21, 1);
  D.18129 = da->elem_size;
  D.18132 = da->size;
  D.18133 = D.18129 * D.18132;
  D.18134 = (long unsigned int) D.18133;
  D.18135 = da->data;
  memcpy (new_data, D.18135, D.18134);
  D.18129 = da->elem_size;
  D.18136 = D.18129 * old_capacity;
  D.18137 = (long unsigned int) D.18136;
  D.18135 = da->data;
  sgen_free_internal_dynamic (D.18135, D.18137, 21);
  da->data = new_data;
}


memcpy (void * restrict __dest, const void * restrict __src, size_t __len)
{
  void * D.18139;
  long unsigned int D.18140;

  D.18140 = __builtin_object_size (__dest, 0);
  D.18139 = __builtin___memcpy_chk (__dest, __src, __len, D.18140);
  return D.18139;
}


sgen_bridge_reset_data ()
{
  registered_bridges.size = 0;
}


sgen_bridge_processing_stw_step ()
{
  int D.18142;
  char * D.18145;
  long unsigned int D.18146;
  long unsigned int D.18147;
  void * * D.18148;
  void * D.18149;
  struct HashEntry * D.18150;
  long int D.18151;
  long int D.18152;
  int D.18153;
  long unsigned int step_2.1;
  int i;
  gint64 atv;
  gint64 btv;

  D.18142 = registered_bridges.size;
  if (D.18142 == 0) goto <D.18143>; else goto <D.18144>;
  <D.18143>:
  return;
  <D.18144>:
  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.17890>;
  <D.17889>:
  D.18145 = registered_bridges.data;
  D.18146 = (long unsigned int) i;
  D.18147 = D.18146 * 8;
  D.18148 = D.18145 + D.18147;
  D.18149 = *D.18148;
  register_bridge_object (D.18149);
  i = i + 1;
  <D.17890>:
  D.18142 = registered_bridges.size;
  if (D.18142 > i) goto <D.17889>; else goto <D.17891>;
  <D.17891>:
  i = 0;
  goto <D.17893>;
  <D.17892>:
  D.18145 = registered_bridges.data;
  D.18146 = (long unsigned int) i;
  D.18147 = D.18146 * 8;
  D.18148 = D.18145 + D.18147;
  D.18149 = *D.18148;
  D.18150 = get_hash_entry (D.18149, 0B);
  dfs1 (D.18150, 0B);
  i = i + 1;
  <D.17893>:
  D.18142 = registered_bridges.size;
  if (D.18142 > i) goto <D.17892>; else goto <D.17894>;
  <D.17894>:
  atv = mono_100ns_ticks ();
  D.18151 = atv - btv;
  D.18152 = D.18151 / 10;
  D.18153 = (int) D.18152;
  step_2.1 = (long unsigned int) D.18153;
  step_2 = step_2.1;
}


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


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.18156;
  struct HashEntry * entry;

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


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

  try
    {
      entry = sgen_hash_table_lookup (&hash_table, obj);
      if (entry != 0B) goto <D.18158>; else goto <D.18159>;
      <D.18158>:
      if (existing != 0B) goto <D.18160>; else goto <D.18161>;
      <D.18160>:
      *existing = 1;
      <D.18161>:
      D.18162 = entry;
      return D.18162;
      <D.18159>:
      if (existing != 0B) goto <D.18163>; else goto <D.18164>;
      <D.18163>:
      *existing = 0;
      <D.18164>:
      memset (&new_entry, 0, 56);
      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.18162 = sgen_hash_table_lookup (&hash_table, obj);
      return D.18162;
    }
  finally
    {
      new_entry = {CLOBBER};
    }
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.18169;
  int D.18174;
  void * D.18176;
  long unsigned int D.18177;

  D.18169 = __builtin_constant_p (__len);
  if (D.18169 != 0) goto <D.18170>; else goto <D.18171>;
  <D.18170>:
  if (__len == 0) goto <D.18172>; else goto <D.18173>;
  <D.18172>:
  D.18174 = __builtin_constant_p (__ch);
  if (D.18174 == 0) goto <D.18167>; else goto <D.18175>;
  <D.18175>:
  if (__ch != 0) goto <D.18167>; else goto <D.18168>;
  <D.18167>:
  __warn_memset_zero_len ();
  D.18176 = __dest;
  return D.18176;
  <D.18168>:
  <D.18173>:
  <D.18171>:
  D.18177 = __builtin_object_size (__dest, 0);
  D.18176 = __builtin___memset_chk (__dest, __ch, __len, D.18177);
  return D.18176;
}


dfs1 (struct HashEntry * obj_entry, struct HashEntry * src)
{
  int D.18179;
  _Bool D.18180;
  long int D.18181;
  long int D.18182;
  int dsf1_passes.2;
  int dsf1_passes.3;
  int D.18192;
  long unsigned int D.18195;
  long unsigned int D.18196;
  long unsigned int D.18197;
  long unsigned int D.18198;
  long unsigned int D.18201;
  long unsigned int D.18202;
  long unsigned int D.18203;
  long unsigned int D.18204;
  long unsigned int D.18205;
  long unsigned int D.18206;
  void * dst.4;
  struct MonoObject * dst.5;
  int D.18211;
  struct HashEntry * D.18214;
  struct MonoObject * dst.6;
  int D.18218;
  struct HashEntry * D.18221;
  long unsigned int D.18222;
  long unsigned int D.18223;
  int D.18224;
  void * dst.7;
  struct MonoObject * dst.8;
  int D.18229;
  struct HashEntry * D.18232;
  long unsigned int D.18233;
  long unsigned int D.18234;
  int D.18235;
  struct MonoObject * dst.9;
  int D.18239;
  struct HashEntry * D.18242;
  long unsigned int D.18243;
  long unsigned int D.18246;
  int D.18247;
  int D.18248;
  unsigned int D.18251;
  unsigned int el_size.10;
  unsigned int D.18253;
  sizetype D.18254;
  void * dst.11;
  struct MonoObject * dst.12;
  int D.18259;
  struct HashEntry * D.18262;
  int D.18266;
  int D.18267;
  long unsigned int D.18268;
  long unsigned int D.18269;
  long unsigned int D.18270;
  long unsigned int D.18271;
  void * * D.18272;
  void * dst.13;
  struct MonoObject * dst.14;
  int D.18277;
  struct HashEntry * D.18280;
  sizetype D.18281;
  long unsigned int D.18285;
  void * dst.15;
  struct MonoObject * dst.16;
  int D.18292;
  struct HashEntry * D.18295;
  long unsigned int D.18296;
  void * dst.17;
  struct MonoObject * dst.18;
  int D.18303;
  struct HashEntry * D.18306;
  long unsigned int D.18307;
  unsigned int D.18308;
  unsigned int D.18309;
  struct MonoVTable * D.18312;
  struct MonoClass * D.18313;
  const char * D.18314;
  const char * D.18315;
  gsize * bitmap_data.19;
  long unsigned int D.18317;
  void * dst.20;
  struct MonoObject * dst.21;
  int D.18324;
  struct HashEntry * D.18327;
  int bwords.22;
  long unsigned int D.18329;
  gsize * mbitmap_data.23;
  long unsigned int D.18331;
  unsigned int D.18332;
  unsigned int D.18333;
  struct MonoClass * D.18334;
  unsigned int el_size.24;
  unsigned int D.18336;
  sizetype D.18337;
  const char * D.18340;
  const char * D.18341;
  gsize * bitmap_data.25;
  long unsigned int D.18343;
  void * dst.26;
  struct MonoObject * dst.27;
  int D.18350;
  struct HashEntry * D.18353;
  unsigned int bwords.28;
  sizetype D.18355;
  int current_time.29;
  int current_time.30;
  int current_time.31;

  D.18179 = dfs_stack.size;
  D.18180 = D.18179 != 0;
  D.18181 = (long int) D.18180;
  D.18182 = __builtin_expect (D.18181, 0);
  if (D.18182 != 0) goto <D.18183>; else goto <D.18184>;
  <D.18183>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-bridge.c", 423, "dfs_stack.size == 0");
  <D.18184>:
  dyn_array_ptr_add (&dfs_stack, src);
  dyn_array_ptr_add (&dfs_stack, obj_entry);
  <D.17833>:
  {
    struct MonoObject * obj;
    char * start;

    dsf1_passes.2 = dsf1_passes;
    dsf1_passes.3 = dsf1_passes.2 + 1;
    dsf1_passes = dsf1_passes.3;
    obj_entry = dyn_array_ptr_pop (&dfs_stack);
    if (obj_entry != 0B) goto <D.18187>; else goto <D.18188>;
    <D.18187>:
    src = dyn_array_ptr_pop (&dfs_stack);
    obj = obj_entry->obj;
    start = obj;
    if (src != 0B) goto <D.18189>; else goto <D.18190>;
    <D.18189>:
    add_source (obj_entry, src);
    goto <D.18191>;
    <D.18190>:
    <D.18191>:
    D.18192 = obj_entry->is_visited;
    if (D.18192 != 0) goto <D.18193>; else goto <D.18194>;
    <D.18193>:
    // predicted unlikely by continue predictor.
    goto <D.17734>;
    <D.18194>:
    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.18195 = MEM[(mword *)start];
      D.18196 = D.18195 & 18446744073709551612;
      vt = (struct GCVTable *) D.18196;
      desc = vt->desc;
      D.18197 = desc & 7;
      switch (D.18197) <default: <D.17832>, case 1: <D.17737>, case 2: <D.17746>, case 3: <D.17796>, case 4: <D.17756>, case 5: <D.17789>, case 6: <D.17810>, case 7: <D.17831>>
      <D.17737>:
      D.18198 = desc & 4294901760;
      if (D.18198 != 0) goto <D.18199>; else goto <D.18200>;
      <D.18199>:
      {
        void * * _objptr_end;
        void * * _objptr;

        _objptr = start;
        D.18201 = desc >> 16;
        D.18202 = D.18201 & 255;
        D.18203 = D.18202 * 8;
        _objptr = _objptr + D.18203;
        D.18204 = desc >> 24;
        D.18205 = D.18204 & 255;
        D.18206 = D.18205 * 8;
        _objptr_end = _objptr + D.18206;
        {
          struct MonoObject * dst;

          try
            {
              dst.4 = *_objptr;
              dst = dst.4;
              dst.5 = dst;
              if (dst.5 != 0B) goto <D.18209>; else goto <D.18210>;
              <D.18209>:
              D.18211 = object_is_live (&dst);
              if (D.18211 == 0) goto <D.18212>; else goto <D.18213>;
              <D.18212>:
              dyn_array_ptr_add (&dfs_stack, obj_entry);
              dst.5 = dst;
              D.18214 = get_hash_entry (dst.5, 0B);
              dyn_array_ptr_add (&dfs_stack, D.18214);
              <D.18213>:
              <D.18210>:
            }
          finally
            {
              dst = {CLOBBER};
            }
        }
        _objptr = _objptr + 8;
        goto <D.17743>;
        <D.17742>:
        {
          struct MonoObject * dst;

          try
            {
              dst.4 = *_objptr;
              dst = dst.4;
              dst.6 = dst;
              if (dst.6 != 0B) goto <D.18216>; else goto <D.18217>;
              <D.18216>:
              D.18218 = object_is_live (&dst);
              if (D.18218 == 0) goto <D.18219>; else goto <D.18220>;
              <D.18219>:
              dyn_array_ptr_add (&dfs_stack, obj_entry);
              dst.6 = dst;
              D.18221 = get_hash_entry (dst.6, 0B);
              dyn_array_ptr_add (&dfs_stack, D.18221);
              <D.18220>:
              <D.18217>:
            }
          finally
            {
              dst = {CLOBBER};
            }
        }
        _objptr = _objptr + 8;
        <D.17743>:
        if (_objptr < _objptr_end) goto <D.17742>; else goto <D.17744>;
        <D.17744>:
      }
      <D.18200>:
      goto <D.17745>;
      <D.17746>:
      {
        void * * _objptr;
        gsize _bmap;

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

          _index = __builtin_ctzl (_bmap);
          D.18222 = (long unsigned int) _index;
          D.18223 = D.18222 * 8;
          _objptr = _objptr + D.18223;
          D.18224 = _index + 1;
          _bmap = _bmap >> D.18224;
          {
            struct MonoObject * dst;

            try
              {
                dst.7 = *_objptr;
                dst = dst.7;
                dst.8 = dst;
                if (dst.8 != 0B) goto <D.18227>; else goto <D.18228>;
                <D.18227>:
                D.18229 = object_is_live (&dst);
                if (D.18229 == 0) goto <D.18230>; else goto <D.18231>;
                <D.18230>:
                dyn_array_ptr_add (&dfs_stack, obj_entry);
                dst.8 = dst;
                D.18232 = get_hash_entry (dst.8, 0B);
                dyn_array_ptr_add (&dfs_stack, D.18232);
                <D.18231>:
                <D.18228>:
              }
            finally
              {
                dst = {CLOBBER};
              }
          }
          _objptr = _objptr + 8;
        }
        goto <D.17754>;
        <D.17753>:
        {
          int _index;

          _index = __builtin_ctzl (_bmap);
          D.18233 = (long unsigned int) _index;
          D.18234 = D.18233 * 8;
          _objptr = _objptr + D.18234;
          D.18235 = _index + 1;
          _bmap = _bmap >> D.18235;
          {
            struct MonoObject * dst;

            try
              {
                dst.7 = *_objptr;
                dst = dst.7;
                dst.9 = dst;
                if (dst.9 != 0B) goto <D.18237>; else goto <D.18238>;
                <D.18237>:
                D.18239 = object_is_live (&dst);
                if (D.18239 == 0) goto <D.18240>; else goto <D.18241>;
                <D.18240>:
                dyn_array_ptr_add (&dfs_stack, obj_entry);
                dst.9 = dst;
                D.18242 = get_hash_entry (dst.9, 0B);
                dyn_array_ptr_add (&dfs_stack, D.18242);
                <D.18241>:
                <D.18238>:
              }
            finally
              {
                dst = {CLOBBER};
              }
          }
          _objptr = _objptr + 8;
        }
        <D.17754>:
        if (_bmap != 0) goto <D.17753>; else goto <D.17755>;
        <D.17755>:
      }
      goto <D.17745>;
      <D.17756>:
      D.18243 = desc & 4294950912;
      if (D.18243 != 0) goto <D.18244>; else goto <D.18245>;
      <D.18244>:
      {
        int el_size;
        int etype;

        D.18246 = desc >> 3;
        D.18247 = (int) D.18246;
        el_size = D.18247 & 1023;
        D.18248 = (int) desc;
        etype = D.18248 & 49152;
        if (etype == 16384) goto <D.18249>; else goto <D.18250>;
        <D.18249>:
        {
          void * * p;
          void * * end_refs;

          p = start + 32;
          D.18251 = MEM[(struct MonoArray *)start].max_length;
          el_size.10 = (unsigned int) el_size;
          D.18253 = D.18251 * el_size.10;
          D.18254 = (sizetype) D.18253;
          end_refs = p + D.18254;
          goto <D.17763>;
          <D.17762>:
          {
            struct MonoObject * dst;

            try
              {
                dst.11 = *p;
                dst = dst.11;
                dst.12 = dst;
                if (dst.12 != 0B) goto <D.18257>; else goto <D.18258>;
                <D.18257>:
                D.18259 = object_is_live (&dst);
                if (D.18259 == 0) goto <D.18260>; else goto <D.18261>;
                <D.18260>:
                dyn_array_ptr_add (&dfs_stack, obj_entry);
                dst.12 = dst;
                D.18262 = get_hash_entry (dst.12, 0B);
                dyn_array_ptr_add (&dfs_stack, D.18262);
                <D.18261>:
                <D.18258>:
              }
            finally
              {
                dst = {CLOBBER};
              }
          }
          p = p + 8;
          <D.17763>:
          if (p < end_refs) goto <D.17762>; else goto <D.17764>;
          <D.17764>:
        }
        goto <D.18263>;
        <D.18250>:
        if (etype == 32768) goto <D.18264>; else goto <D.18265>;
        <D.18264>:
        {
          int offset;
          int num_refs;
          char * e_start;
          char * e_end;

          D.18201 = desc >> 16;
          D.18266 = (int) D.18201;
          offset = D.18266 & 255;
          D.18204 = desc >> 24;
          D.18267 = (int) D.18204;
          num_refs = D.18267 & 255;
          e_start = start + 32;
          D.18251 = MEM[(struct MonoArray *)start].max_length;
          el_size.10 = (unsigned int) el_size;
          D.18253 = D.18251 * el_size.10;
          D.18254 = (sizetype) D.18253;
          e_end = e_start + D.18254;
          goto <D.17776>;
          <D.17775>:
          {
            void * * p;
            int i;

            p = e_start;
            D.18268 = (long unsigned int) offset;
            D.18269 = D.18268 * 8;
            p = p + D.18269;
            i = 0;
            goto <D.17773>;
            <D.17772>:
            {
              struct MonoObject * dst;

              try
                {
                  D.18270 = (long unsigned int) i;
                  D.18271 = D.18270 * 8;
                  D.18272 = p + D.18271;
                  dst.13 = *D.18272;
                  dst = dst.13;
                  dst.14 = dst;
                  if (dst.14 != 0B) goto <D.18275>; else goto <D.18276>;
                  <D.18275>:
                  D.18277 = object_is_live (&dst);
                  if (D.18277 == 0) goto <D.18278>; else goto <D.18279>;
                  <D.18278>:
                  dyn_array_ptr_add (&dfs_stack, obj_entry);
                  dst.14 = dst;
                  D.18280 = get_hash_entry (dst.14, 0B);
                  dyn_array_ptr_add (&dfs_stack, D.18280);
                  <D.18279>:
                  <D.18276>:
                }
              finally
                {
                  dst = {CLOBBER};
                }
            }
            i = i + 1;
            <D.17773>:
            if (i < num_refs) goto <D.17772>; else goto <D.17774>;
            <D.17774>:
            D.18281 = (sizetype) el_size;
            e_start = e_start + D.18281;
          }
          <D.17776>:
          if (e_start < e_end) goto <D.17775>; else goto <D.17777>;
          <D.17777>:
        }
        goto <D.18282>;
        <D.18265>:
        if (etype == 49152) goto <D.18283>; else goto <D.18284>;
        <D.18283>:
        {
          char * e_start;
          char * e_end;

          e_start = start + 32;
          D.18251 = MEM[(struct MonoArray *)start].max_length;
          el_size.10 = (unsigned int) el_size;
          D.18253 = D.18251 * el_size.10;
          D.18254 = (sizetype) D.18253;
          e_end = e_start + D.18254;
          goto <D.17787>;
          <D.17786>:
          {
            void * * p;
            gsize _bmap;

            p = e_start;
            _bmap = desc >> 16;
            goto <D.17784>;
            <D.17783>:
            D.18285 = _bmap & 1;
            if (D.18285 != 0) goto <D.18286>; else goto <D.18287>;
            <D.18286>:
            {
              struct MonoObject * dst;

              try
                {
                  dst.15 = *p;
                  dst = dst.15;
                  dst.16 = dst;
                  if (dst.16 != 0B) goto <D.18290>; else goto <D.18291>;
                  <D.18290>:
                  D.18292 = object_is_live (&dst);
                  if (D.18292 == 0) goto <D.18293>; else goto <D.18294>;
                  <D.18293>:
                  dyn_array_ptr_add (&dfs_stack, obj_entry);
                  dst.16 = dst;
                  D.18295 = get_hash_entry (dst.16, 0B);
                  dyn_array_ptr_add (&dfs_stack, D.18295);
                  <D.18294>:
                  <D.18291>:
                }
              finally
                {
                  dst = {CLOBBER};
                }
            }
            <D.18287>:
            _bmap = _bmap >> 1;
            p = p + 8;
            <D.17784>:
            if (_bmap != 0) goto <D.17783>; else goto <D.17785>;
            <D.17785>:
            D.18281 = (sizetype) el_size;
            e_start = e_start + D.18281;
          }
          <D.17787>:
          if (e_start < e_end) goto <D.17786>; else goto <D.17788>;
          <D.17788>:
        }
        <D.18284>:
        <D.18282>:
        <D.18263>:
      }
      <D.18245>:
      goto <D.17745>;
      <D.17789>:
      {
        void * * _objptr;
        gsize _bmap;

        _objptr = start;
        _bmap = desc >> 3;
        _objptr = _objptr + 16;
        goto <D.17794>;
        <D.17793>:
        D.18296 = _bmap & 1;
        if (D.18296 != 0) goto <D.18297>; else goto <D.18298>;
        <D.18297>:
        {
          struct MonoObject * dst;

          try
            {
              dst.17 = *_objptr;
              dst = dst.17;
              dst.18 = dst;
              if (dst.18 != 0B) goto <D.18301>; else goto <D.18302>;
              <D.18301>:
              D.18303 = object_is_live (&dst);
              if (D.18303 == 0) goto <D.18304>; else goto <D.18305>;
              <D.18304>:
              dyn_array_ptr_add (&dfs_stack, obj_entry);
              dst.18 = dst;
              D.18306 = get_hash_entry (dst.18, 0B);
              dyn_array_ptr_add (&dfs_stack, D.18306);
              <D.18305>:
              <D.18302>:
            }
          finally
            {
              dst = {CLOBBER};
            }
        }
        <D.18298>:
        _bmap = _bmap >> 1;
        _objptr = _objptr + 8;
        <D.17794>:
        if (_bmap != 0) goto <D.17793>; else goto <D.17795>;
        <D.17795>:
      }
      goto <D.17745>;
      <D.17796>:
      {
        void * * _objptr;
        gsize * bitmap_data;
        int bwords;
        void * * start_run;

        _objptr = start;
        bitmap_data = sgen_get_complex_descriptor (desc);
        D.18307 = *bitmap_data;
        D.18308 = (unsigned int) D.18307;
        D.18309 = D.18308 + 4294967295;
        bwords = (int) D.18309;
        start_run = _objptr;
        bitmap_data = bitmap_data + 8;
        if (0 != 0) goto <D.18310>; else goto <D.18311>;
        <D.18310>:
        {
          struct MonoObject * myobj;

          myobj = start;
          D.18312 = myobj->vtable;
          D.18313 = D.18312->klass;
          D.18314 = D.18313->name;
          D.18312 = myobj->vtable;
          D.18313 = D.18312->klass;
          D.18315 = D.18313->name_space;
          monoeg_g_print ("found %d at %p (0x%zx): %s.%s\n", bwords, start, desc, D.18315, D.18314);
        }
        <D.18311>:
        goto <D.17808>;
        <D.17807>:
        {
          gsize _bmap;

          bitmap_data.19 = bitmap_data;
          bitmap_data = bitmap_data.19 + 8;
          _bmap = *bitmap_data.19;
          _objptr = start_run;
          goto <D.17805>;
          <D.17804>:
          D.18317 = _bmap & 1;
          if (D.18317 != 0) goto <D.18318>; else goto <D.18319>;
          <D.18318>:
          {
            struct MonoObject * dst;

            try
              {
                dst.20 = *_objptr;
                dst = dst.20;
                dst.21 = dst;
                if (dst.21 != 0B) goto <D.18322>; else goto <D.18323>;
                <D.18322>:
                D.18324 = object_is_live (&dst);
                if (D.18324 == 0) goto <D.18325>; else goto <D.18326>;
                <D.18325>:
                dyn_array_ptr_add (&dfs_stack, obj_entry);
                dst.21 = dst;
                D.18327 = get_hash_entry (dst.21, 0B);
                dyn_array_ptr_add (&dfs_stack, D.18327);
                <D.18326>:
                <D.18323>:
              }
            finally
              {
                dst = {CLOBBER};
              }
          }
          <D.18319>:
          _bmap = _bmap >> 1;
          _objptr = _objptr + 8;
          <D.17805>:
          if (_bmap != 0) goto <D.17804>; else goto <D.17806>;
          <D.17806>:
          start_run = start_run + 512;
        }
        <D.17808>:
        bwords.22 = bwords;
        bwords = bwords.22 + -1;
        if (bwords.22 > 0) goto <D.17807>; else goto <D.17809>;
        <D.17809>:
      }
      goto <D.17745>;
      <D.17810>:
      {
        gsize * mbitmap_data;
        int mbwords;
        int el_size;
        char * e_start;
        char * e_end;

        D.18329 = vt->desc;
        mbitmap_data = sgen_get_complex_descriptor (D.18329);
        mbitmap_data.23 = mbitmap_data;
        mbitmap_data = mbitmap_data.23 + 8;
        D.18331 = *mbitmap_data.23;
        D.18332 = (unsigned int) D.18331;
        D.18333 = D.18332 + 4294967295;
        mbwords = (int) D.18333;
        D.18334 = vt->klass;
        el_size = mono_array_element_size (D.18334);
        e_start = start + 32;
        D.18251 = MEM[(struct MonoArray *)start].max_length;
        el_size.24 = (unsigned int) el_size;
        D.18336 = D.18251 * el_size.24;
        D.18337 = (sizetype) D.18336;
        e_end = e_start + D.18337;
        if (0 != 0) goto <D.18338>; else goto <D.18339>;
        <D.18338>:
        D.18334 = vt->klass;
        D.18340 = D.18334->name;
        D.18334 = vt->klass;
        D.18341 = D.18334->name_space;
        D.18329 = vt->desc;
        monoeg_g_print ("found %d at %p (0x%zx): %s.%s\n", mbwords, start, D.18329, D.18341, D.18340);
        <D.18339>:
        goto <D.17829>;
        <D.17828>:
        {
          void * * _objptr;
          gsize * bitmap_data;
          unsigned int bwords;

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

            bitmap_data.25 = bitmap_data;
            bitmap_data = bitmap_data.25 + 8;
            _bmap = *bitmap_data.25;
            start_run = _objptr;
            goto <D.17823>;
            <D.17822>:
            D.18343 = _bmap & 1;
            if (D.18343 != 0) goto <D.18344>; else goto <D.18345>;
            <D.18344>:
            {
              struct MonoObject * dst;

              try
                {
                  dst.26 = *_objptr;
                  dst = dst.26;
                  dst.27 = dst;
                  if (dst.27 != 0B) goto <D.18348>; else goto <D.18349>;
                  <D.18348>:
                  D.18350 = object_is_live (&dst);
                  if (D.18350 == 0) goto <D.18351>; else goto <D.18352>;
                  <D.18351>:
                  dyn_array_ptr_add (&dfs_stack, obj_entry);
                  dst.27 = dst;
                  D.18353 = get_hash_entry (dst.27, 0B);
                  dyn_array_ptr_add (&dfs_stack, D.18353);
                  <D.18352>:
                  <D.18349>:
                }
              finally
                {
                  dst = {CLOBBER};
                }
            }
            <D.18345>:
            _bmap = _bmap >> 1;
            _objptr = _objptr + 8;
            <D.17823>:
            if (_bmap != 0) goto <D.17822>; else goto <D.17824>;
            <D.17824>:
            _objptr = start_run + 512;
          }
          <D.17826>:
          bwords.28 = bwords;
          bwords = bwords.28 + 4294967295;
          if (bwords.28 != 0) goto <D.17825>; else goto <D.17827>;
          <D.17827>:
          D.18355 = (sizetype) el_size;
          e_start = e_start + D.18355;
        }
        <D.17829>:
        if (e_start < e_end) goto <D.17828>; else goto <D.17830>;
        <D.17830>:
      }
      goto <D.17745>;
      <D.17831>:
      goto <D.17745>;
      <D.17832>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "sgen-scan-object.h", 111);
      <D.17745>:
    }
    goto <D.18356>;
    <D.18188>:
    obj_entry = dyn_array_ptr_pop (&dfs_stack);
    current_time.29 = current_time;
    current_time.30 = current_time.29;
    current_time.31 = current_time.30 + 1;
    current_time = current_time.31;
    register_finishing_time (obj_entry, current_time.30);
    <D.18356>:
  }
  <D.17734>:
  D.18179 = dfs_stack.size;
  if (D.18179 > 0) goto <D.17833>; else goto <D.17834>;
  <D.17834>:
}


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

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


object_is_live (struct MonoObject * * objp)
{
  struct MonoObject * iftmp.32;
  long unsigned int D.18364;
  long unsigned int D.18365;
  long unsigned int D.18368;
  gboolean D.18372;
  void * D.18373;
  _Bool D.18374;
  int D.18375;
  void * D.18378;
  _Bool D.18379;
  struct MonoObject * obj;
  struct MonoObject * fwd;

  obj = *objp;
  D.18364 = MEM[(mword *)obj];
  D.18365 = D.18364 & 1;
  if (D.18365 != 0) goto <D.18366>; else goto <D.18367>;
  <D.18366>:
  D.18364 = MEM[(mword *)obj];
  D.18368 = D.18364 & 18446744073709551612;
  iftmp.32 = (struct MonoObject *) D.18368;
  goto <D.18369>;
  <D.18367>:
  iftmp.32 = 0B;
  <D.18369>:
  fwd = iftmp.32;
  if (fwd != 0B) goto <D.18370>; else goto <D.18371>;
  <D.18370>:
  *objp = fwd;
  D.18373 = sgen_hash_table_lookup (&hash_table, fwd);
  D.18374 = D.18373 == 0B;
  D.18372 = (gboolean) D.18374;
  return D.18372;
  <D.18371>:
  D.18375 = sgen_object_is_live (obj);
  if (D.18375 == 0) goto <D.18376>; else goto <D.18377>;
  <D.18376>:
  D.18372 = 0;
  return D.18372;
  <D.18377>:
  D.18378 = sgen_hash_table_lookup (&hash_table, obj);
  D.18379 = D.18378 == 0B;
  D.18372 = (gboolean) D.18379;
  return D.18372;
}


dyn_array_ptr_pop (struct DynArray * da)
{
  int D.18381;
  _Bool D.18382;
  long int D.18383;
  long int D.18384;
  char * D.18387;
  long unsigned int D.18388;
  long unsigned int D.18389;
  sizetype D.18390;
  void * * D.18391;
  int D.18392;
  void * D.18393;
  void * p;

  D.18381 = da->size;
  D.18382 = D.18381 <= 0;
  D.18383 = (long int) D.18382;
  D.18384 = __builtin_expect (D.18383, 0);
  if (D.18384 != 0) goto <D.18385>; else goto <D.18386>;
  <D.18385>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-bridge.c", 142, "da->size > 0");
  <D.18386>:
  D.18387 = da->data;
  D.18381 = da->size;
  D.18388 = (long unsigned int) D.18381;
  D.18389 = D.18388 * 8;
  D.18390 = D.18389 + 18446744073709551608;
  D.18391 = D.18387 + D.18390;
  p = *D.18391;
  D.18381 = da->size;
  D.18392 = D.18381 + -1;
  da->size = D.18392;
  D.18393 = p;
  return D.18393;
}


register_finishing_time (struct HashEntry * entry, int t)
{
  int D.18395;
  _Bool D.18396;
  long int D.18397;
  long int D.18398;

  D.18395 = entry->finishing_time;
  D.18396 = D.18395 >= 0;
  D.18397 = (long int) D.18396;
  D.18398 = __builtin_expect (D.18397, 0);
  if (D.18398 != 0) goto <D.18399>; else goto <D.18400>;
  <D.18399>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-bridge.c", 387, "entry->finishing_time < 0");
  <D.18400>:
  entry->finishing_time = t;
}


sgen_bridge_processing_finish (int generation)
{
  int D.18401;
  int bridge_processing_in_progress.33;
  _Bool D.18405;
  long int D.18406;
  long int D.18407;
  unsigned int D.18410;
  long unsigned int D.18411;
  long unsigned int D.18412;
  long unsigned int D.18413;
  long unsigned int D.18414;
  int D.18415;
  _Bool D.18416;
  long int D.18417;
  long int D.18418;
  int j.34;
  long unsigned int D.18422;
  long unsigned int D.18423;
  struct HashEntry * * D.18424;
  int D.18425;
  int fist_pass_links.35;
  int fist_pass_links.36;
  struct SgenHashTableEntry * D.18428;
  unsigned int D.18429;
  unsigned int j.37;
  _Bool D.18431;
  long int D.18432;
  long int D.18433;
  long unsigned int D.18436;
  long int D.18437;
  long int D.18438;
  int D.18439;
  long unsigned int step_3.38;
  long unsigned int D.18441;
  long unsigned int D.18442;
  struct HashEntry * * D.18443;
  int D.18444;
  void * current_scc.39;
  struct SCC * current_scc.40;
  struct DynArray * D.18449;
  unsigned int i.41;
  int D.18451;
  int second_pass_links.42;
  int second_pass_links.43;
  long int D.18454;
  long int D.18455;
  int D.18456;
  long unsigned int step_4.44;
  char * D.18458;
  int D.18459;
  int D.18460;
  sizetype D.18461;
  int D.18462;
  _Bool D.18463;
  long int D.18464;
  long int D.18465;
  int D.18468;
  int D.18471;
  int sccs_links.45;
  int sccs_links.46;
  int max_sccs_links.47;
  int max_sccs_links.48;
  int D.18476;
  long unsigned int D.18477;
  long unsigned int D.18478;
  int D.18479;
  long unsigned int D.18482;
  long unsigned int D.18483;
  struct MonoGCBridgeSCC * * D.18484;
  long unsigned int D.18485;
  long unsigned int D.18486;
  long unsigned int D.18487;
  void * D.18488;
  struct MonoGCBridgeSCC * D.18489;
  int j.49;
  int D.18491;
  long unsigned int D.18492;
  long unsigned int D.18493;
  int D.18494;
  int D.18497;
  int D.18498;
  sizetype D.18499;
  int D.18500;
  long unsigned int D.18501;
  long unsigned int D.18502;
  struct MonoGCBridgeSCC * * D.18503;
  struct MonoGCBridgeSCC * D.18504;
  int D.18505;
  int D.18506;
  int D.18507;
  struct MonoObject * D.18508;
  struct SgenHashTableEntry * D.18509;
  long unsigned int D.18510;
  long unsigned int D.18511;
  int D.18512;
  char * D.18515;
  long unsigned int D.18516;
  long unsigned int D.18517;
  int * D.18518;
  int D.18519;
  int D.18520;
  sizetype D.18521;
  int D.18522;
  struct MonoGCBridgeXRef * D.18525;
  int D.18526;
  int D.18527;
  int D.18528;
  int D.18529;
  int D.18534;
  struct DynArray * D.18537;
  void (*<T2ee9>) (int, struct MonoGCBridgeSCC * *, int, struct MonoGCBridgeXRef *) D.18538;
  struct MonoGCBridgeSCC * * D.18539;
  struct MonoGCBridgeSCC * D.18540;
  int D.18541;
  _Bool D.18542;
  unsigned char alive.50;
  struct MonoObject * D.18544;
  int D.18547;
  long unsigned int D.18550;
  long unsigned int D.18551;
  long unsigned int D.18552;
  int dsf2_passes.51;
  int dsf1_passes.52;
  long unsigned int step_8.53;
  float D.18556;
  float D.18557;
  double D.18558;
  long unsigned int step_7.54;
  float D.18560;
  float D.18561;
  double D.18562;
  long unsigned int step_6.55;
  float D.18564;
  float D.18565;
  double D.18566;
  long unsigned int step_5.56;
  float D.18568;
  float D.18569;
  double D.18570;
  long unsigned int step_4.57;
  float D.18572;
  float D.18573;
  double D.18574;
  long unsigned int step_3.58;
  float D.18576;
  float D.18577;
  double D.18578;
  long unsigned int step_2.59;
  float D.18580;
  float D.18581;
  double D.18582;
  long unsigned int step_1.60;
  float D.18584;
  float D.18585;
  double D.18586;
  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.18401 = registered_bridges.size;
      if (D.18401 == 0) goto <D.18402>; else goto <D.18403>;
      <D.18402>:
      return;
      <D.18403>:
      bridge_processing_in_progress.33 = bridge_processing_in_progress;
      D.18405 = bridge_processing_in_progress.33 == 0;
      D.18406 = (long int) D.18405;
      D.18407 = __builtin_expect (D.18406, 0);
      if (D.18407 != 0) goto <D.18408>; else goto <D.18409>;
      <D.18408>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-bridge.c", 620, "bridge_processing_in_progress");
      <D.18409>:
      atv = mono_100ns_ticks ();
      D.18410 = hash_table.num_entries;
      D.18411 = (long unsigned int) D.18410;
      D.18412 = D.18411 * 8;
      all_entries = sgen_alloc_internal_dynamic (D.18412, 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.17931>;
        <D.17930>:
        {
          struct SgenHashTableEntry * * __iter;
          struct SgenHashTableEntry * * __next;

          D.18413 = (long unsigned int) __i;
          D.18414 = D.18413 * 8;
          __iter = __table + D.18414;
          goto <D.17928>;
          <D.17927>:
          {
            struct SgenHashTableEntry * __entry;

            __entry = *__iter;
            __next = &__entry->next;
            obj = __entry->key;
            entry = &__entry->data;
            D.18415 = entry->finishing_time;
            D.18416 = D.18415 < 0;
            D.18417 = (long int) D.18416;
            D.18418 = __builtin_expect (D.18417, 0);
            if (D.18418 != 0) goto <D.18419>; else goto <D.18420>;
            <D.18419>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-bridge.c", 630, "entry->finishing_time >= 0");
            <D.18420>:
            j.34 = j;
            j = j.34 + 1;
            D.18422 = (long unsigned int) j.34;
            D.18423 = D.18422 * 8;
            D.18424 = all_entries + D.18423;
            *D.18424 = entry;
            D.18425 = entry->srcs.size;
            fist_pass_links.35 = fist_pass_links;
            fist_pass_links.36 = D.18425 + fist_pass_links.35;
            fist_pass_links = fist_pass_links.36;
          }
          __iter = __next;
          <D.17928>:
          D.18428 = *__iter;
          if (D.18428 != 0B) goto <D.17927>; else goto <D.17929>;
          <D.17929>:
        }
        __i = __i + 1;
        <D.17931>:
        D.18429 = hash_table.size;
        if (D.18429 > __i) goto <D.17930>; else goto <D.17932>;
        <D.17932>:
      }
      j.37 = (unsigned int) j;
      D.18410 = hash_table.num_entries;
      D.18431 = j.37 != D.18410;
      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", 634, "j == hash_table.num_entries");
      <D.18435>:
      D.18410 = hash_table.num_entries;
      hash_table_size = (int) D.18410;
      D.18410 = hash_table.num_entries;
      D.18436 = (long unsigned int) D.18410;
      sgen_qsort (all_entries, D.18436, 8, compare_hash_entries);
      btv = mono_100ns_ticks ();
      D.18437 = btv - atv;
      D.18438 = D.18437 / 10;
      D.18439 = (int) D.18438;
      step_3.38 = (long unsigned int) D.18439;
      step_3 = step_3.38;
      dyn_array_init (&sccs, 40);
      i = 0;
      goto <D.17936>;
      <D.17935>:
      {
        struct HashEntry * entry;

        D.18441 = (long unsigned int) i;
        D.18442 = D.18441 * 8;
        D.18443 = all_entries + D.18442;
        entry = *D.18443;
        D.18444 = entry->scc_index;
        if (D.18444 < 0) goto <D.18445>; else goto <D.18446>;
        <D.18445>:
        {
          int index;

          index = sccs.size;
          current_scc.39 = dyn_array_add (&sccs);
          current_scc = current_scc.39;
          current_scc.40 = current_scc;
          current_scc.40->index = index;
          current_scc.40 = current_scc;
          current_scc.40->num_bridge_entries = 0;
          current_scc.40 = current_scc;
          current_scc.40->api_index = -1;
          current_scc.40 = current_scc;
          D.18449 = &current_scc.40->xrefs;
          dyn_array_int_init (D.18449);
          dfs2 (entry);
        }
        <D.18446>:
      }
      i = i + 1;
      <D.17936>:
      i.41 = (unsigned int) i;
      D.18410 = hash_table.num_entries;
      if (i.41 < D.18410) goto <D.17935>; else goto <D.17937>;
      <D.17937>:
      sccs_size = sccs.size;
      i = 0;
      goto <D.17940>;
      <D.17939>:
      {
        struct HashEntry * entry;

        D.18441 = (long unsigned int) i;
        D.18442 = D.18441 * 8;
        D.18443 = all_entries + D.18442;
        entry = *D.18443;
        D.18451 = entry->srcs.size;
        second_pass_links.42 = second_pass_links;
        second_pass_links.43 = D.18451 + second_pass_links.42;
        second_pass_links = second_pass_links.43;
      }
      i = i + 1;
      <D.17940>:
      i.41 = (unsigned int) i;
      D.18410 = hash_table.num_entries;
      if (i.41 < D.18410) goto <D.17939>; else goto <D.17941>;
      <D.17941>:
      atv = mono_100ns_ticks ();
      D.18454 = atv - btv;
      D.18455 = D.18454 / 10;
      D.18456 = (int) D.18455;
      step_4.44 = (long unsigned int) D.18456;
      step_4 = step_4.44;
      dyn_array_uninit (&dfs_stack);
      num_sccs = 0;
      i = 0;
      goto <D.17944>;
      <D.17943>:
      {
        struct SCC * scc;

        D.18458 = sccs.data;
        D.18459 = sccs.elem_size;
        D.18460 = D.18459 * i;
        D.18461 = (sizetype) D.18460;
        scc = D.18458 + D.18461;
        D.18462 = scc->index;
        D.18463 = D.18462 != i;
        D.18464 = (long int) D.18463;
        D.18465 = __builtin_expect (D.18464, 0);
        if (D.18465 != 0) goto <D.18466>; else goto <D.18467>;
        <D.18466>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-bridge.c", 680, "scc->index == i");
        <D.18467>:
        D.18468 = scc->num_bridge_entries;
        if (D.18468 != 0) goto <D.18469>; else goto <D.18470>;
        <D.18469>:
        num_sccs = num_sccs + 1;
        <D.18470>:
        D.18471 = scc->xrefs.size;
        sccs_links.45 = sccs_links;
        sccs_links.46 = D.18471 + sccs_links.45;
        sccs_links = sccs_links.46;
        D.18471 = scc->xrefs.size;
        max_sccs_links.47 = max_sccs_links;
        max_sccs_links.48 = MAX_EXPR <D.18471, max_sccs_links.47>;
        max_sccs_links = max_sccs_links.48;
      }
      i = i + 1;
      <D.17944>:
      D.18476 = sccs.size;
      if (D.18476 > i) goto <D.17943>; else goto <D.17945>;
      <D.17945>:
      D.18477 = (long unsigned int) num_sccs;
      D.18478 = D.18477 * 8;
      api_sccs = sgen_alloc_internal_dynamic (D.18478, 21, 1);
      num_xrefs = 0;
      j = 0;
      i = 0;
      goto <D.17949>;
      <D.17948>:
      {
        struct SCC * scc;

        D.18458 = sccs.data;
        D.18459 = sccs.elem_size;
        D.18460 = D.18459 * i;
        D.18461 = (sizetype) D.18460;
        scc = D.18458 + D.18461;
        D.18479 = scc->num_bridge_entries;
        if (D.18479 == 0) goto <D.18480>; else goto <D.18481>;
        <D.18480>:
        // predicted unlikely by continue predictor.
        goto <D.17947>;
        <D.18481>:
        D.18482 = (long unsigned int) j;
        D.18483 = D.18482 * 8;
        D.18484 = api_sccs + D.18483;
        D.18479 = scc->num_bridge_entries;
        D.18485 = (long unsigned int) D.18479;
        D.18486 = D.18485 + 1;
        D.18487 = D.18486 * 8;
        D.18488 = sgen_alloc_internal_dynamic (D.18487, 21, 1);
        *D.18484 = D.18488;
        D.18482 = (long unsigned int) j;
        D.18483 = D.18482 * 8;
        D.18484 = api_sccs + D.18483;
        D.18489 = *D.18484;
        D.18489->is_alive = 0;
        D.18482 = (long unsigned int) j;
        D.18483 = D.18482 * 8;
        D.18484 = api_sccs + D.18483;
        D.18489 = *D.18484;
        D.18479 = scc->num_bridge_entries;
        D.18489->num_objs = D.18479;
        scc->num_bridge_entries = 0;
        j.49 = j;
        j = j.49 + 1;
        scc->api_index = j.49;
        D.18491 = scc->xrefs.size;
        num_xrefs = D.18491 + num_xrefs;
      }
      <D.17947>:
      i = i + 1;
      <D.17949>:
      D.18476 = sccs.size;
      if (D.18476 > i) goto <D.17948>; else goto <D.17950>;
      <D.17950>:
      {
        struct SgenHashTable * __hash_table;
        struct SgenHashTableEntry * * __table;
        guint __i;

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

          D.18492 = (long unsigned int) __i;
          D.18493 = D.18492 * 8;
          __iter = __table + D.18493;
          goto <D.17959>;
          <D.17958>:
          {
            struct SgenHashTableEntry * __entry;

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

              D.18458 = sccs.data;
              D.18497 = entry->scc_index;
              D.18459 = sccs.elem_size;
              D.18498 = D.18497 * D.18459;
              D.18499 = (sizetype) D.18498;
              scc = D.18458 + D.18499;
              D.18500 = scc->api_index;
              D.18501 = (long unsigned int) D.18500;
              D.18502 = D.18501 * 8;
              D.18503 = api_sccs + D.18502;
              D.18504 = *D.18503;
              D.18505 = scc->num_bridge_entries;
              D.18506 = D.18505;
              D.18507 = D.18506 + 1;
              scc->num_bridge_entries = D.18507;
              D.18508 = entry->obj;
              D.18504->objs[D.18506] = D.18508;
            }
            <D.18496>:
          }
          __iter = __next;
          <D.17959>:
          D.18509 = *__iter;
          if (D.18509 != 0B) goto <D.17958>; else goto <D.17960>;
          <D.17960>:
        }
        __i = __i + 1;
        <D.17962>:
        D.18429 = hash_table.size;
        if (D.18429 > __i) goto <D.17961>; else goto <D.17963>;
        <D.17963>:
      }
      D.18510 = (long unsigned int) num_xrefs;
      D.18511 = D.18510 * 8;
      api_xrefs = sgen_alloc_internal_dynamic (D.18511, 21, 1);
      j = 0;
      i = 0;
      goto <D.17973>;
      <D.17972>:
      {
        int k;
        struct SCC * scc;

        D.18458 = sccs.data;
        D.18459 = sccs.elem_size;
        D.18460 = D.18459 * i;
        D.18461 = (sizetype) D.18460;
        scc = D.18458 + D.18461;
        D.18512 = scc->num_bridge_entries;
        if (D.18512 == 0) goto <D.18513>; else goto <D.18514>;
        <D.18513>:
        // predicted unlikely by continue predictor.
        goto <D.17966>;
        <D.18514>:
        k = 0;
        goto <D.17970>;
        <D.17969>:
        {
          struct SCC * src_scc;

          D.18458 = sccs.data;
          D.18515 = scc->xrefs.data;
          D.18516 = (long unsigned int) k;
          D.18517 = D.18516 * 4;
          D.18518 = D.18515 + D.18517;
          D.18519 = *D.18518;
          D.18459 = sccs.elem_size;
          D.18520 = D.18519 * D.18459;
          D.18521 = (sizetype) D.18520;
          src_scc = D.18458 + D.18521;
          D.18522 = src_scc->num_bridge_entries;
          if (D.18522 == 0) goto <D.18523>; else goto <D.18524>;
          <D.18523>:
          // predicted unlikely by continue predictor.
          goto <D.17968>;
          <D.18524>:
          D.18482 = (long unsigned int) j;
          D.18483 = D.18482 * 8;
          D.18525 = api_xrefs + D.18483;
          D.18526 = src_scc->api_index;
          D.18525->src_scc_index = D.18526;
          D.18482 = (long unsigned int) j;
          D.18483 = D.18482 * 8;
          D.18525 = api_xrefs + D.18483;
          D.18527 = scc->api_index;
          D.18525->dst_scc_index = D.18527;
          j = j + 1;
        }
        <D.17968>:
        k = k + 1;
        <D.17970>:
        D.18528 = scc->xrefs.size;
        if (D.18528 > k) goto <D.17969>; else goto <D.17971>;
        <D.17971>:
      }
      <D.17966>:
      i = i + 1;
      <D.17973>:
      D.18476 = sccs.size;
      if (D.18476 > i) goto <D.17972>; else goto <D.17974>;
      <D.17974>:
      btv = mono_100ns_ticks ();
      D.18437 = btv - atv;
      D.18438 = D.18437 / 10;
      D.18439 = (int) D.18438;
      step_3.38 = (long unsigned int) D.18439;
      step_5 = step_3.38;
      j = 0;
      max_xrefs = 0;
      max_entries = max_xrefs;
      i = 0;
      goto <D.17977>;
      <D.17976>:
      {
        struct SCC * scc;

        D.18458 = sccs.data;
        D.18459 = sccs.elem_size;
        D.18460 = D.18459 * i;
        D.18461 = (sizetype) D.18460;
        scc = D.18458 + D.18461;
        D.18529 = scc->num_bridge_entries;
        if (D.18529 != 0) goto <D.18530>; else goto <D.18531>;
        <D.18530>:
        j = j + 1;
        <D.18531>:
        D.18529 = scc->num_bridge_entries;
        if (D.18529 > max_entries) goto <D.18532>; else goto <D.18533>;
        <D.18532>:
        max_entries = scc->num_bridge_entries;
        <D.18533>:
        D.18534 = scc->xrefs.size;
        if (D.18534 > max_xrefs) goto <D.18535>; else goto <D.18536>;
        <D.18535>:
        max_xrefs = scc->xrefs.size;
        <D.18536>:
        D.18537 = &scc->xrefs;
        dyn_array_uninit (D.18537);
      }
      i = i + 1;
      <D.17977>:
      D.18476 = sccs.size;
      if (D.18476 > i) goto <D.17976>; else goto <D.17978>;
      <D.17978>:
      dyn_array_uninit (&sccs);
      D.18410 = hash_table.num_entries;
      D.18411 = (long unsigned int) D.18410;
      D.18412 = D.18411 * 8;
      sgen_free_internal_dynamic (all_entries, D.18412, 21);
      free_data ();
      num_registered_bridges = registered_bridges.size;
      registered_bridges.size = 0;
      atv = mono_100ns_ticks ();
      D.18454 = atv - btv;
      D.18455 = D.18454 / 10;
      D.18456 = (int) D.18455;
      step_4.44 = (long unsigned int) D.18456;
      step_6 = step_4.44;
      D.18538 = bridge_callbacks.cross_references;
      D.18538 (num_sccs, api_sccs, num_xrefs, api_xrefs);
      btv = mono_100ns_ticks ();
      D.18437 = btv - atv;
      D.18438 = D.18437 / 10;
      D.18439 = (int) D.18438;
      step_3.38 = (long unsigned int) D.18439;
      step_7 = step_3.38;
      i = 0;
      goto <D.17984>;
      <D.17983>:
      {
        unsigned char alive;

        try
          {
            D.18441 = (long unsigned int) i;
            D.18442 = D.18441 * 8;
            D.18539 = api_sccs + D.18442;
            D.18540 = *D.18539;
            D.18541 = D.18540->is_alive;
            D.18542 = D.18541 != 0;
            alive.50 = (unsigned char) D.18542;
            alive = alive.50;
            j = 0;
            goto <D.17981>;
            <D.17980>:
            D.18441 = (long unsigned int) i;
            D.18442 = D.18441 * 8;
            D.18539 = api_sccs + D.18442;
            D.18540 = *D.18539;
            D.18544 = D.18540->objs[j];
            sgen_hash_table_replace (&alive_hash, D.18544, &alive, 0B);
            D.18441 = (long unsigned int) i;
            D.18442 = D.18441 * 8;
            D.18539 = api_sccs + D.18442;
            D.18540 = *D.18539;
            D.18541 = D.18540->is_alive;
            if (D.18541 == 0) goto <D.18545>; else goto <D.18546>;
            <D.18545>:
            D.18441 = (long unsigned int) i;
            D.18442 = D.18441 * 8;
            D.18539 = api_sccs + D.18442;
            D.18540 = *D.18539;
            D.18544 = D.18540->objs[j];
            sgen_mark_bridge_object (D.18544);
            <D.18546>:
            j = j + 1;
            <D.17981>:
            D.18441 = (long unsigned int) i;
            D.18442 = D.18441 * 8;
            D.18539 = api_sccs + D.18442;
            D.18540 = *D.18539;
            D.18547 = D.18540->num_objs;
            if (D.18547 > j) goto <D.17980>; else goto <D.17982>;
            <D.17982>:
          }
        finally
          {
            alive = {CLOBBER};
          }
      }
      i = i + 1;
      <D.17984>:
      if (i < num_sccs) goto <D.17983>; else goto <D.17985>;
      <D.17985>:
      sgen_null_links_with_predicate (0, is_bridge_object_alive, &alive_hash);
      if (generation == 1) goto <D.18548>; else goto <D.18549>;
      <D.18548>:
      sgen_null_links_with_predicate (1, is_bridge_object_alive, &alive_hash);
      <D.18549>:
      sgen_hash_table_clean (&alive_hash);
      i = 0;
      goto <D.17987>;
      <D.17986>:
      D.18441 = (long unsigned int) i;
      D.18442 = D.18441 * 8;
      D.18539 = api_sccs + D.18442;
      D.18540 = *D.18539;
      D.18547 = D.18540->num_objs;
      D.18550 = (long unsigned int) D.18547;
      D.18551 = D.18550 + 1;
      D.18552 = D.18551 * 8;
      D.18441 = (long unsigned int) i;
      D.18442 = D.18441 * 8;
      D.18539 = api_sccs + D.18442;
      D.18540 = *D.18539;
      sgen_free_internal_dynamic (D.18540, D.18552, 21);
      i = i + 1;
      <D.17987>:
      if (i < num_sccs) goto <D.17986>; else goto <D.17988>;
      <D.17988>:
      D.18477 = (long unsigned int) num_sccs;
      D.18478 = D.18477 * 8;
      sgen_free_internal_dynamic (api_sccs, D.18478, 21);
      D.18510 = (long unsigned int) num_xrefs;
      D.18511 = D.18510 * 8;
      sgen_free_internal_dynamic (api_xrefs, D.18511, 21);
      atv = mono_100ns_ticks ();
      D.18454 = atv - btv;
      D.18455 = D.18454 / 10;
      D.18456 = (int) D.18455;
      step_4.44 = (long unsigned int) D.18456;
      step_8 = step_4.44;
      dsf2_passes.51 = dsf2_passes;
      dsf1_passes.52 = dsf1_passes;
      max_sccs_links.47 = max_sccs_links;
      sccs_links.45 = sccs_links;
      second_pass_links.42 = second_pass_links;
      fist_pass_links.35 = fist_pass_links;
      step_8.53 = step_8;
      D.18556 = (float) step_8.53;
      D.18557 = D.18556 / 1.0e+3;
      D.18558 = (double) D.18557;
      step_7.54 = step_7;
      D.18560 = (float) step_7.54;
      D.18561 = D.18560 / 1.0e+3;
      D.18562 = (double) D.18561;
      step_6.55 = step_6;
      D.18564 = (float) step_6.55;
      D.18565 = D.18564 / 1.0e+3;
      D.18566 = (double) D.18565;
      step_5.56 = step_5;
      D.18568 = (float) step_5.56;
      D.18569 = D.18568 / 1.0e+3;
      D.18570 = (double) D.18569;
      step_4.57 = step_4;
      D.18572 = (float) step_4.57;
      D.18573 = D.18572 / 1.0e+3;
      D.18574 = (double) D.18573;
      step_3.58 = step_3;
      D.18576 = (float) step_3.58;
      D.18577 = D.18576 / 1.0e+3;
      D.18578 = (double) D.18577;
      step_2.59 = step_2;
      D.18580 = (float) step_2.59;
      D.18581 = D.18580 / 1.0e+3;
      D.18582 = (double) D.18581;
      step_1.60 = step_1;
      D.18584 = (float) step_1.60;
      D.18585 = D.18584 / 1.0e+3;
      D.18586 = (double) D.18585;
      D.18476 = 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.18476, D.18586, D.18582, D.18578, D.18574, D.18570, D.18566, D.18562, D.18558, fist_pass_links.35, second_pass_links.42, sccs_links.45, max_sccs_links.47, dsf1_passes.52, dsf2_passes.51);
      step_1 = 0;
      bridge_processing_in_progress = 0;
    }
  finally
    {
      alive_hash = {CLOBBER};
    }
}


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

  table = data;
  value = sgen_hash_table_lookup (table, obj);
  if (value == 0B) goto <D.18590>; else goto <D.18591>;
  <D.18590>:
  D.18592 = 1;
  return D.18592;
  <D.18591>:
  D.18593 = *value;
  D.18592 = (mono_bool) D.18593;
  return D.18592;
}


compare_hash_entries (const void * ep1, const void * ep2)
{
  int D.18595;
  int D.18596;
  int D.18597;
  struct HashEntry * e1;
  struct HashEntry * e2;

  e1 = MEM[(struct HashEntry * *)ep1];
  e2 = MEM[(struct HashEntry * *)ep2];
  D.18596 = e2->finishing_time;
  D.18597 = e1->finishing_time;
  D.18595 = D.18596 - D.18597;
  return D.18595;
}


dfs2 (struct HashEntry * entry)
{
  int D.18599;
  _Bool D.18600;
  long int D.18601;
  long int D.18602;
  int dsf2_passes.61;
  int dsf2_passes.62;
  int D.18607;
  struct SCC * current_scc.63;
  int D.18611;
  char * D.18614;
  int D.18615;
  int D.18616;
  sizetype D.18617;
  struct SCC * D.18618;
  char * D.18619;
  long unsigned int D.18620;
  long unsigned int D.18621;
  void * * D.18622;
  void * D.18623;
  int D.18624;
  int i;

  D.18599 = dfs_stack.size;
  D.18600 = D.18599 != 0;
  D.18601 = (long int) D.18600;
  D.18602 = __builtin_expect (D.18601, 0);
  if (D.18602 != 0) goto <D.18603>; else goto <D.18604>;
  <D.18603>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-bridge.c", 501, "dfs_stack.size == 0");
  <D.18604>:
  dyn_array_ptr_add (&dfs_stack, entry);
  <D.17857>:
  entry = dyn_array_ptr_pop (&dfs_stack);
  dsf2_passes.61 = dsf2_passes;
  dsf2_passes.62 = dsf2_passes.61 + 1;
  dsf2_passes = dsf2_passes.62;
  D.18607 = entry->scc_index;
  if (D.18607 >= 0) goto <D.18608>; else goto <D.18609>;
  <D.18608>:
  D.18607 = entry->scc_index;
  current_scc.63 = current_scc;
  D.18611 = current_scc.63->index;
  if (D.18607 != D.18611) goto <D.18612>; else goto <D.18613>;
  <D.18612>:
  current_scc.63 = current_scc;
  D.18614 = sccs.data;
  D.18607 = entry->scc_index;
  D.18615 = sccs.elem_size;
  D.18616 = D.18607 * D.18615;
  D.18617 = (sizetype) D.18616;
  D.18618 = D.18614 + D.18617;
  scc_add_xref (D.18618, current_scc.63);
  <D.18613>:
  // predicted unlikely by continue predictor.
  goto <D.17853>;
  <D.18609>:
  current_scc.63 = current_scc;
  scc_add_entry (current_scc.63, entry);
  i = 0;
  goto <D.17855>;
  <D.17854>:
  D.18619 = entry->srcs.data;
  D.18620 = (long unsigned int) i;
  D.18621 = D.18620 * 8;
  D.18622 = D.18619 + D.18621;
  D.18623 = *D.18622;
  dyn_array_ptr_add (&dfs_stack, D.18623);
  i = i + 1;
  <D.17855>:
  D.18624 = entry->srcs.size;
  if (D.18624 > i) goto <D.17854>; else goto <D.17856>;
  <D.17856>:
  <D.17853>:
  D.18599 = dfs_stack.size;
  if (D.18599 > 0) goto <D.17857>; else goto <D.17858>;
  <D.17858>:
}


scc_add_xref (struct SCC * src, struct SCC * dst)
{
  _Bool D.18625;
  long int D.18626;
  long int D.18627;
  int D.18630;
  int D.18631;
  _Bool D.18632;
  long int D.18633;
  long int D.18634;
  struct DynArray * D.18637;
  int D.18638;
  int D.18641;
  struct DynArray * D.18645;
  char * D.18646;
  long unsigned int D.18647;
  long unsigned int D.18648;
  int * D.18649;
  int D.18650;
  _Bool D.18651;
  long int D.18652;
  long int D.18653;
  int D.18656;

  D.18625 = src == dst;
  D.18626 = (long int) D.18625;
  D.18627 = __builtin_expect (D.18626, 0);
  if (D.18627 != 0) goto <D.18628>; else goto <D.18629>;
  <D.18628>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-bridge.c", 469, "src != dst");
  <D.18629>:
  D.18630 = src->index;
  D.18631 = dst->index;
  D.18632 = D.18630 == D.18631;
  D.18633 = (long int) D.18632;
  D.18634 = __builtin_expect (D.18633, 0);
  if (D.18634 != 0) goto <D.18635>; else goto <D.18636>;
  <D.18635>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-bridge.c", 470, "src->index != dst->index");
  <D.18636>:
  D.18630 = src->index;
  D.18637 = &dst->xrefs;
  D.18638 = dyn_array_int_contains (D.18637, D.18630);
  if (D.18638 != 0) goto <D.18639>; else goto <D.18640>;
  <D.18639>:
  return;
  <D.18640>:
  D.18641 = src->num_bridge_entries;
  if (D.18641 != 0) goto <D.18642>; else goto <D.18643>;
  <D.18642>:
  D.18630 = src->index;
  D.18637 = &dst->xrefs;
  dyn_array_int_merge_one (D.18637, D.18630);
  goto <D.18644>;
  <D.18643>:
  {
    int i;

    D.18645 = &src->xrefs;
    D.18637 = &dst->xrefs;
    dyn_array_int_merge (D.18637, D.18645);
    i = 0;
    goto <D.17841>;
    <D.17840>:
    D.18646 = dst->xrefs.data;
    D.18647 = (long unsigned int) i;
    D.18648 = D.18647 * 4;
    D.18649 = D.18646 + D.18648;
    D.18650 = *D.18649;
    D.18631 = dst->index;
    D.18651 = D.18650 == D.18631;
    D.18652 = (long int) D.18651;
    D.18653 = __builtin_expect (D.18652, 0);
    if (D.18653 != 0) goto <D.18654>; else goto <D.18655>;
    <D.18654>:
    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.18655>:
    i = i + 1;
    <D.17841>:
    D.18656 = dst->xrefs.size;
    if (D.18656 > i) goto <D.17840>; else goto <D.17842>;
    <D.17842>:
  }
  <D.18644>:
}


dyn_array_int_contains (struct DynArray * da, int x)
{
  char * D.18658;
  long unsigned int D.18659;
  long unsigned int D.18660;
  int * D.18661;
  int D.18662;
  gboolean D.18665;
  int D.18666;
  int i;

  i = 0;
  goto <D.17621>;
  <D.17620>:
  D.18658 = da->data;
  D.18659 = (long unsigned int) i;
  D.18660 = D.18659 * 4;
  D.18661 = D.18658 + D.18660;
  D.18662 = *D.18661;
  if (D.18662 == x) goto <D.18663>; else goto <D.18664>;
  <D.18663>:
  D.18665 = 1;
  return D.18665;
  <D.18664>:
  i = i + 1;
  <D.17621>:
  D.18666 = da->size;
  if (D.18666 > i) goto <D.17620>; else goto <D.17622>;
  <D.17622>:
  D.18665 = 0;
  return D.18665;
}


dyn_array_int_merge_one (struct DynArray * array, int value)
{
  char * D.18668;
  long unsigned int D.18669;
  long unsigned int D.18670;
  int * D.18671;
  int D.18672;
  int D.18676;
  int D.18677;
  sizetype D.18680;
  sizetype D.18681;
  sizetype D.18682;
  int * D.18683;
  sizetype D.18684;
  sizetype D.18685;
  sizetype D.18686;
  int * D.18687;
  long unsigned int D.18689;
  long unsigned int D.18690;
  int * D.18691;
  int i;
  int tmp;
  int end;

  end = array->size;
  i = 0;
  goto <D.17644>;
  <D.17643>:
  D.18668 = array->data;
  D.18669 = (long unsigned int) i;
  D.18670 = D.18669 * 4;
  D.18671 = D.18668 + D.18670;
  D.18672 = *D.18671;
  if (D.18672 == value) goto <D.18673>; else goto <D.18674>;
  <D.18673>:
  return;
  <D.18674>:
  D.18668 = array->data;
  D.18669 = (long unsigned int) i;
  D.18670 = D.18669 * 4;
  D.18671 = D.18668 + D.18670;
  D.18672 = *D.18671;
  if (D.18672 > value) goto <D.17642>; else goto <D.18675>;
  <D.18675>:
  i = i + 1;
  <D.17644>:
  if (i < end) goto <D.17643>; else goto <D.17642>;
  <D.17642>:
  D.18676 = array->size;
  D.18677 = D.18676 + 1;
  dyn_array_ensure_capacity (array, D.18677);
  if (i < end) goto <D.18678>; else goto <D.18679>;
  <D.18678>:
  D.18668 = array->data;
  D.18669 = (long unsigned int) i;
  D.18670 = D.18669 * 4;
  D.18671 = D.18668 + D.18670;
  tmp = *D.18671;
  goto <D.17646>;
  <D.17645>:
  D.18668 = array->data;
  D.18669 = (long unsigned int) i;
  D.18670 = D.18669 * 4;
  D.18671 = D.18668 + D.18670;
  *D.18671 = value;
  value = tmp;
  D.18668 = array->data;
  D.18680 = (sizetype) i;
  D.18681 = D.18680 + 1;
  D.18682 = D.18681 * 4;
  D.18683 = D.18668 + D.18682;
  tmp = *D.18683;
  i = i + 1;
  <D.17646>:
  if (i <= end) goto <D.17645>; else goto <D.17647>;
  <D.17647>:
  D.18668 = array->data;
  D.18684 = (sizetype) end;
  D.18685 = D.18684 + 1;
  D.18686 = D.18685 * 4;
  D.18687 = D.18668 + D.18686;
  *D.18687 = tmp;
  goto <D.18688>;
  <D.18679>:
  D.18668 = array->data;
  D.18689 = (long unsigned int) end;
  D.18690 = D.18689 * 4;
  D.18691 = D.18668 + D.18690;
  *D.18691 = value;
  <D.18688>:
  D.18676 = array->size;
  D.18677 = D.18676 + 1;
  array->size = D.18677;
}


dyn_array_int_merge (struct DynArray * dst, struct DynArray * src)
{
  int D.18693;
  int D.18694;
  int D.18695;
  char * D.18700;
  long unsigned int D.18701;
  long unsigned int D.18702;
  int * D.18703;
  char * D.18704;
  long unsigned int D.18705;
  long unsigned int D.18706;
  int * D.18707;
  int D.18716;
  int D.18718;
  int D.18720;
  int D.18723;
  int D.18724;
  long unsigned int D.18725;
  char * D.18726;
  int i;
  int j;

  D.18693 = dst->size;
  D.18694 = src->size;
  D.18695 = D.18693 + D.18694;
  dyn_array_ensure_capacity (&merge_array, D.18695);
  merge_array.size = 0;
  j = 0;
  i = j;
  goto <D.17633>;
  <D.17632>:
  D.18693 = dst->size;
  if (D.18693 > i) goto <D.18698>; else goto <D.18696>;
  <D.18698>:
  D.18694 = src->size;
  if (D.18694 > j) goto <D.18699>; else goto <D.18696>;
  <D.18699>:
  {
    int a;
    int b;

    D.18700 = dst->data;
    D.18701 = (long unsigned int) i;
    D.18702 = D.18701 * 4;
    D.18703 = D.18700 + D.18702;
    a = *D.18703;
    D.18704 = src->data;
    D.18705 = (long unsigned int) j;
    D.18706 = D.18705 * 4;
    D.18707 = D.18704 + D.18706;
    b = *D.18707;
    if (a < b) goto <D.18708>; else goto <D.18709>;
    <D.18708>:
    dyn_array_int_add (&merge_array, a);
    i = i + 1;
    goto <D.18710>;
    <D.18709>:
    if (a == b) goto <D.18711>; else goto <D.18712>;
    <D.18711>:
    dyn_array_int_add (&merge_array, a);
    i = i + 1;
    j = j + 1;
    goto <D.18713>;
    <D.18712>:
    dyn_array_int_add (&merge_array, b);
    j = j + 1;
    <D.18713>:
    <D.18710>:
  }
  goto <D.18697>;
  <D.18696>:
  D.18693 = dst->size;
  if (D.18693 > i) goto <D.18714>; else goto <D.18715>;
  <D.18714>:
  D.18700 = dst->data;
  D.18701 = (long unsigned int) i;
  D.18702 = D.18701 * 4;
  D.18703 = D.18700 + D.18702;
  D.18716 = *D.18703;
  dyn_array_int_add (&merge_array, D.18716);
  i = i + 1;
  goto <D.18717>;
  <D.18715>:
  D.18704 = src->data;
  D.18705 = (long unsigned int) j;
  D.18706 = D.18705 * 4;
  D.18707 = D.18704 + D.18706;
  D.18718 = *D.18707;
  dyn_array_int_add (&merge_array, D.18718);
  j = j + 1;
  <D.18717>:
  <D.18697>:
  <D.17633>:
  D.18693 = dst->size;
  if (D.18693 > i) goto <D.17632>; else goto <D.18719>;
  <D.18719>:
  D.18694 = src->size;
  if (D.18694 > j) goto <D.17632>; else goto <D.17634>;
  <D.17634>:
  D.18720 = merge_array.size;
  D.18693 = dst->size;
  if (D.18720 > D.18693) goto <D.18721>; else goto <D.18722>;
  <D.18721>:
  D.18720 = merge_array.size;
  dyn_array_ensure_capacity (dst, D.18720);
  D.18720 = merge_array.size;
  D.18723 = merge_array.elem_size;
  D.18724 = D.18720 * D.18723;
  D.18725 = (long unsigned int) D.18724;
  D.18726 = merge_array.data;
  D.18700 = dst->data;
  memcpy (D.18700, D.18726, D.18725);
  D.18720 = merge_array.size;
  dst->size = D.18720;
  <D.18722>:
}


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.18727;
  _Bool D.18728;
  long int D.18729;
  long int D.18730;
  int D.18733;
  int D.18734;
  int D.18737;
  int D.18738;

  D.18727 = entry->scc_index;
  D.18728 = D.18727 >= 0;
  D.18729 = (long int) D.18728;
  D.18730 = __builtin_expect (D.18729, 0);
  if (D.18730 != 0) goto <D.18731>; else goto <D.18732>;
  <D.18731>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-bridge.c", 487, "entry->scc_index < 0");
  <D.18732>:
  D.18733 = scc->index;
  entry->scc_index = D.18733;
  D.18734 = entry->is_bridge;
  if (D.18734 != 0) goto <D.18735>; else goto <D.18736>;
  <D.18735>:
  D.18737 = scc->num_bridge_entries;
  D.18738 = D.18737 + 1;
  scc->num_bridge_entries = D.18738;
  <D.18736>:
}


dyn_array_uninit (struct DynArray * da)
{
  int D.18739;
  int D.18742;
  int D.18743;
  long unsigned int D.18744;
  char * D.18745;

  D.18739 = da->capacity;
  if (D.18739 <= 0) goto <D.18740>; else goto <D.18741>;
  <D.18740>:
  return;
  <D.18741>:
  D.18742 = da->elem_size;
  D.18739 = da->capacity;
  D.18743 = D.18742 * D.18739;
  D.18744 = (long unsigned int) D.18743;
  D.18745 = da->data;
  sgen_free_internal_dynamic (D.18745, D.18744, 21);
  da->data = 0B;
}


free_data ()
{
  long unsigned int D.18747;
  long unsigned int D.18748;
  int D.18749;
  struct DynArray * D.18752;
  struct SgenHashTableEntry * D.18753;
  unsigned int D.18754;
  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.17709>;
    <D.17708>:
    {
      struct SgenHashTableEntry * * __iter;
      struct SgenHashTableEntry * * __next;

      D.18747 = (long unsigned int) __i;
      D.18748 = D.18747 * 8;
      __iter = __table + D.18748;
      goto <D.17706>;
      <D.17705>:
      {
        struct SgenHashTableEntry * __entry;

        __entry = *__iter;
        __next = &__entry->next;
        obj = __entry->key;
        entry = &__entry->data;
        D.18749 = entry->srcs.size;
        total_srcs = D.18749 + total_srcs;
        D.18749 = entry->srcs.size;
        if (D.18749 > max_srcs) goto <D.18750>; else goto <D.18751>;
        <D.18750>:
        max_srcs = entry->srcs.size;
        <D.18751>:
        D.18752 = &entry->srcs;
        dyn_array_uninit (D.18752);
      }
      __iter = __next;
      <D.17706>:
      D.18753 = *__iter;
      if (D.18753 != 0B) goto <D.17705>; else goto <D.17707>;
      <D.17707>:
    }
    __i = __i + 1;
    <D.17709>:
    D.18754 = hash_table.size;
    if (D.18754 > __i) goto <D.17708>; else goto <D.17710>;
    <D.17710>:
  }
  sgen_hash_table_clean (&hash_table);
  dyn_array_uninit (&merge_array);
}


sgen_bridge_describe_pointer (struct MonoObject * obj)
{
  char * D.18755;
  long unsigned int D.18756;
  long unsigned int D.18757;
  void * * D.18758;
  void * D.18759;
  int D.18762;
  int D.18765;
  int D.18766;
  struct HashEntry * entry;
  int i;

  i = 0;
  goto <D.17996>;
  <D.17995>:
  D.18755 = registered_bridges.data;
  D.18756 = (long unsigned int) i;
  D.18757 = D.18756 * 8;
  D.18758 = D.18755 + D.18757;
  D.18759 = *D.18758;
  if (D.18759 == obj) goto <D.18760>; else goto <D.18761>;
  <D.18760>:
  printf ("Pointer is a registered bridge object.\n");
  goto <D.17994>;
  <D.18761>:
  i = i + 1;
  <D.17996>:
  D.18762 = registered_bridges.size;
  if (D.18762 > i) goto <D.17995>; else goto <D.17994>;
  <D.17994>:
  entry = sgen_hash_table_lookup (&hash_table, obj);
  if (entry == 0B) goto <D.18763>; else goto <D.18764>;
  <D.18763>:
  return;
  <D.18764>:
  printf ("Bridge hash table entry %p:\n", entry);
  D.18765 = entry->is_bridge;
  printf ("  is bridge: %d\n", D.18765);
  D.18766 = entry->is_visited;
  printf ("  is visited: %d\n", D.18766);
}


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

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


sgen_register_test_bridge_callbacks (const char * bridge_class_name)
{
  void (*<T2ee9>) (int, struct MonoGCBridgeSCC * *, int, struct MonoGCBridgeXRef *) iftmp.64;
  char D.18771;
  sizetype iftmp.65;
  const char * bridge_class.66;
  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.18771 = *bridge_class_name;
      if (D.18771 == 50) goto <D.18772>; else goto <D.18773>;
      <D.18772>:
      iftmp.64 = bridge_test_cross_reference2;
      goto <D.18774>;
      <D.18773>:
      iftmp.64 = bridge_test_cross_reference;
      <D.18774>:
      callbacks.cross_references = iftmp.64;
      mono_gc_register_bridge_callbacks (&callbacks);
      D.18771 = *bridge_class_name;
      if (D.18771 == 50) goto <D.18776>; else goto <D.18777>;
      <D.18776>:
      iftmp.65 = 1;
      goto <D.18778>;
      <D.18777>:
      iftmp.65 = 0;
      <D.18778>:
      bridge_class.66 = bridge_class_name + iftmp.65;
      bridge_class = bridge_class.66;
    }
  finally
    {
      callbacks = {CLOBBER};
    }
}


bridge_test_cross_reference (int num_sccs, struct MonoGCBridgeSCC * * sccs, int num_xrefs, struct MonoGCBridgeXRef * xrefs)
{
  int D.18780;
  long unsigned int D.18783;
  long unsigned int D.18784;
  struct MonoGCBridgeSCC * * D.18785;
  struct MonoGCBridgeSCC * D.18786;
  int D.18787;
  int iftmp.67;
  struct MonoGCBridgeXRef * D.18792;
  int D.18793;
  _Bool D.18795;
  long int D.18796;
  long int D.18797;
  int iftmp.68;
  int D.18804;
  _Bool D.18806;
  long int D.18807;
  long int D.18808;
  int i;

  i = 0;
  goto <D.18025>;
  <D.18024>:
  {
    int j;

    j = 0;
    goto <D.18022>;
    <D.18021>:
    D.18780 = i & 1;
    if (D.18780 != 0) goto <D.18781>; else goto <D.18782>;
    <D.18781>:
    D.18783 = (long unsigned int) i;
    D.18784 = D.18783 * 8;
    D.18785 = sccs + D.18784;
    D.18786 = *D.18785;
    D.18786->is_alive = 1;
    <D.18782>:
    j = j + 1;
    <D.18022>:
    D.18783 = (long unsigned int) i;
    D.18784 = D.18783 * 8;
    D.18785 = sccs + D.18784;
    D.18786 = *D.18785;
    D.18787 = D.18786->num_objs;
    if (D.18787 > j) goto <D.18021>; else goto <D.18023>;
    <D.18023>:
  }
  i = i + 1;
  <D.18025>:
  if (i < num_sccs) goto <D.18024>; else goto <D.18026>;
  <D.18026>:
  i = 0;
  goto <D.18028>;
  <D.18027>:
  D.18783 = (long unsigned int) i;
  D.18784 = D.18783 * 8;
  D.18792 = xrefs + D.18784;
  D.18793 = D.18792->src_scc_index;
  if (D.18793 < 0) goto <D.18789>; else goto <D.18794>;
  <D.18794>:
  D.18783 = (long unsigned int) i;
  D.18784 = D.18783 * 8;
  D.18792 = xrefs + D.18784;
  D.18793 = D.18792->src_scc_index;
  if (D.18793 >= num_sccs) goto <D.18789>; else goto <D.18790>;
  <D.18789>:
  iftmp.67 = 1;
  goto <D.18791>;
  <D.18790>:
  iftmp.67 = 0;
  <D.18791>:
  D.18795 = iftmp.67 != 0;
  D.18796 = (long int) D.18795;
  D.18797 = __builtin_expect (D.18796, 0);
  if (D.18797 != 0) goto <D.18798>; else goto <D.18799>;
  <D.18798>:
  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.18799>:
  D.18783 = (long unsigned int) i;
  D.18784 = D.18783 * 8;
  D.18792 = xrefs + D.18784;
  D.18804 = D.18792->dst_scc_index;
  if (D.18804 < 0) goto <D.18801>; else goto <D.18805>;
  <D.18805>:
  D.18783 = (long unsigned int) i;
  D.18784 = D.18783 * 8;
  D.18792 = xrefs + D.18784;
  D.18804 = D.18792->dst_scc_index;
  if (D.18804 >= num_sccs) goto <D.18801>; else goto <D.18802>;
  <D.18801>:
  iftmp.68 = 1;
  goto <D.18803>;
  <D.18802>:
  iftmp.68 = 0;
  <D.18803>:
  D.18806 = iftmp.68 != 0;
  D.18807 = (long int) D.18806;
  D.18808 = __builtin_expect (D.18807, 0);
  if (D.18808 != 0) goto <D.18809>; else goto <D.18810>;
  <D.18809>:
  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.18810>:
  i = i + 1;
  <D.18028>:
  if (i < num_xrefs) goto <D.18027>; else goto <D.18029>;
  <D.18029>:
}


bridge_test_cross_reference2 (int num_sccs, struct MonoGCBridgeSCC * * sccs, int num_xrefs, struct MonoGCBridgeXRef * xrefs)
{
  struct MonoClassField * mono_bridge_test_field.69;
  struct MonoGCBridgeSCC * D.18814;
  struct MonoObject * D.18815;
  struct MonoClass * D.18816;
  struct MonoClassField * mono_bridge_test_field.70;
  _Bool D.18818;
  long int D.18819;
  long int D.18820;
  long unsigned int D.18823;
  long unsigned int D.18824;
  struct MonoGCBridgeSCC * * D.18825;
  struct MonoGCBridgeSCC * D.18826;
  int D.18827;
  int D.18830;
  int D.18833;
  struct MonoObject * D.18836;
  struct MonoGCBridgeXRef * D.18837;
  int D.18838;
  long unsigned int D.18839;
  long unsigned int D.18840;
  struct MonoGCBridgeSCC * * D.18841;
  struct MonoGCBridgeSCC * D.18842;
  int D.18843;
  int D.18846;
  long unsigned int D.18847;
  long unsigned int D.18848;
  struct MonoGCBridgeSCC * * D.18849;
  struct MonoGCBridgeSCC * D.18850;
  int D.18851;
  int i;
  gboolean modified;

  mono_bridge_test_field.69 = mono_bridge_test_field;
  if (mono_bridge_test_field.69 == 0B) goto <D.18812>; else goto <D.18813>;
  <D.18812>:
  D.18814 = *sccs;
  D.18815 = D.18814->objs[0];
  D.18816 = mono_object_get_class (D.18815);
  mono_bridge_test_field.70 = mono_class_get_field_from_name (D.18816, "__test");
  mono_bridge_test_field = mono_bridge_test_field.70;
  mono_bridge_test_field.69 = mono_bridge_test_field;
  D.18818 = mono_bridge_test_field.69 == 0B;
  D.18819 = (long int) D.18818;
  D.18820 = __builtin_expect (D.18819, 0);
  if (D.18820 != 0) goto <D.18821>; else goto <D.18822>;
  <D.18821>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-bridge.c", 912, "mono_bridge_test_field");
  <D.18822>:
  <D.18813>:
  i = 0;
  goto <D.18069>;
  <D.18068>:
  {
    int j;
    gboolean live;

    live = 0;
    j = 0;
    goto <D.18062>;
    <D.18061>:
    D.18823 = (long unsigned int) i;
    D.18824 = D.18823 * 8;
    D.18825 = sccs + D.18824;
    D.18826 = *D.18825;
    D.18827 = test_scc (D.18826, j);
    if (D.18827 != 0) goto <D.18828>; else goto <D.18829>;
    <D.18828>:
    live = 1;
    goto <D.18060>;
    <D.18829>:
    j = j + 1;
    <D.18062>:
    D.18823 = (long unsigned int) i;
    D.18824 = D.18823 * 8;
    D.18825 = sccs + D.18824;
    D.18826 = *D.18825;
    D.18830 = D.18826->num_objs;
    if (D.18830 > j) goto <D.18061>; else goto <D.18060>;
    <D.18060>:
    if (live == 0) goto <D.18831>; else goto <D.18832>;
    <D.18831>:
    // predicted unlikely by continue predictor.
    goto <D.18063>;
    <D.18832>:
    j = 0;
    goto <D.18066>;
    <D.18065>:
    D.18823 = (long unsigned int) i;
    D.18824 = D.18823 * 8;
    D.18825 = sccs + D.18824;
    D.18826 = *D.18825;
    D.18833 = test_scc (D.18826, j);
    if (D.18833 == 0) goto <D.18834>; else goto <D.18835>;
    <D.18834>:
    {
      int status;

      try
        {
          status = 2;
          mono_bridge_test_field.69 = mono_bridge_test_field;
          D.18823 = (long unsigned int) i;
          D.18824 = D.18823 * 8;
          D.18825 = sccs + D.18824;
          D.18826 = *D.18825;
          D.18836 = D.18826->objs[j];
          mono_field_set_value (D.18836, mono_bridge_test_field.69, &status);
        }
      finally
        {
          status = {CLOBBER};
        }
    }
    <D.18835>:
    j = j + 1;
    <D.18066>:
    D.18823 = (long unsigned int) i;
    D.18824 = D.18823 * 8;
    D.18825 = sccs + D.18824;
    D.18826 = *D.18825;
    D.18830 = D.18826->num_objs;
    if (D.18830 > j) goto <D.18065>; else goto <D.18067>;
    <D.18067>:
  }
  <D.18063>:
  i = i + 1;
  <D.18069>:
  if (i < num_sccs) goto <D.18068>; else goto <D.18070>;
  <D.18070>:
  modified = 1;
  goto <D.18076>;
  <D.18075>:
  modified = 0;
  i = 0;
  goto <D.18073>;
  <D.18072>:
  {
    struct MonoGCBridgeXRef ref;

    try
      {
        D.18823 = (long unsigned int) i;
        D.18824 = D.18823 * 8;
        D.18837 = xrefs + D.18824;
        ref = *D.18837;
        D.18838 = ref.src_scc_index;
        D.18839 = (long unsigned int) D.18838;
        D.18840 = D.18839 * 8;
        D.18841 = sccs + D.18840;
        D.18842 = *D.18841;
        D.18843 = test_scc (D.18842, 0);
        if (D.18843 != 0) goto <D.18844>; else goto <D.18845>;
        <D.18844>:
        D.18846 = ref.dst_scc_index;
        D.18847 = (long unsigned int) D.18846;
        D.18848 = D.18847 * 8;
        D.18849 = sccs + D.18848;
        D.18850 = *D.18849;
        D.18851 = test_scc (D.18850, 0);
        if (D.18851 == 0) goto <D.18852>; else goto <D.18853>;
        <D.18852>:
        modified = 1;
        D.18846 = ref.dst_scc_index;
        D.18847 = (long unsigned int) D.18846;
        D.18848 = D.18847 * 8;
        D.18849 = sccs + D.18848;
        D.18850 = *D.18849;
        mark_scc (D.18850, 3);
        <D.18853>:
        <D.18845>:
      }
    finally
      {
        ref = {CLOBBER};
      }
  }
  i = i + 1;
  <D.18073>:
  if (i < num_xrefs) goto <D.18072>; else goto <D.18074>;
  <D.18074>:
  <D.18076>:
  if (modified != 0) goto <D.18075>; else goto <D.18077>;
  <D.18077>:
  i = 0;
  goto <D.18079>;
  <D.18078>:
  D.18823 = (long unsigned int) i;
  D.18824 = D.18823 * 8;
  D.18825 = sccs + D.18824;
  D.18826 = *D.18825;
  D.18826->is_alive = 1;
  i = i + 1;
  <D.18079>:
  if (i < num_sccs) goto <D.18078>; else goto <D.18080>;
  <D.18080>:
}


test_scc (struct MonoGCBridgeSCC * scc, int i)
{
  struct MonoClassField * mono_bridge_test_field.71;
  struct MonoObject * D.18855;
  gboolean D.18856;
  int status.72;
  _Bool D.18858;
  int status;

  try
    {
      status = 0;
      mono_bridge_test_field.71 = mono_bridge_test_field;
      D.18855 = scc->objs[i];
      mono_field_get_value (D.18855, mono_bridge_test_field.71, &status);
      status.72 = status;
      D.18858 = status.72 > 0;
      D.18856 = (gboolean) D.18858;
      return D.18856;
    }
  finally
    {
      status = {CLOBBER};
    }
}


mark_scc (struct MonoGCBridgeSCC * scc, int value)
{
  int D.18861;
  struct MonoClassField * mono_bridge_test_field.73;
  struct MonoObject * D.18865;
  int D.18866;
  int i;

  i = 0;
  goto <D.18048>;
  <D.18047>:
  D.18861 = test_scc (scc, i);
  if (D.18861 == 0) goto <D.18862>; else goto <D.18863>;
  <D.18862>:
  {
    int status;

    try
      {
        status = value;
        mono_bridge_test_field.73 = mono_bridge_test_field;
        D.18865 = scc->objs[i];
        mono_field_set_value (D.18865, mono_bridge_test_field.73, &status);
      }
    finally
      {
        status = {CLOBBER};
      }
  }
  <D.18863>:
  i = i + 1;
  <D.18048>:
  D.18866 = scc->num_objs;
  if (D.18866 > i) goto <D.18047>; else goto <D.18049>;
  <D.18049>:
}


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

  D.18867 = 1;
  return D.18867;
}


bridge_test_is_bridge_class (struct MonoClass * class)
{
  gboolean D.18869;
  int D.18009;
  const char * D.18870;
  const char * bridge_class.74;
  _Bool D.18872;

  {
    size_t __s1_len;
    size_t __s2_len;

    D.18870 = class->name;
    bridge_class.74 = bridge_class;
    D.18009 = __builtin_strcmp (bridge_class.74, D.18870);
  }
  D.18872 = D.18009 == 0;
  D.18869 = (gboolean) D.18872;
  return D.18869;
}