#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 */
typedef int /*<<< orphan*/ mode_t;

/* Variables and functions */
int aaip_encode_acl(char *, int /*<<< orphan*/, size_t *, unsigned char **,
                    int);
unsigned char *calloc(size_t, int);
int /*<<< orphan*/ free(unsigned char *);
int /*<<< orphan*/ memcpy(unsigned char *, unsigned char *, size_t);
int aaip_encode_both_acl(char *a_acl_text, char *d_acl_text, mode_t st_mode,
                         size_t *result_len, unsigned char **result, int flag) {
  int ret;
  size_t a_acl_len = 0, d_acl_len = 0, acl_len = 0;
  unsigned char *a_acl = NULL, *d_acl = NULL, *acl = NULL;
  if (a_acl_text != NULL) {
    ret = aaip_encode_acl(a_acl_text, st_mode, &a_acl_len, &a_acl, flag & 11);
    if (ret <= 0)
      goto ex;
  }
  if (d_acl_text != NULL) {
    ret = aaip_encode_acl(d_acl_text, (mode_t)0, &d_acl_len, &d_acl,
                          (flag & 3) | 4);
    if (ret <= 0)
      goto ex;
  }
  if (a_acl == NULL || a_acl_len == 0) {
    acl = d_acl;
    d_acl = NULL;
    acl_len = d_acl_len;
  } else if (d_acl == NULL || d_acl_len == 0) {
    acl = a_acl;
    a_acl = NULL;
    acl_len = a_acl_len;
  } else {
    acl = calloc(a_acl_len + d_acl_len, 1);
    if (acl == NULL) {
      ret = -1;
      goto ex;
    }
    memcpy(acl, a_acl, a_acl_len);
    memcpy(acl + a_acl_len, d_acl, d_acl_len);
    acl_len = a_acl_len + d_acl_len;
  }
  *result = acl;
  *result_len = acl_len;
  ret = 1;
ex:;
  if (a_acl != NULL)
    free(a_acl);
  if (d_acl != NULL)
    free(d_acl);
  return (ret);
}


