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.20289>; else goto <D.20290>;
  <D.20289>:
  return;
  <D.20290>:
  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.20292;

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


sgen_is_bridge_object (struct MonoObject * obj)
{
  struct MonoVTable * D.20295;
  <unnamed-unsigned:4> D.20296;
  int D.20297;
  int D.20298;
  gboolean D.20301;
  mono_bool (*<T389d>) (struct MonoObject *) D.20302;

  D.20295 = obj->vtable;
  D.20296 = D.20295->gc_bits;
  D.20297 = (int) D.20296;
  D.20298 = D.20297 & 1;
  if (D.20298 == 0) goto <D.20299>; else goto <D.20300>;
  <D.20299>:
  D.20301 = 0;
  return D.20301;
  <D.20300>:
  D.20302 = bridge_callbacks.is_bridge_object;
  D.20301 = D.20302 (obj);
  return D.20301;
}


sgen_is_bridge_class (struct MonoClass * class)
{
  gboolean D.20304;
  mono_bool (*<T3899>) (struct MonoClass *) D.20305;

  D.20305 = bridge_callbacks.is_bridge_class;
  D.20304 = D.20305 (class);
  return D.20304;
}


sgen_need_bridge_processing ()
{
  gboolean D.20307;
  void (*<T38a7>) (int, struct MonoGCBridgeSCC * *, int, struct MonoGCBridgeXRef *) D.20308;
  _Bool D.20309;

  D.20308 = bridge_callbacks.cross_references;
  D.20309 = D.20308 != 0B;
  D.20307 = (gboolean) D.20309;
  return D.20307;
}


sgen_bridge_register_finalized_object (struct MonoObject * obj)
{
  int D.20311;
  _Bool D.20312;
  long int D.20313;
  long int D.20314;

  D.20311 = sgen_need_bridge_processing ();
  D.20312 = D.20311 == 0;
  D.20313 = (long int) D.20312;
  D.20314 = __builtin_expect (D.20313, 0);
  if (D.20314 != 0) goto <D.20315>; else goto <D.20316>;
  <D.20315>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-bridge.c", 537, "sgen_need_bridge_processing ()");
  <D.20316>:
  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.20317;
  int D.20318;
  char * D.20319;
  int D.20320;
  int D.20321;
  sizetype D.20322;
  void * D.20323;
  void * p;

  D.20317 = da->size;
  D.20318 = D.20317 + 1;
  dyn_array_ensure_capacity (da, D.20318);
  D.20319 = da->data;
  D.20317 = da->size;
  D.20320 = da->elem_size;
  D.20321 = D.20317 * D.20320;
  D.20322 = (sizetype) D.20321;
  p = D.20319 + D.20322;
  D.20317 = da->size;
  D.20318 = D.20317 + 1;
  da->size = D.20318;
  D.20323 = p;
  return D.20323;
}


dyn_array_ensure_capacity (struct DynArray * da, int capacity)
{
  int D.20327;
  int D.20330;
  int D.20331;
  int D.20332;
  unsigned int D.20333;
  char * D.20334;
  int D.20335;
  int D.20336;
  unsigned int D.20337;
  int D.20338;
  unsigned int D.20339;
  int old_capacity;
  char * new_data;

  old_capacity = da->capacity;
  if (capacity <= old_capacity) goto <D.20325>; else goto <D.20326>;
  <D.20325>:
  return;
  <D.20326>:
  D.20327 = da->capacity;
  if (D.20327 == 0) goto <D.20328>; else goto <D.20329>;
  <D.20328>:
  da->capacity = 2;
  <D.20329>:
  goto <D.19795>;
  <D.19794>:
  D.20327 = da->capacity;
  D.20330 = D.20327 * 2;
  da->capacity = D.20330;
  <D.19795>:
  D.20327 = da->capacity;
  if (D.20327 < capacity) goto <D.19794>; else goto <D.19796>;
  <D.19796>:
  D.20331 = da->elem_size;
  D.20327 = da->capacity;
  D.20332 = D.20331 * D.20327;
  D.20333 = (unsigned int) D.20332;
  new_data = sgen_alloc_internal_dynamic (D.20333, 21, 1);
  D.20334 = da->data;
  D.20331 = da->elem_size;
  D.20335 = da->size;
  D.20336 = D.20331 * D.20335;
  D.20337 = (unsigned int) D.20336;
  memcpy (new_data, D.20334, D.20337);
  D.20334 = da->data;
  D.20331 = da->elem_size;
  D.20338 = D.20331 * old_capacity;
  D.20339 = (unsigned int) D.20338;
  sgen_free_internal_dynamic (D.20334, D.20339, 21);
  da->data = new_data;
}


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

  D.20342 = __builtin_object_size (__dest, 0);
  D.20341 = __builtin___memcpy_chk (__dest, __src, __len, D.20342);
  return D.20341;
}


sgen_bridge_reset_data ()
{
  registered_bridges.size = 0;
}


sgen_bridge_processing_stw_step ()
{
  int D.20344;
  char * D.20347;
  unsigned int i.1;
  unsigned int D.20349;
  void * * D.20350;
  void * D.20351;
  struct HashEntry * D.20352;
  long long int D.20353;
  long long int D.20354;
  long unsigned int step_2.2;
  int i;
  gint64 atv;
  gint64 btv;

  D.20344 = registered_bridges.size;
  if (D.20344 == 0) goto <D.20345>; else goto <D.20346>;
  <D.20345>:
  return;
  <D.20346>:
  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.20090>;
  <D.20089>:
  D.20347 = registered_bridges.data;
  i.1 = (unsigned int) i;
  D.20349 = i.1 * 4;
  D.20350 = D.20347 + D.20349;
  D.20351 = *D.20350;
  register_bridge_object (D.20351);
  i = i + 1;
  <D.20090>:
  D.20344 = registered_bridges.size;
  if (D.20344 > i) goto <D.20089>; else goto <D.20091>;
  <D.20091>:
  i = 0;
  goto <D.20093>;
  <D.20092>:
  D.20347 = registered_bridges.data;
  i.1 = (unsigned int) i;
  D.20349 = i.1 * 4;
  D.20350 = D.20347 + D.20349;
  D.20351 = *D.20350;
  D.20352 = get_hash_entry (D.20351, 0B);
  dfs1 (D.20352, 0B);
  i = i + 1;
  <D.20093>:
  D.20344 = registered_bridges.size;
  if (D.20344 > i) goto <D.20092>; else goto <D.20094>;
  <D.20094>:
  atv = mono_100ns_ticks ();
  D.20353 = atv - btv;
  D.20354 = D.20353 / 10;
  step_2.2 = (long unsigned int) D.20354;
  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.20357;
  struct HashEntry * entry;

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


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

  try
    {
      entry = sgen_hash_table_lookup (&hash_table, obj);
      if (entry != 0B) goto <D.20359>; else goto <D.20360>;
      <D.20359>:
      if (existing != 0B) goto <D.20361>; else goto <D.20362>;
      <D.20361>:
      *existing = 1;
      <D.20362>:
      D.20363 = entry;
      return D.20363;
      <D.20360>:
      if (existing != 0B) goto <D.20364>; else goto <D.20365>;
      <D.20364>:
      *existing = 0;
      <D.20365>:
      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.20363 = sgen_hash_table_lookup (&hash_table, obj);
      return D.20363;
    }
  finally
    {
      new_entry = {CLOBBER};
    }
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.20370;
  int D.20375;
  void * D.20377;
  unsigned int D.20378;

  D.20370 = __builtin_constant_p (__len);
  if (D.20370 != 0) goto <D.20371>; else goto <D.20372>;
  <D.20371>:
  if (__len == 0) goto <D.20373>; else goto <D.20374>;
  <D.20373>:
  D.20375 = __builtin_constant_p (__ch);
  if (D.20375 == 0) goto <D.20368>; else goto <D.20376>;
  <D.20376>:
  if (__ch != 0) goto <D.20368>; else goto <D.20369>;
  <D.20368>:
  __warn_memset_zero_len ();
  D.20377 = __dest;
  return D.20377;
  <D.20369>:
  <D.20374>:
  <D.20372>:
  D.20378 = __builtin_object_size (__dest, 0);
  D.20377 = __builtin___memset_chk (__dest, __ch, __len, D.20378);
  return D.20377;
}


