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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int EXIT_FAILURE;
int EXIT_SUCCESS;
int /*<<< orphan*/ printf(char *, int);
int scanf(char *, char *);
int strlen(char *);
int main(int argc, char *argv[]) {
  char real[1001], want[1001];
  if (scanf("%s", real) != 1)
    return EXIT_FAILURE;
  if (scanf("%s", want) != 1)
    return EXIT_FAILURE;
  int len_real = strlen(real);
  int len_want = strlen(want);
  int stat_real[128] = {0};
  int stat_want[128] = {0};
  for (int i = 0; i < len_real; i++) {
    stat_real[(int)real[i]]++;
  }
  for (int i = 0; i < len_want; i++) {
    stat_want[(int)want[i]]++;
  }
  int stat_diff[128] = {0};
  for (int i = 0; i < 128; i++) {
    stat_diff[i] = stat_real[i] - stat_want[i];
  }
  int is_yes = 1;
  int result_count = 0;
  for (int i = 0; i < 128; i++) {
    if (stat_diff[i] < 0) {
      is_yes = 0;
    }
  }
  if (is_yes == 1) {
    result_count = len_real - len_want;
    printf("Yes %d", result_count);
  } else {
    for (int i = 0; i < 128; i++) {
      if (stat_diff[i] < 0) {
        result_count += stat_diff[i];
      }
    }
    result_count *= -1;
    printf("No %d", result_count);
  }
  return EXIT_SUCCESS;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0xe30,%rsp
movl   $0x0,-0x4(%rbp)
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
lea    -0x400(%rbp),%rsi
lea    0xe99(%rip),%rdi
call   1060 <scanf@plt>
cmp    $0x1,%eax
je     1186 <main+0x46>
mov    0x2e64(%rip),%rax
mov    (%rax),%eax
mov    %eax,-0x4(%rbp)
jmp    1435 <main+0x2f5>
lea    -0x7f0(%rbp),%rsi
lea    0xe6c(%rip),%rdi
call   1060 <scanf@plt>
cmp    $0x1,%eax
je     11b3 <main+0x73>
mov    0x2e37(%rip),%rax
mov    (%rax),%eax
mov    %eax,-0x4(%rbp)
jmp    1435 <main+0x2f5>
lea    -0x400(%rbp),%rdi
call   1030 <strlen@plt>
mov    %eax,-0x7f4(%rbp)
lea    -0x7f0(%rbp),%rdi
call   1030 <strlen@plt>
mov    %eax,-0x7f8(%rbp)
lea    -0xa00(%rbp),%rdi
xor    %esi,%esi
mov    $0x200,%edx
call   1050 <memset@plt>
lea    -0xc00(%rbp),%rdi
xor    %esi,%esi
mov    $0x200,%edx
call   1050 <memset@plt>
movl   $0x0,-0xc04(%rbp)
mov    -0xc04(%rbp),%eax
cmp    -0x7f4(%rbp),%eax
jge    124f <main+0x10f>
movslq -0xc04(%rbp),%rax
movsbl -0x400(%rbp,%rax,1),%eax
ff
cltq
mov    -0xa00(%rbp,%rax,4),%ecx
add    $0x1,%ecx
mov    %ecx,-0xa00(%rbp,%rax,4)
mov    -0xc04(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc04(%rbp)
jmp    1207 <main+0xc7>
movl   $0x0,-0xc08(%rbp)
mov    -0xc08(%rbp),%eax
cmp    -0x7f8(%rbp),%eax
jge    12a1 <main+0x161>
movslq -0xc08(%rbp),%rax
movsbl -0x7f0(%rbp,%rax,1),%eax
ff
cltq
mov    -0xc00(%rbp,%rax,4),%ecx
add    $0x1,%ecx
mov    %ecx,-0xc00(%rbp,%rax,4)
mov    -0xc08(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc08(%rbp)
jmp    1259 <main+0x119>
lea    -0xe10(%rbp),%rdi
xor    %esi,%esi
mov    $0x200,%edx
call   1050 <memset@plt>
movl   $0x0,-0xe14(%rbp)
cmpl   $0x80,-0xe14(%rbp)
jge    130c <main+0x1cc>
movslq -0xe14(%rbp),%rax
mov    -0xa00(%rbp,%rax,4),%ecx
movslq -0xe14(%rbp),%rax
sub    -0xc00(%rbp,%rax,4),%ecx
movslq -0xe14(%rbp),%rax
mov    %ecx,-0xe10(%rbp,%rax,4)
mov    -0xe14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xe14(%rbp)
jmp    12be <main+0x17e>
movl   $0x1,-0xe18(%rbp)
movl   $0x0,-0xe1c(%rbp)
movl   $0x0,-0xe20(%rbp)
cmpl   $0x80,-0xe20(%rbp)
jge    1372 <main+0x232>
movslq -0xe20(%rbp),%rax
cmpl   $0x0,-0xe10(%rbp,%rax,4)
jge    1359 <main+0x219>
movl   $0x0,-0xe18(%rbp)
jmp    135e <main+0x21e>
mov    -0xe20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xe20(%rbp)
jmp    132a <main+0x1ea>
cmpl   $0x1,-0xe18(%rbp)
jne    13a8 <main+0x268>
mov    -0x7f4(%rbp),%eax
sub    -0x7f8(%rbp),%eax
mov    %eax,-0xe1c(%rbp)
mov    -0xe1c(%rbp),%esi
lea    0xc65(%rip),%rdi
call   1040 <printf@plt>
jmp    1429 <main+0x2e9>
movl   $0x0,-0xe24(%rbp)
cmpl   $0x80,-0xe24(%rbp)
jge    140a <main+0x2ca>
movslq -0xe24(%rbp),%rax
cmpl   $0x0,-0xe10(%rbp,%rax,4)
jge    13f1 <main+0x2b1>
movslq -0xe24(%rbp),%rax
mov    -0xe10(%rbp,%rax,4),%eax
add    -0xe1c(%rbp),%eax
mov    %eax,-0xe1c(%rbp)
jmp    13f6 <main+0x2b6>
mov    -0xe24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xe24(%rbp)
jmp    13b2 <main+0x272>
imul   $0xffffffff,-0xe1c(%rbp),%eax
mov    %eax,-0xe1c(%rbp)
mov    -0xe1c(%rbp),%esi
lea    0xbe6(%rip),%rdi
call   1040 <printf@plt>
mov    0x2ba8(%rip),%rax
mov    (%rax),%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0xe30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %rbx
sub    $0xde8,%rsp
lea    0xec0(%rip),%rdi
lea    0x9f0(%rsp),%rsi
call   1060 <scanf@plt>
cmp    $0x1,%eax
jne    11de <main+0x9e>
lea    0xea7(%rip),%rdi
lea    0x600(%rsp),%rsi
call   1060 <scanf@plt>
cmp    $0x1,%eax
jne    11de <main+0x9e>
lea    0x9f0(%rsp),%rdi
call   1030 <strlen@plt>
mov    %eax,%ebx
lea    0x600(%rsp),%rdi
call   1030 <strlen@plt>
mov    %eax,%ebp
lea    0x400(%rsp),%rdi
mov    $0x200,%edx
xor    %esi,%esi
call   1050 <memset@plt>
lea    0x200(%rsp),%rdi
mov    $0x200,%edx
xor    %esi,%esi
call   1050 <memset@plt>
test   %ebx,%ebx
jle    1266 <main+0x126>
mov    %ebx,%ecx
lea    -0x1(%rcx),%rdx
mov    %ecx,%eax
and    $0x3,%eax
cmp    $0x3,%rdx
jae    11ea <main+0xaa>
xor    %edx,%edx
jmp    123d <main+0xfd>
mov    0x2dfb(%rip),%rax
jmp    1ac8 <main+0x988>
and    $0xfffffffc,%ecx
xor    %edx,%edx
nop
movsbq 0x9f0(%rsp,%rdx,1),%rsi
addl   $0x1,0x400(%rsp,%rsi,4)
movsbq 0x9f1(%rsp,%rdx,1),%rsi
addl   $0x1,0x400(%rsp,%rsi,4)
01
movsbq 0x9f2(%rsp,%rdx,1),%rsi
addl   $0x1,0x400(%rsp,%rsi,4)
01
movsbq 0x9f3(%rsp,%rdx,1),%rsi
addl   $0x1,0x400(%rsp,%rsi,4)
01
add    $0x4,%rdx
cmp    %rdx,%rcx
jne    11f0 <main+0xb0>
test   %rax,%rax
je     1266 <main+0x126>
lea    (%rsp,%rdx,1),%rcx
add    $0x9f0,%rcx
xor    %edx,%edx
nop
movsbq (%rcx,%rdx,1),%rsi
addl   $0x1,0x400(%rsp,%rsi,4)
01
add    $0x1,%rdx
cmp    %rdx,%rax
jne    1250 <main+0x110>
test   %ebp,%ebp
jle    1306 <main+0x1c6>
mov    %ebp,%ecx
lea    -0x1(%rcx),%rdx
mov    %ecx,%eax
and    $0x3,%eax
cmp    $0x3,%rdx
jae    1283 <main+0x143>
xor    %edx,%edx
jmp    12dd <main+0x19d>
and    $0xfffffffc,%ecx
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
movsbq 0x600(%rsp,%rdx,1),%rsi
addl   $0x1,0x200(%rsp,%rsi,4)
01
movsbq 0x601(%rsp,%rdx,1),%rsi
addl   $0x1,0x200(%rsp,%rsi,4)
01
movsbq 0x602(%rsp,%rdx,1),%rsi
addl   $0x1,0x200(%rsp,%rsi,4)
01
movsbq 0x603(%rsp,%rdx,1),%rsi
addl   $0x1,0x200(%rsp,%rsi,4)
01
add    $0x4,%rdx
cmp    %rdx,%rcx
jne    1290 <main+0x150>
test   %rax,%rax
je     1306 <main+0x1c6>
lea    (%rsp,%rdx,1),%rcx
add    $0x600,%rcx
xor    %edx,%edx
nop
movsbq (%rcx,%rdx,1),%rsi
addl   $0x1,0x200(%rsp,%rsi,4)
01
add    $0x1,%rdx
cmp    %rdx,%rax
jne    12f0 <main+0x1b0>
mov    %rsp,%rdi
mov    $0x200,%edx
xor    %esi,%esi
call   1050 <memset@plt>
movdqa 0x400(%rsp),%xmm0
movdqa 0x410(%rsp),%xmm1
movdqa 0x420(%rsp),%xmm2
psubd  0x200(%rsp),%xmm0
psubd  0x210(%rsp),%xmm1
movdqa 0x430(%rsp),%xmm3
movdqa %xmm0,(%rsp)
psubd  0x220(%rsp),%xmm2
movdqa %xmm1,0x10(%rsp)
psubd  0x230(%rsp),%xmm3
movdqa %xmm2,0x20(%rsp)
movdqa %xmm3,0x30(%rsp)
movdqa 0x440(%rsp),%xmm0
psubd  0x240(%rsp),%xmm0
movdqa 0x450(%rsp),%xmm1
psubd  0x250(%rsp),%xmm1
movdqa %xmm0,0x40(%rsp)
movdqa %xmm1,0x50(%rsp)
movdqa 0x460(%rsp),%xmm0
movdqa 0x470(%rsp),%xmm1
movdqa 0x480(%rsp),%xmm2
psubd  0x260(%rsp),%xmm0
psubd  0x270(%rsp),%xmm1
movdqa 0x490(%rsp),%xmm3
movdqa %xmm0,0x60(%rsp)
psubd  0x280(%rsp),%xmm2
movdqa %xmm1,0x70(%rsp)
psubd  0x290(%rsp),%xmm3
movdqa %xmm2,0x80(%rsp)
movdqa %xmm3,0x90(%rsp)
movdqa 0x4a0(%rsp),%xmm0
psubd  0x2a0(%rsp),%xmm0
movdqa 0x4b0(%rsp),%xmm1
psubd  0x2b0(%rsp),%xmm1
movdqa %xmm0,0xa0(%rsp)
movdqa %xmm1,0xb0(%rsp)
movdqa 0x4c0(%rsp),%xmm0
movdqa 0x4d0(%rsp),%xmm1
movdqa 0x4e0(%rsp),%xmm2
psubd  0x2c0(%rsp),%xmm0
psubd  0x2d0(%rsp),%xmm1
movdqa 0x4f0(%rsp),%xmm3
movdqa %xmm0,0xc0(%rsp)
psubd  0x2e0(%rsp),%xmm2
movdqa %xmm1,0xd0(%rsp)
psubd  0x2f0(%rsp),%xmm3
movdqa %xmm2,0xe0(%rsp)
movdqa %xmm3,0xf0(%rsp)
movdqa 0x500(%rsp),%xmm0
psubd  0x300(%rsp),%xmm0
movdqa 0x510(%rsp),%xmm1
psubd  0x310(%rsp),%xmm1
movdqa %xmm0,0x100(%rsp)
movdqa %xmm1,0x110(%rsp)
movdqa 0x520(%rsp),%xmm0
movdqa 0x530(%rsp),%xmm1
movdqa 0x540(%rsp),%xmm2
psubd  0x320(%rsp),%xmm0
psubd  0x330(%rsp),%xmm1
movdqa 0x550(%rsp),%xmm3
movdqa %xmm0,0x120(%rsp)
psubd  0x340(%rsp),%xmm2
movdqa %xmm1,0x130(%rsp)
psubd  0x350(%rsp),%xmm3
movdqa %xmm2,0x140(%rsp)
movdqa %xmm3,0x150(%rsp)
movdqa 0x560(%rsp),%xmm0
psubd  0x360(%rsp),%xmm0
movdqa 0x570(%rsp),%xmm1
psubd  0x370(%rsp),%xmm1
movdqa %xmm0,0x160(%rsp)
movdqa %xmm1,0x170(%rsp)
movdqa 0x580(%rsp),%xmm0
psubd  0x380(%rsp),%xmm0
movdqa 0x590(%rsp),%xmm1
psubd  0x390(%rsp),%xmm1
movdqa %xmm0,0x180(%rsp)
movdqa %xmm1,0x190(%rsp)
movdqa 0x5a0(%rsp),%xmm6
psubd  0x3a0(%rsp),%xmm6
movdqa 0x5b0(%rsp),%xmm3
psubd  0x3b0(%rsp),%xmm3
movdqa %xmm6,0x1a0(%rsp)
movdqa %xmm3,0x1b0(%rsp)
movdqa 0x5c0(%rsp),%xmm7
psubd  0x3c0(%rsp),%xmm7
movdqa 0x5d0(%rsp),%xmm4
psubd  0x3d0(%rsp),%xmm4
movdqa %xmm7,0x1c0(%rsp)
movdqa %xmm4,0x1d0(%rsp)
movdqa 0x5e0(%rsp),%xmm0
psubd  0x3e0(%rsp),%xmm0
movdqa 0x5f0(%rsp),%xmm1
psubd  0x3f0(%rsp),%xmm1
movdqa %xmm0,0x1e0(%rsp)
movdqa %xmm1,0x1f0(%rsp)
pcmpeqd %xmm2,%xmm2
movdqa (%rsp),%xmm5
pxor   %xmm2,%xmm5
psrld  $0x1f,%xmm5
pxor   0x10(%rsp),%xmm2
psrld  $0x1f,%xmm2
por    %xmm7,%xmm0
por    %xmm6,%xmm0
por    0x180(%rsp),%xmm0
por    0x160(%rsp),%xmm0
por    0x140(%rsp),%xmm0
por    0x120(%rsp),%xmm0
por    0x100(%rsp),%xmm0
por    0xe0(%rsp),%xmm0
por    0xc0(%rsp),%xmm0
por    0xa0(%rsp),%xmm0
por    0x80(%rsp),%xmm0
por    0x60(%rsp),%xmm0
por    0x40(%rsp),%xmm0
por    %xmm4,%xmm1
por    0x20(%rsp),%xmm0
psrld  $0x1f,%xmm0
pandn  %xmm5,%xmm0
por    %xmm3,%xmm1
por    0x190(%rsp),%xmm1
por    0x170(%rsp),%xmm1
por    0x150(%rsp),%xmm1
por    0x130(%rsp),%xmm1
por    0x110(%rsp),%xmm1
por    0xf0(%rsp),%xmm1
por    0xd0(%rsp),%xmm1
por    0xb0(%rsp),%xmm1
por    0x90(%rsp),%xmm1
por    0x70(%rsp),%xmm1
por    0x50(%rsp),%xmm1
por    0x30(%rsp),%xmm1
psrld  $0x1f,%xmm1
pandn  %xmm2,%xmm1
movdqa 0x897(%rip),%xmm2
movdqa %xmm0,%xmm3
pcmpeqd %xmm2,%xmm3
pand   %xmm3,%xmm1
pandn  %xmm0,%xmm3
por    %xmm1,%xmm3
pcmpeqd %xmm2,%xmm3
movmskps %xmm3,%eax
cmp    $0xf,%eax
je     1ab1 <main+0x971>
pxor   %xmm0,%xmm0
movdqa (%rsp),%xmm1
movdqa 0x10(%rsp),%xmm2
movdqa 0x20(%rsp),%xmm3
movdqa 0x30(%rsp),%xmm4
pxor   %xmm5,%xmm5
pcmpgtd %xmm1,%xmm5
pand   %xmm1,%xmm5
pxor   %xmm1,%xmm1
pcmpgtd %xmm2,%xmm1
pand   %xmm2,%xmm1
pxor   %xmm6,%xmm6
pcmpgtd %xmm3,%xmm6
pand   %xmm3,%xmm6
paddd  %xmm5,%xmm6
pxor   %xmm2,%xmm2
pcmpgtd %xmm4,%xmm2
pand   %xmm4,%xmm2
paddd  %xmm1,%xmm2
movdqa 0x40(%rsp),%xmm1
movdqa 0x50(%rsp),%xmm3
pxor   %xmm4,%xmm4
pcmpgtd %xmm1,%xmm4
pand   %xmm1,%xmm4
pxor   %xmm5,%xmm5
pcmpgtd %xmm3,%xmm5
pand   %xmm3,%xmm5
movdqa 0x60(%rsp),%xmm3
movdqa 0x70(%rsp),%xmm7
pxor   %xmm1,%xmm1
pcmpgtd %xmm3,%xmm1
pand   %xmm3,%xmm1
paddd  %xmm4,%xmm1
paddd  %xmm6,%xmm1
pxor   %xmm4,%xmm4
pcmpgtd %xmm7,%xmm4
pand   %xmm7,%xmm4
paddd  %xmm5,%xmm4
paddd  %xmm2,%xmm4
movdqa 0x80(%rsp),%xmm2
movdqa 0x90(%rsp),%xmm3
pxor   %xmm5,%xmm5
pcmpgtd %xmm2,%xmm5
pand   %xmm2,%xmm5
pxor   %xmm2,%xmm2
pcmpgtd %xmm3,%xmm2
pand   %xmm3,%xmm2
movdqa 0xa0(%rsp),%xmm3
movdqa 0xb0(%rsp),%xmm6
pxor   %xmm7,%xmm7
pcmpgtd %xmm3,%xmm7
pand   %xmm3,%xmm7
paddd  %xmm5,%xmm7
pxor   %xmm5,%xmm5
pcmpgtd %xmm6,%xmm5
pand   %xmm6,%xmm5
paddd  %xmm2,%xmm5
movdqa 0xc0(%rsp),%xmm3
movdqa 0xd0(%rsp),%xmm6
pxor   %xmm2,%xmm2
pcmpgtd %xmm3,%xmm2
pand   %xmm3,%xmm2
paddd  %xmm7,%xmm2
paddd  %xmm1,%xmm2
pxor   %xmm3,%xmm3
pcmpgtd %xmm6,%xmm3
pand   %xmm6,%xmm3
paddd  %xmm5,%xmm3
paddd  %xmm4,%xmm3
movdqa 0xe0(%rsp),%xmm1
movdqa 0xf0(%rsp),%xmm4
pxor   %xmm5,%xmm5
pcmpgtd %xmm1,%xmm5
pand   %xmm1,%xmm5
pxor   %xmm1,%xmm1
pcmpgtd %xmm4,%xmm1
pand   %xmm4,%xmm1
movdqa 0x100(%rsp),%xmm4
movdqa 0x110(%rsp),%xmm6
pxor   %xmm7,%xmm7
pcmpgtd %xmm4,%xmm7
pand   %xmm4,%xmm7
paddd  %xmm5,%xmm7
pxor   %xmm4,%xmm4
pcmpgtd %xmm6,%xmm4
pand   %xmm6,%xmm4
paddd  %xmm1,%xmm4
movdqa 0x120(%rsp),%xmm1
movdqa 0x130(%rsp),%xmm5
pxor   %xmm6,%xmm6
pcmpgtd %xmm1,%xmm6
pand   %xmm1,%xmm6
paddd  %xmm7,%xmm6
pxor   %xmm7,%xmm7
pcmpgtd %xmm5,%xmm7
pand   %xmm5,%xmm7
paddd  %xmm4,%xmm7
movdqa 0x140(%rsp),%xmm4
movdqa 0x150(%rsp),%xmm5
pxor   %xmm1,%xmm1
pcmpgtd %xmm4,%xmm1
pand   %xmm4,%xmm1
paddd  %xmm6,%xmm1
paddd  %xmm2,%xmm1
pxor   %xmm2,%xmm2
pcmpgtd %xmm5,%xmm2
pand   %xmm5,%xmm2
paddd  %xmm7,%xmm2
paddd  %xmm3,%xmm2
movdqa 0x160(%rsp),%xmm3
movdqa 0x170(%rsp),%xmm4
pxor   %xmm5,%xmm5
pcmpgtd %xmm3,%xmm5
pand   %xmm3,%xmm5
pxor   %xmm3,%xmm3
pcmpgtd %xmm4,%xmm3
pand   %xmm4,%xmm3
movdqa 0x180(%rsp),%xmm4
movdqa 0x190(%rsp),%xmm6
pxor   %xmm7,%xmm7
pcmpgtd %xmm4,%xmm7
pand   %xmm4,%xmm7
paddd  %xmm5,%xmm7
pxor   %xmm4,%xmm4
pcmpgtd %xmm6,%xmm4
pand   %xmm6,%xmm4
paddd  %xmm3,%xmm4
movdqa 0x1a0(%rsp),%xmm3
movdqa 0x1b0(%rsp),%xmm5
pxor   %xmm6,%xmm6
pcmpgtd %xmm3,%xmm6
pand   %xmm3,%xmm6
paddd  %xmm7,%xmm6
pxor   %xmm3,%xmm3
pcmpgtd %xmm5,%xmm3
pand   %xmm5,%xmm3
paddd  %xmm4,%xmm3
movdqa 0x1c0(%rsp),%xmm4
movdqa 0x1d0(%rsp),%xmm5
pxor   %xmm7,%xmm7
pcmpgtd %xmm4,%xmm7
pand   %xmm4,%xmm7
paddd  %xmm6,%xmm7
pxor   %xmm4,%xmm4
pcmpgtd %xmm5,%xmm4
pand   %xmm5,%xmm4
paddd  %xmm3,%xmm4
movdqa 0x1e0(%rsp),%xmm3
movdqa 0x1f0(%rsp),%xmm5
pxor   %xmm6,%xmm6
pcmpgtd %xmm3,%xmm6
pand   %xmm3,%xmm6
paddd  %xmm7,%xmm6
paddd  %xmm1,%xmm6
pcmpgtd %xmm5,%xmm0
pand   %xmm5,%xmm0
paddd  %xmm4,%xmm0
paddd  %xmm2,%xmm0
paddd  %xmm6,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%esi
neg    %esi
lea    0x56b(%rip),%rdi
jmp    1abc <main+0x97c>
sub    %ebp,%ebx
lea    0x559(%rip),%rdi
mov    %ebx,%esi
call   1040 <printf@plt>
mov    0x2510(%rip),%rax
mov    (%rax),%eax
add    $0xde8,%rsp
pop    %rbx
pop    %rbp
ret

LLVM IR (-O0):
@.str = [3 x i8] c"%s\00"
@EXIT_FAILURE = global i32 0
@.str.1 = [7 x i8] c"Yes %d\00"
@.str.2 = [6 x i8] c"No %d\00"
@EXIT_SUCCESS = global i32 0
define i32 @main(i32 %0, i8** %1) {
%3 = alloca i32
%4 = alloca i32
%5 = alloca i8**
%6 = alloca [1001 x i8]
%7 = alloca [1001 x i8]
%8 = alloca i32
%9 = alloca i32
%10 = alloca [128 x i32]
%11 = alloca [128 x i32]
%12 = alloca i32
%13 = alloca i32
%14 = alloca [128 x i32]
%15 = alloca i32
%16 = alloca i32
%17 = alloca i32
%18 = alloca i32
%19 = alloca i32
store i32 0, i32* %3
store i32 %0, i32* %4
store i8** %1, i8*** %5
%20 = getelementptr inbounds [1001 x i8], [1001 x i8]* %6, i64 0, i64 0
%21 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i8* %20)
%22 = icmp ne i32 %21, 1
br i1 %22, label %23, label %25
23: ; preds = %2
%24 = load i32, i32* @EXIT_FAILURE
store i32 %24, i32* %3
br label %146
25: ; preds = %2
%26 = getelementptr inbounds [1001 x i8], [1001 x i8]* %7, i64 0, i64 0
%27 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i8* %26)
%28 = icmp ne i32 %27, 1
br i1 %28, label %29, label %31
29: ; preds = %25
%30 = load i32, i32* @EXIT_FAILURE
store i32 %30, i32* %3
br label %146
31: ; preds = %25
%32 = getelementptr inbounds [1001 x i8], [1001 x i8]* %6, i64 0, i64 0
%33 = call i32 @strlen(i8* %32)
store i32 %33, i32* %8
%34 = getelementptr inbounds [1001 x i8], [1001 x i8]* %7, i64 0, i64 0
%35 = call i32 @strlen(i8* %34)
store i32 %35, i32* %9
%36 = bitcast [128 x i32]* %10 to i8*
%37 = bitcast [128 x i32]* %11 to i8*
store i32 0, i32* %12
br label %38
38: ; preds = %52, %31
%39 = load i32, i32* %12
%40 = load i32, i32* %8
%41 = icmp slt i32 %39, %40
br i1 %41, label %42, label %55
42: ; preds = %38
%43 = load i32, i32* %12
%44 = sext i32 %43 to i64
%45 = getelementptr inbounds [1001 x i8], [1001 x i8]* %6, i64 0, i64 %44
%46 = load i8, i8* %45
%47 = sext i8 %46 to i32
%48 = sext i32 %47 to i64
%49 = getelementptr inbounds [128 x i32], [128 x i32]* %10, i64 0, i64 %48
%50 = load i32, i32* %49
%51 = add nsw i32 %50, 1
store i32 %51, i32* %49
br label %52
52: ; preds = %42
%53 = load i32, i32* %12
%54 = add nsw i32 %53, 1
store i32 %54, i32* %12
br label %38
55: ; preds = %38
store i32 0, i32* %13
br label %56
56: ; preds = %70, %55
%57 = load i32, i32* %13
%58 = load i32, i32* %9
%59 = icmp slt i32 %57, %58
br i1 %59, label %60, label %73
60: ; preds = %56
%61 = load i32, i32* %13
%62 = sext i32 %61 to i64
%63 = getelementptr inbounds [1001 x i8], [1001 x i8]* %7, i64 0, i64 %62
%64 = load i8, i8* %63
%65 = sext i8 %64 to i32
%66 = sext i32 %65 to i64
%67 = getelementptr inbounds [128 x i32], [128 x i32]* %11, i64 0, i64 %66
%68 = load i32, i32* %67
%69 = add nsw i32 %68, 1
store i32 %69, i32* %67
br label %70
70: ; preds = %60
%71 = load i32, i32* %13
%72 = add nsw i32 %71, 1
store i32 %72, i32* %13
br label %56
73: ; preds = %56
%74 = bitcast [128 x i32]* %14 to i8*
store i32 0, i32* %15
br label %75
75: ; preds = %91, %73
%76 = load i32, i32* %15
%77 = icmp slt i32 %76, 128
br i1 %77, label %78, label %94
78: ; preds = %75
%79 = load i32, i32* %15
%80 = sext i32 %79 to i64
%81 = getelementptr inbounds [128 x i32], [128 x i32]* %10, i64 0, i64 %80
%82 = load i32, i32* %81
%83 = load i32, i32* %15
%84 = sext i32 %83 to i64
%85 = getelementptr inbounds [128 x i32], [128 x i32]* %11, i64 0, i64 %84
%86 = load i32, i32* %85
%87 = sub nsw i32 %82, %86
%88 = load i32, i32* %15
%89 = sext i32 %88 to i64
%90 = getelementptr inbounds [128 x i32], [128 x i32]* %14, i64 0, i64 %89
store i32 %87, i32* %90
br label %91
91: ; preds = %78
%92 = load i32, i32* %15
%93 = add nsw i32 %92, 1
store i32 %93, i32* %15
br label %75
94: ; preds = %75
store i32 1, i32* %16
store i32 0, i32* %17
store i32 0, i32* %18
br label %95
95: ; preds = %106, %94
%96 = load i32, i32* %18
%97 = icmp slt i32 %96, 128
br i1 %97, label %98, label %109
98: ; preds = %95
%99 = load i32, i32* %18
%100 = sext i32 %99 to i64
%101 = getelementptr inbounds [128 x i32], [128 x i32]* %14, i64 0, i64 %100
%102 = load i32, i32* %101
%103 = icmp slt i32 %102, 0
br i1 %103, label %104, label %105
104: ; preds = %98
store i32 0, i32* %16
br label %105
105: ; preds = %104, %98
br label %106
106: ; preds = %105
%107 = load i32, i32* %18
%108 = add nsw i32 %107, 1
store i32 %108, i32* %18
br label %95
109: ; preds = %95
%110 = load i32, i32* %16
%111 = icmp eq i32 %110, 1
br i1 %111, label %112, label %118
112: ; preds = %109
%113 = load i32, i32* %8
%114 = load i32, i32* %9
%115 = sub nsw i32 %113, %114
store i32 %115, i32* %17
%116 = load i32, i32* %17
%117 = call i32 @printf(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), i32 %116)
br label %144
118: ; preds = %109
store i32 0, i32* %19
br label %119
119: ; preds = %136, %118
%120 = load i32, i32* %19
%121 = icmp slt i32 %120, 128
br i1 %121, label %122, label %139
122: ; preds = %119
%123 = load i32, i32* %19
%124 = sext i32 %123 to i64
%125 = getelementptr inbounds [128 x i32], [128 x i32]* %14, i64 0, i64 %124
%126 = load i32, i32* %125
%127 = icmp slt i32 %126, 0
br i1 %127, label %128, label %135
128: ; preds = %122
%129 = load i32, i32* %19
%130 = sext i32 %129 to i64
%131 = getelementptr inbounds [128 x i32], [128 x i32]* %14, i64 0, i64 %130
%132 = load i32, i32* %131
%133 = load i32, i32* %17
%134 = add nsw i32 %133, %132
store i32 %134, i32* %17
br label %135
135: ; preds = %128, %122
br label %136
136: ; preds = %135
%137 = load i32, i32* %19
%138 = add nsw i32 %137, 1
store i32 %138, i32* %19
br label %119
139: ; preds = %119
%140 = load i32, i32* %17
%141 = mul nsw i32 %140, -1
store i32 %141, i32* %17
%142 = load i32, i32* %17
%143 = call i32 @printf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.2, i64 0, i64 0), i32 %142)
br label %144
144: ; preds = %139, %112
%145 = load i32, i32* @EXIT_SUCCESS
store i32 %145, i32* %3
br label %146
146: ; preds = %144, %29, %23
%147 = load i32, i32* %3
ret i32 %147
}

