#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 _splitpath(const char *path, char *drv, char *dir, char *name, char *ext) {
  const char *end;
  const char *p;
  const char *s;
  if (path[0] != '\0' && path[1] == ':') {
    if (drv != NULL) {
      *drv++ = *path++;
      *drv++ = *path++;
      *drv = '\0';
    }
  } else if (drv != NULL) {
    *drv = '\0';
  }
  for (end = path; *end != '\0' && *end != ':';)
    end++;
  for (p = end; p > path && *--p != '\\' && *p != '/';) {
    if (*p == '.') {
      end = p;
      break;
    }
  }
  if (ext != NULL) {
    for (s = end; (*ext = *s++);)
      ext++;
  }
  for (p = end; p > path;) {
    if (*--p == '\\' || *p == '/') {
      p++;
      break;
    }
  }
  if (name != NULL) {
    for (s = p; s < end;)
      *name++ = *s++;
    *name = '\0';
  }
  if (dir != NULL) {
    for (s = path; s < p;)
      *dir++ = *s++;
    *dir = '\0';
  }
}


x86 assembly (clang, -O0):
<_splitpath>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    -0x8(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x0,%eax
je     1194 <_splitpath+0x94>
mov    -0x8(%rbp),%rax
movsbl 0x1(%rax),%eax
cmp    $0x3a,%eax
jne    1194 <_splitpath+0x94>
cmpq   $0x0,-0x10(%rbp)
je     118f <_splitpath+0x8f>
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x8(%rbp)
mov    (%rax),%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x8(%rbp)
mov    (%rax),%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
mov    -0x10(%rbp),%rax
movb   $0x0,(%rax)
jmp    11ab <_splitpath+0xab>
cmpq   $0x0,-0x10(%rbp)
je     11a6 <_splitpath+0xa6>
mov    -0x10(%rbp),%rax
movb   $0x0,(%rax)
jmp    11ab <_splitpath+0xab>
mov    -0x8(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
movsbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x41(%rbp)
je     11d8 <_splitpath+0xd8>
mov    -0x30(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x3a,%eax
setne  %al
mov    %al,-0x41(%rbp)
mov    -0x41(%rbp),%al
test   $0x1,%al
jne    11e8 <_splitpath+0xe8>
jmp    11f9 <_splitpath+0xf9>
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    11b3 <_splitpath+0xb3>
mov    -0x30(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rcx
xor    %eax,%eax
cmp    -0x8(%rbp),%rcx
mov    %al,-0x42(%rbp)
jbe    1245 <_splitpath+0x145>
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x38(%rbp)
movsbl -0x1(%rax),%ecx
xor    %eax,%eax
cmp    $0x5c,%ecx
mov    %al,-0x42(%rbp)
je     1245 <_splitpath+0x145>
mov    -0x38(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x2f,%eax
setne  %al
mov    %al,-0x42(%rbp)
mov    -0x42(%rbp),%al
test   $0x1,%al
jne    1255 <_splitpath+0x155>
jmp    1277 <_splitpath+0x177>
mov    -0x38(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x2e,%eax
jne    1272 <_splitpath+0x172>
mov    -0x38(%rbp),%rax
mov    %rax,-0x30(%rbp)
jmp    1277 <_splitpath+0x177>
jmp    1201 <_splitpath+0x101>
cmpq   $0x0,-0x28(%rbp)
je     12bf <_splitpath+0x1bf>
mov    -0x30(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x40(%rbp)
mov    (%rax),%al
mov    -0x28(%rbp),%rcx
mov    %al,(%rcx)
cmp    $0x0,%al
je     12ba <_splitpath+0x1ba>
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
jmp    128a <_splitpath+0x18a>
jmp    12bf <_splitpath+0x1bf>
mov    -0x30(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rax
cmp    -0x8(%rbp),%rax
jbe    1317 <_splitpath+0x217>
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x38(%rbp)
movsbl -0x1(%rax),%eax
cmp    $0x5c,%eax
je     1301 <_splitpath+0x201>
mov    -0x38(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x2f,%eax
jne    1312 <_splitpath+0x212>
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    1317 <_splitpath+0x217>
jmp    12c7 <_splitpath+0x1c7>
cmpq   $0x0,-0x20(%rbp)
je     1366 <_splitpath+0x266>
mov    -0x38(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x40(%rbp),%rax
cmp    -0x30(%rbp),%rax
jae    135f <_splitpath+0x25f>
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x40(%rbp)
mov    (%rax),%cl
mov    -0x20(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x20(%rbp)
mov    %cl,(%rax)
jmp    132a <_splitpath+0x22a>
mov    -0x20(%rbp),%rax
movb   $0x0,(%rax)
cmpq   $0x0,-0x18(%rbp)
je     13b5 <_splitpath+0x2b5>
mov    -0x8(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x40(%rbp),%rax
cmp    -0x38(%rbp),%rax
jae    13ae <_splitpath+0x2ae>
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x40(%rbp)
mov    (%rax),%cl
mov    -0x18(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x18(%rbp)
mov    %cl,(%rax)
jmp    1379 <_splitpath+0x279>
mov    -0x18(%rbp),%rax
movb   $0x0,(%rax)
pop    %rbp
ret

x86 assembly (clang, -O2):
<_splitpath>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    (%rdi),%al
test   %al,%al
je     112d <_splitpath+0x2d>
cmpb   $0x3a,0x1(%rdi)
jne    112d <_splitpath+0x2d>
test   %rsi,%rsi
je     1135 <_splitpath+0x35>
mov    %al,(%rsi)
mov    0x1(%rdi),%al
add    $0x2,%rdi
mov    %al,0x1(%rsi)
add    $0x2,%rsi
jmp    1132 <_splitpath+0x32>
test   %rsi,%rsi
je     1135 <_splitpath+0x35>
movb   $0x0,(%rsi)
mov    %rdi,%rsi
nopl   0x0(%rax,%rax,1)
movzbl (%rsi),%eax
cmp    $0x3a,%al
je     1151 <_splitpath+0x51>
test   %al,%al
je     1151 <_splitpath+0x51>
add    $0x1,%rsi
jmp    1140 <_splitpath+0x40>
mov    %rsi,%r9
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
cmp    %rdi,%r9
jbe    1181 <_splitpath+0x81>
movzbl -0x1(%r9),%eax
cmp    $0x5c,%al
je     118b <_splitpath+0x8b>
cmp    $0x2f,%al
je     1181 <_splitpath+0x81>
add    $0xffffffffffffffff,%r9
cmp    $0x2e,%al
jne    1160 <_splitpath+0x60>
test   %r8,%r8
jne    1193 <_splitpath+0x93>
jmp    11c1 <_splitpath+0xc1>
mov    %rsi,%r9
test   %r8,%r8
jne    1193 <_splitpath+0x93>
jmp    11c1 <_splitpath+0xc1>
mov    %rsi,%r9
test   %r8,%r8
je     11c1 <_splitpath+0xc1>
mov    (%r9),%al
mov    %al,(%r8)
test   %al,%al
je     11c1 <_splitpath+0xc1>
mov    $0x1,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movzbl (%r9,%rax,1),%ebx
mov    %bl,(%r8,%rax,1)
add    $0x1,%rax
test   %bl,%bl
jne    11b0 <_splitpath+0xb0>
mov    %r9,%r15
sub    %rdi,%r15
xor    %esi,%esi
xor    %ebx,%ebx
mov    %r9d,%ebp
xchg   %ax,%ax
mov    %ebp,%r8d
mov    %rbx,%r10
mov    %rsi,%r11
lea    (%r9,%rsi,1),%r12
cmp    %rdi,%r12
jbe    11fc <_splitpath+0xfc>
movzbl -0x1(%r9,%r11,1),%eax
cmp    $0x5c,%al
je     11fc <_splitpath+0xfc>
lea    0x7(%r8),%ebp
lea    0x1(%r10),%rbx
lea    -0x1(%r11),%rsi
cmp    $0x2f,%al
jne    11d0 <_splitpath+0xd0>
test   %rcx,%rcx
je     13d6 <_splitpath+0x2d6>
cmp    %r9,%r12
jae    13d3 <_splitpath+0x2d3>
mov    %r11,%rbx
neg    %rbx
mov    %r12,%rsi
sub    %r11,%rsi
cmp    $0x20,%rbx
jb     1238 <_splitpath+0x138>
cmp    %rcx,%rsi
jbe    12c0 <_splitpath+0x1c0>
mov    %rcx,%rax
sub    %r11,%rax
cmp    %rax,%r12
jae    12c0 <_splitpath+0x1c0>
mov    %r12,%r10
mov    %r9d,%eax
sub    %r10d,%eax
mov    %r10,%rbp
not    %rbp
add    %r9,%rbp
and    $0x7,%rax
je     1264 <_splitpath+0x164>
movzbl (%r10),%ebx
add    $0x1,%r10
mov    %bl,(%rcx)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rax
jne    1250 <_splitpath+0x150>
cmp    $0x7,%rbp
jb     13d3 <_splitpath+0x2d3>
xchg   %ax,%ax
movzbl (%r10),%eax
mov    %al,(%rcx)
movzbl 0x1(%r10),%eax
mov    %al,0x1(%rcx)
movzbl 0x2(%r10),%eax
mov    %al,0x2(%rcx)
movzbl 0x3(%r10),%eax
mov    %al,0x3(%rcx)
movzbl 0x4(%r10),%eax
mov    %al,0x4(%rcx)
movzbl 0x5(%r10),%eax
mov    %al,0x5(%rcx)
movzbl 0x6(%r10),%eax
mov    %al,0x6(%rcx)
movzbl 0x7(%r10),%eax
mov    %al,0x7(%rcx)
add    $0x8,%rcx
add    $0x8,%r10
cmp    %rsi,%r10
jne    1270 <_splitpath+0x170>
jmp    13d3 <_splitpath+0x2d3>
mov    %rbx,%rax
mov    %rbx,-0x10(%rsp)
and    $0xffffffffffffffe0,%rbx
mov    %rbx,-0x8(%rsp)
lea    -0x20(%rbx),%rax
mov    %rax,%r13
shr    $0x5,%r13
add    $0x1,%r13
cmp    $0x60,%rax
jae    12ea <_splitpath+0x1ea>
xor    %ebx,%ebx
jmp    1364 <_splitpath+0x264>
mov    %r13,%rbp
and    $0xfffffffffffffffc,%rbp
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    (%r9,%rbx,1),%rax
movups (%r11,%rax,1),%xmm0
movups 0x10(%r11,%rax,1),%xmm1
movups %xmm0,(%rcx,%rbx,1)
movups %xmm1,0x10(%rcx,%rbx,1)
movups 0x20(%r11,%rax,1),%xmm0
movups 0x30(%r11,%rax,1),%xmm1
movups %xmm0,0x20(%rcx,%rbx,1)
movups %xmm1,0x30(%rcx,%rbx,1)
movups 0x40(%r11,%rax,1),%xmm0
movups 0x50(%r11,%rax,1),%xmm1
movups %xmm0,0x40(%rcx,%rbx,1)
movups %xmm1,0x50(%rcx,%rbx,1)
movups 0x60(%r11,%rax,1),%xmm0
movups 0x70(%r11,%rax,1),%xmm1
movups %xmm0,0x60(%rcx,%rbx,1)
movups %xmm1,0x70(%rcx,%rbx,1)
sub    $0xffffffffffffff80,%rbx
add    $0xfffffffffffffffc,%rbp
jne    1300 <_splitpath+0x200>
test   $0x3,%r13b
je     13c4 <_splitpath+0x2c4>
lea    (%rcx,%rbx,1),%r13
add    $0x10,%r13
mov    -0x10(%rsp),%rax
and    $0x60,%al
add    $0xe0,%al
shr    $0x5,%al
add    $0x1,%al
movzbl %al,%ebp
and    $0x3,%ebp
shl    $0x5,%rbp
add    %r9,%rbx
add    $0x10,%rbx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    (%rbx,%rax,1),%r14
movups -0x10(%r11,%r14,1),%xmm0
movups (%r11,%r14,1),%xmm1
movups %xmm0,-0x10(%r13,%rax,1)
movups %xmm1,0x0(%r13,%rax,1)
add    $0x20,%rax
cmp    %rax,%rbp
jne    13a0 <_splitpath+0x2a0>
mov    -0x8(%rsp),%rax
add    %rax,%rcx
cmp    %rax,-0x10(%rsp)
jne    1431 <_splitpath+0x331>
movb   $0x0,(%rcx)
test   %rdx,%rdx
je     1596 <_splitpath+0x496>
cmp    %rdi,%r12
jbe    1593 <_splitpath+0x493>
lea    (%r15,%r11,1),%r10
lea    (%rdi,%r15,1),%rcx
add    %r11,%rcx
cmp    $0x20,%r10
jb     150a <_splitpath+0x40a>
cmp    %rdx,%rcx
jbe    1411 <_splitpath+0x311>
add    %rdx,%r15
add    %r11,%r15
cmp    %r15,%rdi
jb     150a <_splitpath+0x40a>
mov    %r10,%r14
and    $0xffffffffffffffe0,%r14
lea    -0x20(%r14),%rax
mov    %rax,%rbp
shr    $0x5,%rbp
add    $0x1,%rbp
cmp    $0x60,%rax
jae    1440 <_splitpath+0x340>
xor    %esi,%esi
jmp    14a8 <_splitpath+0x3a8>
and    $0xffffffffffffffe0,%r10
add    %r9,%r10
add    %r11,%r10
jmp    123b <_splitpath+0x13b>
mov    %rbp,%rbx
and    $0xfffffffffffffffc,%rbx
xor    %esi,%esi
nopl   0x0(%rax)
movups (%rdi,%rsi,1),%xmm0
movups 0x10(%rdi,%rsi,1),%xmm1
movups %xmm0,(%rdx,%rsi,1)
movups %xmm1,0x10(%rdx,%rsi,1)
movups 0x20(%rdi,%rsi,1),%xmm0
movups 0x30(%rdi,%rsi,1),%xmm1
movups %xmm0,0x20(%rdx,%rsi,1)
movups %xmm1,0x30(%rdx,%rsi,1)
movups 0x40(%rdi,%rsi,1),%xmm0
movups 0x50(%rdi,%rsi,1),%xmm1
movups %xmm0,0x40(%rdx,%rsi,1)
movups %xmm1,0x50(%rdx,%rsi,1)
movups 0x60(%rdi,%rsi,1),%xmm0
movups 0x70(%rdi,%rsi,1),%xmm1
movups %xmm0,0x60(%rdx,%rsi,1)
movups %xmm1,0x70(%rdx,%rsi,1)
sub    $0xffffffffffffff80,%rsi
add    $0xfffffffffffffffc,%rbx
jne    1450 <_splitpath+0x350>
test   $0x3,%bpl
je     14fb <_splitpath+0x3fb>
lea    (%rdx,%rsi,1),%rbx
add    $0x10,%rbx
add    %rdi,%rsi
add    $0x10,%rsi
mov    %r10d,%eax
and    $0x60,%al
add    $0xe0,%al
shr    $0x5,%al
add    $0x1,%al
movzbl %al,%ebp
and    $0x3,%ebp
shl    $0x5,%rbp
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nop
movups -0x10(%rsi,%rax,1),%xmm0
movups (%rsi,%rax,1),%xmm1
movups %xmm0,-0x10(%rbx,%rax,1)
movups %xmm1,(%rbx,%rax,1)
add    $0x20,%rax
cmp    %rax,%rbp
jne    14e0 <_splitpath+0x3e0>
add    %r14,%rdx
cmp    %r14,%r10
je     1593 <_splitpath+0x493>
add    %r14,%rdi
mov    %r9d,%eax
sub    %edi,%eax
add    %r11d,%eax
mov    %rdi,%rsi
not    %rsi
add    %r9,%rsi
add    %r11,%rsi
test   $0x7,%al
je     1543 <_splitpath+0x443>
sub    %dil,%r8b
movzbl %r8b,%eax
and    $0x7,%eax
nopl   0x0(%rax)
movzbl (%rdi),%ebx
add    $0x1,%rdi
mov    %bl,(%rdx)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rax
jne    1530 <_splitpath+0x430>
cmp    $0x7,%rsi
jb     1593 <_splitpath+0x493>
nopl   0x0(%rax)
movzbl (%rdi),%eax
mov    %al,(%rdx)
movzbl 0x1(%rdi),%eax
mov    %al,0x1(%rdx)
movzbl 0x2(%rdi),%eax
mov    %al,0x2(%rdx)
movzbl 0x3(%rdi),%eax
mov    %al,0x3(%rdx)
movzbl 0x4(%rdi),%eax
mov    %al,0x4(%rdx)
movzbl 0x5(%rdi),%eax
mov    %al,0x5(%rdx)
movzbl 0x6(%rdi),%eax
mov    %al,0x6(%rdx)
movzbl 0x7(%rdi),%eax
mov    %al,0x7(%rdx)
add    $0x8,%rdx
add    $0x8,%rdi
cmp    %rdi,%rcx
jne    1550 <_splitpath+0x450>
movb   $0x0,(%rdx)
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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