dfs1 (struct HashEntry * obj_entry, struct HashEntry * src)
{
  int D.20380;
  _Bool D.20381;
  long int D.20382;
  long int D.20383;
  int dsf1_passes.3;
  int dsf1_passes.4;
  int D.20393;
  unsigned int D.20396;
  unsigned int D.20397;
  unsigned int D.20398;
  unsigned int D.20399;
  unsigned int D.20402;
  unsigned int D.20403;
  unsigned int D.20404;
  unsigned int D.20405;
  unsigned int D.20406;
  void * dst.5;
  struct MonoObject * dst.6;
  int D.20411;
  struct HashEntry * D.20414;
  struct MonoObject * dst.7;
  int D.20418;
  struct HashEntry * D.20421;
  unsigned int _index.8;
  unsigned int D.20423;
  int D.20424;
  void * dst.9;
  struct MonoObject * dst.10;
  int D.20429;
  struct HashEntry * D.20432;
  unsigned int _index.11;
  unsigned int D.20434;
  int D.20435;
  struct MonoObject * dst.12;
  int D.20439;
  struct HashEntry * D.20442;
  unsigned int D.20443;
  unsigned int D.20446;
  int D.20447;
  int desc.13;
  unsigned int D.20451;
  unsigned int el_size.14;
  unsigned int D.20453;
  void * dst.15;
  struct MonoObject * dst.16;
  int D.20458;
  struct HashEntry * D.20461;
  int D.20465;
  unsigned int offset.17;
  unsigned int D.20467;
  unsigned int i.18;
  unsigned int D.20469;
  void * * D.20470;
  void * dst.19;
  struct MonoObject * dst.20;
  int D.20475;
  struct HashEntry * D.20478;
  sizetype el_size.21;
  unsigned int D.20483;
  void * dst.22;
  struct MonoObject * dst.23;
  int D.20490;
  struct HashEntry * D.20493;
  unsigned int D.20494;
  void * dst.24;
  struct MonoObject * dst.25;
  int D.20501;
  struct HashEntry * D.20504;
  unsigned int D.20505;
  unsigned int D.20506;
  struct MonoVTable * D.20509;
  struct MonoClass * D.20510;
  const char * D.20511;
  const char * D.20512;
  gsize * bitmap_data.26;
  unsigned int D.20514;
  void * dst.27;
  struct MonoObject * dst.28;
  int D.20521;
  struct HashEntry * D.20524;
  int bwords.29;
  unsigned int D.20526;
  gsize * mbitmap_data.30;
  unsigned int D.20528;
  unsigned int D.20529;
  struct MonoClass * D.20530;
  unsigned int el_size.31;
  unsigned int D.20532;
  const char * D.20535;
  const char * D.20536;
  gsize * bitmap_data.32;
  unsigned int D.20538;
  void * dst.33;
  struct MonoObject * dst.34;
  int D.20545;
  struct HashEntry * D.20548;
  unsigned int bwords.35;
  sizetype el_size.36;
  int current_time.37;
  int current_time.38;
  int current_time.39;

  D.20380 = dfs_stack.size;
  D.20381 = D.20380 != 0;
  D.20382 = (long int) D.20381;
  D.20383 = __builtin_expect (D.20382, 0);
  if (D.20383 != 0) goto <D.20384>; else goto <D.20385>;
  <D.20384>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-bridge.c", 423, "dfs_stack.size == 0");
  <D.20385>:
  dyn_array_ptr_add (&dfs_stack, src);
  dyn_array_ptr_add (&dfs_stack, obj_entry);
  <D.20033>:
  {
    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.20388>; else goto <D.20389>;
    <D.20388>:
    src = dyn_array_ptr_pop (&dfs_stack);
    obj = obj_entry->obj;
    start = obj;
    if (src != 0B) goto <D.20390>; else goto <D.20391>;
    <D.20390>:
    add_source (obj_entry, src);
    goto <D.20392>;
    <D.20391>:
    <D.20392>:
    D.20393 = obj_entry->is_visited;
    if (D.20393 != 0) goto <D.20394>; else goto <D.20395>;
    <D.20394>:
    // predicted unlikely by continue predictor.
    goto <D.19934>;
    <D.20395>:
    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.20396 = MEM[(mword *)start];
      D.20397 = D.20396 & 4294967292;
      vt = (struct GCVTable *) D.20397;
      desc = vt->desc;
      D.20398 = desc & 7;
      switch (D.20398) <default: <D.20032>, case 1: <D.19937>, case 2: <D.19946>, case 3: <D.19996>, case 4: <D.19956>, case 5: <D.19989>, case 6: <D.20010>, case 7: <D.20031>>
      <D.19937>:
      D.20399 = desc & 4294901760;
      if (D.20399 != 0) goto <D.20400>; else goto <D.20401>;
      <D.20400>:
      {
        void * * _objptr_end;
        void * * _objptr;

        _objptr = start;
        D.20402 = desc >> 16;
        D.20403 = D.20402 & 255;
        D.20404 = D.20403 * 4;
        _objptr = _objptr + D.20404;
        D.20405 = desc >> 24;
        D.20406 = D.20405 * 4;
        _objptr_end = _objptr + D.20406;
        {
          struct MonoObject * dst;

          try
            {
              dst.5 = *_objptr;
              dst = dst.5;
              dst.6 = dst;
              if (dst.6 != 0B) goto <D.20409>; else goto <D.20410>;
              <D.20409>:
              D.20411 = object_is_live (&dst);
              if (D.20411 == 0) goto <D.20412>; else goto <D.20413>;
              <D.20412>:
              dyn_array_ptr_add (&dfs_stack, obj_entry);
              dst.6 = dst;
              D.20414 = get_hash_entry (dst.6, 0B);
              dyn_array_ptr_add (&dfs_stack, D.20414);
              <D.20413>:
              <D.20410>:
            }
          finally
            {
              dst = {CLOBBER};
            }
        }
        _objptr = _objptr + 4;
        goto <D.19943>;
        <D.19942>:
        {
          struct MonoObject * dst;

          try
            {
              dst.5 = *_objptr;
              dst = dst.5;
              dst.7 = dst;
              if (dst.7 != 0B) goto <D.20416>; else goto <D.20417>;
              <D.20416>:
              D.20418 = object_is_live (&dst);
              if (D.20418 == 0) goto <D.20419>; else goto <D.20420>;
              <D.20419>:
              dyn_array_ptr_add (&dfs_stack, obj_entry);
              dst.7 = dst;
              D.20421 = get_hash_entry (dst.7, 0B);
              dyn_array_ptr_add (&dfs_stack, D.20421);
              <D.20420>:
              <D.20417>:
            }
          finally
            {
              dst = {CLOBBER};
            }
        }
        _objptr = _objptr + 4;
        <D.19943>:
        if (_objptr < _objptr_end) goto <D.19942>; else goto <D.19944>;
        <D.19944>:
      }
      <D.20401>:
      goto <D.19945>;
      <D.19946>:
      {
        void * * _objptr;
        gsize _bmap;

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

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

            try
              {
                dst.9 = *_objptr;
                dst = dst.9;
                dst.10 = dst;
                if (dst.10 != 0B) goto <D.20427>; else goto <D.20428>;
                <D.20427>:
                D.20429 = object_is_live (&dst);
                if (D.20429 == 0) goto <D.20430>; else goto <D.20431>;
                <D.20430>:
                dyn_array_ptr_add (&dfs_stack, obj_entry);
                dst.10 = dst;
                D.20432 = get_hash_entry (dst.10, 0B);
                dyn_array_ptr_add (&dfs_stack, D.20432);
                <D.20431>:
                <D.20428>:
              }
            finally
              {
                dst = {CLOBBER};
              }
          }
          _objptr = _objptr + 4;
        }
        goto <D.19954>;
        <D.19953>:
        {
          int _index;

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

            try
              {
                dst.9 = *_objptr;
                dst = dst.9;
                dst.12 = dst;
                if (dst.12 != 0B) goto <D.20437>; else goto <D.20438>;
                <D.20437>:
                D.20439 = object_is_live (&dst);
                if (D.20439 == 0) goto <D.20440>; else goto <D.20441>;
                <D.20440>:
                dyn_array_ptr_add (&dfs_stack, obj_entry);
                dst.12 = dst;
                D.20442 = get_hash_entry (dst.12, 0B);
                dyn_array_ptr_add (&dfs_stack, D.20442);
                <D.20441>:
                <D.20438>:
              }
            finally
              {
                dst = {CLOBBER};
              }
          }
          _objptr = _objptr + 4;
        }
        <D.19954>:
        if (_bmap != 0) goto <D.19953>; else goto <D.19955>;
        <D.19955>:
      }
      goto <D.19945>;
      <D.19956>:
      D.20443 = desc & 4294950912;
      if (D.20443 != 0) goto <D.20444>; else goto <D.20445>;
      <D.20444>:
      {
        int el_size;
        int etype;

        D.20446 = desc >> 3;
        D.20447 = (int) D.20446;
        el_size = D.20447 & 1023;
        desc.13 = (int) desc;
        etype = desc.13 & 49152;
        if (etype == 16384) goto <D.20449>; else goto <D.20450>;
        <D.20449>:
        {
          void * * p;
          void * * end_refs;

          p = start + 16;
          D.20451 = MEM[(struct MonoArray *)start].max_length;
          el_size.14 = (unsigned int) el_size;
          D.20453 = D.20451 * el_size.14;
          end_refs = p + D.20453;
          goto <D.19963>;
          <D.19962>:
          {
            struct MonoObject * dst;

            try
              {
                dst.15 = *p;
                dst = dst.15;
                dst.16 = dst;
                if (dst.16 != 0B) goto <D.20456>; else goto <D.20457>;
                <D.20456>:
                D.20458 = object_is_live (&dst);
                if (D.20458 == 0) goto <D.20459>; else goto <D.20460>;
                <D.20459>:
                dyn_array_ptr_add (&dfs_stack, obj_entry);
                dst.16 = dst;
                D.20461 = get_hash_entry (dst.16, 0B);
                dyn_array_ptr_add (&dfs_stack, D.20461);
                <D.20460>:
                <D.20457>:
              }
            finally
              {
                dst = {CLOBBER};
              }
          }
          p = p + 4;
          <D.19963>:
          if (p < end_refs) goto <D.19962>; else goto <D.19964>;
          <D.19964>:
        }
        goto <D.20462>;
        <D.20450>:
        if (etype == 32768) goto <D.20463>; else goto <D.20464>;
        <D.20463>:
        {
          int offset;
          int num_refs;
          char * e_start;
          char * e_end;

          D.20402 = desc >> 16;
          D.20465 = (int) D.20402;
          offset = D.20465 & 255;
          D.20405 = desc >> 24;
          num_refs = (int) D.20405;
          e_start = start + 16;
          D.20451 = MEM[(struct MonoArray *)start].max_length;
          el_size.14 = (unsigned int) el_size;
          D.20453 = D.20451 * el_size.14;
          e_end = e_start + D.20453;
          goto <D.19976>;
          <D.19975>:
          {
            void * * p;
            int i;

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

              try
                {
                  i.18 = (unsigned int) i;
                  D.20469 = i.18 * 4;
                  D.20470 = p + D.20469;
                  dst.19 = *D.20470;
                  dst = dst.19;
                  dst.20 = dst;
                  if (dst.20 != 0B) goto <D.20473>; else goto <D.20474>;
                  <D.20473>:
                  D.20475 = object_is_live (&dst);
                  if (D.20475 == 0) goto <D.20476>; else goto <D.20477>;
                  <D.20476>:
                  dyn_array_ptr_add (&dfs_stack, obj_entry);
                  dst.20 = dst;
                  D.20478 = get_hash_entry (dst.20, 0B);
                  dyn_array_ptr_add (&dfs_stack, D.20478);
                  <D.20477>:
                  <D.20474>:
                }
              finally
                {
                  dst = {CLOBBER};
                }
            }
            i = i + 1;
            <D.19973>:
            if (i < num_refs) goto <D.19972>; else goto <D.19974>;
            <D.19974>:
            el_size.21 = (sizetype) el_size;
            e_start = e_start + el_size.21;
          }
          <D.19976>:
          if (e_start < e_end) goto <D.19975>; else goto <D.19977>;
          <D.19977>:
        }
        goto <D.20480>;
        <D.20464>:
        if (etype == 49152) goto <D.20481>; else goto <D.20482>;
        <D.20481>:
        {
          char * e_start;
          char * e_end;

          e_start = start + 16;
          D.20451 = MEM[(struct MonoArray *)start].max_length;
          el_size.14 = (unsigned int) el_size;
          D.20453 = D.20451 * el_size.14;
          e_end = e_start + D.20453;
          goto <D.19987>;
          <D.19986>:
          {
            void * * p;
            gsize _bmap;

            p = e_start;
            _bmap = desc >> 16;
            goto <D.19984>;
            <D.19983>:
            D.20483 = _bmap & 1;
            if (D.20483 != 0) goto <D.20484>; else goto <D.20485>;
            <D.20484>:
            {
              struct MonoObject * dst;

              try
                {
                  dst.22 = *p;
                  dst = dst.22;
                  dst.23 = dst;
                  if (dst.23 != 0B) goto <D.20488>; else goto <D.20489>;
                  <D.20488>:
                  D.20490 = object_is_live (&dst);
                  if (D.20490 == 0) goto <D.20491>; else goto <D.20492>;
                  <D.20491>:
                  dyn_array_ptr_add (&dfs_stack, obj_entry);
                  dst.23 = dst;
                  D.20493 = get_hash_entry (dst.23, 0B);
                  dyn_array_ptr_add (&dfs_stack, D.20493);
                  <D.20492>:
                  <D.20489>:
                }
              finally
                {
                  dst = {CLOBBER};
                }
            }
            <D.20485>:
            _bmap = _bmap >> 1;
            p = p + 4;
            <D.19984>:
            if (_bmap != 0) goto <D.19983>; else goto <D.19985>;
            <D.19985>:
            el_size.21 = (sizetype) el_size;
            e_start = e_start + el_size.21;
          }
          <D.19987>:
          if (e_start < e_end) goto <D.19986>; else goto <D.19988>;
          <D.19988>:
        }
        <D.20482>:
        <D.20480>:
        <D.20462>:
      }
      <D.20445>:
      goto <D.19945>;
      <D.19989>:
      {
        void * * _objptr;
        gsize _bmap;

        _objptr = start;
        _bmap = desc >> 3;
        _objptr = _objptr + 8;
        goto <D.19994>;
        <D.19993>:
        D.20494 = _bmap & 1;
        if (D.20494 != 0) goto <D.20495>; else goto <D.20496>;
        <D.20495>:
        {
          struct MonoObject * dst;

          try
            {
              dst.24 = *_objptr;
              dst = dst.24;
              dst.25 = dst;
              if (dst.25 != 0B) goto <D.20499>; else goto <D.20500>;
              <D.20499>:
              D.20501 = object_is_live (&dst);
              if (D.20501 == 0) goto <D.20502>; else goto <D.20503>;
              <D.20502>:
              dyn_array_ptr_add (&dfs_stack, obj_entry);
              dst.25 = dst;
              D.20504 = get_hash_entry (dst.25, 0B);
              dyn_array_ptr_add (&dfs_stack, D.20504);
              <D.20503>:
              <D.20500>:
            }
          finally
            {
              dst = {CLOBBER};
            }
        }
        <D.20496>:
        _bmap = _bmap >> 1;
        _objptr = _objptr + 4;
        <D.19994>:
        if (_bmap != 0) goto <D.19993>; else goto <D.19995>;
        <D.19995>:
      }
      goto <D.19945>;
      <D.19996>:
      {
        void * * _objptr;
        gsize * bitmap_data;
        int bwords;
        void * * start_run;

        _objptr = start;
        bitmap_data = sgen_get_complex_descriptor (desc);
        D.20505 = *bitmap_data;
        D.20506 = D.20505 + 4294967295;
        bwords = (int) D.20506;
        start_run = _objptr;
        bitmap_data = bitmap_data + 4;
        if (0 != 0) goto <D.20507>; else goto <D.20508>;
        <D.20507>:
        {
          struct MonoObject * myobj;

          myobj = start;
          D.20509 = myobj->vtable;
          D.20510 = D.20509->klass;
          D.20511 = D.20510->name_space;
          D.20509 = myobj->vtable;
          D.20510 = D.20509->klass;
          D.20512 = D.20510->name;
          monoeg_g_print ("found %d at %p (0x%zx): %s.%s\n", bwords, start, desc, D.20511, D.20512);
        }
        <D.20508>:
        goto <D.20008>;
        <D.20007>:
        {
          gsize _bmap;

          bitmap_data.26 = bitmap_data;
          bitmap_data = bitmap_data.26 + 4;
          _bmap = *bitmap_data.26;
          _objptr = start_run;
          goto <D.20005>;
          <D.20004>:
          D.20514 = _bmap & 1;
          if (D.20514 != 0) goto <D.20515>; else goto <D.20516>;
          <D.20515>:
          {
            struct MonoObject * dst;

            try
              {
                dst.27 = *_objptr;
                dst = dst.27;
                dst.28 = dst;
                if (dst.28 != 0B) goto <D.20519>; else goto <D.20520>;
                <D.20519>:
                D.20521 = object_is_live (&dst);
                if (D.20521 == 0) goto <D.20522>; else goto <D.20523>;
                <D.20522>:
                dyn_array_ptr_add (&dfs_stack, obj_entry);
                dst.28 = dst;
                D.20524 = get_hash_entry (dst.28, 0B);
                dyn_array_ptr_add (&dfs_stack, D.20524);
                <D.20523>:
                <D.20520>:
              }
            finally
              {
                dst = {CLOBBER};
              }
          }
          <D.20516>:
          _bmap = _bmap >> 1;
          _objptr = _objptr + 4;
          <D.20005>:
          if (_bmap != 0) goto <D.20004>; else goto <D.20006>;
          <D.20006>:
          start_run = start_run + 128;
        }
        <D.20008>:
        bwords.29 = bwords;
        bwords = bwords.29 + -1;
        if (bwords.29 > 0) goto <D.20007>; else goto <D.20009>;
        <D.20009>:
      }
      goto <D.19945>;
      <D.20010>:
      {
        gsize * mbitmap_data;
        int mbwords;
        int el_size;
        char * e_start;
        char * e_end;

        D.20526 = vt->desc;
        mbitmap_data = sgen_get_complex_descriptor (D.20526);
        mbitmap_data.30 = mbitmap_data;
        mbitmap_data = mbitmap_data.30 + 4;
        D.20528 = *mbitmap_data.30;
        D.20529 = D.20528 + 4294967295;
        mbwords = (int) D.20529;
        D.20530 = vt->klass;
        el_size = mono_array_element_size (D.20530);
        e_start = start + 16;
        D.20451 = MEM[(struct MonoArray *)start].max_length;
        el_size.31 = (unsigned int) el_size;
        D.20532 = D.20451 * el_size.31;
        e_end = e_start + D.20532;
        if (0 != 0) goto <D.20533>; else goto <D.20534>;
        <D.20533>:
        D.20526 = vt->desc;
        D.20530 = vt->klass;
        D.20535 = D.20530->name_space;
        D.20530 = vt->klass;
        D.20536 = D.20530->name;
        monoeg_g_print ("found %d at %p (0x%zx): %s.%s\n", mbwords, start, D.20526, D.20535, D.20536);
        <D.20534>:
        goto <D.20029>;
        <D.20028>:
        {
          void * * _objptr;
          gsize * bitmap_data;
          unsigned int bwords;

          _objptr = e_start;
          bitmap_data = mbitmap_data;
          bwords = (unsigned int) mbwords;
          goto <D.20026>;
          <D.20025>:
          {
            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.20023>;
            <D.20022>:
            D.20538 = _bmap & 1;
            if (D.20538 != 0) goto <D.20539>; else goto <D.20540>;
            <D.20539>:
            {
              struct MonoObject * dst;

              try
                {
                  dst.33 = *_objptr;
                  dst = dst.33;
                  dst.34 = dst;
                  if (dst.34 != 0B) goto <D.20543>; else goto <D.20544>;
                  <D.20543>:
                  D.20545 = object_is_live (&dst);
                  if (D.20545 == 0) goto <D.20546>; else goto <D.20547>;
                  <D.20546>:
                  dyn_array_ptr_add (&dfs_stack, obj_entry);
                  dst.34 = dst;
                  D.20548 = get_hash_entry (dst.34, 0B);
                  dyn_array_ptr_add (&dfs_stack, D.20548);
                  <D.20547>:
                  <D.20544>:
                }
              finally
                {
                  dst = {CLOBBER};
                }
            }
            <D.20540>:
            _bmap = _bmap >> 1;
            _objptr = _objptr + 4;
            <D.20023>:
            if (_bmap != 0) goto <D.20022>; else goto <D.20024>;
            <D.20024>:
            _objptr = start_run + 128;
          }
          <D.20026>:
          bwords.35 = bwords;
          bwords = bwords.35 + 4294967295;
          if (bwords.35 != 0) goto <D.20025>; else goto <D.20027>;
          <D.20027>:
          el_size.36 = (sizetype) el_size;
          e_start = e_start + el_size.36;
        }
        <D.20029>:
        if (e_start < e_end) goto <D.20028>; else goto <D.20030>;
        <D.20030>:
      }
      goto <D.19945>;
      <D.20031>:
      goto <D.19945>;
      <D.20032>:
      monoeg_assertion_message ("* Assertion: should not be reached at %s:%d\n", "sgen-scan-object.h", 111);
      <D.19945>:
    }
    goto <D.20551>;
    <D.20389>:
    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.20551>:
  }
  <D.19934>:
  D.20380 = dfs_stack.size;
  if (D.20380 > 0) goto <D.20033>; else goto <D.20034>;
  <D.20034>:
}


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

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


