#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ abort();
void test_reductions_minmax(void) {
  const int n = 1000;
  int i;
  float array[n];
  for (i = 0; i < n; i++)
    array[i] = i;
  {
    float res, vres;
    res = (n + 1);
#pragma acc parallel num_gangs(ng) copy(res)

#pragma acc loop gang reduction(min : res)
    for (i = 0; i < n; i++)
      res = (((res) < ((array[i]))) ? (res) : ((array[i])));
    vres = (n + 1);
    for (i = 0; i < n; i++)
      vres = (((vres) < ((array[i]))) ? (vres) : ((array[i])));
    if (res != vres)
      abort();
  };
  {
    float res, vres;
    res = (-1);
#pragma acc parallel num_gangs(ng) copy(res)

#pragma acc loop gang reduction(max : res)
    for (i = 0; i < n; i++)
      res = (((res) > ((array[i]))) ? (res) : ((array[i])));
    vres = (-1);
    for (i = 0; i < n; i++)
      vres = (((vres) > ((array[i]))) ? (vres) : ((array[i])));
    if (res != vres)
      abort();
  };
  {
    float res, vres;
    res = (n + 1);
#pragma acc parallel num_workers(nw) copy(res)

#pragma acc loop worker reduction(min : res)
    for (i = 0; i < n; i++)
      res = (((res) < ((array[i]))) ? (res) : ((array[i])));
    vres = (n + 1);
    for (i = 0; i < n; i++)
      vres = (((vres) < ((array[i]))) ? (vres) : ((array[i])));
    if (res != vres)
      abort();
  };
  {
    float res, vres;
    res = (-1);
#pragma acc parallel num_workers(nw) copy(res)

#pragma acc loop worker reduction(max : res)
    for (i = 0; i < n; i++)
      res = (((res) > ((array[i]))) ? (res) : ((array[i])));
    vres = (-1);
    for (i = 0; i < n; i++)
      vres = (((vres) > ((array[i]))) ? (vres) : ((array[i])));
    if (res != vres)
      abort();
  };
  {
    float res, vres;
    res = (n + 1);
#pragma acc parallel vector_length(vl) copy(res)

#pragma acc loop vector reduction(min : res)
    for (i = 0; i < n; i++)
      res = (((res) < ((array[i]))) ? (res) : ((array[i])));
    vres = (n + 1);
    for (i = 0; i < n; i++)
      vres = (((vres) < ((array[i]))) ? (vres) : ((array[i])));
    if (res != vres)
      abort();
  };
  {
    float res, vres;
    res = (-1);
#pragma acc parallel vector_length(vl) copy(res)

#pragma acc loop vector reduction(max : res)
    for (i = 0; i < n; i++)
      res = (((res) > ((array[i]))) ? (res) : ((array[i])));
    vres = (-1);
    for (i = 0; i < n; i++)
      vres = (((vres) > ((array[i]))) ? (vres) : ((array[i])));
    if (res != vres)
      abort();
  };
  {
    float res, vres;
    res = (n + 1);
#pragma acc parallel num_gangs(ng) num_workers(nw) vector_length(vl) copy(res)

#pragma acc loop gang worker vector reduction(min : res)
    for (i = 0; i < n; i++)
      res = (((res) < ((array[i]))) ? (res) : ((array[i])));
    vres = (n + 1);
    for (i = 0; i < n; i++)
      vres = (((vres) < ((array[i]))) ? (vres) : ((array[i])));
    if (res != vres)
      abort();
  };
  {
    float res, vres;
    res = (-1);
#pragma acc parallel num_gangs(ng) num_workers(nw) vector_length(vl) copy(res)

#pragma acc loop gang worker vector reduction(max : res)
    for (i = 0; i < n; i++)
      res = (((res) > ((array[i]))) ? (res) : ((array[i])));
    vres = (-1);
    for (i = 0; i < n; i++)
      vres = (((vres) > ((array[i]))) ? (vres) : ((array[i])));
    if (res != vres)
      abort();
  };
}


