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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int strlen(char *);
void reverseWords(char *s) {
  int len = strlen(s);
  int count = 0;
  while (s[count] == ' ')
    count++;
  for (int i = count; i < len + 1; i++)
    s[i - count] = s[i];
  len -= count;
  while (s[len - 1] == ' ')
    len--;
  s[len] = '\0';
  int index = 0;
  count = 0;
  for (int i = 0; i < len; i++) {
    if (s[i] != ' ') {
      s[index++] = s[i];
      count = 0;
    } else {
      if (!count)
        s[index++] = s[i];
      count++;
    }
  }
  s[index] = '\0';
  len = index;
  for (int i = 0; i < len / 2; i++) {
    char c = s[i];
    s[i] = s[len - i - 1];
    s[len - i - 1] = c;
  }
  int begin = 0, end = 0;
  for (int i = 0; i < len; i++) {
    if (s[i] == ' ' || i == len - 1) {
      end = i;
      if (i != len - 1)
        end--;
      int size = end - begin + 1;
      for (int j = 0; j < size / 2; j++) {
        char c = s[begin + j];
        s[begin + j] = s[end - j];
        s[end - j] = c;
      }
      begin = end + 2;
    }
  }
}


x86 assembly (clang, -O0):
<reverseWords>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x8(%rbp)
mov    -0x8(%rbp),%rdi
call   1030 <strlen@plt>
mov    %eax,-0xc(%rbp)
movl   $0x0,-0x10(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x10(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x20,%eax
jne    1152 <reverseWords+0x42>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    112f <reverseWords+0x1f>
mov    -0x10(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
mov    -0xc(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1192 <reverseWords+0x82>
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    -0x10(%rbp),%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1158 <reverseWords+0x48>
mov    -0x10(%rbp),%ecx
mov    -0xc(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0xc(%rbp)
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x20,%eax
jne    11c5 <reverseWords+0xb5>
mov    -0xc(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xc(%rbp)
jmp    119d <reverseWords+0x8d>
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
movl   $0x0,-0x18(%rbp)
movl   $0x0,-0x10(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1279 <reverseWords+0x169>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x20,%eax
je     1233 <reverseWords+0x123>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x18(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
movl   $0x0,-0x10(%rbp)
jmp    1266 <reverseWords+0x156>
cmpl   $0x0,-0x10(%rbp)
jne    125d <reverseWords+0x14d>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x18(%rbp)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    126b <reverseWords+0x15b>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    11e6 <reverseWords+0xd6>
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x18(%rbp),%eax
mov    %eax,-0xc(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0xc(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x40(%rbp),%eax
cmp    %ecx,%eax
jge    1300 <reverseWords+0x1f0>
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x21(%rbp)
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
sub    -0x20(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x21(%rbp),%dl
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
sub    -0x20(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1292 <reverseWords+0x182>
movl   $0x0,-0x28(%rbp)
movl   $0x0,-0x2c(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1408 <reverseWords+0x2f8>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x20,%eax
je     1347 <reverseWords+0x237>
mov    -0x30(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    13f5 <reverseWords+0x2e5>
mov    -0x30(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x30(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
je     1367 <reverseWords+0x257>
mov    -0x2c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
sub    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x34(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x44(%rbp),%eax
cmp    %ecx,%eax
jge    13ec <reverseWords+0x2dc>
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x39(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    -0x38(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x8(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x39(%rbp),%dl
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    -0x38(%rbp),%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    137a <reverseWords+0x26a>
mov    -0x2c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x28(%rbp)
jmp    13fa <reverseWords+0x2ea>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1315 <reverseWords+0x205>
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<reverseWords>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %rdi,%r13
movabs $0xffffffff00000000,%r14
ff ff ff
movabs $0x100000000,%r15
call   1030 <strlen@plt>
xor    %edx,%edx
mov    %r14,%rcx
nopl   0x0(%rax)
add    %r15,%rcx
cmpb   $0x20,0x0(%r13,%rdx,1)
lea    0x1(%rdx),%rdx
je     1140 <reverseWords+0x30>
lea    -0x1(%rdx),%r11
cmp    %r11d,%eax
jl     138a <reverseWords+0x27a>
sar    $0x20,%rcx
mov    %eax,%esi
sub    %rdx,%rsi
add    $0x1,%rsi
cmp    $0x7,%esi
jb     12f4 <reverseWords+0x1e4>
cmp    %r11d,%eax
jb     12f4 <reverseWords+0x1e4>
mov    %eax,%edi
sub    %edx,%edi
add    $0x1,%edi
mov    %r11d,%ebp
lea    (%rdi,%rbp,1),%rbx
add    %r13,%rbx
add    $0x1,%rbx
cmp    %r13,%rbx
jbe    11a8 <reverseWords+0x98>
add    %r13,%rdi
add    $0x1,%rdi
add    %r13,%rbp
cmp    %rdi,%rbp
jb     12f4 <reverseWords+0x1e4>
movabs $0x1ffffffe0,%r8
cmp    $0x1f,%esi
jae    11bf <reverseWords+0xaf>
xor    %r12d,%r12d
jmp    1286 <reverseWords+0x176>
mov    %esi,%r9d
add    $0x1,%r9
mov    %r9,%r12
and    %r8,%r12
lea    -0x20(%r12),%rsi
mov    %rsi,%r10
shr    $0x5,%r10
add    $0x1,%r10
test   %rsi,%rsi
je     12e3 <reverseWords+0x1d3>
lea    0x1f(%rdx),%rsi
mov    %eax,%edi
sub    %edx,%edi
add    $0x1,%edi
add    $0x1,%rdi
and    $0xffffffffffffffe0,%rdi
add    $0xffffffffffffffe0,%rdi
shr    $0x5,%rdi
add    $0x1,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
lea    -0x20(%rsi),%ebx
movups 0x0(%r13,%rbx,1),%xmm0
movups 0x10(%r13,%rbx,1),%xmm1
movups %xmm0,0x0(%r13,%rbp,1)
movups %xmm1,0x10(%r13,%rbp,1)
mov    %esi,%ebx
movups 0x0(%r13,%rbx,1),%xmm0
movups 0x10(%r13,%rbx,1),%xmm1
movups %xmm0,0x20(%r13,%rbp,1)
movups %xmm1,0x30(%r13,%rbp,1)
add    $0x40,%rbp
add    $0x40,%rsi
add    $0xfffffffffffffffe,%rdi
jne    1210 <reverseWords+0x100>
test   $0x1,%r10b
je     1277 <reverseWords+0x167>
lea    (%rdx,%rbp,1),%esi
add    $0xffffffff,%esi
movups 0x0(%r13,%rsi,1),%xmm0
movups 0x10(%r13,%rsi,1),%xmm1
movups %xmm0,0x0(%r13,%rbp,1)
movups %xmm1,0x10(%r13,%rbp,1)
cmp    %r12,%r9
je     138a <reverseWords+0x27a>
test   $0x18,%r9b
je     12f1 <reverseWords+0x1e1>
mov    %eax,%r9d
sub    %edx,%r9d
add    $0x1,%r9d
add    $0x1,%r9
add    $0x18,%r8
and    %r9,%r8
add    %r8,%rcx
lea    (%r12,%r13,1),%rdi
mov    %r9,%rsi
and    $0xfffffffffffffff8,%rsi
sub    %r12,%rsi
add    %rdx,%r12
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
lea    (%r12,%rbx,1),%ebp
add    $0xffffffff,%ebp
mov    0x0(%r13,%rbp,1),%rbp
mov    %rbp,(%rdi,%rbx,1)
add    $0x8,%rbx
cmp    %rbx,%rsi
jne    12c0 <reverseWords+0x1b0>
cmp    %r8,%r9
jne    12f4 <reverseWords+0x1e4>
jmp    138a <reverseWords+0x27a>
xor    %ebp,%ebp
test   $0x1,%r10b
jne    1259 <reverseWords+0x149>
jmp    1277 <reverseWords+0x167>
add    %r12,%rcx
lea    0x1(%rax),%r8d
mov    %r8d,%esi
sub    %ecx,%esi
mov    %eax,%r9d
sub    %ecx,%r9d
and    $0x3,%esi
je     1334 <reverseWords+0x224>
movslq %r11d,%rbp
mov    %r13,%rdi
sub    %rbp,%rdi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %ecx,%ebp
movzbl 0x0(%r13,%rbp,1),%ebx
mov    %bl,(%rdi,%rcx,1)
add    $0x1,%rcx
add    $0xffffffff,%esi
jne    1320 <reverseWords+0x210>
cmp    $0x3,%r9d
jb     138a <reverseWords+0x27a>
mov    %r8d,%esi
movslq %r11d,%rbp
mov    %r13,%rdi
sub    %rbp,%rdi
add    $0x3,%rdi
nopw   0x0(%rax,%rax,1)
mov    %ecx,%ebp
movzbl 0x0(%r13,%rbp,1),%ebx
mov    %bl,-0x3(%rdi,%rcx,1)
lea    0x1(%rcx),%ebp
movzbl 0x0(%r13,%rbp,1),%ebx
mov    %bl,-0x2(%rdi,%rcx,1)
lea    0x2(%rcx),%ebp
movzbl 0x0(%r13,%rbp,1),%ebx
mov    %bl,-0x1(%rdi,%rcx,1)
lea    0x3(%rcx),%ebp
movzbl 0x0(%r13,%rbp,1),%ebx
mov    %bl,(%rdi,%rcx,1)
add    $0x4,%rcx
cmp    %ecx,%esi
jne    1350 <reverseWords+0x240>
sub    %edx,%eax
lea    0x2(%rax),%ecx
add    $0x1,%eax
cltq
lea    (%rax,%r13,1),%rdx
add    $0xffffffffffffffff,%rdx
shl    $0x20,%rax
add    %r15,%rax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0xffffffff,%ecx
add    %r14,%rax
cmpb   $0x20,(%rdx)
lea    -0x1(%rdx),%rdx
je     13b0 <reverseWords+0x2a0>
sar    $0x20,%rax
movb   $0x0,0x0(%r13,%rax,1)
test   %ecx,%ecx
jle    1438 <reverseWords+0x328>
mov    %ecx,%eax
xor    %edx,%edx
xor    %esi,%esi
xor    %ecx,%ecx
jmp    13f6 <reverseWords+0x2e6>
nopw   0x0(%rax,%rax,1)
movslq %ecx,%rsi
add    $0x1,%ecx
mov    %bl,0x0(%r13,%rsi,1)
xor    %esi,%esi
add    $0x1,%rdx
cmp    %rdx,%rax
je     1416 <reverseWords+0x306>
movzbl 0x0(%r13,%rdx,1),%ebx
cmp    $0x20,%bl
jne    13e0 <reverseWords+0x2d0>
test   %esi,%esi
jne    1411 <reverseWords+0x301>
movslq %ecx,%rdi
add    $0x1,%ecx
movb   $0x20,0x0(%r13,%rdi,1)
add    $0x1,%esi
jmp    13ed <reverseWords+0x2dd>
movslq %ecx,%rax
movb   $0x0,0x0(%r13,%rax,1)
cmp    $0x2,%eax
jl     14b4 <reverseWords+0x3a4>
mov    %ecx,%r8d
shr    %r8d
cmp    $0x1,%r8d
jne    1442 <reverseWords+0x332>
xor    %edx,%edx
jmp    1491 <reverseWords+0x381>
movb   $0x0,0x0(%r13)
jmp    15ba <reverseWords+0x4aa>
mov    %r8d,%esi
and    $0xfffffffe,%esi
lea    -0x2(%rcx),%edi
xor    %edx,%edx
nopl   (%rax)
movzbl 0x0(%r13,%rdx,1),%ebx
lea    0x1(%rdi),%ebp
movslq %ebp,%rbp
movzbl 0x0(%r13,%rbp,1),%eax
mov    %al,0x0(%r13,%rdx,1)
mov    %bl,0x0(%r13,%rbp,1)
movzbl 0x1(%r13,%rdx,1),%eax
movslq %edi,%rdi
movzbl 0x0(%r13,%rdi,1),%ebx
mov    %bl,0x1(%r13,%rdx,1)
mov    %al,0x0(%r13,%rdi,1)
add    $0x2,%rdx
add    $0xfffffffe,%edi
cmp    %rdx,%rsi
jne    1450 <reverseWords+0x340>
test   $0x1,%r8b
je     14b4 <reverseWords+0x3a4>
mov    0x0(%r13,%rdx,1),%al
mov    %edx,%esi
not    %esi
add    %ecx,%esi
movslq %esi,%rsi
mov    0x0(%r13,%rsi,1),%bl
mov    %bl,0x0(%r13,%rdx,1)
mov    %al,0x0(%r13,%rsi,1)
test   %ecx,%ecx
jle    15ba <reverseWords+0x4aa>
lea    -0x1(%rcx),%r10d
mov    %ecx,%r9d
lea    0x1(%r13),%rax
mov    %rax,(%rsp)
xor    %esi,%esi
mov    $0x1,%r12d
xor    %r14d,%r14d
jmp    14f8 <reverseWords+0x3e8>
nopl   0x0(%rax,%rax,1)
add    $0x2,%r15d
mov    %r15d,%r14d
add    $0x1,%rsi
add    $0x1,%r12d
cmp    %r9,%rsi
je     15ba <reverseWords+0x4aa>
cmpb   $0x20,0x0(%r13,%rsi,1)
je     1505 <reverseWords+0x3f5>
cmp    %r10,%rsi
jne    14e7 <reverseWords+0x3d7>
xor    %r8d,%r8d
cmp    %r10,%rsi
setne  %r8b
mov    %esi,%r15d
sub    %r8d,%r15d
mov    %r15d,%edi
sub    %r14d,%edi
add    $0x1,%edi
cmp    $0x2,%edi
jl     14e0 <reverseWords+0x3d0>
shr    %edi
movslq %r14d,%r11
cmp    $0x1,%edi
jne    1537 <reverseWords+0x427>
xor    %ebx,%ebx
test   $0x1,%dil
je     14e0 <reverseWords+0x3d0>
jmp    1598 <reverseWords+0x488>
neg    %r8d
mov    (%rsp),%rax
lea    (%rax,%r11,1),%rbp
lea    (%rsi,%r8,1),%edx
movslq %edx,%rdx
add    %r13,%rdx
add    %r12d,%r8d
sub    %r14d,%r8d
shr    %r8d
and    $0xfffffffe,%r8d
neg    %r8
xor    %ebx,%ebx
xchg   %ax,%ax
movzbl -0x1(%rbp),%eax
movzbl (%rdx,%rbx,1),%ecx
mov    %cl,-0x1(%rbp)
mov    %al,(%rdx,%rbx,1)
movzbl 0x0(%rbp),%eax
movzbl -0x1(%rdx,%rbx,1),%ecx
mov    %cl,0x0(%rbp)
mov    %al,-0x1(%rdx,%rbx,1)
add    $0x2,%rbp
add    $0xfffffffffffffffe,%rbx
cmp    %rbx,%r8
jne    1560 <reverseWords+0x450>
neg    %rbx
test   $0x1,%dil
je     14e0 <reverseWords+0x3d0>
movslq %r15d,%rax
add    %rbx,%r11
mov    0x0(%r13,%r11,1),%cl
sub    %rbx,%rax
mov    0x0(%r13,%rax,1),%dl
mov    %dl,0x0(%r13,%r11,1)
mov    %cl,0x0(%r13,%rax,1)
jmp    14e0 <reverseWords+0x3d0>
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define void @reverseWords(i8* %0) {
%2 = tail call i32 @strlen(i8* %0)
br label %3
3: ; preds = %3, %1
%4 = phi i64 [ %8, %3 ], [ 0, %1 ]
%5 = getelementptr inbounds i8, i8* %0, i64 %4
%6 = load i8, i8* %5
%7 = icmp eq i8 %6, 32
%8 = add nuw i64 %4, 1
br i1 %7, label %3, label %9
9: ; preds = %3
%10 = trunc i64 %4 to i32
%11 = icmp slt i32 %2, %10
br i1 %11, label %141, label %12
12: ; preds = %9
%13 = shl i64 %4, 32
%14 = ashr exact i64 %13, 32
%15 = add i32 %2, 1
%16 = sub i32 %2, %10
%17 = zext i32 %16 to i64
%18 = add nuw nsw i64 %17, 1
%19 = icmp ult i32 %16, 7
%20 = icmp ult i32 %2, %10
%21 = or i1 %19, %20
br i1 %21, label %119, label %22
22: ; preds = %12
%23 = sub i32 %2, %10
%24 = zext i32 %23 to i64
%25 = add nuw nsw i64 %24, 1
%26 = getelementptr i8, i8* %0, i64 %25
%27 = and i64 %4, 4294967295
%28 = getelementptr i8, i8* %0, i64 %27
%29 = add nuw nsw i64 %27, %24
%30 = add nuw nsw i64 %29, 1
%31 = getelementptr i8, i8* %0, i64 %30
%32 = icmp ugt i8* %31, %0
%33 = icmp ult i8* %28, %26
%34 = and i1 %32, %33
br i1 %34, label %119, label %35
35: ; preds = %22
%36 = icmp ult i32 %16, 31
br i1 %36, label %99, label %37
37: ; preds = %35
%38 = and i64 %18, 8589934560
%39 = add nsw i64 %38, -32
%40 = lshr exact i64 %39, 5
%41 = add nuw nsw i64 %40, 1
%42 = and i64 %41, 1
%43 = icmp eq i64 %39, 0
br i1 %43, label %77, label %44
44: ; preds = %37
%45 = and i64 %41, 1152921504606846974
br label %46
46: ; preds = %46, %44
%47 = phi i64 [ 0, %44 ], [ %74, %46 ]
%48 = phi i64 [ 0, %44 ], [ %75, %46 ]
%49 = add i64 %4, %47
%50 = and i64 %49, 4294967295
%51 = getelementptr inbounds i8, i8* %0, i64 %50
%52 = bitcast i8* %51 to <16 x i8>*
%53 = load <16 x i8>, <16 x i8>* %52
%54 = getelementptr inbounds i8, i8* %51, i64 16
%55 = bitcast i8* %54 to <16 x i8>*
%56 = load <16 x i8>, <16 x i8>* %55
%57 = getelementptr inbounds i8, i8* %0, i64 %47
%58 = bitcast i8* %57 to <16 x i8>*
store <16 x i8> %53, <16 x i8>* %58
%59 = getelementptr inbounds i8, i8* %57, i64 16
%60 = bitcast i8* %59 to <16 x i8>*
store <16 x i8> %56, <16 x i8>* %60
%61 = or i64 %47, 32
%62 = add i64 %4, %61
%63 = and i64 %62, 4294967295
%64 = getelementptr inbounds i8, i8* %0, i64 %63
%65 = bitcast i8* %64 to <16 x i8>*
%66 = load <16 x i8>, <16 x i8>* %65
%67 = getelementptr inbounds i8, i8* %64, i64 16
%68 = bitcast i8* %67 to <16 x i8>*
%69 = load <16 x i8>, <16 x i8>* %68
%70 = getelementptr inbounds i8, i8* %0, i64 %61
%71 = bitcast i8* %70 to <16 x i8>*
store <16 x i8> %66, <16 x i8>* %71
%72 = getelementptr inbounds i8, i8* %70, i64 16
%73 = bitcast i8* %72 to <16 x i8>*
store <16 x i8> %69, <16 x i8>* %73
%74 = add nuw i64 %47, 64
%75 = add i64 %48, 2
%76 = icmp eq i64 %75, %45
br i1 %76, label %77, label %46
77: ; preds = %46, %37
%78 = phi i64 [ 0, %37 ], [ %74, %46 ]
%79 = icmp eq i64 %42, 0
br i1 %79, label %93, label %80
80: ; preds = %77
%81 = add i64 %4, %78
%82 = and i64 %81, 4294967295
%83 = getelementptr inbounds i8, i8* %0, i64 %82
%84 = bitcast i8* %83 to <16 x i8>*
%85 = load <16 x i8>, <16 x i8>* %84
%86 = getelementptr inbounds i8, i8* %83, i64 16
%87 = bitcast i8* %86 to <16 x i8>*
%88 = load <16 x i8>, <16 x i8>* %87
%89 = getelementptr inbounds i8, i8* %0, i64 %78
%90 = bitcast i8* %89 to <16 x i8>*
store <16 x i8> %85, <16 x i8>* %90
%91 = getelementptr inbounds i8, i8* %89, i64 16
%92 = bitcast i8* %91 to <16 x i8>*
store <16 x i8> %88, <16 x i8>* %92
br label %93
93: ; preds = %77, %80
%94 = icmp eq i64 %18, %38
br i1 %94, label %141, label %95
95: ; preds = %93
%96 = add nsw i64 %14, %38
%97 = and i64 %18, 24
%98 = icmp eq i64 %97, 0
br i1 %98, label %119, label %99
99: ; preds = %35, %95
%100 = phi i64 [ %38, %95 ], [ 0, %35 ]
%101 = sub i32 %2, %10
%102 = zext i32 %101 to i64
%103 = add nuw nsw i64 %102, 1
%104 = and i64 %103, 8589934584
%105 = add nsw i64 %14, %104
br label %106
106: ; preds = %106, %99
%107 = phi i64 [ %100, %99 ], [ %115, %106 ]
%108 = add i64 %4, %107
%109 = and i64 %108, 4294967295
%110 = getelementptr inbounds i8, i8* %0, i64 %109
%111 = bitcast i8* %110 to <8 x i8>*
%112 = load <8 x i8>, <8 x i8>* %111
%113 = getelementptr inbounds i8, i8* %0, i64 %107
%114 = bitcast i8* %113 to <8 x i8>*
store <8 x i8> %112, <8 x i8>* %114
%115 = add nuw i64 %107, 8
%116 = icmp eq i64 %115, %104
br i1 %116, label %117, label %106
117: ; preds = %106
%118 = icmp eq i64 %103, %104
br i1 %118, label %141, label %119
119: ; preds = %22, %12, %95, %117
%120 = phi i64 [ %14, %12 ], [ %14, %22 ], [ %96, %95 ], [ %105, %117 ]
%121 = add i32 %2, 1
%122 = trunc i64 %120 to i32
%123 = sub i32 %121, %122
%124 = sub i32 %2, %122
%125 = and i32 %123, 3
%126 = icmp eq i32 %125, 0
br i1 %126, label %138, label %127
127: ; preds = %119, %127
%128 = phi i64 [ %135, %127 ], [ %120, %119 ]
%129 = phi i32 [ %136, %127 ], [ 0, %119 ]
%130 = and i64 %128, 4294967295
%131 = getelementptr inbounds i8, i8* %0, i64 %130
%132 = load i8, i8* %131
%133 = sub nuw nsw i64 %128, %14
%134 = getelementptr inbounds i8, i8* %0, i64 %133
store i8 %132, i8* %134
%135 = add nsw i64 %128, 1
%136 = add i32 %129, 1
%137 = icmp eq i32 %136, %125
br i1 %137, label %138, label %127
138: ; preds = %127, %119
%139 = phi i64 [ %120, %119 ], [ %135, %127 ]
%140 = icmp ult i32 %124, 3
br i1 %140, label %141, label %144
141: ; preds = %138, %144, %93, %117, %9
%142 = sub i32 %2, %10
%143 = sext i32 %142 to i64
br label %172
144: ; preds = %138, %144
%145 = phi i64 [ %169, %144 ], [ %139, %138 ]
%146 = and i64 %145, 4294967295
%147 = getelementptr inbounds i8, i8* %0, i64 %146
%148 = load i8, i8* %147
%149 = sub nuw nsw i64 %145, %14
%150 = getelementptr inbounds i8, i8* %0, i64 %149
store i8 %148, i8* %150
%151 = add nsw i64 %145, 1
%152 = and i64 %151, 4294967295
%153 = getelementptr inbounds i8, i8* %0, i64 %152
%154 = load i8, i8* %153
%155 = sub nuw nsw i64 %151, %14
%156 = getelementptr inbounds i8, i8* %0, i64 %155
store i8 %154, i8* %156
%157 = add nsw i64 %145, 2
%158 = and i64 %157, 4294967295
%159 = getelementptr inbounds i8, i8* %0, i64 %158
%160 = load i8, i8* %159
%161 = sub nuw nsw i64 %157, %14
%162 = getelementptr inbounds i8, i8* %0, i64 %161
store i8 %160, i8* %162
%163 = add nsw i64 %145, 3
%164 = and i64 %163, 4294967295
%165 = getelementptr inbounds i8, i8* %0, i64 %164
%166 = load i8, i8* %165
%167 = sub nuw nsw i64 %163, %14
%168 = getelementptr inbounds i8, i8* %0, i64 %167
store i8 %166, i8* %168
%169 = add nsw i64 %145, 4
%170 = trunc i64 %169 to i32
%171 = icmp eq i32 %15, %170
br i1 %171, label %141, label %144
172: ; preds = %172, %141
%173 = phi i64 [ %174, %172 ], [ %143, %141 ]
%174 = add i64 %173, -1
%175 = getelementptr inbounds i8, i8* %0, i64 %174
%176 = load i8, i8* %175
%177 = icmp eq i8 %176, 32
br i1 %177, label %172, label %178
178: ; preds = %172
%179 = trunc i64 %173 to i32
%180 = shl i64 %173, 32
%181 = ashr exact i64 %180, 32
%182 = getelementptr inbounds i8, i8* %0, i64 %181
store i8 0, i8* %182
%183 = icmp sgt i32 %179, 0
br i1 %183, label %185, label %184
184: ; preds = %178
store i8 0, i8* %0
br label %264
185: ; preds = %178
%186 = and i64 %173, 4294967295
br label %198
187: ; preds = %218
%188 = sext i32 %219 to i64
%189 = getelementptr inbounds i8, i8* %0, i64 %188
store i8 0, i8* %189
%190 = icmp sgt i32 %219, 1
br i1 %190, label %191, label %235
191: ; preds = %187
%192 = lshr i32 %219, 1
%193 = zext i32 %192 to i64
%194 = and i64 %193, 1
%195 = icmp eq i32 %192, 1
br i1 %195, label %223, label %196
196: ; preds = %191
%197 = and i64 %193, 2147483646
br label %241
198: ; preds = %185, %218
%199 = phi i64 [ 0, %185 ], [ %221, %218 ]
%200 = phi i32 [ 0, %185 ], [ %220, %218 ]
%201 = phi i32 [ 0, %185 ], [ %219, %218 ]
%202 = getelementptr inbounds i8, i8* %0, i64 %199
%203 = load i8, i8* %202
%204 = icmp eq i8 %203, 32
br i1 %204, label %209, label %205
205: ; preds = %198
%206 = add nsw i32 %201, 1
%207 = sext i32 %201 to i64
%208 = getelementptr inbounds i8, i8* %0, i64 %207
store i8 %203, i8* %208
br label %218
209: ; preds = %198
%210 = icmp eq i32 %200, 0
br i1 %210, label %211, label %215
211: ; preds = %209
%212 = add nsw i32 %201, 1
%213 = sext i32 %201 to i64
%214 = getelementptr inbounds i8, i8* %0, i64 %213
store i8 32, i8* %214
br label %215
215: ; preds = %211, %209
%216 = phi i32 [ %201, %209 ], [ %212, %211 ]
%217 = add nsw i32 %200, 1
br label %218
218: ; preds = %205, %215
%219 = phi i32 [ %206, %205 ], [ %216, %215 ]
%220 = phi i32 [ 0, %205 ], [ %217, %215 ]
%221 = add nuw nsw i64 %199, 1
%222 = icmp eq i64 %221, %186
br i1 %222, label %187, label %198
223: ; preds = %241, %191
%224 = phi i64 [ 0, %191 ], [ %261, %241 ]
%225 = icmp eq i64 %194, 0
br i1 %225, label %235, label %226
226: ; preds = %223
%227 = getelementptr inbounds i8, i8* %0, i64 %224
%228 = load i8, i8* %227
%229 = trunc i64 %224 to i32
%230 = xor i32 %229, -1
%231 = add i32 %219, %230
%232 = sext i32 %231 to i64
%233 = getelementptr inbounds i8, i8* %0, i64 %232
%234 = load i8, i8* %233
store i8 %234, i8* %227
store i8 %228, i8* %233
br label %235
235: ; preds = %226, %223, %187
%236 = icmp sgt i32 %219, 0
br i1 %236, label %237, label %264
237: ; preds = %235
%238 = add nsw i32 %219, -1
%239 = zext i32 %238 to i64
%240 = zext i32 %219 to i64
br label %265
241: ; preds = %241, %196
%242 = phi i64 [ 0, %196 ], [ %261, %241 ]
%243 = phi i64 [ 0, %196 ], [ %262, %241 ]
%244 = getelementptr inbounds i8, i8* %0, i64 %242
%245 = load i8, i8* %244
%246 = trunc i64 %242 to i32
%247 = xor i32 %246, -1
%248 = add i32 %219, %247
%249 = sext i32 %248 to i64
%250 = getelementptr inbounds i8, i8* %0, i64 %249
%251 = load i8, i8* %250
store i8 %251, i8* %244
store i8 %245, i8* %250
%252 = or i64 %242, 1
%253 = getelementptr inbounds i8, i8* %0, i64 %252
%254 = load i8, i8* %253
%255 = trunc i64 %252 to i32
%256 = xor i32 %255, -1
%257 = add i32 %219, %256
%258 = sext i32 %257 to i64
%259 = getelementptr inbounds i8, i8* %0, i64 %258
%260 = load i8, i8* %259
store i8 %260, i8* %253
store i8 %254, i8* %259
%261 = add nuw nsw i64 %242, 2
%262 = add i64 %243, 2
%263 = icmp eq i64 %262, %197
br i1 %263, label %223, label %241
264: ; preds = %321, %184, %235
ret void
265: ; preds = %237, %321
%266 = phi i64 [ 0, %237 ], [ %323, %321 ]
%267 = phi i32 [ 0, %237 ], [ %322, %321 ]
%268 = getelementptr inbounds i8, i8* %0, i64 %266
%269 = load i8, i8* %268
%270 = icmp eq i8 %269, 32
%271 = icmp eq i64 %266, %239
%272 = select i1 %270, i1 true, i1 %271
br i1 %272, label %273, label %321
273: ; preds = %265
%274 = xor i1 %271, true
%275 = sext i1 %274 to i32
%276 = trunc i64 %266 to i32
%277 = add nsw i32 %276, %275
%278 = sub i32 1, %267
%279 = add i32 %278, %277
%280 = icmp sgt i32 %279, 1
br i1 %280, label %281, label %300
281: ; preds = %273
%282 = lshr i32 %279, 1
%283 = sext i32 %267 to i64
%284 = sext i32 %277 to i64
%285 = zext i32 %282 to i64
%286 = and i64 %285, 1
%287 = icmp eq i32 %282, 1
br i1 %287, label %290, label %288
288: ; preds = %281
%289 = and i64 %285, 2147483646
br label %302
290: ; preds = %302, %281
%291 = phi i64 [ 0, %281 ], [ %318, %302 ]
%292 = icmp eq i64 %286, 0
br i1 %292, label %300, label %293
293: ; preds = %290
%294 = add nsw i64 %291, %283
%295 = getelementptr inbounds i8, i8* %0, i64 %294
%296 = load i8, i8* %295
%297 = sub nsw i64 %284, %291
%298 = getelementptr inbounds i8, i8* %0, i64 %297
%299 = load i8, i8* %298
store i8 %299, i8* %295
store i8 %296, i8* %298
br label %300
300: ; preds = %293, %290, %273
%301 = add nsw i32 %277, 2
br label %321
302: ; preds = %302, %288
%303 = phi i64 [ 0, %288 ], [ %318, %302 ]
%304 = phi i64 [ 0, %288 ], [ %319, %302 ]
%305 = add nsw i64 %303, %283
%306 = getelementptr inbounds i8, i8* %0, i64 %305
%307 = load i8, i8* %306
%308 = sub nsw i64 %284, %303
%309 = getelementptr inbounds i8, i8* %0, i64 %308
%310 = load i8, i8* %309
store i8 %310, i8* %306
store i8 %307, i8* %309
%311 = or i64 %303, 1
%312 = add nsw i64 %311, %283
%313 = getelementptr inbounds i8, i8* %0, i64 %312
%314 = load i8, i8* %313
%315 = sub nsw i64 %284, %311
%316 = getelementptr inbounds i8, i8* %0, i64 %315
%317 = load i8, i8* %316
store i8 %317, i8* %313
store i8 %314, i8* %316
%318 = add nuw nsw i64 %303, 2
%319 = add i64 %304, 2
%320 = icmp eq i64 %319, %289
br i1 %320, label %290, label %302
321: ; preds = %265, %300
%322 = phi i32 [ %301, %300 ], [ %267, %265 ]
%323 = add nuw nsw i64 %266, 1
%324 = icmp eq i64 %323, %240
br i1 %324, label %264, label %265
}