#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 */
typedef struct TYPE_3__ TYPE_1__;

/* Type definitions */
struct TYPE_3__ {
  int rm_so;
  int rm_eo;
};
typedef TYPE_1__ regmatch_t;
typedef int /*<<< orphan*/ regex_t;

/* Variables and functions */
int /*<<< orphan*/ printf(char *, int);
int regexec(int /*<<< orphan*/ *, char *, int, TYPE_1__ *, int /*<<< orphan*/);
void execute_regex(regex_t *reg, char *source, char *dest) {
  char *mpos = source;
  int match_count = 5;
  int i, k, j;
  regmatch_t result[match_count];
  while (1) {
    char *extract;
    int unmatched = regexec(reg, mpos, match_count, result, 0);
    if (unmatched == 1)
      break;
    printf("-%d-", unmatched);
    for (i = 0; i < match_count; i++) {
      int start;
      int finish;
      if (result[i].rm_so == -1)
        break;
      start = result[i].rm_so + (mpos - source);
      finish = result[i].rm_eo + (mpos - source);
      k = 0;
      for (j = result[i].rm_so; j < result[i].rm_eo; ++j) {
        dest[k] = source[j];
        k++;
      }
      dest[k] = '\0';
    }
    mpos += result[0].rm_eo;
  }
  return;
}


