#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 */
scalar_t__ calloc(int, int);
int /*<<< orphan*/ fun(char *, int, int, char *);
char *getPermutation(int n, int k) {
  char buf[10] = {0};
  char *ret = (char *)calloc(sizeof(char), 10);
  int i;
  for (i = 0; i < n; i++)
    buf[i] = '1' + i;
  fun(buf, n, k, ret);
  return ret;
}


x86 assembly (clang, -O0):
<getPermutation>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
lea    -0x12(%rbp),%rdi
xor    %esi,%esi
mov    $0xa,%edx
call   1040 <memset@plt>
mov    $0x1,%edi
mov    $0xa,%esi
call   1050 <calloc@plt>
mov    %rax,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1192 <getPermutation+0x62>
mov    -0x24(%rbp),%eax
add    $0x31,%eax
mov    %al,%cl
movslq -0x24(%rbp),%rax
mov    %cl,-0x12(%rbp,%rax,1)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1168 <getPermutation+0x38>
lea    -0x12(%rbp),%rdi
mov    -0x4(%rbp),%esi
mov    -0x8(%rbp),%edx
mov    -0x20(%rbp),%rcx
call   1030 <fun@plt>
mov    -0x20(%rbp),%rax
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<getPermutation>:
push   %rbp
push   %r14
push   %rbx
sub    $0x10,%rsp
mov    %esi,%r14d
mov    %edi,%ebp
movw   $0x0,0x8(%rsp)
movq   $0x0,(%rsp)
mov    $0x1,%edi
mov    $0xa,%esi
call   1040 <calloc@plt>
mov    %rax,%rbx
test   %ebp,%ebp
jle    12ef <getPermutation+0x1cf>
mov    %ebp,%eax
cmp    $0x20,%ebp
jae    1164 <getPermutation+0x44>
xor    %ecx,%ecx
jmp    12e0 <getPermutation+0x1c0>
mov    %eax,%ecx
and    $0xffffffe0,%ecx
lea    -0x20(%rcx),%rdi
mov    %rdi,%rsi
shr    $0x5,%rsi
add    $0x1,%rsi
mov    %esi,%edx
and    $0x3,%edx
cmp    $0x60,%rdi
jae    1192 <getPermutation+0x72>
movdqa 0xe75(%rip),%xmm0
xor    %edi,%edi
jmp    1275 <getPermutation+0x155>
and    $0xfffffffffffffffc,%rsi
movdqa 0xe62(%rip),%xmm0
xor    %edi,%edi
movdqa 0xe67(%rip),%xmm8
movdqa 0xe6e(%rip),%xmm9
movdqa 0xe75(%rip),%xmm10
movdqa 0xe7c(%rip),%xmm11
movdqa 0xe84(%rip),%xmm5
movdqa 0xe8c(%rip),%xmm6
movdqa 0xe94(%rip),%xmm7
movdqa 0xe9c(%rip),%xmm1
movdqa 0xea4(%rip),%xmm2
nopl   0x0(%rax)
movdqa %xmm0,%xmm3
paddb  %xmm8,%xmm3
movdqa %xmm0,%xmm4
paddb  %xmm9,%xmm4
movdqu %xmm3,(%rsp,%rdi,1)
movdqu %xmm4,0x10(%rsp,%rdi,1)
movdqa %xmm0,%xmm3
paddb  %xmm10,%xmm3
movdqa %xmm0,%xmm4
paddb  %xmm11,%xmm4
movdqu %xmm3,0x20(%rsp,%rdi,1)
movdqu %xmm4,0x30(%rsp,%rdi,1)
movdqa %xmm0,%xmm3
paddb  %xmm5,%xmm3
movdqa %xmm0,%xmm4
paddb  %xmm6,%xmm4
movdqu %xmm3,0x40(%rsp,%rdi,1)
movdqu %xmm4,0x50(%rsp,%rdi,1)
movdqa %xmm0,%xmm3
paddb  %xmm7,%xmm3
movdqa %xmm0,%xmm4
paddb  %xmm1,%xmm4
movdqu %xmm3,0x60(%rsp,%rdi,1)
movdqu %xmm4,0x70(%rsp,%rdi,1)
sub    $0xffffffffffffff80,%rdi
pxor   %xmm2,%xmm0
add    $0xfffffffffffffffc,%rsi
jne    11f0 <getPermutation+0xd0>
test   %rdx,%rdx
je     12d8 <getPermutation+0x1b8>
mov    %rsp,%rsi
add    %rdi,%rsi
add    $0x10,%rsi
shl    $0x5,%rdx
xor    %edi,%edi
movdqa 0xd7e(%rip),%xmm1
movdqa 0xd86(%rip),%xmm2
movdqa 0xdfe(%rip),%xmm3
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movdqa %xmm0,%xmm4
paddb  %xmm1,%xmm4
movdqa %xmm0,%xmm5
paddb  %xmm2,%xmm5
movdqu %xmm4,-0x10(%rsi,%rdi,1)
movdqu %xmm5,(%rsi,%rdi,1)
paddb  %xmm3,%xmm0
add    $0x20,%rdi
cmp    %rdi,%rdx
jne    12b0 <getPermutation+0x190>
cmp    %rax,%rcx
je     12ef <getPermutation+0x1cf>
nopl   (%rax)
lea    0x31(%rcx),%edx
mov    %dl,(%rsp,%rcx,1)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    12e0 <getPermutation+0x1c0>
mov    %rsp,%rdi
mov    %ebp,%esi
mov    %r14d,%edx
mov    %rbx,%rcx
call   1030 <fun@plt>
mov    %rbx,%rax
add    $0x10,%rsp
pop    %rbx
pop    %r14
pop    %rbp
ret

