#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 */
void *length(char *);
long replace(char *str, char *str2, char *s, char *t) {
  int ls, lt, c;
  long a, b, fl, f, e, m;
  ls = length(s);
  lt = length(t);
  fl = length(str);
  c = 0;
  f = 0;
  e = 0;
  for (a = 0; a <= fl - ls; a++) {
    b = 0;
    while (*(str + a + b) == *(s + b) && b < ls)
      b++;
    if (b == ls) {
      c++;
      for (m = f; m < a; m++)
        *(str2 + e + m - f) = *(str + m);
      e += a - f;
      for (m = 0; m < lt; m++)
        *(str2 + e + m) = *(t + m);
      e += lt;
      f = a + ls;
      a += ls - 1;
    }
  }
  for (m = f; m <= fl; m++)
    *(str2 + e + m - f) = *(str + m);
  return c;
}


x86 assembly (clang, -O0):
<replace>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    -0x18(%rbp),%rdi
call   1030 <length@plt>
mov    %eax,-0x24(%rbp)
mov    -0x20(%rbp),%rdi
call   1030 <length@plt>
mov    %eax,-0x28(%rbp)
mov    -0x8(%rbp),%rdi
call   1030 <length@plt>
mov    %rax,-0x48(%rbp)
movl   $0x0,-0x2c(%rbp)
movq   $0x0,-0x50(%rbp)
movq   $0x0,-0x58(%rbp)
movq   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%rax
mov    -0x48(%rbp),%rcx
movslq -0x24(%rbp),%rdx
sub    %rdx,%rcx
cmp    %rcx,%rax
jg     12dd <replace+0x1cd>
movq   $0x0,-0x40(%rbp)
mov    -0x8(%rbp),%rax
add    -0x38(%rbp),%rax
mov    -0x40(%rbp),%rcx
movsbl (%rax,%rcx,1),%ecx
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%rdx
movsbl (%rax,%rdx,1),%edx
xor    %eax,%eax
cmp    %edx,%ecx
mov    %al,-0x61(%rbp)
jne    11c6 <replace+0xb6>
mov    -0x40(%rbp),%rax
movslq -0x24(%rbp),%rcx
cmp    %rcx,%rax
setl   %al
mov    %al,-0x61(%rbp)
mov    -0x61(%rbp),%al
test   $0x1,%al
jne    11d6 <replace+0xc6>
jmp    11e7 <replace+0xd7>
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    118c <replace+0x7c>
mov    -0x40(%rbp),%rax
movslq -0x24(%rbp),%rcx
cmp    %rcx,%rax
jne    12c7 <replace+0x1b7>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x50(%rbp),%rax
mov    %rax,-0x60(%rbp)
mov    -0x60(%rbp),%rax
cmp    -0x38(%rbp),%rax
jge    1248 <replace+0x138>
mov    -0x8(%rbp),%rax
mov    -0x60(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x10(%rbp),%rax
add    -0x58(%rbp),%rax
add    -0x60(%rbp),%rax
xor    %ecx,%ecx
sub    -0x50(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x60(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x60(%rbp)
jmp    1209 <replace+0xf9>
mov    -0x38(%rbp),%rax
sub    -0x50(%rbp),%rax
add    -0x58(%rbp),%rax
mov    %rax,-0x58(%rbp)
movq   $0x0,-0x60(%rbp)
mov    -0x60(%rbp),%rax
movslq -0x28(%rbp),%rcx
cmp    %rcx,%rax
jge    129c <replace+0x18c>
mov    -0x20(%rbp),%rax
mov    -0x60(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x10(%rbp),%rax
add    -0x58(%rbp),%rax
mov    -0x60(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x60(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x60(%rbp)
jmp    1260 <replace+0x150>
movslq -0x28(%rbp),%rax
add    -0x58(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x38(%rbp),%rax
movslq -0x24(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
mov    -0x24(%rbp),%eax
sub    $0x1,%eax
cltq
add    -0x38(%rbp),%rax
mov    %rax,-0x38(%rbp)
jmp    12cc <replace+0x1bc>
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    116c <replace+0x5c>
mov    -0x50(%rbp),%rax
mov    %rax,-0x60(%rbp)
mov    -0x60(%rbp),%rax
cmp    -0x48(%rbp),%rax
jg     1324 <replace+0x214>
mov    -0x8(%rbp),%rax
mov    -0x60(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x10(%rbp),%rax
add    -0x58(%rbp),%rax
add    -0x60(%rbp),%rax
xor    %ecx,%ecx
sub    -0x50(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x60(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x60(%rbp)
jmp    12e5 <replace+0x1d5>
movslq -0x2c(%rbp),%rax
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<replace>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xd8,%rsp
mov    %rcx,%r13
mov    %rdx,%rbx
mov    %rsi,%r14
mov    %rdi,%r12
mov    %rdx,%rdi
call   1030 <length@plt>
mov    %rax,%r15
mov    %r13,%rdi
call   1030 <length@plt>
mov    %rax,%rbp
mov    %r12,%rdi
call   1030 <length@plt>
movslq %r15d,%rdi
mov    %rax,%r10
sub    %rdi,%r10
mov    %r14,0x8(%rsp)
mov    %rax,0x88(%rsp)
js     1779 <replace+0x669>
mov    %rbp,%rax
shl    $0x20,%r15
shl    $0x20,%rbp
mov    %rbp,0xc8(%rsp)
cltq
movabs $0xffffffff00000000,%rcx
ff ff ff
add    %r15,%rcx
sar    $0x20,%rcx
mov    %rcx,0xb0(%rsp)
cmp    $0x2,%rax
mov    $0x1,%r15d
mov    %rax,0xb8(%rsp)
cmovge %rax,%r15
lea    (%r14,%r15,1),%rax
mov    %rax,0x90(%rsp)
lea    0x0(%r13,%r15,1),%rax
mov    %rax,0xa0(%rsp)
movabs $0x7fffffffffffffe0,%rax
ff ff 7f
mov    %r15,%rcx
and    %rax,%rcx
mov    %rcx,0x38(%rsp)
add    $0xffffffffffffffe0,%rcx
mov    %rcx,0x80(%rsp)
shr    $0x5,%rcx
add    $0x1,%rcx
mov    %ecx,%edx
and    $0x3,%edx
and    $0xfffffffffffffffc,%rcx
mov    %rcx,0x60(%rsp)
or     $0x18,%rax
and    %r15,%rax
mov    %rax,0x40(%rsp)
mov    %r15,0x10(%rsp)
and    $0x3,%r15d
lea    0x1(%rdi),%rbp
lea    0x70(%r14),%rax
mov    %rax,0x20(%rsp)
mov    %rdx,0x78(%rsp)
shl    $0x5,%rdx
mov    %rdx,0x28(%rsp)
lea    0x70(%r12),%rax
mov    %rax,0x50(%rsp)
lea    0x10(%r14),%rax
mov    %rax,0x30(%rsp)
lea    0x10(%r12),%rax
mov    %rax,0x58(%rsp)
lea    0x3(%r14),%rax
mov    %rax,0x48(%rsp)
lea    0x10(%r13),%rax
mov    %rax,0x68(%rsp)
mov    %r13,0x18(%rsp)
lea    0x3(%r13),%rax
mov    %rax,0x98(%rsp)
xor    %r9d,%r9d
xor    %eax,%eax
mov    %rax,(%rsp)
xor    %r8d,%r8d
xor    %r13d,%r13d
mov    %r10,0xc0(%rsp)
mov    %rbp,0xa8(%rsp)
jmp    12cf <replace+0x1bf>
nopl   0x0(%rax)
mov    0xd0(%rsp),%r8
add    $0x1,%r8d
add    0xb8(%rsp),%r11
lea    (%rdi,%r13,1),%rax
mov    %rax,(%rsp)
add    0xb0(%rsp),%r13
mov    %r11,%r9
mov    0xa8(%rsp),%rbp
lea    0x1(%r13),%rax
cmp    %r10,%r13
mov    %rax,%r13
jge    1785 <replace+0x675>
lea    (%r12,%r13,1),%rax
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nop
movzbl (%rax,%rcx,1),%edx
lea    0x1(%rcx),%rsi
cmp    (%rbx,%rcx,1),%dl
jne    12f5 <replace+0x1e5>
cmp    %rdi,%rcx
mov    %rsi,%rcx
jl     12e0 <replace+0x1d0>
cmp    %rsi,%rbp
jne    12bf <replace+0x1af>
mov    %r8,0xd0(%rsp)
mov    %r13,%r11
mov    (%rsp),%r8
sub    %r8,%r11
jle    152f <replace+0x41f>
mov    0x8(%rsp),%rcx
lea    (%rcx,%r9,1),%r14
mov    %r8,%rsi
cmp    $0x8,%r11
jb     14b0 <replace+0x3a0>
lea    (%r12,%r8,1),%rdx
cmp    %rax,%r14
jae    1349 <replace+0x239>
lea    (%r9,%r13,1),%rax
sub    %r8,%rax
add    0x8(%rsp),%rax
mov    %r8,%rsi
cmp    %rax,%rdx
jb     14b0 <replace+0x3a0>
cmp    $0x20,%r11
jae    1357 <replace+0x247>
xor    %r10d,%r10d
jmp    146a <replace+0x35a>
mov    %r8,(%rsp)
mov    %r11,%r10
and    $0xffffffffffffffe0,%r10
lea    -0x20(%r10),%rax
mov    %rax,%rsi
shr    $0x5,%rsi
add    $0x1,%rsi
mov    %esi,%ecx
and    $0x3,%ecx
mov    %rcx,0x70(%rsp)
cmp    $0x60,%rax
jae    1388 <replace+0x278>
xor    %ecx,%ecx
jmp    1410 <replace+0x300>
movabs $0xffffffffffffffc,%rax
ff ff 0f
and    %rax,%rsi
mov    0x20(%rsp),%rax
lea    (%rax,%r9,1),%r8
mov    0x50(%rsp),%rax
mov    (%rsp),%rcx
add    %rcx,%rax
xor    %ecx,%ecx
nopl   0x0(%rax)
movups -0x70(%rax,%rcx,1),%xmm0
movups -0x60(%rax,%rcx,1),%xmm1
movups %xmm0,-0x70(%r8,%rcx,1)
movups %xmm1,-0x60(%r8,%rcx,1)
movups -0x50(%rax,%rcx,1),%xmm0
movups -0x40(%rax,%rcx,1),%xmm1
movups %xmm0,-0x50(%r8,%rcx,1)
movups %xmm1,-0x40(%r8,%rcx,1)
movups -0x30(%rax,%rcx,1),%xmm0
movups -0x20(%rax,%rcx,1),%xmm1
movups %xmm0,-0x30(%r8,%rcx,1)
movups %xmm1,-0x20(%r8,%rcx,1)
movups -0x10(%rax,%rcx,1),%xmm0
movups (%rax,%rcx,1),%xmm1
movups %xmm0,-0x10(%r8,%rcx,1)
movups %xmm1,(%r8,%rcx,1)
sub    $0xffffffffffffff80,%rcx
add    $0xfffffffffffffffc,%rsi
jne    13b0 <replace+0x2a0>
mov    0x70(%rsp),%rbp
test   %rbp,%rbp
mov    (%rsp),%r8
je     145b <replace+0x34b>
lea    (%r9,%rcx,1),%rax
add    0x30(%rsp),%rax
add    %r8,%rcx
add    0x58(%rsp),%rcx
shl    $0x5,%rbp
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nop
movups -0x10(%rcx,%rsi,1),%xmm0
movups (%rcx,%rsi,1),%xmm1
movups %xmm0,-0x10(%rax,%rsi,1)
movups %xmm1,(%rax,%rsi,1)
add    $0x20,%rsi
cmp    %rsi,%rbp
jne    1440 <replace+0x330>
cmp    %r10,%r11
je     152f <replace+0x41f>
test   $0x18,%r11b
je     149b <replace+0x38b>
mov    %r11,%rax
and    $0xfffffffffffffff8,%rax
lea    (%r8,%rax,1),%rsi
cs nopw 0x0(%rax,%rax,1)
nop
mov    (%rdx,%r10,1),%rcx
mov    %rcx,(%r14,%r10,1)
add    $0x8,%r10
cmp    %r10,%rax
jne    1480 <replace+0x370>
cmp    %rax,%r11
jne    14b0 <replace+0x3a0>
jmp    152f <replace+0x41f>
add    %r8,%r10
mov    %r10,%rsi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %r13d,%ecx
sub    %esi,%ecx
mov    %rsi,%rax
not    %rax
add    %r13,%rax
and    $0x3,%rcx
je     14e3 <replace+0x3d3>
sub    %r8,%r14
nopw   0x0(%rax,%rax,1)
movzbl (%r12,%rsi,1),%edx
mov    %dl,(%r14,%rsi,1)
add    $0x1,%rsi
add    $0xffffffffffffffff,%rcx
jne    14d0 <replace+0x3c0>
cmp    $0x3,%rax
jb     152f <replace+0x41f>
mov    %r9,%rax
sub    %r8,%rax
add    0x48(%rsp),%rax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movzbl (%r12,%rsi,1),%ecx
mov    %cl,-0x3(%rax,%rsi,1)
movzbl 0x1(%r12,%rsi,1),%ecx
mov    %cl,-0x2(%rax,%rsi,1)
movzbl 0x2(%r12,%rsi,1),%ecx
mov    %cl,-0x1(%rax,%rsi,1)
movzbl 0x3(%r12,%rsi,1),%ecx
mov    %cl,(%rax,%rsi,1)
add    $0x4,%rsi
cmp    %rsi,%r13
jne    1500 <replace+0x3f0>
add    %r9,%r11
cmpq   $0x0,0xc8(%rsp)
mov    0xc0(%rsp),%r10
jle    1290 <replace+0x180>
cmpq   $0x8,0x10(%rsp)
jb     1580 <replace+0x470>
mov    0x8(%rsp),%rax
add    %r11,%rax
cmp    0xa0(%rsp),%rax
mov    0x18(%rsp),%rbp
jae    1634 <replace+0x524>
mov    0x90(%rsp),%rax
add    %r11,%rax
cmp    %rbp,%rax
jbe    1634 <replace+0x524>
xor    %esi,%esi
mov    %rsi,%r8
not    %r8
add    0x10(%rsp),%r8
test   %r15,%r15
je     15cb <replace+0x4bb>
mov    %rsi,%rcx
neg    %rcx
lea    (%rsi,%r9,1),%rbp
add    %r13,%rbp
sub    (%rsp),%rbp
add    0x8(%rsp),%rbp
add    0x18(%rsp),%rsi
xor    %eax,%eax
nop
movzbl (%rsi,%rax,1),%edx
mov    %dl,0x0(%rbp,%rax,1)
add    $0x1,%rax
add    $0xffffffffffffffff,%rcx
cmp    %rax,%r15
jne    15b0 <replace+0x4a0>
neg    %rcx
mov    %rcx,%rsi
cmp    $0x3,%r8
jb     1290 <replace+0x180>
mov    0x10(%rsp),%rax
sub    %rsi,%rax
add    %rsi,%r9
add    %r13,%r9
sub    (%rsp),%r9
add    0x48(%rsp),%r9
add    0x98(%rsp),%rsi
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
movzbl -0x3(%rsi,%rcx,1),%edx
mov    %dl,-0x3(%r9,%rcx,1)
movzbl -0x2(%rsi,%rcx,1),%edx
mov    %dl,-0x2(%r9,%rcx,1)
movzbl -0x1(%rsi,%rcx,1),%edx
mov    %dl,-0x1(%r9,%rcx,1)
movzbl (%rsi,%rcx,1),%edx
mov    %dl,(%r9,%rcx,1)
add    $0x4,%rcx
cmp    %rcx,%rax
jne    1600 <replace+0x4f0>
jmp    1290 <replace+0x180>
cmpq   $0x20,0x10(%rsp)
jae    1643 <replace+0x533>
xor    %ebp,%ebp
jmp    172e <replace+0x61e>
cmpq   $0x60,0x80(%rsp)
mov    (%rsp),%r8
jae    165b <replace+0x54b>
xor    %ecx,%ecx
mov    0x28(%rsp),%rdx
jmp    16c9 <replace+0x5b9>
mov    0x20(%rsp),%rax
add    %r11,%rax
mov    0x60(%rsp),%rsi
xor    %ecx,%ecx
mov    0x28(%rsp),%rdx
nop
movups 0x0(%rbp,%rcx,1),%xmm0
movups 0x10(%rbp,%rcx,1),%xmm1
movups %xmm0,-0x70(%rax,%rcx,1)
movups %xmm1,-0x60(%rax,%rcx,1)
movups 0x20(%rbp,%rcx,1),%xmm0
movups 0x30(%rbp,%rcx,1),%xmm1
movups %xmm0,-0x50(%rax,%rcx,1)
movups %xmm1,-0x40(%rax,%rcx,1)
movups 0x40(%rbp,%rcx,1),%xmm0
movups 0x50(%rbp,%rcx,1),%xmm1
movups %xmm0,-0x30(%rax,%rcx,1)
movups %xmm1,-0x20(%rax,%rcx,1)
movups 0x60(%rbp,%rcx,1),%xmm0
movups 0x70(%rbp,%rcx,1),%xmm1
movups %xmm0,-0x10(%rax,%rcx,1)
movups %xmm1,(%rax,%rcx,1)
sub    $0xffffffffffffff80,%rcx
add    $0xfffffffffffffffc,%rsi
jne    1670 <replace+0x560>
cmpq   $0x0,0x78(%rsp)
je     170b <replace+0x5fb>
lea    (%r9,%rcx,1),%rax
add    %r13,%rax
sub    %r8,%rax
add    0x30(%rsp),%rax
add    0x68(%rsp),%rcx
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
movups -0x10(%rcx,%rsi,1),%xmm0
movups (%rcx,%rsi,1),%xmm1
movups %xmm0,-0x10(%rax,%rsi,1)
movups %xmm1,(%rax,%rsi,1)
add    $0x20,%rsi
cmp    %rsi,%rdx
jne    16f0 <replace+0x5e0>
mov    0x38(%rsp),%rax
cmp    %rax,0x10(%rsp)
je     1290 <replace+0x180>
mov    0x38(%rsp),%rsi
mov    %rsi,%rbp
testb  $0x18,0x10(%rsp)
je     1582 <replace+0x472>
mov    0x18(%rsp),%rax
add    %rbp,%rax
lea    (%r9,%rbp,1),%rcx
add    %r13,%rcx
sub    (%rsp),%rcx
add    0x8(%rsp),%rcx
mov    0x40(%rsp),%rsi
sub    %rbp,%rsi
xor    %ebp,%ebp
mov    (%rax,%rbp,1),%rdx
mov    %rdx,(%rcx,%rbp,1)
add    $0x8,%rbp
cmp    %rbp,%rsi
jne    1750 <replace+0x640>
mov    0x40(%rsp),%rax
mov    %rax,%rsi
cmp    %rax,0x10(%rsp)
je     1290 <replace+0x180>
jmp    1582 <replace+0x472>
xor    %r8d,%r8d
xor    %eax,%eax
mov    %rax,(%rsp)
xor    %r9d,%r9d
mov    0x88(%rsp),%rdx
mov    (%rsp),%rdi
cmp    %rdx,%rdi
jg     199f <replace+0x88f>
mov    0x8(%rsp),%rax
add    %r9,%rax
mov    %rdx,%r11
sub    %rdi,%r11
add    $0x1,%r11
mov    %rdi,%rsi
cmp    $0x8,%r11
jb     1925 <replace+0x815>
lea    (%r12,%rdi,1),%r10
lea    (%rdx,%r12,1),%rcx
add    $0x1,%rcx
cmp    %rcx,%rax
jae    17e9 <replace+0x6d9>
lea    (%r9,%rdx,1),%rcx
sub    %rdi,%rcx
mov    0x8(%rsp),%rsi
add    %rsi,%rcx
add    $0x1,%rcx
mov    %rdi,%rsi
cmp    %rcx,%r10
jb     1925 <replace+0x815>
mov    %r8,%r15
cmp    $0x20,%r11
jae    17f9 <replace+0x6e9>
xor    %ecx,%ecx
jmp    18ed <replace+0x7dd>
mov    %r11,%rcx
and    $0xffffffffffffffe0,%rcx
lea    -0x20(%rcx),%rdi
mov    %rdi,%rsi
shr    $0x5,%rsi
add    $0x1,%rsi
mov    %esi,%r14d
and    $0x3,%r14d
cmp    $0x60,%rdi
jae    1820 <replace+0x710>
xor    %ebx,%ebx
jmp    1899 <replace+0x789>
and    $0xfffffffffffffffc,%rsi
mov    0x8(%rsp),%rdi
add    %r9,%rdi
add    $0x70,%rdi
mov    (%rsp),%rbx
lea    (%rbx,%r12,1),%rbp
add    $0x70,%rbp
xor    %ebx,%ebx
xchg   %ax,%ax
movups -0x70(%rbp,%rbx,1),%xmm0
movups -0x60(%rbp,%rbx,1),%xmm1
movups %xmm0,-0x70(%rdi,%rbx,1)
movups %xmm1,-0x60(%rdi,%rbx,1)
movups -0x50(%rbp,%rbx,1),%xmm0
movups -0x40(%rbp,%rbx,1),%xmm1
movups %xmm0,-0x50(%rdi,%rbx,1)
movups %xmm1,-0x40(%rdi,%rbx,1)
movups -0x30(%rbp,%rbx,1),%xmm0
movups -0x20(%rbp,%rbx,1),%xmm1
movups %xmm0,-0x30(%rdi,%rbx,1)
movups %xmm1,-0x20(%rdi,%rbx,1)
movups -0x10(%rbp,%rbx,1),%xmm0
movups 0x0(%rbp,%rbx,1),%xmm1
movups %xmm0,-0x10(%rdi,%rbx,1)
movups %xmm1,(%rdi,%rbx,1)
sub    $0xffffffffffffff80,%rbx
add    $0xfffffffffffffffc,%rsi
jne    1840 <replace+0x730>
test   %r14,%r14
je     18db <replace+0x7cb>
lea    (%r9,%rbx,1),%rsi
mov    0x8(%rsp),%rdi
add    %rdi,%rsi
add    $0x10,%rsi
add    (%rsp),%rbx
lea    (%r12,%rbx,1),%rdi
add    $0x10,%rdi
shl    $0x5,%r14
xor    %ebp,%ebp
movups -0x10(%rdi,%rbp,1),%xmm0
movups (%rdi,%rbp,1),%xmm1
movups %xmm0,-0x10(%rsi,%rbp,1)
movups %xmm1,(%rsi,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%r14
jne    18c0 <replace+0x7b0>
cmp    %rcx,%r11
mov    %r15,%r8
je     199f <replace+0x88f>
test   $0x18,%r11b
je     191e <replace+0x80e>
mov    %r11,%rdi
and    $0xfffffffffffffff8,%rdi
mov    (%rsp),%rsi
add    %rdi,%rsi
nopl   0x0(%rax,%rax,1)
mov    (%r10,%rcx,1),%rbp
mov    %rbp,(%rax,%rcx,1)
add    $0x8,%rcx
cmp    %rcx,%rdi
jne    1900 <replace+0x7f0>
cmp    %rdi,%r11
mov    %r15,%r8
jne    1925 <replace+0x815>
jmp    199f <replace+0x88f>
add    (%rsp),%rcx
mov    %rcx,%rsi
lea    0x1(%rdx),%rcx
mov    %ecx,%edi
sub    %esi,%edi
sub    %rsi,%rdx
and    $0x3,%rdi
je     1952 <replace+0x842>
sub    (%rsp),%rax
nopw   0x0(%rax,%rax,1)
movzbl (%r12,%rsi,1),%ebx
mov    %bl,(%rax,%rsi,1)
add    $0x1,%rsi
add    $0xffffffffffffffff,%rdi
jne    1940 <replace+0x830>
cmp    $0x3,%rdx
mov    (%rsp),%rax
jb     199f <replace+0x88f>
sub    %rax,%r9
mov    0x8(%rsp),%rax
add    %r9,%rax
add    $0x3,%rax
nopl   0x0(%rax,%rax,1)
movzbl (%r12,%rsi,1),%edx
mov    %dl,-0x3(%rax,%rsi,1)
movzbl 0x1(%r12,%rsi,1),%edx
mov    %dl,-0x2(%rax,%rsi,1)
movzbl 0x2(%r12,%rsi,1),%edx
mov    %dl,-0x1(%rax,%rsi,1)
movzbl 0x3(%r12,%rsi,1),%edx
mov    %dl,(%rax,%rsi,1)
add    $0x4,%rsi
cmp    %rsi,%rcx
jne    1970 <replace+0x860>
movslq %r8d,%rax
add    $0xd8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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