#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 */
typedef scalar_t__ uint64_t;
typedef int /*<<< orphan*/ Ret;
typedef int /*<<< orphan*/ Array;

/* Variables and functions */
int /*<<< orphan*/ Add1(float *, float *, int, float);
int /*<<< orphan*/ Add2(float *, float *, int, float);
int /*<<< orphan*/ And1(float *, float *, int, float);
int /*<<< orphan*/ And2(float *, float *, int, float);
int /*<<< orphan*/ Max1(float *, float *, int, float);
int /*<<< orphan*/ Max2(float *, float *, int, float);
int /*<<< orphan*/ Min1(float *, float *, int, float);
int /*<<< orphan*/ Min2(float *, float *, int, float);
int /*<<< orphan*/ ScaleValue1(float *, float *, int, float);
int /*<<< orphan*/ ScaleValue2(float *, float *, int, float);
int /*<<< orphan*/ Sqrt1(float *, float *, int, float);
int /*<<< orphan*/ Sqrt2(float *, float *, int, float);
int /*<<< orphan*/ getpid();
scalar_t__ memcmp(float *, float *, int);
int /*<<< orphan*/ memcpy(float *, float *, int);
scalar_t__ now();
int /*<<< orphan*/ printf(char *, ...);
int random();
int /*<<< orphan*/ srandom(int /*<<< orphan*/);
int main(int argc, char *argv[]) {
  __attribute__((aligned(16))) float Array[1000];
  __attribute__((aligned(16))) float bakArray[1000];
  __attribute__((aligned(16))) float Ret[1000];
  __attribute__((aligned(16))) float Ret2[1000];
  srandom(getpid());
  for (int i = 0; i < 1000; ++i) {
    bakArray[i] = random() % 10000 / 10.0;
  }
  uint64_t s, e;
  printf("乘法:\n");
  memcpy(Array, bakArray, sizeof(Array));
  s = now();
  for (int i = 0; i < 10000; i++) {
    ScaleValue1(Ret, Array, 1000, 1000.0f);
  }
  e = now();
  printf("    Use SSE: %lu\n", e - s);
  memcpy(Array, bakArray, sizeof(Array));
  s = now();
  for (int i = 0; i < 10000; i++) {
    ScaleValue2(Ret2, Array, 1000, 1000.0f);
  }
  e = now();
  printf("Not Use SSE: %lu\n", e - s);
  if (memcmp(Ret, Ret2, sizeof(Ret)) != 0) {
    printf("check fail\n");
  }
  printf("加法：\n");
  memcpy(Array, bakArray, sizeof(Array));
  s = now();
  for (int i = 0; i < 10000; i++) {
    Add1(Ret, Array, 1000, 1000.0f);
  }
  e = now();
  printf("    Use SSE: %lu\n", e - s);
  memcpy(Array, bakArray, sizeof(Array));
  s = now();
  for (int i = 0; i < 10000; i++) {
    Add2(Ret2, Array, 1000, 1000.0f);
  }
  e = now();
  printf("Not Use SSE: %lu\n", e - s);
  if (memcmp(Ret, Ret2, sizeof(Ret)) != 0) {
    printf("check fail\n");
  }
  printf("平方：\n");
  memcpy(Array, bakArray, sizeof(Array));
  s = now();
  for (int i = 0; i < 10000; i++) {
    Sqrt1(Ret, Array, 1000, 1000.0f);
  }
  e = now();
  printf("    Use SSE: %lu\n", e - s);
  memcpy(Array, bakArray, sizeof(Array));
  s = now();
  for (int i = 0; i < 10000; i++) {
    Sqrt2(Ret2, Array, 1000, 1000.0f);
  }
  e = now();
  printf("Not Use SSE: %lu\n", e - s);
  if (memcmp(Ret, Ret2, sizeof(Ret)) != 0) {
    printf("check fail\n");
  }
  printf("最小值：\n");
  memcpy(Array, bakArray, sizeof(Array));
  s = now();
  for (int i = 0; i < 10000; i++) {
    Min1(Ret, Array, 1000, 1000.0f);
  }
  e = now();
  printf("    Use SSE: %lu\n", e - s);
  memcpy(Array, bakArray, sizeof(Array));
  s = now();
  for (int i = 0; i < 10000; i++) {
    Min2(Ret2, Array, 1000, 1000.0f);
  }
  e = now();
  printf("Not Use SSE: %lu\n", e - s);
  if (memcmp(Ret, Ret2, sizeof(Ret)) != 0) {
    printf("check fail\n");
  }
  printf("最大值：\n");
  memcpy(Array, bakArray, sizeof(Array));
  s = now();
  for (int i = 0; i < 10000; i++) {
    Max1(Ret, Array, 1000, 1000.0f);
  }
  e = now();
  printf("    Use SSE: %lu\n", e - s);
  memcpy(Array, bakArray, sizeof(Array));
  s = now();
  for (int i = 0; i < 10000; i++) {
    Max2(Ret2, Array, 1000, 1000.0f);
  }
  e = now();
  printf("Not Use SSE: %lu\n", e - s);
  if (memcmp(Ret, Ret2, sizeof(Ret)) != 0) {
    printf("check fail\n");
  }
  printf("与操作：\n");
  memcpy(Array, bakArray, sizeof(Array));
  s = now();
  for (int i = 0; i < 10000; i++) {
    And1(Ret, Array, 1000, 1000.0f);
  }
  e = now();
  printf("    Use SSE: %lu\n", e - s);
  memcpy(Array, bakArray, sizeof(Array));
  s = now();
  for (int i = 0; i < 10000; i++) {
    And2(Ret2, Array, 1000, 1000.0f);
  }
  e = now();
  printf("Not Use SSE: %lu\n", e - s);
  if (memcmp(Ret, Ret2, sizeof(Ret)) != 0) {
    printf("check fail\n");
  }
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x3ee0,%rsp
movl   $0x0,-0x4(%rbp)
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    $0x0,%al
call   1090 <getpid@plt>
mov    %eax,%edi
call   1070 <srandom@plt>
movl   $0x0,-0x3e94(%rbp)
cmpl   $0x3e8,-0x3e94(%rbp)
jge    12b8 <main+0x88>
mov    $0x0,%al
call   1110 <random@plt>
mov    $0x2710,%ecx
cltd
idiv   %ecx
cvtsi2sd %edx,%xmm0
movsd  0xd7c(%rip),%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movslq -0x3e94(%rbp),%rax
movss  %xmm0,-0x1f50(%rbp,%rax,4)
ff ff
mov    -0x3e94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3e94(%rbp)
jmp    1261 <main+0x31>
lea    0xd51(%rip),%rdi
mov    $0x0,%al
call   10a0 <printf@plt>
lea    -0xfb0(%rbp),%rdi
lea    -0x1f50(%rbp),%rsi
mov    $0xfa0,%edx
call   10d0 <memcpy@plt>
mov    $0x0,%al
call   1140 <now@plt>
mov    %rax,-0x3ea0(%rbp)
movl   $0x0,-0x3eac(%rbp)
cmpl   $0x2710,-0x3eac(%rbp)
jge    133a <main+0x10a>
lea    -0x2ef0(%rbp),%rdi
lea    -0xfb0(%rbp),%rsi
mov    $0x3e8,%edx
movss  0xcdf(%rip),%xmm0
call   1130 <ScaleValue1@plt>
mov    -0x3eac(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3eac(%rbp)
jmp    12f6 <main+0xc6>
mov    $0x0,%al
call   1140 <now@plt>
mov    %rax,-0x3ea8(%rbp)
mov    -0x3ea8(%rbp),%rsi
sub    -0x3ea0(%rbp),%rsi
lea    0xcbc(%rip),%rdi
mov    $0x0,%al
call   10a0 <printf@plt>
lea    -0xfb0(%rbp),%rdi
lea    -0x1f50(%rbp),%rsi
mov    $0xfa0,%edx
call   10d0 <memcpy@plt>
mov    $0x0,%al
call   1140 <now@plt>
mov    %rax,-0x3ea0(%rbp)
movl   $0x0,-0x3eb0(%rbp)
cmpl   $0x2710,-0x3eb0(%rbp)
jge    13d8 <main+0x1a8>
lea    -0x3e90(%rbp),%rdi
lea    -0xfb0(%rbp),%rsi
mov    $0x3e8,%edx
movss  0xc41(%rip),%xmm0
call   1080 <ScaleValue2@plt>
mov    -0x3eb0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3eb0(%rbp)
jmp    1394 <main+0x164>
mov    $0x0,%al
call   1140 <now@plt>
mov    %rax,-0x3ea8(%rbp)
mov    -0x3ea8(%rbp),%rsi
sub    -0x3ea0(%rbp),%rsi
lea    0xc30(%rip),%rdi
mov    $0x0,%al
call   10a0 <printf@plt>
lea    -0x2ef0(%rbp),%rdi
lea    -0x3e90(%rbp),%rsi
mov    $0xfa0,%edx
call   10c0 <memcmp@plt>
cmp    $0x0,%rax
je     1432 <main+0x202>
lea    0xc12(%rip),%rdi
mov    $0x0,%al
call   10a0 <printf@plt>
lea    0xc10(%rip),%rdi
mov    $0x0,%al
call   10a0 <printf@plt>
lea    -0xfb0(%rbp),%rdi
lea    -0x1f50(%rbp),%rsi
mov    $0xfa0,%edx
call   10d0 <memcpy@plt>
mov    $0x0,%al
call   1140 <now@plt>
mov    %rax,-0x3ea0(%rbp)
movl   $0x0,-0x3eb4(%rbp)
cmpl   $0x2710,-0x3eb4(%rbp)
jge    14b4 <main+0x284>
lea    -0x2ef0(%rbp),%rdi
lea    -0xfb0(%rbp),%rsi
mov    $0x3e8,%edx
movss  0xb65(%rip),%xmm0
call   1040 <Add1@plt>
mov    -0x3eb4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3eb4(%rbp)
jmp    1470 <main+0x240>
mov    $0x0,%al
call   1140 <now@plt>
mov    %rax,-0x3ea8(%rbp)
mov    -0x3ea8(%rbp),%rsi
sub    -0x3ea0(%rbp),%rsi
lea    0xb42(%rip),%rdi
mov    $0x0,%al
call   10a0 <printf@plt>
lea    -0xfb0(%rbp),%rdi
lea    -0x1f50(%rbp),%rsi
mov    $0xfa0,%edx
call   10d0 <memcpy@plt>
mov    $0x0,%al
call   1140 <now@plt>
mov    %rax,-0x3ea0(%rbp)
movl   $0x0,-0x3eb8(%rbp)
cmpl   $0x2710,-0x3eb8(%rbp)
jge    1552 <main+0x322>
lea    -0x3e90(%rbp),%rdi
lea    -0xfb0(%rbp),%rsi
mov    $0x3e8,%edx
movss  0xac7(%rip),%xmm0
call   10f0 <Add2@plt>
mov    -0x3eb8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3eb8(%rbp)
jmp    150e <main+0x2de>
mov    $0x0,%al
call   1140 <now@plt>
mov    %rax,-0x3ea8(%rbp)
mov    -0x3ea8(%rbp),%rsi
sub    -0x3ea0(%rbp),%rsi
lea    0xab6(%rip),%rdi
mov    $0x0,%al
call   10a0 <printf@plt>
lea    -0x2ef0(%rbp),%rdi
lea    -0x3e90(%rbp),%rsi
mov    $0xfa0,%edx
call   10c0 <memcmp@plt>
cmp    $0x0,%rax
je     15ac <main+0x37c>
lea    0xa98(%rip),%rdi
mov    $0x0,%al
call   10a0 <printf@plt>
lea    0xaa1(%rip),%rdi
mov    $0x0,%al
call   10a0 <printf@plt>
lea    -0xfb0(%rbp),%rdi
lea    -0x1f50(%rbp),%rsi
mov    $0xfa0,%edx
call   10d0 <memcpy@plt>
mov    $0x0,%al
call   1140 <now@plt>
mov    %rax,-0x3ea0(%rbp)
movl   $0x0,-0x3ebc(%rbp)
cmpl   $0x2710,-0x3ebc(%rbp)
jge    162e <main+0x3fe>
lea    -0x2ef0(%rbp),%rdi
lea    -0xfb0(%rbp),%rsi
mov    $0x3e8,%edx
movss  0x9eb(%rip),%xmm0
call   1060 <Sqrt1@plt>
mov    -0x3ebc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3ebc(%rbp)
jmp    15ea <main+0x3ba>
mov    $0x0,%al
call   1140 <now@plt>
mov    %rax,-0x3ea8(%rbp)
mov    -0x3ea8(%rbp),%rsi
sub    -0x3ea0(%rbp),%rsi
lea    0x9c8(%rip),%rdi
mov    $0x0,%al
call   10a0 <printf@plt>
lea    -0xfb0(%rbp),%rdi
lea    -0x1f50(%rbp),%rsi
mov    $0xfa0,%edx
call   10d0 <memcpy@plt>
mov    $0x0,%al
call   1140 <now@plt>
mov    %rax,-0x3ea0(%rbp)
movl   $0x0,-0x3ec0(%rbp)
cmpl   $0x2710,-0x3ec0(%rbp)
jge    16cc <main+0x49c>
lea    -0x3e90(%rbp),%rdi
lea    -0xfb0(%rbp),%rsi
mov    $0x3e8,%edx
movss  0x94d(%rip),%xmm0
call   1120 <Sqrt2@plt>
mov    -0x3ec0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3ec0(%rbp)
jmp    1688 <main+0x458>
mov    $0x0,%al
call   1140 <now@plt>
mov    %rax,-0x3ea8(%rbp)
mov    -0x3ea8(%rbp),%rsi
sub    -0x3ea0(%rbp),%rsi
lea    0x93c(%rip),%rdi
mov    $0x0,%al
call   10a0 <printf@plt>
lea    -0x2ef0(%rbp),%rdi
lea    -0x3e90(%rbp),%rsi
mov    $0xfa0,%edx
call   10c0 <memcmp@plt>
cmp    $0x0,%rax
je     1726 <main+0x4f6>
lea    0x91e(%rip),%rdi
mov    $0x0,%al
call   10a0 <printf@plt>
lea    0x932(%rip),%rdi
mov    $0x0,%al
call   10a0 <printf@plt>
lea    -0xfb0(%rbp),%rdi
lea    -0x1f50(%rbp),%rsi
mov    $0xfa0,%edx
call   10d0 <memcpy@plt>
mov    $0x0,%al
call   1140 <now@plt>
mov    %rax,-0x3ea0(%rbp)
movl   $0x0,-0x3ec4(%rbp)
cmpl   $0x2710,-0x3ec4(%rbp)
jge    17a8 <main+0x578>
lea    -0x2ef0(%rbp),%rdi
lea    -0xfb0(%rbp),%rsi
mov    $0x3e8,%edx
movss  0x871(%rip),%xmm0
call   1100 <Min1@plt>
mov    -0x3ec4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3ec4(%rbp)
jmp    1764 <main+0x534>
mov    $0x0,%al
call   1140 <now@plt>
mov    %rax,-0x3ea8(%rbp)
mov    -0x3ea8(%rbp),%rsi
sub    -0x3ea0(%rbp),%rsi
lea    0x84e(%rip),%rdi
mov    $0x0,%al
call   10a0 <printf@plt>
lea    -0xfb0(%rbp),%rdi
lea    -0x1f50(%rbp),%rsi
mov    $0xfa0,%edx
call   10d0 <memcpy@plt>
mov    $0x0,%al
call   1140 <now@plt>
mov    %rax,-0x3ea0(%rbp)
movl   $0x0,-0x3ec8(%rbp)
cmpl   $0x2710,-0x3ec8(%rbp)
jge    1846 <main+0x616>
lea    -0x3e90(%rbp),%rdi
lea    -0xfb0(%rbp),%rsi
mov    $0x3e8,%edx
movss  0x7d3(%rip),%xmm0
call   1050 <Min2@plt>
mov    -0x3ec8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3ec8(%rbp)
jmp    1802 <main+0x5d2>
mov    $0x0,%al
call   1140 <now@plt>
mov    %rax,-0x3ea8(%rbp)
mov    -0x3ea8(%rbp),%rsi
sub    -0x3ea0(%rbp),%rsi
lea    0x7c2(%rip),%rdi
mov    $0x0,%al
call   10a0 <printf@plt>
lea    -0x2ef0(%rbp),%rdi
lea    -0x3e90(%rbp),%rsi
mov    $0xfa0,%edx
call   10c0 <memcmp@plt>
cmp    $0x0,%rax
je     18a0 <main+0x670>
lea    0x7a4(%rip),%rdi
mov    $0x0,%al
call   10a0 <printf@plt>
lea    0x7c6(%rip),%rdi
mov    $0x0,%al
call   10a0 <printf@plt>
lea    -0xfb0(%rbp),%rdi
lea    -0x1f50(%rbp),%rsi
mov    $0xfa0,%edx
call   10d0 <memcpy@plt>
mov    $0x0,%al
call   1140 <now@plt>
mov    %rax,-0x3ea0(%rbp)
movl   $0x0,-0x3ecc(%rbp)
cmpl   $0x2710,-0x3ecc(%rbp)
jge    1922 <main+0x6f2>
lea    -0x2ef0(%rbp),%rdi
lea    -0xfb0(%rbp),%rsi
mov    $0x3e8,%edx
movss  0x6f7(%rip),%xmm0
call   1030 <Max1@plt>
mov    -0x3ecc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3ecc(%rbp)
jmp    18de <main+0x6ae>
mov    $0x0,%al
call   1140 <now@plt>
mov    %rax,-0x3ea8(%rbp)
mov    -0x3ea8(%rbp),%rsi
sub    -0x3ea0(%rbp),%rsi
lea    0x6d4(%rip),%rdi
mov    $0x0,%al
call   10a0 <printf@plt>
lea    -0xfb0(%rbp),%rdi
lea    -0x1f50(%rbp),%rsi
mov    $0xfa0,%edx
call   10d0 <memcpy@plt>
mov    $0x0,%al
call   1140 <now@plt>
mov    %rax,-0x3ea0(%rbp)
movl   $0x0,-0x3ed0(%rbp)
cmpl   $0x2710,-0x3ed0(%rbp)
jge    19c0 <main+0x790>
lea    -0x3e90(%rbp),%rdi
lea    -0xfb0(%rbp),%rsi
mov    $0x3e8,%edx
movss  0x659(%rip),%xmm0
call   10e0 <Max2@plt>
mov    -0x3ed0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3ed0(%rbp)
jmp    197c <main+0x74c>
mov    $0x0,%al
call   1140 <now@plt>
mov    %rax,-0x3ea8(%rbp)
mov    -0x3ea8(%rbp),%rsi
sub    -0x3ea0(%rbp),%rsi
lea    0x648(%rip),%rdi
mov    $0x0,%al
call   10a0 <printf@plt>
lea    -0x2ef0(%rbp),%rdi
lea    -0x3e90(%rbp),%rsi
mov    $0xfa0,%edx
call   10c0 <memcmp@plt>
cmp    $0x0,%rax
je     1a1a <main+0x7ea>
lea    0x62a(%rip),%rdi
mov    $0x0,%al
call   10a0 <printf@plt>
lea    0x65a(%rip),%rdi
mov    $0x0,%al
call   10a0 <printf@plt>
lea    -0xfb0(%rbp),%rdi
lea    -0x1f50(%rbp),%rsi
mov    $0xfa0,%edx
call   10d0 <memcpy@plt>
mov    $0x0,%al
call   1140 <now@plt>
mov    %rax,-0x3ea0(%rbp)
movl   $0x0,-0x3ed4(%rbp)
cmpl   $0x2710,-0x3ed4(%rbp)
jge    1a9c <main+0x86c>
lea    -0x2ef0(%rbp),%rdi
lea    -0xfb0(%rbp),%rsi
mov    $0x3e8,%edx
movss  0x57d(%rip),%xmm0
call   10b0 <And1@plt>
mov    -0x3ed4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3ed4(%rbp)
jmp    1a58 <main+0x828>
mov    $0x0,%al
call   1140 <now@plt>
mov    %rax,-0x3ea8(%rbp)
mov    -0x3ea8(%rbp),%rsi
sub    -0x3ea0(%rbp),%rsi
lea    0x55a(%rip),%rdi
mov    $0x0,%al
call   10a0 <printf@plt>
lea    -0xfb0(%rbp),%rdi
lea    -0x1f50(%rbp),%rsi
mov    $0xfa0,%edx
call   10d0 <memcpy@plt>
mov    $0x0,%al
call   1140 <now@plt>
mov    %rax,-0x3ea0(%rbp)
movl   $0x0,-0x3ed8(%rbp)
cmpl   $0x2710,-0x3ed8(%rbp)
jge    1b3a <main+0x90a>
lea    -0x3e90(%rbp),%rdi
lea    -0xfb0(%rbp),%rsi
mov    $0x3e8,%edx
movss  0x4df(%rip),%xmm0
call   1150 <And2@plt>
mov    -0x3ed8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3ed8(%rbp)
jmp    1af6 <main+0x8c6>
mov    $0x0,%al
call   1140 <now@plt>
mov    %rax,-0x3ea8(%rbp)
mov    -0x3ea8(%rbp),%rsi
sub    -0x3ea0(%rbp),%rsi
lea    0x4ce(%rip),%rdi
mov    $0x0,%al
call   10a0 <printf@plt>
lea    -0x2ef0(%rbp),%rdi
lea    -0x3e90(%rbp),%rsi
mov    $0xfa0,%edx
call   10c0 <memcmp@plt>
cmp    $0x0,%rax
je     1b94 <main+0x964>
lea    0x4b0(%rip),%rdi
mov    $0x0,%al
call   10a0 <printf@plt>
xor    %eax,%eax
add    $0x3ee0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %rbx
sub    $0x3e88,%rsp
xor    %eax,%eax
call   10a0 <getpid@plt>
mov    %eax,%edi
call   1070 <srandom@plt>
xor    %ebx,%ebx
nopl   (%rax)
xor    %eax,%eax
call   1120 <random@plt>
cltq
imul   $0x68db8bad,%rax,%rcx
mov    %rcx,%rdx
shr    $0x3f,%rdx
sar    $0x2c,%rcx
add    %edx,%ecx
imul   $0x2710,%ecx,%ecx
sub    %ecx,%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
divsd  0xd6c(%rip),%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%rsp,%rbx,4)
add    $0x1,%rbx
cmp    $0x3e8,%rbx
jne    1260 <main+0x20>
lea    0xd7f(%rip),%rdi
call   1090 <puts@plt>
lea    0x2ee0(%rsp),%r15
mov    %rsp,%rsi
mov    %r15,%rdi
mov    $0xfa0,%edx
call   10e0 <memcpy@plt>
xor    %eax,%eax
call   1150 <now@plt>
mov    %rax,%r14
mov    $0x2710,%ebp
lea    0x1f40(%rsp),%rbx
cs nopw 0x0(%rax,%rax,1)
nop
mov    %rbx,%rdi
mov    %r15,%rsi
mov    $0x3e8,%edx
movss  0xd05(%rip),%xmm0
call   1140 <ScaleValue1@plt>
add    $0xffffffff,%ebp
jne    12f0 <main+0xb0>
xor    %eax,%eax
call   1150 <now@plt>
sub    %r14,%rax
lea    0xcee(%rip),%rdi
mov    %rax,%rsi
xor    %eax,%eax
call   10b0 <printf@plt>
lea    0x2ee0(%rsp),%r15
mov    %rsp,%rsi
mov    %r15,%rdi
mov    $0xfa0,%edx
call   10e0 <memcpy@plt>
xor    %eax,%eax
call   1150 <now@plt>
mov    %rax,%r14
mov    $0x2710,%ebp
lea    0xfa0(%rsp),%rbx
nopw   0x0(%rax,%rax,1)
mov    %rbx,%rdi
mov    %r15,%rsi
mov    $0x3e8,%edx
movss  0xc95(%rip),%xmm0
call   1080 <ScaleValue2@plt>
add    $0xffffffff,%ebp
jne    1360 <main+0x120>
xor    %eax,%eax
call   1150 <now@plt>
sub    %r14,%rax
lea    0xc90(%rip),%rdi
mov    %rax,%rsi
xor    %eax,%eax
call   10b0 <printf@plt>
lea    0x1f40(%rsp),%rdi
lea    0xfa0(%rsp),%rsi
mov    $0xfa0,%edx
call   10d0 <memcmp@plt>
test   %rax,%rax
je     13c3 <main+0x183>
lea    0xcb5(%rip),%rdi
call   1090 <puts@plt>
lea    0xc6e(%rip),%rdi
call   1090 <puts@plt>
lea    0x2ee0(%rsp),%r15
mov    %rsp,%rsi
mov    %r15,%rdi
mov    $0xfa0,%edx
call   10e0 <memcpy@plt>
xor    %eax,%eax
call   1150 <now@plt>
mov    %rax,%r14
mov    $0x2710,%ebp
lea    0x1f40(%rsp),%rbx
xchg   %ax,%ax
mov    %rbx,%rdi
mov    %r15,%rsi
mov    $0x3e8,%edx
movss  0xbf5(%rip),%xmm0
call   1040 <Add1@plt>
add    $0xffffffff,%ebp
jne    1400 <main+0x1c0>
xor    %eax,%eax
call   1150 <now@plt>
sub    %r14,%rax
lea    0xbde(%rip),%rdi
mov    %rax,%rsi
xor    %eax,%eax
call   10b0 <printf@plt>
lea    0x2ee0(%rsp),%r15
mov    %rsp,%rsi
mov    %r15,%rdi
mov    $0xfa0,%edx
call   10e0 <memcpy@plt>
xor    %eax,%eax
call   1150 <now@plt>
mov    %rax,%r14
mov    $0x2710,%ebp
lea    0xfa0(%rsp),%rbx
nopw   0x0(%rax,%rax,1)
mov    %rbx,%rdi
mov    %r15,%rsi
mov    $0x3e8,%edx
movss  0xb85(%rip),%xmm0
call   1100 <Add2@plt>
add    $0xffffffff,%ebp
jne    1470 <main+0x230>
xor    %eax,%eax
call   1150 <now@plt>
sub    %r14,%rax
lea    0xb80(%rip),%rdi
mov    %rax,%rsi
xor    %eax,%eax
call   10b0 <printf@plt>
lea    0x1f40(%rsp),%rdi
lea    0xfa0(%rsp),%rsi
mov    $0xfa0,%edx
call   10d0 <memcmp@plt>
test   %rax,%rax
je     14d3 <main+0x293>
lea    0xba5(%rip),%rdi
call   1090 <puts@plt>
lea    0xb68(%rip),%rdi
call   1090 <puts@plt>
lea    0x2ee0(%rsp),%r15
mov    %rsp,%rsi
mov    %r15,%rdi
mov    $0xfa0,%edx
call   10e0 <memcpy@plt>
xor    %eax,%eax
call   1150 <now@plt>
mov    %rax,%r14
mov    $0x2710,%ebp
lea    0x1f40(%rsp),%rbx
xchg   %ax,%ax
mov    %rbx,%rdi
mov    %r15,%rsi
mov    $0x3e8,%edx
movss  0xae5(%rip),%xmm0
call   1060 <Sqrt1@plt>
add    $0xffffffff,%ebp
jne    1510 <main+0x2d0>
xor    %eax,%eax
call   1150 <now@plt>
sub    %r14,%rax
lea    0xace(%rip),%rdi
mov    %rax,%rsi
xor    %eax,%eax
call   10b0 <printf@plt>
lea    0x2ee0(%rsp),%r15
mov    %rsp,%rsi
mov    %r15,%rdi
mov    $0xfa0,%edx
call   10e0 <memcpy@plt>
xor    %eax,%eax
call   1150 <now@plt>
mov    %rax,%r14
mov    $0x2710,%ebp
lea    0xfa0(%rsp),%rbx
nopw   0x0(%rax,%rax,1)
mov    %rbx,%rdi
mov    %r15,%rsi
mov    $0x3e8,%edx
movss  0xa75(%rip),%xmm0
call   1130 <Sqrt2@plt>
add    $0xffffffff,%ebp
jne    1580 <main+0x340>
xor    %eax,%eax
call   1150 <now@plt>
sub    %r14,%rax
lea    0xa70(%rip),%rdi
mov    %rax,%rsi
xor    %eax,%eax
call   10b0 <printf@plt>
lea    0x1f40(%rsp),%rdi
lea    0xfa0(%rsp),%rsi
mov    $0xfa0,%edx
call   10d0 <memcmp@plt>
test   %rax,%rax
je     15e3 <main+0x3a3>
lea    0xa95(%rip),%rdi
call   1090 <puts@plt>
lea    0xa62(%rip),%rdi
call   1090 <puts@plt>
lea    0x2ee0(%rsp),%r15
mov    %rsp,%rsi
mov    %r15,%rdi
mov    $0xfa0,%edx
call   10e0 <memcpy@plt>
xor    %eax,%eax
call   1150 <now@plt>
mov    %rax,%r14
mov    $0x2710,%ebp
lea    0x1f40(%rsp),%rbx
xchg   %ax,%ax
mov    %rbx,%rdi
mov    %r15,%rsi
mov    $0x3e8,%edx
movss  0x9d5(%rip),%xmm0
call   1110 <Min1@plt>
add    $0xffffffff,%ebp
jne    1620 <main+0x3e0>
xor    %eax,%eax
call   1150 <now@plt>
sub    %r14,%rax
lea    0x9be(%rip),%rdi
mov    %rax,%rsi
xor    %eax,%eax
call   10b0 <printf@plt>
lea    0x2ee0(%rsp),%r15
mov    %rsp,%rsi
mov    %r15,%rdi
mov    $0xfa0,%edx
call   10e0 <memcpy@plt>
xor    %eax,%eax
call   1150 <now@plt>
mov    %rax,%r14
mov    $0x2710,%ebp
lea    0xfa0(%rsp),%rbx
nopw   0x0(%rax,%rax,1)
mov    %rbx,%rdi
mov    %r15,%rsi
mov    $0x3e8,%edx
movss  0x965(%rip),%xmm0
call   1050 <Min2@plt>
add    $0xffffffff,%ebp
jne    1690 <main+0x450>
xor    %eax,%eax
call   1150 <now@plt>
sub    %r14,%rax
lea    0x960(%rip),%rdi
mov    %rax,%rsi
xor    %eax,%eax
call   10b0 <printf@plt>
lea    0x1f40(%rsp),%rdi
lea    0xfa0(%rsp),%rsi
mov    $0xfa0,%edx
call   10d0 <memcmp@plt>
test   %rax,%rax
je     16f3 <main+0x4b3>
lea    0x985(%rip),%rdi
call   1090 <puts@plt>
lea    0x95f(%rip),%rdi
call   1090 <puts@plt>
lea    0x2ee0(%rsp),%r15
mov    %rsp,%rsi
mov    %r15,%rdi
mov    $0xfa0,%edx
call   10e0 <memcpy@plt>
xor    %eax,%eax
call   1150 <now@plt>
mov    %rax,%r14
mov    $0x2710,%ebp
lea    0x1f40(%rsp),%rbx
xchg   %ax,%ax
mov    %rbx,%rdi
mov    %r15,%rsi
mov    $0x3e8,%edx
movss  0x8c5(%rip),%xmm0
call   1030 <Max1@plt>
add    $0xffffffff,%ebp
jne    1730 <main+0x4f0>
xor    %eax,%eax
call   1150 <now@plt>
sub    %r14,%rax
lea    0x8ae(%rip),%rdi
mov    %rax,%rsi
xor    %eax,%eax
call   10b0 <printf@plt>
lea    0x2ee0(%rsp),%r15
mov    %rsp,%rsi
mov    %r15,%rdi
mov    $0xfa0,%edx
call   10e0 <memcpy@plt>
xor    %eax,%eax
call   1150 <now@plt>
mov    %rax,%r14
mov    $0x2710,%ebp
lea    0xfa0(%rsp),%rbx
nopw   0x0(%rax,%rax,1)
mov    %rbx,%rdi
mov    %r15,%rsi
mov    $0x3e8,%edx
movss  0x855(%rip),%xmm0
call   10f0 <Max2@plt>
add    $0xffffffff,%ebp
jne    17a0 <main+0x560>
xor    %eax,%eax
call   1150 <now@plt>
sub    %r14,%rax
lea    0x850(%rip),%rdi
mov    %rax,%rsi
xor    %eax,%eax
call   10b0 <printf@plt>
lea    0x1f40(%rsp),%rdi
lea    0xfa0(%rsp),%rsi
mov    $0xfa0,%edx
call   10d0 <memcmp@plt>
test   %rax,%rax
je     1803 <main+0x5c3>
lea    0x875(%rip),%rdi
call   1090 <puts@plt>
lea    0x85c(%rip),%rdi
call   1090 <puts@plt>
lea    0x2ee0(%rsp),%r15
mov    %rsp,%rsi
mov    %r15,%rdi
mov    $0xfa0,%edx
call   10e0 <memcpy@plt>
xor    %eax,%eax
call   1150 <now@plt>
mov    %rax,%r14
mov    $0x2710,%ebp
lea    0x1f40(%rsp),%rbx
xchg   %ax,%ax
mov    %rbx,%rdi
mov    %r15,%rsi
mov    $0x3e8,%edx
movss  0x7b5(%rip),%xmm0
call   10c0 <And1@plt>
add    $0xffffffff,%ebp
jne    1840 <main+0x600>
xor    %eax,%eax
call   1150 <now@plt>
sub    %r14,%rax
lea    0x79e(%rip),%rdi
mov    %rax,%rsi
xor    %eax,%eax
call   10b0 <printf@plt>
lea    0x2ee0(%rsp),%r15
mov    %rsp,%rsi
mov    %r15,%rdi
mov    $0xfa0,%edx
call   10e0 <memcpy@plt>
xor    %eax,%eax
call   1150 <now@plt>
mov    %rax,%r14
mov    $0x2710,%ebp
lea    0xfa0(%rsp),%rbx
nopw   0x0(%rax,%rax,1)
mov    %rbx,%rdi
mov    %r15,%rsi
mov    $0x3e8,%edx
movss  0x745(%rip),%xmm0
call   1160 <And2@plt>
add    $0xffffffff,%ebp
jne    18b0 <main+0x670>
xor    %eax,%eax
call   1150 <now@plt>
sub    %r14,%rax
lea    0x740(%rip),%rdi
mov    %rax,%rsi
xor    %eax,%eax
call   10b0 <printf@plt>
lea    0x1f40(%rsp),%rdi
lea    0xfa0(%rsp),%rsi
mov    $0xfa0,%edx
call   10d0 <memcmp@plt>
test   %rax,%rax
je     1913 <main+0x6d3>
lea    0x765(%rip),%rdi
call   1090 <puts@plt>
xor    %eax,%eax
add    $0x3e88,%rsp
pop    %rbx
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [9 x i8] c"\E4\B9\98\E6\B3\95:\0A\00"
@.str.1 = [18 x i8] c" Use SSE: %lu\0A\00"
@.str.2 = [18 x i8] c"Not Use SSE: %lu\0A\00"
@.str.3 = [12 x i8] c"check fail\0A\00"
@.str.4 = [11 x i8] c"\E5\8A\A0\E6\B3\95\EF\BC\9A\0A\00"
@.str.5 = [11 x i8] c"\E5\B9\B3\E6\96\B9\EF\BC\9A\0A\00"
@.str.6 = [14 x i8] c"\E6\9C\80\E5\B0\8F\E5\80\BC\EF\BC\9A\0A\00"
@.str.7 = [14 x i8] c"\E6\9C\80\E5\A4\A7\E5\80\BC\EF\BC\9A\0A\00"
@.str.8 = [14 x i8] c"\E4\B8\8E\E6\93\8D\E4\BD\9C\EF\BC\9A\0A\00"
define i32 @main(i32 %0, i8** %1) {
%3 = alloca i32
%4 = alloca i32
%5 = alloca i8**
%6 = alloca [1000 x float]
%7 = alloca [1000 x float]
%8 = alloca [1000 x float]
%9 = alloca [1000 x float]
%10 = alloca i32
%11 = alloca i64
%12 = alloca i64
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
%17 = alloca i32
%18 = alloca i32
%19 = alloca i32
%20 = alloca i32
%21 = alloca i32
%22 = alloca i32
%23 = alloca i32
%24 = alloca i32
store i32 0, i32* %3
store i32 %0, i32* %4
store i8** %1, i8*** %5
%25 = call i32 (...) @getpid()
%26 = call i32 @srandom(i32 %25)
store i32 0, i32* %10
br label %27
27: ; preds = %39, %2
%28 = load i32, i32* %10
%29 = icmp slt i32 %28, 1000
br i1 %29, label %30, label %42
30: ; preds = %27
%31 = call i32 (...) @random()
%32 = srem i32 %31, 10000
%33 = sitofp i32 %32 to double
%34 = fdiv double %33, 1.000000e+01
%35 = fptrunc double %34 to float
%36 = load i32, i32* %10
%37 = sext i32 %36 to i64
%38 = getelementptr inbounds [1000 x float], [1000 x float]* %7, i64 0, i64 %37
store float %35, float* %38
br label %39
39: ; preds = %30
%40 = load i32, i32* %10
%41 = add nsw i32 %40, 1
store i32 %41, i32* %10
br label %27
42: ; preds = %27
%43 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str, i64 0, i64 0))
%44 = getelementptr inbounds [1000 x float], [1000 x float]* %6, i64 0, i64 0
%45 = getelementptr inbounds [1000 x float], [1000 x float]* %7, i64 0, i64 0
%46 = call i32 @memcpy(float* %44, float* %45, i32 4000)
%47 = call i64 (...) @now()
store i64 %47, i64* %11
store i32 0, i32* %13
br label %48
48: ; preds = %55, %42
%49 = load i32, i32* %13
%50 = icmp slt i32 %49, 10000
br i1 %50, label %51, label %58
51: ; preds = %48
%52 = getelementptr inbounds [1000 x float], [1000 x float]* %8, i64 0, i64 0
%53 = getelementptr inbounds [1000 x float], [1000 x float]* %6, i64 0, i64 0
%54 = call i32 @ScaleValue1(float* %52, float* %53, i32 1000, float 1.000000e+03)
br label %55
55: ; preds = %51
%56 = load i32, i32* %13
%57 = add nsw i32 %56, 1
store i32 %57, i32* %13
br label %48
58: ; preds = %48
%59 = call i64 (...) @now()
store i64 %59, i64* %12
%60 = load i64, i64* %12
%61 = load i64, i64* %11
%62 = sub nsw i64 %60, %61
%63 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.1, i64 0, i64 0), i64 %62)
%64 = getelementptr inbounds [1000 x float], [1000 x float]* %6, i64 0, i64 0
%65 = getelementptr inbounds [1000 x float], [1000 x float]* %7, i64 0, i64 0
%66 = call i32 @memcpy(float* %64, float* %65, i32 4000)
%67 = call i64 (...) @now()
store i64 %67, i64* %11
store i32 0, i32* %14
br label %68
68: ; preds = %75, %58
%69 = load i32, i32* %14
%70 = icmp slt i32 %69, 10000
br i1 %70, label %71, label %78
71: ; preds = %68
%72 = getelementptr inbounds [1000 x float], [1000 x float]* %9, i64 0, i64 0
%73 = getelementptr inbounds [1000 x float], [1000 x float]* %6, i64 0, i64 0
%74 = call i32 @ScaleValue2(float* %72, float* %73, i32 1000, float 1.000000e+03)
br label %75
75: ; preds = %71
%76 = load i32, i32* %14
%77 = add nsw i32 %76, 1
store i32 %77, i32* %14
br label %68
78: ; preds = %68
%79 = call i64 (...) @now()
store i64 %79, i64* %12
%80 = load i64, i64* %12
%81 = load i64, i64* %11
%82 = sub nsw i64 %80, %81
%83 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.2, i64 0, i64 0), i64 %82)
%84 = getelementptr inbounds [1000 x float], [1000 x float]* %8, i64 0, i64 0
%85 = getelementptr inbounds [1000 x float], [1000 x float]* %9, i64 0, i64 0
%86 = call i64 @memcmp(float* %84, float* %85, i32 4000)
%87 = icmp ne i64 %86, 0
br i1 %87, label %88, label %90
88: ; preds = %78
%89 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.3, i64 0, i64 0))
br label %90
90: ; preds = %88, %78
%91 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.4, i64 0, i64 0))
%92 = getelementptr inbounds [1000 x float], [1000 x float]* %6, i64 0, i64 0
%93 = getelementptr inbounds [1000 x float], [1000 x float]* %7, i64 0, i64 0
%94 = call i32 @memcpy(float* %92, float* %93, i32 4000)
%95 = call i64 (...) @now()
store i64 %95, i64* %11
store i32 0, i32* %15
br label %96
96: ; preds = %103, %90
%97 = load i32, i32* %15
%98 = icmp slt i32 %97, 10000
br i1 %98, label %99, label %106
99: ; preds = %96
%100 = getelementptr inbounds [1000 x float], [1000 x float]* %8, i64 0, i64 0
%101 = getelementptr inbounds [1000 x float], [1000 x float]* %6, i64 0, i64 0
%102 = call i32 @Add1(float* %100, float* %101, i32 1000, float 1.000000e+03)
br label %103
103: ; preds = %99
%104 = load i32, i32* %15
%105 = add nsw i32 %104, 1
store i32 %105, i32* %15
br label %96
106: ; preds = %96
%107 = call i64 (...) @now()
store i64 %107, i64* %12
%108 = load i64, i64* %12
%109 = load i64, i64* %11
%110 = sub nsw i64 %108, %109
%111 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.1, i64 0, i64 0), i64 %110)
%112 = getelementptr inbounds [1000 x float], [1000 x float]* %6, i64 0, i64 0
%113 = getelementptr inbounds [1000 x float], [1000 x float]* %7, i64 0, i64 0
%114 = call i32 @memcpy(float* %112, float* %113, i32 4000)
%115 = call i64 (...) @now()
store i64 %115, i64* %11
store i32 0, i32* %16
br label %116
116: ; preds = %123, %106
%117 = load i32, i32* %16
%118 = icmp slt i32 %117, 10000
br i1 %118, label %119, label %126
119: ; preds = %116
%120 = getelementptr inbounds [1000 x float], [1000 x float]* %9, i64 0, i64 0
%121 = getelementptr inbounds [1000 x float], [1000 x float]* %6, i64 0, i64 0
%122 = call i32 @Add2(float* %120, float* %121, i32 1000, float 1.000000e+03)
br label %123
123: ; preds = %119
%124 = load i32, i32* %16
%125 = add nsw i32 %124, 1
store i32 %125, i32* %16
br label %116
126: ; preds = %116
%127 = call i64 (...) @now()
store i64 %127, i64* %12
%128 = load i64, i64* %12
%129 = load i64, i64* %11
%130 = sub nsw i64 %128, %129
%131 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.2, i64 0, i64 0), i64 %130)
%132 = getelementptr inbounds [1000 x float], [1000 x float]* %8, i64 0, i64 0
%133 = getelementptr inbounds [1000 x float], [1000 x float]* %9, i64 0, i64 0
%134 = call i64 @memcmp(float* %132, float* %133, i32 4000)
%135 = icmp ne i64 %134, 0
br i1 %135, label %136, label %138
136: ; preds = %126
%137 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.3, i64 0, i64 0))
br label %138
138: ; preds = %136, %126
%139 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.5, i64 0, i64 0))
%140 = getelementptr inbounds [1000 x float], [1000 x float]* %6, i64 0, i64 0
%141 = getelementptr inbounds [1000 x float], [1000 x float]* %7, i64 0, i64 0
%142 = call i32 @memcpy(float* %140, float* %141, i32 4000)
%143 = call i64 (...) @now()
store i64 %143, i64* %11
store i32 0, i32* %17
br label %144
144: ; preds = %151, %138
%145 = load i32, i32* %17
%146 = icmp slt i32 %145, 10000
br i1 %146, label %147, label %154
147: ; preds = %144
%148 = getelementptr inbounds [1000 x float], [1000 x float]* %8, i64 0, i64 0
%149 = getelementptr inbounds [1000 x float], [1000 x float]* %6, i64 0, i64 0
%150 = call i32 @Sqrt1(float* %148, float* %149, i32 1000, float 1.000000e+03)
br label %151
151: ; preds = %147
%152 = load i32, i32* %17
%153 = add nsw i32 %152, 1
store i32 %153, i32* %17
br label %144
154: ; preds = %144
%155 = call i64 (...) @now()
store i64 %155, i64* %12
%156 = load i64, i64* %12
%157 = load i64, i64* %11
%158 = sub nsw i64 %156, %157
%159 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.1, i64 0, i64 0), i64 %158)
%160 = getelementptr inbounds [1000 x float], [1000 x float]* %6, i64 0, i64 0
%161 = getelementptr inbounds [1000 x float], [1000 x float]* %7, i64 0, i64 0
%162 = call i32 @memcpy(float* %160, float* %161, i32 4000)
%163 = call i64 (...) @now()
store i64 %163, i64* %11
store i32 0, i32* %18
br label %164
164: ; preds = %171, %154
%165 = load i32, i32* %18
%166 = icmp slt i32 %165, 10000
br i1 %166, label %167, label %174
167: ; preds = %164
%168 = getelementptr inbounds [1000 x float], [1000 x float]* %9, i64 0, i64 0
%169 = getelementptr inbounds [1000 x float], [1000 x float]* %6, i64 0, i64 0
%170 = call i32 @Sqrt2(float* %168, float* %169, i32 1000, float 1.000000e+03)
br label %171
171: ; preds = %167
%172 = load i32, i32* %18
%173 = add nsw i32 %172, 1
store i32 %173, i32* %18
br label %164
174: ; preds = %164
%175 = call i64 (...) @now()
store i64 %175, i64* %12
%176 = load i64, i64* %12
%177 = load i64, i64* %11
%178 = sub nsw i64 %176, %177
%179 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.2, i64 0, i64 0), i64 %178)
%180 = getelementptr inbounds [1000 x float], [1000 x float]* %8, i64 0, i64 0
%181 = getelementptr inbounds [1000 x float], [1000 x float]* %9, i64 0, i64 0
%182 = call i64 @memcmp(float* %180, float* %181, i32 4000)
%183 = icmp ne i64 %182, 0
br i1 %183, label %184, label %186
184: ; preds = %174
%185 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.3, i64 0, i64 0))
br label %186
186: ; preds = %184, %174
%187 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.6, i64 0, i64 0))
%188 = getelementptr inbounds [1000 x float], [1000 x float]* %6, i64 0, i64 0
%189 = getelementptr inbounds [1000 x float], [1000 x float]* %7, i64 0, i64 0
%190 = call i32 @memcpy(float* %188, float* %189, i32 4000)
%191 = call i64 (...) @now()
store i64 %191, i64* %11
store i32 0, i32* %19
br label %192
192: ; preds = %199, %186
%193 = load i32, i32* %19
%194 = icmp slt i32 %193, 10000
br i1 %194, label %195, label %202
195: ; preds = %192
%196 = getelementptr inbounds [1000 x float], [1000 x float]* %8, i64 0, i64 0
%197 = getelementptr inbounds [1000 x float], [1000 x float]* %6, i64 0, i64 0
%198 = call i32 @Min1(float* %196, float* %197, i32 1000, float 1.000000e+03)
br label %199
199: ; preds = %195
%200 = load i32, i32* %19
%201 = add nsw i32 %200, 1
store i32 %201, i32* %19
br label %192
202: ; preds = %192
%203 = call i64 (...) @now()
store i64 %203, i64* %12
%204 = load i64, i64* %12
%205 = load i64, i64* %11
%206 = sub nsw i64 %204, %205
%207 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.1, i64 0, i64 0), i64 %206)
%208 = getelementptr inbounds [1000 x float], [1000 x float]* %6, i64 0, i64 0
%209 = getelementptr inbounds [1000 x float], [1000 x float]* %7, i64 0, i64 0
%210 = call i32 @memcpy(float* %208, float* %209, i32 4000)
%211 = call i64 (...) @now()
store i64 %211, i64* %11
store i32 0, i32* %20
br label %212
212: ; preds = %219, %202
%213 = load i32, i32* %20
%214 = icmp slt i32 %213, 10000
br i1 %214, label %215, label %222
215: ; preds = %212
%216 = getelementptr inbounds [1000 x float], [1000 x float]* %9, i64 0, i64 0
%217 = getelementptr inbounds [1000 x float], [1000 x float]* %6, i64 0, i64 0
%218 = call i32 @Min2(float* %216, float* %217, i32 1000, float 1.000000e+03)
br label %219
219: ; preds = %215
%220 = load i32, i32* %20
%221 = add nsw i32 %220, 1
store i32 %221, i32* %20
br label %212
222: ; preds = %212
%223 = call i64 (...) @now()
store i64 %223, i64* %12
%224 = load i64, i64* %12
%225 = load i64, i64* %11
%226 = sub nsw i64 %224, %225
%227 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.2, i64 0, i64 0), i64 %226)
%228 = getelementptr inbounds [1000 x float], [1000 x float]* %8, i64 0, i64 0
%229 = getelementptr inbounds [1000 x float], [1000 x float]* %9, i64 0, i64 0
%230 = call i64 @memcmp(float* %228, float* %229, i32 4000)
%231 = icmp ne i64 %230, 0
br i1 %231, label %232, label %234
232: ; preds = %222
%233 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.3, i64 0, i64 0))
br label %234
234: ; preds = %232, %222
%235 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.7, i64 0, i64 0))
%236 = getelementptr inbounds [1000 x float], [1000 x float]* %6, i64 0, i64 0
%237 = getelementptr inbounds [1000 x float], [1000 x float]* %7, i64 0, i64 0
%238 = call i32 @memcpy(float* %236, float* %237, i32 4000)
%239 = call i64 (...) @now()
store i64 %239, i64* %11
store i32 0, i32* %21
br label %240
240: ; preds = %247, %234
%241 = load i32, i32* %21
%242 = icmp slt i32 %241, 10000
br i1 %242, label %243, label %250
243: ; preds = %240
%244 = getelementptr inbounds [1000 x float], [1000 x float]* %8, i64 0, i64 0
%245 = getelementptr inbounds [1000 x float], [1000 x float]* %6, i64 0, i64 0
%246 = call i32 @Max1(float* %244, float* %245, i32 1000, float 1.000000e+03)
br label %247
247: ; preds = %243
%248 = load i32, i32* %21
%249 = add nsw i32 %248, 1
store i32 %249, i32* %21
br label %240
250: ; preds = %240
%251 = call i64 (...) @now()
store i64 %251, i64* %12
%252 = load i64, i64* %12
%253 = load i64, i64* %11
%254 = sub nsw i64 %252, %253
%255 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.1, i64 0, i64 0), i64 %254)
%256 = getelementptr inbounds [1000 x float], [1000 x float]* %6, i64 0, i64 0
%257 = getelementptr inbounds [1000 x float], [1000 x float]* %7, i64 0, i64 0
%258 = call i32 @memcpy(float* %256, float* %257, i32 4000)
%259 = call i64 (...) @now()
store i64 %259, i64* %11
store i32 0, i32* %22
br label %260
260: ; preds = %267, %250
%261 = load i32, i32* %22
%262 = icmp slt i32 %261, 10000
br i1 %262, label %263, label %270
263: ; preds = %260
%264 = getelementptr inbounds [1000 x float], [1000 x float]* %9, i64 0, i64 0
%265 = getelementptr inbounds [1000 x float], [1000 x float]* %6, i64 0, i64 0
%266 = call i32 @Max2(float* %264, float* %265, i32 1000, float 1.000000e+03)
br label %267
267: ; preds = %263
%268 = load i32, i32* %22
%269 = add nsw i32 %268, 1
store i32 %269, i32* %22
br label %260
270: ; preds = %260
%271 = call i64 (...) @now()
store i64 %271, i64* %12
%272 = load i64, i64* %12
%273 = load i64, i64* %11
%274 = sub nsw i64 %272, %273
%275 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.2, i64 0, i64 0), i64 %274)
%276 = getelementptr inbounds [1000 x float], [1000 x float]* %8, i64 0, i64 0
%277 = getelementptr inbounds [1000 x float], [1000 x float]* %9, i64 0, i64 0
%278 = call i64 @memcmp(float* %276, float* %277, i32 4000)
%279 = icmp ne i64 %278, 0
br i1 %279, label %280, label %282
280: ; preds = %270
%281 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.3, i64 0, i64 0))
br label %282
282: ; preds = %280, %270
%283 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.8, i64 0, i64 0))
%284 = getelementptr inbounds [1000 x float], [1000 x float]* %6, i64 0, i64 0
%285 = getelementptr inbounds [1000 x float], [1000 x float]* %7, i64 0, i64 0
%286 = call i32 @memcpy(float* %284, float* %285, i32 4000)
%287 = call i64 (...) @now()
store i64 %287, i64* %11
store i32 0, i32* %23
br label %288
288: ; preds = %295, %282
%289 = load i32, i32* %23
%290 = icmp slt i32 %289, 10000
br i1 %290, label %291, label %298
291: ; preds = %288
%292 = getelementptr inbounds [1000 x float], [1000 x float]* %8, i64 0, i64 0
%293 = getelementptr inbounds [1000 x float], [1000 x float]* %6, i64 0, i64 0
%294 = call i32 @And1(float* %292, float* %293, i32 1000, float 1.000000e+03)
br label %295
295: ; preds = %291
%296 = load i32, i32* %23
%297 = add nsw i32 %296, 1
store i32 %297, i32* %23
br label %288
298: ; preds = %288
%299 = call i64 (...) @now()
store i64 %299, i64* %12
%300 = load i64, i64* %12
%301 = load i64, i64* %11
%302 = sub nsw i64 %300, %301
%303 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.1, i64 0, i64 0), i64 %302)
%304 = getelementptr inbounds [1000 x float], [1000 x float]* %6, i64 0, i64 0
%305 = getelementptr inbounds [1000 x float], [1000 x float]* %7, i64 0, i64 0
%306 = call i32 @memcpy(float* %304, float* %305, i32 4000)
%307 = call i64 (...) @now()
store i64 %307, i64* %11
store i32 0, i32* %24
br label %308
308: ; preds = %315, %298
%309 = load i32, i32* %24
%310 = icmp slt i32 %309, 10000
br i1 %310, label %311, label %318
311: ; preds = %308
%312 = getelementptr inbounds [1000 x float], [1000 x float]* %9, i64 0, i64 0
%313 = getelementptr inbounds [1000 x float], [1000 x float]* %6, i64 0, i64 0
%314 = call i32 @And2(float* %312, float* %313, i32 1000, float 1.000000e+03)
br label %315
315: ; preds = %311
%316 = load i32, i32* %24
%317 = add nsw i32 %316, 1
store i32 %317, i32* %24
br label %308
318: ; preds = %308
%319 = call i64 (...) @now()
store i64 %319, i64* %12
%320 = load i64, i64* %12
%321 = load i64, i64* %11
%322 = sub nsw i64 %320, %321
%323 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.2, i64 0, i64 0), i64 %322)
%324 = getelementptr inbounds [1000 x float], [1000 x float]* %8, i64 0, i64 0
%325 = getelementptr inbounds [1000 x float], [1000 x float]* %9, i64 0, i64 0
%326 = call i64 @memcmp(float* %324, float* %325, i32 4000)
%327 = icmp ne i64 %326, 0
br i1 %327, label %328, label %330
328: ; preds = %318
%329 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.3, i64 0, i64 0))
br label %330
330: ; preds = %328, %318
ret i32 0
}