x86 assembly (clang, -O0):
<test_reductions_minmax>:
push   %rbp
mov    %rsp,%rbp
sub    $0x1030,%rsp
movl   $0x3e8,-0x4(%rbp)
mov    %rsp,%rax
mov    %rax,-0x10(%rbp)
movl   $0x0,-0x8(%rbp)
cmpl   $0x3e8,-0x8(%rbp)
jge    115d <test_reductions_minmax+0x4d>
cvtsi2ssl -0x8(%rbp),%xmm0
movslq -0x8(%rbp),%rax
movss  %xmm0,-0xff0(%rbp,%rax,4)
ff ff
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    1130 <test_reductions_minmax+0x20>
movss  0xe9b(%rip),%xmm0
movss  %xmm0,-0x14(%rbp)
movl   $0x0,-0x8(%rbp)
cmpl   $0x3e8,-0x8(%rbp)
jge    11db <test_reductions_minmax+0xcb>
movss  -0x14(%rbp),%xmm1
movslq -0x8(%rbp),%rax
movss  -0xff0(%rbp,%rax,4),%xmm0
ff ff
ucomiss %xmm1,%xmm0
jbe    11ab <test_reductions_minmax+0x9b>
movss  -0x14(%rbp),%xmm0
movss  %xmm0,-0xff4(%rbp)
ff
jmp    11c0 <test_reductions_minmax+0xb0>
movslq -0x8(%rbp),%rax
movss  -0xff0(%rbp,%rax,4),%xmm0
ff ff
movss  %xmm0,-0xff4(%rbp)
ff
movss  -0xff4(%rbp),%xmm0
ff
movss  %xmm0,-0x14(%rbp)
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    1171 <test_reductions_minmax+0x61>
movss  0xe1d(%rip),%xmm0
movss  %xmm0,-0x18(%rbp)
movl   $0x0,-0x8(%rbp)
cmpl   $0x3e8,-0x8(%rbp)
jge    1259 <test_reductions_minmax+0x149>
movss  -0x18(%rbp),%xmm1
movslq -0x8(%rbp),%rax
movss  -0xff0(%rbp,%rax,4),%xmm0
ff ff
ucomiss %xmm1,%xmm0
jbe    1229 <test_reductions_minmax+0x119>
movss  -0x18(%rbp),%xmm0
movss  %xmm0,-0xff8(%rbp)
ff
jmp    123e <test_reductions_minmax+0x12e>
movslq -0x8(%rbp),%rax
movss  -0xff0(%rbp,%rax,4),%xmm0
ff ff
movss  %xmm0,-0xff8(%rbp)
ff
movss  -0xff8(%rbp),%xmm0
ff
movss  %xmm0,-0x18(%rbp)
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    11ef <test_reductions_minmax+0xdf>
movss  -0x14(%rbp),%xmm0
ucomiss -0x18(%rbp),%xmm0
jne    1273 <test_reductions_minmax+0x163>
jp     1273 <test_reductions_minmax+0x163>
jmp    127a <test_reductions_minmax+0x16a>
mov    $0x0,%al
call   1030 <abort@plt>
movss  0xd82(%rip),%xmm0
movss  %xmm0,-0x1c(%rbp)
movl   $0x0,-0x8(%rbp)
cmpl   $0x3e8,-0x8(%rbp)
jge    12f4 <test_reductions_minmax+0x1e4>
movss  -0x1c(%rbp),%xmm0
movslq -0x8(%rbp),%rax
ucomiss -0xff0(%rbp,%rax,4),%xmm0
ff
jbe    12c4 <test_reductions_minmax+0x1b4>
movss  -0x1c(%rbp),%xmm0
movss  %xmm0,-0xffc(%rbp)
ff
jmp    12d9 <test_reductions_minmax+0x1c9>
movslq -0x8(%rbp),%rax
movss  -0xff0(%rbp,%rax,4),%xmm0
ff ff
movss  %xmm0,-0xffc(%rbp)
ff
movss  -0xffc(%rbp),%xmm0
ff
movss  %xmm0,-0x1c(%rbp)
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    128e <test_reductions_minmax+0x17e>
movss  0xd08(%rip),%xmm0
movss  %xmm0,-0x20(%rbp)
movl   $0x0,-0x8(%rbp)
cmpl   $0x3e8,-0x8(%rbp)
jge    136e <test_reductions_minmax+0x25e>
movss  -0x20(%rbp),%xmm0
movslq -0x8(%rbp),%rax
ucomiss -0xff0(%rbp,%rax,4),%xmm0
ff
jbe    133e <test_reductions_minmax+0x22e>
movss  -0x20(%rbp),%xmm0
movss  %xmm0,-0x1000(%rbp)
ff
jmp    1353 <test_reductions_minmax+0x243>
movslq -0x8(%rbp),%rax
movss  -0xff0(%rbp,%rax,4),%xmm0
ff ff
movss  %xmm0,-0x1000(%rbp)
ff
movss  -0x1000(%rbp),%xmm0
ff
movss  %xmm0,-0x20(%rbp)
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    1308 <test_reductions_minmax+0x1f8>
movss  -0x1c(%rbp),%xmm0
ucomiss -0x20(%rbp),%xmm0
jne    1388 <test_reductions_minmax+0x278>
jp     1388 <test_reductions_minmax+0x278>
jmp    138f <test_reductions_minmax+0x27f>
mov    $0x0,%al
call   1030 <abort@plt>
movss  0xc69(%rip),%xmm0
movss  %xmm0,-0x24(%rbp)
movl   $0x0,-0x8(%rbp)
cmpl   $0x3e8,-0x8(%rbp)
jge    140d <test_reductions_minmax+0x2fd>
movss  -0x24(%rbp),%xmm1
movslq -0x8(%rbp),%rax
movss  -0xff0(%rbp,%rax,4),%xmm0
ff ff
ucomiss %xmm1,%xmm0
jbe    13dd <test_reductions_minmax+0x2cd>
movss  -0x24(%rbp),%xmm0
movss  %xmm0,-0x1004(%rbp)
ff
jmp    13f2 <test_reductions_minmax+0x2e2>
movslq -0x8(%rbp),%rax
movss  -0xff0(%rbp,%rax,4),%xmm0
ff ff
movss  %xmm0,-0x1004(%rbp)
ff
movss  -0x1004(%rbp),%xmm0
ff
movss  %xmm0,-0x24(%rbp)
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    13a3 <test_reductions_minmax+0x293>
movss  0xbeb(%rip),%xmm0
movss  %xmm0,-0x28(%rbp)
movl   $0x0,-0x8(%rbp)
cmpl   $0x3e8,-0x8(%rbp)
jge    148b <test_reductions_minmax+0x37b>
movss  -0x28(%rbp),%xmm1
movslq -0x8(%rbp),%rax
movss  -0xff0(%rbp,%rax,4),%xmm0
ff ff
ucomiss %xmm1,%xmm0
jbe    145b <test_reductions_minmax+0x34b>
movss  -0x28(%rbp),%xmm0
movss  %xmm0,-0x1008(%rbp)
ff
jmp    1470 <test_reductions_minmax+0x360>
movslq -0x8(%rbp),%rax
movss  -0xff0(%rbp,%rax,4),%xmm0
ff ff
movss  %xmm0,-0x1008(%rbp)
ff
movss  -0x1008(%rbp),%xmm0
ff
movss  %xmm0,-0x28(%rbp)
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    1421 <test_reductions_minmax+0x311>
movss  -0x24(%rbp),%xmm0
ucomiss -0x28(%rbp),%xmm0
jne    14a5 <test_reductions_minmax+0x395>
jp     14a5 <test_reductions_minmax+0x395>
jmp    14ac <test_reductions_minmax+0x39c>
mov    $0x0,%al
call   1030 <abort@plt>
movss  0xb50(%rip),%xmm0
movss  %xmm0,-0x2c(%rbp)
movl   $0x0,-0x8(%rbp)
cmpl   $0x3e8,-0x8(%rbp)
jge    1526 <test_reductions_minmax+0x416>
movss  -0x2c(%rbp),%xmm0
movslq -0x8(%rbp),%rax
ucomiss -0xff0(%rbp,%rax,4),%xmm0
ff
jbe    14f6 <test_reductions_minmax+0x3e6>
movss  -0x2c(%rbp),%xmm0
movss  %xmm0,-0x100c(%rbp)
ff
jmp    150b <test_reductions_minmax+0x3fb>
movslq -0x8(%rbp),%rax
movss  -0xff0(%rbp,%rax,4),%xmm0
ff ff
movss  %xmm0,-0x100c(%rbp)
ff
movss  -0x100c(%rbp),%xmm0
ff
movss  %xmm0,-0x2c(%rbp)
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    14c0 <test_reductions_minmax+0x3b0>
movss  0xad6(%rip),%xmm0
movss  %xmm0,-0x30(%rbp)
movl   $0x0,-0x8(%rbp)
cmpl   $0x3e8,-0x8(%rbp)
jge    15a0 <test_reductions_minmax+0x490>
movss  -0x30(%rbp),%xmm0
movslq -0x8(%rbp),%rax
ucomiss -0xff0(%rbp,%rax,4),%xmm0
ff
jbe    1570 <test_reductions_minmax+0x460>
movss  -0x30(%rbp),%xmm0
movss  %xmm0,-0x1010(%rbp)
ff
jmp    1585 <test_reductions_minmax+0x475>
movslq -0x8(%rbp),%rax
movss  -0xff0(%rbp,%rax,4),%xmm0
ff ff
movss  %xmm0,-0x1010(%rbp)
ff
movss  -0x1010(%rbp),%xmm0
ff
movss  %xmm0,-0x30(%rbp)
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    153a <test_reductions_minmax+0x42a>
movss  -0x2c(%rbp),%xmm0
ucomiss -0x30(%rbp),%xmm0
jne    15ba <test_reductions_minmax+0x4aa>
jp     15ba <test_reductions_minmax+0x4aa>
jmp    15c1 <test_reductions_minmax+0x4b1>
mov    $0x0,%al
call   1030 <abort@plt>
movss  0xa37(%rip),%xmm0
movss  %xmm0,-0x34(%rbp)
movl   $0x0,-0x8(%rbp)
cmpl   $0x3e8,-0x8(%rbp)
jge    163f <test_reductions_minmax+0x52f>
movss  -0x34(%rbp),%xmm1
movslq -0x8(%rbp),%rax
movss  -0xff0(%rbp,%rax,4),%xmm0
ff ff
ucomiss %xmm1,%xmm0
jbe    160f <test_reductions_minmax+0x4ff>
movss  -0x34(%rbp),%xmm0
movss  %xmm0,-0x1014(%rbp)
ff
jmp    1624 <test_reductions_minmax+0x514>
movslq -0x8(%rbp),%rax
movss  -0xff0(%rbp,%rax,4),%xmm0
ff ff
movss  %xmm0,-0x1014(%rbp)
ff
movss  -0x1014(%rbp),%xmm0
ff
movss  %xmm0,-0x34(%rbp)
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    15d5 <test_reductions_minmax+0x4c5>
movss  0x9b9(%rip),%xmm0
movss  %xmm0,-0x38(%rbp)
movl   $0x0,-0x8(%rbp)
cmpl   $0x3e8,-0x8(%rbp)
jge    16bd <test_reductions_minmax+0x5ad>
movss  -0x38(%rbp),%xmm1
movslq -0x8(%rbp),%rax
movss  -0xff0(%rbp,%rax,4),%xmm0
ff ff
ucomiss %xmm1,%xmm0
jbe    168d <test_reductions_minmax+0x57d>
movss  -0x38(%rbp),%xmm0
movss  %xmm0,-0x1018(%rbp)
ff
jmp    16a2 <test_reductions_minmax+0x592>
movslq -0x8(%rbp),%rax
movss  -0xff0(%rbp,%rax,4),%xmm0
ff ff
movss  %xmm0,-0x1018(%rbp)
ff
movss  -0x1018(%rbp),%xmm0
ff
movss  %xmm0,-0x38(%rbp)
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    1653 <test_reductions_minmax+0x543>
movss  -0x34(%rbp),%xmm0
ucomiss -0x38(%rbp),%xmm0
jne    16d7 <test_reductions_minmax+0x5c7>
jp     16d7 <test_reductions_minmax+0x5c7>
jmp    16de <test_reductions_minmax+0x5ce>
mov    $0x0,%al
call   1030 <abort@plt>
movss  0x91e(%rip),%xmm0
movss  %xmm0,-0x3c(%rbp)
movl   $0x0,-0x8(%rbp)
cmpl   $0x3e8,-0x8(%rbp)
jge    1758 <test_reductions_minmax+0x648>
movss  -0x3c(%rbp),%xmm0
movslq -0x8(%rbp),%rax
ucomiss -0xff0(%rbp,%rax,4),%xmm0
ff
jbe    1728 <test_reductions_minmax+0x618>
movss  -0x3c(%rbp),%xmm0
movss  %xmm0,-0x101c(%rbp)
ff
jmp    173d <test_reductions_minmax+0x62d>
movslq -0x8(%rbp),%rax
movss  -0xff0(%rbp,%rax,4),%xmm0
ff ff
movss  %xmm0,-0x101c(%rbp)
ff
movss  -0x101c(%rbp),%xmm0
ff
movss  %xmm0,-0x3c(%rbp)
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    16f2 <test_reductions_minmax+0x5e2>
movss  0x8a4(%rip),%xmm0
movss  %xmm0,-0x40(%rbp)
movl   $0x0,-0x8(%rbp)
cmpl   $0x3e8,-0x8(%rbp)
jge    17d2 <test_reductions_minmax+0x6c2>
movss  -0x40(%rbp),%xmm0
movslq -0x8(%rbp),%rax
ucomiss -0xff0(%rbp,%rax,4),%xmm0
ff
jbe    17a2 <test_reductions_minmax+0x692>
movss  -0x40(%rbp),%xmm0
movss  %xmm0,-0x1020(%rbp)
ff
jmp    17b7 <test_reductions_minmax+0x6a7>
movslq -0x8(%rbp),%rax
movss  -0xff0(%rbp,%rax,4),%xmm0
ff ff
movss  %xmm0,-0x1020(%rbp)
ff
movss  -0x1020(%rbp),%xmm0
ff
movss  %xmm0,-0x40(%rbp)
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    176c <test_reductions_minmax+0x65c>
movss  -0x3c(%rbp),%xmm0
ucomiss -0x40(%rbp),%xmm0
jne    17ec <test_reductions_minmax+0x6dc>
jp     17ec <test_reductions_minmax+0x6dc>
jmp    17f3 <test_reductions_minmax+0x6e3>
mov    $0x0,%al
call   1030 <abort@plt>
movss  0x805(%rip),%xmm0
movss  %xmm0,-0x44(%rbp)
movl   $0x0,-0x8(%rbp)
cmpl   $0x3e8,-0x8(%rbp)
jge    1871 <test_reductions_minmax+0x761>
movss  -0x44(%rbp),%xmm1
movslq -0x8(%rbp),%rax
movss  -0xff0(%rbp,%rax,4),%xmm0
ff ff
ucomiss %xmm1,%xmm0
jbe    1841 <test_reductions_minmax+0x731>
movss  -0x44(%rbp),%xmm0
movss  %xmm0,-0x1024(%rbp)
ff
jmp    1856 <test_reductions_minmax+0x746>
movslq -0x8(%rbp),%rax
movss  -0xff0(%rbp,%rax,4),%xmm0
ff ff
movss  %xmm0,-0x1024(%rbp)
ff
movss  -0x1024(%rbp),%xmm0
ff
movss  %xmm0,-0x44(%rbp)
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    1807 <test_reductions_minmax+0x6f7>
movss  0x787(%rip),%xmm0
movss  %xmm0,-0x48(%rbp)
movl   $0x0,-0x8(%rbp)
cmpl   $0x3e8,-0x8(%rbp)
jge    18ef <test_reductions_minmax+0x7df>
movss  -0x48(%rbp),%xmm1
movslq -0x8(%rbp),%rax
movss  -0xff0(%rbp,%rax,4),%xmm0
ff ff
ucomiss %xmm1,%xmm0
jbe    18bf <test_reductions_minmax+0x7af>
movss  -0x48(%rbp),%xmm0
movss  %xmm0,-0x1028(%rbp)
ff
jmp    18d4 <test_reductions_minmax+0x7c4>
movslq -0x8(%rbp),%rax
movss  -0xff0(%rbp,%rax,4),%xmm0
ff ff
movss  %xmm0,-0x1028(%rbp)
ff
movss  -0x1028(%rbp),%xmm0
ff
movss  %xmm0,-0x48(%rbp)
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    1885 <test_reductions_minmax+0x775>
movss  -0x44(%rbp),%xmm0
ucomiss -0x48(%rbp),%xmm0
jne    1909 <test_reductions_minmax+0x7f9>
jp     1909 <test_reductions_minmax+0x7f9>
jmp    1910 <test_reductions_minmax+0x800>
mov    $0x0,%al
call   1030 <abort@plt>
movss  0x6ec(%rip),%xmm0
movss  %xmm0,-0x4c(%rbp)
movl   $0x0,-0x8(%rbp)
cmpl   $0x3e8,-0x8(%rbp)
jge    198a <test_reductions_minmax+0x87a>
movss  -0x4c(%rbp),%xmm0
movslq -0x8(%rbp),%rax
ucomiss -0xff0(%rbp,%rax,4),%xmm0
ff
jbe    195a <test_reductions_minmax+0x84a>
movss  -0x4c(%rbp),%xmm0
movss  %xmm0,-0x102c(%rbp)
ff
jmp    196f <test_reductions_minmax+0x85f>
movslq -0x8(%rbp),%rax
movss  -0xff0(%rbp,%rax,4),%xmm0
ff ff
movss  %xmm0,-0x102c(%rbp)
ff
movss  -0x102c(%rbp),%xmm0
ff
movss  %xmm0,-0x4c(%rbp)
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    1924 <test_reductions_minmax+0x814>
movss  0x672(%rip),%xmm0
movss  %xmm0,-0x50(%rbp)
movl   $0x0,-0x8(%rbp)
cmpl   $0x3e8,-0x8(%rbp)
jge    1a04 <test_reductions_minmax+0x8f4>
movss  -0x50(%rbp),%xmm0
movslq -0x8(%rbp),%rax
ucomiss -0xff0(%rbp,%rax,4),%xmm0
ff
jbe    19d4 <test_reductions_minmax+0x8c4>
movss  -0x50(%rbp),%xmm0
movss  %xmm0,-0x1030(%rbp)
ff
jmp    19e9 <test_reductions_minmax+0x8d9>
movslq -0x8(%rbp),%rax
movss  -0xff0(%rbp,%rax,4),%xmm0
ff ff
movss  %xmm0,-0x1030(%rbp)
ff
movss  -0x1030(%rbp),%xmm0
ff
movss  %xmm0,-0x50(%rbp)
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    199e <test_reductions_minmax+0x88e>
movss  -0x4c(%rbp),%xmm0
ucomiss -0x50(%rbp),%xmm0
jne    1a1e <test_reductions_minmax+0x90e>
jp     1a1e <test_reductions_minmax+0x90e>
jmp    1a25 <test_reductions_minmax+0x915>
mov    $0x0,%al
call   1030 <abort@plt>
mov    -0x10(%rbp),%rax
mov    %rax,%rsp
add    $0x1030,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<test_reductions_minmax>:
sub    $0xfa8,%rsp
movdqa 0xee1(%rip),%xmm0
mov    $0xc,%eax
movdqa 0xee4(%rip),%xmm1
movdqa 0xeec(%rip),%xmm2
movdqa 0xef4(%rip),%xmm3
movdqa 0xefc(%rip),%xmm4
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movdqa %xmm0,%xmm5
paddd  %xmm1,%xmm5
cvtdq2ps %xmm0,%xmm6
cvtdq2ps %xmm5,%xmm5
movaps %xmm6,-0x30(%rsp,%rax,4)
movaps %xmm5,-0x20(%rsp,%rax,4)
cmp    $0x3ec,%rax
je     1199 <test_reductions_minmax+0x89>
movdqa %xmm0,%xmm5
paddd  %xmm2,%xmm5
movdqa %xmm0,%xmm6
paddd  %xmm3,%xmm6
cvtdq2ps %xmm5,%xmm5
cvtdq2ps %xmm6,%xmm6
movaps %xmm5,-0x10(%rsp,%rax,4)
movaps %xmm6,(%rsp,%rax,4)
paddd  %xmm4,%xmm0
add    $0x10,%rax
jmp    1150 <test_reductions_minmax+0x40>
movss  0xeaf(%rip),%xmm0
mov    $0x4,%eax
cs nopw 0x0(%rax,%rax,1)
minss  -0x10(%rsp,%rax,4),%xmm0
minss  -0xc(%rsp,%rax,4),%xmm0
minss  -0x8(%rsp,%rax,4),%xmm0
minss  -0x4(%rsp,%rax,4),%xmm0
minss  (%rsp,%rax,4),%xmm0
add    $0x5,%rax
cmp    $0x3ec,%rax
jne    11b0 <test_reductions_minmax+0xa0>
movss  0xe6f(%rip),%xmm1
mov    $0x4,%eax
cs nopw 0x0(%rax,%rax,1)
minss  -0x10(%rsp,%rax,4),%xmm1
minss  -0xc(%rsp,%rax,4),%xmm1
minss  -0x8(%rsp,%rax,4),%xmm1
minss  -0x4(%rsp,%rax,4),%xmm1
minss  (%rsp,%rax,4),%xmm1
add    $0x5,%rax
cmp    $0x3ec,%rax
jne    11f0 <test_reductions_minmax+0xe0>
ucomiss %xmm1,%xmm0
jne    1618 <test_reductions_minmax+0x508>
jp     1618 <test_reductions_minmax+0x508>
movss  0xe24(%rip),%xmm0
mov    $0x4,%eax
cs nopw 0x0(%rax,%rax,1)
nop
maxss  -0x10(%rsp,%rax,4),%xmm0
maxss  -0xc(%rsp,%rax,4),%xmm0
maxss  -0x8(%rsp,%rax,4),%xmm0
maxss  -0x4(%rsp,%rax,4),%xmm0
maxss  (%rsp,%rax,4),%xmm0
add    $0x5,%rax
cmp    $0x3ec,%rax
jne    1240 <test_reductions_minmax+0x130>
movss  0xde3(%rip),%xmm1
mov    $0x4,%eax
cs nopw 0x0(%rax,%rax,1)
maxss  -0x10(%rsp,%rax,4),%xmm1
maxss  -0xc(%rsp,%rax,4),%xmm1
maxss  -0x8(%rsp,%rax,4),%xmm1
maxss  -0x4(%rsp,%rax,4),%xmm1
maxss  (%rsp,%rax,4),%xmm1
add    $0x5,%rax
cmp    $0x3ec,%rax
jne    1280 <test_reductions_minmax+0x170>
ucomiss %xmm1,%xmm0
jne    1618 <test_reductions_minmax+0x508>
jp     1618 <test_reductions_minmax+0x508>
movss  0xd90(%rip),%xmm0
mov    $0x4,%eax
cs nopw 0x0(%rax,%rax,1)
nop
minss  -0x10(%rsp,%rax,4),%xmm0
minss  -0xc(%rsp,%rax,4),%xmm0
minss  -0x8(%rsp,%rax,4),%xmm0
minss  -0x4(%rsp,%rax,4),%xmm0
minss  (%rsp,%rax,4),%xmm0
add    $0x5,%rax
cmp    $0x3ec,%rax
jne    12d0 <test_reductions_minmax+0x1c0>
movss  0xd4f(%rip),%xmm1
mov    $0x4,%eax
cs nopw 0x0(%rax,%rax,1)
minss  -0x10(%rsp,%rax,4),%xmm1
minss  -0xc(%rsp,%rax,4),%xmm1
minss  -0x8(%rsp,%rax,4),%xmm1
minss  -0x4(%rsp,%rax,4),%xmm1
minss  (%rsp,%rax,4),%xmm1
add    $0x5,%rax
cmp    $0x3ec,%rax
jne    1310 <test_reductions_minmax+0x200>
ucomiss %xmm1,%xmm0
jne    1618 <test_reductions_minmax+0x508>
jp     1618 <test_reductions_minmax+0x508>
movss  0xd04(%rip),%xmm0
mov    $0x4,%eax
cs nopw 0x0(%rax,%rax,1)
nop
maxss  -0x10(%rsp,%rax,4),%xmm0
maxss  -0xc(%rsp,%rax,4),%xmm0
maxss  -0x8(%rsp,%rax,4),%xmm0
maxss  -0x4(%rsp,%rax,4),%xmm0
maxss  (%rsp,%rax,4),%xmm0
add    $0x5,%rax
cmp    $0x3ec,%rax
jne    1360 <test_reductions_minmax+0x250>
movss  0xcc3(%rip),%xmm1
mov    $0x4,%eax
cs nopw 0x0(%rax,%rax,1)
maxss  -0x10(%rsp,%rax,4),%xmm1
maxss  -0xc(%rsp,%rax,4),%xmm1
maxss  -0x8(%rsp,%rax,4),%xmm1
maxss  -0x4(%rsp,%rax,4),%xmm1
maxss  (%rsp,%rax,4),%xmm1
add    $0x5,%rax
cmp    $0x3ec,%rax
jne    13a0 <test_reductions_minmax+0x290>
ucomiss %xmm1,%xmm0
jne    1618 <test_reductions_minmax+0x508>
jp     1618 <test_reductions_minmax+0x508>
movss  0xc70(%rip),%xmm0
mov    $0x4,%eax
cs nopw 0x0(%rax,%rax,1)
nop
minss  -0x10(%rsp,%rax,4),%xmm0
minss  -0xc(%rsp,%rax,4),%xmm0
minss  -0x8(%rsp,%rax,4),%xmm0
minss  -0x4(%rsp,%rax,4),%xmm0
minss  (%rsp,%rax,4),%xmm0
add    $0x5,%rax
cmp    $0x3ec,%rax
jne    13f0 <test_reductions_minmax+0x2e0>
movss  0xc2f(%rip),%xmm1
mov    $0x4,%eax
cs nopw 0x0(%rax,%rax,1)
minss  -0x10(%rsp,%rax,4),%xmm1
minss  -0xc(%rsp,%rax,4),%xmm1
minss  -0x8(%rsp,%rax,4),%xmm1
minss  -0x4(%rsp,%rax,4),%xmm1
minss  (%rsp,%rax,4),%xmm1
add    $0x5,%rax
cmp    $0x3ec,%rax
jne    1430 <test_reductions_minmax+0x320>
ucomiss %xmm1,%xmm0
jne    1618 <test_reductions_minmax+0x508>
jp     1618 <test_reductions_minmax+0x508>
movss  0xbe4(%rip),%xmm0
mov    $0x4,%eax
cs nopw 0x0(%rax,%rax,1)
nop
maxss  -0x10(%rsp,%rax,4),%xmm0
maxss  -0xc(%rsp,%rax,4),%xmm0
maxss  -0x8(%rsp,%rax,4),%xmm0
maxss  -0x4(%rsp,%rax,4),%xmm0
maxss  (%rsp,%rax,4),%xmm0
add    $0x5,%rax
cmp    $0x3ec,%rax
jne    1480 <test_reductions_minmax+0x370>
movss  0xba3(%rip),%xmm1
mov    $0x4,%eax
cs nopw 0x0(%rax,%rax,1)
maxss  -0x10(%rsp,%rax,4),%xmm1
maxss  -0xc(%rsp,%rax,4),%xmm1
maxss  -0x8(%rsp,%rax,4),%xmm1
maxss  -0x4(%rsp,%rax,4),%xmm1
maxss  (%rsp,%rax,4),%xmm1
add    $0x5,%rax
cmp    $0x3ec,%rax
jne    14c0 <test_reductions_minmax+0x3b0>
ucomiss %xmm1,%xmm0
jne    1618 <test_reductions_minmax+0x508>
jp     1618 <test_reductions_minmax+0x508>
movss  0xb50(%rip),%xmm0
mov    $0x4,%eax
cs nopw 0x0(%rax,%rax,1)
nop
minss  -0x10(%rsp,%rax,4),%xmm0
minss  -0xc(%rsp,%rax,4),%xmm0
minss  -0x8(%rsp,%rax,4),%xmm0
minss  -0x4(%rsp,%rax,4),%xmm0
minss  (%rsp,%rax,4),%xmm0
add    $0x5,%rax
cmp    $0x3ec,%rax
jne    1510 <test_reductions_minmax+0x400>
movss  0xb0f(%rip),%xmm1
mov    $0x4,%eax
cs nopw 0x0(%rax,%rax,1)
minss  -0x10(%rsp,%rax,4),%xmm1
minss  -0xc(%rsp,%rax,4),%xmm1
minss  -0x8(%rsp,%rax,4),%xmm1
minss  -0x4(%rsp,%rax,4),%xmm1
minss  (%rsp,%rax,4),%xmm1
add    $0x5,%rax
cmp    $0x3ec,%rax
jne    1550 <test_reductions_minmax+0x440>
ucomiss %xmm1,%xmm0
jne    1618 <test_reductions_minmax+0x508>
jp     1618 <test_reductions_minmax+0x508>
movss  0xac4(%rip),%xmm0
mov    $0x4,%eax
cs nopw 0x0(%rax,%rax,1)
nop
maxss  -0x10(%rsp,%rax,4),%xmm0
maxss  -0xc(%rsp,%rax,4),%xmm0
maxss  -0x8(%rsp,%rax,4),%xmm0
maxss  -0x4(%rsp,%rax,4),%xmm0
maxss  (%rsp,%rax,4),%xmm0
add    $0x5,%rax
cmp    $0x3ec,%rax
jne    15a0 <test_reductions_minmax+0x490>
movss  0xa83(%rip),%xmm1
mov    $0x4,%eax
cs nopw 0x0(%rax,%rax,1)
maxss  -0x10(%rsp,%rax,4),%xmm1
maxss  -0xc(%rsp,%rax,4),%xmm1
maxss  -0x8(%rsp,%rax,4),%xmm1
maxss  -0x4(%rsp,%rax,4),%xmm1
maxss  (%rsp,%rax,4),%xmm1
add    $0x5,%rax
cmp    $0x3ec,%rax
jne    15e0 <test_reductions_minmax+0x4d0>
ucomiss %xmm1,%xmm0
jne    1618 <test_reductions_minmax+0x508>
jp     1618 <test_reductions_minmax+0x508>
add    $0xfa8,%rsp
ret
xor    %eax,%eax
call   1030 <abort@plt>