object_is_live (struct MonoObject * * objp)
{
  struct MonoObject * iftmp.40;
  unsigned int D.20559;
  unsigned int D.20560;
  unsigned int D.20563;
  gboolean D.20567;
  void * D.20568;
  _Bool D.20569;
  int D.20570;
  void * D.20573;
  _Bool D.20574;
  struct MonoObject * obj;
  struct MonoObject * fwd;

  obj = *objp;
  D.20559 = MEM[(mword *)obj];
  D.20560 = D.20559 & 1;
  if (D.20560 != 0) goto <D.20561>; else goto <D.20562>;
  <D.20561>:
  D.20559 = MEM[(mword *)obj];
  D.20563 = D.20559 & 4294967292;
  iftmp.40 = (struct MonoObject *) D.20563;
  goto <D.20564>;
  <D.20562>:
  iftmp.40 = 0B;
  <D.20564>:
  fwd = iftmp.40;
  if (fwd != 0B) goto <D.20565>; else goto <D.20566>;
  <D.20565>:
  *objp = fwd;
  D.20568 = sgen_hash_table_lookup (&hash_table, fwd);
  D.20569 = D.20568 == 0B;
  D.20567 = (gboolean) D.20569;
  return D.20567;
  <D.20566>:
  D.20570 = sgen_object_is_live (obj);
  if (D.20570 == 0) goto <D.20571>; else goto <D.20572>;
  <D.20571>:
  D.20567 = 0;
  return D.20567;
  <D.20572>:
  D.20573 = sgen_hash_table_lookup (&hash_table, obj);
  D.20574 = D.20573 == 0B;
  D.20567 = (gboolean) D.20574;
  return D.20567;
}


dyn_array_ptr_pop (struct DynArray * da)
{
  int D.20576;
  _Bool D.20577;
  long int D.20578;
  long int D.20579;
  char * D.20582;
  sizetype D.20583;
  sizetype D.20584;
  sizetype D.20585;
  void * * D.20586;
  int D.20587;
  void * D.20588;
  void * p;

  D.20576 = da->size;
  D.20577 = D.20576 <= 0;
  D.20578 = (long int) D.20577;
  D.20579 = __builtin_expect (D.20578, 0);
  if (D.20579 != 0) goto <D.20580>; else goto <D.20581>;
  <D.20580>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-bridge.c", 142, "da->size > 0");
  <D.20581>:
  D.20582 = da->data;
  D.20576 = da->size;
  D.20583 = (sizetype) D.20576;
  D.20584 = D.20583 + 1073741823;
  D.20585 = D.20584 * 4;
  D.20586 = D.20582 + D.20585;
  p = *D.20586;
  D.20576 = da->size;
  D.20587 = D.20576 + -1;
  da->size = D.20587;
  D.20588 = p;
  return D.20588;
}


register_finishing_time (struct HashEntry * entry, int t)
{
  int D.20590;
  _Bool D.20591;
  long int D.20592;
  long int D.20593;

  D.20590 = entry->finishing_time;
  D.20591 = D.20590 >= 0;
  D.20592 = (long int) D.20591;
  D.20593 = __builtin_expect (D.20592, 0);
  if (D.20593 != 0) goto <D.20594>; else goto <D.20595>;
  <D.20594>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-bridge.c", 387, "entry->finishing_time < 0");
  <D.20595>:
  entry->finishing_time = t;
}


