#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 int /*<<< orphan*/ picture;
typedef int /*<<< orphan*/ FILE;

/* Variables and functions */
double M_PI;
int /*<<< orphan*/ MapCoord(int, int, int, double *);
double atan2(double, double);
double exp(int);
int /*<<< orphan*/ fclose(int /*<<< orphan*/ *);
int /*<<< orphan*/ *fopen(char *, char *);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/, char *, ...);
int /*<<< orphan*/ fread(unsigned char ****, int, int, int /*<<< orphan*/ *);
int /*<<< orphan*/ perror(char *);
double pow(double, double);
int /*<<< orphan*/ printf(char *, double, double);
double sqrt(double);
int /*<<< orphan*/ stderr;
int main(int argc, char **argv) {
  FILE *f;
  int i, j, k;
  unsigned char picture[6][512][512];
  unsigned char max;
  double brightvec[3];
  double pitch, yaw, l;
  if (argc != 2) {
    fprintf(stderr, "Usage: %s imagefile.gray\n", *argv);
    return 1;
  }
  f = fopen(argv[1], "rb");
  if (!f) {
    perror("fopen");
    return 1;
  }
  fread(&picture, sizeof(picture), 1, f);
  fclose(f);
  brightvec[0] = brightvec[1] = brightvec[2] = 0;
  max = 0;
  for (i = 0; i < 6; ++i)
    for (j = 0; j < 512; ++j)
      for (k = 0; k < 512; ++k)
        if (picture[i][j][k] > max)
          max = picture[i][j][k];
  for (i = 0; i < 6; ++i)
    for (j = 0; j < 512; ++j)
      for (k = 0; k < 512; ++k) {
        double vec[3], f;
        MapCoord(i, j, k, vec);
        f = pow(vec[0] * vec[0] + vec[1] * vec[1] + vec[2] * vec[2], -1.5);
        f *= exp(10 * (picture[i][j][k] - max));
        brightvec[0] += f * vec[0];
        brightvec[1] += f * vec[1];
        brightvec[2] += f * vec[2];
      }
  l = sqrt(brightvec[0] * brightvec[0] + brightvec[1] * brightvec[1] +
           brightvec[2] * brightvec[2]);
  fprintf(stderr, "vec = %f %f %f\n", brightvec[0] / l, brightvec[1] / l,
          brightvec[2] / l);
  pitch = atan2(brightvec[2], sqrt(brightvec[0] * brightvec[0] +
                                   brightvec[1] * brightvec[1]));
  yaw = atan2(brightvec[1], brightvec[0]);
  printf("%f %f\n", yaw * 180 / M_PI, pitch * 180 / M_PI);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x180090,%rsp
movl   $0x0,-0x4(%rbp)
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
cmpl   $0x2,-0x8(%rbp)
je     11fd <main+0x4d>
mov    0x2dfe(%rip),%rax
mov    (%rax),%edi
mov    -0x10(%rbp),%rax
mov    (%rax),%rdx
lea    0xe26(%rip),%rsi
mov    $0x0,%al
call   1070 <fprintf@plt>
movl   $0x1,-0x4(%rbp)
jmp    1637 <main+0x487>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rdi
lea    0xe1e(%rip),%rsi
call   1090 <fopen@plt>
mov    %rax,-0x18(%rbp)
cmpq   $0x0,-0x18(%rbp)
jne    1238 <main+0x88>
lea    0xe06(%rip),%rdi
call   10b0 <perror@plt>
movl   $0x1,-0x4(%rbp)
jmp    1637 <main+0x487>
lea    -0x180030(%rbp),%rdi
mov    -0x18(%rbp),%rcx
mov    $0x180000,%esi
mov    $0x1,%edx
call   1030 <fread@plt>
mov    -0x18(%rbp),%rdi
call   1050 <fclose@plt>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x180040(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x180048(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x180050(%rbp)
ff
movb   $0x0,-0x180031(%rbp)
movl   $0x0,-0x1c(%rbp)
cmpl   $0x6,-0x1c(%rbp)
jge    1353 <main+0x1a3>
movl   $0x0,-0x20(%rbp)
cmpl   $0x200,-0x20(%rbp)
jge    1340 <main+0x190>
movl   $0x0,-0x24(%rbp)
cmpl   $0x200,-0x24(%rbp)
jge    132d <main+0x17d>
movslq -0x1c(%rbp),%rcx
lea    -0x180030(%rbp),%rax
shl    $0x12,%rcx
add    %rcx,%rax
movslq -0x20(%rbp),%rcx
shl    $0x9,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
movzbl -0x180031(%rbp),%ecx
cmp    %ecx,%eax
jle    131a <main+0x16a>
movslq -0x1c(%rbp),%rcx
lea    -0x180030(%rbp),%rax
shl    $0x12,%rcx
add    %rcx,%rax
movslq -0x20(%rbp),%rcx
shl    $0x9,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x180031(%rbp)
jmp    131f <main+0x16f>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    12af <main+0xff>
jmp    1332 <main+0x182>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    129b <main+0xeb>
jmp    1345 <main+0x195>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    128a <main+0xda>
movl   $0x0,-0x1c(%rbp)
cmpl   $0x6,-0x1c(%rbp)
jge    14e8 <main+0x338>
movl   $0x0,-0x20(%rbp)
cmpl   $0x200,-0x20(%rbp)
jge    14d5 <main+0x325>
movl   $0x0,-0x24(%rbp)
cmpl   $0x200,-0x24(%rbp)
jge    14c2 <main+0x312>
mov    -0x1c(%rbp),%edi
mov    -0x20(%rbp),%esi
mov    -0x24(%rbp),%edx
lea    -0x180080(%rbp),%rcx
call   10c0 <MapCoord@plt>
movsd  -0x180080(%rbp),%xmm1
ff
movsd  -0x180080(%rbp),%xmm2
ff
movsd  -0x180078(%rbp),%xmm0
ff
mulsd  -0x180078(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x180070(%rbp),%xmm0
ff
movsd  -0x180070(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  0xc1f(%rip),%xmm1
call   10a0 <pow@plt>
movsd  %xmm0,-0x180088(%rbp)
ff
movslq -0x1c(%rbp),%rcx
lea    -0x180030(%rbp),%rax
shl    $0x12,%rcx
add    %rcx,%rax
movslq -0x20(%rbp),%rcx
shl    $0x9,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
movzbl -0x180031(%rbp),%ecx
sub    %ecx,%eax
imul   $0xa,%eax,%edi
call   1080 <exp@plt>
mulsd  -0x180088(%rbp),%xmm0
ff
movsd  %xmm0,-0x180088(%rbp)
ff
movsd  -0x180088(%rbp),%xmm0
ff
movsd  -0x180080(%rbp),%xmm2
ff
movsd  -0x180050(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x180050(%rbp)
ff
movsd  -0x180088(%rbp),%xmm0
ff
movsd  -0x180078(%rbp),%xmm2
ff
movsd  -0x180048(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x180048(%rbp)
ff
movsd  -0x180088(%rbp),%xmm0
ff
movsd  -0x180070(%rbp),%xmm2
ff
movsd  -0x180040(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x180040(%rbp)
ff
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    137f <main+0x1cf>
jmp    14c7 <main+0x317>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    136b <main+0x1bb>
jmp    14da <main+0x32a>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    135a <main+0x1aa>
movsd  -0x180050(%rbp),%xmm1
ff
movsd  -0x180050(%rbp),%xmm2
ff
movsd  -0x180048(%rbp),%xmm0
ff
mulsd  -0x180048(%rbp),%xmm0
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x180040(%rbp),%xmm0
ff
movsd  -0x180040(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   10d0 <sqrt@plt>
movsd  %xmm0,-0x180068(%rbp)
ff
mov    0x2a9c(%rip),%rax
mov    (%rax),%edi
movsd  -0x180050(%rbp),%xmm0
ff
divsd  -0x180068(%rbp),%xmm0
ff
movsd  -0x180048(%rbp),%xmm1
ff
divsd  -0x180068(%rbp),%xmm1
ff
movsd  -0x180040(%rbp),%xmm2
ff
divsd  -0x180068(%rbp),%xmm2
ff
lea    0xabe(%rip),%rsi
mov    $0x3,%al
call   1070 <fprintf@plt>
movsd  -0x180040(%rbp),%xmm0
ff
movsd  %xmm0,-0x180090(%rbp)
ff
movsd  -0x180050(%rbp),%xmm0
ff
movsd  -0x180050(%rbp),%xmm2
ff
movsd  -0x180048(%rbp),%xmm1
ff
mulsd  -0x180048(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   10d0 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  -0x180090(%rbp),%xmm0
ff
call   1040 <atan2@plt>
movsd  %xmm0,-0x180058(%rbp)
ff
movsd  -0x180048(%rbp),%xmm0
ff
movsd  -0x180050(%rbp),%xmm1
ff
call   1040 <atan2@plt>
movsd  %xmm0,-0x180060(%rbp)
ff
movsd  0xa0a(%rip),%xmm0
mulsd  -0x180060(%rbp),%xmm0
ff
mov    0x29e3(%rip),%rax
divsd  (%rax),%xmm0
movsd  0x9ef(%rip),%xmm1
mulsd  -0x180058(%rbp),%xmm1
ff
mov    0x29c8(%rip),%rax
divsd  (%rax),%xmm1
lea    0xa11(%rip),%rdi
call   1060 <printf@plt>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x180090,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x180068,%rsp
cmp    $0x2,%edi
jne    1cb9 <main+0xb09>
mov    0x8(%rsi),%rdi
lea    0xe5d(%rip),%rsi
call   1090 <fopen@plt>
test   %rax,%rax
je     1dab <main+0xbfb>
mov    %rax,%rbp
lea    0x60(%rsp),%r14
mov    %r14,%rdi
mov    $0x180000,%esi
mov    $0x1,%edx
mov    %rax,%rcx
call   1030 <fread@plt>
mov    %rbp,%rdi
call   1050 <fclose@plt>
xor    %eax,%eax
xor    %ecx,%ecx
nopl   0x0(%rax)
movzbl %cl,%ecx
movd   %ecx,%xmm0
punpcklbw %xmm0,%xmm0
pshuflw $0x0,%xmm0,%xmm0
pshufd $0x0,%xmm0,%xmm0
movdqa 0x60(%rsp,%rax,1),%xmm1
pmaxub %xmm0,%xmm1
pmaxub 0x70(%rsp,%rax,1),%xmm0
pmaxub 0x80(%rsp,%rax,1),%xmm1
pmaxub 0x90(%rsp,%rax,1),%xmm0
pmaxub 0xa0(%rsp,%rax,1),%xmm1
pmaxub 0xb0(%rsp,%rax,1),%xmm0
pmaxub 0xc0(%rsp,%rax,1),%xmm1
pmaxub 0xd0(%rsp,%rax,1),%xmm0
pmaxub 0xe0(%rsp,%rax,1),%xmm1
pmaxub 0xf0(%rsp,%rax,1),%xmm0
pmaxub 0x100(%rsp,%rax,1),%xmm1
pmaxub 0x110(%rsp,%rax,1),%xmm0
pmaxub 0x120(%rsp,%rax,1),%xmm1
pmaxub 0x130(%rsp,%rax,1),%xmm0
pmaxub 0x140(%rsp,%rax,1),%xmm1
pmaxub 0x150(%rsp,%rax,1),%xmm0
pmaxub 0x160(%rsp,%rax,1),%xmm1
pmaxub 0x170(%rsp,%rax,1),%xmm0
pmaxub 0x180(%rsp,%rax,1),%xmm1
pmaxub 0x190(%rsp,%rax,1),%xmm0
pmaxub 0x1a0(%rsp,%rax,1),%xmm1
pmaxub 0x1b0(%rsp,%rax,1),%xmm0
pmaxub 0x1c0(%rsp,%rax,1),%xmm1
pmaxub 0x1d0(%rsp,%rax,1),%xmm0
pmaxub 0x1e0(%rsp,%rax,1),%xmm1
pmaxub 0x1f0(%rsp,%rax,1),%xmm0
pmaxub 0x200(%rsp,%rax,1),%xmm1
pmaxub 0x210(%rsp,%rax,1),%xmm0
pmaxub 0x220(%rsp,%rax,1),%xmm1
pmaxub 0x230(%rsp,%rax,1),%xmm0
pmaxub 0x240(%rsp,%rax,1),%xmm1
pmaxub 0x250(%rsp,%rax,1),%xmm0
pmaxub %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
pmaxub %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
pmaxub %xmm1,%xmm0
movdqa %xmm0,%xmm1
psrld  $0x10,%xmm1
pmaxub %xmm0,%xmm1
movdqa %xmm1,%xmm0
psrlw  $0x8,%xmm0
pmaxub %xmm1,%xmm0
movd   %xmm0,%ecx
add    $0x200,%rax
cmp    $0x40000,%rax
jne    1210 <main+0x60>
xor    %eax,%eax
nopl   0x0(%rax,%rax,1)
movzbl %cl,%ecx
movd   %ecx,%xmm0
punpcklbw %xmm0,%xmm0
pshuflw $0x0,%xmm0,%xmm0
pshufd $0x0,%xmm0,%xmm0
movdqa 0x40060(%rsp,%rax,1),%xmm1
pmaxub %xmm0,%xmm1
pmaxub 0x40070(%rsp,%rax,1),%xmm0
pmaxub 0x40080(%rsp,%rax,1),%xmm1
pmaxub 0x40090(%rsp,%rax,1),%xmm0
pmaxub 0x400a0(%rsp,%rax,1),%xmm1
pmaxub 0x400b0(%rsp,%rax,1),%xmm0
pmaxub 0x400c0(%rsp,%rax,1),%xmm1
pmaxub 0x400d0(%rsp,%rax,1),%xmm0
pmaxub 0x400e0(%rsp,%rax,1),%xmm1
pmaxub 0x400f0(%rsp,%rax,1),%xmm0
pmaxub 0x40100(%rsp,%rax,1),%xmm1
pmaxub 0x40110(%rsp,%rax,1),%xmm0
pmaxub 0x40120(%rsp,%rax,1),%xmm1
pmaxub 0x40130(%rsp,%rax,1),%xmm0
pmaxub 0x40140(%rsp,%rax,1),%xmm1
pmaxub 0x40150(%rsp,%rax,1),%xmm0
pmaxub 0x40160(%rsp,%rax,1),%xmm1
pmaxub 0x40170(%rsp,%rax,1),%xmm0
pmaxub 0x40180(%rsp,%rax,1),%xmm1
pmaxub 0x40190(%rsp,%rax,1),%xmm0
pmaxub 0x401a0(%rsp,%rax,1),%xmm1
pmaxub 0x401b0(%rsp,%rax,1),%xmm0
pmaxub 0x401c0(%rsp,%rax,1),%xmm1
pmaxub 0x401d0(%rsp,%rax,1),%xmm0
pmaxub 0x401e0(%rsp,%rax,1),%xmm1
pmaxub 0x401f0(%rsp,%rax,1),%xmm0
pmaxub 0x40200(%rsp,%rax,1),%xmm1
pmaxub 0x40210(%rsp,%rax,1),%xmm0
pmaxub 0x40220(%rsp,%rax,1),%xmm1
pmaxub 0x40230(%rsp,%rax,1),%xmm0
pmaxub 0x40240(%rsp,%rax,1),%xmm1
pmaxub 0x40250(%rsp,%rax,1),%xmm0
pmaxub %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
pmaxub %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
pmaxub %xmm1,%xmm0
movdqa %xmm0,%xmm1
psrld  $0x10,%xmm1
pmaxub %xmm0,%xmm1
movdqa %xmm1,%xmm0
psrlw  $0x8,%xmm0
pmaxub %xmm1,%xmm0
movd   %xmm0,%ecx
add    $0x200,%rax
cmp    $0x40000,%rax
jne    1390 <main+0x1e0>
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movzbl %cl,%ecx
movd   %ecx,%xmm0
punpcklbw %xmm0,%xmm0
pshuflw $0x0,%xmm0,%xmm0
pshufd $0x0,%xmm0,%xmm0
movdqa 0x80060(%rsp,%rax,1),%xmm1
pmaxub %xmm0,%xmm1
pmaxub 0x80070(%rsp,%rax,1),%xmm0
pmaxub 0x80080(%rsp,%rax,1),%xmm1
pmaxub 0x80090(%rsp,%rax,1),%xmm0
pmaxub 0x800a0(%rsp,%rax,1),%xmm1
pmaxub 0x800b0(%rsp,%rax,1),%xmm0
pmaxub 0x800c0(%rsp,%rax,1),%xmm1
pmaxub 0x800d0(%rsp,%rax,1),%xmm0
pmaxub 0x800e0(%rsp,%rax,1),%xmm1
pmaxub 0x800f0(%rsp,%rax,1),%xmm0
pmaxub 0x80100(%rsp,%rax,1),%xmm1
pmaxub 0x80110(%rsp,%rax,1),%xmm0
pmaxub 0x80120(%rsp,%rax,1),%xmm1
pmaxub 0x80130(%rsp,%rax,1),%xmm0
pmaxub 0x80140(%rsp,%rax,1),%xmm1
pmaxub 0x80150(%rsp,%rax,1),%xmm0
pmaxub 0x80160(%rsp,%rax,1),%xmm1
pmaxub 0x80170(%rsp,%rax,1),%xmm0
pmaxub 0x80180(%rsp,%rax,1),%xmm1
pmaxub 0x80190(%rsp,%rax,1),%xmm0
pmaxub 0x801a0(%rsp,%rax,1),%xmm1
pmaxub 0x801b0(%rsp,%rax,1),%xmm0
pmaxub 0x801c0(%rsp,%rax,1),%xmm1
pmaxub 0x801d0(%rsp,%rax,1),%xmm0
pmaxub 0x801e0(%rsp,%rax,1),%xmm1
pmaxub 0x801f0(%rsp,%rax,1),%xmm0
pmaxub 0x80200(%rsp,%rax,1),%xmm1
pmaxub 0x80210(%rsp,%rax,1),%xmm0
pmaxub 0x80220(%rsp,%rax,1),%xmm1
pmaxub 0x80230(%rsp,%rax,1),%xmm0
pmaxub 0x80240(%rsp,%rax,1),%xmm1
pmaxub 0x80250(%rsp,%rax,1),%xmm0
pmaxub %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
pmaxub %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
pmaxub %xmm1,%xmm0
movdqa %xmm0,%xmm1
psrld  $0x10,%xmm1
pmaxub %xmm0,%xmm1
movdqa %xmm1,%xmm0
psrlw  $0x8,%xmm0
pmaxub %xmm1,%xmm0
movd   %xmm0,%ecx
add    $0x200,%rax
cmp    $0x40000,%rax
jne    1520 <main+0x370>
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movzbl %cl,%ecx
movd   %ecx,%xmm0
punpcklbw %xmm0,%xmm0
pshuflw $0x0,%xmm0,%xmm0
pshufd $0x0,%xmm0,%xmm0
movdqa 0xc0060(%rsp,%rax,1),%xmm1
pmaxub %xmm0,%xmm1
pmaxub 0xc0070(%rsp,%rax,1),%xmm0
pmaxub 0xc0080(%rsp,%rax,1),%xmm1
pmaxub 0xc0090(%rsp,%rax,1),%xmm0
pmaxub 0xc00a0(%rsp,%rax,1),%xmm1
pmaxub 0xc00b0(%rsp,%rax,1),%xmm0
pmaxub 0xc00c0(%rsp,%rax,1),%xmm1
pmaxub 0xc00d0(%rsp,%rax,1),%xmm0
pmaxub 0xc00e0(%rsp,%rax,1),%xmm1
pmaxub 0xc00f0(%rsp,%rax,1),%xmm0
pmaxub 0xc0100(%rsp,%rax,1),%xmm1
pmaxub 0xc0110(%rsp,%rax,1),%xmm0
pmaxub 0xc0120(%rsp,%rax,1),%xmm1
pmaxub 0xc0130(%rsp,%rax,1),%xmm0
pmaxub 0xc0140(%rsp,%rax,1),%xmm1
pmaxub 0xc0150(%rsp,%rax,1),%xmm0
pmaxub 0xc0160(%rsp,%rax,1),%xmm1
pmaxub 0xc0170(%rsp,%rax,1),%xmm0
pmaxub 0xc0180(%rsp,%rax,1),%xmm1
pmaxub 0xc0190(%rsp,%rax,1),%xmm0
pmaxub 0xc01a0(%rsp,%rax,1),%xmm1
pmaxub 0xc01b0(%rsp,%rax,1),%xmm0
pmaxub 0xc01c0(%rsp,%rax,1),%xmm1
pmaxub 0xc01d0(%rsp,%rax,1),%xmm0
pmaxub 0xc01e0(%rsp,%rax,1),%xmm1
pmaxub 0xc01f0(%rsp,%rax,1),%xmm0
pmaxub 0xc0200(%rsp,%rax,1),%xmm1
pmaxub 0xc0210(%rsp,%rax,1),%xmm0
pmaxub 0xc0220(%rsp,%rax,1),%xmm1
pmaxub 0xc0230(%rsp,%rax,1),%xmm0
pmaxub 0xc0240(%rsp,%rax,1),%xmm1
pmaxub 0xc0250(%rsp,%rax,1),%xmm0
pmaxub %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
pmaxub %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
pmaxub %xmm1,%xmm0
movdqa %xmm0,%xmm1
psrld  $0x10,%xmm1
pmaxub %xmm0,%xmm1
movdqa %xmm1,%xmm0
psrlw  $0x8,%xmm0
pmaxub %xmm1,%xmm0
movd   %xmm0,%ecx
add    $0x200,%rax
cmp    $0x40000,%rax
jne    16b0 <main+0x500>
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movzbl %cl,%ecx
movd   %ecx,%xmm0
punpcklbw %xmm0,%xmm0
pshuflw $0x0,%xmm0,%xmm0
pshufd $0x0,%xmm0,%xmm0
movdqa 0x100060(%rsp,%rax,1),%xmm1
pmaxub %xmm0,%xmm1
pmaxub 0x100070(%rsp,%rax,1),%xmm0
pmaxub 0x100080(%rsp,%rax,1),%xmm1
pmaxub 0x100090(%rsp,%rax,1),%xmm0
pmaxub 0x1000a0(%rsp,%rax,1),%xmm1
pmaxub 0x1000b0(%rsp,%rax,1),%xmm0
pmaxub 0x1000c0(%rsp,%rax,1),%xmm1
pmaxub 0x1000d0(%rsp,%rax,1),%xmm0
pmaxub 0x1000e0(%rsp,%rax,1),%xmm1
pmaxub 0x1000f0(%rsp,%rax,1),%xmm0
pmaxub 0x100100(%rsp,%rax,1),%xmm1
pmaxub 0x100110(%rsp,%rax,1),%xmm0
pmaxub 0x100120(%rsp,%rax,1),%xmm1
pmaxub 0x100130(%rsp,%rax,1),%xmm0
pmaxub 0x100140(%rsp,%rax,1),%xmm1
pmaxub 0x100150(%rsp,%rax,1),%xmm0
pmaxub 0x100160(%rsp,%rax,1),%xmm1
pmaxub 0x100170(%rsp,%rax,1),%xmm0
pmaxub 0x100180(%rsp,%rax,1),%xmm1
pmaxub 0x100190(%rsp,%rax,1),%xmm0
pmaxub 0x1001a0(%rsp,%rax,1),%xmm1
pmaxub 0x1001b0(%rsp,%rax,1),%xmm0
pmaxub 0x1001c0(%rsp,%rax,1),%xmm1
pmaxub 0x1001d0(%rsp,%rax,1),%xmm0
pmaxub 0x1001e0(%rsp,%rax,1),%xmm1
pmaxub 0x1001f0(%rsp,%rax,1),%xmm0
pmaxub 0x100200(%rsp,%rax,1),%xmm1
pmaxub 0x100210(%rsp,%rax,1),%xmm0
pmaxub 0x100220(%rsp,%rax,1),%xmm1
pmaxub 0x100230(%rsp,%rax,1),%xmm0
pmaxub 0x100240(%rsp,%rax,1),%xmm1
pmaxub 0x100250(%rsp,%rax,1),%xmm0
pmaxub %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
pmaxub %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
pmaxub %xmm1,%xmm0
movdqa %xmm0,%xmm1
psrld  $0x10,%xmm1
pmaxub %xmm0,%xmm1
movdqa %xmm1,%xmm0
psrlw  $0x8,%xmm0
pmaxub %xmm1,%xmm0
movd   %xmm0,%ecx
add    $0x200,%rax
cmp    $0x40000,%rax
jne    1840 <main+0x690>
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movzbl %cl,%ecx
movd   %ecx,%xmm0
punpcklbw %xmm0,%xmm0
pshuflw $0x0,%xmm0,%xmm0
pshufd $0x0,%xmm0,%xmm0
movdqa 0x140060(%rsp,%rax,1),%xmm1
pmaxub %xmm0,%xmm1
pmaxub 0x140070(%rsp,%rax,1),%xmm0
pmaxub 0x140080(%rsp,%rax,1),%xmm1
pmaxub 0x140090(%rsp,%rax,1),%xmm0
pmaxub 0x1400a0(%rsp,%rax,1),%xmm1
pmaxub 0x1400b0(%rsp,%rax,1),%xmm0
pmaxub 0x1400c0(%rsp,%rax,1),%xmm1
pmaxub 0x1400d0(%rsp,%rax,1),%xmm0
pmaxub 0x1400e0(%rsp,%rax,1),%xmm1
pmaxub 0x1400f0(%rsp,%rax,1),%xmm0
pmaxub 0x140100(%rsp,%rax,1),%xmm1
pmaxub 0x140110(%rsp,%rax,1),%xmm0
pmaxub 0x140120(%rsp,%rax,1),%xmm1
pmaxub 0x140130(%rsp,%rax,1),%xmm0
pmaxub 0x140140(%rsp,%rax,1),%xmm1
pmaxub 0x140150(%rsp,%rax,1),%xmm0
pmaxub 0x140160(%rsp,%rax,1),%xmm1
pmaxub 0x140170(%rsp,%rax,1),%xmm0
pmaxub 0x140180(%rsp,%rax,1),%xmm1
pmaxub 0x140190(%rsp,%rax,1),%xmm0
pmaxub 0x1401a0(%rsp,%rax,1),%xmm1
pmaxub 0x1401b0(%rsp,%rax,1),%xmm0
pmaxub 0x1401c0(%rsp,%rax,1),%xmm1
pmaxub 0x1401d0(%rsp,%rax,1),%xmm0
pmaxub 0x1401e0(%rsp,%rax,1),%xmm1
pmaxub 0x1401f0(%rsp,%rax,1),%xmm0
pmaxub 0x140200(%rsp,%rax,1),%xmm1
pmaxub 0x140210(%rsp,%rax,1),%xmm0
pmaxub 0x140220(%rsp,%rax,1),%xmm1
pmaxub 0x140230(%rsp,%rax,1),%xmm0
pmaxub 0x140240(%rsp,%rax,1),%xmm1
pmaxub 0x140250(%rsp,%rax,1),%xmm0
pmaxub %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
pmaxub %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
pmaxub %xmm1,%xmm0
movdqa %xmm0,%xmm1
psrld  $0x10,%xmm1
pmaxub %xmm0,%xmm1
movdqa %xmm1,%xmm0
psrlw  $0x8,%xmm0
pmaxub %xmm1,%xmm0
movd   %xmm0,%ecx
add    $0x200,%rax
cmp    $0x40000,%rax
jne    19d0 <main+0x820>
movzbl %cl,%ebp
xorpd  %xmm3,%xmm3
xorpd  %xmm2,%xmm2
xor    %r12d,%r12d
lea    0x40(%rsp),%r15
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %r14,0x30(%rsp)
xor    %r13d,%r13d
nopl   0x0(%rax,%rax,1)
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  %xmm2,0x8(%rsp)
movapd %xmm3,0x10(%rsp)
mov    %r12d,%edi
mov    %r13d,%esi
mov    %ebx,%edx
mov    %r15,%rcx
call   10c0 <MapCoord@plt>
movsd  0x40(%rsp),%xmm1
movsd  0x48(%rsp),%xmm0
mulsd  %xmm0,%xmm0
mulsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
movsd  0x50(%rsp),%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
movsd  0x426(%rip),%xmm1
call   10a0 <pow@plt>
movsd  %xmm0,0x20(%rsp)
movzbl (%r14,%rbx,1),%eax
sub    %ebp,%eax
add    %eax,%eax
lea    (%rax,%rax,4),%edi
call   1080 <exp@plt>
mulsd  0x20(%rsp),%xmm0
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
mulpd  0x40(%rsp),%xmm1
mulsd  0x50(%rsp),%xmm0
movapd 0x10(%rsp),%xmm2
addpd  %xmm1,%xmm2
movapd %xmm2,0x10(%rsp)
movsd  0x8(%rsp),%xmm2
movapd 0x10(%rsp),%xmm3
addsd  %xmm0,%xmm2
add    $0x1,%rbx
cmp    $0x200,%rbx
jne    1b90 <main+0x9e0>
add    $0x1,%r13
add    $0x200,%r14
cmp    $0x200,%r13
jne    1b80 <main+0x9d0>
add    $0x1,%r12
mov    0x30(%rsp),%r14
add    $0x40000,%r14
cmp    $0x6,%r12
jne    1b70 <main+0x9c0>
movapd %xmm3,%xmm0
unpckhpd %xmm3,%xmm0
movapd %xmm0,0x20(%rsp)
mulsd  %xmm0,%xmm0
movapd %xmm3,%xmm1
mulsd  %xmm3,%xmm1
addsd  %xmm0,%xmm1
movapd %xmm2,%xmm0
mulsd  %xmm2,%xmm0
movapd %xmm1,0x30(%rsp)
addsd  %xmm1,%xmm0
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
movsd  %xmm2,0x8(%rsp)
jb     1cdd <main+0xb2d>
sqrtsd %xmm0,%xmm0
jmp    1cee <main+0xb3e>
mov    0x2318(%rip),%rax
mov    (%rax),%edi
mov    (%rsi),%rdx
lea    0x34c(%rip),%rsi
xor    %eax,%eax
call   1070 <fprintf@plt>
mov    $0x1,%eax
jmp    1d99 <main+0xbe9>
call   10d0 <sqrt@plt>
movsd  0x8(%rsp),%xmm2
movapd 0x10(%rsp),%xmm3
mov    0x22e3(%rip),%rax
mov    (%rax),%edi
divsd  %xmm0,%xmm3
movapd 0x20(%rsp),%xmm1
divsd  %xmm0,%xmm1
divsd  %xmm0,%xmm2
lea    0x32b(%rip),%rsi
movapd %xmm3,%xmm0
mov    $0x3,%al
call   1070 <fprintf@plt>
movapd 0x30(%rsp),%xmm0
ucomisd 0x2e7(%rip),%xmm0
jb     1d34 <main+0xb84>
xorps  %xmm1,%xmm1
sqrtsd %xmm0,%xmm1
jmp    1d3d <main+0xb8d>
call   10d0 <sqrt@plt>
movapd %xmm0,%xmm1
movsd  0x8(%rsp),%xmm0
call   1040 <atan2@plt>
movsd  %xmm0,0x8(%rsp)
movapd 0x20(%rsp),%xmm0
movaps 0x10(%rsp),%xmm1
call   1040 <atan2@plt>
movsd  0x2a2(%rip),%xmm1
mulsd  %xmm1,%xmm0
mov    0x2277(%rip),%rax
movsd  (%rax),%xmm2
divsd  %xmm2,%xmm0
movsd  0x8(%rsp),%xmm3
mulsd  %xmm1,%xmm3
divsd  %xmm2,%xmm3
movapd %xmm3,%xmm1
lea    0x2b2(%rip),%rdi
call   1060 <printf@plt>
xor    %eax,%eax
add    $0x180068,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    0x283(%rip),%rdi
call   10b0 <perror@plt>
mov    $0x1,%eax
jmp    1d99 <main+0xbe9>

LLVM IR (-O0):
@stderr = global i32 0
@.str = [26 x i8] c"Usage: %s imagefile.gray\0A\00"
@.str.1 = [3 x i8] c"rb\00"
@.str.2 = [6 x i8] c"fopen\00"
@.str.3 = [16 x i8] c"vec = %f %f %f\0A\00"
@.str.4 = [7 x i8] c"%f %f\0A\00"
@M_PI = global double 0.000000e+00
define i32 @main(i32 %0, i8** %1) {
%3 = alloca i32
%4 = alloca i32
%5 = alloca i8**
%6 = alloca i32*
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca [6 x [512 x [512 x i8]]]
%11 = alloca i8
%12 = alloca [3 x double]
%13 = alloca double
%14 = alloca double
%15 = alloca double
%16 = alloca [3 x double]
%17 = alloca double
store i32 0, i32* %3
store i32 %0, i32* %4
store i8** %1, i8*** %5
%18 = load i32, i32* %4
%19 = icmp ne i32 %18, 2
br i1 %19, label %20, label %25
20: ; preds = %2
%21 = load i32, i32* @stderr
%22 = load i8**, i8*** %5
%23 = load i8*, i8** %22
%24 = call i32 (i32, i8*, ...) @fprintf(i32 %21, i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str, i64 0, i64 0), i8* %23)
store i32 1, i32* %3
br label %232
25: ; preds = %2
%26 = load i8**, i8*** %5
%27 = getelementptr inbounds i8*, i8** %26, i64 1
%28 = load i8*, i8** %27
%29 = call i32* @fopen(i8* %28, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
store i32* %29, i32** %6
%30 = load i32*, i32** %6
%31 = icmp ne i32* %30, null
br i1 %31, label %34, label %32
32: ; preds = %25
%33 = call i32 @perror(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.2, i64 0, i64 0))
store i32 1, i32* %3
br label %232
34: ; preds = %25
%35 = bitcast [6 x [512 x [512 x i8]]]* %10 to i8****
%36 = load i32*, i32** %6
%37 = call i32 @fread(i8**** %35, i32 1572864, i32 1, i32* %36)
%38 = load i32*, i32** %6
%39 = call i32 @fclose(i32* %38)
%40 = getelementptr inbounds [3 x double], [3 x double]* %12, i64 0, i64 2
store double 0.000000e+00, double* %40
%41 = getelementptr inbounds [3 x double], [3 x double]* %12, i64 0, i64 1
store double 0.000000e+00, double* %41
%42 = getelementptr inbounds [3 x double], [3 x double]* %12, i64 0, i64 0
store double 0.000000e+00, double* %42
store i8 0, i8* %11
store i32 0, i32* %7
br label %43
43: ; preds = %89, %34
%44 = load i32, i32* %7
%45 = icmp slt i32 %44, 6
br i1 %45, label %46, label %92
46: ; preds = %43
store i32 0, i32* %8
br label %47
47: ; preds = %85, %46
%48 = load i32, i32* %8
%49 = icmp slt i32 %48, 512
br i1 %49, label %50, label %88
50: ; preds = %47
store i32 0, i32* %9
br label %51
51: ; preds = %81, %50
%52 = load i32, i32* %9
%53 = icmp slt i32 %52, 512
br i1 %53, label %54, label %84
54: ; preds = %51
%55 = load i32, i32* %7
%56 = sext i32 %55 to i64
%57 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %10, i64 0, i64 %56
%58 = load i32, i32* %8
%59 = sext i32 %58 to i64
%60 = getelementptr inbounds [512 x [512 x i8]], [512 x [512 x i8]]* %57, i64 0, i64 %59
%61 = load i32, i32* %9
%62 = sext i32 %61 to i64
%63 = getelementptr inbounds [512 x i8], [512 x i8]* %60, i64 0, i64 %62
%64 = load i8, i8* %63
%65 = zext i8 %64 to i32
%66 = load i8, i8* %11
%67 = zext i8 %66 to i32
%68 = icmp sgt i32 %65, %67
br i1 %68, label %69, label %80
69: ; preds = %54
%70 = load i32, i32* %7
%71 = sext i32 %70 to i64
%72 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %10, i64 0, i64 %71
%73 = load i32, i32* %8
%74 = sext i32 %73 to i64
%75 = getelementptr inbounds [512 x [512 x i8]], [512 x [512 x i8]]* %72, i64 0, i64 %74
%76 = load i32, i32* %9
%77 = sext i32 %76 to i64
%78 = getelementptr inbounds [512 x i8], [512 x i8]* %75, i64 0, i64 %77
%79 = load i8, i8* %78
store i8 %79, i8* %11
br label %80
80: ; preds = %69, %54
br label %81
81: ; preds = %80
%82 = load i32, i32* %9
%83 = add nsw i32 %82, 1
store i32 %83, i32* %9
br label %51
84: ; preds = %51
br label %85
85: ; preds = %84
%86 = load i32, i32* %8
%87 = add nsw i32 %86, 1
store i32 %87, i32* %8
br label %47
88: ; preds = %47
br label %89
89: ; preds = %88
%90 = load i32, i32* %7
%91 = add nsw i32 %90, 1
store i32 %91, i32* %7
br label %43
92: ; preds = %43
store i32 0, i32* %7
br label %93
93: ; preds = %170, %92
%94 = load i32, i32* %7
%95 = icmp slt i32 %94, 6
br i1 %95, label %96, label %173
96: ; preds = %93
store i32 0, i32* %8
br label %97
97: ; preds = %166, %96
%98 = load i32, i32* %8
%99 = icmp slt i32 %98, 512
br i1 %99, label %100, label %169
100: ; preds = %97
store i32 0, i32* %9
br label %101
101: ; preds = %162, %100
%102 = load i32, i32* %9
%103 = icmp slt i32 %102, 512
br i1 %103, label %104, label %165
104: ; preds = %101
%105 = load i32, i32* %7
%106 = load i32, i32* %8
%107 = load i32, i32* %9
%108 = getelementptr inbounds [3 x double], [3 x double]* %16, i64 0, i64 0
%109 = call i32 @MapCoord(i32 %105, i32 %106, i32 %107, double* %108)
%110 = getelementptr inbounds [3 x double], [3 x double]* %16, i64 0, i64 0
%111 = load double, double* %110
%112 = getelementptr inbounds [3 x double], [3 x double]* %16, i64 0, i64 0
%113 = load double, double* %112
%114 = getelementptr inbounds [3 x double], [3 x double]* %16, i64 0, i64 1
%115 = load double, double* %114
%116 = getelementptr inbounds [3 x double], [3 x double]* %16, i64 0, i64 1
%117 = load double, double* %116
%118 = fmul double %115, %117
%119 = call double @llvm.fmuladd.f64(double %111, double %113, double %118)
%120 = getelementptr inbounds [3 x double], [3 x double]* %16, i64 0, i64 2
%121 = load double, double* %120
%122 = getelementptr inbounds [3 x double], [3 x double]* %16, i64 0, i64 2
%123 = load double, double* %122
%124 = call double @llvm.fmuladd.f64(double %121, double %123, double %119)
%125 = call double @pow(double %124, double -1.500000e+00)
store double %125, double* %17
%126 = load i32, i32* %7
%127 = sext i32 %126 to i64
%128 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %10, i64 0, i64 %127
%129 = load i32, i32* %8
%130 = sext i32 %129 to i64
%131 = getelementptr inbounds [512 x [512 x i8]], [512 x [512 x i8]]* %128, i64 0, i64 %130
%132 = load i32, i32* %9
%133 = sext i32 %132 to i64
%134 = getelementptr inbounds [512 x i8], [512 x i8]* %131, i64 0, i64 %133
%135 = load i8, i8* %134
%136 = zext i8 %135 to i32
%137 = load i8, i8* %11
%138 = zext i8 %137 to i32
%139 = sub nsw i32 %136, %138
%140 = mul nsw i32 10, %139
%141 = call double @exp(i32 %140)
%142 = load double, double* %17
%143 = fmul double %142, %141
store double %143, double* %17
%144 = load double, double* %17
%145 = getelementptr inbounds [3 x double], [3 x double]* %16, i64 0, i64 0
%146 = load double, double* %145
%147 = getelementptr inbounds [3 x double], [3 x double]* %12, i64 0, i64 0
%148 = load double, double* %147
%149 = call double @llvm.fmuladd.f64(double %144, double %146, double %148)
store double %149, double* %147
%150 = load double, double* %17
%151 = getelementptr inbounds [3 x double], [3 x double]* %16, i64 0, i64 1
%152 = load double, double* %151
%153 = getelementptr inbounds [3 x double], [3 x double]* %12, i64 0, i64 1
%154 = load double, double* %153
%155 = call double @llvm.fmuladd.f64(double %150, double %152, double %154)
store double %155, double* %153
%156 = load double, double* %17
%157 = getelementptr inbounds [3 x double], [3 x double]* %16, i64 0, i64 2
%158 = load double, double* %157
%159 = getelementptr inbounds [3 x double], [3 x double]* %12, i64 0, i64 2
%160 = load double, double* %159
%161 = call double @llvm.fmuladd.f64(double %156, double %158, double %160)
store double %161, double* %159
br label %162
162: ; preds = %104
%163 = load i32, i32* %9
%164 = add nsw i32 %163, 1
store i32 %164, i32* %9
br label %101
165: ; preds = %101
br label %166
166: ; preds = %165
%167 = load i32, i32* %8
%168 = add nsw i32 %167, 1
store i32 %168, i32* %8
br label %97
169: ; preds = %97
br label %170
170: ; preds = %169
%171 = load i32, i32* %7
%172 = add nsw i32 %171, 1
store i32 %172, i32* %7
br label %93
173: ; preds = %93
%174 = getelementptr inbounds [3 x double], [3 x double]* %12, i64 0, i64 0
%175 = load double, double* %174
%176 = getelementptr inbounds [3 x double], [3 x double]* %12, i64 0, i64 0
%177 = load double, double* %176
%178 = getelementptr inbounds [3 x double], [3 x double]* %12, i64 0, i64 1
%179 = load double, double* %178
%180 = getelementptr inbounds [3 x double], [3 x double]* %12, i64 0, i64 1
%181 = load double, double* %180
%182 = fmul double %179, %181
%183 = call double @llvm.fmuladd.f64(double %175, double %177, double %182)
%184 = getelementptr inbounds [3 x double], [3 x double]* %12, i64 0, i64 2
%185 = load double, double* %184
%186 = getelementptr inbounds [3 x double], [3 x double]* %12, i64 0, i64 2
%187 = load double, double* %186
%188 = call double @llvm.fmuladd.f64(double %185, double %187, double %183)
%189 = call double @sqrt(double %188)
store double %189, double* %15
%190 = load i32, i32* @stderr
%191 = getelementptr inbounds [3 x double], [3 x double]* %12, i64 0, i64 0
%192 = load double, double* %191
%193 = load double, double* %15
%194 = fdiv double %192, %193
%195 = getelementptr inbounds [3 x double], [3 x double]* %12, i64 0, i64 1
%196 = load double, double* %195
%197 = load double, double* %15
%198 = fdiv double %196, %197
%199 = getelementptr inbounds [3 x double], [3 x double]* %12, i64 0, i64 2
%200 = load double, double* %199
%201 = load double, double* %15
%202 = fdiv double %200, %201
%203 = call i32 (i32, i8*, ...) @fprintf(i32 %190, i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.3, i64 0, i64 0), double %194, double %198, double %202)
%204 = getelementptr inbounds [3 x double], [3 x double]* %12, i64 0, i64 2
%205 = load double, double* %204
%206 = getelementptr inbounds [3 x double], [3 x double]* %12, i64 0, i64 0
%207 = load double, double* %206
%208 = getelementptr inbounds [3 x double], [3 x double]* %12, i64 0, i64 0
%209 = load double, double* %208
%210 = getelementptr inbounds [3 x double], [3 x double]* %12, i64 0, i64 1
%211 = load double, double* %210
%212 = getelementptr inbounds [3 x double], [3 x double]* %12, i64 0, i64 1
%213 = load double, double* %212
%214 = fmul double %211, %213
%215 = call double @llvm.fmuladd.f64(double %207, double %209, double %214)
%216 = call double @sqrt(double %215)
%217 = call double @atan2(double %205, double %216)
store double %217, double* %13
%218 = getelementptr inbounds [3 x double], [3 x double]* %12, i64 0, i64 1
%219 = load double, double* %218
%220 = getelementptr inbounds [3 x double], [3 x double]* %12, i64 0, i64 0
%221 = load double, double* %220
%222 = call double @atan2(double %219, double %221)
store double %222, double* %14
%223 = load double, double* %14
%224 = fmul double %223, 1.800000e+02
%225 = load double, double* @M_PI
%226 = fdiv double %224, %225
%227 = load double, double* %13
%228 = fmul double %227, 1.800000e+02
%229 = load double, double* @M_PI
%230 = fdiv double %228, %229
%231 = call i32 @printf(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.4, i64 0, i64 0), double %226, double %230)
store i32 0, i32* %3
br label %232
232: ; preds = %173, %32, %20
%233 = load i32, i32* %3
ret i32 %233
}

LLVM IR (-O2):
@stderr = global i32 0
@.str = [26 x i8] c"Usage: %s imagefile.gray\0A\00"
@.str.1 = [3 x i8] c"rb\00"
@.str.2 = [6 x i8] c"fopen\00"
@.str.3 = [16 x i8] c"vec = %f %f %f\0A\00"
@.str.4 = [7 x i8] c"%f %f\0A\00"
@M_PI = global double 0.000000e+00
define i32 @main(i32 %0, i8** nocapture %1) {
%3 = alloca [6 x [512 x [512 x i8]]]
%4 = alloca [3 x double]
%5 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 0, i64 0, i64 0
%6 = icmp eq i32 %0, 2
br i1 %6, label %11, label %7
7: ; preds = %2
%8 = load i32, i32* @stderr
%9 = load i8*, i8** %1
%10 = tail call i32 (i32, i8*, ...) @fprintf(i32 %8, i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str, i64 0, i64 0), i8* %9)
br label %1114
11: ; preds = %2
%12 = getelementptr inbounds i8*, i8** %1, i64 1
%13 = load i8*, i8** %12
%14 = tail call i32* @fopen(i8* %13, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0))
%15 = icmp eq i32* %14, null
br i1 %15, label %16, label %18
16: ; preds = %11
%17 = tail call i32 @perror(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.2, i64 0, i64 0))
br label %1114
18: ; preds = %11
%19 = bitcast [6 x [512 x [512 x i8]]]* %3 to i8****
%20 = call i32 @fread(i8**** %19, i32 1572864, i32 1, i32* %14)
%21 = tail call i32 @fclose(i32* %14)
br label %22
22: ; preds = %18, %22
%23 = phi i64 [ 0, %18 ], [ %190, %22 ]
%24 = phi i8 [ 0, %18 ], [ %189, %22 ]
%25 = insertelement <16 x i8> poison, i8 %24, i64 0
%26 = shufflevector <16 x i8> %25, <16 x i8> poison, <16 x i32> zeroinitializer
%27 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 0, i64 %23, i64 0
%28 = bitcast i8* %27 to <16 x i8>*
%29 = load <16 x i8>, <16 x i8>* %28
%30 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 0, i64 %23, i64 16
%31 = bitcast i8* %30 to <16 x i8>*
%32 = load <16 x i8>, <16 x i8>* %31
%33 = icmp ugt <16 x i8> %29, %26
%34 = icmp ugt <16 x i8> %32, %26
%35 = select <16 x i1> %33, <16 x i8> %29, <16 x i8> %26
%36 = select <16 x i1> %34, <16 x i8> %32, <16 x i8> %26
%37 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 0, i64 %23, i64 32
%38 = bitcast i8* %37 to <16 x i8>*
%39 = load <16 x i8>, <16 x i8>* %38
%40 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 0, i64 %23, i64 48
%41 = bitcast i8* %40 to <16 x i8>*
%42 = load <16 x i8>, <16 x i8>* %41
%43 = icmp ugt <16 x i8> %39, %35
%44 = icmp ugt <16 x i8> %42, %36
%45 = select <16 x i1> %43, <16 x i8> %39, <16 x i8> %35
%46 = select <16 x i1> %44, <16 x i8> %42, <16 x i8> %36
%47 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 0, i64 %23, i64 64
%48 = bitcast i8* %47 to <16 x i8>*
%49 = load <16 x i8>, <16 x i8>* %48
%50 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 0, i64 %23, i64 80
%51 = bitcast i8* %50 to <16 x i8>*
%52 = load <16 x i8>, <16 x i8>* %51
%53 = icmp ugt <16 x i8> %49, %45
%54 = icmp ugt <16 x i8> %52, %46
%55 = select <16 x i1> %53, <16 x i8> %49, <16 x i8> %45
%56 = select <16 x i1> %54, <16 x i8> %52, <16 x i8> %46
%57 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 0, i64 %23, i64 96
%58 = bitcast i8* %57 to <16 x i8>*
%59 = load <16 x i8>, <16 x i8>* %58
%60 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 0, i64 %23, i64 112
%61 = bitcast i8* %60 to <16 x i8>*
%62 = load <16 x i8>, <16 x i8>* %61
%63 = icmp ugt <16 x i8> %59, %55
%64 = icmp ugt <16 x i8> %62, %56
%65 = select <16 x i1> %63, <16 x i8> %59, <16 x i8> %55
%66 = select <16 x i1> %64, <16 x i8> %62, <16 x i8> %56
%67 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 0, i64 %23, i64 128
%68 = bitcast i8* %67 to <16 x i8>*
%69 = load <16 x i8>, <16 x i8>* %68
%70 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 0, i64 %23, i64 144
%71 = bitcast i8* %70 to <16 x i8>*
%72 = load <16 x i8>, <16 x i8>* %71
%73 = icmp ugt <16 x i8> %69, %65
%74 = icmp ugt <16 x i8> %72, %66
%75 = select <16 x i1> %73, <16 x i8> %69, <16 x i8> %65
%76 = select <16 x i1> %74, <16 x i8> %72, <16 x i8> %66
%77 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 0, i64 %23, i64 160
%78 = bitcast i8* %77 to <16 x i8>*
%79 = load <16 x i8>, <16 x i8>* %78
%80 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 0, i64 %23, i64 176
%81 = bitcast i8* %80 to <16 x i8>*
%82 = load <16 x i8>, <16 x i8>* %81
%83 = icmp ugt <16 x i8> %79, %75
%84 = icmp ugt <16 x i8> %82, %76
%85 = select <16 x i1> %83, <16 x i8> %79, <16 x i8> %75
%86 = select <16 x i1> %84, <16 x i8> %82, <16 x i8> %76
%87 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 0, i64 %23, i64 192
%88 = bitcast i8* %87 to <16 x i8>*
%89 = load <16 x i8>, <16 x i8>* %88
%90 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 0, i64 %23, i64 208
%91 = bitcast i8* %90 to <16 x i8>*
%92 = load <16 x i8>, <16 x i8>* %91
%93 = icmp ugt <16 x i8> %89, %85
%94 = icmp ugt <16 x i8> %92, %86
%95 = select <16 x i1> %93, <16 x i8> %89, <16 x i8> %85
%96 = select <16 x i1> %94, <16 x i8> %92, <16 x i8> %86
%97 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 0, i64 %23, i64 224
%98 = bitcast i8* %97 to <16 x i8>*
%99 = load <16 x i8>, <16 x i8>* %98
%100 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 0, i64 %23, i64 240
%101 = bitcast i8* %100 to <16 x i8>*
%102 = load <16 x i8>, <16 x i8>* %101
%103 = icmp ugt <16 x i8> %99, %95
%104 = icmp ugt <16 x i8> %102, %96
%105 = select <16 x i1> %103, <16 x i8> %99, <16 x i8> %95
%106 = select <16 x i1> %104, <16 x i8> %102, <16 x i8> %96
%107 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 0, i64 %23, i64 256
%108 = bitcast i8* %107 to <16 x i8>*
%109 = load <16 x i8>, <16 x i8>* %108
%110 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 0, i64 %23, i64 272
%111 = bitcast i8* %110 to <16 x i8>*
%112 = load <16 x i8>, <16 x i8>* %111
%113 = icmp ugt <16 x i8> %109, %105
%114 = icmp ugt <16 x i8> %112, %106
%115 = select <16 x i1> %113, <16 x i8> %109, <16 x i8> %105
%116 = select <16 x i1> %114, <16 x i8> %112, <16 x i8> %106
%117 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 0, i64 %23, i64 288
%118 = bitcast i8* %117 to <16 x i8>*
%119 = load <16 x i8>, <16 x i8>* %118
%120 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 0, i64 %23, i64 304
%121 = bitcast i8* %120 to <16 x i8>*
%122 = load <16 x i8>, <16 x i8>* %121
%123 = icmp ugt <16 x i8> %119, %115
%124 = icmp ugt <16 x i8> %122, %116
%125 = select <16 x i1> %123, <16 x i8> %119, <16 x i8> %115
%126 = select <16 x i1> %124, <16 x i8> %122, <16 x i8> %116
%127 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 0, i64 %23, i64 320
%128 = bitcast i8* %127 to <16 x i8>*
%129 = load <16 x i8>, <16 x i8>* %128
%130 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 0, i64 %23, i64 336
%131 = bitcast i8* %130 to <16 x i8>*
%132 = load <16 x i8>, <16 x i8>* %131
%133 = icmp ugt <16 x i8> %129, %125
%134 = icmp ugt <16 x i8> %132, %126
%135 = select <16 x i1> %133, <16 x i8> %129, <16 x i8> %125
%136 = select <16 x i1> %134, <16 x i8> %132, <16 x i8> %126
%137 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 0, i64 %23, i64 352
%138 = bitcast i8* %137 to <16 x i8>*
%139 = load <16 x i8>, <16 x i8>* %138
%140 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 0, i64 %23, i64 368
%141 = bitcast i8* %140 to <16 x i8>*
%142 = load <16 x i8>, <16 x i8>* %141
%143 = icmp ugt <16 x i8> %139, %135
%144 = icmp ugt <16 x i8> %142, %136
%145 = select <16 x i1> %143, <16 x i8> %139, <16 x i8> %135
%146 = select <16 x i1> %144, <16 x i8> %142, <16 x i8> %136
%147 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 0, i64 %23, i64 384
%148 = bitcast i8* %147 to <16 x i8>*
%149 = load <16 x i8>, <16 x i8>* %148
%150 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 0, i64 %23, i64 400
%151 = bitcast i8* %150 to <16 x i8>*
%152 = load <16 x i8>, <16 x i8>* %151
%153 = icmp ugt <16 x i8> %149, %145
%154 = icmp ugt <16 x i8> %152, %146
%155 = select <16 x i1> %153, <16 x i8> %149, <16 x i8> %145
%156 = select <16 x i1> %154, <16 x i8> %152, <16 x i8> %146
%157 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 0, i64 %23, i64 416
%158 = bitcast i8* %157 to <16 x i8>*
%159 = load <16 x i8>, <16 x i8>* %158
%160 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 0, i64 %23, i64 432
%161 = bitcast i8* %160 to <16 x i8>*
%162 = load <16 x i8>, <16 x i8>* %161
%163 = icmp ugt <16 x i8> %159, %155
%164 = icmp ugt <16 x i8> %162, %156
%165 = select <16 x i1> %163, <16 x i8> %159, <16 x i8> %155
%166 = select <16 x i1> %164, <16 x i8> %162, <16 x i8> %156
%167 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 0, i64 %23, i64 448
%168 = bitcast i8* %167 to <16 x i8>*
%169 = load <16 x i8>, <16 x i8>* %168
%170 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 0, i64 %23, i64 464
%171 = bitcast i8* %170 to <16 x i8>*
%172 = load <16 x i8>, <16 x i8>* %171
%173 = icmp ugt <16 x i8> %169, %165
%174 = icmp ugt <16 x i8> %172, %166
%175 = select <16 x i1> %173, <16 x i8> %169, <16 x i8> %165
%176 = select <16 x i1> %174, <16 x i8> %172, <16 x i8> %166
%177 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 0, i64 %23, i64 480
%178 = bitcast i8* %177 to <16 x i8>*
%179 = load <16 x i8>, <16 x i8>* %178
%180 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 0, i64 %23, i64 496
%181 = bitcast i8* %180 to <16 x i8>*
%182 = load <16 x i8>, <16 x i8>* %181
%183 = icmp ugt <16 x i8> %179, %175
%184 = icmp ugt <16 x i8> %182, %176
%185 = select <16 x i1> %183, <16 x i8> %179, <16 x i8> %175
%186 = select <16 x i1> %184, <16 x i8> %182, <16 x i8> %176
%187 = icmp ugt <16 x i8> %185, %186
%188 = select <16 x i1> %187, <16 x i8> %185, <16 x i8> %186
%189 = call i8 @llvm.vector.reduce.umax.v16i8(<16 x i8> %188)
%190 = add nuw nsw i64 %23, 1
%191 = icmp eq i64 %190, 512
br i1 %191, label %192, label %22
192: ; preds = %22, %192
%193 = phi i64 [ %360, %192 ], [ 0, %22 ]
%194 = phi i8 [ %359, %192 ], [ %189, %22 ]
%195 = insertelement <16 x i8> poison, i8 %194, i64 0
%196 = shufflevector <16 x i8> %195, <16 x i8> poison, <16 x i32> zeroinitializer
%197 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 1, i64 %193, i64 0
%198 = bitcast i8* %197 to <16 x i8>*
%199 = load <16 x i8>, <16 x i8>* %198
%200 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 1, i64 %193, i64 16
%201 = bitcast i8* %200 to <16 x i8>*
%202 = load <16 x i8>, <16 x i8>* %201
%203 = icmp ugt <16 x i8> %199, %196
%204 = icmp ugt <16 x i8> %202, %196
%205 = select <16 x i1> %203, <16 x i8> %199, <16 x i8> %196
%206 = select <16 x i1> %204, <16 x i8> %202, <16 x i8> %196
%207 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 1, i64 %193, i64 32
%208 = bitcast i8* %207 to <16 x i8>*
%209 = load <16 x i8>, <16 x i8>* %208
%210 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 1, i64 %193, i64 48
%211 = bitcast i8* %210 to <16 x i8>*
%212 = load <16 x i8>, <16 x i8>* %211
%213 = icmp ugt <16 x i8> %209, %205
%214 = icmp ugt <16 x i8> %212, %206
%215 = select <16 x i1> %213, <16 x i8> %209, <16 x i8> %205
%216 = select <16 x i1> %214, <16 x i8> %212, <16 x i8> %206
%217 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 1, i64 %193, i64 64
%218 = bitcast i8* %217 to <16 x i8>*
%219 = load <16 x i8>, <16 x i8>* %218
%220 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 1, i64 %193, i64 80
%221 = bitcast i8* %220 to <16 x i8>*
%222 = load <16 x i8>, <16 x i8>* %221
%223 = icmp ugt <16 x i8> %219, %215
%224 = icmp ugt <16 x i8> %222, %216
%225 = select <16 x i1> %223, <16 x i8> %219, <16 x i8> %215
%226 = select <16 x i1> %224, <16 x i8> %222, <16 x i8> %216
%227 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 1, i64 %193, i64 96
%228 = bitcast i8* %227 to <16 x i8>*
%229 = load <16 x i8>, <16 x i8>* %228
%230 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 1, i64 %193, i64 112
%231 = bitcast i8* %230 to <16 x i8>*
%232 = load <16 x i8>, <16 x i8>* %231
%233 = icmp ugt <16 x i8> %229, %225
%234 = icmp ugt <16 x i8> %232, %226
%235 = select <16 x i1> %233, <16 x i8> %229, <16 x i8> %225
%236 = select <16 x i1> %234, <16 x i8> %232, <16 x i8> %226
%237 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 1, i64 %193, i64 128
%238 = bitcast i8* %237 to <16 x i8>*
%239 = load <16 x i8>, <16 x i8>* %238
%240 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 1, i64 %193, i64 144
%241 = bitcast i8* %240 to <16 x i8>*
%242 = load <16 x i8>, <16 x i8>* %241
%243 = icmp ugt <16 x i8> %239, %235
%244 = icmp ugt <16 x i8> %242, %236
%245 = select <16 x i1> %243, <16 x i8> %239, <16 x i8> %235
%246 = select <16 x i1> %244, <16 x i8> %242, <16 x i8> %236
%247 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 1, i64 %193, i64 160
%248 = bitcast i8* %247 to <16 x i8>*
%249 = load <16 x i8>, <16 x i8>* %248
%250 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 1, i64 %193, i64 176
%251 = bitcast i8* %250 to <16 x i8>*
%252 = load <16 x i8>, <16 x i8>* %251
%253 = icmp ugt <16 x i8> %249, %245
%254 = icmp ugt <16 x i8> %252, %246
%255 = select <16 x i1> %253, <16 x i8> %249, <16 x i8> %245
%256 = select <16 x i1> %254, <16 x i8> %252, <16 x i8> %246
%257 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 1, i64 %193, i64 192
%258 = bitcast i8* %257 to <16 x i8>*
%259 = load <16 x i8>, <16 x i8>* %258
%260 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 1, i64 %193, i64 208
%261 = bitcast i8* %260 to <16 x i8>*
%262 = load <16 x i8>, <16 x i8>* %261
%263 = icmp ugt <16 x i8> %259, %255
%264 = icmp ugt <16 x i8> %262, %256
%265 = select <16 x i1> %263, <16 x i8> %259, <16 x i8> %255
%266 = select <16 x i1> %264, <16 x i8> %262, <16 x i8> %256
%267 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 1, i64 %193, i64 224
%268 = bitcast i8* %267 to <16 x i8>*
%269 = load <16 x i8>, <16 x i8>* %268
%270 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 1, i64 %193, i64 240
%271 = bitcast i8* %270 to <16 x i8>*
%272 = load <16 x i8>, <16 x i8>* %271
%273 = icmp ugt <16 x i8> %269, %265
%274 = icmp ugt <16 x i8> %272, %266
%275 = select <16 x i1> %273, <16 x i8> %269, <16 x i8> %265
%276 = select <16 x i1> %274, <16 x i8> %272, <16 x i8> %266
%277 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 1, i64 %193, i64 256
%278 = bitcast i8* %277 to <16 x i8>*
%279 = load <16 x i8>, <16 x i8>* %278
%280 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 1, i64 %193, i64 272
%281 = bitcast i8* %280 to <16 x i8>*
%282 = load <16 x i8>, <16 x i8>* %281
%283 = icmp ugt <16 x i8> %279, %275
%284 = icmp ugt <16 x i8> %282, %276
%285 = select <16 x i1> %283, <16 x i8> %279, <16 x i8> %275
%286 = select <16 x i1> %284, <16 x i8> %282, <16 x i8> %276
%287 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 1, i64 %193, i64 288
%288 = bitcast i8* %287 to <16 x i8>*
%289 = load <16 x i8>, <16 x i8>* %288
%290 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 1, i64 %193, i64 304
%291 = bitcast i8* %290 to <16 x i8>*
%292 = load <16 x i8>, <16 x i8>* %291
%293 = icmp ugt <16 x i8> %289, %285
%294 = icmp ugt <16 x i8> %292, %286
%295 = select <16 x i1> %293, <16 x i8> %289, <16 x i8> %285
%296 = select <16 x i1> %294, <16 x i8> %292, <16 x i8> %286
%297 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 1, i64 %193, i64 320
%298 = bitcast i8* %297 to <16 x i8>*
%299 = load <16 x i8>, <16 x i8>* %298
%300 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 1, i64 %193, i64 336
%301 = bitcast i8* %300 to <16 x i8>*
%302 = load <16 x i8>, <16 x i8>* %301
%303 = icmp ugt <16 x i8> %299, %295
%304 = icmp ugt <16 x i8> %302, %296
%305 = select <16 x i1> %303, <16 x i8> %299, <16 x i8> %295
%306 = select <16 x i1> %304, <16 x i8> %302, <16 x i8> %296
%307 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 1, i64 %193, i64 352
%308 = bitcast i8* %307 to <16 x i8>*
%309 = load <16 x i8>, <16 x i8>* %308
%310 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 1, i64 %193, i64 368
%311 = bitcast i8* %310 to <16 x i8>*
%312 = load <16 x i8>, <16 x i8>* %311
%313 = icmp ugt <16 x i8> %309, %305
%314 = icmp ugt <16 x i8> %312, %306
%315 = select <16 x i1> %313, <16 x i8> %309, <16 x i8> %305
%316 = select <16 x i1> %314, <16 x i8> %312, <16 x i8> %306
%317 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 1, i64 %193, i64 384
%318 = bitcast i8* %317 to <16 x i8>*
%319 = load <16 x i8>, <16 x i8>* %318
%320 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 1, i64 %193, i64 400
%321 = bitcast i8* %320 to <16 x i8>*
%322 = load <16 x i8>, <16 x i8>* %321
%323 = icmp ugt <16 x i8> %319, %315
%324 = icmp ugt <16 x i8> %322, %316
%325 = select <16 x i1> %323, <16 x i8> %319, <16 x i8> %315
%326 = select <16 x i1> %324, <16 x i8> %322, <16 x i8> %316
%327 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 1, i64 %193, i64 416
%328 = bitcast i8* %327 to <16 x i8>*
%329 = load <16 x i8>, <16 x i8>* %328
%330 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 1, i64 %193, i64 432
%331 = bitcast i8* %330 to <16 x i8>*
%332 = load <16 x i8>, <16 x i8>* %331
%333 = icmp ugt <16 x i8> %329, %325
%334 = icmp ugt <16 x i8> %332, %326
%335 = select <16 x i1> %333, <16 x i8> %329, <16 x i8> %325
%336 = select <16 x i1> %334, <16 x i8> %332, <16 x i8> %326
%337 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 1, i64 %193, i64 448
%338 = bitcast i8* %337 to <16 x i8>*
%339 = load <16 x i8>, <16 x i8>* %338
%340 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 1, i64 %193, i64 464
%341 = bitcast i8* %340 to <16 x i8>*
%342 = load <16 x i8>, <16 x i8>* %341
%343 = icmp ugt <16 x i8> %339, %335
%344 = icmp ugt <16 x i8> %342, %336
%345 = select <16 x i1> %343, <16 x i8> %339, <16 x i8> %335
%346 = select <16 x i1> %344, <16 x i8> %342, <16 x i8> %336
%347 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 1, i64 %193, i64 480
%348 = bitcast i8* %347 to <16 x i8>*
%349 = load <16 x i8>, <16 x i8>* %348
%350 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 1, i64 %193, i64 496
%351 = bitcast i8* %350 to <16 x i8>*
%352 = load <16 x i8>, <16 x i8>* %351
%353 = icmp ugt <16 x i8> %349, %345
%354 = icmp ugt <16 x i8> %352, %346
%355 = select <16 x i1> %353, <16 x i8> %349, <16 x i8> %345
%356 = select <16 x i1> %354, <16 x i8> %352, <16 x i8> %346
%357 = icmp ugt <16 x i8> %355, %356
%358 = select <16 x i1> %357, <16 x i8> %355, <16 x i8> %356
%359 = call i8 @llvm.vector.reduce.umax.v16i8(<16 x i8> %358)
%360 = add nuw nsw i64 %193, 1
%361 = icmp eq i64 %360, 512
br i1 %361, label %362, label %192
362: ; preds = %192, %362
%363 = phi i64 [ %530, %362 ], [ 0, %192 ]
%364 = phi i8 [ %529, %362 ], [ %359, %192 ]
%365 = insertelement <16 x i8> poison, i8 %364, i64 0
%366 = shufflevector <16 x i8> %365, <16 x i8> poison, <16 x i32> zeroinitializer
%367 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 2, i64 %363, i64 0
%368 = bitcast i8* %367 to <16 x i8>*
%369 = load <16 x i8>, <16 x i8>* %368
%370 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 2, i64 %363, i64 16
%371 = bitcast i8* %370 to <16 x i8>*
%372 = load <16 x i8>, <16 x i8>* %371
%373 = icmp ugt <16 x i8> %369, %366
%374 = icmp ugt <16 x i8> %372, %366
%375 = select <16 x i1> %373, <16 x i8> %369, <16 x i8> %366
%376 = select <16 x i1> %374, <16 x i8> %372, <16 x i8> %366
%377 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 2, i64 %363, i64 32
%378 = bitcast i8* %377 to <16 x i8>*
%379 = load <16 x i8>, <16 x i8>* %378
%380 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 2, i64 %363, i64 48
%381 = bitcast i8* %380 to <16 x i8>*
%382 = load <16 x i8>, <16 x i8>* %381
%383 = icmp ugt <16 x i8> %379, %375
%384 = icmp ugt <16 x i8> %382, %376
%385 = select <16 x i1> %383, <16 x i8> %379, <16 x i8> %375
%386 = select <16 x i1> %384, <16 x i8> %382, <16 x i8> %376
%387 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 2, i64 %363, i64 64
%388 = bitcast i8* %387 to <16 x i8>*
%389 = load <16 x i8>, <16 x i8>* %388
%390 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 2, i64 %363, i64 80
%391 = bitcast i8* %390 to <16 x i8>*
%392 = load <16 x i8>, <16 x i8>* %391
%393 = icmp ugt <16 x i8> %389, %385
%394 = icmp ugt <16 x i8> %392, %386
%395 = select <16 x i1> %393, <16 x i8> %389, <16 x i8> %385
%396 = select <16 x i1> %394, <16 x i8> %392, <16 x i8> %386
%397 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 2, i64 %363, i64 96
%398 = bitcast i8* %397 to <16 x i8>*
%399 = load <16 x i8>, <16 x i8>* %398
%400 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 2, i64 %363, i64 112
%401 = bitcast i8* %400 to <16 x i8>*
%402 = load <16 x i8>, <16 x i8>* %401
%403 = icmp ugt <16 x i8> %399, %395
%404 = icmp ugt <16 x i8> %402, %396
%405 = select <16 x i1> %403, <16 x i8> %399, <16 x i8> %395
%406 = select <16 x i1> %404, <16 x i8> %402, <16 x i8> %396
%407 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 2, i64 %363, i64 128
%408 = bitcast i8* %407 to <16 x i8>*
%409 = load <16 x i8>, <16 x i8>* %408
%410 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 2, i64 %363, i64 144
%411 = bitcast i8* %410 to <16 x i8>*
%412 = load <16 x i8>, <16 x i8>* %411
%413 = icmp ugt <16 x i8> %409, %405
%414 = icmp ugt <16 x i8> %412, %406
%415 = select <16 x i1> %413, <16 x i8> %409, <16 x i8> %405
%416 = select <16 x i1> %414, <16 x i8> %412, <16 x i8> %406
%417 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 2, i64 %363, i64 160
%418 = bitcast i8* %417 to <16 x i8>*
%419 = load <16 x i8>, <16 x i8>* %418
%420 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 2, i64 %363, i64 176
%421 = bitcast i8* %420 to <16 x i8>*
%422 = load <16 x i8>, <16 x i8>* %421
%423 = icmp ugt <16 x i8> %419, %415
%424 = icmp ugt <16 x i8> %422, %416
%425 = select <16 x i1> %423, <16 x i8> %419, <16 x i8> %415
%426 = select <16 x i1> %424, <16 x i8> %422, <16 x i8> %416
%427 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 2, i64 %363, i64 192
%428 = bitcast i8* %427 to <16 x i8>*
%429 = load <16 x i8>, <16 x i8>* %428
%430 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 2, i64 %363, i64 208
%431 = bitcast i8* %430 to <16 x i8>*
%432 = load <16 x i8>, <16 x i8>* %431
%433 = icmp ugt <16 x i8> %429, %425
%434 = icmp ugt <16 x i8> %432, %426
%435 = select <16 x i1> %433, <16 x i8> %429, <16 x i8> %425
%436 = select <16 x i1> %434, <16 x i8> %432, <16 x i8> %426
%437 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 2, i64 %363, i64 224
%438 = bitcast i8* %437 to <16 x i8>*
%439 = load <16 x i8>, <16 x i8>* %438
%440 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 2, i64 %363, i64 240
%441 = bitcast i8* %440 to <16 x i8>*
%442 = load <16 x i8>, <16 x i8>* %441
%443 = icmp ugt <16 x i8> %439, %435
%444 = icmp ugt <16 x i8> %442, %436
%445 = select <16 x i1> %443, <16 x i8> %439, <16 x i8> %435
%446 = select <16 x i1> %444, <16 x i8> %442, <16 x i8> %436
%447 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 2, i64 %363, i64 256
%448 = bitcast i8* %447 to <16 x i8>*
%449 = load <16 x i8>, <16 x i8>* %448
%450 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 2, i64 %363, i64 272
%451 = bitcast i8* %450 to <16 x i8>*
%452 = load <16 x i8>, <16 x i8>* %451
%453 = icmp ugt <16 x i8> %449, %445
%454 = icmp ugt <16 x i8> %452, %446
%455 = select <16 x i1> %453, <16 x i8> %449, <16 x i8> %445
%456 = select <16 x i1> %454, <16 x i8> %452, <16 x i8> %446
%457 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 2, i64 %363, i64 288
%458 = bitcast i8* %457 to <16 x i8>*
%459 = load <16 x i8>, <16 x i8>* %458
%460 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 2, i64 %363, i64 304
%461 = bitcast i8* %460 to <16 x i8>*
%462 = load <16 x i8>, <16 x i8>* %461
%463 = icmp ugt <16 x i8> %459, %455
%464 = icmp ugt <16 x i8> %462, %456
%465 = select <16 x i1> %463, <16 x i8> %459, <16 x i8> %455
%466 = select <16 x i1> %464, <16 x i8> %462, <16 x i8> %456
%467 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 2, i64 %363, i64 320
%468 = bitcast i8* %467 to <16 x i8>*
%469 = load <16 x i8>, <16 x i8>* %468
%470 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 2, i64 %363, i64 336
%471 = bitcast i8* %470 to <16 x i8>*
%472 = load <16 x i8>, <16 x i8>* %471
%473 = icmp ugt <16 x i8> %469, %465
%474 = icmp ugt <16 x i8> %472, %466
%475 = select <16 x i1> %473, <16 x i8> %469, <16 x i8> %465
%476 = select <16 x i1> %474, <16 x i8> %472, <16 x i8> %466
%477 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 2, i64 %363, i64 352
%478 = bitcast i8* %477 to <16 x i8>*
%479 = load <16 x i8>, <16 x i8>* %478
%480 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 2, i64 %363, i64 368
%481 = bitcast i8* %480 to <16 x i8>*
%482 = load <16 x i8>, <16 x i8>* %481
%483 = icmp ugt <16 x i8> %479, %475
%484 = icmp ugt <16 x i8> %482, %476
%485 = select <16 x i1> %483, <16 x i8> %479, <16 x i8> %475
%486 = select <16 x i1> %484, <16 x i8> %482, <16 x i8> %476
%487 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 2, i64 %363, i64 384
%488 = bitcast i8* %487 to <16 x i8>*
%489 = load <16 x i8>, <16 x i8>* %488
%490 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 2, i64 %363, i64 400
%491 = bitcast i8* %490 to <16 x i8>*
%492 = load <16 x i8>, <16 x i8>* %491
%493 = icmp ugt <16 x i8> %489, %485
%494 = icmp ugt <16 x i8> %492, %486
%495 = select <16 x i1> %493, <16 x i8> %489, <16 x i8> %485
%496 = select <16 x i1> %494, <16 x i8> %492, <16 x i8> %486
%497 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 2, i64 %363, i64 416
%498 = bitcast i8* %497 to <16 x i8>*
%499 = load <16 x i8>, <16 x i8>* %498
%500 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 2, i64 %363, i64 432
%501 = bitcast i8* %500 to <16 x i8>*
%502 = load <16 x i8>, <16 x i8>* %501
%503 = icmp ugt <16 x i8> %499, %495
%504 = icmp ugt <16 x i8> %502, %496
%505 = select <16 x i1> %503, <16 x i8> %499, <16 x i8> %495
%506 = select <16 x i1> %504, <16 x i8> %502, <16 x i8> %496
%507 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 2, i64 %363, i64 448
%508 = bitcast i8* %507 to <16 x i8>*
%509 = load <16 x i8>, <16 x i8>* %508
%510 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 2, i64 %363, i64 464
%511 = bitcast i8* %510 to <16 x i8>*
%512 = load <16 x i8>, <16 x i8>* %511
%513 = icmp ugt <16 x i8> %509, %505
%514 = icmp ugt <16 x i8> %512, %506
%515 = select <16 x i1> %513, <16 x i8> %509, <16 x i8> %505
%516 = select <16 x i1> %514, <16 x i8> %512, <16 x i8> %506
%517 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 2, i64 %363, i64 480
%518 = bitcast i8* %517 to <16 x i8>*
%519 = load <16 x i8>, <16 x i8>* %518
%520 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 2, i64 %363, i64 496
%521 = bitcast i8* %520 to <16 x i8>*
%522 = load <16 x i8>, <16 x i8>* %521
%523 = icmp ugt <16 x i8> %519, %515
%524 = icmp ugt <16 x i8> %522, %516
%525 = select <16 x i1> %523, <16 x i8> %519, <16 x i8> %515
%526 = select <16 x i1> %524, <16 x i8> %522, <16 x i8> %516
%527 = icmp ugt <16 x i8> %525, %526
%528 = select <16 x i1> %527, <16 x i8> %525, <16 x i8> %526
%529 = call i8 @llvm.vector.reduce.umax.v16i8(<16 x i8> %528)
%530 = add nuw nsw i64 %363, 1
%531 = icmp eq i64 %530, 512
br i1 %531, label %532, label %362
532: ; preds = %362, %532
%533 = phi i64 [ %700, %532 ], [ 0, %362 ]
%534 = phi i8 [ %699, %532 ], [ %529, %362 ]
%535 = insertelement <16 x i8> poison, i8 %534, i64 0
%536 = shufflevector <16 x i8> %535, <16 x i8> poison, <16 x i32> zeroinitializer
%537 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 3, i64 %533, i64 0
%538 = bitcast i8* %537 to <16 x i8>*
%539 = load <16 x i8>, <16 x i8>* %538
%540 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 3, i64 %533, i64 16
%541 = bitcast i8* %540 to <16 x i8>*
%542 = load <16 x i8>, <16 x i8>* %541
%543 = icmp ugt <16 x i8> %539, %536
%544 = icmp ugt <16 x i8> %542, %536
%545 = select <16 x i1> %543, <16 x i8> %539, <16 x i8> %536
%546 = select <16 x i1> %544, <16 x i8> %542, <16 x i8> %536
%547 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 3, i64 %533, i64 32
%548 = bitcast i8* %547 to <16 x i8>*
%549 = load <16 x i8>, <16 x i8>* %548
%550 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 3, i64 %533, i64 48
%551 = bitcast i8* %550 to <16 x i8>*
%552 = load <16 x i8>, <16 x i8>* %551
%553 = icmp ugt <16 x i8> %549, %545
%554 = icmp ugt <16 x i8> %552, %546
%555 = select <16 x i1> %553, <16 x i8> %549, <16 x i8> %545
%556 = select <16 x i1> %554, <16 x i8> %552, <16 x i8> %546
%557 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 3, i64 %533, i64 64
%558 = bitcast i8* %557 to <16 x i8>*
%559 = load <16 x i8>, <16 x i8>* %558
%560 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 3, i64 %533, i64 80
%561 = bitcast i8* %560 to <16 x i8>*
%562 = load <16 x i8>, <16 x i8>* %561
%563 = icmp ugt <16 x i8> %559, %555
%564 = icmp ugt <16 x i8> %562, %556
%565 = select <16 x i1> %563, <16 x i8> %559, <16 x i8> %555
%566 = select <16 x i1> %564, <16 x i8> %562, <16 x i8> %556
%567 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 3, i64 %533, i64 96
%568 = bitcast i8* %567 to <16 x i8>*
%569 = load <16 x i8>, <16 x i8>* %568
%570 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 3, i64 %533, i64 112
%571 = bitcast i8* %570 to <16 x i8>*
%572 = load <16 x i8>, <16 x i8>* %571
%573 = icmp ugt <16 x i8> %569, %565
%574 = icmp ugt <16 x i8> %572, %566
%575 = select <16 x i1> %573, <16 x i8> %569, <16 x i8> %565
%576 = select <16 x i1> %574, <16 x i8> %572, <16 x i8> %566
%577 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 3, i64 %533, i64 128
%578 = bitcast i8* %577 to <16 x i8>*
%579 = load <16 x i8>, <16 x i8>* %578
%580 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 3, i64 %533, i64 144
%581 = bitcast i8* %580 to <16 x i8>*
%582 = load <16 x i8>, <16 x i8>* %581
%583 = icmp ugt <16 x i8> %579, %575
%584 = icmp ugt <16 x i8> %582, %576
%585 = select <16 x i1> %583, <16 x i8> %579, <16 x i8> %575
%586 = select <16 x i1> %584, <16 x i8> %582, <16 x i8> %576
%587 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 3, i64 %533, i64 160
%588 = bitcast i8* %587 to <16 x i8>*
%589 = load <16 x i8>, <16 x i8>* %588
%590 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 3, i64 %533, i64 176
%591 = bitcast i8* %590 to <16 x i8>*
%592 = load <16 x i8>, <16 x i8>* %591
%593 = icmp ugt <16 x i8> %589, %585
%594 = icmp ugt <16 x i8> %592, %586
%595 = select <16 x i1> %593, <16 x i8> %589, <16 x i8> %585
%596 = select <16 x i1> %594, <16 x i8> %592, <16 x i8> %586
%597 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 3, i64 %533, i64 192
%598 = bitcast i8* %597 to <16 x i8>*
%599 = load <16 x i8>, <16 x i8>* %598
%600 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 3, i64 %533, i64 208
%601 = bitcast i8* %600 to <16 x i8>*
%602 = load <16 x i8>, <16 x i8>* %601
%603 = icmp ugt <16 x i8> %599, %595
%604 = icmp ugt <16 x i8> %602, %596
%605 = select <16 x i1> %603, <16 x i8> %599, <16 x i8> %595
%606 = select <16 x i1> %604, <16 x i8> %602, <16 x i8> %596
%607 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 3, i64 %533, i64 224
%608 = bitcast i8* %607 to <16 x i8>*
%609 = load <16 x i8>, <16 x i8>* %608
%610 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 3, i64 %533, i64 240
%611 = bitcast i8* %610 to <16 x i8>*
%612 = load <16 x i8>, <16 x i8>* %611
%613 = icmp ugt <16 x i8> %609, %605
%614 = icmp ugt <16 x i8> %612, %606
%615 = select <16 x i1> %613, <16 x i8> %609, <16 x i8> %605
%616 = select <16 x i1> %614, <16 x i8> %612, <16 x i8> %606
%617 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 3, i64 %533, i64 256
%618 = bitcast i8* %617 to <16 x i8>*
%619 = load <16 x i8>, <16 x i8>* %618
%620 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 3, i64 %533, i64 272
%621 = bitcast i8* %620 to <16 x i8>*
%622 = load <16 x i8>, <16 x i8>* %621
%623 = icmp ugt <16 x i8> %619, %615
%624 = icmp ugt <16 x i8> %622, %616
%625 = select <16 x i1> %623, <16 x i8> %619, <16 x i8> %615
%626 = select <16 x i1> %624, <16 x i8> %622, <16 x i8> %616
%627 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 3, i64 %533, i64 288
%628 = bitcast i8* %627 to <16 x i8>*
%629 = load <16 x i8>, <16 x i8>* %628
%630 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 3, i64 %533, i64 304
%631 = bitcast i8* %630 to <16 x i8>*
%632 = load <16 x i8>, <16 x i8>* %631
%633 = icmp ugt <16 x i8> %629, %625
%634 = icmp ugt <16 x i8> %632, %626
%635 = select <16 x i1> %633, <16 x i8> %629, <16 x i8> %625
%636 = select <16 x i1> %634, <16 x i8> %632, <16 x i8> %626
%637 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 3, i64 %533, i64 320
%638 = bitcast i8* %637 to <16 x i8>*
%639 = load <16 x i8>, <16 x i8>* %638
%640 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 3, i64 %533, i64 336
%641 = bitcast i8* %640 to <16 x i8>*
%642 = load <16 x i8>, <16 x i8>* %641
%643 = icmp ugt <16 x i8> %639, %635
%644 = icmp ugt <16 x i8> %642, %636
%645 = select <16 x i1> %643, <16 x i8> %639, <16 x i8> %635
%646 = select <16 x i1> %644, <16 x i8> %642, <16 x i8> %636
%647 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 3, i64 %533, i64 352
%648 = bitcast i8* %647 to <16 x i8>*
%649 = load <16 x i8>, <16 x i8>* %648
%650 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 3, i64 %533, i64 368
%651 = bitcast i8* %650 to <16 x i8>*
%652 = load <16 x i8>, <16 x i8>* %651
%653 = icmp ugt <16 x i8> %649, %645
%654 = icmp ugt <16 x i8> %652, %646
%655 = select <16 x i1> %653, <16 x i8> %649, <16 x i8> %645
%656 = select <16 x i1> %654, <16 x i8> %652, <16 x i8> %646
%657 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 3, i64 %533, i64 384
%658 = bitcast i8* %657 to <16 x i8>*
%659 = load <16 x i8>, <16 x i8>* %658
%660 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 3, i64 %533, i64 400
%661 = bitcast i8* %660 to <16 x i8>*
%662 = load <16 x i8>, <16 x i8>* %661
%663 = icmp ugt <16 x i8> %659, %655
%664 = icmp ugt <16 x i8> %662, %656
%665 = select <16 x i1> %663, <16 x i8> %659, <16 x i8> %655
%666 = select <16 x i1> %664, <16 x i8> %662, <16 x i8> %656
%667 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 3, i64 %533, i64 416
%668 = bitcast i8* %667 to <16 x i8>*
%669 = load <16 x i8>, <16 x i8>* %668
%670 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 3, i64 %533, i64 432
%671 = bitcast i8* %670 to <16 x i8>*
%672 = load <16 x i8>, <16 x i8>* %671
%673 = icmp ugt <16 x i8> %669, %665
%674 = icmp ugt <16 x i8> %672, %666
%675 = select <16 x i1> %673, <16 x i8> %669, <16 x i8> %665
%676 = select <16 x i1> %674, <16 x i8> %672, <16 x i8> %666
%677 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 3, i64 %533, i64 448
%678 = bitcast i8* %677 to <16 x i8>*
%679 = load <16 x i8>, <16 x i8>* %678
%680 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 3, i64 %533, i64 464
%681 = bitcast i8* %680 to <16 x i8>*
%682 = load <16 x i8>, <16 x i8>* %681
%683 = icmp ugt <16 x i8> %679, %675
%684 = icmp ugt <16 x i8> %682, %676
%685 = select <16 x i1> %683, <16 x i8> %679, <16 x i8> %675
%686 = select <16 x i1> %684, <16 x i8> %682, <16 x i8> %676
%687 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 3, i64 %533, i64 480
%688 = bitcast i8* %687 to <16 x i8>*
%689 = load <16 x i8>, <16 x i8>* %688
%690 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 3, i64 %533, i64 496
%691 = bitcast i8* %690 to <16 x i8>*
%692 = load <16 x i8>, <16 x i8>* %691
%693 = icmp ugt <16 x i8> %689, %685
%694 = icmp ugt <16 x i8> %692, %686
%695 = select <16 x i1> %693, <16 x i8> %689, <16 x i8> %685
%696 = select <16 x i1> %694, <16 x i8> %692, <16 x i8> %686
%697 = icmp ugt <16 x i8> %695, %696
%698 = select <16 x i1> %697, <16 x i8> %695, <16 x i8> %696
%699 = call i8 @llvm.vector.reduce.umax.v16i8(<16 x i8> %698)
%700 = add nuw nsw i64 %533, 1
%701 = icmp eq i64 %700, 512
br i1 %701, label %702, label %532
702: ; preds = %532, %702
%703 = phi i64 [ %870, %702 ], [ 0, %532 ]
%704 = phi i8 [ %869, %702 ], [ %699, %532 ]
%705 = insertelement <16 x i8> poison, i8 %704, i64 0
%706 = shufflevector <16 x i8> %705, <16 x i8> poison, <16 x i32> zeroinitializer
%707 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 4, i64 %703, i64 0
%708 = bitcast i8* %707 to <16 x i8>*
%709 = load <16 x i8>, <16 x i8>* %708
%710 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 4, i64 %703, i64 16
%711 = bitcast i8* %710 to <16 x i8>*
%712 = load <16 x i8>, <16 x i8>* %711
%713 = icmp ugt <16 x i8> %709, %706
%714 = icmp ugt <16 x i8> %712, %706
%715 = select <16 x i1> %713, <16 x i8> %709, <16 x i8> %706
%716 = select <16 x i1> %714, <16 x i8> %712, <16 x i8> %706
%717 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 4, i64 %703, i64 32
%718 = bitcast i8* %717 to <16 x i8>*
%719 = load <16 x i8>, <16 x i8>* %718
%720 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 4, i64 %703, i64 48
%721 = bitcast i8* %720 to <16 x i8>*
%722 = load <16 x i8>, <16 x i8>* %721
%723 = icmp ugt <16 x i8> %719, %715
%724 = icmp ugt <16 x i8> %722, %716
%725 = select <16 x i1> %723, <16 x i8> %719, <16 x i8> %715
%726 = select <16 x i1> %724, <16 x i8> %722, <16 x i8> %716
%727 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 4, i64 %703, i64 64
%728 = bitcast i8* %727 to <16 x i8>*
%729 = load <16 x i8>, <16 x i8>* %728
%730 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 4, i64 %703, i64 80
%731 = bitcast i8* %730 to <16 x i8>*
%732 = load <16 x i8>, <16 x i8>* %731
%733 = icmp ugt <16 x i8> %729, %725
%734 = icmp ugt <16 x i8> %732, %726
%735 = select <16 x i1> %733, <16 x i8> %729, <16 x i8> %725
%736 = select <16 x i1> %734, <16 x i8> %732, <16 x i8> %726
%737 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 4, i64 %703, i64 96
%738 = bitcast i8* %737 to <16 x i8>*
%739 = load <16 x i8>, <16 x i8>* %738
%740 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 4, i64 %703, i64 112
%741 = bitcast i8* %740 to <16 x i8>*
%742 = load <16 x i8>, <16 x i8>* %741
%743 = icmp ugt <16 x i8> %739, %735
%744 = icmp ugt <16 x i8> %742, %736
%745 = select <16 x i1> %743, <16 x i8> %739, <16 x i8> %735
%746 = select <16 x i1> %744, <16 x i8> %742, <16 x i8> %736
%747 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 4, i64 %703, i64 128
%748 = bitcast i8* %747 to <16 x i8>*
%749 = load <16 x i8>, <16 x i8>* %748
%750 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 4, i64 %703, i64 144
%751 = bitcast i8* %750 to <16 x i8>*
%752 = load <16 x i8>, <16 x i8>* %751
%753 = icmp ugt <16 x i8> %749, %745
%754 = icmp ugt <16 x i8> %752, %746
%755 = select <16 x i1> %753, <16 x i8> %749, <16 x i8> %745
%756 = select <16 x i1> %754, <16 x i8> %752, <16 x i8> %746
%757 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 4, i64 %703, i64 160
%758 = bitcast i8* %757 to <16 x i8>*
%759 = load <16 x i8>, <16 x i8>* %758
%760 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 4, i64 %703, i64 176
%761 = bitcast i8* %760 to <16 x i8>*
%762 = load <16 x i8>, <16 x i8>* %761
%763 = icmp ugt <16 x i8> %759, %755
%764 = icmp ugt <16 x i8> %762, %756
%765 = select <16 x i1> %763, <16 x i8> %759, <16 x i8> %755
%766 = select <16 x i1> %764, <16 x i8> %762, <16 x i8> %756
%767 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 4, i64 %703, i64 192
%768 = bitcast i8* %767 to <16 x i8>*
%769 = load <16 x i8>, <16 x i8>* %768
%770 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 4, i64 %703, i64 208
%771 = bitcast i8* %770 to <16 x i8>*
%772 = load <16 x i8>, <16 x i8>* %771
%773 = icmp ugt <16 x i8> %769, %765
%774 = icmp ugt <16 x i8> %772, %766
%775 = select <16 x i1> %773, <16 x i8> %769, <16 x i8> %765
%776 = select <16 x i1> %774, <16 x i8> %772, <16 x i8> %766
%777 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 4, i64 %703, i64 224
%778 = bitcast i8* %777 to <16 x i8>*
%779 = load <16 x i8>, <16 x i8>* %778
%780 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 4, i64 %703, i64 240
%781 = bitcast i8* %780 to <16 x i8>*
%782 = load <16 x i8>, <16 x i8>* %781
%783 = icmp ugt <16 x i8> %779, %775
%784 = icmp ugt <16 x i8> %782, %776
%785 = select <16 x i1> %783, <16 x i8> %779, <16 x i8> %775
%786 = select <16 x i1> %784, <16 x i8> %782, <16 x i8> %776
%787 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 4, i64 %703, i64 256
%788 = bitcast i8* %787 to <16 x i8>*
%789 = load <16 x i8>, <16 x i8>* %788
%790 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 4, i64 %703, i64 272
%791 = bitcast i8* %790 to <16 x i8>*
%792 = load <16 x i8>, <16 x i8>* %791
%793 = icmp ugt <16 x i8> %789, %785
%794 = icmp ugt <16 x i8> %792, %786
%795 = select <16 x i1> %793, <16 x i8> %789, <16 x i8> %785
%796 = select <16 x i1> %794, <16 x i8> %792, <16 x i8> %786
%797 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 4, i64 %703, i64 288
%798 = bitcast i8* %797 to <16 x i8>*
%799 = load <16 x i8>, <16 x i8>* %798
%800 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 4, i64 %703, i64 304
%801 = bitcast i8* %800 to <16 x i8>*
%802 = load <16 x i8>, <16 x i8>* %801
%803 = icmp ugt <16 x i8> %799, %795
%804 = icmp ugt <16 x i8> %802, %796
%805 = select <16 x i1> %803, <16 x i8> %799, <16 x i8> %795
%806 = select <16 x i1> %804, <16 x i8> %802, <16 x i8> %796
%807 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 4, i64 %703, i64 320
%808 = bitcast i8* %807 to <16 x i8>*
%809 = load <16 x i8>, <16 x i8>* %808
%810 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 4, i64 %703, i64 336
%811 = bitcast i8* %810 to <16 x i8>*
%812 = load <16 x i8>, <16 x i8>* %811
%813 = icmp ugt <16 x i8> %809, %805
%814 = icmp ugt <16 x i8> %812, %806
%815 = select <16 x i1> %813, <16 x i8> %809, <16 x i8> %805
%816 = select <16 x i1> %814, <16 x i8> %812, <16 x i8> %806
%817 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 4, i64 %703, i64 352
%818 = bitcast i8* %817 to <16 x i8>*
%819 = load <16 x i8>, <16 x i8>* %818
%820 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 4, i64 %703, i64 368
%821 = bitcast i8* %820 to <16 x i8>*
%822 = load <16 x i8>, <16 x i8>* %821
%823 = icmp ugt <16 x i8> %819, %815
%824 = icmp ugt <16 x i8> %822, %816
%825 = select <16 x i1> %823, <16 x i8> %819, <16 x i8> %815
%826 = select <16 x i1> %824, <16 x i8> %822, <16 x i8> %816
%827 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 4, i64 %703, i64 384
%828 = bitcast i8* %827 to <16 x i8>*
%829 = load <16 x i8>, <16 x i8>* %828
%830 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 4, i64 %703, i64 400
%831 = bitcast i8* %830 to <16 x i8>*
%832 = load <16 x i8>, <16 x i8>* %831
%833 = icmp ugt <16 x i8> %829, %825
%834 = icmp ugt <16 x i8> %832, %826
%835 = select <16 x i1> %833, <16 x i8> %829, <16 x i8> %825
%836 = select <16 x i1> %834, <16 x i8> %832, <16 x i8> %826
%837 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 4, i64 %703, i64 416
%838 = bitcast i8* %837 to <16 x i8>*
%839 = load <16 x i8>, <16 x i8>* %838
%840 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 4, i64 %703, i64 432
%841 = bitcast i8* %840 to <16 x i8>*
%842 = load <16 x i8>, <16 x i8>* %841
%843 = icmp ugt <16 x i8> %839, %835
%844 = icmp ugt <16 x i8> %842, %836
%845 = select <16 x i1> %843, <16 x i8> %839, <16 x i8> %835
%846 = select <16 x i1> %844, <16 x i8> %842, <16 x i8> %836
%847 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 4, i64 %703, i64 448
%848 = bitcast i8* %847 to <16 x i8>*
%849 = load <16 x i8>, <16 x i8>* %848
%850 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 4, i64 %703, i64 464
%851 = bitcast i8* %850 to <16 x i8>*
%852 = load <16 x i8>, <16 x i8>* %851
%853 = icmp ugt <16 x i8> %849, %845
%854 = icmp ugt <16 x i8> %852, %846
%855 = select <16 x i1> %853, <16 x i8> %849, <16 x i8> %845
%856 = select <16 x i1> %854, <16 x i8> %852, <16 x i8> %846
%857 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 4, i64 %703, i64 480
%858 = bitcast i8* %857 to <16 x i8>*
%859 = load <16 x i8>, <16 x i8>* %858
%860 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 4, i64 %703, i64 496
%861 = bitcast i8* %860 to <16 x i8>*
%862 = load <16 x i8>, <16 x i8>* %861
%863 = icmp ugt <16 x i8> %859, %855
%864 = icmp ugt <16 x i8> %862, %856
%865 = select <16 x i1> %863, <16 x i8> %859, <16 x i8> %855
%866 = select <16 x i1> %864, <16 x i8> %862, <16 x i8> %856
%867 = icmp ugt <16 x i8> %865, %866
%868 = select <16 x i1> %867, <16 x i8> %865, <16 x i8> %866
%869 = call i8 @llvm.vector.reduce.umax.v16i8(<16 x i8> %868)
%870 = add nuw nsw i64 %703, 1
%871 = icmp eq i64 %870, 512
br i1 %871, label %872, label %702
872: ; preds = %702, %872
%873 = phi i64 [ %1040, %872 ], [ 0, %702 ]
%874 = phi i8 [ %1039, %872 ], [ %869, %702 ]
%875 = insertelement <16 x i8> poison, i8 %874, i64 0
%876 = shufflevector <16 x i8> %875, <16 x i8> poison, <16 x i32> zeroinitializer
%877 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 5, i64 %873, i64 0
%878 = bitcast i8* %877 to <16 x i8>*
%879 = load <16 x i8>, <16 x i8>* %878
%880 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 5, i64 %873, i64 16
%881 = bitcast i8* %880 to <16 x i8>*
%882 = load <16 x i8>, <16 x i8>* %881
%883 = icmp ugt <16 x i8> %879, %876
%884 = icmp ugt <16 x i8> %882, %876
%885 = select <16 x i1> %883, <16 x i8> %879, <16 x i8> %876
%886 = select <16 x i1> %884, <16 x i8> %882, <16 x i8> %876
%887 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 5, i64 %873, i64 32
%888 = bitcast i8* %887 to <16 x i8>*
%889 = load <16 x i8>, <16 x i8>* %888
%890 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 5, i64 %873, i64 48
%891 = bitcast i8* %890 to <16 x i8>*
%892 = load <16 x i8>, <16 x i8>* %891
%893 = icmp ugt <16 x i8> %889, %885
%894 = icmp ugt <16 x i8> %892, %886
%895 = select <16 x i1> %893, <16 x i8> %889, <16 x i8> %885
%896 = select <16 x i1> %894, <16 x i8> %892, <16 x i8> %886
%897 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 5, i64 %873, i64 64
%898 = bitcast i8* %897 to <16 x i8>*
%899 = load <16 x i8>, <16 x i8>* %898
%900 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 5, i64 %873, i64 80
%901 = bitcast i8* %900 to <16 x i8>*
%902 = load <16 x i8>, <16 x i8>* %901
%903 = icmp ugt <16 x i8> %899, %895
%904 = icmp ugt <16 x i8> %902, %896
%905 = select <16 x i1> %903, <16 x i8> %899, <16 x i8> %895
%906 = select <16 x i1> %904, <16 x i8> %902, <16 x i8> %896
%907 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 5, i64 %873, i64 96
%908 = bitcast i8* %907 to <16 x i8>*
%909 = load <16 x i8>, <16 x i8>* %908
%910 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 5, i64 %873, i64 112
%911 = bitcast i8* %910 to <16 x i8>*
%912 = load <16 x i8>, <16 x i8>* %911
%913 = icmp ugt <16 x i8> %909, %905
%914 = icmp ugt <16 x i8> %912, %906
%915 = select <16 x i1> %913, <16 x i8> %909, <16 x i8> %905
%916 = select <16 x i1> %914, <16 x i8> %912, <16 x i8> %906
%917 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 5, i64 %873, i64 128
%918 = bitcast i8* %917 to <16 x i8>*
%919 = load <16 x i8>, <16 x i8>* %918
%920 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 5, i64 %873, i64 144
%921 = bitcast i8* %920 to <16 x i8>*
%922 = load <16 x i8>, <16 x i8>* %921
%923 = icmp ugt <16 x i8> %919, %915
%924 = icmp ugt <16 x i8> %922, %916
%925 = select <16 x i1> %923, <16 x i8> %919, <16 x i8> %915
%926 = select <16 x i1> %924, <16 x i8> %922, <16 x i8> %916
%927 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 5, i64 %873, i64 160
%928 = bitcast i8* %927 to <16 x i8>*
%929 = load <16 x i8>, <16 x i8>* %928
%930 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 5, i64 %873, i64 176
%931 = bitcast i8* %930 to <16 x i8>*
%932 = load <16 x i8>, <16 x i8>* %931
%933 = icmp ugt <16 x i8> %929, %925
%934 = icmp ugt <16 x i8> %932, %926
%935 = select <16 x i1> %933, <16 x i8> %929, <16 x i8> %925
%936 = select <16 x i1> %934, <16 x i8> %932, <16 x i8> %926
%937 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 5, i64 %873, i64 192
%938 = bitcast i8* %937 to <16 x i8>*
%939 = load <16 x i8>, <16 x i8>* %938
%940 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 5, i64 %873, i64 208
%941 = bitcast i8* %940 to <16 x i8>*
%942 = load <16 x i8>, <16 x i8>* %941
%943 = icmp ugt <16 x i8> %939, %935
%944 = icmp ugt <16 x i8> %942, %936
%945 = select <16 x i1> %943, <16 x i8> %939, <16 x i8> %935
%946 = select <16 x i1> %944, <16 x i8> %942, <16 x i8> %936
%947 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 5, i64 %873, i64 224
%948 = bitcast i8* %947 to <16 x i8>*
%949 = load <16 x i8>, <16 x i8>* %948
%950 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 5, i64 %873, i64 240
%951 = bitcast i8* %950 to <16 x i8>*
%952 = load <16 x i8>, <16 x i8>* %951
%953 = icmp ugt <16 x i8> %949, %945
%954 = icmp ugt <16 x i8> %952, %946
%955 = select <16 x i1> %953, <16 x i8> %949, <16 x i8> %945
%956 = select <16 x i1> %954, <16 x i8> %952, <16 x i8> %946
%957 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 5, i64 %873, i64 256
%958 = bitcast i8* %957 to <16 x i8>*
%959 = load <16 x i8>, <16 x i8>* %958
%960 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 5, i64 %873, i64 272
%961 = bitcast i8* %960 to <16 x i8>*
%962 = load <16 x i8>, <16 x i8>* %961
%963 = icmp ugt <16 x i8> %959, %955
%964 = icmp ugt <16 x i8> %962, %956
%965 = select <16 x i1> %963, <16 x i8> %959, <16 x i8> %955
%966 = select <16 x i1> %964, <16 x i8> %962, <16 x i8> %956
%967 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 5, i64 %873, i64 288
%968 = bitcast i8* %967 to <16 x i8>*
%969 = load <16 x i8>, <16 x i8>* %968
%970 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 5, i64 %873, i64 304
%971 = bitcast i8* %970 to <16 x i8>*
%972 = load <16 x i8>, <16 x i8>* %971
%973 = icmp ugt <16 x i8> %969, %965
%974 = icmp ugt <16 x i8> %972, %966
%975 = select <16 x i1> %973, <16 x i8> %969, <16 x i8> %965
%976 = select <16 x i1> %974, <16 x i8> %972, <16 x i8> %966
%977 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 5, i64 %873, i64 320
%978 = bitcast i8* %977 to <16 x i8>*
%979 = load <16 x i8>, <16 x i8>* %978
%980 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 5, i64 %873, i64 336
%981 = bitcast i8* %980 to <16 x i8>*
%982 = load <16 x i8>, <16 x i8>* %981
%983 = icmp ugt <16 x i8> %979, %975
%984 = icmp ugt <16 x i8> %982, %976
%985 = select <16 x i1> %983, <16 x i8> %979, <16 x i8> %975
%986 = select <16 x i1> %984, <16 x i8> %982, <16 x i8> %976
%987 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 5, i64 %873, i64 352
%988 = bitcast i8* %987 to <16 x i8>*
%989 = load <16 x i8>, <16 x i8>* %988
%990 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 5, i64 %873, i64 368
%991 = bitcast i8* %990 to <16 x i8>*
%992 = load <16 x i8>, <16 x i8>* %991
%993 = icmp ugt <16 x i8> %989, %985
%994 = icmp ugt <16 x i8> %992, %986
%995 = select <16 x i1> %993, <16 x i8> %989, <16 x i8> %985
%996 = select <16 x i1> %994, <16 x i8> %992, <16 x i8> %986
%997 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 5, i64 %873, i64 384
%998 = bitcast i8* %997 to <16 x i8>*
%999 = load <16 x i8>, <16 x i8>* %998
%1000 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 5, i64 %873, i64 400
%1001 = bitcast i8* %1000 to <16 x i8>*
%1002 = load <16 x i8>, <16 x i8>* %1001
%1003 = icmp ugt <16 x i8> %999, %995
%1004 = icmp ugt <16 x i8> %1002, %996
%1005 = select <16 x i1> %1003, <16 x i8> %999, <16 x i8> %995
%1006 = select <16 x i1> %1004, <16 x i8> %1002, <16 x i8> %996
%1007 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 5, i64 %873, i64 416
%1008 = bitcast i8* %1007 to <16 x i8>*
%1009 = load <16 x i8>, <16 x i8>* %1008
%1010 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 5, i64 %873, i64 432
%1011 = bitcast i8* %1010 to <16 x i8>*
%1012 = load <16 x i8>, <16 x i8>* %1011
%1013 = icmp ugt <16 x i8> %1009, %1005
%1014 = icmp ugt <16 x i8> %1012, %1006
%1015 = select <16 x i1> %1013, <16 x i8> %1009, <16 x i8> %1005
%1016 = select <16 x i1> %1014, <16 x i8> %1012, <16 x i8> %1006
%1017 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 5, i64 %873, i64 448
%1018 = bitcast i8* %1017 to <16 x i8>*
%1019 = load <16 x i8>, <16 x i8>* %1018
%1020 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 5, i64 %873, i64 464
%1021 = bitcast i8* %1020 to <16 x i8>*
%1022 = load <16 x i8>, <16 x i8>* %1021
%1023 = icmp ugt <16 x i8> %1019, %1015
%1024 = icmp ugt <16 x i8> %1022, %1016
%1025 = select <16 x i1> %1023, <16 x i8> %1019, <16 x i8> %1015
%1026 = select <16 x i1> %1024, <16 x i8> %1022, <16 x i8> %1016
%1027 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 5, i64 %873, i64 480
%1028 = bitcast i8* %1027 to <16 x i8>*
%1029 = load <16 x i8>, <16 x i8>* %1028
%1030 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 5, i64 %873, i64 496
%1031 = bitcast i8* %1030 to <16 x i8>*
%1032 = load <16 x i8>, <16 x i8>* %1031
%1033 = icmp ugt <16 x i8> %1029, %1025
%1034 = icmp ugt <16 x i8> %1032, %1026
%1035 = select <16 x i1> %1033, <16 x i8> %1029, <16 x i8> %1025
%1036 = select <16 x i1> %1034, <16 x i8> %1032, <16 x i8> %1026
%1037 = icmp ugt <16 x i8> %1035, %1036
%1038 = select <16 x i1> %1037, <16 x i8> %1035, <16 x i8> %1036
%1039 = call i8 @llvm.vector.reduce.umax.v16i8(<16 x i8> %1038)
%1040 = add nuw nsw i64 %873, 1
%1041 = icmp eq i64 %1040, 512
br i1 %1041, label %1042, label %872
1042: ; preds = %872
%1043 = bitcast [3 x double]* %4 to i8*
%1044 = getelementptr inbounds [3 x double], [3 x double]* %4, i64 0, i64 0
%1045 = getelementptr inbounds [3 x double], [3 x double]* %4, i64 0, i64 1
%1046 = getelementptr inbounds [3 x double], [3 x double]* %4, i64 0, i64 2
%1047 = zext i8 %1039 to i32
%1048 = bitcast [3 x double]* %4 to <2 x double>*
br label %1049
1049: ; preds = %1042, %1090
%1050 = phi i64 [ 0, %1042 ], [ %1091, %1090 ]
%1051 = phi double [ 0.000000e+00, %1042 ], [ %1084, %1090 ]
%1052 = phi <2 x double> [ zeroinitializer, %1042 ], [ %1082, %1090 ]
%1053 = trunc i64 %1050 to i32
br label %1054
1054: ; preds = %1049, %1087
%1055 = phi i64 [ 0, %1049 ], [ %1088, %1087 ]
%1056 = phi double [ %1051, %1049 ], [ %1084, %1087 ]
%1057 = phi <2 x double> [ %1052, %1049 ], [ %1082, %1087 ]
%1058 = trunc i64 %1055 to i32
br label %1059
1059: ; preds = %1054, %1059
%1060 = phi i64 [ 0, %1054 ], [ %1085, %1059 ]
%1061 = phi double [ %1056, %1054 ], [ %1084, %1059 ]
%1062 = phi <2 x double> [ %1057, %1054 ], [ %1082, %1059 ]
%1063 = trunc i64 %1060 to i32
%1064 = call i32 @MapCoord(i32 %1053, i32 %1058, i32 %1063, double* %1044)
%1065 = load double, double* %1044
%1066 = load double, double* %1045
%1067 = fmul double %1066, %1066
%1068 = call double @llvm.fmuladd.f64(double %1065, double %1065, double %1067)
%1069 = load double, double* %1046
%1070 = call double @llvm.fmuladd.f64(double %1069, double %1069, double %1068)
%1071 = call double @pow(double %1070, double -1.500000e+00)
%1072 = getelementptr inbounds [6 x [512 x [512 x i8]]], [6 x [512 x [512 x i8]]]* %3, i64 0, i64 %1050, i64 %1055, i64 %1060
%1073 = load i8, i8* %1072
%1074 = zext i8 %1073 to i32
%1075 = sub nsw i32 %1074, %1047
%1076 = mul nsw i32 %1075, 10
%1077 = call double @exp(i32 %1076)
%1078 = fmul double %1071, %1077
%1079 = load <2 x double>, <2 x double>* %1048
%1080 = insertelement <2 x double> poison, double %1078, i64 0
%1081 = shufflevector <2 x double> %1080, <2 x double> poison, <2 x i32> zeroinitializer
%1082 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %1081, <2 x double> %1079, <2 x double> %1062)
%1083 = load double, double* %1046
%1084 = call double @llvm.fmuladd.f64(double %1078, double %1083, double %1061)
%1085 = add nuw nsw i64 %1060, 1
%1086 = icmp eq i64 %1085, 512
br i1 %1086, label %1087, label %1059
1087: ; preds = %1059
%1088 = add nuw nsw i64 %1055, 1
%1089 = icmp eq i64 %1088, 512
br i1 %1089, label %1090, label %1054
1090: ; preds = %1087
%1091 = add nuw nsw i64 %1050, 1
%1092 = icmp eq i64 %1091, 6
br i1 %1092, label %1093, label %1049
1093: ; preds = %1090
%1094 = extractelement <2 x double> %1082, i64 1
%1095 = fmul double %1094, %1094
%1096 = extractelement <2 x double> %1082, i64 0
%1097 = call double @llvm.fmuladd.f64(double %1096, double %1096, double %1095)
%1098 = call double @llvm.fmuladd.f64(double %1084, double %1084, double %1097)
%1099 = call double @sqrt(double %1098)
%1100 = load i32, i32* @stderr
%1101 = fdiv double %1096, %1099
%1102 = fdiv double %1094, %1099
%1103 = fdiv double %1084, %1099
%1104 = call i32 (i32, i8*, ...) @fprintf(i32 %1100, i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.3, i64 0, i64 0), double %1101, double %1102, double %1103)
%1105 = call double @sqrt(double %1097)
%1106 = call double @atan2(double %1084, double %1105)
%1107 = call double @atan2(double %1094, double %1096)
%1108 = fmul double %1107, 1.800000e+02
%1109 = load double, double* @M_PI
%1110 = fdiv double %1108, %1109
%1111 = fmul double %1106, 1.800000e+02
%1112 = fdiv double %1111, %1109
%1113 = call i32 @printf(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.4, i64 0, i64 0), double %1110, double %1112)
br label %1114
1114: ; preds = %1093, %16, %7
%1115 = phi i32 [ 1, %7 ], [ 0, %1093 ], [ 1, %16 ]
ret i32 %1115
}