main ()
{
  int i.0;
  int D.17201;
  sizetype D.17202;
  sizetype i.1;
  bitsizetype D.17204;
  bitsizetype D.17205;
  sizetype D.17206;
  int[0:D.17202] * a.2;
  int D.17208;
  int D.17209;
  int[0:D.17202] * D.17210;
  unsigned int i.3;
  void * saved_stack.4;
  long int D.17213;
  unsigned int D.17214;
  long int D.17215;
  long int D.17216;
  int D.17217;
  int i;

  i = 0;
  goto <D.17189>;
  <D.17188>:
  {
    int a[0:D.17202] [value-expr: *a.2];
    int j;

    saved_stack.4 = __builtin_stack_save ();
    try
      {
        i.0 = i;
        D.17201 = i.0 + -1;
        D.17202 = (sizetype) D.17201;
        i.1 = (sizetype) i.0;
        D.17204 = (bitsizetype) i.1;
        D.17205 = D.17204 * 32;
        i.1 = (sizetype) i.0;
        D.17206 = i.1 * 4;
        i.1 = (sizetype) i.0;
        D.17204 = (bitsizetype) i.1;
        D.17205 = D.17204 * 32;
        i.1 = (sizetype) i.0;
        D.17206 = i.1 * 4;
        a.2 = __builtin_alloca_with_align (D.17206, 32);
        j = 0;
        goto <D.17186>;
        <D.17185>:
        D.17208 = i - j;
        D.17209 = D.17208 + -1;
        *a.2[j] = D.17209;
        j = j + 1;
        <D.17186>:
        if (j < i) goto <D.17185>; else goto <D.17187>;
        <D.17187>:
        D.17210 = a.2;
        i.3 = (unsigned int) i;
        compare_sorts (D.17210, i.3, 4, compare_ints);
      }
    finally
      {
        __builtin_stack_restore (saved_stack.4);
      }
  }
  i = i + 1;
  <D.17189>:
  if (i <= 3999) goto <D.17188>; else goto <D.17190>;
  <D.17190>:
  D.17213 = time (0B);
  D.17214 = (unsigned int) D.17213;
  srandom (D.17214);
  i = 0;
  goto <D.17197>;
  <D.17196>:
  {
    struct teststruct_t a[200];
    int j;

    try
      {
        j = 0;
        goto <D.17194>;
        <D.17193>:
        D.17215 = random ();
        a[j].key = D.17215;
        D.17216 = random ();
        a[j].val = D.17216;
        j = j + 1;
        <D.17194>:
        if (j <= 199) goto <D.17193>; else goto <D.17195>;
        <D.17195>:
        compare_sorts (&a, 200, 8, compare_teststructs);
      }
    finally
      {
        a = {CLOBBER};
      }
  }
  i = i + 1;
  <D.17197>:
  if (i <= 1999) goto <D.17196>; else goto <D.17198>;
  <D.17198>:
  D.17217 = 0;
  return D.17217;
}


compare_teststructs (const void * pa, const void * pb)
{
  int D.17221;
  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.17219>; else goto <D.17220>;
  <D.17219>:
  D.17221 = -1;
  return D.17221;
  <D.17220>:
  if (a == b) goto <D.17222>; else goto <D.17223>;
  <D.17222>:
  D.17221 = 0;
  return D.17221;
  <D.17223>:
  D.17221 = 1;
  return D.17221;
}


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

  a = MEM[(const int *)pa];
  b = MEM[(const int *)pb];
  if (a < b) goto <D.17225>; else goto <D.17226>;
  <D.17225>:
  D.17227 = -1;
  return D.17227;
  <D.17226>:
  if (a == b) goto <D.17228>; else goto <D.17229>;
  <D.17228>:
  D.17227 = 0;
  return D.17227;
  <D.17229>:
  D.17227 = 1;
  return D.17227;
}


compare_sorts (void * base, size_t nel, size_t width, int (*<T4b4>) (const void *, const void *) compar)
{
  int D.17231;
  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.17231 = memcmp (b1, b2, len);
  if (D.17231 != 0) goto <D.17232>; else goto <D.17233>;
  <D.17232>:
  __assert_fail ("!memcmp (b1, b2, len)", "test-sgen-qsort.c", 71, &__PRETTY_FUNCTION__);
  <D.17233>:
  free (b1);
  free (b2);
}


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

  D.17235 = __builtin_object_size (__dest, 0);
  D.17234 = __builtin___memcpy_chk (__dest, __src, __len, D.17235);
  return D.17234;
}