sgen_bridge_processing_finish (int generation)
{
  int D.20597;
  int bridge_processing_in_progress.41;
  _Bool D.20601;
  long int D.20602;
  long int D.20603;
  unsigned int D.20606;
  unsigned int D.20607;
  unsigned int D.20608;
  int D.20609;
  _Bool D.20610;
  long int D.20611;
  long int D.20612;
  int j.42;
  unsigned int j.43;
  unsigned int D.20617;
  struct HashEntry * * D.20618;
  int D.20619;
  int fist_pass_links.44;
  int fist_pass_links.45;
  struct SgenHashTableEntry * D.20622;
  unsigned int D.20623;
  unsigned int j.46;
  _Bool D.20625;
  long int D.20626;
  long int D.20627;
  long long int D.20630;
  long long int D.20631;
  long unsigned int step_3.47;
  unsigned int i.48;
  unsigned int D.20634;
  struct HashEntry * * D.20635;
  int D.20636;
  void * current_scc.49;
  struct SCC * current_scc.50;
  struct DynArray * D.20641;
  unsigned int i.51;
  int D.20643;
  int second_pass_links.52;
  int second_pass_links.53;
  long long int D.20646;
  long long int D.20647;
  long unsigned int step_4.54;
  char * D.20649;
  int D.20650;
  int D.20651;
  sizetype D.20652;
  int D.20653;
  _Bool D.20654;
  long int D.20655;
  long int D.20656;
  int D.20659;
  int D.20662;
  int sccs_links.55;
  int sccs_links.56;
  int max_sccs_links.57;
  int max_sccs_links.58;
  int D.20667;
  unsigned int num_sccs.59;
  unsigned int D.20669;
  int D.20670;
  unsigned int j.60;
  unsigned int D.20674;
  struct MonoGCBridgeSCC * * D.20675;
  unsigned int D.20676;
  unsigned int D.20677;
  unsigned int D.20678;
  void * D.20679;
  struct MonoGCBridgeSCC * D.20680;
  int j.61;
  int D.20682;
  unsigned int D.20683;
  int D.20684;
  int D.20687;
  int D.20688;
  sizetype D.20689;
  int D.20690;
  unsigned int D.20691;
  unsigned int D.20692;
  struct MonoGCBridgeSCC * * D.20693;
  struct MonoGCBridgeSCC * D.20694;
  int D.20695;
  int D.20696;
  int D.20697;
  struct MonoObject * D.20698;
  struct SgenHashTableEntry * D.20699;
  unsigned int num_xrefs.62;
  unsigned int D.20701;
  int D.20702;
  char * D.20705;
  unsigned int k.63;
  unsigned int D.20707;
  int * D.20708;
  int D.20709;
  int D.20710;
  sizetype D.20711;
  int D.20712;
  unsigned int D.20715;
  struct MonoGCBridgeXRef * D.20716;
  int D.20717;
  int D.20718;
  int D.20719;
  int D.20720;
  int D.20725;
  struct DynArray * D.20728;
  void (*<T38a7>) (int, struct MonoGCBridgeSCC * *, int, struct MonoGCBridgeXRef *) D.20729;
  struct MonoGCBridgeSCC * * D.20730;
  struct MonoGCBridgeSCC * D.20731;
  int D.20732;
  _Bool D.20733;
  unsigned char alive.64;
  struct MonoObject * D.20735;
  int D.20738;
  unsigned int D.20741;
  unsigned int D.20742;
  unsigned int D.20743;
  long unsigned int step_1.65;
  float D.20745;
  float D.20746;
  double D.20747;
  long unsigned int step_2.66;
  float D.20749;
  float D.20750;
  double D.20751;
  long unsigned int step_3.67;
  float D.20753;
  float D.20754;
  double D.20755;
  long unsigned int step_4.68;
  float D.20757;
  float D.20758;
  double D.20759;
  long unsigned int step_5.69;
  float D.20761;
  float D.20762;
  double D.20763;
  long unsigned int step_6.70;
  float D.20765;
  float D.20766;
  double D.20767;
  long unsigned int step_7.71;
  float D.20769;
  float D.20770;
  double D.20771;
  long unsigned int step_8.72;
  float D.20773;
  float D.20774;
  double D.20775;
  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 = *.LC0;
      D.20597 = registered_bridges.size;
      if (D.20597 == 0) goto <D.20598>; else goto <D.20599>;
      <D.20598>:
      return;
      <D.20599>:
      bridge_processing_in_progress.41 = bridge_processing_in_progress;
      D.20601 = bridge_processing_in_progress.41 == 0;
      D.20602 = (long int) D.20601;
      D.20603 = __builtin_expect (D.20602, 0);
      if (D.20603 != 0) goto <D.20604>; else goto <D.20605>;
      <D.20604>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-bridge.c", 620, "bridge_processing_in_progress");
      <D.20605>:
      atv = mono_100ns_ticks ();
      D.20606 = hash_table.num_entries;
      D.20607 = D.20606 * 4;
      all_entries = sgen_alloc_internal_dynamic (D.20607, 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.20131>;
        <D.20130>:
        {
          struct SgenHashTableEntry * * __iter;
          struct SgenHashTableEntry * * __next;

          D.20608 = __i * 4;
          __iter = __table + D.20608;
          goto <D.20128>;
          <D.20127>:
          {
            struct SgenHashTableEntry * __entry;

            __entry = *__iter;
            __next = &__entry->next;
            obj = __entry->key;
            entry = &__entry->data;
            D.20609 = entry->finishing_time;
            D.20610 = D.20609 < 0;
            D.20611 = (long int) D.20610;
            D.20612 = __builtin_expect (D.20611, 0);
            if (D.20612 != 0) goto <D.20613>; else goto <D.20614>;
            <D.20613>:
            monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-bridge.c", 630, "entry->finishing_time >= 0");
            <D.20614>:
            j.42 = j;
            j = j.42 + 1;
            j.43 = (unsigned int) j.42;
            D.20617 = j.43 * 4;
            D.20618 = all_entries + D.20617;
            *D.20618 = entry;
            D.20619 = entry->srcs.size;
            fist_pass_links.44 = fist_pass_links;
            fist_pass_links.45 = D.20619 + fist_pass_links.44;
            fist_pass_links = fist_pass_links.45;
          }
          __iter = __next;
          <D.20128>:
          D.20622 = *__iter;
          if (D.20622 != 0B) goto <D.20127>; else goto <D.20129>;
          <D.20129>:
        }
        __i = __i + 1;
        <D.20131>:
        D.20623 = hash_table.size;
        if (D.20623 > __i) goto <D.20130>; else goto <D.20132>;
        <D.20132>:
      }
      j.46 = (unsigned int) j;
      D.20606 = hash_table.num_entries;
      D.20625 = j.46 != D.20606;
      D.20626 = (long int) D.20625;
      D.20627 = __builtin_expect (D.20626, 0);
      if (D.20627 != 0) goto <D.20628>; else goto <D.20629>;
      <D.20628>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-bridge.c", 634, "j == hash_table.num_entries");
      <D.20629>:
      D.20606 = hash_table.num_entries;
      hash_table_size = (int) D.20606;
      D.20606 = hash_table.num_entries;
      sgen_qsort (all_entries, D.20606, 4, compare_hash_entries);
      btv = mono_100ns_ticks ();
      D.20630 = btv - atv;
      D.20631 = D.20630 / 10;
      step_3.47 = (long unsigned int) D.20631;
      step_3 = step_3.47;
      dyn_array_init (&sccs, 28);
      i = 0;
      goto <D.20136>;
      <D.20135>:
      {
        struct HashEntry * entry;

        i.48 = (unsigned int) i;
        D.20634 = i.48 * 4;
        D.20635 = all_entries + D.20634;
        entry = *D.20635;
        D.20636 = entry->scc_index;
        if (D.20636 < 0) goto <D.20637>; else goto <D.20638>;
        <D.20637>:
        {
          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.20641 = &current_scc.50->xrefs;
          dyn_array_int_init (D.20641);
          dfs2 (entry);
        }
        <D.20638>:
      }
      i = i + 1;
      <D.20136>:
      i.51 = (unsigned int) i;
      D.20606 = hash_table.num_entries;
      if (i.51 < D.20606) goto <D.20135>; else goto <D.20137>;
      <D.20137>:
      sccs_size = sccs.size;
      i = 0;
      goto <D.20140>;
      <D.20139>:
      {
        struct HashEntry * entry;

        i.48 = (unsigned int) i;
        D.20634 = i.48 * 4;
        D.20635 = all_entries + D.20634;
        entry = *D.20635;
        D.20643 = entry->srcs.size;
        second_pass_links.52 = second_pass_links;
        second_pass_links.53 = D.20643 + second_pass_links.52;
        second_pass_links = second_pass_links.53;
      }
      i = i + 1;
      <D.20140>:
      i.51 = (unsigned int) i;
      D.20606 = hash_table.num_entries;
      if (i.51 < D.20606) goto <D.20139>; else goto <D.20141>;
      <D.20141>:
      atv = mono_100ns_ticks ();
      D.20646 = atv - btv;
      D.20647 = D.20646 / 10;
      step_4.54 = (long unsigned int) D.20647;
      step_4 = step_4.54;
      dyn_array_uninit (&dfs_stack);
      num_sccs = 0;
      i = 0;
      goto <D.20144>;
      <D.20143>:
      {
        struct SCC * scc;

        D.20649 = sccs.data;
        D.20650 = sccs.elem_size;
        D.20651 = D.20650 * i;
        D.20652 = (sizetype) D.20651;
        scc = D.20649 + D.20652;
        D.20653 = scc->index;
        D.20654 = D.20653 != i;
        D.20655 = (long int) D.20654;
        D.20656 = __builtin_expect (D.20655, 0);
        if (D.20656 != 0) goto <D.20657>; else goto <D.20658>;
        <D.20657>:
        monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-bridge.c", 680, "scc->index == i");
        <D.20658>:
        D.20659 = scc->num_bridge_entries;
        if (D.20659 != 0) goto <D.20660>; else goto <D.20661>;
        <D.20660>:
        num_sccs = num_sccs + 1;
        <D.20661>:
        D.20662 = scc->xrefs.size;
        sccs_links.55 = sccs_links;
        sccs_links.56 = D.20662 + sccs_links.55;
        sccs_links = sccs_links.56;
        D.20662 = scc->xrefs.size;
        max_sccs_links.57 = max_sccs_links;
        max_sccs_links.58 = MAX_EXPR <D.20662, max_sccs_links.57>;
        max_sccs_links = max_sccs_links.58;
      }
      i = i + 1;
      <D.20144>:
      D.20667 = sccs.size;
      if (D.20667 > i) goto <D.20143>; else goto <D.20145>;
      <D.20145>:
      num_sccs.59 = (unsigned int) num_sccs;
      D.20669 = num_sccs.59 * 4;
      api_sccs = sgen_alloc_internal_dynamic (D.20669, 21, 1);
      num_xrefs = 0;
      j = 0;
      i = 0;
      goto <D.20149>;
      <D.20148>:
      {
        struct SCC * scc;

        D.20649 = sccs.data;
        D.20650 = sccs.elem_size;
        D.20651 = D.20650 * i;
        D.20652 = (sizetype) D.20651;
        scc = D.20649 + D.20652;
        D.20670 = scc->num_bridge_entries;
        if (D.20670 == 0) goto <D.20671>; else goto <D.20672>;
        <D.20671>:
        // predicted unlikely by continue predictor.
        goto <D.20147>;
        <D.20672>:
        j.60 = (unsigned int) j;
        D.20674 = j.60 * 4;
        D.20675 = api_sccs + D.20674;
        D.20670 = scc->num_bridge_entries;
        D.20676 = (unsigned int) D.20670;
        D.20677 = D.20676 + 2;
        D.20678 = D.20677 * 4;
        D.20679 = sgen_alloc_internal_dynamic (D.20678, 21, 1);
        *D.20675 = D.20679;
        j.60 = (unsigned int) j;
        D.20674 = j.60 * 4;
        D.20675 = api_sccs + D.20674;
        D.20680 = *D.20675;
        D.20680->is_alive = 0;
        j.60 = (unsigned int) j;
        D.20674 = j.60 * 4;
        D.20675 = api_sccs + D.20674;
        D.20680 = *D.20675;
        D.20670 = scc->num_bridge_entries;
        D.20680->num_objs = D.20670;
        scc->num_bridge_entries = 0;
        j.61 = j;
        j = j.61 + 1;
        scc->api_index = j.61;
        D.20682 = scc->xrefs.size;
        num_xrefs = D.20682 + num_xrefs;
      }
      <D.20147>:
      i = i + 1;
      <D.20149>:
      D.20667 = sccs.size;
      if (D.20667 > i) goto <D.20148>; else goto <D.20150>;
      <D.20150>:
      {
        struct SgenHashTable * __hash_table;
        struct SgenHashTableEntry * * __table;
        guint __i;

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

          D.20683 = __i * 4;
          __iter = __table + D.20683;
          goto <D.20159>;
          <D.20158>:
          {
            struct SgenHashTableEntry * __entry;

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

              D.20649 = sccs.data;
              D.20687 = entry->scc_index;
              D.20650 = sccs.elem_size;
              D.20688 = D.20687 * D.20650;
              D.20689 = (sizetype) D.20688;
              scc = D.20649 + D.20689;
              D.20690 = scc->api_index;
              D.20691 = (unsigned int) D.20690;
              D.20692 = D.20691 * 4;
              D.20693 = api_sccs + D.20692;
              D.20694 = *D.20693;
              D.20695 = scc->num_bridge_entries;
              D.20696 = D.20695;
              D.20697 = D.20696 + 1;
              scc->num_bridge_entries = D.20697;
              D.20698 = entry->obj;
              D.20694->objs[D.20696] = D.20698;
            }
            <D.20686>:
          }
          __iter = __next;
          <D.20159>:
          D.20699 = *__iter;
          if (D.20699 != 0B) goto <D.20158>; else goto <D.20160>;
          <D.20160>:
        }
        __i = __i + 1;
        <D.20162>:
        D.20623 = hash_table.size;
        if (D.20623 > __i) goto <D.20161>; else goto <D.20163>;
        <D.20163>:
      }
      num_xrefs.62 = (unsigned int) num_xrefs;
      D.20701 = num_xrefs.62 * 8;
      api_xrefs = sgen_alloc_internal_dynamic (D.20701, 21, 1);
      j = 0;
      i = 0;
      goto <D.20173>;
      <D.20172>:
      {
        int k;
        struct SCC * scc;

        D.20649 = sccs.data;
        D.20650 = sccs.elem_size;
        D.20651 = D.20650 * i;
        D.20652 = (sizetype) D.20651;
        scc = D.20649 + D.20652;
        D.20702 = scc->num_bridge_entries;
        if (D.20702 == 0) goto <D.20703>; else goto <D.20704>;
        <D.20703>:
        // predicted unlikely by continue predictor.
        goto <D.20166>;
        <D.20704>:
        k = 0;
        goto <D.20170>;
        <D.20169>:
        {
          struct SCC * src_scc;

          D.20649 = sccs.data;
          D.20705 = scc->xrefs.data;
          k.63 = (unsigned int) k;
          D.20707 = k.63 * 4;
          D.20708 = D.20705 + D.20707;
          D.20709 = *D.20708;
          D.20650 = sccs.elem_size;
          D.20710 = D.20709 * D.20650;
          D.20711 = (sizetype) D.20710;
          src_scc = D.20649 + D.20711;
          D.20712 = src_scc->num_bridge_entries;
          if (D.20712 == 0) goto <D.20713>; else goto <D.20714>;
          <D.20713>:
          // predicted unlikely by continue predictor.
          goto <D.20168>;
          <D.20714>:
          j.60 = (unsigned int) j;
          D.20715 = j.60 * 8;
          D.20716 = api_xrefs + D.20715;
          D.20717 = src_scc->api_index;
          D.20716->src_scc_index = D.20717;
          j.60 = (unsigned int) j;
          D.20715 = j.60 * 8;
          D.20716 = api_xrefs + D.20715;
          D.20718 = scc->api_index;
          D.20716->dst_scc_index = D.20718;
          j = j + 1;
        }
        <D.20168>:
        k = k + 1;
        <D.20170>:
        D.20719 = scc->xrefs.size;
        if (D.20719 > k) goto <D.20169>; else goto <D.20171>;
        <D.20171>:
      }
      <D.20166>:
      i = i + 1;
      <D.20173>:
      D.20667 = sccs.size;
      if (D.20667 > i) goto <D.20172>; else goto <D.20174>;
      <D.20174>:
      btv = mono_100ns_ticks ();
      D.20630 = btv - atv;
      D.20631 = D.20630 / 10;
      step_3.47 = (long unsigned int) D.20631;
      step_5 = step_3.47;
      j = 0;
      max_xrefs = 0;
      max_entries = max_xrefs;
      i = 0;
      goto <D.20177>;
      <D.20176>:
      {
        struct SCC * scc;

        D.20649 = sccs.data;
        D.20650 = sccs.elem_size;
        D.20651 = D.20650 * i;
        D.20652 = (sizetype) D.20651;
        scc = D.20649 + D.20652;
        D.20720 = scc->num_bridge_entries;
        if (D.20720 != 0) goto <D.20721>; else goto <D.20722>;
        <D.20721>:
        j = j + 1;
        <D.20722>:
        D.20720 = scc->num_bridge_entries;
        if (D.20720 > max_entries) goto <D.20723>; else goto <D.20724>;
        <D.20723>:
        max_entries = scc->num_bridge_entries;
        <D.20724>:
        D.20725 = scc->xrefs.size;
        if (D.20725 > max_xrefs) goto <D.20726>; else goto <D.20727>;
        <D.20726>:
        max_xrefs = scc->xrefs.size;
        <D.20727>:
        D.20728 = &scc->xrefs;
        dyn_array_uninit (D.20728);
      }
      i = i + 1;
      <D.20177>:
      D.20667 = sccs.size;
      if (D.20667 > i) goto <D.20176>; else goto <D.20178>;
      <D.20178>:
      dyn_array_uninit (&sccs);
      D.20606 = hash_table.num_entries;
      D.20607 = D.20606 * 4;
      sgen_free_internal_dynamic (all_entries, D.20607, 21);
      free_data ();
      num_registered_bridges = registered_bridges.size;
      registered_bridges.size = 0;
      atv = mono_100ns_ticks ();
      D.20646 = atv - btv;
      D.20647 = D.20646 / 10;
      step_4.54 = (long unsigned int) D.20647;
      step_6 = step_4.54;
      D.20729 = bridge_callbacks.cross_references;
      D.20729 (num_sccs, api_sccs, num_xrefs, api_xrefs);
      btv = mono_100ns_ticks ();
      D.20630 = btv - atv;
      D.20631 = D.20630 / 10;
      step_3.47 = (long unsigned int) D.20631;
      step_7 = step_3.47;
      i = 0;
      goto <D.20184>;
      <D.20183>:
      {
        unsigned char alive;

        try
          {
            i.48 = (unsigned int) i;
            D.20634 = i.48 * 4;
            D.20730 = api_sccs + D.20634;
            D.20731 = *D.20730;
            D.20732 = D.20731->is_alive;
            D.20733 = D.20732 != 0;
            alive.64 = (unsigned char) D.20733;
            alive = alive.64;
            j = 0;
            goto <D.20181>;
            <D.20180>:
            i.48 = (unsigned int) i;
            D.20634 = i.48 * 4;
            D.20730 = api_sccs + D.20634;
            D.20731 = *D.20730;
            D.20735 = D.20731->objs[j];
            sgen_hash_table_replace (&alive_hash, D.20735, &alive, 0B);
            i.48 = (unsigned int) i;
            D.20634 = i.48 * 4;
            D.20730 = api_sccs + D.20634;
            D.20731 = *D.20730;
            D.20732 = D.20731->is_alive;
            if (D.20732 == 0) goto <D.20736>; else goto <D.20737>;
            <D.20736>:
            i.48 = (unsigned int) i;
            D.20634 = i.48 * 4;
            D.20730 = api_sccs + D.20634;
            D.20731 = *D.20730;
            D.20735 = D.20731->objs[j];
            sgen_mark_bridge_object (D.20735);
            <D.20737>:
            j = j + 1;
            <D.20181>:
            i.48 = (unsigned int) i;
            D.20634 = i.48 * 4;
            D.20730 = api_sccs + D.20634;
            D.20731 = *D.20730;
            D.20738 = D.20731->num_objs;
            if (D.20738 > j) goto <D.20180>; else goto <D.20182>;
            <D.20182>:
          }
        finally
          {
            alive = {CLOBBER};
          }
      }
      i = i + 1;
      <D.20184>:
      if (i < num_sccs) goto <D.20183>; else goto <D.20185>;
      <D.20185>:
      sgen_null_links_with_predicate (0, is_bridge_object_alive, &alive_hash);
      if (generation == 1) goto <D.20739>; else goto <D.20740>;
      <D.20739>:
      sgen_null_links_with_predicate (1, is_bridge_object_alive, &alive_hash);
      <D.20740>:
      sgen_hash_table_clean (&alive_hash);
      i = 0;
      goto <D.20187>;
      <D.20186>:
      i.48 = (unsigned int) i;
      D.20634 = i.48 * 4;
      D.20730 = api_sccs + D.20634;
      D.20731 = *D.20730;
      i.48 = (unsigned int) i;
      D.20634 = i.48 * 4;
      D.20730 = api_sccs + D.20634;
      D.20731 = *D.20730;
      D.20738 = D.20731->num_objs;
      D.20741 = (unsigned int) D.20738;
      D.20742 = D.20741 + 2;
      D.20743 = D.20742 * 4;
      sgen_free_internal_dynamic (D.20731, D.20743, 21);
      i = i + 1;
      <D.20187>:
      if (i < num_sccs) goto <D.20186>; else goto <D.20188>;
      <D.20188>:
      num_sccs.59 = (unsigned int) num_sccs;
      D.20669 = num_sccs.59 * 4;
      sgen_free_internal_dynamic (api_sccs, D.20669, 21);
      num_xrefs.62 = (unsigned int) num_xrefs;
      D.20701 = num_xrefs.62 * 8;
      sgen_free_internal_dynamic (api_xrefs, D.20701, 21);
      atv = mono_100ns_ticks ();
      D.20646 = atv - btv;
      D.20647 = D.20646 / 10;
      step_4.54 = (long unsigned int) D.20647;
      step_8 = step_4.54;
      D.20667 = sccs.size;
      step_1.65 = step_1;
      D.20745 = (float) step_1.65;
      D.20746 = D.20745 / 1.0e+3;
      D.20747 = (double) D.20746;
      step_2.66 = step_2;
      D.20749 = (float) step_2.66;
      D.20750 = D.20749 / 1.0e+3;
      D.20751 = (double) D.20750;
      step_3.67 = step_3;
      D.20753 = (float) step_3.67;
      D.20754 = D.20753 / 1.0e+3;
      D.20755 = (double) D.20754;
      step_4.68 = step_4;
      D.20757 = (float) step_4.68;
      D.20758 = D.20757 / 1.0e+3;
      D.20759 = (double) D.20758;
      step_5.69 = step_5;
      D.20761 = (float) step_5.69;
      D.20762 = D.20761 / 1.0e+3;
      D.20763 = (double) D.20762;
      step_6.70 = step_6;
      D.20765 = (float) step_6.70;
      D.20766 = D.20765 / 1.0e+3;
      D.20767 = (double) D.20766;
      step_7.71 = step_7;
      D.20769 = (float) step_7.71;
      D.20770 = D.20769 / 1.0e+3;
      D.20771 = (double) D.20770;
      step_8.72 = step_8;
      D.20773 = (float) step_8.72;
      D.20774 = D.20773 / 1.0e+3;
      D.20775 = (double) D.20774;
      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.20667, D.20747, D.20751, D.20755, D.20759, D.20763, D.20767, D.20771, D.20775, 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.20783;
  unsigned char D.20784;
  struct SgenHashTable * table;
  unsigned char * value;

  table = data;
  value = sgen_hash_table_lookup (table, obj);
  if (value == 0B) goto <D.20781>; else goto <D.20782>;
  <D.20781>:
  D.20783 = 1;
  return D.20783;
  <D.20782>:
  D.20784 = *value;
  D.20783 = (mono_bool) D.20784;
  return D.20783;
}


