int main() {
  srand(time(0));
  char respuesta[2][5], user[5], hint[5];
  for (int i = 0; i < 5; i++)
    respuesta[0][i] = (i < 4) ? 'a' + (rand() % 6) : '\0';
  int won = 0, k, r;
  printf("Respuesta: %s\n", respuesta[0]);
  for (int times = 0, k = 0; times < 10 && !won; times++, k = 0) {
    memset(hint, '\0', 5);
    strcpy(respuesta[1], respuesta[0]);
    printf("Ingresa respuesta: "), scanf("%s", user);
    if ((k = intersection(respuesta[1], user, hint, '!')) == 4)
      won = 1;
    insertion_sort(respuesta[1], 4), insertion_sort(user, 4);
    for (int j = 0; j < merge(respuesta[1], user, 4) && k < 4; j++, k++)
      hint[k] = '#';
    printf("Hint: %s\n\n", hint);
  }
  if (!won) {
    printf("Perdiste. La respuesta era: %s\n", respuesta[0]);
  } else
    printf("Ganaste!\n");
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
movl   $0x0,-0x4(%rbp)
xor    %edi,%edi
mov    $0x0,%al
call   1070 <time@plt>
mov    %eax,%edi
mov    $0x0,%al
call   1060 <srand@plt>
movl   $0x0,-0x1c(%rbp)
cmpl   $0x5,-0x1c(%rbp)
jge    121d <main+0x7d>
cmpl   $0x4,-0x1c(%rbp)
jge    11f8 <main+0x58>
mov    $0x0,%al
call   10c0 <rand@plt>
mov    $0x6,%ecx
cltd
idiv   %ecx
mov    %edx,%eax
add    $0x61,%eax
mov    %eax,-0x38(%rbp)
jmp    1202 <main+0x62>
xor    %eax,%eax
mov    %eax,-0x38(%rbp)
jmp    1202 <main+0x62>
mov    -0x38(%rbp),%eax
mov    %al,%cl
movslq -0x1c(%rbp),%rax
mov    %cl,-0xe(%rbp,%rax,1)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    11c8 <main+0x28>
movl   $0x0,-0x20(%rbp)
lea    -0xe(%rbp),%rsi
lea    0xdd1(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x0,-0x2c(%rbp)
movl   $0x0,-0x30(%rbp)
xor    %eax,%eax
cmpl   $0xa,-0x2c(%rbp)
mov    %al,-0x39(%rbp)
jge    125f <main+0xbf>
cmpl   $0x0,-0x20(%rbp)
setne  %al
xor    $0xff,%al
mov    %al,-0x39(%rbp)
mov    -0x39(%rbp),%al
test   $0x1,%al
jne    126f <main+0xcf>
jmp    139b <main+0x1fb>
lea    -0x18(%rbp),%rdi
xor    %esi,%esi
mov    $0x5,%edx
call   1050 <memset@plt>
lea    -0xe(%rbp),%rdi
add    $0x5,%rdi
lea    -0xe(%rbp),%rsi
call   1030 <strcpy@plt>
lea    0xd78(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
lea    -0x13(%rbp),%rsi
lea    0xd7a(%rip),%rdi
mov    $0x0,%al
call   10a0 <scanf@plt>
lea    -0xe(%rbp),%rdi
add    $0x5,%rdi
lea    -0x13(%rbp),%rsi
lea    -0x18(%rbp),%rdx
mov    $0x21,%ecx
mov    $0x0,%al
call   1090 <intersection@plt>
mov    %eax,-0x30(%rbp)
cmp    $0x4,%eax
jne    12df <main+0x13f>
movl   $0x1,-0x20(%rbp)
lea    -0xe(%rbp),%rdi
add    $0x5,%rdi
mov    $0x4,%esi
mov    $0x0,%al
call   10b0 <insertion_sort@plt>
lea    -0x13(%rbp),%rdi
mov    $0x4,%esi
mov    $0x0,%al
call   10b0 <insertion_sort@plt>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    %eax,-0x40(%rbp)
lea    -0xe(%rbp),%rdi
add    $0x5,%rdi
lea    -0x13(%rbp),%rsi
mov    $0x4,%edx
mov    $0x0,%al
call   1080 <merge@plt>
mov    -0x40(%rbp),%ecx
mov    %eax,%edx
xor    %eax,%eax
cmp    %edx,%ecx
mov    %al,-0x3a(%rbp)
jge    1344 <main+0x1a4>
cmpl   $0x4,-0x30(%rbp)
setl   %al
mov    %al,-0x3a(%rbp)
mov    -0x3a(%rbp),%al
test   $0x1,%al
jne    1354 <main+0x1b4>
jmp    1374 <main+0x1d4>
movslq -0x30(%rbp),%rax
movb   $0x23,-0x18(%rbp,%rax,1)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    130a <main+0x16a>
lea    -0x18(%rbp),%rsi
lea    0xca7(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
movl   $0x0,-0x30(%rbp)
jmp    1244 <main+0xa4>
cmpl   $0x0,-0x20(%rbp)
jne    13bc <main+0x21c>
lea    -0xe(%rbp),%rsi
lea    0xc81(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
jmp    13ca <main+0x22a>
lea    0xc8e(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x4(%rbp),%eax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
xor    %edi,%edi
xor    %eax,%eax
call   1070 <time@plt>
mov    %eax,%edi
xor    %eax,%eax
call   1060 <srand@plt>
xor    %eax,%eax
call   10c0 <rand@plt>
cltq
imul   $0x2aaaaaab,%rax,%rcx
mov    %rcx,%rdx
shr    $0x3f,%rdx
shr    $0x20,%rcx
add    %edx,%ecx
add    %ecx,%ecx
lea    (%rcx,%rcx,2),%ecx
sub    %ecx,%eax
add    $0x61,%al
mov    %al,0x9(%rsp)
xor    %eax,%eax
call   10c0 <rand@plt>
cltq
imul   $0x2aaaaaab,%rax,%rcx
mov    %rcx,%rdx
shr    $0x3f,%rdx
shr    $0x20,%rcx
add    %edx,%ecx
add    %ecx,%ecx
lea    (%rcx,%rcx,2),%ecx
sub    %ecx,%eax
add    $0x61,%al
mov    %al,0xa(%rsp)
xor    %eax,%eax
call   10c0 <rand@plt>
cltq
imul   $0x2aaaaaab,%rax,%rcx
mov    %rcx,%rdx
shr    $0x3f,%rdx
shr    $0x20,%rcx
add    %edx,%ecx
add    %ecx,%ecx
lea    (%rcx,%rcx,2),%ecx
sub    %ecx,%eax
add    $0x61,%al
mov    %al,0xb(%rsp)
xor    %eax,%eax
call   10c0 <rand@plt>
cltq
imul   $0x2aaaaaab,%rax,%rcx
mov    %rcx,%rdx
shr    $0x3f,%rdx
shr    $0x20,%rcx
add    %edx,%ecx
add    %ecx,%ecx
lea    (%rcx,%rcx,2),%ecx
sub    %ecx,%eax
add    $0x61,%al
mov    %al,0xc(%rsp)
movb   $0x0,0xd(%rsp)
lea    0xd8c(%rip),%rdi
lea    0x9(%rsp),%rsi
xor    %eax,%eax
call   1050 <printf@plt>
lea    0xe(%rsp),%r13
lea    0x13(%rsp),%rbx
lea    0x4(%rsp),%rbp
xor    %r12d,%r12d
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movb   $0x0,0x8(%rsp)
movl   $0x0,0x4(%rsp)
mov    %r13,%rdi
lea    0x9(%rsp),%rsi
call   1030 <strcpy@plt>
lea    0xd4e(%rip),%rdi
xor    %eax,%eax
call   1050 <printf@plt>
lea    0xd54(%rip),%rdi
mov    %rbx,%rsi
xor    %eax,%eax
call   10a0 <scanf@plt>
mov    %r13,%rdi
mov    %rbx,%rsi
mov    %rbp,%rdx
mov    $0x21,%ecx
xor    %eax,%eax
call   1090 <intersection@plt>
mov    %eax,%r15d
mov    %r13,%rdi
mov    $0x4,%esi
xor    %eax,%eax
call   10b0 <insertion_sort@plt>
mov    %rbx,%rdi
mov    $0x4,%esi
xor    %eax,%eax
call   10b0 <insertion_sort@plt>
mov    %r13,%rdi
mov    %rbx,%rsi
mov    $0x4,%edx
xor    %eax,%eax
call   1080 <merge@plt>
test   %eax,%eax
jle    136d <main+0x1cd>
cmp    $0x3,%r15d
jg     136d <main+0x1cd>
movslq %r15d,%rbp
mov    $0x1,%r14d
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movb   $0x23,0x4(%rsp,%rbp,1)
mov    %r13,%rdi
mov    %rbx,%rsi
mov    $0x4,%edx
xor    %eax,%eax
call   1080 <merge@plt>
cmp    %eax,%r14d
jge    136d <main+0x1cd>
lea    0x1(%rbp),%rax
add    $0x1,%r14d
cmp    $0x3,%rbp
mov    %rax,%rbp
jl     1340 <main+0x1a0>
lea    0xcb2(%rip),%rdi
lea    0x4(%rsp),%rbp
mov    %rbp,%rsi
xor    %eax,%eax
call   1050 <printf@plt>
cmp    $0x8,%r12d
ja     1397 <main+0x1f7>
add    $0x1,%r12d
cmp    $0x4,%r15d
jne    12a0 <main+0x100>
cmp    $0x4,%r15d
je     13b2 <main+0x212>
lea    0xc8d(%rip),%rdi
lea    0x9(%rsp),%rsi
xor    %eax,%eax
call   1050 <printf@plt>
jmp    13be <main+0x21e>
lea    0xc98(%rip),%rdi
call   1040 <puts@plt>
xor    %eax,%eax
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
@.str = [15 x i8] c"Respuesta: %s\0A\00"
@.str.1 = [20 x i8] c"Ingresa respuesta: \00"
@.str.2 = [3 x i8] c"%s\00"
@.str.3 = [11 x i8] c"Hint: %s\0A\0A\00"
@.str.4 = [32 x i8] c"Perdiste. La respuesta era: %s\0A\00"
@str = [9 x i8] c"Ganaste!\00"
define i32 @main() {
%1 = alloca [2 x [5 x i8]]
%2 = alloca [5 x i8]
%3 = alloca [5 x i8]
%4 = tail call i32 (i32, ...) bitcast (i32 (...)* @time to i32 (i32, ...)*)(i32 0)
%5 = tail call i32 (i32, ...) bitcast (i32 (...)* @srand to i32 (i32, ...)*)(i32 %4)
%6 = getelementptr inbounds [2 x [5 x i8]], [2 x [5 x i8]]* %1, i64 0, i64 0, i64 0
%7 = getelementptr inbounds [5 x i8], [5 x i8]* %2, i64 0, i64 0
%8 = getelementptr inbounds [5 x i8], [5 x i8]* %3, i64 0, i64 0
%9 = tail call i32 (...) @rand()
%10 = srem i32 %9, 6
%11 = trunc i32 %10 to i8
%12 = add nsw i8 %11, 97
store i8 %12, i8* %6
%13 = tail call i32 (...) @rand()
%14 = srem i32 %13, 6
%15 = trunc i32 %14 to i8
%16 = add nsw i8 %15, 97
%17 = getelementptr inbounds [2 x [5 x i8]], [2 x [5 x i8]]* %1, i64 0, i64 0, i64 1
store i8 %16, i8* %17
%18 = tail call i32 (...) @rand()
%19 = srem i32 %18, 6
%20 = trunc i32 %19 to i8
%21 = add nsw i8 %20, 97
%22 = getelementptr inbounds [2 x [5 x i8]], [2 x [5 x i8]]* %1, i64 0, i64 0, i64 2
store i8 %21, i8* %22
%23 = tail call i32 (...) @rand()
%24 = srem i32 %23, 6
%25 = trunc i32 %24 to i8
%26 = add nsw i8 %25, 97
%27 = getelementptr inbounds [2 x [5 x i8]], [2 x [5 x i8]]* %1, i64 0, i64 0, i64 3
store i8 %26, i8* %27
%28 = getelementptr inbounds [2 x [5 x i8]], [2 x [5 x i8]]* %1, i64 0, i64 0, i64 4
store i8 0, i8* %28
%29 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([15 x i8], [15 x i8]* @.str, i64 0, i64 0), i8* %6)
%30 = getelementptr inbounds [2 x [5 x i8]], [2 x [5 x i8]]* %1, i64 0, i64 1, i64 0
br label %32
31: ; preds = %47
br i1 %38, label %62, label %64
32: ; preds = %0, %47
%33 = phi i32 [ 0, %0 ], [ %49, %47 ]
%34 = call i8* @strcpy(i8* %30, i8* %6)
%35 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([20 x i8], [20 x i8]* @.str.1, i64 0, i64 0))
%36 = call i32 (i8*, ...) @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.2, i64 0, i64 0), i8* %7)
%37 = call i32 (i8*, i8*, i8*, i32, ...) bitcast (i32 (...)* @intersection to i32 (i8*, i8*, i8*, i32, ...)*)(i8* %30, i8* %7, i8* %8, i32 33)
%38 = icmp ne i32 %37, 4
%39 = call i32 (i8*, i32, ...) bitcast (i32 (...)* @insertion_sort to i32 (i8*, i32, ...)*)(i8* %30, i32 4)
%40 = call i32 (i8*, i32, ...) bitcast (i32 (...)* @insertion_sort to i32 (i8*, i32, ...)*)(i8* %7, i32 4)
%41 = call i32 (i8*, i8*, i32, ...) bitcast (i32 (...)* @merge to i32 (i8*, i8*, i32, ...)*)(i8* %30, i8* %7, i32 4)
%42 = icmp sgt i32 %41, 0
%43 = icmp slt i32 %37, 4
%44 = select i1 %42, i1 %43, i1 false
br i1 %44, label %45, label %47
45: ; preds = %32
%46 = sext i32 %37 to i64
br label %52
47: ; preds = %52, %32
%48 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([11 x i8], [11 x i8]* @.str.3, i64 0, i64 0), i8* %8)
%49 = add nuw nsw i32 %33, 1
%50 = icmp ult i32 %33, 9
%51 = select i1 %50, i1 %38, i1 false
br i1 %51, label %32, label %31
52: ; preds = %45, %52
%53 = phi i64 [ %46, %45 ], [ %57, %52 ]
%54 = phi i32 [ 0, %45 ], [ %56, %52 ]
%55 = getelementptr inbounds [5 x i8], [5 x i8]* %3, i64 0, i64 %53
store i8 35, i8* %55
%56 = add nuw nsw i32 %54, 1
%57 = add nsw i64 %53, 1
%58 = call i32 (i8*, i8*, i32, ...) bitcast (i32 (...)* @merge to i32 (i8*, i8*, i32, ...)*)(i8* %30, i8* %7, i32 4)
%59 = icmp slt i32 %56, %58
%60 = icmp slt i64 %53, 3
%61 = select i1 %59, i1 %60, i1 false
br i1 %61, label %52, label %47
62: ; preds = %31
%63 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([32 x i8], [32 x i8]* @.str.4, i64 0, i64 0), i8* %6)
br label %66
64: ; preds = %31
%65 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([9 x i8], [9 x i8]* @str, i64 0, i64 0))
br label %66
66: ; preds = %64, %62
ret i32 0
}