x86 assembly (clang, -O0):
<aaip_encode_both_acl>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9d,-0x2c(%rbp)
movq   $0x0,-0x38(%rbp)
movq   $0x0,-0x40(%rbp)
movq   $0x0,-0x48(%rbp)
movq   $0x0,-0x50(%rbp)
movq   $0x0,-0x58(%rbp)
movq   $0x0,-0x60(%rbp)
cmpq   $0x0,-0x8(%rbp)
je     11cd <aaip_encode_both_acl+0x8d>
mov    -0x8(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x2c(%rbp),%r8d
and    $0xb,%r8d
lea    -0x38(%rbp),%rdx
lea    -0x50(%rbp),%rcx
call   1030 <aaip_encode_acl@plt>
mov    %eax,-0x30(%rbp)
cmpl   $0x0,-0x30(%rbp)
jg     11c8 <aaip_encode_both_acl+0x88>
jmp    12f5 <aaip_encode_both_acl+0x1b5>
jmp    11cd <aaip_encode_both_acl+0x8d>
cmpq   $0x0,-0x10(%rbp)
je     120e <aaip_encode_both_acl+0xce>
mov    -0x10(%rbp),%rdi
mov    -0x2c(%rbp),%r8d
and    $0x3,%r8d
or     $0x4,%r8d
xor    %esi,%esi
lea    -0x40(%rbp),%rdx
lea    -0x58(%rbp),%rcx
call   1030 <aaip_encode_acl@plt>
mov    %eax,-0x30(%rbp)
cmpl   $0x0,-0x30(%rbp)
jg     1209 <aaip_encode_both_acl+0xc9>
jmp    12f5 <aaip_encode_both_acl+0x1b5>
jmp    120e <aaip_encode_both_acl+0xce>
cmpq   $0x0,-0x50(%rbp)
je     1224 <aaip_encode_both_acl+0xe4>
cmpq   $0x0,-0x38(%rbp)
jne    1241 <aaip_encode_both_acl+0x101>
mov    -0x58(%rbp),%rax
mov    %rax,-0x60(%rbp)
movq   $0x0,-0x58(%rbp)
mov    -0x40(%rbp),%rax
mov    %rax,-0x48(%rbp)
jmp    12d8 <aaip_encode_both_acl+0x198>
cmpq   $0x0,-0x58(%rbp)
je     1257 <aaip_encode_both_acl+0x117>
cmpq   $0x0,-0x40(%rbp)
jne    1274 <aaip_encode_both_acl+0x134>
mov    -0x50(%rbp),%rax
mov    %rax,-0x60(%rbp)
movq   $0x0,-0x50(%rbp)
mov    -0x38(%rbp),%rax
mov    %rax,-0x48(%rbp)
jmp    12d3 <aaip_encode_both_acl+0x193>
mov    -0x38(%rbp),%rdi
add    -0x40(%rbp),%rdi
mov    $0x1,%esi
call   1050 <calloc@plt>
mov    %rax,-0x60(%rbp)
cmpq   $0x0,-0x60(%rbp)
jne    12a1 <aaip_encode_both_acl+0x161>
movl   $0xffffffff,-0x30(%rbp)
jmp    12f5 <aaip_encode_both_acl+0x1b5>
mov    -0x60(%rbp),%rdi
mov    -0x50(%rbp),%rsi
mov    -0x38(%rbp),%rdx
call   1060 <memcpy@plt>
mov    -0x60(%rbp),%rdi
add    -0x38(%rbp),%rdi
mov    -0x58(%rbp),%rsi
mov    -0x40(%rbp),%rdx
call   1060 <memcpy@plt>
mov    -0x38(%rbp),%rax
add    -0x40(%rbp),%rax
mov    %rax,-0x48(%rbp)
jmp    12d8 <aaip_encode_both_acl+0x198>
mov    -0x60(%rbp),%rcx
mov    -0x28(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x48(%rbp),%rcx
mov    -0x20(%rbp),%rax
mov    %rcx,(%rax)
movl   $0x1,-0x30(%rbp)
cmpq   $0x0,-0x50(%rbp)
je     1309 <aaip_encode_both_acl+0x1c9>
mov    -0x50(%rbp),%rdi
call   1040 <free@plt>
cmpq   $0x0,-0x58(%rbp)
je     131d <aaip_encode_both_acl+0x1dd>
mov    -0x58(%rbp),%rdi
call   1040 <free@plt>
mov    -0x30(%rbp),%eax
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<aaip_encode_both_acl>:
push   %rbp
push   %r15
push   %r14
push   %r12
push   %rbx
sub    $0x20,%rsp
mov    %r9d,%ebx
mov    %r8,%r14
mov    %rcx,%r15
mov    %rsi,%r12
movq   $0x0,0x18(%rsp)
movq   $0x0,0x10(%rsp)
movq   $0x0,0x8(%rsp)
movq   $0x0,(%rsp)
test   %rdi,%rdi
je     11a3 <aaip_encode_both_acl+0x63>
mov    %ebx,%r8d
and    $0xb,%r8d
lea    0x18(%rsp),%rax
lea    0x8(%rsp),%rcx
mov    %edx,%esi
mov    %rax,%rdx
call   1030 <aaip_encode_acl@plt>
test   %eax,%eax
jle    123b <aaip_encode_both_acl+0xfb>
test   %r12,%r12
je     11c7 <aaip_encode_both_acl+0x87>
and    $0x3,%ebx
or     $0x4,%ebx
lea    0x10(%rsp),%rdx
mov    %rsp,%rcx
mov    %r12,%rdi
xor    %esi,%esi
mov    %ebx,%r8d
call   1030 <aaip_encode_acl@plt>
test   %eax,%eax
jle    123b <aaip_encode_both_acl+0xfb>
mov    0x8(%rsp),%rcx
mov    (%rsp),%rbx
test   %rcx,%rcx
je     123f <aaip_encode_both_acl+0xff>
mov    0x18(%rsp),%rax
test   %rax,%rax
je     123f <aaip_encode_both_acl+0xff>
test   %rbx,%rbx
je     124e <aaip_encode_both_acl+0x10e>
mov    0x10(%rsp),%rdi
test   %rdi,%rdi
je     124e <aaip_encode_both_acl+0x10e>
add    %rax,%rdi
mov    $0x1,%esi
call   1050 <calloc@plt>
test   %rax,%rax
je     1291 <aaip_encode_both_acl+0x151>
mov    %rax,%rbx
mov    0x8(%rsp),%rsi
mov    0x18(%rsp),%rdx
mov    %rax,%rdi
call   1060 <memcpy@plt>
mov    0x18(%rsp),%rdi
add    %rbx,%rdi
mov    (%rsp),%rsi
mov    0x10(%rsp),%rdx
call   1060 <memcpy@plt>
mov    0x10(%rsp),%rax
add    0x18(%rsp),%rax
jmp    125a <aaip_encode_both_acl+0x11a>
mov    %eax,%ebp
jmp    1265 <aaip_encode_both_acl+0x125>
movq   $0x0,(%rsp)
mov    0x10(%rsp),%rax
jmp    125a <aaip_encode_both_acl+0x11a>
movq   $0x0,0x8(%rsp)
mov    %rcx,%rbx
mov    %rbx,(%r14)
mov    %rax,(%r15)
mov    $0x1,%ebp
mov    0x8(%rsp),%rdi
test   %rdi,%rdi
je     1274 <aaip_encode_both_acl+0x134>
call   1040 <free@plt>
mov    (%rsp),%rdi
test   %rdi,%rdi
je     1282 <aaip_encode_both_acl+0x142>
call   1040 <free@plt>
mov    %ebp,%eax
add    $0x20,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
ret
mov    $0xffffffff,%ebp
jmp    1265 <aaip_encode_both_acl+0x125>

LLVM IR (-O0):
define i32 @aaip_encode_both_acl(i8* %0, i8* %1, i32 %2, i64* %3, i8** %4, i32 %5) {
%7 = alloca i8*
%8 = alloca i8*
%9 = alloca i32
%10 = alloca i64*
%11 = alloca i8**
%12 = alloca i32
%13 = alloca i32
%14 = alloca i64
%15 = alloca i64
%16 = alloca i64
%17 = alloca i8*
%18 = alloca i8*
%19 = alloca i8*
store i8* %0, i8** %7
store i8* %1, i8** %8
store i32 %2, i32* %9
store i64* %3, i64** %10
store i8** %4, i8*** %11
store i32 %5, i32* %12
store i64 0, i64* %14
store i64 0, i64* %15
store i64 0, i64* %16
store i8* null, i8** %17
store i8* null, i8** %18
store i8* null, i8** %19
%20 = load i8*, i8** %7
%21 = icmp ne i8* %20, null
br i1 %21, label %22, label %32
22: ; preds = %6
%23 = load i8*, i8** %7
%24 = load i32, i32* %9
%25 = load i32, i32* %12
%26 = and i32 %25, 11
%27 = call i32 @aaip_encode_acl(i8* %23, i32 %24, i64* %14, i8** %17, i32 %26)
store i32 %27, i32* %13
%28 = load i32, i32* %13
%29 = icmp sle i32 %28, 0
br i1 %29, label %30, label %31
30: ; preds = %22
br label %91
31: ; preds = %22
br label %32
32: ; preds = %31, %6
%33 = load i8*, i8** %8
%34 = icmp ne i8* %33, null
br i1 %34, label %35, label %45
35: ; preds = %32
%36 = load i8*, i8** %8
%37 = load i32, i32* %12
%38 = and i32 %37, 3
%39 = or i32 %38, 4
%40 = call i32 @aaip_encode_acl(i8* %36, i32 0, i64* %15, i8** %18, i32 %39)
store i32 %40, i32* %13
%41 = load i32, i32* %13
%42 = icmp sle i32 %41, 0
br i1 %42, label %43, label %44
43: ; preds = %35
br label %91
44: ; preds = %35
br label %45
45: ; preds = %44, %32
%46 = load i8*, i8** %17
%47 = icmp eq i8* %46, null
br i1 %47, label %51, label %48
48: ; preds = %45
%49 = load i64, i64* %14
%50 = icmp eq i64 %49, 0
br i1 %50, label %51, label %54
51: ; preds = %48, %45
%52 = load i8*, i8** %18
store i8* %52, i8** %19
store i8* null, i8** %18
%53 = load i64, i64* %15
store i64 %53, i64* %16
br label %86
54: ; preds = %48
%55 = load i8*, i8** %18
%56 = icmp eq i8* %55, null
br i1 %56, label %60, label %57
57: ; preds = %54
%58 = load i64, i64* %15
%59 = icmp eq i64 %58, 0
br i1 %59, label %60, label %63
60: ; preds = %57, %54
%61 = load i8*, i8** %17
store i8* %61, i8** %19
store i8* null, i8** %17
%62 = load i64, i64* %14
store i64 %62, i64* %16
br label %85
63: ; preds = %57
%64 = load i64, i64* %14
%65 = load i64, i64* %15
%66 = add i64 %64, %65
%67 = call i8* @calloc(i64 %66, i32 1)
store i8* %67, i8** %19
%68 = load i8*, i8** %19
%69 = icmp eq i8* %68, null
br i1 %69, label %70, label %71
70: ; preds = %63
store i32 -1, i32* %13
br label %91
71: ; preds = %63
%72 = load i8*, i8** %19
%73 = load i8*, i8** %17
%74 = load i64, i64* %14
%75 = call i32 @memcpy(i8* %72, i8* %73, i64 %74)
%76 = load i8*, i8** %19
%77 = load i64, i64* %14
%78 = getelementptr inbounds i8, i8* %76, i64 %77
%79 = load i8*, i8** %18
%80 = load i64, i64* %15
%81 = call i32 @memcpy(i8* %78, i8* %79, i64 %80)
%82 = load i64, i64* %14
%83 = load i64, i64* %15
%84 = add i64 %82, %83
store i64 %84, i64* %16
br label %85
85: ; preds = %71, %60
br label %86
86: ; preds = %85, %51
%87 = load i8*, i8** %19
%88 = load i8**, i8*** %11
store i8* %87, i8** %88
%89 = load i64, i64* %16
%90 = load i64*, i64** %10
store i64 %89, i64* %90
store i32 1, i32* %13
br label %91
91: ; preds = %86, %70, %43, %30
%92 = load i8*, i8** %17
%93 = icmp ne i8* %92, null
br i1 %93, label %94, label %97
94: ; preds = %91
%95 = load i8*, i8** %17
%96 = call i32 @free(i8* %95)
br label %97
97: ; preds = %94, %91
%98 = load i8*, i8** %18
%99 = icmp ne i8* %98, null
br i1 %99, label %100, label %103
100: ; preds = %97
%101 = load i8*, i8** %18
%102 = call i32 @free(i8* %101)
br label %103
103: ; preds = %100, %97
%104 = load i32, i32* %13
ret i32 %104
}

LLVM IR (-O2):
define i32 @aaip_encode_both_acl(i8* %0, i8* %1, i32 %2, i64* nocapture writeonly %3, i8** nocapture writeonly %4, i32 %5) {
%7 = alloca i64
%8 = alloca i64
%9 = alloca i8*
%10 = alloca i8*
%11 = bitcast i64* %7 to i8*
store i64 0, i64* %7
%12 = bitcast i64* %8 to i8*
store i64 0, i64* %8
%13 = bitcast i8** %9 to i8*
store i8* null, i8** %9
%14 = bitcast i8** %10 to i8*
store i8* null, i8** %10
%15 = icmp eq i8* %0, null
br i1 %15, label %20, label %16
16: ; preds = %6
%17 = and i32 %5, 11
%18 = call i32 @aaip_encode_acl(i8* %0, i32 %2, i64* %7, i8** %9, i32 %17)
%19 = icmp slt i32 %18, 1
br i1 %19, label %61, label %20
20: ; preds = %16, %6
%21 = icmp eq i8* %1, null
br i1 %21, label %27, label %22
22: ; preds = %20
%23 = and i32 %5, 3
%24 = or i32 %23, 4
%25 = call i32 @aaip_encode_acl(i8* %1, i32 0, i64* %8, i8** %10, i32 %24)
%26 = icmp slt i32 %25, 1
br i1 %26, label %61, label %27
27: ; preds = %22, %20
%28 = load i8*, i8** %9
%29 = icmp eq i8* %28, null
%30 = load i64, i64* %7
%31 = icmp eq i64 %30, 0
%32 = select i1 %29, i1 true, i1 %31
%33 = load i8*, i8** %10
br i1 %32, label %34, label %36
34: ; preds = %27
store i8* null, i8** %10
%35 = load i64, i64* %8
br label %58
36: ; preds = %27
%37 = icmp eq i8* %33, null
%38 = load i64, i64* %8
%39 = icmp eq i64 %38, 0
%40 = select i1 %37, i1 true, i1 %39
br i1 %40, label %41, label %42
41: ; preds = %36
store i8* null, i8** %9
br label %58
42: ; preds = %36
%43 = add i64 %38, %30
%44 = call i8* @calloc(i64 %43, i32 1)
%45 = icmp eq i8* %44, null
br i1 %45, label %61, label %46
46: ; preds = %42
%47 = load i8*, i8** %9
%48 = load i64, i64* %7
%49 = call i32 @memcpy(i8* %44, i8* %47, i64 %48)
%50 = load i64, i64* %7
%51 = getelementptr inbounds i8, i8* %44, i64 %50
%52 = load i8*, i8** %10
%53 = load i64, i64* %8
%54 = call i32 @memcpy(i8* %51, i8* %52, i64 %53)
%55 = load i64, i64* %7
%56 = load i64, i64* %8
%57 = add i64 %56, %55
br label %58
58: ; preds = %41, %46, %34
%59 = phi i64 [ %35, %34 ], [ %30, %41 ], [ %57, %46 ]
%60 = phi i8* [ %33, %34 ], [ %28, %41 ], [ %44, %46 ]
store i8* %60, i8** %4
store i64 %59, i64* %3
br label %61
61: ; preds = %42, %22, %16, %58
%62 = phi i32 [ %18, %16 ], [ %25, %22 ], [ 1, %58 ], [ -1, %42 ]
%63 = load i8*, i8** %9
%64 = icmp eq i8* %63, null
br i1 %64, label %67, label %65
65: ; preds = %61
%66 = call i32 @free(i8* %63)
br label %67
67: ; preds = %65, %61
%68 = load i8*, i8** %10
%69 = icmp eq i8* %68, null
br i1 %69, label %72, label %70
70: ; preds = %67
%71 = call i32 @free(i8* %68)
br label %72
72: ; preds = %70, %67
ret i32 %62
}