LLVM IR (-O0):
define void @test_reductions_minmax() {
%1 = alloca i32
%2 = alloca i32
%3 = alloca i8*
%4 = alloca float
%5 = alloca float
%6 = alloca float
%7 = alloca float
%8 = alloca float
%9 = alloca float
%10 = alloca float
%11 = alloca float
%12 = alloca float
%13 = alloca float
%14 = alloca float
%15 = alloca float
%16 = alloca float
%17 = alloca float
%18 = alloca float
%19 = alloca float
store i32 1000, i32* %1
%20 = call i8* @llvm.stacksave()
store i8* %20, i8** %3
%21 = alloca float, i64 1000
store i32 0, i32* %2
br label %22
22: ; preds = %31, %0
%23 = load i32, i32* %2
%24 = icmp slt i32 %23, 1000
br i1 %24, label %25, label %34
25: ; preds = %22
%26 = load i32, i32* %2
%27 = sitofp i32 %26 to float
%28 = load i32, i32* %2
%29 = sext i32 %28 to i64
%30 = getelementptr inbounds float, float* %21, i64 %29
store float %27, float* %30
br label %31
31: ; preds = %25
%32 = load i32, i32* %2
%33 = add nsw i32 %32, 1
store i32 %33, i32* %2
br label %22
34: ; preds = %22
store float 1.001000e+03, float* %4
store i32 0, i32* %2
br label %35
35: ; preds = %54, %34
%36 = load i32, i32* %2
%37 = icmp slt i32 %36, 1000
br i1 %37, label %38, label %57
38: ; preds = %35
%39 = load float, float* %4
%40 = load i32, i32* %2
%41 = sext i32 %40 to i64
%42 = getelementptr inbounds float, float* %21, i64 %41
%43 = load float, float* %42
%44 = fcmp olt float %39, %43
br i1 %44, label %45, label %47
45: ; preds = %38
%46 = load float, float* %4
br label %52
47: ; preds = %38
%48 = load i32, i32* %2
%49 = sext i32 %48 to i64
%50 = getelementptr inbounds float, float* %21, i64 %49
%51 = load float, float* %50
br label %52
52: ; preds = %47, %45
%53 = phi float [ %46, %45 ], [ %51, %47 ]
store float %53, float* %4
br label %54
54: ; preds = %52
%55 = load i32, i32* %2
%56 = add nsw i32 %55, 1
store i32 %56, i32* %2
br label %35
57: ; preds = %35
store float 1.001000e+03, float* %5
store i32 0, i32* %2
br label %58
58: ; preds = %77, %57
%59 = load i32, i32* %2
%60 = icmp slt i32 %59, 1000
br i1 %60, label %61, label %80
61: ; preds = %58
%62 = load float, float* %5
%63 = load i32, i32* %2
%64 = sext i32 %63 to i64
%65 = getelementptr inbounds float, float* %21, i64 %64
%66 = load float, float* %65
%67 = fcmp olt float %62, %66
br i1 %67, label %68, label %70
68: ; preds = %61
%69 = load float, float* %5
br label %75
70: ; preds = %61
%71 = load i32, i32* %2
%72 = sext i32 %71 to i64
%73 = getelementptr inbounds float, float* %21, i64 %72
%74 = load float, float* %73
br label %75
75: ; preds = %70, %68
%76 = phi float [ %69, %68 ], [ %74, %70 ]
store float %76, float* %5
br label %77
77: ; preds = %75
%78 = load i32, i32* %2
%79 = add nsw i32 %78, 1
store i32 %79, i32* %2
br label %58
80: ; preds = %58
%81 = load float, float* %4
%82 = load float, float* %5
%83 = fcmp une float %81, %82
br i1 %83, label %84, label %86
84: ; preds = %80
%85 = call i32 (...) @abort()
unreachable
86: ; preds = %80
store float -1.000000e+00, float* %6
store i32 0, i32* %2
br label %87
87: ; preds = %106, %86
%88 = load i32, i32* %2
%89 = icmp slt i32 %88, 1000
br i1 %89, label %90, label %109
90: ; preds = %87
%91 = load float, float* %6
%92 = load i32, i32* %2
%93 = sext i32 %92 to i64
%94 = getelementptr inbounds float, float* %21, i64 %93
%95 = load float, float* %94
%96 = fcmp ogt float %91, %95
br i1 %96, label %97, label %99
97: ; preds = %90
%98 = load float, float* %6
br label %104
99: ; preds = %90
%100 = load i32, i32* %2
%101 = sext i32 %100 to i64
%102 = getelementptr inbounds float, float* %21, i64 %101
%103 = load float, float* %102
br label %104
104: ; preds = %99, %97
%105 = phi float [ %98, %97 ], [ %103, %99 ]
store float %105, float* %6
br label %106
106: ; preds = %104
%107 = load i32, i32* %2
%108 = add nsw i32 %107, 1
store i32 %108, i32* %2
br label %87
109: ; preds = %87
store float -1.000000e+00, float* %7
store i32 0, i32* %2
br label %110
110: ; preds = %129, %109
%111 = load i32, i32* %2
%112 = icmp slt i32 %111, 1000
br i1 %112, label %113, label %132
113: ; preds = %110
%114 = load float, float* %7
%115 = load i32, i32* %2
%116 = sext i32 %115 to i64
%117 = getelementptr inbounds float, float* %21, i64 %116
%118 = load float, float* %117
%119 = fcmp ogt float %114, %118
br i1 %119, label %120, label %122
120: ; preds = %113
%121 = load float, float* %7
br label %127
122: ; preds = %113
%123 = load i32, i32* %2
%124 = sext i32 %123 to i64
%125 = getelementptr inbounds float, float* %21, i64 %124
%126 = load float, float* %125
br label %127
127: ; preds = %122, %120
%128 = phi float [ %121, %120 ], [ %126, %122 ]
store float %128, float* %7
br label %129
129: ; preds = %127
%130 = load i32, i32* %2
%131 = add nsw i32 %130, 1
store i32 %131, i32* %2
br label %110
132: ; preds = %110
%133 = load float, float* %6
%134 = load float, float* %7
%135 = fcmp une float %133, %134
br i1 %135, label %136, label %138
136: ; preds = %132
%137 = call i32 (...) @abort()
unreachable
138: ; preds = %132
store float 1.001000e+03, float* %8
store i32 0, i32* %2
br label %139
139: ; preds = %158, %138
%140 = load i32, i32* %2
%141 = icmp slt i32 %140, 1000
br i1 %141, label %142, label %161
142: ; preds = %139
%143 = load float, float* %8
%144 = load i32, i32* %2
%145 = sext i32 %144 to i64
%146 = getelementptr inbounds float, float* %21, i64 %145
%147 = load float, float* %146
%148 = fcmp olt float %143, %147
br i1 %148, label %149, label %151
149: ; preds = %142
%150 = load float, float* %8
br label %156
151: ; preds = %142
%152 = load i32, i32* %2
%153 = sext i32 %152 to i64
%154 = getelementptr inbounds float, float* %21, i64 %153
%155 = load float, float* %154
br label %156
156: ; preds = %151, %149
%157 = phi float [ %150, %149 ], [ %155, %151 ]
store float %157, float* %8
br label %158
158: ; preds = %156
%159 = load i32, i32* %2
%160 = add nsw i32 %159, 1
store i32 %160, i32* %2
br label %139
161: ; preds = %139
store float 1.001000e+03, float* %9
store i32 0, i32* %2
br label %162
162: ; preds = %181, %161
%163 = load i32, i32* %2
%164 = icmp slt i32 %163, 1000
br i1 %164, label %165, label %184
165: ; preds = %162
%166 = load float, float* %9
%167 = load i32, i32* %2
%168 = sext i32 %167 to i64
%169 = getelementptr inbounds float, float* %21, i64 %168
%170 = load float, float* %169
%171 = fcmp olt float %166, %170
br i1 %171, label %172, label %174
172: ; preds = %165
%173 = load float, float* %9
br label %179
174: ; preds = %165
%175 = load i32, i32* %2
%176 = sext i32 %175 to i64
%177 = getelementptr inbounds float, float* %21, i64 %176
%178 = load float, float* %177
br label %179
179: ; preds = %174, %172
%180 = phi float [ %173, %172 ], [ %178, %174 ]
store float %180, float* %9
br label %181
181: ; preds = %179
%182 = load i32, i32* %2
%183 = add nsw i32 %182, 1
store i32 %183, i32* %2
br label %162
184: ; preds = %162
%185 = load float, float* %8
%186 = load float, float* %9
%187 = fcmp une float %185, %186
br i1 %187, label %188, label %190
188: ; preds = %184
%189 = call i32 (...) @abort()
unreachable
190: ; preds = %184
store float -1.000000e+00, float* %10
store i32 0, i32* %2
br label %191
191: ; preds = %210, %190
%192 = load i32, i32* %2
%193 = icmp slt i32 %192, 1000
br i1 %193, label %194, label %213
194: ; preds = %191
%195 = load float, float* %10
%196 = load i32, i32* %2
%197 = sext i32 %196 to i64
%198 = getelementptr inbounds float, float* %21, i64 %197
%199 = load float, float* %198
%200 = fcmp ogt float %195, %199
br i1 %200, label %201, label %203
201: ; preds = %194
%202 = load float, float* %10
br label %208
203: ; preds = %194
%204 = load i32, i32* %2
%205 = sext i32 %204 to i64
%206 = getelementptr inbounds float, float* %21, i64 %205
%207 = load float, float* %206
br label %208
208: ; preds = %203, %201
%209 = phi float [ %202, %201 ], [ %207, %203 ]
store float %209, float* %10
br label %210
210: ; preds = %208
%211 = load i32, i32* %2
%212 = add nsw i32 %211, 1
store i32 %212, i32* %2
br label %191
213: ; preds = %191
store float -1.000000e+00, float* %11
store i32 0, i32* %2
br label %214
214: ; preds = %233, %213
%215 = load i32, i32* %2
%216 = icmp slt i32 %215, 1000
br i1 %216, label %217, label %236
217: ; preds = %214
%218 = load float, float* %11
%219 = load i32, i32* %2
%220 = sext i32 %219 to i64
%221 = getelementptr inbounds float, float* %21, i64 %220
%222 = load float, float* %221
%223 = fcmp ogt float %218, %222
br i1 %223, label %224, label %226
224: ; preds = %217
%225 = load float, float* %11
br label %231
226: ; preds = %217
%227 = load i32, i32* %2
%228 = sext i32 %227 to i64
%229 = getelementptr inbounds float, float* %21, i64 %228
%230 = load float, float* %229
br label %231
231: ; preds = %226, %224
%232 = phi float [ %225, %224 ], [ %230, %226 ]
store float %232, float* %11
br label %233
233: ; preds = %231
%234 = load i32, i32* %2
%235 = add nsw i32 %234, 1
store i32 %235, i32* %2
br label %214
236: ; preds = %214
%237 = load float, float* %10
%238 = load float, float* %11
%239 = fcmp une float %237, %238
br i1 %239, label %240, label %242
240: ; preds = %236
%241 = call i32 (...) @abort()
unreachable
242: ; preds = %236
store float 1.001000e+03, float* %12
store i32 0, i32* %2
br label %243
243: ; preds = %262, %242
%244 = load i32, i32* %2
%245 = icmp slt i32 %244, 1000
br i1 %245, label %246, label %265
246: ; preds = %243
%247 = load float, float* %12
%248 = load i32, i32* %2
%249 = sext i32 %248 to i64
%250 = getelementptr inbounds float, float* %21, i64 %249
%251 = load float, float* %250
%252 = fcmp olt float %247, %251
br i1 %252, label %253, label %255
253: ; preds = %246
%254 = load float, float* %12
br label %260
255: ; preds = %246
%256 = load i32, i32* %2
%257 = sext i32 %256 to i64
%258 = getelementptr inbounds float, float* %21, i64 %257
%259 = load float, float* %258
br label %260
260: ; preds = %255, %253
%261 = phi float [ %254, %253 ], [ %259, %255 ]
store float %261, float* %12
br label %262
262: ; preds = %260
%263 = load i32, i32* %2
%264 = add nsw i32 %263, 1
store i32 %264, i32* %2
br label %243
265: ; preds = %243
store float 1.001000e+03, float* %13
store i32 0, i32* %2
br label %266
266: ; preds = %285, %265
%267 = load i32, i32* %2
%268 = icmp slt i32 %267, 1000
br i1 %268, label %269, label %288
269: ; preds = %266
%270 = load float, float* %13
%271 = load i32, i32* %2
%272 = sext i32 %271 to i64
%273 = getelementptr inbounds float, float* %21, i64 %272
%274 = load float, float* %273
%275 = fcmp olt float %270, %274
br i1 %275, label %276, label %278
276: ; preds = %269
%277 = load float, float* %13
br label %283
278: ; preds = %269
%279 = load i32, i32* %2
%280 = sext i32 %279 to i64
%281 = getelementptr inbounds float, float* %21, i64 %280
%282 = load float, float* %281
br label %283
283: ; preds = %278, %276
%284 = phi float [ %277, %276 ], [ %282, %278 ]
store float %284, float* %13
br label %285
285: ; preds = %283
%286 = load i32, i32* %2
%287 = add nsw i32 %286, 1
store i32 %287, i32* %2
br label %266
288: ; preds = %266
%289 = load float, float* %12
%290 = load float, float* %13
%291 = fcmp une float %289, %290
br i1 %291, label %292, label %294
292: ; preds = %288
%293 = call i32 (...) @abort()
unreachable
294: ; preds = %288
store float -1.000000e+00, float* %14
store i32 0, i32* %2
br label %295
295: ; preds = %314, %294
%296 = load i32, i32* %2
%297 = icmp slt i32 %296, 1000
br i1 %297, label %298, label %317
298: ; preds = %295
%299 = load float, float* %14
%300 = load i32, i32* %2
%301 = sext i32 %300 to i64
%302 = getelementptr inbounds float, float* %21, i64 %301
%303 = load float, float* %302
%304 = fcmp ogt float %299, %303
br i1 %304, label %305, label %307
305: ; preds = %298
%306 = load float, float* %14
br label %312
307: ; preds = %298
%308 = load i32, i32* %2
%309 = sext i32 %308 to i64
%310 = getelementptr inbounds float, float* %21, i64 %309
%311 = load float, float* %310
br label %312
312: ; preds = %307, %305
%313 = phi float [ %306, %305 ], [ %311, %307 ]
store float %313, float* %14
br label %314
314: ; preds = %312
%315 = load i32, i32* %2
%316 = add nsw i32 %315, 1
store i32 %316, i32* %2
br label %295
317: ; preds = %295
store float -1.000000e+00, float* %15
store i32 0, i32* %2
br label %318
318: ; preds = %337, %317
%319 = load i32, i32* %2
%320 = icmp slt i32 %319, 1000
br i1 %320, label %321, label %340
321: ; preds = %318
%322 = load float, float* %15
%323 = load i32, i32* %2
%324 = sext i32 %323 to i64
%325 = getelementptr inbounds float, float* %21, i64 %324
%326 = load float, float* %325
%327 = fcmp ogt float %322, %326
br i1 %327, label %328, label %330
328: ; preds = %321
%329 = load float, float* %15
br label %335
330: ; preds = %321
%331 = load i32, i32* %2
%332 = sext i32 %331 to i64
%333 = getelementptr inbounds float, float* %21, i64 %332
%334 = load float, float* %333
br label %335
335: ; preds = %330, %328
%336 = phi float [ %329, %328 ], [ %334, %330 ]
store float %336, float* %15
br label %337
337: ; preds = %335
%338 = load i32, i32* %2
%339 = add nsw i32 %338, 1
store i32 %339, i32* %2
br label %318
340: ; preds = %318
%341 = load float, float* %14
%342 = load float, float* %15
%343 = fcmp une float %341, %342
br i1 %343, label %344, label %346
344: ; preds = %340
%345 = call i32 (...) @abort()
unreachable
346: ; preds = %340
store float 1.001000e+03, float* %16
store i32 0, i32* %2
br label %347
347: ; preds = %366, %346
%348 = load i32, i32* %2
%349 = icmp slt i32 %348, 1000
br i1 %349, label %350, label %369
350: ; preds = %347
%351 = load float, float* %16
%352 = load i32, i32* %2
%353 = sext i32 %352 to i64
%354 = getelementptr inbounds float, float* %21, i64 %353
%355 = load float, float* %354
%356 = fcmp olt float %351, %355
br i1 %356, label %357, label %359
357: ; preds = %350
%358 = load float, float* %16
br label %364
359: ; preds = %350
%360 = load i32, i32* %2
%361 = sext i32 %360 to i64
%362 = getelementptr inbounds float, float* %21, i64 %361
%363 = load float, float* %362
br label %364
364: ; preds = %359, %357
%365 = phi float [ %358, %357 ], [ %363, %359 ]
store float %365, float* %16
br label %366
366: ; preds = %364
%367 = load i32, i32* %2
%368 = add nsw i32 %367, 1
store i32 %368, i32* %2
br label %347
369: ; preds = %347
store float 1.001000e+03, float* %17
store i32 0, i32* %2
br label %370
370: ; preds = %389, %369
%371 = load i32, i32* %2
%372 = icmp slt i32 %371, 1000
br i1 %372, label %373, label %392
373: ; preds = %370
%374 = load float, float* %17
%375 = load i32, i32* %2
%376 = sext i32 %375 to i64
%377 = getelementptr inbounds float, float* %21, i64 %376
%378 = load float, float* %377
%379 = fcmp olt float %374, %378
br i1 %379, label %380, label %382
380: ; preds = %373
%381 = load float, float* %17
br label %387
382: ; preds = %373
%383 = load i32, i32* %2
%384 = sext i32 %383 to i64
%385 = getelementptr inbounds float, float* %21, i64 %384
%386 = load float, float* %385
br label %387
387: ; preds = %382, %380
%388 = phi float [ %381, %380 ], [ %386, %382 ]
store float %388, float* %17
br label %389
389: ; preds = %387
%390 = load i32, i32* %2
%391 = add nsw i32 %390, 1
store i32 %391, i32* %2
br label %370
392: ; preds = %370
%393 = load float, float* %16
%394 = load float, float* %17
%395 = fcmp une float %393, %394
br i1 %395, label %396, label %398
396: ; preds = %392
%397 = call i32 (...) @abort()
unreachable
398: ; preds = %392
store float -1.000000e+00, float* %18
store i32 0, i32* %2
br label %399
399: ; preds = %418, %398
%400 = load i32, i32* %2
%401 = icmp slt i32 %400, 1000
br i1 %401, label %402, label %421
402: ; preds = %399
%403 = load float, float* %18
%404 = load i32, i32* %2
%405 = sext i32 %404 to i64
%406 = getelementptr inbounds float, float* %21, i64 %405
%407 = load float, float* %406
%408 = fcmp ogt float %403, %407
br i1 %408, label %409, label %411
409: ; preds = %402
%410 = load float, float* %18
br label %416
411: ; preds = %402
%412 = load i32, i32* %2
%413 = sext i32 %412 to i64
%414 = getelementptr inbounds float, float* %21, i64 %413
%415 = load float, float* %414
br label %416
416: ; preds = %411, %409
%417 = phi float [ %410, %409 ], [ %415, %411 ]
store float %417, float* %18
br label %418
418: ; preds = %416
%419 = load i32, i32* %2
%420 = add nsw i32 %419, 1
store i32 %420, i32* %2
br label %399
421: ; preds = %399
store float -1.000000e+00, float* %19
store i32 0, i32* %2
br label %422
422: ; preds = %441, %421
%423 = load i32, i32* %2
%424 = icmp slt i32 %423, 1000
br i1 %424, label %425, label %444
425: ; preds = %422
%426 = load float, float* %19
%427 = load i32, i32* %2
%428 = sext i32 %427 to i64
%429 = getelementptr inbounds float, float* %21, i64 %428
%430 = load float, float* %429
%431 = fcmp ogt float %426, %430
br i1 %431, label %432, label %434
432: ; preds = %425
%433 = load float, float* %19
br label %439
434: ; preds = %425
%435 = load i32, i32* %2
%436 = sext i32 %435 to i64
%437 = getelementptr inbounds float, float* %21, i64 %436
%438 = load float, float* %437
br label %439
439: ; preds = %434, %432
%440 = phi float [ %433, %432 ], [ %438, %434 ]
store float %440, float* %19
br label %441
441: ; preds = %439
%442 = load i32, i32* %2
%443 = add nsw i32 %442, 1
store i32 %443, i32* %2
br label %422
444: ; preds = %422
%445 = load float, float* %18
%446 = load float, float* %19
%447 = fcmp une float %445, %446
br i1 %447, label %448, label %450
448: ; preds = %444
%449 = call i32 (...) @abort()
unreachable
450: ; preds = %444
%451 = load i8*, i8** %3
ret void
}

