main ()
{
  int i.0;
  int D.19786;
  sizetype D.19787;
  sizetype i.1;
  bitsizetype D.19789;
  bitsizetype D.19790;
  sizetype D.19791;
  int[0:D.19787] * a.2;
  int D.19793;
  int D.19794;
  int[0:D.19787] * D.19795;
  unsigned int i.3;
  void * saved_stack.4;
  long int D.19798;
  unsigned int D.19799;
  long int D.19800;
  long int D.19801;
  int D.19802;
  int i;

  i = 0;
  goto <D.19772>;
  <D.19771>:
  {
    int a[0:D.19787] [value-expr: *a.2];
    int j;

    saved_stack.4 = __builtin_stack_save ();
    try
      {
        i.0 = i;
        D.19786 = i.0 + -1;
        D.19787 = (sizetype) D.19786;
        i.1 = (sizetype) i.0;
        D.19789 = (bitsizetype) i.1;
        D.19790 = D.19789 * 32;
        i.1 = (sizetype) i.0;
        D.19791 = i.1 * 4;
        i.1 = (sizetype) i.0;
        D.19789 = (bitsizetype) i.1;
        D.19790 = D.19789 * 32;
        i.1 = (sizetype) i.0;
        D.19791 = i.1 * 4;
        a.2 = __builtin_alloca_with_align (D.19791, 32);
        j = 0;
        goto <D.19769>;
        <D.19768>:
        D.19793 = i - j;
        D.19794 = D.19793 + -1;
        *a.2[j] = D.19794;
        j = j + 1;
        <D.19769>:
        if (j < i) goto <D.19768>; else goto <D.19770>;
        <D.19770>:
        D.19795 = a.2;
        i.3 = (unsigned int) i;
        compare_sorts (D.19795, i.3, 4, compare_ints);
      }
    finally
      {
        __builtin_stack_restore (saved_stack.4);
      }
  }
  i = i + 1;
  <D.19772>:
  if (i <= 3999) goto <D.19771>; else goto <D.19773>;
  <D.19773>:
  D.19798 = time (0B);
  D.19799 = (unsigned int) D.19798;
  srandom (D.19799);
  i = 0;
  goto <D.19780>;
  <D.19779>:
  {
    struct teststruct_t a[200];
    int j;

    try
      {
        j = 0;
        goto <D.19777>;
        <D.19776>:
        D.19800 = random ();
        a[j].key = D.19800;
        D.19801 = random ();
        a[j].val = D.19801;
        j = j + 1;
        <D.19777>:
        if (j <= 199) goto <D.19776>; else goto <D.19778>;
        <D.19778>:
        compare_sorts (&a, 200, 8, compare_teststructs);
      }
    finally
      {
        a = {CLOBBER};
      }
  }
  i = i + 1;
  <D.19780>:
  if (i <= 1999) goto <D.19779>; else goto <D.19781>;
  <D.19781>:
  D.19802 = 0;
  return D.19802;
}


compare_teststructs (const void * pa, const void * pb)
{
  int D.19806;
  int a;
  int b;

  a = MEM[(const struct teststruct_t *)pa].key;
  b = MEM[(const struct teststruct_t *)pb].key;
  if (a < b) goto <D.19804>; else goto <D.19805>;
  <D.19804>:
  D.19806 = -1;
  return D.19806;
  <D.19805>:
  if (a == b) goto <D.19807>; else goto <D.19808>;
  <D.19807>:
  D.19806 = 0;
  return D.19806;
  <D.19808>:
  D.19806 = 1;
  return D.19806;
}


compare_ints (const void * pa, const void * pb)
{
  int D.19812;
  int a;
  int b;

  a = MEM[(const int *)pa];
  b = MEM[(const int *)pb];
  if (a < b) goto <D.19810>; else goto <D.19811>;
  <D.19810>:
  D.19812 = -1;
  return D.19812;
  <D.19811>:
  if (a == b) goto <D.19813>; else goto <D.19814>;
  <D.19813>:
  D.19812 = 0;
  return D.19812;
  <D.19814>:
  D.19812 = 1;
  return D.19812;
}


compare_sorts (void * base, size_t nel, size_t width, int (*<Tf6d>) (const void *, const void *) compar)
{
  int D.19816;
  size_t len;
  void * b1;
  void * b2;
  static const char __PRETTY_FUNCTION__[14] = "compare_sorts";

  len = nel * width;
  b1 = malloc (len);
  b2 = malloc (len);
  memcpy (b1, base, len);
  memcpy (b2, base, len);
  qsort (b1, nel, width, compar);
  sgen_qsort (b2, nel, width, compar);
  {
    D.19816 = memcmp (b1, b2, len);
    if (D.19816 == 0) goto <D.19817>; else goto <D.19818>;
    <D.19817>:
    goto <D.19819>;
    <D.19818>:
    __assert_fail ("!memcmp (b1, b2, len)", "test-sgen-qsort.c", 71, &__PRETTY_FUNCTION__);
    <D.19819>:
  }
  free (b1);
  free (b2);
}


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

  D.19821 = __builtin_object_size (__dest, 0);
  D.19820 = __builtin___memcpy_chk (__dest, __src, __len, D.19821);
  return D.19820;
}