#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 */
struct aufs_ibusy {
  int /*<<< orphan*/ bindex;
};
typedef int /*<<< orphan*/ a;
typedef int /*<<< orphan*/ DIR;

/* Variables and functions */
scalar_t__ EINVAL;
int dirfd(int /*<<< orphan*/ *);
int do_ibusy(char *, int, struct aufs_ibusy *);
scalar_t__ errno;
scalar_t__ fgets(char *, int, int /*<<< orphan*/);
int /*<<< orphan*/ *opendir(char *);
int /*<<< orphan*/ perror(char *);
int /*<<< orphan*/ stdin;
int /*<<< orphan*/ strtoul(char *, int /*<<< orphan*/ *, int /*<<< orphan*/);
int /*<<< orphan*/ usage(char *);
int main(int argc, char *argv[]) {
  int err, fd, i;
  struct aufs_ibusy ibusy;
  char a[16], *eprefix;
  DIR *dp;
  err = -1;
  errno = EINVAL;
  eprefix = argv[0];
  if (argc < 3) {
    usage(argv[0]);
    goto out;
  }
  eprefix = argv[1];
  dp = opendir(argv[1]);
  if (!dp)
    goto out;
  fd = dirfd(dp);
  eprefix = argv[2];
  errno = 0;
  ibusy.bindex = strtoul(argv[2], NULL, 0);
  if (errno)
    goto out;
  if (argc > 3) {
    for (i = 3; i < argc; i++) {
      eprefix = argv[i];
      err = do_ibusy(argv[i], fd, &ibusy);
      if (err)
        break;
    }
  } else {
    eprefix = a;
    while (fgets(a, sizeof(a), stdin)) {
      err = do_ibusy(a, fd, &ibusy);
      if (err)
        break;
    }
  }
out:
  if (err)
    perror(eprefix);
  return err;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
movl   $0x0,-0x4(%rbp)
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movl   $0xffffffff,-0x14(%rbp)
mov    0x2e3c(%rip),%rax
mov    (%rax),%rcx
mov    0x2e3a(%rip),%rax
mov    %rcx,(%rax)
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x38(%rbp)
cmpl   $0x3,-0x8(%rbp)
jge    11c7 <main+0x57>
mov    -0x10(%rbp),%rax
mov    (%rax),%rdi
call   1070 <usage@plt>
jmp    130f <main+0x19f>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rax
mov    %rax,-0x38(%rbp)
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rdi
call   1030 <opendir@plt>
mov    %rax,-0x40(%rbp)
cmpq   $0x0,-0x40(%rbp)
jne    11f4 <main+0x84>
jmp    130f <main+0x19f>
mov    -0x40(%rbp),%rdi
call   1060 <dirfd@plt>
mov    %eax,-0x18(%rbp)
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rax
mov    %rax,-0x38(%rbp)
mov    0x2dc5(%rip),%rax
movq   $0x0,(%rax)
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rdi
xor    %eax,%eax
mov    %eax,%esi
xor    %edx,%edx
call   1090 <strtoul@plt>
mov    %eax,-0x20(%rbp)
mov    0x2da1(%rip),%rax
cmpq   $0x0,(%rax)
je     1246 <main+0xd6>
jmp    130f <main+0x19f>
cmpl   $0x3,-0x8(%rbp)
jle    12b5 <main+0x145>
movl   $0x3,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    12b0 <main+0x140>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x38(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
mov    -0x18(%rbp),%esi
lea    -0x20(%rbp),%rdx
call   1040 <do_ibusy@plt>
mov    %eax,-0x14(%rbp)
cmpl   $0x0,-0x14(%rbp)
je     129d <main+0x12d>
jmp    12b0 <main+0x140>
jmp    12a2 <main+0x132>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1257 <main+0xe7>
jmp    130a <main+0x19a>
lea    -0x30(%rbp),%rax
mov    %rax,-0x38(%rbp)
lea    -0x30(%rbp),%rdi
mov    0x2d20(%rip),%rax
mov    (%rax),%edx
mov    $0x10,%esi
call   1050 <fgets@plt>
cmp    $0x0,%rax
je     1305 <main+0x195>
lea    -0x30(%rbp),%rdi
mov    -0x18(%rbp),%esi
lea    -0x20(%rbp),%rdx
call   1040 <do_ibusy@plt>
mov    %eax,-0x14(%rbp)
cmpl   $0x0,-0x14(%rbp)
je     1300 <main+0x190>
jmp    1305 <main+0x195>
jmp    12bd <main+0x14d>
jmp    130a <main+0x19a>
jmp    130f <main+0x19f>
cmpl   $0x0,-0x14(%rbp)
je     1322 <main+0x1b2>
mov    -0x38(%rbp),%rdi
call   1080 <perror@plt>
mov    -0x14(%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    $0x28,%rsp
mov    %rsi,%r15
mov    0x2e48(%rip),%rax
mov    (%rax),%rax
mov    0x2e46(%rip),%r13
mov    %rax,0x0(%r13)
cmp    $0x2,%edi
jle    127c <main+0x10c>
mov    %edi,%r12d
mov    0x8(%r15),%rbx
mov    %rbx,%rdi
call   1030 <opendir@plt>
mov    $0xffffffff,%ebp
test   %rax,%rax
je     1290 <main+0x120>
mov    %rax,%rdi
call   1060 <dirfd@plt>
mov    %eax,%r14d
mov    0x10(%r15),%rbx
movq   $0x0,0x0(%r13)
mov    %rbx,%rdi
xor    %esi,%esi
xor    %edx,%edx
call   1090 <strtoul@plt>
mov    %eax,0x8(%rsp)
cmpq   $0x0,0x0(%r13)
jne    1290 <main+0x120>
cmp    $0x3,%r12d
jbe    1223 <main+0xb3>
mov    %r12d,%r13d
mov    $0x3,%r12d
nopl   (%rax)
mov    (%r15,%r12,8),%rbx
mov    %rbx,%rdi
mov    %r14d,%esi
lea    0x8(%rsp),%rdx
call   1040 <do_ibusy@plt>
test   %eax,%eax
jne    128e <main+0x11e>
add    $0x1,%r12
cmp    %r12,%r13
jne    1200 <main+0x90>
jmp    1278 <main+0x108>
lea    0x10(%rsp),%rbx
mov    0x2db9(%rip),%r12
mov    (%r12),%edx
mov    %rbx,%rdi
mov    $0x10,%esi
call   1050 <fgets@plt>
test   %rax,%rax
je     1290 <main+0x120>
lea    0x10(%rsp),%rbx
lea    0x8(%rsp),%r15
nop
mov    %rbx,%rdi
mov    %r14d,%esi
mov    %r15,%rdx
call   1040 <do_ibusy@plt>
test   %eax,%eax
jne    128e <main+0x11e>
mov    (%r12),%edx
mov    %rbx,%rdi
mov    $0x10,%esi
call   1050 <fgets@plt>
test   %rax,%rax
jne    1250 <main+0xe0>
xor    %ebp,%ebp
jmp    1298 <main+0x128>
mov    (%r15),%rbx
mov    %rbx,%rdi
call   1070 <usage@plt>
mov    $0xffffffff,%ebp
jmp    1290 <main+0x120>
mov    %eax,%ebp
mov    %rbx,%rdi
call   1080 <perror@plt>
mov    %ebp,%eax
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
%struct.aufs_ibusy = type { i32 }
@EINVAL = global i64 0
@errno = global i64 0
@stdin = global i32 0
define i32 @main(i32 %0, i8** %1) {
%3 = alloca i32
%4 = alloca i32
%5 = alloca i8**
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca %struct.aufs_ibusy
%10 = alloca [16 x i8]
%11 = alloca i8*
%12 = alloca i32*
store i32 0, i32* %3
store i32 %0, i32* %4
store i8** %1, i8*** %5
store i32 -1, i32* %6
%13 = load i64, i64* @EINVAL
store i64 %13, i64* @errno
%14 = load i8**, i8*** %5
%15 = getelementptr inbounds i8*, i8** %14, i64 0
%16 = load i8*, i8** %15
store i8* %16, i8** %11
%17 = load i32, i32* %4
%18 = icmp slt i32 %17, 3
br i1 %18, label %19, label %24
19: ; preds = %2
%20 = load i8**, i8*** %5
%21 = getelementptr inbounds i8*, i8** %20, i64 0
%22 = load i8*, i8** %21
%23 = call i32 @usage(i8* %22)
br label %95
24: ; preds = %2
%25 = load i8**, i8*** %5
%26 = getelementptr inbounds i8*, i8** %25, i64 1
%27 = load i8*, i8** %26
store i8* %27, i8** %11
%28 = load i8**, i8*** %5
%29 = getelementptr inbounds i8*, i8** %28, i64 1
%30 = load i8*, i8** %29
%31 = call i32* @opendir(i8* %30)
store i32* %31, i32** %12
%32 = load i32*, i32** %12
%33 = icmp ne i32* %32, null
br i1 %33, label %35, label %34
34: ; preds = %24
br label %95
35: ; preds = %24
%36 = load i32*, i32** %12
%37 = call i32 @dirfd(i32* %36)
store i32 %37, i32* %7
%38 = load i8**, i8*** %5
%39 = getelementptr inbounds i8*, i8** %38, i64 2
%40 = load i8*, i8** %39
store i8* %40, i8** %11
store i64 0, i64* @errno
%41 = load i8**, i8*** %5
%42 = getelementptr inbounds i8*, i8** %41, i64 2
%43 = load i8*, i8** %42
%44 = call i32 @strtoul(i8* %43, i32* null, i32 0)
%45 = getelementptr inbounds %struct.aufs_ibusy, %struct.aufs_ibusy* %9, i32 0, i32 0
store i32 %44, i32* %45
%46 = load i64, i64* @errno
%47 = icmp ne i64 %46, 0
br i1 %47, label %48, label %49
48: ; preds = %35
br label %95
49: ; preds = %35
%50 = load i32, i32* %4
%51 = icmp sgt i32 %50, 3
br i1 %51, label %52, label %78
52: ; preds = %49
store i32 3, i32* %8
br label %53
53: ; preds = %74, %52
%54 = load i32, i32* %8
%55 = load i32, i32* %4
%56 = icmp slt i32 %54, %55
br i1 %56, label %57, label %77
57: ; preds = %53
%58 = load i8**, i8*** %5
%59 = load i32, i32* %8
%60 = sext i32 %59 to i64
%61 = getelementptr inbounds i8*, i8** %58, i64 %60
%62 = load i8*, i8** %61
store i8* %62, i8** %11
%63 = load i8**, i8*** %5
%64 = load i32, i32* %8
%65 = sext i32 %64 to i64
%66 = getelementptr inbounds i8*, i8** %63, i64 %65
%67 = load i8*, i8** %66
%68 = load i32, i32* %7
%69 = call i32 @do_ibusy(i8* %67, i32 %68, %struct.aufs_ibusy* %9)
store i32 %69, i32* %6
%70 = load i32, i32* %6
%71 = icmp ne i32 %70, 0
br i1 %71, label %72, label %73
72: ; preds = %57
br label %77
73: ; preds = %57
br label %74
74: ; preds = %73
%75 = load i32, i32* %8
%76 = add nsw i32 %75, 1
store i32 %76, i32* %8
br label %53
77: ; preds = %72, %53
br label %94
78: ; preds = %49
%79 = getelementptr inbounds [16 x i8], [16 x i8]* %10, i64 0, i64 0
store i8* %79, i8** %11
br label %80
80: ; preds = %92, %78
%81 = getelementptr inbounds [16 x i8], [16 x i8]* %10, i64 0, i64 0
%82 = load i32, i32* @stdin
%83 = call i64 @fgets(i8* %81, i32 16, i32 %82)
%84 = icmp ne i64 %83, 0
br i1 %84, label %85, label %93
85: ; preds = %80
%86 = getelementptr inbounds [16 x i8], [16 x i8]* %10, i64 0, i64 0
%87 = load i32, i32* %7
%88 = call i32 @do_ibusy(i8* %86, i32 %87, %struct.aufs_ibusy* %9)
store i32 %88, i32* %6
%89 = load i32, i32* %6
%90 = icmp ne i32 %89, 0
br i1 %90, label %91, label %92
91: ; preds = %85
br label %93
92: ; preds = %85
br label %80
93: ; preds = %91, %80
br label %94
94: ; preds = %93, %77
br label %95
95: ; preds = %94, %48, %34, %19
%96 = load i32, i32* %6
%97 = icmp ne i32 %96, 0
br i1 %97, label %98, label %101
98: ; preds = %95
%99 = load i8*, i8** %11
%100 = call i32 @perror(i8* %99)
br label %101
101: ; preds = %98, %95
%102 = load i32, i32* %6
ret i32 %102
}

LLVM IR (-O2):
%struct.aufs_ibusy = type { i32 }
@EINVAL = global i64 0
@errno = global i64 0
@stdin = global i32 0
define i32 @main(i32 %0, i8** nocapture %1) {
%3 = alloca %struct.aufs_ibusy
%4 = alloca [16 x i8]
%5 = bitcast %struct.aufs_ibusy* %3 to i8*
%6 = getelementptr inbounds [16 x i8], [16 x i8]* %4, i64 0, i64 0
%7 = load i64, i64* @EINVAL
store i64 %7, i64* @errno
%8 = load i8*, i8** %1
%9 = icmp slt i32 %0, 3
br i1 %9, label %10, label %12
10: ; preds = %2
%11 = tail call i32 @usage(i8* %8)
br label %49
12: ; preds = %2
%13 = getelementptr inbounds i8*, i8** %1, i64 1
%14 = load i8*, i8** %13
%15 = tail call i32* @opendir(i8* %14)
%16 = icmp eq i32* %15, null
br i1 %16, label %49, label %17
17: ; preds = %12
%18 = tail call i32 @dirfd(i32* %15)
%19 = getelementptr inbounds i8*, i8** %1, i64 2
%20 = load i8*, i8** %19
store i64 0, i64* @errno
%21 = tail call i32 @strtoul(i8* nocapture %20, i32* null, i32 0)
%22 = getelementptr inbounds %struct.aufs_ibusy, %struct.aufs_ibusy* %3, i64 0, i32 0
store i32 %21, i32* %22
%23 = load i64, i64* @errno
%24 = icmp eq i64 %23, 0
br i1 %24, label %25, label %49
25: ; preds = %17
%26 = icmp ugt i32 %0, 3
br i1 %26, label %31, label %27
27: ; preds = %25
%28 = load i32, i32* @stdin
%29 = call i64 @fgets(i8* %6, i32 16, i32 %28)
%30 = icmp eq i64 %29, 0
br i1 %30, label %49, label %46
31: ; preds = %25
%32 = zext i32 %0 to i64
br label %35
33: ; preds = %35
%34 = icmp eq i64 %41, %32
br i1 %34, label %53, label %35
35: ; preds = %31, %33
%36 = phi i64 [ 3, %31 ], [ %41, %33 ]
%37 = getelementptr inbounds i8*, i8** %1, i64 %36
%38 = load i8*, i8** %37
%39 = call i32 @do_ibusy(i8* %38, i32 %18, %struct.aufs_ibusy* %3)
%40 = icmp eq i32 %39, 0
%41 = add nuw nsw i64 %36, 1
br i1 %40, label %33, label %49
42: ; preds = %46
%43 = load i32, i32* @stdin
%44 = call i64 @fgets(i8* %6, i32 16, i32 %43)
%45 = icmp eq i64 %44, 0
br i1 %45, label %53, label %46
46: ; preds = %27, %42
%47 = call i32 @do_ibusy(i8* %6, i32 %18, %struct.aufs_ibusy* %3)
%48 = icmp eq i32 %47, 0
br i1 %48, label %42, label %49
49: ; preds = %46, %35, %27, %12, %17, %10
%50 = phi i32 [ -1, %12 ], [ -1, %17 ], [ -1, %10 ], [ -1, %27 ], [ %39, %35 ], [ %47, %46 ]
%51 = phi i8* [ %14, %12 ], [ %20, %17 ], [ %8, %10 ], [ %6, %27 ], [ %38, %35 ], [ %6, %46 ]
%52 = call i32 @perror(i8* %51)
br label %53
53: ; preds = %42, %33, %49
%54 = phi i32 [ %50, %49 ], [ 0, %33 ], [ 0, %42 ]
ret i32 %54
}