compare_hash_entries (const void * ep1, const void * ep2)
{
  int D.20786;
  int D.20787;
  int D.20788;
  struct HashEntry * e1;
  struct HashEntry * e2;

  e1 = MEM[(struct HashEntry * *)ep1];
  e2 = MEM[(struct HashEntry * *)ep2];
  D.20787 = e2->finishing_time;
  D.20788 = e1->finishing_time;
  D.20786 = D.20787 - D.20788;
  return D.20786;
}


dfs2 (struct HashEntry * entry)
{
  int D.20790;
  _Bool D.20791;
  long int D.20792;
  long int D.20793;
  int dsf2_passes.75;
  int dsf2_passes.76;
  int D.20798;
  struct SCC * current_scc.77;
  int D.20802;
  char * D.20805;
  int D.20806;
  int D.20807;
  sizetype D.20808;
  struct SCC * D.20809;
  char * D.20810;
  unsigned int i.78;
  unsigned int D.20812;
  void * * D.20813;
  void * D.20814;
  int D.20815;
  int i;

  D.20790 = dfs_stack.size;
  D.20791 = D.20790 != 0;
  D.20792 = (long int) D.20791;
  D.20793 = __builtin_expect (D.20792, 0);
  if (D.20793 != 0) goto <D.20794>; else goto <D.20795>;
  <D.20794>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-bridge.c", 501, "dfs_stack.size == 0");
  <D.20795>:
  dyn_array_ptr_add (&dfs_stack, entry);
  <D.20057>:
  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.20798 = entry->scc_index;
  if (D.20798 >= 0) goto <D.20799>; else goto <D.20800>;
  <D.20799>:
  D.20798 = entry->scc_index;
  current_scc.77 = current_scc;
  D.20802 = current_scc.77->index;
  if (D.20798 != D.20802) goto <D.20803>; else goto <D.20804>;
  <D.20803>:
  D.20805 = sccs.data;
  D.20798 = entry->scc_index;
  D.20806 = sccs.elem_size;
  D.20807 = D.20798 * D.20806;
  D.20808 = (sizetype) D.20807;
  D.20809 = D.20805 + D.20808;
  current_scc.77 = current_scc;
  scc_add_xref (D.20809, current_scc.77);
  <D.20804>:
  // predicted unlikely by continue predictor.
  goto <D.20053>;
  <D.20800>:
  current_scc.77 = current_scc;
  scc_add_entry (current_scc.77, entry);
  i = 0;
  goto <D.20055>;
  <D.20054>:
  D.20810 = entry->srcs.data;
  i.78 = (unsigned int) i;
  D.20812 = i.78 * 4;
  D.20813 = D.20810 + D.20812;
  D.20814 = *D.20813;
  dyn_array_ptr_add (&dfs_stack, D.20814);
  i = i + 1;
  <D.20055>:
  D.20815 = entry->srcs.size;
  if (D.20815 > i) goto <D.20054>; else goto <D.20056>;
  <D.20056>:
  <D.20053>:
  D.20790 = dfs_stack.size;
  if (D.20790 > 0) goto <D.20057>; else goto <D.20058>;
  <D.20058>:
}


