#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 /*<<< orphan*/ printf(char *, char const *);
scalar_t__ strcmp(char const *, char *);
int strlen(char const *);
int extraer_directorio(const char *camino, char *inicial, char *nombre) {
  if ((camino[0] == '/') && (strcmp(camino, "/") != 0)) {
    int longitud = strlen(camino);
    int i;
    if (camino[longitud - 1] == '/') {
      i = longitud - 2;
    } else {
      i = longitud - 1;
    }
    while (camino[i] != '/') {
      i--;
    }
    int p = i;
    i = 0;
    while (i <= p) {
      inicial[i] = camino[i];
      i++;
    }
    int j = 0;
    while (camino[i] != '/' && i < longitud) {
      nombre[j] = camino[i];
      j++;
      i++;
    }
    nombre[j] = '\0';
    return (1);
  } else {
    printf(
        "ERROR (directorios.c -> extraer_directorio(%s)): Camino no válido.\n",
        camino);
    return (-1);
  }
}


x86 assembly (clang, -O0):
<extraer_directorio>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x2f,%eax
jne    1292 <extraer_directorio+0x162>
mov    -0x10(%rbp),%rdi
lea    0xea1(%rip),%rsi
call   1050 <strcmp@plt>
cmp    $0x0,%rax
je     1292 <extraer_directorio+0x162>
mov    -0x10(%rbp),%rdi
call   1030 <strlen@plt>
mov    %eax,-0x24(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x2f,%eax
jne    11a2 <extraer_directorio+0x72>
mov    -0x24(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x28(%rbp)
jmp    11ab <extraer_directorio+0x7b>
mov    -0x24(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    11b0 <extraer_directorio+0x80>
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x2f,%eax
je     11d3 <extraer_directorio+0xa3>
mov    -0x28(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x28(%rbp)
jmp    11b0 <extraer_directorio+0x80>
mov    -0x28(%rbp),%eax
mov    %eax,-0x2c(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jg     1210 <extraer_directorio+0xe0>
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    11e0 <extraer_directorio+0xb0>
movl   $0x0,-0x30(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsbl (%rax,%rcx,1),%ecx
xor    %eax,%eax
cmp    $0x2f,%ecx
mov    %al,-0x31(%rbp)
je     123d <extraer_directorio+0x10d>
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
setl   %al
mov    %al,-0x31(%rbp)
mov    -0x31(%rbp),%al
test   $0x1,%al
jne    124d <extraer_directorio+0x11d>
jmp    127a <extraer_directorio+0x14a>
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1217 <extraer_directorio+0xe7>
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
movl   $0x1,-0x4(%rbp)
jmp    12a9 <extraer_directorio+0x179>
mov    -0x10(%rbp),%rsi
lea    0xd65(%rip),%rdi
call   1040 <printf@plt>
movl   $0xffffffff,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<extraer_directorio>:
push   %r15
push   %r14
push   %rbx
mov    %rdi,%rbx
cmpb   $0x2f,(%rdi)
jne    1231 <extraer_directorio+0x101>
mov    %rdx,%r14
mov    %rsi,%r15
lea    0xeb2(%rip),%rsi
mov    %rbx,%rdi
call   1050 <strcmp@plt>
test   %rax,%rax
je     1231 <extraer_directorio+0x101>
mov    %rbx,%rdi
call   1030 <strlen@plt>
movslq %eax,%rcx
lea    -0x1(%rcx),%rdx
lea    -0x2(%rcx),%esi
cmpb   $0x2f,-0x1(%rbx,%rcx,1)
cmovne %edx,%esi
movslq %esi,%rdx
lea    0x2(%rdx),%ecx
add    %rbx,%rdx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0xffffffff,%ecx
cmpb   $0x2f,(%rdx)
lea    -0x1(%rdx),%rdx
jne    1190 <extraer_directorio+0x60>
mov    %ecx,%edx
add    $0xffffffff,%edx
js     1247 <extraer_directorio+0x117>
mov    %ecx,%r9d
cmp    $0x7,%edx
jb     11c9 <extraer_directorio+0x99>
lea    (%rbx,%r9,1),%rsi
cmp    %r15,%rsi
jbe    129c <extraer_directorio+0x16c>
lea    (%r15,%r9,1),%rsi
cmp    %rbx,%rsi
jbe    129c <extraer_directorio+0x16c>
xor    %esi,%esi
mov    %rsi,%r8
not    %r8
add    %r9,%r8
test   $0x3,%r9b
je     11f2 <extraer_directorio+0xc2>
mov    %ecx,%edi
and    $0x3,%edi
nop
movzbl (%rbx,%rsi,1),%edx
mov    %dl,(%r15,%rsi,1)
add    $0x1,%rsi
add    $0xffffffffffffffff,%rdi
jne    11e0 <extraer_directorio+0xb0>
cmp    $0x3,%r8
jb     1249 <extraer_directorio+0x119>
nopl   0x0(%rax,%rax,1)
movzbl (%rbx,%rsi,1),%edx
mov    %dl,(%r15,%rsi,1)
movzbl 0x1(%rbx,%rsi,1),%edx
mov    %dl,0x1(%r15,%rsi,1)
movzbl 0x2(%rbx,%rsi,1),%edx
mov    %dl,0x2(%r15,%rsi,1)
movzbl 0x3(%rbx,%rsi,1),%edx
mov    %dl,0x3(%r15,%rsi,1)
add    $0x4,%rsi
cmp    %rsi,%r9
jne    1200 <extraer_directorio+0xd0>
jmp    1249 <extraer_directorio+0x119>
lea    0xdca(%rip),%rdi
mov    %rbx,%rsi
call   1040 <printf@plt>
mov    $0xffffffff,%eax
jmp    1296 <extraer_directorio+0x166>
xor    %ecx,%ecx
mov    %ecx,%esi
mov    (%rbx,%rsi,1),%dl
xor    %edi,%edi
cmp    $0x2f,%dl
je     128c <extraer_directorio+0x15c>
cmp    %eax,%ecx
jge    128c <extraer_directorio+0x15c>
lea    0x1(%rsi),%ecx
add    %rbx,%rsi
add    $0x1,%rsi
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nop
mov    %dl,(%r14,%rdi,1)
lea    0x1(%rdi),%rbx
movzbl (%rsi,%rdi,1),%edx
cmp    $0x2f,%dl
je     128a <extraer_directorio+0x15a>
add    %ecx,%edi
cmp    %edi,%eax
mov    %rbx,%rdi
jg     1270 <extraer_directorio+0x140>
mov    %ebx,%edi
movb   $0x0,(%r14,%rdi,1)
mov    $0x1,%eax
pop    %rbx
pop    %r14
pop    %r15
ret
cmp    $0x1f,%edx
jae    12a8 <extraer_directorio+0x178>
xor    %esi,%esi
jmp    13b0 <extraer_directorio+0x280>
mov    %r9d,%esi
and    $0xffffffe0,%esi
lea    -0x20(%rsi),%rdx
mov    %rdx,%r8
shr    $0x5,%r8
add    $0x1,%r8
cmp    $0x60,%rdx
jae    12c7 <extraer_directorio+0x197>
xor    %edi,%edi
jmp    1340 <extraer_directorio+0x210>
mov    %ecx,%edx
and    $0xffffffe0,%edx
add    $0xffffffffffffffe0,%rdx
shr    $0x5,%rdx
add    $0x1,%rdx
and    $0xfffffffffffffffc,%rdx
xor    %edi,%edi
xchg   %ax,%ax
movups (%rbx,%rdi,1),%xmm0
movups 0x10(%rbx,%rdi,1),%xmm1
movups %xmm0,(%r15,%rdi,1)
movups %xmm1,0x10(%r15,%rdi,1)
movups 0x20(%rbx,%rdi,1),%xmm0
movups 0x30(%rbx,%rdi,1),%xmm1
movups %xmm0,0x20(%r15,%rdi,1)
movups %xmm1,0x30(%r15,%rdi,1)
movups 0x40(%rbx,%rdi,1),%xmm0
movups 0x50(%rbx,%rdi,1),%xmm1
movups %xmm0,0x40(%r15,%rdi,1)
movups %xmm1,0x50(%r15,%rdi,1)
movups 0x60(%rbx,%rdi,1),%xmm0
movups 0x70(%rbx,%rdi,1),%xmm1
movups %xmm0,0x60(%r15,%rdi,1)
movups %xmm1,0x70(%r15,%rdi,1)
sub    $0xffffffffffffff80,%rdi
add    $0xfffffffffffffffc,%rdx
jne    12e0 <extraer_directorio+0x1b0>
test   $0x3,%r8b
je     139d <extraer_directorio+0x26d>
lea    (%r15,%rdi,1),%r10
add    $0x10,%r10
add    %rbx,%rdi
add    $0x10,%rdi
mov    %ecx,%edx
and    $0x60,%dl
add    $0xe0,%dl
shr    $0x5,%dl
add    $0x1,%dl
movzbl %dl,%r8d
and    $0x3,%r8d
shl    $0x5,%r8
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movups -0x10(%rdi,%rdx,1),%xmm0
movups (%rdi,%rdx,1),%xmm1
movups %xmm0,-0x10(%r10,%rdx,1)
movups %xmm1,(%r10,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%r8
jne    1380 <extraer_directorio+0x250>
cmp    %r9,%rsi
je     1249 <extraer_directorio+0x119>
test   $0x18,%r9b
je     11cb <extraer_directorio+0x9b>
mov    %rsi,%rdx
mov    %r9d,%esi
and    $0xfffffff8,%esi
mov    %ecx,%r8d
and    $0xfffffff8,%r8d
mov    (%rbx,%rdx,1),%rdi
mov    %rdi,(%r15,%rdx,1)
add    $0x8,%rdx
cmp    %rdx,%r8
jne    13c0 <extraer_directorio+0x290>
cmp    %r9,%rsi
je     1249 <extraer_directorio+0x119>
jmp    11cb <extraer_directorio+0x9b>

LLVM IR (-O0):
@.str = [2 x i8] c"/\00"
@.str.1 = [69 x i8] c"ERROR (directorios.c -> extraer_directorio(%s)): Camino no v\C3\A1lido.\0A\00"
define i32 @extraer_directorio(i8* %0, i8* %1, i8* %2) {
%4 = alloca i32
%5 = alloca i8*
%6 = alloca i8*
%7 = alloca i8*
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
store i8* %0, i8** %5
store i8* %1, i8** %6
store i8* %2, i8** %7
%12 = load i8*, i8** %5
%13 = getelementptr inbounds i8, i8* %12, i64 0
%14 = load i8, i8* %13
%15 = sext i8 %14 to i32
%16 = icmp eq i32 %15, 47
br i1 %16, label %17, label %102
17: ; preds = %3
%18 = load i8*, i8** %5
%19 = call i64 @strcmp(i8* %18, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
%20 = icmp ne i64 %19, 0
br i1 %20, label %21, label %102
21: ; preds = %17
%22 = load i8*, i8** %5
%23 = call i32 @strlen(i8* %22)
store i32 %23, i32* %8
%24 = load i8*, i8** %5
%25 = load i32, i32* %8
%26 = sub nsw i32 %25, 1
%27 = sext i32 %26 to i64
%28 = getelementptr inbounds i8, i8* %24, i64 %27
%29 = load i8, i8* %28
%30 = sext i8 %29 to i32
%31 = icmp eq i32 %30, 47
br i1 %31, label %32, label %35
32: ; preds = %21
%33 = load i32, i32* %8
%34 = sub nsw i32 %33, 2
store i32 %34, i32* %9
br label %38
35: ; preds = %21
%36 = load i32, i32* %8
%37 = sub nsw i32 %36, 1
store i32 %37, i32* %9
br label %38
38: ; preds = %35, %32
br label %39
39: ; preds = %47, %38
%40 = load i8*, i8** %5
%41 = load i32, i32* %9
%42 = sext i32 %41 to i64
%43 = getelementptr inbounds i8, i8* %40, i64 %42
%44 = load i8, i8* %43
%45 = sext i8 %44 to i32
%46 = icmp ne i32 %45, 47
br i1 %46, label %47, label %50
47: ; preds = %39
%48 = load i32, i32* %9
%49 = add nsw i32 %48, -1
store i32 %49, i32* %9
br label %39
50: ; preds = %39
%51 = load i32, i32* %9
store i32 %51, i32* %10
store i32 0, i32* %9
br label %52
52: ; preds = %56, %50
%53 = load i32, i32* %9
%54 = load i32, i32* %10
%55 = icmp sle i32 %53, %54
br i1 %55, label %56, label %68
56: ; preds = %52
%57 = load i8*, i8** %5
%58 = load i32, i32* %9
%59 = sext i32 %58 to i64
%60 = getelementptr inbounds i8, i8* %57, i64 %59
%61 = load i8, i8* %60
%62 = load i8*, i8** %6
%63 = load i32, i32* %9
%64 = sext i32 %63 to i64
%65 = getelementptr inbounds i8, i8* %62, i64 %64
store i8 %61, i8* %65
%66 = load i32, i32* %9
%67 = add nsw i32 %66, 1
store i32 %67, i32* %9
br label %52
68: ; preds = %52
store i32 0, i32* %11
br label %69
69: ; preds = %83, %68
%70 = load i8*, i8** %5
%71 = load i32, i32* %9
%72 = sext i32 %71 to i64
%73 = getelementptr inbounds i8, i8* %70, i64 %72
%74 = load i8, i8* %73
%75 = sext i8 %74 to i32
%76 = icmp ne i32 %75, 47
br i1 %76, label %77, label %81
77: ; preds = %69
%78 = load i32, i32* %9
%79 = load i32, i32* %8
%80 = icmp slt i32 %78, %79
br label %81
81: ; preds = %77, %69
%82 = phi i1 [ false, %69 ], [ %80, %77 ]
br i1 %82, label %83, label %97
83: ; preds = %81
%84 = load i8*, i8** %5
%85 = load i32, i32* %9
%86 = sext i32 %85 to i64
%87 = getelementptr inbounds i8, i8* %84, i64 %86
%88 = load i8, i8* %87
%89 = load i8*, i8** %7
%90 = load i32, i32* %11
%91 = sext i32 %90 to i64
%92 = getelementptr inbounds i8, i8* %89, i64 %91
store i8 %88, i8* %92
%93 = load i32, i32* %11
%94 = add nsw i32 %93, 1
store i32 %94, i32* %11
%95 = load i32, i32* %9
%96 = add nsw i32 %95, 1
store i32 %96, i32* %9
br label %69
97: ; preds = %81
%98 = load i8*, i8** %7
%99 = load i32, i32* %11
%100 = sext i32 %99 to i64
%101 = getelementptr inbounds i8, i8* %98, i64 %100
store i8 0, i8* %101
store i32 1, i32* %4
br label %105
102: ; preds = %17, %3
%103 = load i8*, i8** %5
%104 = call i32 @printf(i8* getelementptr inbounds ([69 x i8], [69 x i8]* @.str.1, i64 0, i64 0), i8* %103)
store i32 -1, i32* %4
br label %105
105: ; preds = %102, %97
%106 = load i32, i32* %4
ret i32 %106
}

LLVM IR (-O2):
@.str = [2 x i8] c"/\00"
@.str.1 = [69 x i8] c"ERROR (directorios.c -> extraer_directorio(%s)): Camino no v\C3\A1lido.\0A\00"
define i32 @extraer_directorio(i8* %0, i8* nocapture writeonly %1, i8* nocapture writeonly %2) {
%4 = load i8, i8* %0
%5 = icmp eq i8 %4, 47
br i1 %5, label %6, label %199
6: ; preds = %3
%7 = tail call i64 @strcmp(i8* %0, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
%8 = icmp eq i64 %7, 0
br i1 %8, label %199, label %9
9: ; preds = %6
%10 = tail call i32 @strlen(i8* %0)
%11 = add nsw i32 %10, -1
%12 = sext i32 %11 to i64
%13 = getelementptr inbounds i8, i8* %0, i64 %12
%14 = load i8, i8* %13
%15 = icmp eq i8 %14, 47
%16 = add nsw i32 %10, -2
%17 = select i1 %15, i32 %16, i32 %11
%18 = sext i32 %17 to i64
br label %19
19: ; preds = %19, %9
%20 = phi i64 [ %24, %19 ], [ %18, %9 ]
%21 = getelementptr inbounds i8, i8* %0, i64 %20
%22 = load i8, i8* %21
%23 = icmp eq i8 %22, 47
%24 = add i64 %20, -1
br i1 %23, label %25, label %19
25: ; preds = %19
%26 = trunc i64 %20 to i32
%27 = icmp slt i32 %26, 0
br i1 %27, label %154, label %28
28: ; preds = %25
%29 = add nuw i32 %26, 1
%30 = zext i32 %29 to i64
%31 = icmp ult i32 %26, 7
br i1 %31, label %136, label %32
32: ; preds = %28
%33 = getelementptr i8, i8* %1, i64 %30
%34 = getelementptr i8, i8* %0, i64 %30
%35 = icmp ugt i8* %34, %1
%36 = icmp ugt i8* %33, %0
%37 = and i1 %35, %36
br i1 %37, label %136, label %38
38: ; preds = %32
%39 = icmp ult i32 %26, 31
br i1 %39, label %122, label %40
40: ; preds = %38
%41 = and i64 %30, 4294967264
%42 = add nsw i64 %41, -32
%43 = lshr exact i64 %42, 5
%44 = add nuw nsw i64 %43, 1
%45 = and i64 %44, 3
%46 = icmp ult i64 %42, 96
br i1 %46, label %98, label %47
47: ; preds = %40
%48 = and i64 %44, 1152921504606846972
br label %49
49: ; preds = %49, %47
%50 = phi i64 [ 0, %47 ], [ %95, %49 ]
%51 = phi i64 [ 0, %47 ], [ %96, %49 ]
%52 = getelementptr inbounds i8, i8* %0, i64 %50
%53 = bitcast i8* %52 to <16 x i8>*
%54 = load <16 x i8>, <16 x i8>* %53
%55 = getelementptr inbounds i8, i8* %52, i64 16
%56 = bitcast i8* %55 to <16 x i8>*
%57 = load <16 x i8>, <16 x i8>* %56
%58 = getelementptr inbounds i8, i8* %1, i64 %50
%59 = bitcast i8* %58 to <16 x i8>*
store <16 x i8> %54, <16 x i8>* %59
%60 = getelementptr inbounds i8, i8* %58, i64 16
%61 = bitcast i8* %60 to <16 x i8>*
store <16 x i8> %57, <16 x i8>* %61
%62 = or i64 %50, 32
%63 = getelementptr inbounds i8, i8* %0, i64 %62
%64 = bitcast i8* %63 to <16 x i8>*
%65 = load <16 x i8>, <16 x i8>* %64
%66 = getelementptr inbounds i8, i8* %63, i64 16
%67 = bitcast i8* %66 to <16 x i8>*
%68 = load <16 x i8>, <16 x i8>* %67
%69 = getelementptr inbounds i8, i8* %1, i64 %62
%70 = bitcast i8* %69 to <16 x i8>*
store <16 x i8> %65, <16 x i8>* %70
%71 = getelementptr inbounds i8, i8* %69, i64 16
%72 = bitcast i8* %71 to <16 x i8>*
store <16 x i8> %68, <16 x i8>* %72
%73 = or i64 %50, 64
%74 = getelementptr inbounds i8, i8* %0, i64 %73
%75 = bitcast i8* %74 to <16 x i8>*
%76 = load <16 x i8>, <16 x i8>* %75
%77 = getelementptr inbounds i8, i8* %74, i64 16
%78 = bitcast i8* %77 to <16 x i8>*
%79 = load <16 x i8>, <16 x i8>* %78
%80 = getelementptr inbounds i8, i8* %1, i64 %73
%81 = bitcast i8* %80 to <16 x i8>*
store <16 x i8> %76, <16 x i8>* %81
%82 = getelementptr inbounds i8, i8* %80, i64 16
%83 = bitcast i8* %82 to <16 x i8>*
store <16 x i8> %79, <16 x i8>* %83
%84 = or i64 %50, 96
%85 = getelementptr inbounds i8, i8* %0, i64 %84
%86 = bitcast i8* %85 to <16 x i8>*
%87 = load <16 x i8>, <16 x i8>* %86
%88 = getelementptr inbounds i8, i8* %85, i64 16
%89 = bitcast i8* %88 to <16 x i8>*
%90 = load <16 x i8>, <16 x i8>* %89
%91 = getelementptr inbounds i8, i8* %1, i64 %84
%92 = bitcast i8* %91 to <16 x i8>*
store <16 x i8> %87, <16 x i8>* %92
%93 = getelementptr inbounds i8, i8* %91, i64 16
%94 = bitcast i8* %93 to <16 x i8>*
store <16 x i8> %90, <16 x i8>* %94
%95 = add nuw i64 %50, 128
%96 = add i64 %51, 4
%97 = icmp eq i64 %96, %48
br i1 %97, label %98, label %49
98: ; preds = %49, %40
%99 = phi i64 [ 0, %40 ], [ %95, %49 ]
%100 = icmp eq i64 %45, 0
br i1 %100, label %117, label %101
101: ; preds = %98, %101
%102 = phi i64 [ %114, %101 ], [ %99, %98 ]
%103 = phi i64 [ %115, %101 ], [ 0, %98 ]
%104 = getelementptr inbounds i8, i8* %0, i64 %102
%105 = bitcast i8* %104 to <16 x i8>*
%106 = load <16 x i8>, <16 x i8>* %105
%107 = getelementptr inbounds i8, i8* %104, i64 16
%108 = bitcast i8* %107 to <16 x i8>*
%109 = load <16 x i8>, <16 x i8>* %108
%110 = getelementptr inbounds i8, i8* %1, i64 %102
%111 = bitcast i8* %110 to <16 x i8>*
store <16 x i8> %106, <16 x i8>* %111
%112 = getelementptr inbounds i8, i8* %110, i64 16
%113 = bitcast i8* %112 to <16 x i8>*
store <16 x i8> %109, <16 x i8>* %113
%114 = add nuw i64 %102, 32
%115 = add i64 %103, 1
%116 = icmp eq i64 %115, %45
br i1 %116, label %117, label %101
117: ; preds = %101, %98
%118 = icmp eq i64 %41, %30
br i1 %118, label %154, label %119
119: ; preds = %117
%120 = and i64 %30, 24
%121 = icmp eq i64 %120, 0
br i1 %121, label %136, label %122
122: ; preds = %38, %119
%123 = phi i64 [ %41, %119 ], [ 0, %38 ]
%124 = and i64 %30, 4294967288
br label %125
125: ; preds = %125, %122
%126 = phi i64 [ %123, %122 ], [ %132, %125 ]
%127 = getelementptr inbounds i8, i8* %0, i64 %126
%128 = bitcast i8* %127 to <8 x i8>*
%129 = load <8 x i8>, <8 x i8>* %128
%130 = getelementptr inbounds i8, i8* %1, i64 %126
%131 = bitcast i8* %130 to <8 x i8>*
store <8 x i8> %129, <8 x i8>* %131
%132 = add nuw i64 %126, 8
%133 = icmp eq i64 %132, %124
br i1 %133, label %134, label %125
134: ; preds = %125
%135 = icmp eq i64 %124, %30
br i1 %135, label %154, label %136
136: ; preds = %32, %28, %119, %134
%137 = phi i64 [ 0, %28 ], [ 0, %32 ], [ %41, %119 ], [ %124, %134 ]
%138 = xor i64 %137, -1
%139 = add nsw i64 %138, %30
%140 = and i64 %30, 3
%141 = icmp eq i64 %140, 0
br i1 %141, label %151, label %142
142: ; preds = %136, %142
%143 = phi i64 [ %148, %142 ], [ %137, %136 ]
%144 = phi i64 [ %149, %142 ], [ 0, %136 ]
%145 = getelementptr inbounds i8, i8* %0, i64 %143
%146 = load i8, i8* %145
%147 = getelementptr inbounds i8, i8* %1, i64 %143
store i8 %146, i8* %147
%148 = add nuw nsw i64 %143, 1
%149 = add i64 %144, 1
%150 = icmp eq i64 %149, %140
br i1 %150, label %151, label %142
151: ; preds = %142, %136
%152 = phi i64 [ %137, %136 ], [ %148, %142 ]
%153 = icmp ult i64 %139, 3
br i1 %153, label %154, label %162
154: ; preds = %151, %162, %117, %134, %25
%155 = phi i32 [ 0, %25 ], [ %29, %134 ], [ %29, %117 ], [ %29, %162 ], [ %29, %151 ]
%156 = zext i32 %155 to i64
%157 = getelementptr inbounds i8, i8* %0, i64 %156
%158 = load i8, i8* %157
%159 = icmp ne i8 %158, 47
%160 = icmp slt i32 %155, %10
%161 = select i1 %159, i1 %160, i1 false
br i1 %161, label %181, label %196
162: ; preds = %151, %162
%163 = phi i64 [ %179, %162 ], [ %152, %151 ]
%164 = getelementptr inbounds i8, i8* %0, i64 %163
%165 = load i8, i8* %164
%166 = getelementptr inbounds i8, i8* %1, i64 %163
store i8 %165, i8* %166
%167 = add nuw nsw i64 %163, 1
%168 = getelementptr inbounds i8, i8* %0, i64 %167
%169 = load i8, i8* %168
%170 = getelementptr inbounds i8, i8* %1, i64 %167
store i8 %169, i8* %170
%171 = add nuw nsw i64 %163, 2
%172 = getelementptr inbounds i8, i8* %0, i64 %171
%173 = load i8, i8* %172
%174 = getelementptr inbounds i8, i8* %1, i64 %171
store i8 %173, i8* %174
%175 = add nuw nsw i64 %163, 3
%176 = getelementptr inbounds i8, i8* %0, i64 %175
%177 = load i8, i8* %176
%178 = getelementptr inbounds i8, i8* %1, i64 %175
store i8 %177, i8* %178
%179 = add nuw nsw i64 %163, 4
%180 = icmp eq i64 %179, %30
br i1 %180, label %154, label %162
181: ; preds = %154, %181
%182 = phi i64 [ %187, %181 ], [ %156, %154 ]
%183 = phi i64 [ %186, %181 ], [ 0, %154 ]
%184 = phi i8 [ %189, %181 ], [ %158, %154 ]
%185 = getelementptr inbounds i8, i8* %2, i64 %183
store i8 %184, i8* %185
%186 = add nuw nsw i64 %183, 1
%187 = add nuw nsw i64 %182, 1
%188 = getelementptr inbounds i8, i8* %0, i64 %187
%189 = load i8, i8* %188
%190 = icmp ne i8 %189, 47
%191 = trunc i64 %187 to i32
%192 = icmp sgt i32 %10, %191
%193 = select i1 %190, i1 %192, i1 false
br i1 %193, label %181, label %194
194: ; preds = %181
%195 = and i64 %186, 4294967295
br label %196
196: ; preds = %194, %154
%197 = phi i64 [ 0, %154 ], [ %195, %194 ]
%198 = getelementptr inbounds i8, i8* %2, i64 %197
store i8 0, i8* %198
br label %201
199: ; preds = %6, %3
%200 = tail call i32 @printf(i8* getelementptr inbounds ([69 x i8], [69 x i8]* @.str.1, i64 0, i64 0), i8* %0)
br label %201
201: ; preds = %199, %196
%202 = phi i32 [ 1, %196 ], [ -1, %199 ]
ret i32 %202
}