LLVM IR (-O2):
define void @test_reductions_minmax() {
%1 = alloca [1000 x float]
br label %2
2: ; preds = %14, %0
%3 = phi i64 [ 0, %0 ], [ %23, %14 ]
%4 = phi <4 x i32> [ <i32 0, i32 1, i32 2, i32 3>, %0 ], [ %24, %14 ]
%5 = add <4 x i32> %4, <i32 4, i32 4, i32 4, i32 4>
%6 = sitofp <4 x i32> %4 to <4 x float>
%7 = sitofp <4 x i32> %5 to <4 x float>
%8 = getelementptr inbounds [1000 x float], [1000 x float]* %1, i64 0, i64 %3
%9 = bitcast float* %8 to <4 x float>*
store <4 x float> %6, <4 x float>* %9
%10 = getelementptr inbounds float, float* %8, i64 4
%11 = bitcast float* %10 to <4 x float>*
store <4 x float> %7, <4 x float>* %11
%12 = or i64 %3, 8
%13 = icmp eq i64 %12, 1000
br i1 %13, label %25, label %14
14: ; preds = %2
%15 = add <4 x i32> %4, <i32 8, i32 8, i32 8, i32 8>
%16 = add <4 x i32> %4, <i32 12, i32 12, i32 12, i32 12>
%17 = sitofp <4 x i32> %15 to <4 x float>
%18 = sitofp <4 x i32> %16 to <4 x float>
%19 = getelementptr inbounds [1000 x float], [1000 x float]* %1, i64 0, i64 %12
%20 = bitcast float* %19 to <4 x float>*
store <4 x float> %17, <4 x float>* %20
%21 = getelementptr inbounds float, float* %19, i64 4
%22 = bitcast float* %21 to <4 x float>*
store <4 x float> %18, <4 x float>* %22
%23 = add nuw nsw i64 %3, 16
%24 = add <4 x i32> %4, <i32 16, i32 16, i32 16, i32 16>
br label %2
25: ; preds = %2, %25
%26 = phi i64 [ %52, %25 ], [ 0, %2 ]
%27 = phi float [ %51, %25 ], [ 1.001000e+03, %2 ]
%28 = getelementptr inbounds [1000 x float], [1000 x float]* %1, i64 0, i64 %26
%29 = load float, float* %28
%30 = fcmp olt float %27, %29
%31 = select i1 %30, float %27, float %29
%32 = add nuw nsw i64 %26, 1
%33 = getelementptr inbounds [1000 x float], [1000 x float]* %1, i64 0, i64 %32
%34 = load float, float* %33
%35 = fcmp olt float %31, %34
%36 = select i1 %35, float %31, float %34
%37 = add nuw nsw i64 %26, 2
%38 = getelementptr inbounds [1000 x float], [1000 x float]* %1, i64 0, i64 %37
%39 = load float, float* %38
%40 = fcmp olt float %36, %39
%41 = select i1 %40, float %36, float %39
%42 = add nuw nsw i64 %26, 3
%43 = getelementptr inbounds [1000 x float], [1000 x float]* %1, i64 0, i64 %42
%44 = load float, float* %43
%45 = fcmp olt float %41, %44
%46 = select i1 %45, float %41, float %44
%47 = add nuw nsw i64 %26, 4
%48 = getelementptr inbounds [1000 x float], [1000 x float]* %1, i64 0, i64 %47
%49 = load float, float* %48
%50 = fcmp olt float %46, %49
%51 = select i1 %50, float %46, float %49
%52 = add nuw nsw i64 %26, 5
%53 = icmp eq i64 %52, 1000
br i1 %53, label %54, label %25
54: ; preds = %25, %54
%55 = phi i64 [ %81, %54 ], [ 0, %25 ]
%56 = phi float [ %80, %54 ], [ 1.001000e+03, %25 ]
%57 = getelementptr inbounds [1000 x float], [1000 x float]* %1, i64 0, i64 %55
%58 = load float, float* %57
%59 = fcmp olt float %56, %58
%60 = select i1 %59, float %56, float %58
%61 = add nuw nsw i64 %55, 1
%62 = getelementptr inbounds [1000 x float], [1000 x float]* %1, i64 0, i64 %61
%63 = load float, float* %62
%64 = fcmp olt float %60, %63
%65 = select i1 %64, float %60, float %63
%66 = add nuw nsw i64 %55, 2
%67 = getelementptr inbounds [1000 x float], [1000 x float]* %1, i64 0, i64 %66
%68 = load float, float* %67
%69 = fcmp olt float %65, %68
%70 = select i1 %69, float %65, float %68
%71 = add nuw nsw i64 %55, 3
%72 = getelementptr inbounds [1000 x float], [1000 x float]* %1, i64 0, i64 %71
%73 = load float, float* %72
%74 = fcmp olt float %70, %73
%75 = select i1 %74, float %70, float %73
%76 = add nuw nsw i64 %55, 4
%77 = getelementptr inbounds [1000 x float], [1000 x float]* %1, i64 0, i64 %76
%78 = load float, float* %77
%79 = fcmp olt float %75, %78
%80 = select i1 %79, float %75, float %78
%81 = add nuw nsw i64 %55, 5
%82 = icmp eq i64 %81, 1000
br i1 %82, label %83, label %54
83: ; preds = %54
%84 = fcmp une float %51, %80
br i1 %84, label %85, label %87
85: ; preds = %83
%86 = tail call i32 (...) @abort()
unreachable
87: ; preds = %83, %87
%88 = phi i64 [ %114, %87 ], [ 0, %83 ]
%89 = phi float [ %113, %87 ], [ -1.000000e+00, %83 ]
%90 = getelementptr inbounds [1000 x float], [1000 x float]* %1, i64 0, i64 %88
%91 = load float, float* %90
%92 = fcmp ogt float %89, %91
%93 = select i1 %92, float %89, float %91
%94 = add nuw nsw i64 %88, 1
%95 = getelementptr inbounds [1000 x float], [1000 x float]* %1, i64 0, i64 %94
%96 = load float, float* %95
%97 = fcmp ogt float %93, %96
%98 = select i1 %97, float %93, float %96
%99 = add nuw nsw i64 %88, 2
%100 = getelementptr inbounds [1000 x float], [1000 x float]* %1, i64 0, i64 %99
%101 = load float, float* %100
%102 = fcmp ogt float %98, %101
%103 = select i1 %102, float %98, float %101
%104 = add nuw nsw i64 %88, 3
%105 = getelementptr inbounds [1000 x float], [1000 x float]* %1, i64 0, i64 %104
%106 = load float, float* %105
%107 = fcmp ogt float %103, %106
%108 = select i1 %107, float %103, float %106
%109 = add nuw nsw i64 %88, 4
%110 = getelementptr inbounds [1000 x float], [1000 x float]* %1, i64 0, i64 %109
%111 = load float, float* %110
%112 = fcmp ogt float %108, %111
%113 = select i1 %112, float %108, float %111
%114 = add nuw nsw i64 %88, 5
%115 = icmp eq i64 %114, 1000
br i1 %115, label %116, label %87
116: ; preds = %87, %116
%117 = phi i64 [ %143, %116 ], [ 0, %87 ]
%118 = phi float [ %142, %116 ], [ -1.000000e+00, %87 ]
%119 = getelementptr inbounds [1000 x float], [1000 x float]* %1, i64 0, i64 %117
%120 = load float, float* %119
%121 = fcmp ogt float %118, %120
%122 = select i1 %121, float %118, float %120
%123 = add nuw nsw i64 %117, 1
%124 = getelementptr inbounds [1000 x float], [1000 x float]* %1, i64 0, i64 %123
%125 = load float, float* %124
%126 = fcmp ogt float %122, %125
%127 = select i1 %126, float %122, float %125
%128 = add nuw nsw i64 %117, 2
%129 = getelementptr inbounds [1000 x float], [1000 x float]* %1, i64 0, i64 %128
%130 = load float, float* %129
%131 = fcmp ogt float %127, %130
%132 = select i1 %131, float %127, float %130
%133 = add nuw nsw i64 %117, 3
%134 = getelementptr inbounds [1000 x float], [1000 x float]* %1, i64 0, i64 %133
%135 = load float, float* %134
%136 = fcmp ogt float %132, %135
%137 = select i1 %136, float %132, float %135
%138 = add nuw nsw i64 %117, 4
%139 = getelementptr inbounds [1000 x float], [1000 x float]* %1, i64 0, i64 %138
%140 = load float, float* %139
%141 = fcmp ogt float %137, %140
%142 = select i1 %141, float %137, float %140
%143 = add nuw nsw i64 %117, 5
%144 = icmp eq i64 %143, 1000
br i1 %144, label %145, label %116
145: ; preds = %116
%146 = fcmp une float %113, %142
br i1 %146, label %147, label %149
147: ; preds = %145
%148 = tail call i32 (...) @abort()
unreachable
149: ; preds = %145, %149
%150 = phi i64 [ %176, %149 ], [ 0, %145 ]
%151 = phi float [ %175, %149 ], [ 1.001000e+03, %145 ]
%152 = getelementptr inbounds [1000 x float], [1000 x float]* %1, i64 0, i64 %150
%153 = load float, float* %152
%154 = fcmp olt float %151, %153
%155 = select i1 %154, float %151, float %153
%156 = add nuw nsw i64 %150, 1
%157 = getelementptr inbounds [1000 x float], [1000 x float]* %1, i64 0, i64 %156
%158 = load float, float* %157
%159 = fcmp olt float %155, %158
%160 = select i1 %159, float %155, float %158
%161 = add nuw nsw i64 %150, 2
%162 = getelementptr inbounds [1000 x float], [1000 x float]* %1, i64 0, i64 %161
%163 = load float, float* %162
%164 = fcmp olt float %160, %163
%165 = select i1 %164, float %160, float %163
%166 = add nuw nsw i64 %150, 3
%167 = getelementptr inbounds [1000 x float], [1000 x float]* %1, i64 0, i64 %166
%168 = load float, float* %167
%169 = fcmp olt float %165, %168
%170 = select i1 %169, float %165, float %168
%171 = add nuw nsw i64 %150, 4
%172 = getelementptr inbounds [1000 x float], [1000 x float]* %1, i64 0, i64 %171
%173 = load float, float* %172
%174 = fcmp olt float %170, %173
%175 = select i1 %174, float %170, float %173
%176 = add nuw nsw i64 %150, 5
%177 = icmp eq i64 %176, 1000
br i1 %177, label %178, label %149
178: ; preds = %149, %178
%179 = phi i64 [ %205, %178 ], [ 0, %149 ]
%180 = phi float [ %204, %178 ], [ 1.001000e+03, %149 ]
%181 = getelementptr inbounds [1000 x float], [1000 x float]* %1, i64 0, i64 %179
%182 = load float, float* %181
%183 = fcmp olt float %180, %182
%184 = select i1 %183, float %180, float %182
%185 = add nuw nsw i64 %179, 1
%186 = getelementptr inbounds [1000 x float], [1000 x float]* %1, i64 0, i64 %185
%187 = load float, float* %186
%188 = fcmp olt float %184, %187
%189 = select i1 %188, float %184, float %187
%190 = add nuw nsw i64 %179, 2
%191 = getelementptr inbounds [1000 x float], [1000 x float]* %1, i64 0, i64 %190
%192 = load float, float* %191
%193 = fcmp olt float %189, %192
%194 = select i1 %193, float %189, float %192
%195 = add nuw nsw i64 %179, 3
%196 = getelementptr inbounds [1000 x float], [1000 x float]* %1, i64 0, i64 %195
%197 = load float, float* %196
%198 = fcmp olt float %194, %197
%199 = select i1 %198, float %194, float %197
%200 = add nuw nsw i64 %179, 4
%201 = getelementptr inbounds [1000 x float], [1000 x float]* %1, i64 0, i64 %200
%202 = load float, float* %201
%203 = fcmp olt float %199, %202
%204 = select i1 %203, float %199, float %202
%205 = add nuw nsw i64 %179, 5
%206 = icmp eq i64 %205, 1000
br i1 %206, label %207, label %178
207: ; preds = %178
%208 = fcmp une float %175, %204
br i1 %208, label %209, label %211
209: ; preds = %207
%210 = tail call i32 (...) @abort()
unreachable
211: ; preds = %207, %211
%212 = phi i64 [ %238, %211 ], [ 0, %207 ]
%213 = phi float [ %237, %211 ], [ -1.000000e+00, %207 ]
%214 = getelementptr inbounds [1000 x float], [1000 x float]* %1, i64 0, i64 %212
%215 = load float, float* %214
%216 = fcmp ogt float %213, %215
%217 = select i1 %216, float %213, float %215
%218 = add nuw nsw i64 %212, 1
%219 = getelementptr inbounds [1000 x float], [1000 x float]* %1, i64 0, i64 %218
%220 = load float, float* %219
%221 = fcmp ogt float %217, %220
%222 = select i1 %221, float %217, float %220
%223 = add nuw nsw i64 %212, 2
%224 = getelementptr inbounds [1000 x float], [1000 x float]* %1, i64 0, i64 %223
%225 = load float, float* %224
%226 = fcmp ogt float %222, %225
%227 = select i1 %226, float %222, float %225
%228 = add nuw nsw i64 %212, 3
%229 = getelementptr inbounds [1000 x float], [1000 x float]* %1, i64 0, i64 %228
%230 = load float, float* %229
%231 = fcmp ogt float %227, %230
%232 = select i1 %231, float %227, float %230
%233 = add nuw nsw i64 %212, 4
%234 = getelementptr inbounds [1000 x float], [1000 x float]* %1, i64 0, i64 %233
%235 = load float, float* %234
%236 = fcmp ogt float %232, %235
%237 = select i1 %236, float %232, float %235
%238 = add nuw nsw i64 %212, 5
%239 = icmp eq i64 %238, 1000
br i1 %239, label %240, label %211
240: ; preds = %211, %240
%241 = phi i64 [ %267, %240 ], [ 0, %211 ]
%242 = phi float [ %266, %240 ], [ -1.000000e+00, %211 ]
%243 = getelementptr inbounds [1000 x float], [1000 x float]* %1, i64 0, i64 %241
%244 = load float, float* %243
%245 = fcmp ogt float %242, %244
%246 = select i1 %245, float %242, float %244
%247 = add nuw nsw i64 %241, 1
%248 = getelementptr inbounds [1000 x float], [1000 x float]* %1, i64 0, i64 %247
%249 = load float, float* %248
%250 = fcmp ogt float %246, %249
%251 = select i1 %250, float %246, float %249
%252 = add nuw nsw i64 %241, 2
%253 = getelementptr inbounds [1000 x float], [1000 x float]* %1, i64 0, i64 %252
%254 = load float, float* %253
%255 = fcmp ogt float %251, %254
%256 = select i1 %255, float %251, float %254
%257 = add nuw nsw i64 %241, 3
%258 = getelementptr inbounds [1000 x float], [1000 x float]* %1, i64 0, i64 %257
%259 = load float, float* %258
%260 = fcmp ogt float %256, %259
%261 = select i1 %260, float %256, float %259
%262 = add nuw nsw i64 %241, 4
%263 = getelementptr inbounds [1000 x float], [1000 x float]* %1, i64 0, i64 %262
%264 = load float, float* %263
%265 = fcmp ogt float %261, %264
%266 = select i1 %265, float %261, float %264
%267 = add nuw nsw i64 %241, 5
%268 = icmp eq i64 %267, 1000
br i1 %268, label %269, label %240
269: ; preds = %240
%270 = fcmp une float %237, %266
br i1 %270, label %271, label %273
271: ; preds = %269
%272 = tail call i32 (...) @abort()
unreachable
273: ; preds = %269, %273
%274 = phi i64 [ %300, %273 ], [ 0, %269 ]
%275 = phi float [ %299, %273 ], [ 1.001000e+03, %269 ]
%276 = getelementptr inbounds [1000 x float], [1000 x float]* %1, i64 0, i64 %274
%277 = load float, float* %276
%278 = fcmp olt float %275, %277
%279 = select i1 %278, float %275, float %277
%280 = add nuw nsw i64 %274, 1
%281 = getelementptr inbounds [1000 x float], [1000 x float]* %1, i64 0, i64 %280
%282 = load float, float* %281
%283 = fcmp olt float %279, %282
%284 = select i1 %283, float %279, float %282
%285 = add nuw nsw i64 %274, 2
%286 = getelementptr inbounds [1000 x float], [1000 x float]* %1, i64 0, i64 %285
%287 = load float, float* %286
%288 = fcmp olt float %284, %287
%289 = select i1 %288, float %284, float %287
%290 = add nuw nsw i64 %274, 3
%291 = getelementptr inbounds [1000 x float], [1000 x float]* %1, i64 0, i64 %290
%292 = load float, float* %291
%293 = fcmp olt float %289, %292
%294 = select i1 %293, float %289, float %292
%295 = add nuw nsw i64 %274, 4
%296 = getelementptr inbounds [1000 x float], [1000 x float]* %1, i64 0, i64 %295
%297 = load float, float* %296
%298 = fcmp olt float %294, %297
%299 = select i1 %298, float %294, float %297
%300 = add nuw nsw i64 %274, 5
%301 = icmp eq i64 %300, 1000
br i1 %301, label %302, label %273
302: ; preds = %273, %302
%303 = phi i64 [ %329, %302 ], [ 0, %273 ]
%304 = phi float [ %328, %302 ], [ 1.001000e+03, %273 ]
%305 = getelementptr inbounds [1000 x float], [1000 x float]* %1, i64 0, i64 %303
%306 = load float, float* %305
%307 = fcmp olt float %304, %306
%308 = select i1 %307, float %304, float %306
%309 = add nuw nsw i64 %303, 1
%310 = getelementptr inbounds [1000 x float], [1000 x float]* %1, i64 0, i64 %309
%311 = load float, float* %310
%312 = fcmp olt float %308, %311
%313 = select i1 %312, float %308, float %311
%314 = add nuw nsw i64 %303, 2
%315 = getelementptr inbounds [1000 x float], [1000 x float]* %1, i64 0, i64 %314
%316 = load float, float* %315
%317 = fcmp olt float %313, %316
%318 = select i1 %317, float %313, float %316
%319 = add nuw nsw i64 %303, 3
%320 = getelementptr inbounds [1000 x float], [1000 x float]* %1, i64 0, i64 %319
%321 = load float, float* %320
%322 = fcmp olt float %318, %321
%323 = select i1 %322, float %318, float %321
%324 = add nuw nsw i64 %303, 4
%325 = getelementptr inbounds [1000 x float], [1000 x float]* %1, i64 0, i64 %324
%326 = load float, float* %325
%327 = fcmp olt float %323, %326
%328 = select i1 %327, float %323, float %326
%329 = add nuw nsw i64 %303, 5
%330 = icmp eq i64 %329, 1000
br i1 %330, label %331, label %302
331: ; preds = %302
%332 = fcmp une float %299, %328
br i1 %332, label %333, label %335
333: ; preds = %331
%334 = tail call i32 (...) @abort()
unreachable
335: ; preds = %331, %335
%336 = phi i64 [ %362, %335 ], [ 0, %331 ]
%337 = phi float [ %361, %335 ], [ -1.000000e+00, %331 ]
%338 = getelementptr inbounds [1000 x float], [1000 x float]* %1, i64 0, i64 %336
%339 = load float, float* %338
%340 = fcmp ogt float %337, %339
%341 = select i1 %340, float %337, float %339
%342 = add nuw nsw i64 %336, 1
%343 = getelementptr inbounds [1000 x float], [1000 x float]* %1, i64 0, i64 %342
%344 = load float, float* %343
%345 = fcmp ogt float %341, %344
%346 = select i1 %345, float %341, float %344
%347 = add nuw nsw i64 %336, 2
%348 = getelementptr inbounds [1000 x float], [1000 x float]* %1, i64 0, i64 %347
%349 = load float, float* %348
%350 = fcmp ogt float %346, %349
%351 = select i1 %350, float %346, float %349
%352 = add nuw nsw i64 %336, 3
%353 = getelementptr inbounds [1000 x float], [1000 x float]* %1, i64 0, i64 %352
%354 = load float, float* %353
%355 = fcmp ogt float %351, %354
%356 = select i1 %355, float %351, float %354
%357 = add nuw nsw i64 %336, 4
%358 = getelementptr inbounds [1000 x float], [1000 x float]* %1, i64 0, i64 %357
%359 = load float, float* %358
%360 = fcmp ogt float %356, %359
%361 = select i1 %360, float %356, float %359
%362 = add nuw nsw i64 %336, 5
%363 = icmp eq i64 %362, 1000
br i1 %363, label %364, label %335
364: ; preds = %335, %364
%365 = phi i64 [ %391, %364 ], [ 0, %335 ]
%366 = phi float [ %390, %364 ], [ -1.000000e+00, %335 ]
%367 = getelementptr inbounds [1000 x float], [1000 x float]* %1, i64 0, i64 %365
%368 = load float, float* %367
%369 = fcmp ogt float %366, %368
%370 = select i1 %369, float %366, float %368
%371 = add nuw nsw i64 %365, 1
%372 = getelementptr inbounds [1000 x float], [1000 x float]* %1, i64 0, i64 %371
%373 = load float, float* %372
%374 = fcmp ogt float %370, %373
%375 = select i1 %374, float %370, float %373
%376 = add nuw nsw i64 %365, 2
%377 = getelementptr inbounds [1000 x float], [1000 x float]* %1, i64 0, i64 %376
%378 = load float, float* %377
%379 = fcmp ogt float %375, %378
%380 = select i1 %379, float %375, float %378
%381 = add nuw nsw i64 %365, 3
%382 = getelementptr inbounds [1000 x float], [1000 x float]* %1, i64 0, i64 %381
%383 = load float, float* %382
%384 = fcmp ogt float %380, %383
%385 = select i1 %384, float %380, float %383
%386 = add nuw nsw i64 %365, 4
%387 = getelementptr inbounds [1000 x float], [1000 x float]* %1, i64 0, i64 %386
%388 = load float, float* %387
%389 = fcmp ogt float %385, %388
%390 = select i1 %389, float %385, float %388
%391 = add nuw nsw i64 %365, 5
%392 = icmp eq i64 %391, 1000
br i1 %392, label %393, label %364
393: ; preds = %364
%394 = fcmp une float %361, %390
br i1 %394, label %395, label %397
395: ; preds = %393
%396 = tail call i32 (...) @abort()
unreachable
397: ; preds = %393, %397
%398 = phi i64 [ %424, %397 ], [ 0, %393 ]
%399 = phi float [ %423, %397 ], [ 1.001000e+03, %393 ]
%400 = getelementptr inbounds [1000 x float], [1000 x float]* %1, i64 0, i64 %398
%401 = load float, float* %400
%402 = fcmp olt float %399, %401
%403 = select i1 %402, float %399, float %401
%404 = add nuw nsw i64 %398, 1
%405 = getelementptr inbounds [1000 x float], [1000 x float]* %1, i64 0, i64 %404
%406 = load float, float* %405
%407 = fcmp olt float %403, %406
%408 = select i1 %407, float %403, float %406
%409 = add nuw nsw i64 %398, 2
%410 = getelementptr inbounds [1000 x float], [1000 x float]* %1, i64 0, i64 %409
%411 = load float, float* %410
%412 = fcmp olt float %408, %411
%413 = select i1 %412, float %408, float %411
%414 = add nuw nsw i64 %398, 3
%415 = getelementptr inbounds [1000 x float], [1000 x float]* %1, i64 0, i64 %414
%416 = load float, float* %415
%417 = fcmp olt float %413, %416
%418 = select i1 %417, float %413, float %416
%419 = add nuw nsw i64 %398, 4
%420 = getelementptr inbounds [1000 x float], [1000 x float]* %1, i64 0, i64 %419
%421 = load float, float* %420
%422 = fcmp olt float %418, %421
%423 = select i1 %422, float %418, float %421
%424 = add nuw nsw i64 %398, 5
%425 = icmp eq i64 %424, 1000
br i1 %425, label %426, label %397
426: ; preds = %397, %426
%427 = phi i64 [ %453, %426 ], [ 0, %397 ]
%428 = phi float [ %452, %426 ], [ 1.001000e+03, %397 ]
%429 = getelementptr inbounds [1000 x float], [1000 x float]* %1, i64 0, i64 %427
%430 = load float, float* %429
%431 = fcmp olt float %428, %430
%432 = select i1 %431, float %428, float %430
%433 = add nuw nsw i64 %427, 1
%434 = getelementptr inbounds [1000 x float], [1000 x float]* %1, i64 0, i64 %433
%435 = load float, float* %434
%436 = fcmp olt float %432, %435
%437 = select i1 %436, float %432, float %435
%438 = add nuw nsw i64 %427, 2
%439 = getelementptr inbounds [1000 x float], [1000 x float]* %1, i64 0, i64 %438
%440 = load float, float* %439
%441 = fcmp olt float %437, %440
%442 = select i1 %441, float %437, float %440
%443 = add nuw nsw i64 %427, 3
%444 = getelementptr inbounds [1000 x float], [1000 x float]* %1, i64 0, i64 %443
%445 = load float, float* %444
%446 = fcmp olt float %442, %445
%447 = select i1 %446, float %442, float %445
%448 = add nuw nsw i64 %427, 4
%449 = getelementptr inbounds [1000 x float], [1000 x float]* %1, i64 0, i64 %448
%450 = load float, float* %449
%451 = fcmp olt float %447, %450
%452 = select i1 %451, float %447, float %450
%453 = add nuw nsw i64 %427, 5
%454 = icmp eq i64 %453, 1000
br i1 %454, label %455, label %426
455: ; preds = %426
%456 = fcmp une float %423, %452
br i1 %456, label %457, label %459
457: ; preds = %455
%458 = tail call i32 (...) @abort()
unreachable
459: ; preds = %455, %459
%460 = phi i64 [ %486, %459 ], [ 0, %455 ]
%461 = phi float [ %485, %459 ], [ -1.000000e+00, %455 ]
%462 = getelementptr inbounds [1000 x float], [1000 x float]* %1, i64 0, i64 %460
%463 = load float, float* %462
%464 = fcmp ogt float %461, %463
%465 = select i1 %464, float %461, float %463
%466 = add nuw nsw i64 %460, 1
%467 = getelementptr inbounds [1000 x float], [1000 x float]* %1, i64 0, i64 %466
%468 = load float, float* %467
%469 = fcmp ogt float %465, %468
%470 = select i1 %469, float %465, float %468
%471 = add nuw nsw i64 %460, 2
%472 = getelementptr inbounds [1000 x float], [1000 x float]* %1, i64 0, i64 %471
%473 = load float, float* %472
%474 = fcmp ogt float %470, %473
%475 = select i1 %474, float %470, float %473
%476 = add nuw nsw i64 %460, 3
%477 = getelementptr inbounds [1000 x float], [1000 x float]* %1, i64 0, i64 %476
%478 = load float, float* %477
%479 = fcmp ogt float %475, %478
%480 = select i1 %479, float %475, float %478
%481 = add nuw nsw i64 %460, 4
%482 = getelementptr inbounds [1000 x float], [1000 x float]* %1, i64 0, i64 %481
%483 = load float, float* %482
%484 = fcmp ogt float %480, %483
%485 = select i1 %484, float %480, float %483
%486 = add nuw nsw i64 %460, 5
%487 = icmp eq i64 %486, 1000
br i1 %487, label %488, label %459
488: ; preds = %459, %488
%489 = phi i64 [ %515, %488 ], [ 0, %459 ]
%490 = phi float [ %514, %488 ], [ -1.000000e+00, %459 ]
%491 = getelementptr inbounds [1000 x float], [1000 x float]* %1, i64 0, i64 %489
%492 = load float, float* %491
%493 = fcmp ogt float %490, %492
%494 = select i1 %493, float %490, float %492
%495 = add nuw nsw i64 %489, 1
%496 = getelementptr inbounds [1000 x float], [1000 x float]* %1, i64 0, i64 %495
%497 = load float, float* %496
%498 = fcmp ogt float %494, %497
%499 = select i1 %498, float %494, float %497
%500 = add nuw nsw i64 %489, 2
%501 = getelementptr inbounds [1000 x float], [1000 x float]* %1, i64 0, i64 %500
%502 = load float, float* %501
%503 = fcmp ogt float %499, %502
%504 = select i1 %503, float %499, float %502
%505 = add nuw nsw i64 %489, 3
%506 = getelementptr inbounds [1000 x float], [1000 x float]* %1, i64 0, i64 %505
%507 = load float, float* %506
%508 = fcmp ogt float %504, %507
%509 = select i1 %508, float %504, float %507
%510 = add nuw nsw i64 %489, 4
%511 = getelementptr inbounds [1000 x float], [1000 x float]* %1, i64 0, i64 %510
%512 = load float, float* %511
%513 = fcmp ogt float %509, %512
%514 = select i1 %513, float %509, float %512
%515 = add nuw nsw i64 %489, 5
%516 = icmp eq i64 %515, 1000
br i1 %516, label %517, label %488
517: ; preds = %488
%518 = fcmp une float %485, %514
br i1 %518, label %519, label %521
519: ; preds = %517
%520 = tail call i32 (...) @abort()
unreachable
521: ; preds = %517
ret void
}