scc_add_xref (struct SCC * src, struct SCC * dst)
{
  _Bool D.20816;
  long int D.20817;
  long int D.20818;
  int D.20821;
  int D.20822;
  _Bool D.20823;
  long int D.20824;
  long int D.20825;
  struct DynArray * D.20828;
  int D.20829;
  int D.20832;
  struct DynArray * D.20836;
  char * D.20837;
  unsigned int i.79;
  unsigned int D.20839;
  int * D.20840;
  int D.20841;
  _Bool D.20842;
  long int D.20843;
  long int D.20844;
  int D.20847;

  D.20816 = src == dst;
  D.20817 = (long int) D.20816;
  D.20818 = __builtin_expect (D.20817, 0);
  if (D.20818 != 0) goto <D.20819>; else goto <D.20820>;
  <D.20819>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-bridge.c", 469, "src != dst");
  <D.20820>:
  D.20821 = src->index;
  D.20822 = dst->index;
  D.20823 = D.20821 == D.20822;
  D.20824 = (long int) D.20823;
  D.20825 = __builtin_expect (D.20824, 0);
  if (D.20825 != 0) goto <D.20826>; else goto <D.20827>;
  <D.20826>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-bridge.c", 470, "src->index != dst->index");
  <D.20827>:
  D.20828 = &dst->xrefs;
  D.20821 = src->index;
  D.20829 = dyn_array_int_contains (D.20828, D.20821);
  if (D.20829 != 0) goto <D.20830>; else goto <D.20831>;
  <D.20830>:
  return;
  <D.20831>:
  D.20832 = src->num_bridge_entries;
  if (D.20832 != 0) goto <D.20833>; else goto <D.20834>;
  <D.20833>:
  D.20828 = &dst->xrefs;
  D.20821 = src->index;
  dyn_array_int_merge_one (D.20828, D.20821);
  goto <D.20835>;
  <D.20834>:
  {
    int i;

    D.20828 = &dst->xrefs;
    D.20836 = &src->xrefs;
    dyn_array_int_merge (D.20828, D.20836);
    i = 0;
    goto <D.20041>;
    <D.20040>:
    D.20837 = dst->xrefs.data;
    i.79 = (unsigned int) i;
    D.20839 = i.79 * 4;
    D.20840 = D.20837 + D.20839;
    D.20841 = *D.20840;
    D.20822 = dst->index;
    D.20842 = D.20841 == D.20822;
    D.20843 = (long int) D.20842;
    D.20844 = __builtin_expect (D.20843, 0);
    if (D.20844 != 0) goto <D.20845>; else goto <D.20846>;
    <D.20845>:
    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.20846>:
    i = i + 1;
    <D.20041>:
    D.20847 = dst->xrefs.size;
    if (D.20847 > i) goto <D.20040>; else goto <D.20042>;
    <D.20042>:
  }
  <D.20835>:
}


dyn_array_int_contains (struct DynArray * da, int x)
{
  char * D.20849;
  unsigned int i.80;
  unsigned int D.20851;
  int * D.20852;
  int D.20853;
  gboolean D.20856;
  int D.20857;
  int i;

  i = 0;
  goto <D.19821>;
  <D.19820>:
  D.20849 = da->data;
  i.80 = (unsigned int) i;
  D.20851 = i.80 * 4;
  D.20852 = D.20849 + D.20851;
  D.20853 = *D.20852;
  if (D.20853 == x) goto <D.20854>; else goto <D.20855>;
  <D.20854>:
  D.20856 = 1;
  return D.20856;
  <D.20855>:
  i = i + 1;
  <D.19821>:
  D.20857 = da->size;
  if (D.20857 > i) goto <D.19820>; else goto <D.19822>;
  <D.19822>:
  D.20856 = 0;
  return D.20856;
}


dyn_array_int_merge_one (struct DynArray * array, int value)
{
  char * D.20859;
  unsigned int i.81;
  unsigned int D.20861;
  int * D.20862;
  int D.20863;
  int D.20867;
  int D.20868;
  sizetype i.82;
  sizetype D.20872;
  sizetype D.20873;
  int * D.20874;
  sizetype end.83;
  sizetype D.20876;
  sizetype D.20877;
  int * D.20878;
  unsigned int end.84;
  unsigned int D.20881;
  int * D.20882;
  int i;
  int tmp;
  int end;

  end = array->size;
  i = 0;
  goto <D.19844>;
  <D.19843>:
  D.20859 = array->data;
  i.81 = (unsigned int) i;
  D.20861 = i.81 * 4;
  D.20862 = D.20859 + D.20861;
  D.20863 = *D.20862;
  if (D.20863 == value) goto <D.20864>; else goto <D.20865>;
  <D.20864>:
  return;
  <D.20865>:
  D.20859 = array->data;
  i.81 = (unsigned int) i;
  D.20861 = i.81 * 4;
  D.20862 = D.20859 + D.20861;
  D.20863 = *D.20862;
  if (D.20863 > value) goto <D.19842>; else goto <D.20866>;
  <D.20866>:
  i = i + 1;
  <D.19844>:
  if (i < end) goto <D.19843>; else goto <D.19842>;
  <D.19842>:
  D.20867 = array->size;
  D.20868 = D.20867 + 1;
  dyn_array_ensure_capacity (array, D.20868);
  if (i < end) goto <D.20869>; else goto <D.20870>;
  <D.20869>:
  D.20859 = array->data;
  i.81 = (unsigned int) i;
  D.20861 = i.81 * 4;
  D.20862 = D.20859 + D.20861;
  tmp = *D.20862;
  goto <D.19846>;
  <D.19845>:
  D.20859 = array->data;
  i.81 = (unsigned int) i;
  D.20861 = i.81 * 4;
  D.20862 = D.20859 + D.20861;
  *D.20862 = value;
  value = tmp;
  D.20859 = array->data;
  i.82 = (sizetype) i;
  D.20872 = i.82 + 1;
  D.20873 = D.20872 * 4;
  D.20874 = D.20859 + D.20873;
  tmp = *D.20874;
  i = i + 1;
  <D.19846>:
  if (i <= end) goto <D.19845>; else goto <D.19847>;
  <D.19847>:
  D.20859 = array->data;
  end.83 = (sizetype) end;
  D.20876 = end.83 + 1;
  D.20877 = D.20876 * 4;
  D.20878 = D.20859 + D.20877;
  *D.20878 = tmp;
  goto <D.20879>;
  <D.20870>:
  D.20859 = array->data;
  end.84 = (unsigned int) end;
  D.20881 = end.84 * 4;
  D.20882 = D.20859 + D.20881;
  *D.20882 = value;
  <D.20879>:
  D.20867 = array->size;
  D.20868 = D.20867 + 1;
  array->size = D.20868;
}