LLVM IR (-O0):
define i8* @getPermutation(i32 %0, i32 %1) {
%3 = alloca i32
%4 = alloca i32
%5 = alloca [10 x i8]
%6 = alloca i8*
%7 = alloca i32
store i32 %0, i32* %3
store i32 %1, i32* %4
%8 = bitcast [10 x i8]* %5 to i8*
%9 = call i64 @calloc(i32 1, i32 10)
%10 = inttoptr i64 %9 to i8*
store i8* %10, i8** %6
store i32 0, i32* %7
br label %11
11: ; preds = %22, %2
%12 = load i32, i32* %7
%13 = load i32, i32* %3
%14 = icmp slt i32 %12, %13
br i1 %14, label %15, label %25
15: ; preds = %11
%16 = load i32, i32* %7
%17 = add nsw i32 49, %16
%18 = trunc i32 %17 to i8
%19 = load i32, i32* %7
%20 = sext i32 %19 to i64
%21 = getelementptr inbounds [10 x i8], [10 x i8]* %5, i64 0, i64 %20
store i8 %18, i8* %21
br label %22
22: ; preds = %15
%23 = load i32, i32* %7
%24 = add nsw i32 %23, 1
store i32 %24, i32* %7
br label %11
25: ; preds = %11
%26 = getelementptr inbounds [10 x i8], [10 x i8]* %5, i64 0, i64 0
%27 = load i32, i32* %3
%28 = load i32, i32* %4
%29 = load i8*, i8** %6
%30 = call i32 @fun(i8* %26, i32 %27, i32 %28, i8* %29)
%31 = load i8*, i8** %6
ret i8* %31
}