LLVM IR (-O2):
@.str = [3 x i8] c"%s\00"
@EXIT_FAILURE = global i32 0
@.str.1 = [7 x i8] c"Yes %d\00"
@.str.2 = [6 x i8] c"No %d\00"
@EXIT_SUCCESS = global i32 0
define i32 @main(i32 %0, i8** nocapture readnone %1) {
%3 = alloca [1001 x i8]
%4 = alloca [1001 x i8]
%5 = alloca [128 x i32]
%6 = alloca [128 x i32]
%7 = alloca [128 x i32]
%8 = getelementptr inbounds [1001 x i8], [1001 x i8]* %3, i64 0, i64 0
%9 = getelementptr inbounds [1001 x i8], [1001 x i8]* %4, i64 0, i64 0
%10 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i8* %8)
%11 = icmp eq i32 %10, 1
br i1 %11, label %14, label %12
12: ; preds = %2
%13 = load i32, i32* @EXIT_FAILURE
br label %787
14: ; preds = %2
%15 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i8* %9)
%16 = icmp eq i32 %15, 1
br i1 %16, label %19, label %17
17: ; preds = %14
%18 = load i32, i32* @EXIT_FAILURE
br label %787
19: ; preds = %14
%20 = call i32 @strlen(i8* %8)
%21 = call i32 @strlen(i8* %9)
%22 = bitcast [128 x i32]* %5 to i8*
%23 = bitcast [128 x i32]* %6 to i8*
%24 = icmp sgt i32 %20, 0
br i1 %24, label %25, label %47
25: ; preds = %19
%26 = zext i32 %20 to i64
%27 = add nsw i64 %26, -1
%28 = and i64 %26, 3
%29 = icmp ult i64 %27, 3
br i1 %29, label %32, label %30
30: ; preds = %25
%31 = and i64 %26, 4294967292
br label %56
32: ; preds = %56, %25
%33 = phi i64 [ 0, %25 ], [ %86, %56 ]
%34 = icmp eq i64 %28, 0
br i1 %34, label %47, label %35
35: ; preds = %32, %35
%36 = phi i64 [ %44, %35 ], [ %33, %32 ]
%37 = phi i64 [ %45, %35 ], [ 0, %32 ]
%38 = getelementptr inbounds [1001 x i8], [1001 x i8]* %3, i64 0, i64 %36
%39 = load i8, i8* %38
%40 = sext i8 %39 to i64
%41 = getelementptr inbounds [128 x i32], [128 x i32]* %5, i64 0, i64 %40
%42 = load i32, i32* %41
%43 = add nsw i32 %42, 1
store i32 %43, i32* %41
%44 = add nuw nsw i64 %36, 1
%45 = add i64 %37, 1
%46 = icmp eq i64 %45, %28
br i1 %46, label %47, label %35
47: ; preds = %32, %35, %19
%48 = icmp sgt i32 %21, 0
br i1 %48, label %49, label %104
49: ; preds = %47
%50 = zext i32 %21 to i64
%51 = add nsw i64 %50, -1
%52 = and i64 %50, 3
%53 = icmp ult i64 %51, 3
br i1 %53, label %89, label %54
54: ; preds = %49
%55 = and i64 %50, 4294967292
br label %555
56: ; preds = %56, %30
%57 = phi i64 [ 0, %30 ], [ %86, %56 ]
%58 = phi i64 [ 0, %30 ], [ %87, %56 ]
%59 = getelementptr inbounds [1001 x i8], [1001 x i8]* %3, i64 0, i64 %57
%60 = load i8, i8* %59
%61 = sext i8 %60 to i64
%62 = getelementptr inbounds [128 x i32], [128 x i32]* %5, i64 0, i64 %61
%63 = load i32, i32* %62
%64 = add nsw i32 %63, 1
store i32 %64, i32* %62
%65 = or i64 %57, 1
%66 = getelementptr inbounds [1001 x i8], [1001 x i8]* %3, i64 0, i64 %65
%67 = load i8, i8* %66
%68 = sext i8 %67 to i64
%69 = getelementptr inbounds [128 x i32], [128 x i32]* %5, i64 0, i64 %68
%70 = load i32, i32* %69
%71 = add nsw i32 %70, 1
store i32 %71, i32* %69
%72 = or i64 %57, 2
%73 = getelementptr inbounds [1001 x i8], [1001 x i8]* %3, i64 0, i64 %72
%74 = load i8, i8* %73
%75 = sext i8 %74 to i64
%76 = getelementptr inbounds [128 x i32], [128 x i32]* %5, i64 0, i64 %75
%77 = load i32, i32* %76
%78 = add nsw i32 %77, 1
store i32 %78, i32* %76
%79 = or i64 %57, 3
%80 = getelementptr inbounds [1001 x i8], [1001 x i8]* %3, i64 0, i64 %79
%81 = load i8, i8* %80
%82 = sext i8 %81 to i64
%83 = getelementptr inbounds [128 x i32], [128 x i32]* %5, i64 0, i64 %82
%84 = load i32, i32* %83
%85 = add nsw i32 %84, 1
store i32 %85, i32* %83
%86 = add nuw nsw i64 %57, 4
%87 = add i64 %58, 4
%88 = icmp eq i64 %87, %31
br i1 %88, label %32, label %56
89: ; preds = %555, %49
%90 = phi i64 [ 0, %49 ], [ %585, %555 ]
%91 = icmp eq i64 %52, 0
br i1 %91, label %104, label %92
92: ; preds = %89, %92
%93 = phi i64 [ %101, %92 ], [ %90, %89 ]
%94 = phi i64 [ %102, %92 ], [ 0, %89 ]
%95 = getelementptr inbounds [1001 x i8], [1001 x i8]* %4, i64 0, i64 %93
%96 = load i8, i8* %95
%97 = sext i8 %96 to i64
%98 = getelementptr inbounds [128 x i32], [128 x i32]* %6, i64 0, i64 %97
%99 = load i32, i32* %98
%100 = add nsw i32 %99, 1
store i32 %100, i32* %98
%101 = add nuw nsw i64 %93, 1
%102 = add i64 %94, 1
%103 = icmp eq i64 %102, %52
br i1 %103, label %104, label %92
104: ; preds = %89, %92, %47
%105 = bitcast [128 x i32]* %7 to i8*
%106 = bitcast [128 x i32]* %5 to <4 x i32>*
%107 = load <4 x i32>, <4 x i32>* %106
%108 = getelementptr inbounds [128 x i32], [128 x i32]* %5, i64 0, i64 4
%109 = bitcast i32* %108 to <4 x i32>*
%110 = load <4 x i32>, <4 x i32>* %109
%111 = bitcast [128 x i32]* %6 to <4 x i32>*
%112 = load <4 x i32>, <4 x i32>* %111
%113 = getelementptr inbounds [128 x i32], [128 x i32]* %6, i64 0, i64 4
%114 = bitcast i32* %113 to <4 x i32>*
%115 = load <4 x i32>, <4 x i32>* %114
%116 = sub nsw <4 x i32> %107, %112
%117 = sub nsw <4 x i32> %110, %115
%118 = bitcast [128 x i32]* %7 to <4 x i32>*
store <4 x i32> %116, <4 x i32>* %118
%119 = getelementptr inbounds [128 x i32], [128 x i32]* %7, i64 0, i64 4
%120 = bitcast i32* %119 to <4 x i32>*
store <4 x i32> %117, <4 x i32>* %120
%121 = getelementptr inbounds [128 x i32], [128 x i32]* %5, i64 0, i64 8
%122 = bitcast i32* %121 to <4 x i32>*
%123 = load <4 x i32>, <4 x i32>* %122
%124 = getelementptr inbounds [128 x i32], [128 x i32]* %5, i64 0, i64 12
%125 = bitcast i32* %124 to <4 x i32>*
%126 = load <4 x i32>, <4 x i32>* %125
%127 = getelementptr inbounds [128 x i32], [128 x i32]* %6, i64 0, i64 8
%128 = bitcast i32* %127 to <4 x i32>*
%129 = load <4 x i32>, <4 x i32>* %128
%130 = getelementptr inbounds [128 x i32], [128 x i32]* %6, i64 0, i64 12
%131 = bitcast i32* %130 to <4 x i32>*
%132 = load <4 x i32>, <4 x i32>* %131
%133 = sub nsw <4 x i32> %123, %129
%134 = sub nsw <4 x i32> %126, %132
%135 = getelementptr inbounds [128 x i32], [128 x i32]* %7, i64 0, i64 8
%136 = bitcast i32* %135 to <4 x i32>*
store <4 x i32> %133, <4 x i32>* %136
%137 = getelementptr inbounds [128 x i32], [128 x i32]* %7, i64 0, i64 12
%138 = bitcast i32* %137 to <4 x i32>*
store <4 x i32> %134, <4 x i32>* %138
%139 = getelementptr inbounds [128 x i32], [128 x i32]* %5, i64 0, i64 16
%140 = bitcast i32* %139 to <4 x i32>*
%141 = load <4 x i32>, <4 x i32>* %140
%142 = getelementptr inbounds [128 x i32], [128 x i32]* %5, i64 0, i64 20
%143 = bitcast i32* %142 to <4 x i32>*
%144 = load <4 x i32>, <4 x i32>* %143
%145 = getelementptr inbounds [128 x i32], [128 x i32]* %6, i64 0, i64 16
%146 = bitcast i32* %145 to <4 x i32>*
%147 = load <4 x i32>, <4 x i32>* %146
%148 = getelementptr inbounds [128 x i32], [128 x i32]* %6, i64 0, i64 20
%149 = bitcast i32* %148 to <4 x i32>*
%150 = load <4 x i32>, <4 x i32>* %149
%151 = sub nsw <4 x i32> %141, %147
%152 = sub nsw <4 x i32> %144, %150
%153 = getelementptr inbounds [128 x i32], [128 x i32]* %7, i64 0, i64 16
%154 = bitcast i32* %153 to <4 x i32>*
store <4 x i32> %151, <4 x i32>* %154
%155 = getelementptr inbounds [128 x i32], [128 x i32]* %7, i64 0, i64 20
%156 = bitcast i32* %155 to <4 x i32>*
store <4 x i32> %152, <4 x i32>* %156
%157 = getelementptr inbounds [128 x i32], [128 x i32]* %5, i64 0, i64 24
%158 = bitcast i32* %157 to <4 x i32>*
%159 = load <4 x i32>, <4 x i32>* %158
%160 = getelementptr inbounds [128 x i32], [128 x i32]* %5, i64 0, i64 28
%161 = bitcast i32* %160 to <4 x i32>*
%162 = load <4 x i32>, <4 x i32>* %161
%163 = getelementptr inbounds [128 x i32], [128 x i32]* %6, i64 0, i64 24
%164 = bitcast i32* %163 to <4 x i32>*
%165 = load <4 x i32>, <4 x i32>* %164
%166 = getelementptr inbounds [128 x i32], [128 x i32]* %6, i64 0, i64 28
%167 = bitcast i32* %166 to <4 x i32>*
%168 = load <4 x i32>, <4 x i32>* %167
%169 = sub nsw <4 x i32> %159, %165
%170 = sub nsw <4 x i32> %162, %168
%171 = getelementptr inbounds [128 x i32], [128 x i32]* %7, i64 0, i64 24
%172 = bitcast i32* %171 to <4 x i32>*
store <4 x i32> %169, <4 x i32>* %172
%173 = getelementptr inbounds [128 x i32], [128 x i32]* %7, i64 0, i64 28
%174 = bitcast i32* %173 to <4 x i32>*
store <4 x i32> %170, <4 x i32>* %174
%175 = getelementptr inbounds [128 x i32], [128 x i32]* %5, i64 0, i64 32
%176 = bitcast i32* %175 to <4 x i32>*
%177 = load <4 x i32>, <4 x i32>* %176
%178 = getelementptr inbounds [128 x i32], [128 x i32]* %5, i64 0, i64 36
%179 = bitcast i32* %178 to <4 x i32>*
%180 = load <4 x i32>, <4 x i32>* %179
%181 = getelementptr inbounds [128 x i32], [128 x i32]* %6, i64 0, i64 32
%182 = bitcast i32* %181 to <4 x i32>*
%183 = load <4 x i32>, <4 x i32>* %182
%184 = getelementptr inbounds [128 x i32], [128 x i32]* %6, i64 0, i64 36
%185 = bitcast i32* %184 to <4 x i32>*
%186 = load <4 x i32>, <4 x i32>* %185
%187 = sub nsw <4 x i32> %177, %183
%188 = sub nsw <4 x i32> %180, %186
%189 = getelementptr inbounds [128 x i32], [128 x i32]* %7, i64 0, i64 32
%190 = bitcast i32* %189 to <4 x i32>*
store <4 x i32> %187, <4 x i32>* %190
%191 = getelementptr inbounds [128 x i32], [128 x i32]* %7, i64 0, i64 36
%192 = bitcast i32* %191 to <4 x i32>*
store <4 x i32> %188, <4 x i32>* %192
%193 = getelementptr inbounds [128 x i32], [128 x i32]* %5, i64 0, i64 40
%194 = bitcast i32* %193 to <4 x i32>*
%195 = load <4 x i32>, <4 x i32>* %194
%196 = getelementptr inbounds [128 x i32], [128 x i32]* %5, i64 0, i64 44
%197 = bitcast i32* %196 to <4 x i32>*
%198 = load <4 x i32>, <4 x i32>* %197
%199 = getelementptr inbounds [128 x i32], [128 x i32]* %6, i64 0, i64 40
%200 = bitcast i32* %199 to <4 x i32>*
%201 = load <4 x i32>, <4 x i32>* %200
%202 = getelementptr inbounds [128 x i32], [128 x i32]* %6, i64 0, i64 44
%203 = bitcast i32* %202 to <4 x i32>*
%204 = load <4 x i32>, <4 x i32>* %203
%205 = sub nsw <4 x i32> %195, %201
%206 = sub nsw <4 x i32> %198, %204
%207 = getelementptr inbounds [128 x i32], [128 x i32]* %7, i64 0, i64 40
%208 = bitcast i32* %207 to <4 x i32>*
store <4 x i32> %205, <4 x i32>* %208
%209 = getelementptr inbounds [128 x i32], [128 x i32]* %7, i64 0, i64 44
%210 = bitcast i32* %209 to <4 x i32>*
store <4 x i32> %206, <4 x i32>* %210
%211 = getelementptr inbounds [128 x i32], [128 x i32]* %5, i64 0, i64 48
%212 = bitcast i32* %211 to <4 x i32>*
%213 = load <4 x i32>, <4 x i32>* %212
%214 = getelementptr inbounds [128 x i32], [128 x i32]* %5, i64 0, i64 52
%215 = bitcast i32* %214 to <4 x i32>*
%216 = load <4 x i32>, <4 x i32>* %215
%217 = getelementptr inbounds [128 x i32], [128 x i32]* %6, i64 0, i64 48
%218 = bitcast i32* %217 to <4 x i32>*
%219 = load <4 x i32>, <4 x i32>* %218
%220 = getelementptr inbounds [128 x i32], [128 x i32]* %6, i64 0, i64 52
%221 = bitcast i32* %220 to <4 x i32>*
%222 = load <4 x i32>, <4 x i32>* %221
%223 = sub nsw <4 x i32> %213, %219
%224 = sub nsw <4 x i32> %216, %222
%225 = getelementptr inbounds [128 x i32], [128 x i32]* %7, i64 0, i64 48
%226 = bitcast i32* %225 to <4 x i32>*
store <4 x i32> %223, <4 x i32>* %226
%227 = getelementptr inbounds [128 x i32], [128 x i32]* %7, i64 0, i64 52
%228 = bitcast i32* %227 to <4 x i32>*
store <4 x i32> %224, <4 x i32>* %228
%229 = getelementptr inbounds [128 x i32], [128 x i32]* %5, i64 0, i64 56
%230 = bitcast i32* %229 to <4 x i32>*
%231 = load <4 x i32>, <4 x i32>* %230
%232 = getelementptr inbounds [128 x i32], [128 x i32]* %5, i64 0, i64 60
%233 = bitcast i32* %232 to <4 x i32>*
%234 = load <4 x i32>, <4 x i32>* %233
%235 = getelementptr inbounds [128 x i32], [128 x i32]* %6, i64 0, i64 56
%236 = bitcast i32* %235 to <4 x i32>*
%237 = load <4 x i32>, <4 x i32>* %236
%238 = getelementptr inbounds [128 x i32], [128 x i32]* %6, i64 0, i64 60
%239 = bitcast i32* %238 to <4 x i32>*
%240 = load <4 x i32>, <4 x i32>* %239
%241 = sub nsw <4 x i32> %231, %237
%242 = sub nsw <4 x i32> %234, %240
%243 = getelementptr inbounds [128 x i32], [128 x i32]* %7, i64 0, i64 56
%244 = bitcast i32* %243 to <4 x i32>*
store <4 x i32> %241, <4 x i32>* %244
%245 = getelementptr inbounds [128 x i32], [128 x i32]* %7, i64 0, i64 60
%246 = bitcast i32* %245 to <4 x i32>*
store <4 x i32> %242, <4 x i32>* %246
%247 = getelementptr inbounds [128 x i32], [128 x i32]* %5, i64 0, i64 64
%248 = bitcast i32* %247 to <4 x i32>*
%249 = load <4 x i32>, <4 x i32>* %248
%250 = getelementptr inbounds [128 x i32], [128 x i32]* %5, i64 0, i64 68
%251 = bitcast i32* %250 to <4 x i32>*
%252 = load <4 x i32>, <4 x i32>* %251
%253 = getelementptr inbounds [128 x i32], [128 x i32]* %6, i64 0, i64 64
%254 = bitcast i32* %253 to <4 x i32>*
%255 = load <4 x i32>, <4 x i32>* %254
%256 = getelementptr inbounds [128 x i32], [128 x i32]* %6, i64 0, i64 68
%257 = bitcast i32* %256 to <4 x i32>*
%258 = load <4 x i32>, <4 x i32>* %257
%259 = sub nsw <4 x i32> %249, %255
%260 = sub nsw <4 x i32> %252, %258
%261 = getelementptr inbounds [128 x i32], [128 x i32]* %7, i64 0, i64 64
%262 = bitcast i32* %261 to <4 x i32>*
store <4 x i32> %259, <4 x i32>* %262
%263 = getelementptr inbounds [128 x i32], [128 x i32]* %7, i64 0, i64 68
%264 = bitcast i32* %263 to <4 x i32>*
store <4 x i32> %260, <4 x i32>* %264
%265 = getelementptr inbounds [128 x i32], [128 x i32]* %5, i64 0, i64 72
%266 = bitcast i32* %265 to <4 x i32>*
%267 = load <4 x i32>, <4 x i32>* %266
%268 = getelementptr inbounds [128 x i32], [128 x i32]* %5, i64 0, i64 76
%269 = bitcast i32* %268 to <4 x i32>*
%270 = load <4 x i32>, <4 x i32>* %269
%271 = getelementptr inbounds [128 x i32], [128 x i32]* %6, i64 0, i64 72
%272 = bitcast i32* %271 to <4 x i32>*
%273 = load <4 x i32>, <4 x i32>* %272
%274 = getelementptr inbounds [128 x i32], [128 x i32]* %6, i64 0, i64 76
%275 = bitcast i32* %274 to <4 x i32>*
%276 = load <4 x i32>, <4 x i32>* %275
%277 = sub nsw <4 x i32> %267, %273
%278 = sub nsw <4 x i32> %270, %276
%279 = getelementptr inbounds [128 x i32], [128 x i32]* %7, i64 0, i64 72
%280 = bitcast i32* %279 to <4 x i32>*
store <4 x i32> %277, <4 x i32>* %280
%281 = getelementptr inbounds [128 x i32], [128 x i32]* %7, i64 0, i64 76
%282 = bitcast i32* %281 to <4 x i32>*
store <4 x i32> %278, <4 x i32>* %282
%283 = getelementptr inbounds [128 x i32], [128 x i32]* %5, i64 0, i64 80
%284 = bitcast i32* %283 to <4 x i32>*
%285 = load <4 x i32>, <4 x i32>* %284
%286 = getelementptr inbounds [128 x i32], [128 x i32]* %5, i64 0, i64 84
%287 = bitcast i32* %286 to <4 x i32>*
%288 = load <4 x i32>, <4 x i32>* %287
%289 = getelementptr inbounds [128 x i32], [128 x i32]* %6, i64 0, i64 80
%290 = bitcast i32* %289 to <4 x i32>*
%291 = load <4 x i32>, <4 x i32>* %290
%292 = getelementptr inbounds [128 x i32], [128 x i32]* %6, i64 0, i64 84
%293 = bitcast i32* %292 to <4 x i32>*
%294 = load <4 x i32>, <4 x i32>* %293
%295 = sub nsw <4 x i32> %285, %291
%296 = sub nsw <4 x i32> %288, %294
%297 = getelementptr inbounds [128 x i32], [128 x i32]* %7, i64 0, i64 80
%298 = bitcast i32* %297 to <4 x i32>*
store <4 x i32> %295, <4 x i32>* %298
%299 = getelementptr inbounds [128 x i32], [128 x i32]* %7, i64 0, i64 84
%300 = bitcast i32* %299 to <4 x i32>*
store <4 x i32> %296, <4 x i32>* %300
%301 = getelementptr inbounds [128 x i32], [128 x i32]* %5, i64 0, i64 88
%302 = bitcast i32* %301 to <4 x i32>*
%303 = load <4 x i32>, <4 x i32>* %302
%304 = getelementptr inbounds [128 x i32], [128 x i32]* %5, i64 0, i64 92
%305 = bitcast i32* %304 to <4 x i32>*
%306 = load <4 x i32>, <4 x i32>* %305
%307 = getelementptr inbounds [128 x i32], [128 x i32]* %6, i64 0, i64 88
%308 = bitcast i32* %307 to <4 x i32>*
%309 = load <4 x i32>, <4 x i32>* %308
%310 = getelementptr inbounds [128 x i32], [128 x i32]* %6, i64 0, i64 92
%311 = bitcast i32* %310 to <4 x i32>*
%312 = load <4 x i32>, <4 x i32>* %311
%313 = sub nsw <4 x i32> %303, %309
%314 = sub nsw <4 x i32> %306, %312
%315 = getelementptr inbounds [128 x i32], [128 x i32]* %7, i64 0, i64 88
%316 = bitcast i32* %315 to <4 x i32>*
store <4 x i32> %313, <4 x i32>* %316
%317 = getelementptr inbounds [128 x i32], [128 x i32]* %7, i64 0, i64 92
%318 = bitcast i32* %317 to <4 x i32>*
store <4 x i32> %314, <4 x i32>* %318
%319 = getelementptr inbounds [128 x i32], [128 x i32]* %5, i64 0, i64 96
%320 = bitcast i32* %319 to <4 x i32>*
%321 = load <4 x i32>, <4 x i32>* %320
%322 = getelementptr inbounds [128 x i32], [128 x i32]* %5, i64 0, i64 100
%323 = bitcast i32* %322 to <4 x i32>*
%324 = load <4 x i32>, <4 x i32>* %323
%325 = getelementptr inbounds [128 x i32], [128 x i32]* %6, i64 0, i64 96
%326 = bitcast i32* %325 to <4 x i32>*
%327 = load <4 x i32>, <4 x i32>* %326
%328 = getelementptr inbounds [128 x i32], [128 x i32]* %6, i64 0, i64 100
%329 = bitcast i32* %328 to <4 x i32>*
%330 = load <4 x i32>, <4 x i32>* %329
%331 = sub nsw <4 x i32> %321, %327
%332 = sub nsw <4 x i32> %324, %330
%333 = getelementptr inbounds [128 x i32], [128 x i32]* %7, i64 0, i64 96
%334 = bitcast i32* %333 to <4 x i32>*
store <4 x i32> %331, <4 x i32>* %334
%335 = getelementptr inbounds [128 x i32], [128 x i32]* %7, i64 0, i64 100
%336 = bitcast i32* %335 to <4 x i32>*
store <4 x i32> %332, <4 x i32>* %336
%337 = getelementptr inbounds [128 x i32], [128 x i32]* %5, i64 0, i64 104
%338 = bitcast i32* %337 to <4 x i32>*
%339 = load <4 x i32>, <4 x i32>* %338
%340 = getelementptr inbounds [128 x i32], [128 x i32]* %5, i64 0, i64 108
%341 = bitcast i32* %340 to <4 x i32>*
%342 = load <4 x i32>, <4 x i32>* %341
%343 = getelementptr inbounds [128 x i32], [128 x i32]* %6, i64 0, i64 104
%344 = bitcast i32* %343 to <4 x i32>*
%345 = load <4 x i32>, <4 x i32>* %344
%346 = getelementptr inbounds [128 x i32], [128 x i32]* %6, i64 0, i64 108
%347 = bitcast i32* %346 to <4 x i32>*
%348 = load <4 x i32>, <4 x i32>* %347
%349 = sub nsw <4 x i32> %339, %345
%350 = sub nsw <4 x i32> %342, %348
%351 = getelementptr inbounds [128 x i32], [128 x i32]* %7, i64 0, i64 104
%352 = bitcast i32* %351 to <4 x i32>*
store <4 x i32> %349, <4 x i32>* %352
%353 = getelementptr inbounds [128 x i32], [128 x i32]* %7, i64 0, i64 108
%354 = bitcast i32* %353 to <4 x i32>*
store <4 x i32> %350, <4 x i32>* %354
%355 = getelementptr inbounds [128 x i32], [128 x i32]* %5, i64 0, i64 112
%356 = bitcast i32* %355 to <4 x i32>*
%357 = load <4 x i32>, <4 x i32>* %356
%358 = getelementptr inbounds [128 x i32], [128 x i32]* %5, i64 0, i64 116
%359 = bitcast i32* %358 to <4 x i32>*
%360 = load <4 x i32>, <4 x i32>* %359
%361 = getelementptr inbounds [128 x i32], [128 x i32]* %6, i64 0, i64 112
%362 = bitcast i32* %361 to <4 x i32>*
%363 = load <4 x i32>, <4 x i32>* %362
%364 = getelementptr inbounds [128 x i32], [128 x i32]* %6, i64 0, i64 116
%365 = bitcast i32* %364 to <4 x i32>*
%366 = load <4 x i32>, <4 x i32>* %365
%367 = sub nsw <4 x i32> %357, %363
%368 = sub nsw <4 x i32> %360, %366
%369 = getelementptr inbounds [128 x i32], [128 x i32]* %7, i64 0, i64 112
%370 = bitcast i32* %369 to <4 x i32>*
store <4 x i32> %367, <4 x i32>* %370
%371 = getelementptr inbounds [128 x i32], [128 x i32]* %7, i64 0, i64 116
%372 = bitcast i32* %371 to <4 x i32>*
store <4 x i32> %368, <4 x i32>* %372
%373 = getelementptr inbounds [128 x i32], [128 x i32]* %5, i64 0, i64 120
%374 = bitcast i32* %373 to <4 x i32>*
%375 = load <4 x i32>, <4 x i32>* %374
%376 = getelementptr inbounds [128 x i32], [128 x i32]* %5, i64 0, i64 124
%377 = bitcast i32* %376 to <4 x i32>*
%378 = load <4 x i32>, <4 x i32>* %377
%379 = getelementptr inbounds [128 x i32], [128 x i32]* %6, i64 0, i64 120
%380 = bitcast i32* %379 to <4 x i32>*
%381 = load <4 x i32>, <4 x i32>* %380
%382 = getelementptr inbounds [128 x i32], [128 x i32]* %6, i64 0, i64 124
%383 = bitcast i32* %382 to <4 x i32>*
%384 = load <4 x i32>, <4 x i32>* %383
%385 = sub nsw <4 x i32> %375, %381
%386 = sub nsw <4 x i32> %378, %384
%387 = getelementptr inbounds [128 x i32], [128 x i32]* %7, i64 0, i64 120
%388 = bitcast i32* %387 to <4 x i32>*
store <4 x i32> %385, <4 x i32>* %388
%389 = getelementptr inbounds [128 x i32], [128 x i32]* %7, i64 0, i64 124
%390 = bitcast i32* %389 to <4 x i32>*
store <4 x i32> %386, <4 x i32>* %390
%391 = bitcast [128 x i32]* %7 to <4 x i32>*
%392 = load <4 x i32>, <4 x i32>* %391
%393 = getelementptr inbounds [128 x i32], [128 x i32]* %7, i64 0, i64 4
%394 = bitcast i32* %393 to <4 x i32>*
%395 = load <4 x i32>, <4 x i32>* %394
%396 = xor <4 x i32> %392, <i32 -1, i32 -1, i32 -1, i32 -1>
%397 = lshr <4 x i32> %396, <i32 31, i32 31, i32 31, i32 31>
%398 = xor <4 x i32> %395, <i32 -1, i32 -1, i32 -1, i32 -1>
%399 = lshr <4 x i32> %398, <i32 31, i32 31, i32 31, i32 31>
%400 = getelementptr inbounds [128 x i32], [128 x i32]* %7, i64 0, i64 8
%401 = bitcast i32* %400 to <4 x i32>*
%402 = load <4 x i32>, <4 x i32>* %401
%403 = getelementptr inbounds [128 x i32], [128 x i32]* %7, i64 0, i64 12
%404 = bitcast i32* %403 to <4 x i32>*
%405 = load <4 x i32>, <4 x i32>* %404
%406 = icmp slt <4 x i32> %402, zeroinitializer
%407 = icmp slt <4 x i32> %405, zeroinitializer
%408 = getelementptr inbounds [128 x i32], [128 x i32]* %7, i64 0, i64 16
%409 = bitcast i32* %408 to <4 x i32>*
%410 = load <4 x i32>, <4 x i32>* %409
%411 = getelementptr inbounds [128 x i32], [128 x i32]* %7, i64 0, i64 20
%412 = bitcast i32* %411 to <4 x i32>*
%413 = load <4 x i32>, <4 x i32>* %412
%414 = icmp slt <4 x i32> %410, zeroinitializer
%415 = icmp slt <4 x i32> %413, zeroinitializer
%416 = getelementptr inbounds [128 x i32], [128 x i32]* %7, i64 0, i64 24
%417 = bitcast i32* %416 to <4 x i32>*
%418 = load <4 x i32>, <4 x i32>* %417
%419 = getelementptr inbounds [128 x i32], [128 x i32]* %7, i64 0, i64 28
%420 = bitcast i32* %419 to <4 x i32>*
%421 = load <4 x i32>, <4 x i32>* %420
%422 = icmp slt <4 x i32> %418, zeroinitializer
%423 = icmp slt <4 x i32> %421, zeroinitializer
%424 = getelementptr inbounds [128 x i32], [128 x i32]* %7, i64 0, i64 32
%425 = bitcast i32* %424 to <4 x i32>*
%426 = load <4 x i32>, <4 x i32>* %425
%427 = getelementptr inbounds [128 x i32], [128 x i32]* %7, i64 0, i64 36
%428 = bitcast i32* %427 to <4 x i32>*
%429 = load <4 x i32>, <4 x i32>* %428
%430 = icmp slt <4 x i32> %426, zeroinitializer
%431 = icmp slt <4 x i32> %429, zeroinitializer
%432 = getelementptr inbounds [128 x i32], [128 x i32]* %7, i64 0, i64 40
%433 = bitcast i32* %432 to <4 x i32>*
%434 = load <4 x i32>, <4 x i32>* %433
%435 = getelementptr inbounds [128 x i32], [128 x i32]* %7, i64 0, i64 44
%436 = bitcast i32* %435 to <4 x i32>*
%437 = load <4 x i32>, <4 x i32>* %436
%438 = icmp slt <4 x i32> %434, zeroinitializer
%439 = icmp slt <4 x i32> %437, zeroinitializer
%440 = getelementptr inbounds [128 x i32], [128 x i32]* %7, i64 0, i64 48
%441 = bitcast i32* %440 to <4 x i32>*
%442 = load <4 x i32>, <4 x i32>* %441
%443 = getelementptr inbounds [128 x i32], [128 x i32]* %7, i64 0, i64 52
%444 = bitcast i32* %443 to <4 x i32>*
%445 = load <4 x i32>, <4 x i32>* %444
%446 = icmp slt <4 x i32> %442, zeroinitializer
%447 = icmp slt <4 x i32> %445, zeroinitializer
%448 = getelementptr inbounds [128 x i32], [128 x i32]* %7, i64 0, i64 56
%449 = bitcast i32* %448 to <4 x i32>*
%450 = load <4 x i32>, <4 x i32>* %449
%451 = getelementptr inbounds [128 x i32], [128 x i32]* %7, i64 0, i64 60
%452 = bitcast i32* %451 to <4 x i32>*
%453 = load <4 x i32>, <4 x i32>* %452
%454 = icmp slt <4 x i32> %450, zeroinitializer
%455 = icmp slt <4 x i32> %453, zeroinitializer
%456 = getelementptr inbounds [128 x i32], [128 x i32]* %7, i64 0, i64 64
%457 = bitcast i32* %456 to <4 x i32>*
%458 = load <4 x i32>, <4 x i32>* %457
%459 = getelementptr inbounds [128 x i32], [128 x i32]* %7, i64 0, i64 68
%460 = bitcast i32* %459 to <4 x i32>*
%461 = load <4 x i32>, <4 x i32>* %460
%462 = icmp slt <4 x i32> %458, zeroinitializer
%463 = icmp slt <4 x i32> %461, zeroinitializer
%464 = getelementptr inbounds [128 x i32], [128 x i32]* %7, i64 0, i64 72
%465 = bitcast i32* %464 to <4 x i32>*
%466 = load <4 x i32>, <4 x i32>* %465
%467 = getelementptr inbounds [128 x i32], [128 x i32]* %7, i64 0, i64 76
%468 = bitcast i32* %467 to <4 x i32>*
%469 = load <4 x i32>, <4 x i32>* %468
%470 = icmp slt <4 x i32> %466, zeroinitializer
%471 = icmp slt <4 x i32> %469, zeroinitializer
%472 = getelementptr inbounds [128 x i32], [128 x i32]* %7, i64 0, i64 80
%473 = bitcast i32* %472 to <4 x i32>*
%474 = load <4 x i32>, <4 x i32>* %473
%475 = getelementptr inbounds [128 x i32], [128 x i32]* %7, i64 0, i64 84
%476 = bitcast i32* %475 to <4 x i32>*
%477 = load <4 x i32>, <4 x i32>* %476
%478 = icmp slt <4 x i32> %474, zeroinitializer
%479 = icmp slt <4 x i32> %477, zeroinitializer
%480 = getelementptr inbounds [128 x i32], [128 x i32]* %7, i64 0, i64 88
%481 = bitcast i32* %480 to <4 x i32>*
%482 = load <4 x i32>, <4 x i32>* %481
%483 = getelementptr inbounds [128 x i32], [128 x i32]* %7, i64 0, i64 92
%484 = bitcast i32* %483 to <4 x i32>*
%485 = load <4 x i32>, <4 x i32>* %484
%486 = icmp slt <4 x i32> %482, zeroinitializer
%487 = icmp slt <4 x i32> %485, zeroinitializer
%488 = getelementptr inbounds [128 x i32], [128 x i32]* %7, i64 0, i64 96
%489 = bitcast i32* %488 to <4 x i32>*
%490 = load <4 x i32>, <4 x i32>* %489
%491 = getelementptr inbounds [128 x i32], [128 x i32]* %7, i64 0, i64 100
%492 = bitcast i32* %491 to <4 x i32>*
%493 = load <4 x i32>, <4 x i32>* %492
%494 = icmp slt <4 x i32> %490, zeroinitializer
%495 = icmp slt <4 x i32> %493, zeroinitializer
%496 = getelementptr inbounds [128 x i32], [128 x i32]* %7, i64 0, i64 104
%497 = bitcast i32* %496 to <4 x i32>*
%498 = load <4 x i32>, <4 x i32>* %497
%499 = getelementptr inbounds [128 x i32], [128 x i32]* %7, i64 0, i64 108
%500 = bitcast i32* %499 to <4 x i32>*
%501 = load <4 x i32>, <4 x i32>* %500
%502 = icmp slt <4 x i32> %498, zeroinitializer
%503 = icmp slt <4 x i32> %501, zeroinitializer
%504 = getelementptr inbounds [128 x i32], [128 x i32]* %7, i64 0, i64 112
%505 = bitcast i32* %504 to <4 x i32>*
%506 = load <4 x i32>, <4 x i32>* %505
%507 = getelementptr inbounds [128 x i32], [128 x i32]* %7, i64 0, i64 116
%508 = bitcast i32* %507 to <4 x i32>*
%509 = load <4 x i32>, <4 x i32>* %508
%510 = icmp slt <4 x i32> %506, zeroinitializer
%511 = icmp slt <4 x i32> %509, zeroinitializer
%512 = getelementptr inbounds [128 x i32], [128 x i32]* %7, i64 0, i64 120
%513 = bitcast i32* %512 to <4 x i32>*
%514 = load <4 x i32>, <4 x i32>* %513
%515 = getelementptr inbounds [128 x i32], [128 x i32]* %7, i64 0, i64 124
%516 = bitcast i32* %515 to <4 x i32>*
%517 = load <4 x i32>, <4 x i32>* %516
%518 = icmp slt <4 x i32> %514, zeroinitializer
%519 = icmp slt <4 x i32> %517, zeroinitializer
%520 = select <4 x i1> %518, <4 x i1> <i1 true, i1 true, i1 true, i1 true>, <4 x i1> %510
%521 = select <4 x i1> %520, <4 x i1> <i1 true, i1 true, i1 true, i1 true>, <4 x i1> %502
%522 = select <4 x i1> %521, <4 x i1> <i1 true, i1 true, i1 true, i1 true>, <4 x i1> %494
%523 = select <4 x i1> %522, <4 x i1> <i1 true, i1 true, i1 true, i1 true>, <4 x i1> %486
%524 = select <4 x i1> %523, <4 x i1> <i1 true, i1 true, i1 true, i1 true>, <4 x i1> %478
%525 = select <4 x i1> %524, <4 x i1> <i1 true, i1 true, i1 true, i1 true>, <4 x i1> %470
%526 = select <4 x i1> %525, <4 x i1> <i1 true, i1 true, i1 true, i1 true>, <4 x i1> %462
%527 = select <4 x i1> %526, <4 x i1> <i1 true, i1 true, i1 true, i1 true>, <4 x i1> %454
%528 = select <4 x i1> %527, <4 x i1> <i1 true, i1 true, i1 true, i1 true>, <4 x i1> %446
%529 = select <4 x i1> %528, <4 x i1> <i1 true, i1 true, i1 true, i1 true>, <4 x i1> %438
%530 = select <4 x i1> %529, <4 x i1> <i1 true, i1 true, i1 true, i1 true>, <4 x i1> %430
%531 = select <4 x i1> %530, <4 x i1> <i1 true, i1 true, i1 true, i1 true>, <4 x i1> %422
%532 = select <4 x i1> %531, <4 x i1> <i1 true, i1 true, i1 true, i1 true>, <4 x i1> %414
%533 = select <4 x i1> %532, <4 x i1> <i1 true, i1 true, i1 true, i1 true>, <4 x i1> %406
%534 = select <4 x i1> %533, <4 x i32> zeroinitializer, <4 x i32> %397
%535 = select <4 x i1> %519, <4 x i1> <i1 true, i1 true, i1 true, i1 true>, <4 x i1> %511
%536 = select <4 x i1> %535, <4 x i1> <i1 true, i1 true, i1 true, i1 true>, <4 x i1> %503
%537 = select <4 x i1> %536, <4 x i1> <i1 true, i1 true, i1 true, i1 true>, <4 x i1> %495
%538 = select <4 x i1> %537, <4 x i1> <i1 true, i1 true, i1 true, i1 true>, <4 x i1> %487
%539 = select <4 x i1> %538, <4 x i1> <i1 true, i1 true, i1 true, i1 true>, <4 x i1> %479
%540 = select <4 x i1> %539, <4 x i1> <i1 true, i1 true, i1 true, i1 true>, <4 x i1> %471
%541 = select <4 x i1> %540, <4 x i1> <i1 true, i1 true, i1 true, i1 true>, <4 x i1> %463
%542 = select <4 x i1> %541, <4 x i1> <i1 true, i1 true, i1 true, i1 true>, <4 x i1> %455
%543 = select <4 x i1> %542, <4 x i1> <i1 true, i1 true, i1 true, i1 true>, <4 x i1> %447
%544 = select <4 x i1> %543, <4 x i1> <i1 true, i1 true, i1 true, i1 true>, <4 x i1> %439
%545 = select <4 x i1> %544, <4 x i1> <i1 true, i1 true, i1 true, i1 true>, <4 x i1> %431
%546 = select <4 x i1> %545, <4 x i1> <i1 true, i1 true, i1 true, i1 true>, <4 x i1> %423
%547 = select <4 x i1> %546, <4 x i1> <i1 true, i1 true, i1 true, i1 true>, <4 x i1> %415
%548 = select <4 x i1> %547, <4 x i1> <i1 true, i1 true, i1 true, i1 true>, <4 x i1> %407
%549 = select <4 x i1> %548, <4 x i32> zeroinitializer, <4 x i32> %399
%550 = icmp eq <4 x i32> %534, <i32 1, i32 1, i32 1, i32 1>
%551 = select <4 x i1> %550, <4 x i32> %549, <4 x i32> %534
%552 = icmp ne <4 x i32> %551, <i32 1, i32 1, i32 1, i32 1>
%553 = bitcast <4 x i1> %552 to i4
%554 = icmp eq i4 %553, 0
br i1 %554, label %782, label %588
555: ; preds = %555, %54
%556 = phi i64 [ 0, %54 ], [ %585, %555 ]
%557 = phi i64 [ 0, %54 ], [ %586, %555 ]
%558 = getelementptr inbounds [1001 x i8], [1001 x i8]* %4, i64 0, i64 %556
%559 = load i8, i8* %558
%560 = sext i8 %559 to i64
%561 = getelementptr inbounds [128 x i32], [128 x i32]* %6, i64 0, i64 %560
%562 = load i32, i32* %561
%563 = add nsw i32 %562, 1
store i32 %563, i32* %561
%564 = or i64 %556, 1
%565 = getelementptr inbounds [1001 x i8], [1001 x i8]* %4, i64 0, i64 %564
%566 = load i8, i8* %565
%567 = sext i8 %566 to i64
%568 = getelementptr inbounds [128 x i32], [128 x i32]* %6, i64 0, i64 %567
%569 = load i32, i32* %568
%570 = add nsw i32 %569, 1
store i32 %570, i32* %568
%571 = or i64 %556, 2
%572 = getelementptr inbounds [1001 x i8], [1001 x i8]* %4, i64 0, i64 %571
%573 = load i8, i8* %572
%574 = sext i8 %573 to i64
%575 = getelementptr inbounds [128 x i32], [128 x i32]* %6, i64 0, i64 %574
%576 = load i32, i32* %575
%577 = add nsw i32 %576, 1
store i32 %577, i32* %575
%578 = or i64 %556, 3
%579 = getelementptr inbounds [1001 x i8], [1001 x i8]* %4, i64 0, i64 %578
%580 = load i8, i8* %579
%581 = sext i8 %580 to i64
%582 = getelementptr inbounds [128 x i32], [128 x i32]* %6, i64 0, i64 %581
%583 = load i32, i32* %582
%584 = add nsw i32 %583, 1
store i32 %584, i32* %582
%585 = add nuw nsw i64 %556, 4
%586 = add i64 %557, 4
%587 = icmp eq i64 %586, %55
br i1 %587, label %89, label %555
588: ; preds = %104
%589 = bitcast [128 x i32]* %7 to <4 x i32>*
%590 = load <4 x i32>, <4 x i32>* %589
%591 = getelementptr inbounds [128 x i32], [128 x i32]* %7, i64 0, i64 4
%592 = bitcast i32* %591 to <4 x i32>*
%593 = load <4 x i32>, <4 x i32>* %592
%594 = icmp slt <4 x i32> %590, zeroinitializer
%595 = icmp slt <4 x i32> %593, zeroinitializer
%596 = select <4 x i1> %594, <4 x i32> %590, <4 x i32> zeroinitializer
%597 = select <4 x i1> %595, <4 x i32> %593, <4 x i32> zeroinitializer
%598 = getelementptr inbounds [128 x i32], [128 x i32]* %7, i64 0, i64 8
%599 = bitcast i32* %598 to <4 x i32>*
%600 = load <4 x i32>, <4 x i32>* %599
%601 = getelementptr inbounds [128 x i32], [128 x i32]* %7, i64 0, i64 12
%602 = bitcast i32* %601 to <4 x i32>*
%603 = load <4 x i32>, <4 x i32>* %602
%604 = icmp slt <4 x i32> %600, zeroinitializer
%605 = icmp slt <4 x i32> %603, zeroinitializer
%606 = select <4 x i1> %604, <4 x i32> %600, <4 x i32> zeroinitializer
%607 = select <4 x i1> %605, <4 x i32> %603, <4 x i32> zeroinitializer
%608 = add <4 x i32> %606, %596
%609 = add <4 x i32> %607, %597
%610 = getelementptr inbounds [128 x i32], [128 x i32]* %7, i64 0, i64 16
%611 = bitcast i32* %610 to <4 x i32>*
%612 = load <4 x i32>, <4 x i32>* %611
%613 = getelementptr inbounds [128 x i32], [128 x i32]* %7, i64 0, i64 20
%614 = bitcast i32* %613 to <4 x i32>*
%615 = load <4 x i32>, <4 x i32>* %614
%616 = icmp slt <4 x i32> %612, zeroinitializer
%617 = icmp slt <4 x i32> %615, zeroinitializer
%618 = select <4 x i1> %616, <4 x i32> %612, <4 x i32> zeroinitializer
%619 = select <4 x i1> %617, <4 x i32> %615, <4 x i32> zeroinitializer
%620 = add <4 x i32> %618, %608
%621 = add <4 x i32> %619, %609
%622 = getelementptr inbounds [128 x i32], [128 x i32]* %7, i64 0, i64 24
%623 = bitcast i32* %622 to <4 x i32>*
%624 = load <4 x i32>, <4 x i32>* %623
%625 = getelementptr inbounds [128 x i32], [128 x i32]* %7, i64 0, i64 28
%626 = bitcast i32* %625 to <4 x i32>*
%627 = load <4 x i32>, <4 x i32>* %626
%628 = icmp slt <4 x i32> %624, zeroinitializer
%629 = icmp slt <4 x i32> %627, zeroinitializer
%630 = select <4 x i1> %628, <4 x i32> %624, <4 x i32> zeroinitializer
%631 = select <4 x i1> %629, <4 x i32> %627, <4 x i32> zeroinitializer
%632 = add <4 x i32> %630, %620
%633 = add <4 x i32> %631, %621
%634 = getelementptr inbounds [128 x i32], [128 x i32]* %7, i64 0, i64 32
%635 = bitcast i32* %634 to <4 x i32>*
%636 = load <4 x i32>, <4 x i32>* %635
%637 = getelementptr inbounds [128 x i32], [128 x i32]* %7, i64 0, i64 36
%638 = bitcast i32* %637 to <4 x i32>*
%639 = load <4 x i32>, <4 x i32>* %638
%640 = icmp slt <4 x i32> %636, zeroinitializer
%641 = icmp slt <4 x i32> %639, zeroinitializer
%642 = select <4 x i1> %640, <4 x i32> %636, <4 x i32> zeroinitializer
%643 = select <4 x i1> %641, <4 x i32> %639, <4 x i32> zeroinitializer
%644 = add <4 x i32> %642, %632
%645 = add <4 x i32> %643, %633
%646 = getelementptr inbounds [128 x i32], [128 x i32]* %7, i64 0, i64 40
%647 = bitcast i32* %646 to <4 x i32>*
%648 = load <4 x i32>, <4 x i32>* %647
%649 = getelementptr inbounds [128 x i32], [128 x i32]* %7, i64 0, i64 44
%650 = bitcast i32* %649 to <4 x i32>*
%651 = load <4 x i32>, <4 x i32>* %650
%652 = icmp slt <4 x i32> %648, zeroinitializer
%653 = icmp slt <4 x i32> %651, zeroinitializer
%654 = select <4 x i1> %652, <4 x i32> %648, <4 x i32> zeroinitializer
%655 = select <4 x i1> %653, <4 x i32> %651, <4 x i32> zeroinitializer
%656 = add <4 x i32> %654, %644
%657 = add <4 x i32> %655, %645
%658 = getelementptr inbounds [128 x i32], [128 x i32]* %7, i64 0, i64 48
%659 = bitcast i32* %658 to <4 x i32>*
%660 = load <4 x i32>, <4 x i32>* %659
%661 = getelementptr inbounds [128 x i32], [128 x i32]* %7, i64 0, i64 52
%662 = bitcast i32* %661 to <4 x i32>*
%663 = load <4 x i32>, <4 x i32>* %662
%664 = icmp slt <4 x i32> %660, zeroinitializer
%665 = icmp slt <4 x i32> %663, zeroinitializer
%666 = select <4 x i1> %664, <4 x i32> %660, <4 x i32> zeroinitializer
%667 = select <4 x i1> %665, <4 x i32> %663, <4 x i32> zeroinitializer
%668 = add <4 x i32> %666, %656
%669 = add <4 x i32> %667, %657
%670 = getelementptr inbounds [128 x i32], [128 x i32]* %7, i64 0, i64 56
%671 = bitcast i32* %670 to <4 x i32>*
%672 = load <4 x i32>, <4 x i32>* %671
%673 = getelementptr inbounds [128 x i32], [128 x i32]* %7, i64 0, i64 60
%674 = bitcast i32* %673 to <4 x i32>*
%675 = load <4 x i32>, <4 x i32>* %674
%676 = icmp slt <4 x i32> %672, zeroinitializer
%677 = icmp slt <4 x i32> %675, zeroinitializer
%678 = select <4 x i1> %676, <4 x i32> %672, <4 x i32> zeroinitializer
%679 = select <4 x i1> %677, <4 x i32> %675, <4 x i32> zeroinitializer
%680 = add <4 x i32> %678, %668
%681 = add <4 x i32> %679, %669
%682 = getelementptr inbounds [128 x i32], [128 x i32]* %7, i64 0, i64 64
%683 = bitcast i32* %682 to <4 x i32>*
%684 = load <4 x i32>, <4 x i32>* %683
%685 = getelementptr inbounds [128 x i32], [128 x i32]* %7, i64 0, i64 68
%686 = bitcast i32* %685 to <4 x i32>*
%687 = load <4 x i32>, <4 x i32>* %686
%688 = icmp slt <4 x i32> %684, zeroinitializer
%689 = icmp slt <4 x i32> %687, zeroinitializer
%690 = select <4 x i1> %688, <4 x i32> %684, <4 x i32> zeroinitializer
%691 = select <4 x i1> %689, <4 x i32> %687, <4 x i32> zeroinitializer
%692 = add <4 x i32> %690, %680
%693 = add <4 x i32> %691, %681
%694 = getelementptr inbounds [128 x i32], [128 x i32]* %7, i64 0, i64 72
%695 = bitcast i32* %694 to <4 x i32>*
%696 = load <4 x i32>, <4 x i32>* %695
%697 = getelementptr inbounds [128 x i32], [128 x i32]* %7, i64 0, i64 76
%698 = bitcast i32* %697 to <4 x i32>*
%699 = load <4 x i32>, <4 x i32>* %698
%700 = icmp slt <4 x i32> %696, zeroinitializer
%701 = icmp slt <4 x i32> %699, zeroinitializer
%702 = select <4 x i1> %700, <4 x i32> %696, <4 x i32> zeroinitializer
%703 = select <4 x i1> %701, <4 x i32> %699, <4 x i32> zeroinitializer
%704 = add <4 x i32> %702, %692
%705 = add <4 x i32> %703, %693
%706 = getelementptr inbounds [128 x i32], [128 x i32]* %7, i64 0, i64 80
%707 = bitcast i32* %706 to <4 x i32>*
%708 = load <4 x i32>, <4 x i32>* %707
%709 = getelementptr inbounds [128 x i32], [128 x i32]* %7, i64 0, i64 84
%710 = bitcast i32* %709 to <4 x i32>*
%711 = load <4 x i32>, <4 x i32>* %710
%712 = icmp slt <4 x i32> %708, zeroinitializer
%713 = icmp slt <4 x i32> %711, zeroinitializer
%714 = select <4 x i1> %712, <4 x i32> %708, <4 x i32> zeroinitializer
%715 = select <4 x i1> %713, <4 x i32> %711, <4 x i32> zeroinitializer
%716 = add <4 x i32> %714, %704
%717 = add <4 x i32> %715, %705
%718 = getelementptr inbounds [128 x i32], [128 x i32]* %7, i64 0, i64 88
%719 = bitcast i32* %718 to <4 x i32>*
%720 = load <4 x i32>, <4 x i32>* %719
%721 = getelementptr inbounds [128 x i32], [128 x i32]* %7, i64 0, i64 92
%722 = bitcast i32* %721 to <4 x i32>*
%723 = load <4 x i32>, <4 x i32>* %722
%724 = icmp slt <4 x i32> %720, zeroinitializer
%725 = icmp slt <4 x i32> %723, zeroinitializer
%726 = select <4 x i1> %724, <4 x i32> %720, <4 x i32> zeroinitializer
%727 = select <4 x i1> %725, <4 x i32> %723, <4 x i32> zeroinitializer
%728 = add <4 x i32> %726, %716
%729 = add <4 x i32> %727, %717
%730 = getelementptr inbounds [128 x i32], [128 x i32]* %7, i64 0, i64 96
%731 = bitcast i32* %730 to <4 x i32>*
%732 = load <4 x i32>, <4 x i32>* %731
%733 = getelementptr inbounds [128 x i32], [128 x i32]* %7, i64 0, i64 100
%734 = bitcast i32* %733 to <4 x i32>*
%735 = load <4 x i32>, <4 x i32>* %734
%736 = icmp slt <4 x i32> %732, zeroinitializer
%737 = icmp slt <4 x i32> %735, zeroinitializer
%738 = select <4 x i1> %736, <4 x i32> %732, <4 x i32> zeroinitializer
%739 = select <4 x i1> %737, <4 x i32> %735, <4 x i32> zeroinitializer
%740 = add <4 x i32> %738, %728
%741 = add <4 x i32> %739, %729
%742 = getelementptr inbounds [128 x i32], [128 x i32]* %7, i64 0, i64 104
%743 = bitcast i32* %742 to <4 x i32>*
%744 = load <4 x i32>, <4 x i32>* %743
%745 = getelementptr inbounds [128 x i32], [128 x i32]* %7, i64 0, i64 108
%746 = bitcast i32* %745 to <4 x i32>*
%747 = load <4 x i32>, <4 x i32>* %746
%748 = icmp slt <4 x i32> %744, zeroinitializer
%749 = icmp slt <4 x i32> %747, zeroinitializer
%750 = select <4 x i1> %748, <4 x i32> %744, <4 x i32> zeroinitializer
%751 = select <4 x i1> %749, <4 x i32> %747, <4 x i32> zeroinitializer
%752 = add <4 x i32> %750, %740
%753 = add <4 x i32> %751, %741
%754 = getelementptr inbounds [128 x i32], [128 x i32]* %7, i64 0, i64 112
%755 = bitcast i32* %754 to <4 x i32>*
%756 = load <4 x i32>, <4 x i32>* %755
%757 = getelementptr inbounds [128 x i32], [128 x i32]* %7, i64 0, i64 116
%758 = bitcast i32* %757 to <4 x i32>*
%759 = load <4 x i32>, <4 x i32>* %758
%760 = icmp slt <4 x i32> %756, zeroinitializer
%761 = icmp slt <4 x i32> %759, zeroinitializer
%762 = select <4 x i1> %760, <4 x i32> %756, <4 x i32> zeroinitializer
%763 = select <4 x i1> %761, <4 x i32> %759, <4 x i32> zeroinitializer
%764 = add <4 x i32> %762, %752
%765 = add <4 x i32> %763, %753
%766 = getelementptr inbounds [128 x i32], [128 x i32]* %7, i64 0, i64 120
%767 = bitcast i32* %766 to <4 x i32>*
%768 = load <4 x i32>, <4 x i32>* %767
%769 = getelementptr inbounds [128 x i32], [128 x i32]* %7, i64 0, i64 124
%770 = bitcast i32* %769 to <4 x i32>*
%771 = load <4 x i32>, <4 x i32>* %770
%772 = icmp slt <4 x i32> %768, zeroinitializer
%773 = icmp slt <4 x i32> %771, zeroinitializer
%774 = select <4 x i1> %772, <4 x i32> %768, <4 x i32> zeroinitializer
%775 = select <4 x i1> %773, <4 x i32> %771, <4 x i32> zeroinitializer
%776 = add <4 x i32> %774, %764
%777 = add <4 x i32> %775, %765
%778 = add <4 x i32> %777, %776
%779 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %778)
%780 = sub nsw i32 0, %779
%781 = call i32 @printf(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.2, i64 0, i64 0), i32 %780)
br label %785
782: ; preds = %104
%783 = sub nsw i32 %20, %21
%784 = call i32 @printf(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), i32 %783)
br label %785
785: ; preds = %588, %782
%786 = load i32, i32* @EXIT_SUCCESS
br label %787
787: ; preds = %785, %17, %12
%788 = phi i32 [ %13, %12 ], [ %18, %17 ], [ %786, %785 ]
ret i32 %788
}