dyn_array_int_merge (struct DynArray * dst, struct DynArray * src)
{
  int D.20884;
  int D.20885;
  int D.20886;
  char * D.20891;
  unsigned int i.85;
  unsigned int D.20893;
  int * D.20894;
  char * D.20895;
  unsigned int j.86;
  unsigned int D.20897;
  int * D.20898;
  int D.20907;
  int D.20909;
  int D.20911;
  char * D.20914;
  int D.20915;
  int D.20916;
  unsigned int D.20917;
  int i;
  int j;

  D.20884 = dst->size;
  D.20885 = src->size;
  D.20886 = D.20884 + D.20885;
  dyn_array_ensure_capacity (&merge_array, D.20886);
  merge_array.size = 0;
  j = 0;
  i = j;
  goto <D.19833>;
  <D.19832>:
  D.20884 = dst->size;
  if (D.20884 > i) goto <D.20889>; else goto <D.20887>;
  <D.20889>:
  D.20885 = src->size;
  if (D.20885 > j) goto <D.20890>; else goto <D.20887>;
  <D.20890>:
  {
    int a;
    int b;

    D.20891 = dst->data;
    i.85 = (unsigned int) i;
    D.20893 = i.85 * 4;
    D.20894 = D.20891 + D.20893;
    a = *D.20894;
    D.20895 = src->data;
    j.86 = (unsigned int) j;
    D.20897 = j.86 * 4;
    D.20898 = D.20895 + D.20897;
    b = *D.20898;
    if (a < b) goto <D.20899>; else goto <D.20900>;
    <D.20899>:
    dyn_array_int_add (&merge_array, a);
    i = i + 1;
    goto <D.20901>;
    <D.20900>:
    if (a == b) goto <D.20902>; else goto <D.20903>;
    <D.20902>:
    dyn_array_int_add (&merge_array, a);
    i = i + 1;
    j = j + 1;
    goto <D.20904>;
    <D.20903>:
    dyn_array_int_add (&merge_array, b);
    j = j + 1;
    <D.20904>:
    <D.20901>:
  }
  goto <D.20888>;
  <D.20887>:
  D.20884 = dst->size;
  if (D.20884 > i) goto <D.20905>; else goto <D.20906>;
  <D.20905>:
  D.20891 = dst->data;
  i.85 = (unsigned int) i;
  D.20893 = i.85 * 4;
  D.20894 = D.20891 + D.20893;
  D.20907 = *D.20894;
  dyn_array_int_add (&merge_array, D.20907);
  i = i + 1;
  goto <D.20908>;
  <D.20906>:
  D.20895 = src->data;
  j.86 = (unsigned int) j;
  D.20897 = j.86 * 4;
  D.20898 = D.20895 + D.20897;
  D.20909 = *D.20898;
  dyn_array_int_add (&merge_array, D.20909);
  j = j + 1;
  <D.20908>:
  <D.20888>:
  <D.19833>:
  D.20884 = dst->size;
  if (D.20884 > i) goto <D.19832>; else goto <D.20910>;
  <D.20910>:
  D.20885 = src->size;
  if (D.20885 > j) goto <D.19832>; else goto <D.19834>;
  <D.19834>:
  D.20911 = merge_array.size;
  D.20884 = dst->size;
  if (D.20911 > D.20884) goto <D.20912>; else goto <D.20913>;
  <D.20912>:
  D.20911 = merge_array.size;
  dyn_array_ensure_capacity (dst, D.20911);
  D.20891 = dst->data;
  D.20914 = merge_array.data;
  D.20911 = merge_array.size;
  D.20915 = merge_array.elem_size;
  D.20916 = D.20911 * D.20915;
  D.20917 = (unsigned int) D.20916;
  memcpy (D.20891, D.20914, D.20917);
  D.20911 = merge_array.size;
  dst->size = D.20911;
  <D.20913>:
}


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.20918;
  _Bool D.20919;
  long int D.20920;
  long int D.20921;
  int D.20924;
  int D.20925;
  int D.20928;
  int D.20929;

  D.20918 = entry->scc_index;
  D.20919 = D.20918 >= 0;
  D.20920 = (long int) D.20919;
  D.20921 = __builtin_expect (D.20920, 0);
  if (D.20921 != 0) goto <D.20922>; else goto <D.20923>;
  <D.20922>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-bridge.c", 487, "entry->scc_index < 0");
  <D.20923>:
  D.20924 = scc->index;
  entry->scc_index = D.20924;
  D.20925 = entry->is_bridge;
  if (D.20925 != 0) goto <D.20926>; else goto <D.20927>;
  <D.20926>:
  D.20928 = scc->num_bridge_entries;
  D.20929 = D.20928 + 1;
  scc->num_bridge_entries = D.20929;
  <D.20927>:
}


dyn_array_uninit (struct DynArray * da)
{
  int D.20930;
  char * D.20933;
  int D.20934;
  int D.20935;
  unsigned int D.20936;

  D.20930 = da->capacity;
  if (D.20930 <= 0) goto <D.20931>; else goto <D.20932>;
  <D.20931>:
  return;
  <D.20932>:
  D.20933 = da->data;
  D.20934 = da->elem_size;
  D.20930 = da->capacity;
  D.20935 = D.20934 * D.20930;
  D.20936 = (unsigned int) D.20935;
  sgen_free_internal_dynamic (D.20933, D.20936, 21);
  da->data = 0B;
}


free_data ()
{
  unsigned int D.20938;
  int D.20939;
  struct DynArray * D.20942;
  struct SgenHashTableEntry * D.20943;
  unsigned int D.20944;
  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.19909>;
    <D.19908>:
    {
      struct SgenHashTableEntry * * __iter;
      struct SgenHashTableEntry * * __next;

      D.20938 = __i * 4;
      __iter = __table + D.20938;
      goto <D.19906>;
      <D.19905>:
      {
        struct SgenHashTableEntry * __entry;

        __entry = *__iter;
        __next = &__entry->next;
        obj = __entry->key;
        entry = &__entry->data;
        D.20939 = entry->srcs.size;
        total_srcs = D.20939 + total_srcs;
        D.20939 = entry->srcs.size;
        if (D.20939 > max_srcs) goto <D.20940>; else goto <D.20941>;
        <D.20940>:
        max_srcs = entry->srcs.size;
        <D.20941>:
        D.20942 = &entry->srcs;
        dyn_array_uninit (D.20942);
      }
      __iter = __next;
      <D.19906>:
      D.20943 = *__iter;
      if (D.20943 != 0B) goto <D.19905>; else goto <D.19907>;
      <D.19907>:
    }
    __i = __i + 1;
    <D.19909>:
    D.20944 = hash_table.size;
    if (D.20944 > __i) goto <D.19908>; else goto <D.19910>;
    <D.19910>:
  }
  sgen_hash_table_clean (&hash_table);
  dyn_array_uninit (&merge_array);
}


sgen_bridge_describe_pointer (struct MonoObject * obj)
{
  char * D.20945;
  unsigned int i.87;
  unsigned int D.20947;
  void * * D.20948;
  void * D.20949;
  int D.20952;
  int D.20955;
  int D.20956;
  struct HashEntry * entry;
  int i;

  i = 0;
  goto <D.20196>;
  <D.20195>:
  D.20945 = registered_bridges.data;
  i.87 = (unsigned int) i;
  D.20947 = i.87 * 4;
  D.20948 = D.20945 + D.20947;
  D.20949 = *D.20948;
  if (D.20949 == obj) goto <D.20950>; else goto <D.20951>;
  <D.20950>:
  printf ("Pointer is a registered bridge object.\n");
  goto <D.20194>;
  <D.20951>:
  i = i + 1;
  <D.20196>:
  D.20952 = registered_bridges.size;
  if (D.20952 > i) goto <D.20195>; else goto <D.20194>;
  <D.20194>:
  entry = sgen_hash_table_lookup (&hash_table, obj);
  if (entry == 0B) goto <D.20953>; else goto <D.20954>;
  <D.20953>:
  return;
  <D.20954>:
  printf ("Bridge hash table entry %p:\n", entry);
  D.20955 = entry->is_bridge;
  printf ("  is bridge: %d\n", D.20955);
  D.20956 = entry->is_visited;
  printf ("  is visited: %d\n", D.20956);
}


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

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