LLVM IR (-O2):
@.str.1 = [18 x i8] c" Use SSE: %lu\0A\00"
@.str.2 = [18 x i8] c"Not Use SSE: %lu\0A\00"
@str = [8 x i8] c"\E4\B9\98\E6\B3\95:\00"
@str.9 = [10 x i8] c"\E5\8A\A0\E6\B3\95\EF\BC\9A\00"
@str.10 = [10 x i8] c"\E5\B9\B3\E6\96\B9\EF\BC\9A\00"
@str.11 = [13 x i8] c"\E6\9C\80\E5\B0\8F\E5\80\BC\EF\BC\9A\00"
@str.12 = [13 x i8] c"\E6\9C\80\E5\A4\A7\E5\80\BC\EF\BC\9A\00"
@str.13 = [13 x i8] c"\E4\B8\8E\E6\93\8D\E4\BD\9C\EF\BC\9A\00"
@str.19 = [11 x i8] c"check fail\00"
define i32 @main(i32 %0, i8** nocapture readnone %1) {
%3 = alloca [1000 x float]
%4 = alloca [1000 x float]
%5 = alloca [1000 x float]
%6 = alloca [1000 x float]
%7 = bitcast [1000 x float]* %3 to i8*
%8 = bitcast [1000 x float]* %4 to i8*
%9 = bitcast [1000 x float]* %5 to i8*
%10 = bitcast [1000 x float]* %6 to i8*
%11 = tail call i32 (...) @getpid()
%12 = tail call i32 @srandom(i32 %11)
br label %20
13: ; preds = %20
%14 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([8 x i8], [8 x i8]* @str, i64 0, i64 0))
%15 = getelementptr inbounds [1000 x float], [1000 x float]* %3, i64 0, i64 0
%16 = getelementptr inbounds [1000 x float], [1000 x float]* %4, i64 0, i64 0
%17 = call i32 @memcpy(float* %15, float* %16, i32 4000)
%18 = call i64 (...) @now()
%19 = getelementptr inbounds [1000 x float], [1000 x float]* %5, i64 0, i64 0
br label %37
20: ; preds = %2, %20
%21 = phi i64 [ 0, %2 ], [ %28, %20 ]
%22 = tail call i32 (...) @random()
%23 = srem i32 %22, 10000
%24 = sitofp i32 %23 to double
%25 = fdiv double %24, 1.000000e+01
%26 = fptrunc double %25 to float
%27 = getelementptr inbounds [1000 x float], [1000 x float]* %4, i64 0, i64 %21
store float %26, float* %27
%28 = add nuw nsw i64 %21, 1
%29 = icmp eq i64 %28, 1000
br i1 %29, label %13, label %20
30: ; preds = %37
%31 = call i64 (...) @now()
%32 = sub nsw i64 %31, %18
%33 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([18 x i8], [18 x i8]* @.str.1, i64 0, i64 0), i64 %32)
%34 = call i32 @memcpy(float* %15, float* %16, i32 4000)
%35 = call i64 (...) @now()
%36 = getelementptr inbounds [1000 x float], [1000 x float]* %6, i64 0, i64 0
br label %48
37: ; preds = %13, %37
%38 = phi i32 [ 0, %13 ], [ %40, %37 ]
%39 = call i32 @ScaleValue1(float* %19, float* %15, i32 1000, float 1.000000e+03)
%40 = add nuw nsw i32 %38, 1
%41 = icmp eq i32 %40, 10000
br i1 %41, label %30, label %37
42: ; preds = %48
%43 = call i64 (...) @now()
%44 = sub nsw i64 %43, %35
%45 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([18 x i8], [18 x i8]* @.str.2, i64 0, i64 0), i64 %44)
%46 = call i64 @memcmp(float* %19, float* %36, i32 4000)
%47 = icmp eq i64 %46, 0
br i1 %47, label %55, label %53
48: ; preds = %30, %48
%49 = phi i32 [ 0, %30 ], [ %51, %48 ]
%50 = call i32 @ScaleValue2(float* %36, float* %15, i32 1000, float 1.000000e+03)
%51 = add nuw nsw i32 %49, 1
%52 = icmp eq i32 %51, 10000
br i1 %52, label %42, label %48
53: ; preds = %42
%54 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([11 x i8], [11 x i8]* @str.19, i64 0, i64 0))
br label %55
55: ; preds = %53, %42
%56 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([10 x i8], [10 x i8]* @str.9, i64 0, i64 0))
%57 = call i32 @memcpy(float* %15, float* %16, i32 4000)
%58 = call i64 (...) @now()
br label %65
59: ; preds = %65
%60 = call i64 (...) @now()
%61 = sub nsw i64 %60, %58
%62 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([18 x i8], [18 x i8]* @.str.1, i64 0, i64 0), i64 %61)
%63 = call i32 @memcpy(float* %15, float* %16, i32 4000)
%64 = call i64 (...) @now()
br label %76
65: ; preds = %55, %65
%66 = phi i32 [ 0, %55 ], [ %68, %65 ]
%67 = call i32 @Add1(float* %19, float* %15, i32 1000, float 1.000000e+03)
%68 = add nuw nsw i32 %66, 1
%69 = icmp eq i32 %68, 10000
br i1 %69, label %59, label %65
70: ; preds = %76
%71 = call i64 (...) @now()
%72 = sub nsw i64 %71, %64
%73 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([18 x i8], [18 x i8]* @.str.2, i64 0, i64 0), i64 %72)
%74 = call i64 @memcmp(float* %19, float* %36, i32 4000)
%75 = icmp eq i64 %74, 0
br i1 %75, label %83, label %81
76: ; preds = %59, %76
%77 = phi i32 [ 0, %59 ], [ %79, %76 ]
%78 = call i32 @Add2(float* %36, float* %15, i32 1000, float 1.000000e+03)
%79 = add nuw nsw i32 %77, 1
%80 = icmp eq i32 %79, 10000
br i1 %80, label %70, label %76
81: ; preds = %70
%82 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([11 x i8], [11 x i8]* @str.19, i64 0, i64 0))
br label %83
83: ; preds = %81, %70
%84 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([10 x i8], [10 x i8]* @str.10, i64 0, i64 0))
%85 = call i32 @memcpy(float* %15, float* %16, i32 4000)
%86 = call i64 (...) @now()
br label %93
87: ; preds = %93
%88 = call i64 (...) @now()
%89 = sub nsw i64 %88, %86
%90 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([18 x i8], [18 x i8]* @.str.1, i64 0, i64 0), i64 %89)
%91 = call i32 @memcpy(float* %15, float* %16, i32 4000)
%92 = call i64 (...) @now()
br label %104
93: ; preds = %83, %93
%94 = phi i32 [ 0, %83 ], [ %96, %93 ]
%95 = call i32 @Sqrt1(float* %19, float* %15, i32 1000, float 1.000000e+03)
%96 = add nuw nsw i32 %94, 1
%97 = icmp eq i32 %96, 10000
br i1 %97, label %87, label %93
98: ; preds = %104
%99 = call i64 (...) @now()
%100 = sub nsw i64 %99, %92
%101 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([18 x i8], [18 x i8]* @.str.2, i64 0, i64 0), i64 %100)
%102 = call i64 @memcmp(float* %19, float* %36, i32 4000)
%103 = icmp eq i64 %102, 0
br i1 %103, label %111, label %109
104: ; preds = %87, %104
%105 = phi i32 [ 0, %87 ], [ %107, %104 ]
%106 = call i32 @Sqrt2(float* %36, float* %15, i32 1000, float 1.000000e+03)
%107 = add nuw nsw i32 %105, 1
%108 = icmp eq i32 %107, 10000
br i1 %108, label %98, label %104
109: ; preds = %98
%110 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([11 x i8], [11 x i8]* @str.19, i64 0, i64 0))
br label %111
111: ; preds = %109, %98
%112 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([13 x i8], [13 x i8]* @str.11, i64 0, i64 0))
%113 = call i32 @memcpy(float* %15, float* %16, i32 4000)
%114 = call i64 (...) @now()
br label %121
115: ; preds = %121
%116 = call i64 (...) @now()
%117 = sub nsw i64 %116, %114
%118 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([18 x i8], [18 x i8]* @.str.1, i64 0, i64 0), i64 %117)
%119 = call i32 @memcpy(float* %15, float* %16, i32 4000)
%120 = call i64 (...) @now()
br label %132
121: ; preds = %111, %121
%122 = phi i32 [ 0, %111 ], [ %124, %121 ]
%123 = call i32 @Min1(float* %19, float* %15, i32 1000, float 1.000000e+03)
%124 = add nuw nsw i32 %122, 1
%125 = icmp eq i32 %124, 10000
br i1 %125, label %115, label %121
126: ; preds = %132
%127 = call i64 (...) @now()
%128 = sub nsw i64 %127, %120
%129 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([18 x i8], [18 x i8]* @.str.2, i64 0, i64 0), i64 %128)
%130 = call i64 @memcmp(float* %19, float* %36, i32 4000)
%131 = icmp eq i64 %130, 0
br i1 %131, label %139, label %137
132: ; preds = %115, %132
%133 = phi i32 [ 0, %115 ], [ %135, %132 ]
%134 = call i32 @Min2(float* %36, float* %15, i32 1000, float 1.000000e+03)
%135 = add nuw nsw i32 %133, 1
%136 = icmp eq i32 %135, 10000
br i1 %136, label %126, label %132
137: ; preds = %126
%138 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([11 x i8], [11 x i8]* @str.19, i64 0, i64 0))
br label %139
139: ; preds = %137, %126
%140 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([13 x i8], [13 x i8]* @str.12, i64 0, i64 0))
%141 = call i32 @memcpy(float* %15, float* %16, i32 4000)
%142 = call i64 (...) @now()
br label %149
143: ; preds = %149
%144 = call i64 (...) @now()
%145 = sub nsw i64 %144, %142
%146 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([18 x i8], [18 x i8]* @.str.1, i64 0, i64 0), i64 %145)
%147 = call i32 @memcpy(float* %15, float* %16, i32 4000)
%148 = call i64 (...) @now()
br label %160
149: ; preds = %139, %149
%150 = phi i32 [ 0, %139 ], [ %152, %149 ]
%151 = call i32 @Max1(float* %19, float* %15, i32 1000, float 1.000000e+03)
%152 = add nuw nsw i32 %150, 1
%153 = icmp eq i32 %152, 10000
br i1 %153, label %143, label %149
154: ; preds = %160
%155 = call i64 (...) @now()
%156 = sub nsw i64 %155, %148
%157 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([18 x i8], [18 x i8]* @.str.2, i64 0, i64 0), i64 %156)
%158 = call i64 @memcmp(float* %19, float* %36, i32 4000)
%159 = icmp eq i64 %158, 0
br i1 %159, label %167, label %165
160: ; preds = %143, %160
%161 = phi i32 [ 0, %143 ], [ %163, %160 ]
%162 = call i32 @Max2(float* %36, float* %15, i32 1000, float 1.000000e+03)
%163 = add nuw nsw i32 %161, 1
%164 = icmp eq i32 %163, 10000
br i1 %164, label %154, label %160
165: ; preds = %154
%166 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([11 x i8], [11 x i8]* @str.19, i64 0, i64 0))
br label %167
167: ; preds = %165, %154
%168 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([13 x i8], [13 x i8]* @str.13, i64 0, i64 0))
%169 = call i32 @memcpy(float* %15, float* %16, i32 4000)
%170 = call i64 (...) @now()
br label %177
171: ; preds = %177
%172 = call i64 (...) @now()
%173 = sub nsw i64 %172, %170
%174 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([18 x i8], [18 x i8]* @.str.1, i64 0, i64 0), i64 %173)
%175 = call i32 @memcpy(float* %15, float* %16, i32 4000)
%176 = call i64 (...) @now()
br label %188
177: ; preds = %167, %177
%178 = phi i32 [ 0, %167 ], [ %180, %177 ]
%179 = call i32 @And1(float* %19, float* %15, i32 1000, float 1.000000e+03)
%180 = add nuw nsw i32 %178, 1
%181 = icmp eq i32 %180, 10000
br i1 %181, label %171, label %177
182: ; preds = %188
%183 = call i64 (...) @now()
%184 = sub nsw i64 %183, %176
%185 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([18 x i8], [18 x i8]* @.str.2, i64 0, i64 0), i64 %184)
%186 = call i64 @memcmp(float* %19, float* %36, i32 4000)
%187 = icmp eq i64 %186, 0
br i1 %187, label %195, label %193
188: ; preds = %171, %188
%189 = phi i32 [ 0, %171 ], [ %191, %188 ]
%190 = call i32 @And2(float* %36, float* %15, i32 1000, float 1.000000e+03)
%191 = add nuw nsw i32 %189, 1
%192 = icmp eq i32 %191, 10000
br i1 %192, label %182, label %188
193: ; preds = %182
%194 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([11 x i8], [11 x i8]* @str.19, i64 0, i64 0))
br label %195
195: ; preds = %193, %182
ret i32 0
}