LLVM IR (-O2):
define i8* @getPermutation(i32 %0, i32 %1) {
%3 = alloca [10 x i8]
%4 = getelementptr inbounds [10 x i8], [10 x i8]* %3, i64 0, i64 0
%5 = tail call i64 @calloc(i32 1, i32 10)
%6 = inttoptr i64 %5 to i8*
%7 = icmp sgt i32 %0, 0
br i1 %7, label %8, label %84
8: ; preds = %2
%9 = zext i32 %0 to i64
%10 = icmp ult i32 %0, 32
br i1 %10, label %75, label %11
11: ; preds = %8
%12 = and i64 %9, 4294967264
%13 = add nsw i64 %12, -32
%14 = lshr exact i64 %13, 5
%15 = add nuw nsw i64 %14, 1
%16 = and i64 %15, 3
%17 = icmp ult i64 %13, 96
br i1 %17, label %55, label %18
18: ; preds = %11
%19 = and i64 %15, 1152921504606846972
br label %20
20: ; preds = %20, %18
%21 = phi i64 [ 0, %18 ], [ %51, %20 ]
%22 = phi <16 x i8> [ <i8 0, i8 1, i8 2, i8 3, i8 4, i8 5, i8 6, i8 7, i8 8, i8 9, i8 10, i8 11, i8 12, i8 13, i8 14, i8 15>, %18 ], [ %52, %20 ]
%23 = phi i64 [ 0, %18 ], [ %53, %20 ]
%24 = add <16 x i8> %22, <i8 49, i8 49, i8 49, i8 49, i8 49, i8 49, i8 49, i8 49, i8 49, i8 49, i8 49, i8 49, i8 49, i8 49, i8 49, i8 49>
%25 = add <16 x i8> %22, <i8 65, i8 65, i8 65, i8 65, i8 65, i8 65, i8 65, i8 65, i8 65, i8 65, i8 65, i8 65, i8 65, i8 65, i8 65, i8 65>
%26 = getelementptr inbounds [10 x i8], [10 x i8]* %3, i64 0, i64 %21
%27 = bitcast i8* %26 to <16 x i8>*
store <16 x i8> %24, <16 x i8>* %27
%28 = getelementptr inbounds i8, i8* %26, i64 16
%29 = bitcast i8* %28 to <16 x i8>*
store <16 x i8> %25, <16 x i8>* %29
%30 = or i64 %21, 32
%31 = add <16 x i8> %22, <i8 81, i8 81, i8 81, i8 81, i8 81, i8 81, i8 81, i8 81, i8 81, i8 81, i8 81, i8 81, i8 81, i8 81, i8 81, i8 81>
%32 = add <16 x i8> %22, <i8 97, i8 97, i8 97, i8 97, i8 97, i8 97, i8 97, i8 97, i8 97, i8 97, i8 97, i8 97, i8 97, i8 97, i8 97, i8 97>
%33 = getelementptr inbounds [10 x i8], [10 x i8]* %3, i64 0, i64 %30
%34 = bitcast i8* %33 to <16 x i8>*
store <16 x i8> %31, <16 x i8>* %34
%35 = getelementptr inbounds i8, i8* %33, i64 16
%36 = bitcast i8* %35 to <16 x i8>*
store <16 x i8> %32, <16 x i8>* %36
%37 = or i64 %21, 64
%38 = add <16 x i8> %22, <i8 113, i8 113, i8 113, i8 113, i8 113, i8 113, i8 113, i8 113, i8 113, i8 113, i8 113, i8 113, i8 113, i8 113, i8 113, i8 113>
%39 = add <16 x i8> %22, <i8 -127, i8 -127, i8 -127, i8 -127, i8 -127, i8 -127, i8 -127, i8 -127, i8 -127, i8 -127, i8 -127, i8 -127, i8 -127, i8 -127, i8 -127, i8 -127>
%40 = getelementptr inbounds [10 x i8], [10 x i8]* %3, i64 0, i64 %37
%41 = bitcast i8* %40 to <16 x i8>*
store <16 x i8> %38, <16 x i8>* %41
%42 = getelementptr inbounds i8, i8* %40, i64 16
%43 = bitcast i8* %42 to <16 x i8>*
store <16 x i8> %39, <16 x i8>* %43
%44 = or i64 %21, 96
%45 = add <16 x i8> %22, <i8 -111, i8 -111, i8 -111, i8 -111, i8 -111, i8 -111, i8 -111, i8 -111, i8 -111, i8 -111, i8 -111, i8 -111, i8 -111, i8 -111, i8 -111, i8 -111>
%46 = add <16 x i8> %22, <i8 -95, i8 -95, i8 -95, i8 -95, i8 -95, i8 -95, i8 -95, i8 -95, i8 -95, i8 -95, i8 -95, i8 -95, i8 -95, i8 -95, i8 -95, i8 -95>
%47 = getelementptr inbounds [10 x i8], [10 x i8]* %3, i64 0, i64 %44
%48 = bitcast i8* %47 to <16 x i8>*
store <16 x i8> %45, <16 x i8>* %48
%49 = getelementptr inbounds i8, i8* %47, i64 16
%50 = bitcast i8* %49 to <16 x i8>*
store <16 x i8> %46, <16 x i8>* %50
%51 = add nuw i64 %21, 128
%52 = xor <16 x i8> %22, <i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128, i8 -128>
%53 = add i64 %23, 4
%54 = icmp eq i64 %53, %19
br i1 %54, label %55, label %20
55: ; preds = %20, %11
%56 = phi i64 [ 0, %11 ], [ %51, %20 ]
%57 = phi <16 x i8> [ <i8 0, i8 1, i8 2, i8 3, i8 4, i8 5, i8 6, i8 7, i8 8, i8 9, i8 10, i8 11, i8 12, i8 13, i8 14, i8 15>, %11 ], [ %52, %20 ]
%58 = icmp eq i64 %16, 0
br i1 %58, label %73, label %59
59: ; preds = %55, %59
%60 = phi i64 [ %69, %59 ], [ %56, %55 ]
%61 = phi <16 x i8> [ %70, %59 ], [ %57, %55 ]
%62 = phi i64 [ %71, %59 ], [ 0, %55 ]
%63 = add <16 x i8> %61, <i8 49, i8 49, i8 49, i8 49, i8 49, i8 49, i8 49, i8 49, i8 49, i8 49, i8 49, i8 49, i8 49, i8 49, i8 49, i8 49>
%64 = add <16 x i8> %61, <i8 65, i8 65, i8 65, i8 65, i8 65, i8 65, i8 65, i8 65, i8 65, i8 65, i8 65, i8 65, i8 65, i8 65, i8 65, i8 65>
%65 = getelementptr inbounds [10 x i8], [10 x i8]* %3, i64 0, i64 %60
%66 = bitcast i8* %65 to <16 x i8>*
store <16 x i8> %63, <16 x i8>* %66
%67 = getelementptr inbounds i8, i8* %65, i64 16
%68 = bitcast i8* %67 to <16 x i8>*
store <16 x i8> %64, <16 x i8>* %68
%69 = add nuw i64 %60, 32
%70 = add <16 x i8> %61, <i8 32, i8 32, i8 32, i8 32, i8 32, i8 32, i8 32, i8 32, i8 32, i8 32, i8 32, i8 32, i8 32, i8 32, i8 32, i8 32>
%71 = add i64 %62, 1
%72 = icmp eq i64 %71, %16
br i1 %72, label %73, label %59
73: ; preds = %59, %55
%74 = icmp eq i64 %12, %9
br i1 %74, label %84, label %75
75: ; preds = %8, %73
%76 = phi i64 [ 0, %8 ], [ %12, %73 ]
br label %77
77: ; preds = %75, %77
%78 = phi i64 [ %82, %77 ], [ %76, %75 ]
%79 = trunc i64 %78 to i8
%80 = add i8 %79, 49
%81 = getelementptr inbounds [10 x i8], [10 x i8]* %3, i64 0, i64 %78
store i8 %80, i8* %81
%82 = add nuw nsw i64 %78, 1
%83 = icmp eq i64 %82, %9
br i1 %83, label %84, label %77
84: ; preds = %77, %73, %2
%85 = call i32 @fun(i8* %4, i32 %0, i32 %1, i8* %6)
ret i8* %6
}