sgen_register_test_bridge_callbacks (const char * bridge_class_name)
{
  void (*<T38a7>) (int, struct MonoGCBridgeSCC * *, int, struct MonoGCBridgeXRef *) iftmp.88;
  char D.20961;
  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.20961 = *bridge_class_name;
      if (D.20961 == 50) goto <D.20962>; else goto <D.20963>;
      <D.20962>:
      iftmp.88 = bridge_test_cross_reference2;
      goto <D.20964>;
      <D.20963>:
      iftmp.88 = bridge_test_cross_reference;
      <D.20964>:
      callbacks.cross_references = iftmp.88;
      mono_gc_register_bridge_callbacks (&callbacks);
      D.20961 = *bridge_class_name;
      if (D.20961 == 50) goto <D.20966>; else goto <D.20967>;
      <D.20966>:
      iftmp.89 = 1;
      goto <D.20968>;
      <D.20967>:
      iftmp.89 = 0;
      <D.20968>:
      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.20970;
  unsigned int i.91;
  unsigned int D.20974;
  struct MonoGCBridgeSCC * * D.20975;
  struct MonoGCBridgeSCC * D.20976;
  int D.20977;
  int iftmp.92;
  unsigned int D.20982;
  struct MonoGCBridgeXRef * D.20983;
  int D.20984;
  _Bool D.20986;
  long int D.20987;
  long int D.20988;
  int iftmp.93;
  int D.20995;
  _Bool D.20997;
  long int D.20998;
  long int D.20999;
  int i;

  i = 0;
  goto <D.20225>;
  <D.20224>:
  {
    int j;

    j = 0;
    goto <D.20222>;
    <D.20221>:
    D.20970 = i & 1;
    if (D.20970 != 0) goto <D.20971>; else goto <D.20972>;
    <D.20971>:
    i.91 = (unsigned int) i;
    D.20974 = i.91 * 4;
    D.20975 = sccs + D.20974;
    D.20976 = *D.20975;
    D.20976->is_alive = 1;
    <D.20972>:
    j = j + 1;
    <D.20222>:
    i.91 = (unsigned int) i;
    D.20974 = i.91 * 4;
    D.20975 = sccs + D.20974;
    D.20976 = *D.20975;
    D.20977 = D.20976->num_objs;
    if (D.20977 > j) goto <D.20221>; else goto <D.20223>;
    <D.20223>:
  }
  i = i + 1;
  <D.20225>:
  if (i < num_sccs) goto <D.20224>; else goto <D.20226>;
  <D.20226>:
  i = 0;
  goto <D.20228>;
  <D.20227>:
  i.91 = (unsigned int) i;
  D.20982 = i.91 * 8;
  D.20983 = xrefs + D.20982;
  D.20984 = D.20983->src_scc_index;
  if (D.20984 < 0) goto <D.20979>; else goto <D.20985>;
  <D.20985>:
  i.91 = (unsigned int) i;
  D.20982 = i.91 * 8;
  D.20983 = xrefs + D.20982;
  D.20984 = D.20983->src_scc_index;
  if (D.20984 >= num_sccs) goto <D.20979>; else goto <D.20980>;
  <D.20979>:
  iftmp.92 = 1;
  goto <D.20981>;
  <D.20980>:
  iftmp.92 = 0;
  <D.20981>:
  D.20986 = iftmp.92 != 0;
  D.20987 = (long int) D.20986;
  D.20988 = __builtin_expect (D.20987, 0);
  if (D.20988 != 0) goto <D.20989>; else goto <D.20990>;
  <D.20989>:
  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.20990>:
  i.91 = (unsigned int) i;
  D.20982 = i.91 * 8;
  D.20983 = xrefs + D.20982;
  D.20995 = D.20983->dst_scc_index;
  if (D.20995 < 0) goto <D.20992>; else goto <D.20996>;
  <D.20996>:
  i.91 = (unsigned int) i;
  D.20982 = i.91 * 8;
  D.20983 = xrefs + D.20982;
  D.20995 = D.20983->dst_scc_index;
  if (D.20995 >= num_sccs) goto <D.20992>; else goto <D.20993>;
  <D.20992>:
  iftmp.93 = 1;
  goto <D.20994>;
  <D.20993>:
  iftmp.93 = 0;
  <D.20994>:
  D.20997 = iftmp.93 != 0;
  D.20998 = (long int) D.20997;
  D.20999 = __builtin_expect (D.20998, 0);
  if (D.20999 != 0) goto <D.21000>; else goto <D.21001>;
  <D.21000>:
  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.21001>:
  i = i + 1;
  <D.20228>:
  if (i < num_xrefs) goto <D.20227>; else goto <D.20229>;
  <D.20229>:
}


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.21005;
  struct MonoObject * D.21006;
  struct MonoClass * D.21007;
  struct MonoClassField * mono_bridge_test_field.95;
  _Bool D.21009;
  long int D.21010;
  long int D.21011;
  unsigned int i.96;
  unsigned int D.21015;
  struct MonoGCBridgeSCC * * D.21016;
  struct MonoGCBridgeSCC * D.21017;
  int D.21018;
  int D.21021;
  int D.21024;
  struct MonoObject * D.21027;
  unsigned int D.21028;
  struct MonoGCBridgeXRef * D.21029;
  int D.21030;
  unsigned int D.21031;
  unsigned int D.21032;
  struct MonoGCBridgeSCC * * D.21033;
  struct MonoGCBridgeSCC * D.21034;
  int D.21035;
  int D.21038;
  unsigned int D.21039;
  unsigned int D.21040;
  struct MonoGCBridgeSCC * * D.21041;
  struct MonoGCBridgeSCC * D.21042;
  int D.21043;
  int i;
  gboolean modified;

  mono_bridge_test_field.94 = mono_bridge_test_field;
  if (mono_bridge_test_field.94 == 0B) goto <D.21003>; else goto <D.21004>;
  <D.21003>:
  D.21005 = *sccs;
  D.21006 = D.21005->objs[0];
  D.21007 = mono_object_get_class (D.21006);
  mono_bridge_test_field.95 = mono_class_get_field_from_name (D.21007, "__test");
  mono_bridge_test_field = mono_bridge_test_field.95;
  mono_bridge_test_field.94 = mono_bridge_test_field;
  D.21009 = mono_bridge_test_field.94 == 0B;
  D.21010 = (long int) D.21009;
  D.21011 = __builtin_expect (D.21010, 0);
  if (D.21011 != 0) goto <D.21012>; else goto <D.21013>;
  <D.21012>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-bridge.c", 912, "mono_bridge_test_field");
  <D.21013>:
  <D.21004>:
  i = 0;
  goto <D.20269>;
  <D.20268>:
  {
    int j;
    gboolean live;

    live = 0;
    j = 0;
    goto <D.20262>;
    <D.20261>:
    i.96 = (unsigned int) i;
    D.21015 = i.96 * 4;
    D.21016 = sccs + D.21015;
    D.21017 = *D.21016;
    D.21018 = test_scc (D.21017, j);
    if (D.21018 != 0) goto <D.21019>; else goto <D.21020>;
    <D.21019>:
    live = 1;
    goto <D.20260>;
    <D.21020>:
    j = j + 1;
    <D.20262>:
    i.96 = (unsigned int) i;
    D.21015 = i.96 * 4;
    D.21016 = sccs + D.21015;
    D.21017 = *D.21016;
    D.21021 = D.21017->num_objs;
    if (D.21021 > j) goto <D.20261>; else goto <D.20260>;
    <D.20260>:
    if (live == 0) goto <D.21022>; else goto <D.21023>;
    <D.21022>:
    // predicted unlikely by continue predictor.
    goto <D.20263>;
    <D.21023>:
    j = 0;
    goto <D.20266>;
    <D.20265>:
    i.96 = (unsigned int) i;
    D.21015 = i.96 * 4;
    D.21016 = sccs + D.21015;
    D.21017 = *D.21016;
    D.21024 = test_scc (D.21017, j);
    if (D.21024 == 0) goto <D.21025>; else goto <D.21026>;
    <D.21025>:
    {
      int status;

      try
        {
          status = 2;
          i.96 = (unsigned int) i;
          D.21015 = i.96 * 4;
          D.21016 = sccs + D.21015;
          D.21017 = *D.21016;
          D.21027 = D.21017->objs[j];
          mono_bridge_test_field.94 = mono_bridge_test_field;
          mono_field_set_value (D.21027, mono_bridge_test_field.94, &status);
        }
      finally
        {
          status = {CLOBBER};
        }
    }
    <D.21026>:
    j = j + 1;
    <D.20266>:
    i.96 = (unsigned int) i;
    D.21015 = i.96 * 4;
    D.21016 = sccs + D.21015;
    D.21017 = *D.21016;
    D.21021 = D.21017->num_objs;
    if (D.21021 > j) goto <D.20265>; else goto <D.20267>;
    <D.20267>:
  }
  <D.20263>:
  i = i + 1;
  <D.20269>:
  if (i < num_sccs) goto <D.20268>; else goto <D.20270>;
  <D.20270>:
  modified = 1;
  goto <D.20276>;
  <D.20275>:
  modified = 0;
  i = 0;
  goto <D.20273>;
  <D.20272>:
  {
    struct MonoGCBridgeXRef ref;

    try
      {
        i.96 = (unsigned int) i;
        D.21028 = i.96 * 8;
        D.21029 = xrefs + D.21028;
        ref = *D.21029;
        D.21030 = ref.src_scc_index;
        D.21031 = (unsigned int) D.21030;
        D.21032 = D.21031 * 4;
        D.21033 = sccs + D.21032;
        D.21034 = *D.21033;
        D.21035 = test_scc (D.21034, 0);
        if (D.21035 != 0) goto <D.21036>; else goto <D.21037>;
        <D.21036>:
        D.21038 = ref.dst_scc_index;
        D.21039 = (unsigned int) D.21038;
        D.21040 = D.21039 * 4;
        D.21041 = sccs + D.21040;
        D.21042 = *D.21041;
        D.21043 = test_scc (D.21042, 0);
        if (D.21043 == 0) goto <D.21044>; else goto <D.21045>;
        <D.21044>:
        modified = 1;
        D.21038 = ref.dst_scc_index;
        D.21039 = (unsigned int) D.21038;
        D.21040 = D.21039 * 4;
        D.21041 = sccs + D.21040;
        D.21042 = *D.21041;
        mark_scc (D.21042, 3);
        <D.21045>:
        <D.21037>:
      }
    finally
      {
        ref = {CLOBBER};
      }
  }
  i = i + 1;
  <D.20273>:
  if (i < num_xrefs) goto <D.20272>; else goto <D.20274>;
  <D.20274>:
  <D.20276>:
  if (modified != 0) goto <D.20275>; else goto <D.20277>;
  <D.20277>:
  i = 0;
  goto <D.20279>;
  <D.20278>:
  i.96 = (unsigned int) i;
  D.21015 = i.96 * 4;
  D.21016 = sccs + D.21015;
  D.21017 = *D.21016;
  D.21017->is_alive = 1;
  i = i + 1;
  <D.20279>:
  if (i < num_sccs) goto <D.20278>; else goto <D.20280>;
  <D.20280>:
}


test_scc (struct MonoGCBridgeSCC * scc, int i)
{
  struct MonoObject * D.21046;
  struct MonoClassField * mono_bridge_test_field.97;
  gboolean D.21048;
  int status.98;
  _Bool D.21050;
  int status;

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


mark_scc (struct MonoGCBridgeSCC * scc, int value)
{
  int D.21053;
  struct MonoObject * D.21056;
  struct MonoClassField * mono_bridge_test_field.99;
  int D.21058;
  int i;

  i = 0;
  goto <D.20248>;
  <D.20247>:
  D.21053 = test_scc (scc, i);
  if (D.21053 == 0) goto <D.21054>; else goto <D.21055>;
  <D.21054>:
  {
    int status;

    try
      {
        status = value;
        D.21056 = scc->objs[i];
        mono_bridge_test_field.99 = mono_bridge_test_field;
        mono_field_set_value (D.21056, mono_bridge_test_field.99, &status);
      }
    finally
      {
        status = {CLOBBER};
      }
  }
  <D.21055>:
  i = i + 1;
  <D.20248>:
  D.21058 = scc->num_objs;
  if (D.21058 > i) goto <D.20247>; else goto <D.20249>;
  <D.20249>:
}


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

  D.21059 = 1;
  return D.21059;
}


bridge_test_is_bridge_class (struct MonoClass * class)
{
  gboolean D.21061;
  int D.20209;
  const char * bridge_class.100;
  const char * D.21063;
  _Bool D.21064;

  {
    size_t __s1_len;
    size_t __s2_len;

    bridge_class.100 = bridge_class;
    D.21063 = class->name;
    D.20209 = __builtin_strcmp (bridge_class.100, D.21063);
  }
  D.21064 = D.20209 == 0;
  D.21061 = (gboolean) D.21064;
  return D.21061;
}