x86 assembly (clang, -O0):
<execute_regex>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x20(%rbp)
movl   $0x5,-0x24(%rbp)
mov    -0x24(%rbp),%eax
mov    %rsp,%rcx
mov    %rcx,-0x38(%rbp)
lea    0xf(,%rax,8),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x60(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x40(%rbp)
jmp    116f <execute_regex+0x4f>
mov    -0x60(%rbp),%rcx
mov    -0x8(%rbp),%rdi
mov    -0x20(%rbp),%rsi
mov    -0x24(%rbp),%edx
xor    %r8d,%r8d
call   1040 <regexec@plt>
mov    %eax,-0x4c(%rbp)
cmpl   $0x1,-0x4c(%rbp)
jne    1198 <execute_regex+0x78>
jmp    128f <execute_regex+0x16f>
mov    -0x4c(%rbp),%esi
lea    0xe5e(%rip),%rdi
call   1030 <printf@plt>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    1275 <execute_regex+0x155>
mov    -0x60(%rbp),%rax
movslq -0x28(%rbp),%rcx
cmpl   $0xffffffff,(%rax,%rcx,8)
jne    11d1 <execute_regex+0xb1>
jmp    1275 <execute_regex+0x155>
mov    -0x60(%rbp),%rax
movslq -0x28(%rbp),%rcx
movslq (%rax,%rcx,8),%rcx
mov    -0x20(%rbp),%rdx
mov    -0x10(%rbp),%rsi
sub    %rsi,%rdx
add    %rdx,%rcx
mov    %ecx,-0x50(%rbp)
movslq -0x28(%rbp),%rcx
movslq 0x4(%rax,%rcx,8),%rcx
mov    -0x20(%rbp),%rdx
mov    -0x10(%rbp),%rsi
sub    %rsi,%rdx
add    %rdx,%rcx
mov    %ecx,-0x54(%rbp)
movl   $0x0,-0x2c(%rbp)
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%eax
mov    %eax,-0x30(%rbp)
mov    -0x60(%rbp),%rcx
mov    -0x30(%rbp),%eax
movslq -0x28(%rbp),%rdx
cmp    0x4(%rcx,%rdx,8),%eax
jge    125b <execute_regex+0x13b>
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1219 <execute_regex+0xf9>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    11ae <execute_regex+0x8e>
mov    -0x60(%rbp),%rax
mov    0x4(%rax),%ecx
mov    -0x20(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x20(%rbp)
jmp    116a <execute_regex+0x4a>
mov    -0x38(%rbp),%rax
mov    %rax,%rsp
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<execute_regex>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x58,%rsp
mov    %rdx,%rbx
mov    %rsi,%r14
mov    %rdi,%r15
lea    0x30(%rsp),%rcx
mov    $0x5,%edx
xor    %r8d,%r8d
call   1040 <regexec@plt>
cmp    $0x1,%eax
jne    115d <execute_regex+0x3d>
add    $0x58,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    0x70(%r14),%rcx
mov    %rcx,0x10(%rsp)
lea    0x10(%rbx),%rcx
mov    %rcx,0x20(%rsp)
lea    0x10(%r14),%rcx
mov    %rcx,0x18(%rsp)
lea    0x3(%r14),%rbp
lea    0x3(%rbx),%rcx
mov    %rcx,0x28(%rsp)
lea    0x30(%rsp),%r13
mov    %r14,%r12
mov    %rbp,0x8(%rsp)
jmp    11be <execute_regex+0x9e>
mov    %r11d,%eax
mov    %eax,%eax
movb   $0x0,(%rbx,%rax,1)
nopl   (%rax)
add    %r8,%r12
mov    %r15,%rdi
mov    %r12,%rsi
mov    $0x5,%edx
mov    %r13,%rcx
xor    %r8d,%r8d
call   1040 <regexec@plt>
cmp    $0x1,%eax
je     114e <execute_regex+0x2e>
lea    0xe3b(%rip),%rdi
mov    %eax,%esi
call   1030 <printf@plt>
movslq 0x30(%rsp),%rdx
movslq 0x34(%rsp),%r8
cmp    $0xffffffffffffffff,%rdx
je     11a0 <execute_regex+0x80>
xor    %r11d,%r11d
cmp    %edx,%r8d
jle    128b <execute_regex+0x16b>
mov    %r8d,%r11d
sub    %edx,%r11d
cmp    $0x8,%r11d
jb     1215 <execute_regex+0xf5>
lea    (%r14,%rdx,1),%r10
lea    (%rdx,%r11,1),%rax
add    %r14,%rax
cmp    %rbx,%rax
jbe    15c0 <execute_regex+0x4a0>
lea    (%rbx,%r11,1),%rax
cmp    %rax,%r10
jae    15c0 <execute_regex+0x4a0>
xor    %esi,%esi
mov    %rsi,%rax
not    %rax
add    %r11,%rax
mov    %r11,%rdi
and    $0x3,%rdi
je     1246 <execute_regex+0x126>
nopl   0x0(%rax)
movzbl (%r14,%rdx,1),%ecx
mov    %cl,(%rbx,%rsi,1)
add    $0x1,%rsi
add    $0x1,%rdx
add    $0xffffffffffffffff,%rdi
jne    1230 <execute_regex+0x110>
cmp    $0x3,%rax
jb     128b <execute_regex+0x16b>
add    %rbp,%rdx
mov    %r11,%rax
sub    %rsi,%rax
add    0x28(%rsp),%rsi
xor    %edi,%edi
nopl   0x0(%rax)
movzbl -0x3(%rdx,%rdi,1),%ecx
mov    %cl,-0x3(%rsi,%rdi,1)
movzbl -0x2(%rdx,%rdi,1),%ecx
mov    %cl,-0x2(%rsi,%rdi,1)
movzbl -0x1(%rdx,%rdi,1),%ecx
mov    %cl,-0x1(%rsi,%rdi,1)
movzbl (%rdx,%rdi,1),%ecx
mov    %cl,(%rsi,%rdi,1)
add    $0x4,%rdi
cmp    %rdi,%rax
jne    1260 <execute_regex+0x140>
mov    %r11d,%eax
movb   $0x0,(%rbx,%rax,1)
movslq 0x38(%rsp),%rcx
cmp    $0xffffffffffffffff,%rcx
je     11a0 <execute_regex+0x80>
mov    0x3c(%rsp),%r11d
xor    %eax,%eax
cmp    %ecx,%r11d
jle    134e <execute_regex+0x22e>
sub    %ecx,%r11d
cmp    $0x8,%r11d
jb     12db <execute_regex+0x1bb>
lea    (%r14,%rcx,1),%r10
lea    (%rcx,%r11,1),%rax
add    %r14,%rax
cmp    %rbx,%rax
jbe    15cd <execute_regex+0x4ad>
lea    (%rbx,%r11,1),%rax
cmp    %rax,%r10
jae    15cd <execute_regex+0x4ad>
xor    %esi,%esi
mov    %rsi,%rax
not    %rax
add    %r11,%rax
mov    %r11,%rdi
and    $0x3,%rdi
je     1306 <execute_regex+0x1e6>
nop
movzbl (%r14,%rcx,1),%edx
mov    %dl,(%rbx,%rsi,1)
add    $0x1,%rsi
add    $0x1,%rcx
add    $0xffffffffffffffff,%rdi
jne    12f0 <execute_regex+0x1d0>
cmp    $0x3,%rax
jb     134b <execute_regex+0x22b>
add    %rbp,%rcx
mov    %r11,%rax
sub    %rsi,%rax
add    0x28(%rsp),%rsi
xor    %edi,%edi
nopl   0x0(%rax)
movzbl -0x3(%rcx,%rdi,1),%edx
mov    %dl,-0x3(%rsi,%rdi,1)
movzbl -0x2(%rcx,%rdi,1),%edx
mov    %dl,-0x2(%rsi,%rdi,1)
movzbl -0x1(%rcx,%rdi,1),%edx
mov    %dl,-0x1(%rsi,%rdi,1)
movzbl (%rcx,%rdi,1),%edx
mov    %dl,(%rsi,%rdi,1)
add    $0x4,%rdi
cmp    %rdi,%rax
jne    1320 <execute_regex+0x200>
mov    %r11d,%eax
mov    %eax,%eax
movb   $0x0,(%rbx,%rax,1)
movslq 0x40(%rsp),%rcx
cmp    $0xffffffffffffffff,%rcx
je     11a0 <execute_regex+0x80>
mov    0x44(%rsp),%r11d
xor    %eax,%eax
cmp    %ecx,%r11d
jle    141e <execute_regex+0x2fe>
sub    %ecx,%r11d
cmp    $0x8,%r11d
jb     139d <execute_regex+0x27d>
lea    (%r14,%rcx,1),%r10
lea    (%rcx,%r11,1),%rax
add    %r14,%rax
cmp    %rbx,%rax
jbe    1603 <execute_regex+0x4e3>
lea    (%rbx,%r11,1),%rax
cmp    %rax,%r10
jae    1603 <execute_regex+0x4e3>
xor    %esi,%esi
mov    %rsi,%rax
not    %rax
add    %r11,%rax
mov    %r11,%rdi
and    $0x3,%rdi
je     13d6 <execute_regex+0x2b6>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movzbl (%r14,%rcx,1),%edx
mov    %dl,(%rbx,%rsi,1)
add    $0x1,%rsi
add    $0x1,%rcx
add    $0xffffffffffffffff,%rdi
jne    13c0 <execute_regex+0x2a0>
cmp    $0x3,%rax
jb     141b <execute_regex+0x2fb>
add    %rbp,%rcx
mov    %r11,%rax
sub    %rsi,%rax
add    0x28(%rsp),%rsi
xor    %edi,%edi
nopl   0x0(%rax)
movzbl -0x3(%rcx,%rdi,1),%edx
mov    %dl,-0x3(%rsi,%rdi,1)
movzbl -0x2(%rcx,%rdi,1),%edx
mov    %dl,-0x2(%rsi,%rdi,1)
movzbl -0x1(%rcx,%rdi,1),%edx
mov    %dl,-0x1(%rsi,%rdi,1)
movzbl (%rcx,%rdi,1),%edx
mov    %dl,(%rsi,%rdi,1)
add    $0x4,%rdi
cmp    %rdi,%rax
jne    13f0 <execute_regex+0x2d0>
mov    %r11d,%eax
mov    %eax,%eax
movb   $0x0,(%rbx,%rax,1)
movslq 0x48(%rsp),%rcx
cmp    $0xffffffffffffffff,%rcx
je     11a0 <execute_regex+0x80>
mov    0x4c(%rsp),%r11d
xor    %eax,%eax
cmp    %ecx,%r11d
jle    14ee <execute_regex+0x3ce>
sub    %ecx,%r11d
cmp    $0x8,%r11d
jb     146d <execute_regex+0x34d>
lea    (%r14,%rcx,1),%r10
lea    (%rcx,%r11,1),%rax
add    %r14,%rax
cmp    %rbx,%rax
jbe    174f <execute_regex+0x62f>
lea    (%rbx,%r11,1),%rax
cmp    %rax,%r10
jae    174f <execute_regex+0x62f>
xor    %esi,%esi
mov    %rsi,%rax
not    %rax
add    %r11,%rax
mov    %r11,%rdi
and    $0x3,%rdi
je     14a6 <execute_regex+0x386>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movzbl (%r14,%rcx,1),%edx
mov    %dl,(%rbx,%rsi,1)
add    $0x1,%rsi
add    $0x1,%rcx
add    $0xffffffffffffffff,%rdi
jne    1490 <execute_regex+0x370>
cmp    $0x3,%rax
jb     14eb <execute_regex+0x3cb>
add    %rbp,%rcx
mov    %r11,%rax
sub    %rsi,%rax
add    0x28(%rsp),%rsi
xor    %edi,%edi
nopl   0x0(%rax)
movzbl -0x3(%rcx,%rdi,1),%edx
mov    %dl,-0x3(%rsi,%rdi,1)
movzbl -0x2(%rcx,%rdi,1),%edx
mov    %dl,-0x2(%rsi,%rdi,1)
movzbl -0x1(%rcx,%rdi,1),%edx
mov    %dl,-0x1(%rsi,%rdi,1)
movzbl (%rcx,%rdi,1),%edx
mov    %dl,(%rsi,%rdi,1)
add    $0x4,%rdi
cmp    %rdi,%rax
jne    14c0 <execute_regex+0x3a0>
mov    %r11d,%eax
mov    %eax,%eax
movb   $0x0,(%rbx,%rax,1)
movslq 0x50(%rsp),%rcx
cmp    $0xffffffffffffffff,%rcx
je     11a0 <execute_regex+0x80>
mov    0x54(%rsp),%r11d
xor    %eax,%eax
cmp    %ecx,%r11d
jle    1197 <execute_regex+0x77>
sub    %ecx,%r11d
cmp    $0x8,%r11d
jb     153d <execute_regex+0x41d>
lea    (%r14,%rcx,1),%r10
lea    (%rcx,%r11,1),%rax
add    %r14,%rax
cmp    %rbx,%rax
jbe    189f <execute_regex+0x77f>
lea    (%rbx,%r11,1),%rax
cmp    %rax,%r10
jae    189f <execute_regex+0x77f>
xor    %esi,%esi
mov    %rsi,%rax
not    %rax
add    %r11,%rax
mov    %r11,%rdi
and    $0x3,%rdi
je     1576 <execute_regex+0x456>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movzbl (%r14,%rcx,1),%edx
mov    %dl,(%rbx,%rsi,1)
add    $0x1,%rsi
add    $0x1,%rcx
add    $0xffffffffffffffff,%rdi
jne    1560 <execute_regex+0x440>
cmp    $0x3,%rax
jb     1194 <execute_regex+0x74>
add    %rbp,%rcx
mov    %r11,%rax
sub    %rsi,%rax
add    0x28(%rsp),%rsi
xor    %edi,%edi
movzbl -0x3(%rcx,%rdi,1),%edx
mov    %dl,-0x3(%rsi,%rdi,1)
movzbl -0x2(%rcx,%rdi,1),%edx
mov    %dl,-0x2(%rsi,%rdi,1)
movzbl -0x1(%rcx,%rdi,1),%edx
mov    %dl,-0x1(%rsi,%rdi,1)
movzbl (%rcx,%rdi,1),%edx
mov    %dl,(%rsi,%rdi,1)
add    $0x4,%rdi
cmp    %rdi,%rax
jne    1590 <execute_regex+0x470>
jmp    1194 <execute_regex+0x74>
cmp    $0x20,%r11d
jae    15da <execute_regex+0x4ba>
xor    %esi,%esi
jmp    171a <execute_regex+0x5fa>
cmp    $0x20,%r11d
jae    1614 <execute_regex+0x4f4>
xor    %esi,%esi
jmp    186d <execute_regex+0x74d>
mov    %r11d,%esi
and    $0xffffffe0,%esi
lea    -0x20(%rsi),%rdi
mov    %rdi,%rax
shr    $0x5,%rax
add    $0x1,%rax
mov    %eax,%r9d
and    $0x3,%r9d
cmp    $0x60,%rdi
jae    1641 <execute_regex+0x521>
xor    %ebp,%ebp
jmp    16b8 <execute_regex+0x598>
cmp    $0x20,%r11d
jae    1760 <execute_regex+0x640>
xor    %esi,%esi
jmp    19bd <execute_regex+0x89d>
mov    %r11d,%esi
and    $0xffffffe0,%esi
lea    -0x20(%rsi),%rdi
mov    %rdi,%rax
shr    $0x5,%rax
add    $0x1,%rax
mov    %eax,%r9d
and    $0x3,%r9d
cmp    $0x60,%rdi
jae    178d <execute_regex+0x66d>
xor    %ebp,%ebp
jmp    1808 <execute_regex+0x6e8>
movabs $0xffffffffffffffc,%rcx
ff ff 0f
and    %rcx,%rax
mov    0x10(%rsp),%rcx
lea    (%rcx,%rdx,1),%rdi
xor    %ebp,%ebp
nopl   0x0(%rax)
movups -0x70(%rdi,%rbp,1),%xmm0
movups -0x60(%rdi,%rbp,1),%xmm1
movups %xmm0,(%rbx,%rbp,1)
movups %xmm1,0x10(%rbx,%rbp,1)
movups -0x50(%rdi,%rbp,1),%xmm0
movups -0x40(%rdi,%rbp,1),%xmm1
movups %xmm0,0x20(%rbx,%rbp,1)
movups %xmm1,0x30(%rbx,%rbp,1)
movups -0x30(%rdi,%rbp,1),%xmm0
movups -0x20(%rdi,%rbp,1),%xmm1
movups %xmm0,0x40(%rbx,%rbp,1)
movups %xmm1,0x50(%rbx,%rbp,1)
movups -0x10(%rdi,%rbp,1),%xmm0
movups (%rdi,%rbp,1),%xmm1
movups %xmm0,0x60(%rbx,%rbp,1)
movups %xmm1,0x70(%rbx,%rbp,1)
sub    $0xffffffffffffff80,%rbp
add    $0xfffffffffffffffc,%rax
jne    1660 <execute_regex+0x540>
test   %r9,%r9
je     16fc <execute_regex+0x5dc>
mov    0x20(%rsp),%rax
add    %rbp,%rax
add    %rdx,%rbp
add    0x18(%rsp),%rbp
shl    $0x5,%r9
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups -0x10(%rbp,%rdi,1),%xmm0
movups 0x0(%rbp,%rdi,1),%xmm1
movups %xmm0,-0x10(%rax,%rdi,1)
movups %xmm1,(%rax,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%r9
jne    16e0 <execute_regex+0x5c0>
cmp    %r11,%rsi
jne    170b <execute_regex+0x5eb>
mov    0x8(%rsp),%rbp
jmp    128b <execute_regex+0x16b>
test   $0x18,%r11b
je     19ef <execute_regex+0x8cf>
mov    0x8(%rsp),%rbp
mov    %rsi,%rax
mov    %r11d,%esi
and    $0xfffffff8,%esi
add    %rsi,%rdx
cs nopw 0x0(%rax,%rax,1)
mov    (%r10,%rax,1),%rdi
mov    %rdi,(%rbx,%rax,1)
add    $0x8,%rax
cmp    %rax,%rsi
jne    1730 <execute_regex+0x610>
cmp    %r11,%rsi
jne    1217 <execute_regex+0xf7>
jmp    128b <execute_regex+0x16b>
cmp    $0x20,%r11d
jae    18b0 <execute_regex+0x790>
xor    %esi,%esi
jmp    1b0d <execute_regex+0x9ed>
mov    %r11d,%esi
and    $0xffffffe0,%esi
lea    -0x20(%rsi),%rdi
mov    %rdi,%rax
shr    $0x5,%rax
add    $0x1,%rax
mov    %eax,%r9d
and    $0x3,%r9d
cmp    $0x60,%rdi
jae    18dd <execute_regex+0x7bd>
xor    %ebp,%ebp
jmp    1958 <execute_regex+0x838>
movabs $0xffffffffffffffc,%rdx
ff ff 0f
and    %rdx,%rax
mov    0x10(%rsp),%rdx
lea    (%rdx,%rcx,1),%rdi
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nop
movups -0x70(%rdi,%rbp,1),%xmm0
movups -0x60(%rdi,%rbp,1),%xmm1
movups %xmm0,(%rbx,%rbp,1)
movups %xmm1,0x10(%rbx,%rbp,1)
movups -0x50(%rdi,%rbp,1),%xmm0
movups -0x40(%rdi,%rbp,1),%xmm1
movups %xmm0,0x20(%rbx,%rbp,1)
movups %xmm1,0x30(%rbx,%rbp,1)
movups -0x30(%rdi,%rbp,1),%xmm0
movups -0x20(%rdi,%rbp,1),%xmm1
movups %xmm0,0x40(%rbx,%rbp,1)
movups %xmm1,0x50(%rbx,%rbp,1)
movups -0x10(%rdi,%rbp,1),%xmm0
movups (%rdi,%rbp,1),%xmm1
movups %xmm0,0x60(%rbx,%rbp,1)
movups %xmm1,0x70(%rbx,%rbp,1)
sub    $0xffffffffffffff80,%rbp
add    $0xfffffffffffffffc,%rax
jne    17b0 <execute_regex+0x690>
test   %r9,%r9
je     184c <execute_regex+0x72c>
mov    0x20(%rsp),%rax
add    %rbp,%rax
add    %rcx,%rbp
add    0x18(%rsp),%rbp
shl    $0x5,%r9
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups -0x10(%rbp,%rdi,1),%xmm0
movups 0x0(%rbp,%rdi,1),%xmm1
movups %xmm0,-0x10(%rax,%rdi,1)
movups %xmm1,(%rax,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%r9
jne    1830 <execute_regex+0x710>
cmp    %r11,%rsi
jne    185e <execute_regex+0x73e>
mov    %r11d,%eax
mov    0x8(%rsp),%rbp
jmp    134e <execute_regex+0x22e>
test   $0x18,%r11b
mov    0x8(%rsp),%rbp
je     1b3f <execute_regex+0xa1f>
mov    %rsi,%rax
mov    %r11d,%esi
and    $0xfffffff8,%esi
add    %rsi,%rcx
nopl   0x0(%rax)
mov    (%r10,%rax,1),%rdi
mov    %rdi,(%rbx,%rax,1)
add    $0x8,%rax
cmp    %rax,%rsi
jne    1880 <execute_regex+0x760>
cmp    %r11,%rsi
jne    12dd <execute_regex+0x1bd>
jmp    134b <execute_regex+0x22b>
cmp    $0x20,%r11d
jae    19fc <execute_regex+0x8dc>
xor    %esi,%esi
jmp    1c19 <execute_regex+0xaf9>
mov    %r11d,%esi
and    $0xffffffe0,%esi
lea    -0x20(%rsi),%rdi
mov    %rdi,%rax
shr    $0x5,%rax
add    $0x1,%rax
mov    %eax,%r9d
and    $0x3,%r9d
cmp    $0x60,%rdi
jae    1a29 <execute_regex+0x909>
xor    %ebp,%ebp
jmp    1aa8 <execute_regex+0x988>
movabs $0xffffffffffffffc,%rdx
ff ff 0f
and    %rdx,%rax
mov    0x10(%rsp),%rdx
lea    (%rdx,%rcx,1),%rdi
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nop
movups -0x70(%rdi,%rbp,1),%xmm0
movups -0x60(%rdi,%rbp,1),%xmm1
movups %xmm0,(%rbx,%rbp,1)
movups %xmm1,0x10(%rbx,%rbp,1)
movups -0x50(%rdi,%rbp,1),%xmm0
movups -0x40(%rdi,%rbp,1),%xmm1
movups %xmm0,0x20(%rbx,%rbp,1)
movups %xmm1,0x30(%rbx,%rbp,1)
movups -0x30(%rdi,%rbp,1),%xmm0
movups -0x20(%rdi,%rbp,1),%xmm1
movups %xmm0,0x40(%rbx,%rbp,1)
movups %xmm1,0x50(%rbx,%rbp,1)
movups -0x10(%rdi,%rbp,1),%xmm0
movups (%rdi,%rbp,1),%xmm1
movups %xmm0,0x60(%rbx,%rbp,1)
movups %xmm1,0x70(%rbx,%rbp,1)
sub    $0xffffffffffffff80,%rbp
add    $0xfffffffffffffffc,%rax
jne    1900 <execute_regex+0x7e0>
test   %r9,%r9
je     199c <execute_regex+0x87c>
mov    0x20(%rsp),%rax
add    %rbp,%rax
add    %rcx,%rbp
add    0x18(%rsp),%rbp
shl    $0x5,%r9
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups -0x10(%rbp,%rdi,1),%xmm0
movups 0x0(%rbp,%rdi,1),%xmm1
movups %xmm0,-0x10(%rax,%rdi,1)
movups %xmm1,(%rax,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%r9
jne    1980 <execute_regex+0x860>
cmp    %r11,%rsi
jne    19ae <execute_regex+0x88e>
mov    %r11d,%eax
mov    0x8(%rsp),%rbp
jmp    141e <execute_regex+0x2fe>
test   $0x18,%r11b
je     1c4f <execute_regex+0xb2f>
mov    0x8(%rsp),%rbp
mov    %rsi,%rax
mov    %r11d,%esi
and    $0xfffffff8,%esi
add    %rsi,%rcx
nopl   0x0(%rax)
mov    (%r10,%rax,1),%rdi
mov    %rdi,(%rbx,%rax,1)
add    $0x8,%rax
cmp    %rax,%rsi
jne    19d0 <execute_regex+0x8b0>
cmp    %r11,%rsi
jne    139f <execute_regex+0x27f>
jmp    141b <execute_regex+0x2fb>
add    %rsi,%rdx
mov    0x8(%rsp),%rbp
jmp    1217 <execute_regex+0xf7>
mov    %r11d,%esi
and    $0xffffffe0,%esi
lea    -0x20(%rsi),%rdi
mov    %rdi,%rax
shr    $0x5,%rax
add    $0x1,%rax
mov    %eax,%r9d
and    $0x3,%r9d
cmp    $0x60,%rdi
jae    1b47 <execute_regex+0xa27>
xor    %ebp,%ebp
jmp    1bb8 <execute_regex+0xa98>
movabs $0xffffffffffffffc,%rdx
ff ff 0f
and    %rdx,%rax
mov    0x10(%rsp),%rdx
lea    (%rdx,%rcx,1),%rdi
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movups -0x70(%rdi,%rbp,1),%xmm0
movups -0x60(%rdi,%rbp,1),%xmm1
movups %xmm0,(%rbx,%rbp,1)
movups %xmm1,0x10(%rbx,%rbp,1)
movups -0x50(%rdi,%rbp,1),%xmm0
movups -0x40(%rdi,%rbp,1),%xmm1
movups %xmm0,0x20(%rbx,%rbp,1)
movups %xmm1,0x30(%rbx,%rbp,1)
movups -0x30(%rdi,%rbp,1),%xmm0
movups -0x20(%rdi,%rbp,1),%xmm1
movups %xmm0,0x40(%rbx,%rbp,1)
movups %xmm1,0x50(%rbx,%rbp,1)
movups -0x10(%rdi,%rbp,1),%xmm0
movups (%rdi,%rbp,1),%xmm1
movups %xmm0,0x60(%rbx,%rbp,1)
movups %xmm1,0x70(%rbx,%rbp,1)
sub    $0xffffffffffffff80,%rbp
add    $0xfffffffffffffffc,%rax
jne    1a50 <execute_regex+0x930>
test   %r9,%r9
je     1aec <execute_regex+0x9cc>
mov    0x20(%rsp),%rax
add    %rbp,%rax
add    %rcx,%rbp
add    0x18(%rsp),%rbp
shl    $0x5,%r9
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups -0x10(%rbp,%rdi,1),%xmm0
movups 0x0(%rbp,%rdi,1),%xmm1
movups %xmm0,-0x10(%rax,%rdi,1)
movups %xmm1,(%rax,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%r9
jne    1ad0 <execute_regex+0x9b0>
cmp    %r11,%rsi
jne    1afe <execute_regex+0x9de>
mov    %r11d,%eax
mov    0x8(%rsp),%rbp
jmp    14ee <execute_regex+0x3ce>
test   $0x18,%r11b
mov    0x8(%rsp),%rbp
je     1c5c <execute_regex+0xb3c>
mov    %rsi,%rax
mov    %r11d,%esi
and    $0xfffffff8,%esi
add    %rsi,%rcx
nopl   0x0(%rax)
mov    (%r10,%rax,1),%rdi
mov    %rdi,(%rbx,%rax,1)
add    $0x8,%rax
cmp    %rax,%rsi
jne    1b20 <execute_regex+0xa00>
cmp    %r11,%rsi
jne    146f <execute_regex+0x34f>
jmp    14eb <execute_regex+0x3cb>
add    %rsi,%rcx
jmp    12dd <execute_regex+0x1bd>
movabs $0xffffffffffffffc,%rdx
ff ff 0f
and    %rdx,%rax
mov    0x10(%rsp),%rdx
lea    (%rdx,%rcx,1),%rdi
xor    %ebp,%ebp
nop
movups -0x70(%rdi,%rbp,1),%xmm0
movups -0x60(%rdi,%rbp,1),%xmm1
movups %xmm0,(%rbx,%rbp,1)
movups %xmm1,0x10(%rbx,%rbp,1)
movups -0x50(%rdi,%rbp,1),%xmm0
movups -0x40(%rdi,%rbp,1),%xmm1
movups %xmm0,0x20(%rbx,%rbp,1)
movups %xmm1,0x30(%rbx,%rbp,1)
movups -0x30(%rdi,%rbp,1),%xmm0
movups -0x20(%rdi,%rbp,1),%xmm1
movups %xmm0,0x40(%rbx,%rbp,1)
movups %xmm1,0x50(%rbx,%rbp,1)
movups -0x10(%rdi,%rbp,1),%xmm0
movups (%rdi,%rbp,1),%xmm1
movups %xmm0,0x60(%rbx,%rbp,1)
movups %xmm1,0x70(%rbx,%rbp,1)
sub    $0xffffffffffffff80,%rbp
add    $0xfffffffffffffffc,%rax
jne    1b60 <execute_regex+0xa40>
test   %r9,%r9
je     1bfc <execute_regex+0xadc>
mov    0x20(%rsp),%rax
add    %rbp,%rax
add    %rcx,%rbp
add    0x18(%rsp),%rbp
shl    $0x5,%r9
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups -0x10(%rbp,%rdi,1),%xmm0
movups 0x0(%rbp,%rdi,1),%xmm1
movups %xmm0,-0x10(%rax,%rdi,1)
movups %xmm1,(%rax,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%r9
jne    1be0 <execute_regex+0xac0>
cmp    %r11,%rsi
jne    1c0e <execute_regex+0xaee>
mov    %r11d,%eax
mov    0x8(%rsp),%rbp
jmp    1197 <execute_regex+0x77>
test   $0x18,%r11b
mov    0x8(%rsp),%rbp
je     1c64 <execute_regex+0xb44>
mov    %rsi,%rax
mov    %r11d,%esi
and    $0xfffffff8,%esi
add    %rsi,%rcx
cs nopw 0x0(%rax,%rax,1)
nop
mov    (%r10,%rax,1),%rdi
mov    %rdi,(%rbx,%rax,1)
add    $0x8,%rax
cmp    %rax,%rsi
jne    1c30 <execute_regex+0xb10>
cmp    %r11,%rsi
je     1194 <execute_regex+0x74>
jmp    153f <execute_regex+0x41f>
add    %rsi,%rcx
mov    0x8(%rsp),%rbp
jmp    139f <execute_regex+0x27f>
add    %rsi,%rcx
jmp    146f <execute_regex+0x34f>
add    %rsi,%rcx
jmp    153f <execute_regex+0x41f>

LLVM IR (-O0):
%struct.TYPE_3__ = type { i32, i32 }
@.str = [5 x i8] c"-%d-\00"
define void @execute_regex(i32* %0, i8* %1, i8* %2) {
%4 = alloca i32*
%5 = alloca i8*
%6 = alloca i8*
%7 = alloca i8*
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i8*
%13 = alloca i64
%14 = alloca i8*
%15 = alloca i32
%16 = alloca i32
%17 = alloca i32
store i32* %0, i32** %4
store i8* %1, i8** %5
store i8* %2, i8** %6
%18 = load i8*, i8** %5
store i8* %18, i8** %7
store i32 5, i32* %8
%19 = load i32, i32* %8
%20 = zext i32 %19 to i64
%21 = call i8* @llvm.stacksave()
store i8* %21, i8** %12
%22 = alloca %struct.TYPE_3__, i64 %20
store i64 %20, i64* %13
br label %23
23: ; preds = %110, %3
br label %24
24: ; preds = %23
%25 = load i32*, i32** %4
%26 = load i8*, i8** %7
%27 = load i32, i32* %8
%28 = call i32 @regexec(i32* %25, i8* %26, i32 %27, %struct.TYPE_3__* %22, i32 0)
store i32 %28, i32* %15
%29 = load i32, i32* %15
%30 = icmp eq i32 %29, 1
br i1 %30, label %31, label %32
31: ; preds = %24
br label %117
32: ; preds = %24
%33 = load i32, i32* %15
%34 = call i32 @printf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0), i32 %33)
store i32 0, i32* %9
br label %35
35: ; preds = %107, %32
%36 = load i32, i32* %9
%37 = load i32, i32* %8
%38 = icmp slt i32 %36, %37
br i1 %38, label %39, label %110
39: ; preds = %35
%40 = load i32, i32* %9
%41 = sext i32 %40 to i64
%42 = getelementptr inbounds %struct.TYPE_3__, %struct.TYPE_3__* %22, i64 %41
%43 = getelementptr inbounds %struct.TYPE_3__, %struct.TYPE_3__* %42, i32 0, i32 0
%44 = load i32, i32* %43
%45 = icmp eq i32 %44, -1
br i1 %45, label %46, label %47
46: ; preds = %39
br label %110
47: ; preds = %39
%48 = load i32, i32* %9
%49 = sext i32 %48 to i64
%50 = getelementptr inbounds %struct.TYPE_3__, %struct.TYPE_3__* %22, i64 %49
%51 = getelementptr inbounds %struct.TYPE_3__, %struct.TYPE_3__* %50, i32 0, i32 0
%52 = load i32, i32* %51
%53 = sext i32 %52 to i64
%54 = load i8*, i8** %7
%55 = load i8*, i8** %5
%56 = ptrtoint i8* %54 to i64
%57 = ptrtoint i8* %55 to i64
%58 = sub i64 %56, %57
%59 = add nsw i64 %53, %58
%60 = trunc i64 %59 to i32
store i32 %60, i32* %16
%61 = load i32, i32* %9
%62 = sext i32 %61 to i64
%63 = getelementptr inbounds %struct.TYPE_3__, %struct.TYPE_3__* %22, i64 %62
%64 = getelementptr inbounds %struct.TYPE_3__, %struct.TYPE_3__* %63, i32 0, i32 1
%65 = load i32, i32* %64
%66 = sext i32 %65 to i64
%67 = load i8*, i8** %7
%68 = load i8*, i8** %5
%69 = ptrtoint i8* %67 to i64
%70 = ptrtoint i8* %68 to i64
%71 = sub i64 %69, %70
%72 = add nsw i64 %66, %71
%73 = trunc i64 %72 to i32
store i32 %73, i32* %17
store i32 0, i32* %10
%74 = load i32, i32* %9
%75 = sext i32 %74 to i64
%76 = getelementptr inbounds %struct.TYPE_3__, %struct.TYPE_3__* %22, i64 %75
%77 = getelementptr inbounds %struct.TYPE_3__, %struct.TYPE_3__* %76, i32 0, i32 0
%78 = load i32, i32* %77
store i32 %78, i32* %11
br label %79
79: ; preds = %99, %47
%80 = load i32, i32* %11
%81 = load i32, i32* %9
%82 = sext i32 %81 to i64
%83 = getelementptr inbounds %struct.TYPE_3__, %struct.TYPE_3__* %22, i64 %82
%84 = getelementptr inbounds %struct.TYPE_3__, %struct.TYPE_3__* %83, i32 0, i32 1
%85 = load i32, i32* %84
%86 = icmp slt i32 %80, %85
br i1 %86, label %87, label %102
87: ; preds = %79
%88 = load i8*, i8** %5
%89 = load i32, i32* %11
%90 = sext i32 %89 to i64
%91 = getelementptr inbounds i8, i8* %88, i64 %90
%92 = load i8, i8* %91
%93 = load i8*, i8** %6
%94 = load i32, i32* %10
%95 = sext i32 %94 to i64
%96 = getelementptr inbounds i8, i8* %93, i64 %95
store i8 %92, i8* %96
%97 = load i32, i32* %10
%98 = add nsw i32 %97, 1
store i32 %98, i32* %10
br label %99
99: ; preds = %87
%100 = load i32, i32* %11
%101 = add nsw i32 %100, 1
store i32 %101, i32* %11
br label %79
102: ; preds = %79
%103 = load i8*, i8** %6
%104 = load i32, i32* %10
%105 = sext i32 %104 to i64
%106 = getelementptr inbounds i8, i8* %103, i64 %105
store i8 0, i8* %106
br label %107
107: ; preds = %102
%108 = load i32, i32* %9
%109 = add nsw i32 %108, 1
store i32 %109, i32* %9
br label %35
110: ; preds = %46, %35
%111 = getelementptr inbounds %struct.TYPE_3__, %struct.TYPE_3__* %22, i64 0
%112 = getelementptr inbounds %struct.TYPE_3__, %struct.TYPE_3__* %111, i32 0, i32 1
%113 = load i32, i32* %112
%114 = load i8*, i8** %7
%115 = sext i32 %113 to i64
%116 = getelementptr inbounds i8, i8* %114, i64 %115
store i8* %116, i8** %7
br label %23
117: ; preds = %31
%118 = load i8*, i8** %12
ret void
}

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