#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 */
unsigned long O_APPEND;
unsigned long O_ASYNC;
unsigned long O_CLOEXEC;
unsigned long O_CREAT;
unsigned long O_EXCL;
unsigned long O_NOCTTY;
unsigned long O_NOFOLLOW;
unsigned long O_RDWR;
unsigned long O_SYNC;
unsigned long O_TRUNC;
unsigned long O_WRONLY;
size_t scnprintf(char *, size_t, char *, ...);
size_t open__scnprintf_flags(unsigned long flags, char *bf, size_t size) {
  int printed = 0;
  if (flags == 0)
    return scnprintf(bf, size, "RDONLY");
  if (flags & O_RDWR) {
    printed += scnprintf(bf + printed, size - printed, "%s%s",
                         printed ? "|" : "", "RDWR");
    flags &= ~O_RDWR;
  };
  if (flags & O_APPEND) {
    printed += scnprintf(bf + printed, size - printed, "%s%s",
                         printed ? "|" : "", "APPEND");
    flags &= ~O_APPEND;
  };
  if (flags & O_ASYNC) {
    printed += scnprintf(bf + printed, size - printed, "%s%s",
                         printed ? "|" : "", "ASYNC");
    flags &= ~O_ASYNC;
  };
  if (flags & O_CLOEXEC) {
    printed += scnprintf(bf + printed, size - printed, "%s%s",
                         printed ? "|" : "", "CLOEXEC");
    flags &= ~O_CLOEXEC;
  };
  if (flags & O_CREAT) {
    printed += scnprintf(bf + printed, size - printed, "%s%s",
                         printed ? "|" : "", "CREAT");
    flags &= ~O_CREAT;
  };
  if (flags & 00040000) {
    printed += scnprintf(bf + printed, size - printed, "%s%s",
                         printed ? "|" : "", "DIRECT");
    flags &= ~00040000;
  };
  if (flags & 00200000) {
    printed += scnprintf(bf + printed, size - printed, "%s%s",
                         printed ? "|" : "", "DIRECTORY");
    flags &= ~00200000;
  };
  if (flags & O_EXCL) {
    printed += scnprintf(bf + printed, size - printed, "%s%s",
                         printed ? "|" : "", "EXCL");
    flags &= ~O_EXCL;
  };
  if (flags & 00100000) {
    printed += scnprintf(bf + printed, size - printed, "%s%s",
                         printed ? "|" : "", "LARGEFILE");
    flags &= ~00100000;
  };
  if (flags & O_NOFOLLOW) {
    printed += scnprintf(bf + printed, size - printed, "%s%s",
                         printed ? "|" : "", "NOFOLLOW");
    flags &= ~O_NOFOLLOW;
  };
  if (flags & 020000000) {
    printed += scnprintf(bf + printed, size - printed, "%s%s",
                         printed ? "|" : "", "TMPFILE");
    flags &= ~020000000;
  };
  if (flags & 01000000) {
    printed += scnprintf(bf + printed, size - printed, "%s%s",
                         printed ? "|" : "", "NOATIME");
    flags &= ~01000000;
  };
  if (flags & O_NOCTTY) {
    printed += scnprintf(bf + printed, size - printed, "%s%s",
                         printed ? "|" : "", "NOCTTY");
    flags &= ~O_NOCTTY;
  };
  if (flags & O_SYNC) {
    printed += scnprintf(bf + printed, size - printed, "%s%s",
                         printed ? "|" : "", "SYNC");
    flags &= ~O_SYNC;
  };
  if (flags & O_TRUNC) {
    printed += scnprintf(bf + printed, size - printed, "%s%s",
                         printed ? "|" : "", "TRUNC");
    flags &= ~O_TRUNC;
  };
  if (flags & O_WRONLY) {
    printed += scnprintf(bf + printed, size - printed, "%s%s",
                         printed ? "|" : "", "WRONLY");
    flags &= ~O_WRONLY;
  };
  if (flags)
    printed += scnprintf(bf + printed, size - printed, "%s%#x",
                         printed ? "|" : "", flags);
  return printed;
}


x86 assembly (clang, -O0):
<open__scnprintf_flags>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
cmpq   $0x0,-0x10(%rbp)
jne    1155 <open__scnprintf_flags+0x45>
mov    -0x18(%rbp),%rdi
mov    -0x20(%rbp),%rsi
lea    0xebb(%rip),%rdx
mov    $0x0,%al
call   1030 <scnprintf@plt>
mov    %rax,-0x8(%rbp)
jmp    1959 <open__scnprintf_flags+0x849>
mov    -0x10(%rbp),%rax
mov    0x2e70(%rip),%rcx
and    (%rcx),%rax
cmp    $0x0,%rax
je     11d3 <open__scnprintf_flags+0xc3>
mov    -0x18(%rbp),%rdi
movslq -0x24(%rbp),%rax
add    %rax,%rdi
mov    -0x20(%rbp),%rsi
movslq -0x24(%rbp),%rax
sub    %rax,%rsi
mov    -0x24(%rbp),%edx
lea    0xe9a(%rip),%rcx
lea    0xe78(%rip),%rax
cmp    $0x0,%edx
cmovne %rax,%rcx
lea    0xe65(%rip),%rdx
lea    0xe65(%rip),%r8
mov    $0x0,%al
call   1030 <scnprintf@plt>
mov    %rax,%rcx
movslq -0x24(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x24(%rbp)
mov    0x2e0c(%rip),%rax
mov    (%rax),%rax
xor    $0xffffffffffffffff,%rax
and    -0x10(%rbp),%rax
mov    %rax,-0x10(%rbp)
mov    -0x10(%rbp),%rax
mov    0x2db2(%rip),%rcx
and    (%rcx),%rax
cmp    $0x0,%rax
je     1251 <open__scnprintf_flags+0x141>
mov    -0x18(%rbp),%rdi
movslq -0x24(%rbp),%rax
add    %rax,%rdi
mov    -0x20(%rbp),%rsi
movslq -0x24(%rbp),%rax
sub    %rax,%rsi
mov    -0x24(%rbp),%edx
lea    0xe1c(%rip),%rcx
lea    0xdfa(%rip),%rax
cmp    $0x0,%edx
cmovne %rax,%rcx
lea    0xde7(%rip),%rdx
lea    0xdec(%rip),%r8
mov    $0x0,%al
call   1030 <scnprintf@plt>
mov    %rax,%rcx
movslq -0x24(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x24(%rbp)
mov    0x2d4e(%rip),%rax
mov    (%rax),%rax
xor    $0xffffffffffffffff,%rax
and    -0x10(%rbp),%rax
mov    %rax,-0x10(%rbp)
mov    -0x10(%rbp),%rax
mov    0x2d4c(%rip),%rcx
and    (%rcx),%rax
cmp    $0x0,%rax
je     12cf <open__scnprintf_flags+0x1bf>
mov    -0x18(%rbp),%rdi
movslq -0x24(%rbp),%rax
add    %rax,%rdi
mov    -0x20(%rbp),%rsi
movslq -0x24(%rbp),%rax
sub    %rax,%rsi
mov    -0x24(%rbp),%edx
lea    0xd9e(%rip),%rcx
lea    0xd7c(%rip),%rax
cmp    $0x0,%edx
cmovne %rax,%rcx
lea    0xd69(%rip),%rdx
lea    0xd75(%rip),%r8
mov    $0x0,%al
call   1030 <scnprintf@plt>
mov    %rax,%rcx
movslq -0x24(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x24(%rbp)
mov    0x2ce8(%rip),%rax
mov    (%rax),%rax
xor    $0xffffffffffffffff,%rax
and    -0x10(%rbp),%rax
mov    %rax,-0x10(%rbp)
mov    -0x10(%rbp),%rax
mov    0x2cae(%rip),%rcx
and    (%rcx),%rax
cmp    $0x0,%rax
je     134d <open__scnprintf_flags+0x23d>
mov    -0x18(%rbp),%rdi
movslq -0x24(%rbp),%rax
add    %rax,%rdi
mov    -0x20(%rbp),%rsi
movslq -0x24(%rbp),%rax
sub    %rax,%rsi
mov    -0x24(%rbp),%edx
lea    0xd20(%rip),%rcx
lea    0xcfe(%rip),%rax
cmp    $0x0,%edx
cmovne %rax,%rcx
lea    0xceb(%rip),%rdx
lea    0xcfd(%rip),%r8
mov    $0x0,%al
call   1030 <scnprintf@plt>
mov    %rax,%rcx
movslq -0x24(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x24(%rbp)
mov    0x2c4a(%rip),%rax
mov    (%rax),%rax
xor    $0xffffffffffffffff,%rax
and    -0x10(%rbp),%rax
mov    %rax,-0x10(%rbp)
mov    -0x10(%rbp),%rax
mov    0x2ca0(%rip),%rcx
and    (%rcx),%rax
cmp    $0x0,%rax
je     13cb <open__scnprintf_flags+0x2bb>
mov    -0x18(%rbp),%rdi
movslq -0x24(%rbp),%rax
add    %rax,%rdi
mov    -0x20(%rbp),%rsi
movslq -0x24(%rbp),%rax
sub    %rax,%rsi
mov    -0x24(%rbp),%edx
lea    0xca2(%rip),%rcx
lea    0xc80(%rip),%rax
cmp    $0x0,%edx
cmovne %rax,%rcx
lea    0xc6d(%rip),%rdx
lea    0xc87(%rip),%r8
mov    $0x0,%al
call   1030 <scnprintf@plt>
mov    %rax,%rcx
movslq -0x24(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x24(%rbp)
mov    0x2c3c(%rip),%rax
mov    (%rax),%rax
xor    $0xffffffffffffffff,%rax
and    -0x10(%rbp),%rax
mov    %rax,-0x10(%rbp)
mov    -0x10(%rbp),%rax
and    $0x4000,%rax
cmp    $0x0,%rax
je     143d <open__scnprintf_flags+0x32d>
mov    -0x18(%rbp),%rdi
movslq -0x24(%rbp),%rax
add    %rax,%rdi
mov    -0x20(%rbp),%rsi
movslq -0x24(%rbp),%rax
sub    %rax,%rsi
mov    -0x24(%rbp),%edx
lea    0xc28(%rip),%rcx
lea    0xc06(%rip),%rax
cmp    $0x0,%edx
cmovne %rax,%rcx
lea    0xbf3(%rip),%rdx
lea    0xc13(%rip),%r8
mov    $0x0,%al
call   1030 <scnprintf@plt>
mov    %rax,%rcx
movslq -0x24(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x24(%rbp)
mov    -0x10(%rbp),%rax
and    $0xffffffffffffbfff,%rax
mov    %rax,-0x10(%rbp)
mov    -0x10(%rbp),%rax
and    $0x10000,%rax
cmp    $0x0,%rax
je     14af <open__scnprintf_flags+0x39f>
mov    -0x18(%rbp),%rdi
movslq -0x24(%rbp),%rax
add    %rax,%rdi
mov    -0x20(%rbp),%rsi
movslq -0x24(%rbp),%rax
sub    %rax,%rsi
mov    -0x24(%rbp),%edx
lea    0xbb6(%rip),%rcx
lea    0xb94(%rip),%rax
cmp    $0x0,%edx
cmovne %rax,%rcx
lea    0xb81(%rip),%rdx
lea    0xba8(%rip),%r8
mov    $0x0,%al
call   1030 <scnprintf@plt>
mov    %rax,%rcx
movslq -0x24(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x24(%rbp)
mov    -0x10(%rbp),%rax
and    $0xfffffffffffeffff,%rax
mov    %rax,-0x10(%rbp)
mov    -0x10(%rbp),%rax
mov    0x2af6(%rip),%rcx
and    (%rcx),%rax
cmp    $0x0,%rax
je     152d <open__scnprintf_flags+0x41d>
mov    -0x18(%rbp),%rdi
movslq -0x24(%rbp),%rax
add    %rax,%rdi
mov    -0x20(%rbp),%rsi
movslq -0x24(%rbp),%rax
sub    %rax,%rsi
mov    -0x24(%rbp),%edx
lea    0xb40(%rip),%rcx
lea    0xb1e(%rip),%rax
cmp    $0x0,%edx
cmovne %rax,%rcx
lea    0xb0b(%rip),%rdx
lea    0xb3c(%rip),%r8
mov    $0x0,%al
call   1030 <scnprintf@plt>
mov    %rax,%rcx
movslq -0x24(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x24(%rbp)
mov    0x2a92(%rip),%rax
mov    (%rax),%rax
xor    $0xffffffffffffffff,%rax
and    -0x10(%rbp),%rax
mov    %rax,-0x10(%rbp)
mov    -0x10(%rbp),%rax
and    $0x8000,%rax
cmp    $0x0,%rax
je     159f <open__scnprintf_flags+0x48f>
mov    -0x18(%rbp),%rdi
movslq -0x24(%rbp),%rax
add    %rax,%rdi
mov    -0x20(%rbp),%rsi
movslq -0x24(%rbp),%rax
sub    %rax,%rsi
mov    -0x24(%rbp),%edx
lea    0xac6(%rip),%rcx
lea    0xaa4(%rip),%rax
cmp    $0x0,%edx
cmovne %rax,%rcx
lea    0xa91(%rip),%rdx
lea    0xac7(%rip),%r8
mov    $0x0,%al
call   1030 <scnprintf@plt>
mov    %rax,%rcx
movslq -0x24(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x24(%rbp)
mov    -0x10(%rbp),%rax
and    $0xffffffffffff7fff,%rax
mov    %rax,-0x10(%rbp)
mov    -0x10(%rbp),%rax
mov    0x2a46(%rip),%rcx
and    (%rcx),%rax
cmp    $0x0,%rax
je     161d <open__scnprintf_flags+0x50d>
mov    -0x18(%rbp),%rdi
movslq -0x24(%rbp),%rax
add    %rax,%rdi
mov    -0x20(%rbp),%rsi
movslq -0x24(%rbp),%rax
sub    %rax,%rsi
mov    -0x24(%rbp),%edx
lea    0xa50(%rip),%rcx
lea    0xa2e(%rip),%rax
cmp    $0x0,%edx
cmovne %rax,%rcx
lea    0xa1b(%rip),%rdx
lea    0xa5b(%rip),%r8
mov    $0x0,%al
call   1030 <scnprintf@plt>
mov    %rax,%rcx
movslq -0x24(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x24(%rbp)
mov    0x29e2(%rip),%rax
mov    (%rax),%rax
xor    $0xffffffffffffffff,%rax
and    -0x10(%rbp),%rax
mov    %rax,-0x10(%rbp)
mov    -0x10(%rbp),%rax
and    $0x400000,%rax
cmp    $0x0,%rax
je     168f <open__scnprintf_flags+0x57f>
mov    -0x18(%rbp),%rdi
movslq -0x24(%rbp),%rax
add    %rax,%rdi
mov    -0x20(%rbp),%rsi
movslq -0x24(%rbp),%rax
sub    %rax,%rsi
mov    -0x24(%rbp),%edx
lea    0x9d6(%rip),%rcx
lea    0x9b4(%rip),%rax
cmp    $0x0,%edx
cmovne %rax,%rcx
lea    0x9a1(%rip),%rdx
lea    0x9ea(%rip),%r8
mov    $0x0,%al
call   1030 <scnprintf@plt>
mov    %rax,%rcx
movslq -0x24(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x24(%rbp)
mov    -0x10(%rbp),%rax
and    $0xffffffffffbfffff,%rax
mov    %rax,-0x10(%rbp)
mov    -0x10(%rbp),%rax
and    $0x40000,%rax
cmp    $0x0,%rax
je     1701 <open__scnprintf_flags+0x5f1>
mov    -0x18(%rbp),%rdi
movslq -0x24(%rbp),%rax
add    %rax,%rdi
mov    -0x20(%rbp),%rsi
movslq -0x24(%rbp),%rax
sub    %rax,%rsi
mov    -0x24(%rbp),%edx
lea    0x964(%rip),%rcx
lea    0x942(%rip),%rax
cmp    $0x0,%edx
cmovne %rax,%rcx
lea    0x92f(%rip),%rdx
lea    0x980(%rip),%r8
mov    $0x0,%al
call   1030 <scnprintf@plt>
mov    %rax,%rcx
movslq -0x24(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x24(%rbp)
mov    -0x10(%rbp),%rax
and    $0xfffffffffffbffff,%rax
mov    %rax,-0x10(%rbp)
mov    -0x10(%rbp),%rax
mov    0x28ac(%rip),%rcx
and    (%rcx),%rax
cmp    $0x0,%rax
je     177f <open__scnprintf_flags+0x66f>
mov    -0x18(%rbp),%rdi
movslq -0x24(%rbp),%rax
add    %rax,%rdi
mov    -0x20(%rbp),%rsi
movslq -0x24(%rbp),%rax
sub    %rax,%rsi
mov    -0x24(%rbp),%edx
lea    0x8ee(%rip),%rcx
lea    0x8cc(%rip),%rax
cmp    $0x0,%edx
cmovne %rax,%rcx
lea    0x8b9(%rip),%rdx
lea    0x912(%rip),%r8
mov    $0x0,%al
call   1030 <scnprintf@plt>
mov    %rax,%rcx
movslq -0x24(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x24(%rbp)
mov    0x2848(%rip),%rax
mov    (%rax),%rax
xor    $0xffffffffffffffff,%rax
and    -0x10(%rbp),%rax
mov    %rax,-0x10(%rbp)
mov    -0x10(%rbp),%rax
mov    0x283e(%rip),%rcx
and    (%rcx),%rax
cmp    $0x0,%rax
je     17fd <open__scnprintf_flags+0x6ed>
mov    -0x18(%rbp),%rdi
movslq -0x24(%rbp),%rax
add    %rax,%rdi
mov    -0x20(%rbp),%rsi
movslq -0x24(%rbp),%rax
sub    %rax,%rsi
mov    -0x24(%rbp),%edx
lea    0x870(%rip),%rcx
lea    0x84e(%rip),%rax
cmp    $0x0,%edx
cmovne %rax,%rcx
lea    0x83b(%rip),%rdx
lea    0x848(%rip),%r8
mov    $0x0,%al
call   1030 <scnprintf@plt>
mov    %rax,%rcx
movslq -0x24(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x24(%rbp)
mov    0x27da(%rip),%rax
mov    (%rax),%rax
xor    $0xffffffffffffffff,%rax
and    -0x10(%rbp),%rax
mov    %rax,-0x10(%rbp)
mov    -0x10(%rbp),%rax
mov    0x27e0(%rip),%rcx
and    (%rcx),%rax
cmp    $0x0,%rax
je     187b <open__scnprintf_flags+0x76b>
mov    -0x18(%rbp),%rdi
movslq -0x24(%rbp),%rax
add    %rax,%rdi
mov    -0x20(%rbp),%rsi
movslq -0x24(%rbp),%rax
sub    %rax,%rsi
mov    -0x24(%rbp),%edx
lea    0x7f2(%rip),%rcx
lea    0x7d0(%rip),%rax
cmp    $0x0,%edx
cmovne %rax,%rcx
lea    0x7bd(%rip),%rdx
lea    0x81d(%rip),%r8
mov    $0x0,%al
call   1030 <scnprintf@plt>
mov    %rax,%rcx
movslq -0x24(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x24(%rbp)
mov    0x277c(%rip),%rax
mov    (%rax),%rax
xor    $0xffffffffffffffff,%rax
and    -0x10(%rbp),%rax
mov    %rax,-0x10(%rbp)
mov    -0x10(%rbp),%rax
mov    0x2712(%rip),%rcx
and    (%rcx),%rax
cmp    $0x0,%rax
je     18f9 <open__scnprintf_flags+0x7e9>
mov    -0x18(%rbp),%rdi
movslq -0x24(%rbp),%rax
add    %rax,%rdi
mov    -0x20(%rbp),%rsi
movslq -0x24(%rbp),%rax
sub    %rax,%rsi
mov    -0x24(%rbp),%edx
lea    0x774(%rip),%rcx
lea    0x752(%rip),%rax
cmp    $0x0,%edx
cmovne %rax,%rcx
lea    0x73f(%rip),%rdx
lea    0x7a5(%rip),%r8
mov    $0x0,%al
call   1030 <scnprintf@plt>
mov    %rax,%rcx
movslq -0x24(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x24(%rbp)
mov    0x26ae(%rip),%rax
mov    (%rax),%rax
xor    $0xffffffffffffffff,%rax
and    -0x10(%rbp),%rax
mov    %rax,-0x10(%rbp)
cmpq   $0x0,-0x10(%rbp)
je     1951 <open__scnprintf_flags+0x841>
mov    -0x18(%rbp),%rdi
movslq -0x24(%rbp),%rax
add    %rax,%rdi
mov    -0x20(%rbp),%rsi
movslq -0x24(%rbp),%rax
sub    %rax,%rsi
mov    -0x24(%rbp),%edx
lea    0x703(%rip),%rcx
lea    0x6e1(%rip),%rax
cmp    $0x0,%edx
cmovne %rax,%rcx
mov    -0x10(%rbp),%r8
lea    0x73e(%rip),%rdx
mov    $0x0,%al
call   1030 <scnprintf@plt>
mov    %rax,%rcx
movslq -0x24(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x24(%rbp)
movslq -0x24(%rbp),%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<open__scnprintf_flags>:
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %rdx,%r14
mov    %rsi,%r15
test   %rdi,%rdi
je     1162 <open__scnprintf_flags+0x52>
mov    %rdi,%r13
mov    0x2ea2(%rip),%r12
test   %rdi,(%r12)
je     117f <open__scnprintf_flags+0x6f>
lea    0xecc(%rip),%rdx
lea    0xee5(%rip),%rcx
lea    0xec5(%rip),%r8
mov    %r15,%rdi
mov    %r14,%rsi
xor    %eax,%eax
call   1030 <scnprintf@plt>
mov    (%r12),%rcx
not    %rcx
and    %rcx,%r13
jmp    1181 <open__scnprintf_flags+0x71>
lea    0xe97(%rip),%rdx
mov    %r15,%rdi
mov    %r14,%rsi
xor    %eax,%eax
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
jmp    1030 <scnprintf@plt>
xor    %eax,%eax
mov    0x2e08(%rip),%r12
test   %r13,(%r12)
je     11d0 <open__scnprintf_flags+0xc0>
movslq %eax,%rbx
lea    (%r15,%rbx,1),%rdi
mov    %r14,%rsi
sub    %rbx,%rsi
test   %ebx,%ebx
lea    0xe83(%rip),%rax
lea    0xe61(%rip),%rcx
cmove  %rax,%rcx
lea    0xe51(%rip),%rdx
lea    0xe56(%rip),%r8
xor    %eax,%eax
call   1030 <scnprintf@plt>
add    %ebx,%eax
mov    (%r12),%rcx
not    %rcx
and    %rcx,%r13
mov    0x2dd1(%rip),%r12
test   %r13,(%r12)
je     121f <open__scnprintf_flags+0x10f>
movslq %eax,%rbx
lea    (%r15,%rbx,1),%rdi
mov    %r14,%rsi
sub    %rbx,%rsi
test   %ebx,%ebx
lea    0xe34(%rip),%rax
lea    0xe12(%rip),%rcx
cmove  %rax,%rcx
lea    0xe02(%rip),%rdx
lea    0xe0e(%rip),%r8
xor    %eax,%eax
call   1030 <scnprintf@plt>
add    %ebx,%eax
mov    (%r12),%rcx
not    %rcx
and    %rcx,%r13
mov    0x2d62(%rip),%r12
test   %r13,(%r12)
je     126e <open__scnprintf_flags+0x15e>
movslq %eax,%rbx
lea    (%r15,%rbx,1),%rdi
mov    %r14,%rsi
sub    %rbx,%rsi
test   %ebx,%ebx
lea    0xde5(%rip),%rax
lea    0xdc3(%rip),%rcx
cmove  %rax,%rcx
lea    0xdb3(%rip),%rdx
lea    0xdc5(%rip),%r8
xor    %eax,%eax
call   1030 <scnprintf@plt>
add    %ebx,%eax
mov    (%r12),%rcx
not    %rcx
and    %rcx,%r13
mov    0x2d83(%rip),%r12
test   %r13,(%r12)
je     12bd <open__scnprintf_flags+0x1ad>
movslq %eax,%rbx
lea    (%r15,%rbx,1),%rdi
mov    %r14,%rsi
sub    %rbx,%rsi
test   %ebx,%ebx
lea    0xd96(%rip),%rax
lea    0xd74(%rip),%rcx
cmove  %rax,%rcx
lea    0xd64(%rip),%rdx
lea    0xd7e(%rip),%r8
xor    %eax,%eax
call   1030 <scnprintf@plt>
add    %ebx,%eax
mov    (%r12),%rcx
not    %rcx
and    %rcx,%r13
test   $0x4000,%r13d
je     1305 <open__scnprintf_flags+0x1f5>
movslq %eax,%rbx
lea    (%r15,%rbx,1),%rdi
mov    %r14,%rsi
sub    %rbx,%rsi
test   %ebx,%ebx
lea    0xd4b(%rip),%rax
lea    0xd29(%rip),%rcx
cmove  %rax,%rcx
lea    0xd19(%rip),%rdx
lea    0xd39(%rip),%r8
xor    %eax,%eax
call   1030 <scnprintf@plt>
add    %ebx,%eax
and    $0xffffffffffffbfff,%r13
test   $0x10000,%r13d
je     134d <open__scnprintf_flags+0x23d>
movslq %eax,%rbx
lea    (%r15,%rbx,1),%rdi
mov    %r14,%rsi
sub    %rbx,%rsi
test   %ebx,%ebx
lea    0xd03(%rip),%rax
lea    0xce1(%rip),%rcx
cmove  %rax,%rcx
lea    0xcd1(%rip),%rdx
lea    0xcf8(%rip),%r8
xor    %eax,%eax
call   1030 <scnprintf@plt>
add    %ebx,%eax
and    $0xfffffffffffeffff,%r13
mov    0x2c5c(%rip),%r12
test   %r13,(%r12)
je     139c <open__scnprintf_flags+0x28c>
movslq %eax,%rbx
lea    (%r15,%rbx,1),%rdi
mov    %r14,%rsi
sub    %rbx,%rsi
test   %ebx,%ebx
lea    0xcb7(%rip),%rax
lea    0xc95(%rip),%rcx
cmove  %rax,%rcx
lea    0xc85(%rip),%rdx
lea    0xcb6(%rip),%r8
xor    %eax,%eax
call   1030 <scnprintf@plt>
add    %ebx,%eax
mov    (%r12),%rcx
not    %rcx
and    %rcx,%r13
test   $0x8000,%r13d
je     13e4 <open__scnprintf_flags+0x2d4>
movslq %eax,%rbx
lea    (%r15,%rbx,1),%rdi
mov    %r14,%rsi
sub    %rbx,%rsi
test   %ebx,%ebx
lea    0xc6c(%rip),%rax
lea    0xc4a(%rip),%rcx
cmove  %rax,%rcx
lea    0xc3a(%rip),%rdx
lea    0xc70(%rip),%r8
xor    %eax,%eax
call   1030 <scnprintf@plt>
add    %ebx,%eax
and    $0xffffffffffff7fff,%r13
mov    0x2c05(%rip),%r12
test   %r13,(%r12)
je     1433 <open__scnprintf_flags+0x323>
movslq %eax,%rbx
lea    (%r15,%rbx,1),%rdi
mov    %r14,%rsi
sub    %rbx,%rsi
test   %ebx,%ebx
lea    0xc20(%rip),%rax
lea    0xbfe(%rip),%rcx
cmove  %rax,%rcx
lea    0xbee(%rip),%rdx
lea    0xc2e(%rip),%r8
xor    %eax,%eax
call   1030 <scnprintf@plt>
add    %ebx,%eax
mov    (%r12),%rcx
not    %rcx
and    %rcx,%r13
test   $0x400000,%r13d
je     147b <open__scnprintf_flags+0x36b>
movslq %eax,%rbx
lea    (%r15,%rbx,1),%rdi
mov    %r14,%rsi
sub    %rbx,%rsi
test   %ebx,%ebx
lea    0xbd5(%rip),%rax
lea    0xbb3(%rip),%rcx
cmove  %rax,%rcx
lea    0xba3(%rip),%rdx
lea    0xbec(%rip),%r8
xor    %eax,%eax
call   1030 <scnprintf@plt>
add    %ebx,%eax
and    $0xffffffffffbfffff,%r13
test   $0x40000,%r13d
je     14c3 <open__scnprintf_flags+0x3b3>
movslq %eax,%rbx
lea    (%r15,%rbx,1),%rdi
mov    %r14,%rsi
sub    %rbx,%rsi
test   %ebx,%ebx
lea    0xb8d(%rip),%rax
lea    0xb6b(%rip),%rcx
cmove  %rax,%rcx
lea    0xb5b(%rip),%rdx
lea    0xbac(%rip),%r8
xor    %eax,%eax
call   1030 <scnprintf@plt>
add    %ebx,%eax
and    $0xfffffffffffbffff,%r13
mov    0x2aee(%rip),%r12
test   %r13,(%r12)
je     1512 <open__scnprintf_flags+0x402>
movslq %eax,%rbx
lea    (%r15,%rbx,1),%rdi
mov    %r14,%rsi
sub    %rbx,%rsi
test   %ebx,%ebx
lea    0xb41(%rip),%rax
lea    0xb1f(%rip),%rcx
cmove  %rax,%rcx
lea    0xb0f(%rip),%rdx
lea    0xb68(%rip),%r8
xor    %eax,%eax
call   1030 <scnprintf@plt>
add    %ebx,%eax
mov    (%r12),%rcx
not    %rcx
and    %rcx,%r13
mov    0x2aaf(%rip),%r12
test   %r13,(%r12)
je     1561 <open__scnprintf_flags+0x451>
movslq %eax,%rbx
lea    (%r15,%rbx,1),%rdi
mov    %r14,%rsi
sub    %rbx,%rsi
test   %ebx,%ebx
lea    0xaf2(%rip),%rax
lea    0xad0(%rip),%rcx
cmove  %rax,%rcx
lea    0xac0(%rip),%rdx
lea    0xacd(%rip),%r8
xor    %eax,%eax
call   1030 <scnprintf@plt>
add    %ebx,%eax
mov    (%r12),%rcx
not    %rcx
and    %rcx,%r13
mov    0x2a80(%rip),%r12
test   %r13,(%r12)
je     15b0 <open__scnprintf_flags+0x4a0>
movslq %eax,%rbx
lea    (%r15,%rbx,1),%rdi
mov    %r14,%rsi
sub    %rbx,%rsi
test   %ebx,%ebx
lea    0xaa3(%rip),%rax
lea    0xa81(%rip),%rcx
cmove  %rax,%rcx
lea    0xa71(%rip),%rdx
lea    0xad1(%rip),%r8
xor    %eax,%eax
call   1030 <scnprintf@plt>
add    %ebx,%eax
mov    (%r12),%rcx
not    %rcx
and    %rcx,%r13
mov    0x29e1(%rip),%r12
test   %r13,(%r12)
je     15ff <open__scnprintf_flags+0x4ef>
movslq %eax,%rbx
lea    (%r15,%rbx,1),%rdi
mov    %r14,%rsi
sub    %rbx,%rsi
test   %ebx,%ebx
lea    0xa54(%rip),%rax
lea    0xa32(%rip),%rcx
cmove  %rax,%rcx
lea    0xa22(%rip),%rdx
lea    0xa88(%rip),%r8
xor    %eax,%eax
call   1030 <scnprintf@plt>
add    %ebx,%eax
mov    (%r12),%rcx
not    %rcx
and    %rcx,%r13
test   %r13,%r13
je     163a <open__scnprintf_flags+0x52a>
movslq %eax,%rbx
add    %rbx,%r15
sub    %rbx,%r14
test   %ebx,%ebx
lea    0xa11(%rip),%rax
lea    0x9ef(%rip),%rcx
cmove  %rax,%rcx
lea    0xa53(%rip),%rdx
mov    %r15,%rdi
mov    %r14,%rsi
mov    %r13,%r8
xor    %eax,%eax
call   1030 <scnprintf@plt>
add    %ebx,%eax
cltq
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
ret

LLVM IR (-O0):
@.str = [7 x i8] c"RDONLY\00"
@O_RDWR = global i64 0
@.str.1 = [5 x i8] c"%s%s\00"
@.str.2 = [2 x i8] c"|\00"
@.str.3 = [1 x i8] zeroinitializer
@.str.4 = [5 x i8] c"RDWR\00"
@O_APPEND = global i64 0
@.str.5 = [7 x i8] c"APPEND\00"
@O_ASYNC = global i64 0
@.str.6 = [6 x i8] c"ASYNC\00"
@O_CLOEXEC = global i64 0
@.str.7 = [8 x i8] c"CLOEXEC\00"
@O_CREAT = global i64 0
@.str.8 = [6 x i8] c"CREAT\00"
@.str.9 = [7 x i8] c"DIRECT\00"
@.str.10 = [10 x i8] c"DIRECTORY\00"
@O_EXCL = global i64 0
@.str.11 = [5 x i8] c"EXCL\00"
@.str.12 = [10 x i8] c"LARGEFILE\00"
@O_NOFOLLOW = global i64 0
@.str.13 = [9 x i8] c"NOFOLLOW\00"
@.str.14 = [8 x i8] c"TMPFILE\00"
@.str.15 = [8 x i8] c"NOATIME\00"
@O_NOCTTY = global i64 0
@.str.16 = [7 x i8] c"NOCTTY\00"
@O_SYNC = global i64 0
@.str.17 = [5 x i8] c"SYNC\00"
@O_TRUNC = global i64 0
@.str.18 = [6 x i8] c"TRUNC\00"
@O_WRONLY = global i64 0
@.str.19 = [7 x i8] c"WRONLY\00"
@.str.20 = [6 x i8] c"%s%#x\00"
define i64 @open__scnprintf_flags(i64 %0, i8* %1, i64 %2) {
%4 = alloca i64
%5 = alloca i64
%6 = alloca i8*
%7 = alloca i64
%8 = alloca i32
store i64 %0, i64* %5
store i8* %1, i8** %6
store i64 %2, i64* %7
store i32 0, i32* %8
%9 = load i64, i64* %5
%10 = icmp eq i64 %9, 0
br i1 %10, label %11, label %15
11: ; preds = %3
%12 = load i8*, i8** %6
%13 = load i64, i64* %7
%14 = call i64 (i8*, i64, i8*, ...) @scnprintf(i8* %12, i64 %13, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str, i64 0, i64 0))
store i64 %14, i64* %4
br label %457
15: ; preds = %3
%16 = load i64, i64* %5
%17 = load i64, i64* @O_RDWR
%18 = and i64 %16, %17
%19 = icmp ne i64 %18, 0
br i1 %19, label %20, label %42
20: ; preds = %15
%21 = load i8*, i8** %6
%22 = load i32, i32* %8
%23 = sext i32 %22 to i64
%24 = getelementptr inbounds i8, i8* %21, i64 %23
%25 = load i64, i64* %7
%26 = load i32, i32* %8
%27 = sext i32 %26 to i64
%28 = sub i64 %25, %27
%29 = load i32, i32* %8
%30 = icmp ne i32 %29, 0
%31 = zext i1 %30 to i64
%32 = select i1 %30, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.3, i64 0, i64 0)
%33 = call i64 (i8*, i64, i8*, ...) @scnprintf(i8* %24, i64 %28, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0), i8* %32, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.4, i64 0, i64 0))
%34 = load i32, i32* %8
%35 = sext i32 %34 to i64
%36 = add i64 %35, %33
%37 = trunc i64 %36 to i32
store i32 %37, i32* %8
%38 = load i64, i64* @O_RDWR
%39 = xor i64 %38, -1
%40 = load i64, i64* %5
%41 = and i64 %40, %39
store i64 %41, i64* %5
br label %42
42: ; preds = %20, %15
%43 = load i64, i64* %5
%44 = load i64, i64* @O_APPEND
%45 = and i64 %43, %44
%46 = icmp ne i64 %45, 0
br i1 %46, label %47, label %69
47: ; preds = %42
%48 = load i8*, i8** %6
%49 = load i32, i32* %8
%50 = sext i32 %49 to i64
%51 = getelementptr inbounds i8, i8* %48, i64 %50
%52 = load i64, i64* %7
%53 = load i32, i32* %8
%54 = sext i32 %53 to i64
%55 = sub i64 %52, %54
%56 = load i32, i32* %8
%57 = icmp ne i32 %56, 0
%58 = zext i1 %57 to i64
%59 = select i1 %57, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.3, i64 0, i64 0)
%60 = call i64 (i8*, i64, i8*, ...) @scnprintf(i8* %51, i64 %55, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0), i8* %59, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.5, i64 0, i64 0))
%61 = load i32, i32* %8
%62 = sext i32 %61 to i64
%63 = add i64 %62, %60
%64 = trunc i64 %63 to i32
store i32 %64, i32* %8
%65 = load i64, i64* @O_APPEND
%66 = xor i64 %65, -1
%67 = load i64, i64* %5
%68 = and i64 %67, %66
store i64 %68, i64* %5
br label %69
69: ; preds = %47, %42
%70 = load i64, i64* %5
%71 = load i64, i64* @O_ASYNC
%72 = and i64 %70, %71
%73 = icmp ne i64 %72, 0
br i1 %73, label %74, label %96
74: ; preds = %69
%75 = load i8*, i8** %6
%76 = load i32, i32* %8
%77 = sext i32 %76 to i64
%78 = getelementptr inbounds i8, i8* %75, i64 %77
%79 = load i64, i64* %7
%80 = load i32, i32* %8
%81 = sext i32 %80 to i64
%82 = sub i64 %79, %81
%83 = load i32, i32* %8
%84 = icmp ne i32 %83, 0
%85 = zext i1 %84 to i64
%86 = select i1 %84, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.3, i64 0, i64 0)
%87 = call i64 (i8*, i64, i8*, ...) @scnprintf(i8* %78, i64 %82, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0), i8* %86, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.6, i64 0, i64 0))
%88 = load i32, i32* %8
%89 = sext i32 %88 to i64
%90 = add i64 %89, %87
%91 = trunc i64 %90 to i32
store i32 %91, i32* %8
%92 = load i64, i64* @O_ASYNC
%93 = xor i64 %92, -1
%94 = load i64, i64* %5
%95 = and i64 %94, %93
store i64 %95, i64* %5
br label %96
96: ; preds = %74, %69
%97 = load i64, i64* %5
%98 = load i64, i64* @O_CLOEXEC
%99 = and i64 %97, %98
%100 = icmp ne i64 %99, 0
br i1 %100, label %101, label %123
101: ; preds = %96
%102 = load i8*, i8** %6
%103 = load i32, i32* %8
%104 = sext i32 %103 to i64
%105 = getelementptr inbounds i8, i8* %102, i64 %104
%106 = load i64, i64* %7
%107 = load i32, i32* %8
%108 = sext i32 %107 to i64
%109 = sub i64 %106, %108
%110 = load i32, i32* %8
%111 = icmp ne i32 %110, 0
%112 = zext i1 %111 to i64
%113 = select i1 %111, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.3, i64 0, i64 0)
%114 = call i64 (i8*, i64, i8*, ...) @scnprintf(i8* %105, i64 %109, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0), i8* %113, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.7, i64 0, i64 0))
%115 = load i32, i32* %8
%116 = sext i32 %115 to i64
%117 = add i64 %116, %114
%118 = trunc i64 %117 to i32
store i32 %118, i32* %8
%119 = load i64, i64* @O_CLOEXEC
%120 = xor i64 %119, -1
%121 = load i64, i64* %5
%122 = and i64 %121, %120
store i64 %122, i64* %5
br label %123
123: ; preds = %101, %96
%124 = load i64, i64* %5
%125 = load i64, i64* @O_CREAT
%126 = and i64 %124, %125
%127 = icmp ne i64 %126, 0
br i1 %127, label %128, label %150
128: ; preds = %123
%129 = load i8*, i8** %6
%130 = load i32, i32* %8
%131 = sext i32 %130 to i64
%132 = getelementptr inbounds i8, i8* %129, i64 %131
%133 = load i64, i64* %7
%134 = load i32, i32* %8
%135 = sext i32 %134 to i64
%136 = sub i64 %133, %135
%137 = load i32, i32* %8
%138 = icmp ne i32 %137, 0
%139 = zext i1 %138 to i64
%140 = select i1 %138, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.3, i64 0, i64 0)
%141 = call i64 (i8*, i64, i8*, ...) @scnprintf(i8* %132, i64 %136, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0), i8* %140, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.8, i64 0, i64 0))
%142 = load i32, i32* %8
%143 = sext i32 %142 to i64
%144 = add i64 %143, %141
%145 = trunc i64 %144 to i32
store i32 %145, i32* %8
%146 = load i64, i64* @O_CREAT
%147 = xor i64 %146, -1
%148 = load i64, i64* %5
%149 = and i64 %148, %147
store i64 %149, i64* %5
br label %150
150: ; preds = %128, %123
%151 = load i64, i64* %5
%152 = and i64 %151, 16384
%153 = icmp ne i64 %152, 0
br i1 %153, label %154, label %174
154: ; preds = %150
%155 = load i8*, i8** %6
%156 = load i32, i32* %8
%157 = sext i32 %156 to i64
%158 = getelementptr inbounds i8, i8* %155, i64 %157
%159 = load i64, i64* %7
%160 = load i32, i32* %8
%161 = sext i32 %160 to i64
%162 = sub i64 %159, %161
%163 = load i32, i32* %8
%164 = icmp ne i32 %163, 0
%165 = zext i1 %164 to i64
%166 = select i1 %164, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.3, i64 0, i64 0)
%167 = call i64 (i8*, i64, i8*, ...) @scnprintf(i8* %158, i64 %162, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0), i8* %166, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.9, i64 0, i64 0))
%168 = load i32, i32* %8
%169 = sext i32 %168 to i64
%170 = add i64 %169, %167
%171 = trunc i64 %170 to i32
store i32 %171, i32* %8
%172 = load i64, i64* %5
%173 = and i64 %172, -16385
store i64 %173, i64* %5
br label %174
174: ; preds = %154, %150
%175 = load i64, i64* %5
%176 = and i64 %175, 65536
%177 = icmp ne i64 %176, 0
br i1 %177, label %178, label %198
178: ; preds = %174
%179 = load i8*, i8** %6
%180 = load i32, i32* %8
%181 = sext i32 %180 to i64
%182 = getelementptr inbounds i8, i8* %179, i64 %181
%183 = load i64, i64* %7
%184 = load i32, i32* %8
%185 = sext i32 %184 to i64
%186 = sub i64 %183, %185
%187 = load i32, i32* %8
%188 = icmp ne i32 %187, 0
%189 = zext i1 %188 to i64
%190 = select i1 %188, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.3, i64 0, i64 0)
%191 = call i64 (i8*, i64, i8*, ...) @scnprintf(i8* %182, i64 %186, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0), i8* %190, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.10, i64 0, i64 0))
%192 = load i32, i32* %8
%193 = sext i32 %192 to i64
%194 = add i64 %193, %191
%195 = trunc i64 %194 to i32
store i32 %195, i32* %8
%196 = load i64, i64* %5
%197 = and i64 %196, -65537
store i64 %197, i64* %5
br label %198
198: ; preds = %178, %174
%199 = load i64, i64* %5
%200 = load i64, i64* @O_EXCL
%201 = and i64 %199, %200
%202 = icmp ne i64 %201, 0
br i1 %202, label %203, label %225
203: ; preds = %198
%204 = load i8*, i8** %6
%205 = load i32, i32* %8
%206 = sext i32 %205 to i64
%207 = getelementptr inbounds i8, i8* %204, i64 %206
%208 = load i64, i64* %7
%209 = load i32, i32* %8
%210 = sext i32 %209 to i64
%211 = sub i64 %208, %210
%212 = load i32, i32* %8
%213 = icmp ne i32 %212, 0
%214 = zext i1 %213 to i64
%215 = select i1 %213, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.3, i64 0, i64 0)
%216 = call i64 (i8*, i64, i8*, ...) @scnprintf(i8* %207, i64 %211, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0), i8* %215, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.11, i64 0, i64 0))
%217 = load i32, i32* %8
%218 = sext i32 %217 to i64
%219 = add i64 %218, %216
%220 = trunc i64 %219 to i32
store i32 %220, i32* %8
%221 = load i64, i64* @O_EXCL
%222 = xor i64 %221, -1
%223 = load i64, i64* %5
%224 = and i64 %223, %222
store i64 %224, i64* %5
br label %225
225: ; preds = %203, %198
%226 = load i64, i64* %5
%227 = and i64 %226, 32768
%228 = icmp ne i64 %227, 0
br i1 %228, label %229, label %249
229: ; preds = %225
%230 = load i8*, i8** %6
%231 = load i32, i32* %8
%232 = sext i32 %231 to i64
%233 = getelementptr inbounds i8, i8* %230, i64 %232
%234 = load i64, i64* %7
%235 = load i32, i32* %8
%236 = sext i32 %235 to i64
%237 = sub i64 %234, %236
%238 = load i32, i32* %8
%239 = icmp ne i32 %238, 0
%240 = zext i1 %239 to i64
%241 = select i1 %239, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.3, i64 0, i64 0)
%242 = call i64 (i8*, i64, i8*, ...) @scnprintf(i8* %233, i64 %237, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0), i8* %241, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.12, i64 0, i64 0))
%243 = load i32, i32* %8
%244 = sext i32 %243 to i64
%245 = add i64 %244, %242
%246 = trunc i64 %245 to i32
store i32 %246, i32* %8
%247 = load i64, i64* %5
%248 = and i64 %247, -32769
store i64 %248, i64* %5
br label %249
249: ; preds = %229, %225
%250 = load i64, i64* %5
%251 = load i64, i64* @O_NOFOLLOW
%252 = and i64 %250, %251
%253 = icmp ne i64 %252, 0
br i1 %253, label %254, label %276
254: ; preds = %249
%255 = load i8*, i8** %6
%256 = load i32, i32* %8
%257 = sext i32 %256 to i64
%258 = getelementptr inbounds i8, i8* %255, i64 %257
%259 = load i64, i64* %7
%260 = load i32, i32* %8
%261 = sext i32 %260 to i64
%262 = sub i64 %259, %261
%263 = load i32, i32* %8
%264 = icmp ne i32 %263, 0
%265 = zext i1 %264 to i64
%266 = select i1 %264, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.3, i64 0, i64 0)
%267 = call i64 (i8*, i64, i8*, ...) @scnprintf(i8* %258, i64 %262, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0), i8* %266, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.13, i64 0, i64 0))
%268 = load i32, i32* %8
%269 = sext i32 %268 to i64
%270 = add i64 %269, %267
%271 = trunc i64 %270 to i32
store i32 %271, i32* %8
%272 = load i64, i64* @O_NOFOLLOW
%273 = xor i64 %272, -1
%274 = load i64, i64* %5
%275 = and i64 %274, %273
store i64 %275, i64* %5
br label %276
276: ; preds = %254, %249
%277 = load i64, i64* %5
%278 = and i64 %277, 4194304
%279 = icmp ne i64 %278, 0
br i1 %279, label %280, label %300
280: ; preds = %276
%281 = load i8*, i8** %6
%282 = load i32, i32* %8
%283 = sext i32 %282 to i64
%284 = getelementptr inbounds i8, i8* %281, i64 %283
%285 = load i64, i64* %7
%286 = load i32, i32* %8
%287 = sext i32 %286 to i64
%288 = sub i64 %285, %287
%289 = load i32, i32* %8
%290 = icmp ne i32 %289, 0
%291 = zext i1 %290 to i64
%292 = select i1 %290, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.3, i64 0, i64 0)
%293 = call i64 (i8*, i64, i8*, ...) @scnprintf(i8* %284, i64 %288, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0), i8* %292, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.14, i64 0, i64 0))
%294 = load i32, i32* %8
%295 = sext i32 %294 to i64
%296 = add i64 %295, %293
%297 = trunc i64 %296 to i32
store i32 %297, i32* %8
%298 = load i64, i64* %5
%299 = and i64 %298, -4194305
store i64 %299, i64* %5
br label %300
300: ; preds = %280, %276
%301 = load i64, i64* %5
%302 = and i64 %301, 262144
%303 = icmp ne i64 %302, 0
br i1 %303, label %304, label %324
304: ; preds = %300
%305 = load i8*, i8** %6
%306 = load i32, i32* %8
%307 = sext i32 %306 to i64
%308 = getelementptr inbounds i8, i8* %305, i64 %307
%309 = load i64, i64* %7
%310 = load i32, i32* %8
%311 = sext i32 %310 to i64
%312 = sub i64 %309, %311
%313 = load i32, i32* %8
%314 = icmp ne i32 %313, 0
%315 = zext i1 %314 to i64
%316 = select i1 %314, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.3, i64 0, i64 0)
%317 = call i64 (i8*, i64, i8*, ...) @scnprintf(i8* %308, i64 %312, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0), i8* %316, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.15, i64 0, i64 0))
%318 = load i32, i32* %8
%319 = sext i32 %318 to i64
%320 = add i64 %319, %317
%321 = trunc i64 %320 to i32
store i32 %321, i32* %8
%322 = load i64, i64* %5
%323 = and i64 %322, -262145
store i64 %323, i64* %5
br label %324
324: ; preds = %304, %300
%325 = load i64, i64* %5
%326 = load i64, i64* @O_NOCTTY
%327 = and i64 %325, %326
%328 = icmp ne i64 %327, 0
br i1 %328, label %329, label %351
329: ; preds = %324
%330 = load i8*, i8** %6
%331 = load i32, i32* %8
%332 = sext i32 %331 to i64
%333 = getelementptr inbounds i8, i8* %330, i64 %332
%334 = load i64, i64* %7
%335 = load i32, i32* %8
%336 = sext i32 %335 to i64
%337 = sub i64 %334, %336
%338 = load i32, i32* %8
%339 = icmp ne i32 %338, 0
%340 = zext i1 %339 to i64
%341 = select i1 %339, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.3, i64 0, i64 0)
%342 = call i64 (i8*, i64, i8*, ...) @scnprintf(i8* %333, i64 %337, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0), i8* %341, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.16, i64 0, i64 0))
%343 = load i32, i32* %8
%344 = sext i32 %343 to i64
%345 = add i64 %344, %342
%346 = trunc i64 %345 to i32
store i32 %346, i32* %8
%347 = load i64, i64* @O_NOCTTY
%348 = xor i64 %347, -1
%349 = load i64, i64* %5
%350 = and i64 %349, %348
store i64 %350, i64* %5
br label %351
351: ; preds = %329, %324
%352 = load i64, i64* %5
%353 = load i64, i64* @O_SYNC
%354 = and i64 %352, %353
%355 = icmp ne i64 %354, 0
br i1 %355, label %356, label %378
356: ; preds = %351
%357 = load i8*, i8** %6
%358 = load i32, i32* %8
%359 = sext i32 %358 to i64
%360 = getelementptr inbounds i8, i8* %357, i64 %359
%361 = load i64, i64* %7
%362 = load i32, i32* %8
%363 = sext i32 %362 to i64
%364 = sub i64 %361, %363
%365 = load i32, i32* %8
%366 = icmp ne i32 %365, 0
%367 = zext i1 %366 to i64
%368 = select i1 %366, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.3, i64 0, i64 0)
%369 = call i64 (i8*, i64, i8*, ...) @scnprintf(i8* %360, i64 %364, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0), i8* %368, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.17, i64 0, i64 0))
%370 = load i32, i32* %8
%371 = sext i32 %370 to i64
%372 = add i64 %371, %369
%373 = trunc i64 %372 to i32
store i32 %373, i32* %8
%374 = load i64, i64* @O_SYNC
%375 = xor i64 %374, -1
%376 = load i64, i64* %5
%377 = and i64 %376, %375
store i64 %377, i64* %5
br label %378
378: ; preds = %356, %351
%379 = load i64, i64* %5
%380 = load i64, i64* @O_TRUNC
%381 = and i64 %379, %380
%382 = icmp ne i64 %381, 0
br i1 %382, label %383, label %405
383: ; preds = %378
%384 = load i8*, i8** %6
%385 = load i32, i32* %8
%386 = sext i32 %385 to i64
%387 = getelementptr inbounds i8, i8* %384, i64 %386
%388 = load i64, i64* %7
%389 = load i32, i32* %8
%390 = sext i32 %389 to i64
%391 = sub i64 %388, %390
%392 = load i32, i32* %8
%393 = icmp ne i32 %392, 0
%394 = zext i1 %393 to i64
%395 = select i1 %393, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.3, i64 0, i64 0)
%396 = call i64 (i8*, i64, i8*, ...) @scnprintf(i8* %387, i64 %391, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0), i8* %395, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.18, i64 0, i64 0))
%397 = load i32, i32* %8
%398 = sext i32 %397 to i64
%399 = add i64 %398, %396
%400 = trunc i64 %399 to i32
store i32 %400, i32* %8
%401 = load i64, i64* @O_TRUNC
%402 = xor i64 %401, -1
%403 = load i64, i64* %5
%404 = and i64 %403, %402
store i64 %404, i64* %5
br label %405
405: ; preds = %383, %378
%406 = load i64, i64* %5
%407 = load i64, i64* @O_WRONLY
%408 = and i64 %406, %407
%409 = icmp ne i64 %408, 0
br i1 %409, label %410, label %432
410: ; preds = %405
%411 = load i8*, i8** %6
%412 = load i32, i32* %8
%413 = sext i32 %412 to i64
%414 = getelementptr inbounds i8, i8* %411, i64 %413
%415 = load i64, i64* %7
%416 = load i32, i32* %8
%417 = sext i32 %416 to i64
%418 = sub i64 %415, %417
%419 = load i32, i32* %8
%420 = icmp ne i32 %419, 0
%421 = zext i1 %420 to i64
%422 = select i1 %420, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.3, i64 0, i64 0)
%423 = call i64 (i8*, i64, i8*, ...) @scnprintf(i8* %414, i64 %418, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0), i8* %422, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.19, i64 0, i64 0))
%424 = load i32, i32* %8
%425 = sext i32 %424 to i64
%426 = add i64 %425, %423
%427 = trunc i64 %426 to i32
store i32 %427, i32* %8
%428 = load i64, i64* @O_WRONLY
%429 = xor i64 %428, -1
%430 = load i64, i64* %5
%431 = and i64 %430, %429
store i64 %431, i64* %5
br label %432
432: ; preds = %410, %405
%433 = load i64, i64* %5
%434 = icmp ne i64 %433, 0
br i1 %434, label %435, label %454
435: ; preds = %432
%436 = load i8*, i8** %6
%437 = load i32, i32* %8
%438 = sext i32 %437 to i64
%439 = getelementptr inbounds i8, i8* %436, i64 %438
%440 = load i64, i64* %7
%441 = load i32, i32* %8
%442 = sext i32 %441 to i64
%443 = sub i64 %440, %442
%444 = load i32, i32* %8
%445 = icmp ne i32 %444, 0
%446 = zext i1 %445 to i64
%447 = select i1 %445, i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.3, i64 0, i64 0)
%448 = load i64, i64* %5
%449 = call i64 (i8*, i64, i8*, ...) @scnprintf(i8* %439, i64 %443, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.20, i64 0, i64 0), i8* %447, i64 %448)
%450 = load i32, i32* %8
%451 = sext i32 %450 to i64
%452 = add i64 %451, %449
%453 = trunc i64 %452 to i32
store i32 %453, i32* %8
br label %454
454: ; preds = %435, %432
%455 = load i32, i32* %8
%456 = sext i32 %455 to i64
store i64 %456, i64* %4
br label %457
457: ; preds = %454, %11
%458 = load i64, i64* %4
ret i64 %458
}

LLVM IR (-O2):
@.str = [7 x i8] c"RDONLY\00"
@O_RDWR = global i64 0
@.str.1 = [5 x i8] c"%s%s\00"
@.str.2 = [2 x i8] c"|\00"
@.str.3 = [1 x i8] zeroinitializer
@.str.4 = [5 x i8] c"RDWR\00"
@O_APPEND = global i64 0
@.str.5 = [7 x i8] c"APPEND\00"
@O_ASYNC = global i64 0
@.str.6 = [6 x i8] c"ASYNC\00"
@O_CLOEXEC = global i64 0
@.str.7 = [8 x i8] c"CLOEXEC\00"
@O_CREAT = global i64 0
@.str.8 = [6 x i8] c"CREAT\00"
@.str.9 = [7 x i8] c"DIRECT\00"
@.str.10 = [10 x i8] c"DIRECTORY\00"
@O_EXCL = global i64 0
@.str.11 = [5 x i8] c"EXCL\00"
@.str.12 = [10 x i8] c"LARGEFILE\00"
@O_NOFOLLOW = global i64 0
@.str.13 = [9 x i8] c"NOFOLLOW\00"
@.str.14 = [8 x i8] c"TMPFILE\00"
@.str.15 = [8 x i8] c"NOATIME\00"
@O_NOCTTY = global i64 0
@.str.16 = [7 x i8] c"NOCTTY\00"
@O_SYNC = global i64 0
@.str.17 = [5 x i8] c"SYNC\00"
@O_TRUNC = global i64 0
@.str.18 = [6 x i8] c"TRUNC\00"
@O_WRONLY = global i64 0
@.str.19 = [7 x i8] c"WRONLY\00"
@.str.20 = [6 x i8] c"%s%#x\00"
define i64 @open__scnprintf_flags(i64 %0, i8* %1, i64 %2) {
%4 = icmp eq i64 %0, 0
br i1 %4, label %5, label %7
5: ; preds = %3
%6 = tail call i64 (i8*, i64, i8*, ...) @scnprintf(i8* %1, i64 %2, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str, i64 0, i64 0))
br label %288
7: ; preds = %3
%8 = load i64, i64* @O_RDWR
%9 = and i64 %8, %0
%10 = icmp eq i64 %9, 0
br i1 %10, label %17, label %11
11: ; preds = %7
%12 = tail call i64 (i8*, i64, i8*, ...) @scnprintf(i8* %1, i64 %2, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0), i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.3, i64 0, i64 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.4, i64 0, i64 0))
%13 = trunc i64 %12 to i32
%14 = load i64, i64* @O_RDWR
%15 = xor i64 %14, -1
%16 = and i64 %15, %0
br label %17
17: ; preds = %11, %7
%18 = phi i64 [ %16, %11 ], [ %0, %7 ]
%19 = phi i32 [ %13, %11 ], [ 0, %7 ]
%20 = load i64, i64* @O_APPEND
%21 = and i64 %20, %18
%22 = icmp eq i64 %21, 0
br i1 %22, label %35, label %23
23: ; preds = %17
%24 = sext i32 %19 to i64
%25 = getelementptr inbounds i8, i8* %1, i64 %24
%26 = sub i64 %2, %24
%27 = icmp eq i32 %19, 0
%28 = select i1 %27, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.3, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0)
%29 = tail call i64 (i8*, i64, i8*, ...) @scnprintf(i8* %25, i64 %26, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0), i8* %28, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.5, i64 0, i64 0))
%30 = trunc i64 %29 to i32
%31 = add i32 %19, %30
%32 = load i64, i64* @O_APPEND
%33 = xor i64 %32, -1
%34 = and i64 %18, %33
br label %35
35: ; preds = %23, %17
%36 = phi i64 [ %34, %23 ], [ %18, %17 ]
%37 = phi i32 [ %31, %23 ], [ %19, %17 ]
%38 = load i64, i64* @O_ASYNC
%39 = and i64 %38, %36
%40 = icmp eq i64 %39, 0
br i1 %40, label %53, label %41
41: ; preds = %35
%42 = sext i32 %37 to i64
%43 = getelementptr inbounds i8, i8* %1, i64 %42
%44 = sub i64 %2, %42
%45 = icmp eq i32 %37, 0
%46 = select i1 %45, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.3, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0)
%47 = tail call i64 (i8*, i64, i8*, ...) @scnprintf(i8* %43, i64 %44, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0), i8* %46, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.6, i64 0, i64 0))
%48 = trunc i64 %47 to i32
%49 = add i32 %37, %48
%50 = load i64, i64* @O_ASYNC
%51 = xor i64 %50, -1
%52 = and i64 %36, %51
br label %53
53: ; preds = %41, %35
%54 = phi i64 [ %52, %41 ], [ %36, %35 ]
%55 = phi i32 [ %49, %41 ], [ %37, %35 ]
%56 = load i64, i64* @O_CLOEXEC
%57 = and i64 %56, %54
%58 = icmp eq i64 %57, 0
br i1 %58, label %71, label %59
59: ; preds = %53
%60 = sext i32 %55 to i64
%61 = getelementptr inbounds i8, i8* %1, i64 %60
%62 = sub i64 %2, %60
%63 = icmp eq i32 %55, 0
%64 = select i1 %63, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.3, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0)
%65 = tail call i64 (i8*, i64, i8*, ...) @scnprintf(i8* %61, i64 %62, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0), i8* %64, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.7, i64 0, i64 0))
%66 = trunc i64 %65 to i32
%67 = add i32 %55, %66
%68 = load i64, i64* @O_CLOEXEC
%69 = xor i64 %68, -1
%70 = and i64 %54, %69
br label %71
71: ; preds = %59, %53
%72 = phi i64 [ %70, %59 ], [ %54, %53 ]
%73 = phi i32 [ %67, %59 ], [ %55, %53 ]
%74 = load i64, i64* @O_CREAT
%75 = and i64 %74, %72
%76 = icmp eq i64 %75, 0
br i1 %76, label %89, label %77
77: ; preds = %71
%78 = sext i32 %73 to i64
%79 = getelementptr inbounds i8, i8* %1, i64 %78
%80 = sub i64 %2, %78
%81 = icmp eq i32 %73, 0
%82 = select i1 %81, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.3, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0)
%83 = tail call i64 (i8*, i64, i8*, ...) @scnprintf(i8* %79, i64 %80, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0), i8* %82, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.8, i64 0, i64 0))
%84 = trunc i64 %83 to i32
%85 = add i32 %73, %84
%86 = load i64, i64* @O_CREAT
%87 = xor i64 %86, -1
%88 = and i64 %72, %87
br label %89
89: ; preds = %77, %71
%90 = phi i64 [ %88, %77 ], [ %72, %71 ]
%91 = phi i32 [ %85, %77 ], [ %73, %71 ]
%92 = and i64 %90, 16384
%93 = icmp eq i64 %92, 0
br i1 %93, label %104, label %94
94: ; preds = %89
%95 = sext i32 %91 to i64
%96 = getelementptr inbounds i8, i8* %1, i64 %95
%97 = sub i64 %2, %95
%98 = icmp eq i32 %91, 0
%99 = select i1 %98, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.3, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0)
%100 = tail call i64 (i8*, i64, i8*, ...) @scnprintf(i8* %96, i64 %97, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0), i8* %99, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.9, i64 0, i64 0))
%101 = trunc i64 %100 to i32
%102 = add i32 %91, %101
%103 = and i64 %90, -16385
br label %104
104: ; preds = %94, %89
%105 = phi i64 [ %103, %94 ], [ %90, %89 ]
%106 = phi i32 [ %102, %94 ], [ %91, %89 ]
%107 = and i64 %105, 65536
%108 = icmp eq i64 %107, 0
br i1 %108, label %119, label %109
109: ; preds = %104
%110 = sext i32 %106 to i64
%111 = getelementptr inbounds i8, i8* %1, i64 %110
%112 = sub i64 %2, %110
%113 = icmp eq i32 %106, 0
%114 = select i1 %113, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.3, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0)
%115 = tail call i64 (i8*, i64, i8*, ...) @scnprintf(i8* %111, i64 %112, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0), i8* %114, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.10, i64 0, i64 0))
%116 = trunc i64 %115 to i32
%117 = add i32 %106, %116
%118 = and i64 %105, -65537
br label %119
119: ; preds = %109, %104
%120 = phi i64 [ %118, %109 ], [ %105, %104 ]
%121 = phi i32 [ %117, %109 ], [ %106, %104 ]
%122 = load i64, i64* @O_EXCL
%123 = and i64 %122, %120
%124 = icmp eq i64 %123, 0
br i1 %124, label %137, label %125
125: ; preds = %119
%126 = sext i32 %121 to i64
%127 = getelementptr inbounds i8, i8* %1, i64 %126
%128 = sub i64 %2, %126
%129 = icmp eq i32 %121, 0
%130 = select i1 %129, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.3, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0)
%131 = tail call i64 (i8*, i64, i8*, ...) @scnprintf(i8* %127, i64 %128, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0), i8* %130, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.11, i64 0, i64 0))
%132 = trunc i64 %131 to i32
%133 = add i32 %121, %132
%134 = load i64, i64* @O_EXCL
%135 = xor i64 %134, -1
%136 = and i64 %120, %135
br label %137
137: ; preds = %125, %119
%138 = phi i64 [ %136, %125 ], [ %120, %119 ]
%139 = phi i32 [ %133, %125 ], [ %121, %119 ]
%140 = and i64 %138, 32768
%141 = icmp eq i64 %140, 0
br i1 %141, label %152, label %142
142: ; preds = %137
%143 = sext i32 %139 to i64
%144 = getelementptr inbounds i8, i8* %1, i64 %143
%145 = sub i64 %2, %143
%146 = icmp eq i32 %139, 0
%147 = select i1 %146, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.3, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0)
%148 = tail call i64 (i8*, i64, i8*, ...) @scnprintf(i8* %144, i64 %145, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0), i8* %147, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.12, i64 0, i64 0))
%149 = trunc i64 %148 to i32
%150 = add i32 %139, %149
%151 = and i64 %138, -32769
br label %152
152: ; preds = %142, %137
%153 = phi i64 [ %151, %142 ], [ %138, %137 ]
%154 = phi i32 [ %150, %142 ], [ %139, %137 ]
%155 = load i64, i64* @O_NOFOLLOW
%156 = and i64 %155, %153
%157 = icmp eq i64 %156, 0
br i1 %157, label %170, label %158
158: ; preds = %152
%159 = sext i32 %154 to i64
%160 = getelementptr inbounds i8, i8* %1, i64 %159
%161 = sub i64 %2, %159
%162 = icmp eq i32 %154, 0
%163 = select i1 %162, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.3, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0)
%164 = tail call i64 (i8*, i64, i8*, ...) @scnprintf(i8* %160, i64 %161, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0), i8* %163, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.13, i64 0, i64 0))
%165 = trunc i64 %164 to i32
%166 = add i32 %154, %165
%167 = load i64, i64* @O_NOFOLLOW
%168 = xor i64 %167, -1
%169 = and i64 %153, %168
br label %170
170: ; preds = %158, %152
%171 = phi i64 [ %169, %158 ], [ %153, %152 ]
%172 = phi i32 [ %166, %158 ], [ %154, %152 ]
%173 = and i64 %171, 4194304
%174 = icmp eq i64 %173, 0
br i1 %174, label %185, label %175
175: ; preds = %170
%176 = sext i32 %172 to i64
%177 = getelementptr inbounds i8, i8* %1, i64 %176
%178 = sub i64 %2, %176
%179 = icmp eq i32 %172, 0
%180 = select i1 %179, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.3, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0)
%181 = tail call i64 (i8*, i64, i8*, ...) @scnprintf(i8* %177, i64 %178, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0), i8* %180, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.14, i64 0, i64 0))
%182 = trunc i64 %181 to i32
%183 = add i32 %172, %182
%184 = and i64 %171, -4194305
br label %185
185: ; preds = %175, %170
%186 = phi i64 [ %184, %175 ], [ %171, %170 ]
%187 = phi i32 [ %183, %175 ], [ %172, %170 ]
%188 = and i64 %186, 262144
%189 = icmp eq i64 %188, 0
br i1 %189, label %200, label %190
190: ; preds = %185
%191 = sext i32 %187 to i64
%192 = getelementptr inbounds i8, i8* %1, i64 %191
%193 = sub i64 %2, %191
%194 = icmp eq i32 %187, 0
%195 = select i1 %194, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.3, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0)
%196 = tail call i64 (i8*, i64, i8*, ...) @scnprintf(i8* %192, i64 %193, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0), i8* %195, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.15, i64 0, i64 0))
%197 = trunc i64 %196 to i32
%198 = add i32 %187, %197
%199 = and i64 %186, -262145
br label %200
200: ; preds = %190, %185
%201 = phi i64 [ %199, %190 ], [ %186, %185 ]
%202 = phi i32 [ %198, %190 ], [ %187, %185 ]
%203 = load i64, i64* @O_NOCTTY
%204 = and i64 %203, %201
%205 = icmp eq i64 %204, 0
br i1 %205, label %218, label %206
206: ; preds = %200
%207 = sext i32 %202 to i64
%208 = getelementptr inbounds i8, i8* %1, i64 %207
%209 = sub i64 %2, %207
%210 = icmp eq i32 %202, 0
%211 = select i1 %210, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.3, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0)
%212 = tail call i64 (i8*, i64, i8*, ...) @scnprintf(i8* %208, i64 %209, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0), i8* %211, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.16, i64 0, i64 0))
%213 = trunc i64 %212 to i32
%214 = add i32 %202, %213
%215 = load i64, i64* @O_NOCTTY
%216 = xor i64 %215, -1
%217 = and i64 %201, %216
br label %218
218: ; preds = %206, %200
%219 = phi i64 [ %217, %206 ], [ %201, %200 ]
%220 = phi i32 [ %214, %206 ], [ %202, %200 ]
%221 = load i64, i64* @O_SYNC
%222 = and i64 %221, %219
%223 = icmp eq i64 %222, 0
br i1 %223, label %236, label %224
224: ; preds = %218
%225 = sext i32 %220 to i64
%226 = getelementptr inbounds i8, i8* %1, i64 %225
%227 = sub i64 %2, %225
%228 = icmp eq i32 %220, 0
%229 = select i1 %228, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.3, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0)
%230 = tail call i64 (i8*, i64, i8*, ...) @scnprintf(i8* %226, i64 %227, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0), i8* %229, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.17, i64 0, i64 0))
%231 = trunc i64 %230 to i32
%232 = add i32 %220, %231
%233 = load i64, i64* @O_SYNC
%234 = xor i64 %233, -1
%235 = and i64 %219, %234
br label %236
236: ; preds = %224, %218
%237 = phi i64 [ %235, %224 ], [ %219, %218 ]
%238 = phi i32 [ %232, %224 ], [ %220, %218 ]
%239 = load i64, i64* @O_TRUNC
%240 = and i64 %239, %237
%241 = icmp eq i64 %240, 0
br i1 %241, label %254, label %242
242: ; preds = %236
%243 = sext i32 %238 to i64
%244 = getelementptr inbounds i8, i8* %1, i64 %243
%245 = sub i64 %2, %243
%246 = icmp eq i32 %238, 0
%247 = select i1 %246, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.3, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0)
%248 = tail call i64 (i8*, i64, i8*, ...) @scnprintf(i8* %244, i64 %245, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0), i8* %247, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.18, i64 0, i64 0))
%249 = trunc i64 %248 to i32
%250 = add i32 %238, %249
%251 = load i64, i64* @O_TRUNC
%252 = xor i64 %251, -1
%253 = and i64 %237, %252
br label %254
254: ; preds = %242, %236
%255 = phi i64 [ %253, %242 ], [ %237, %236 ]
%256 = phi i32 [ %250, %242 ], [ %238, %236 ]
%257 = load i64, i64* @O_WRONLY
%258 = and i64 %257, %255
%259 = icmp eq i64 %258, 0
br i1 %259, label %272, label %260
260: ; preds = %254
%261 = sext i32 %256 to i64
%262 = getelementptr inbounds i8, i8* %1, i64 %261
%263 = sub i64 %2, %261
%264 = icmp eq i32 %256, 0
%265 = select i1 %264, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.3, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0)
%266 = tail call i64 (i8*, i64, i8*, ...) @scnprintf(i8* %262, i64 %263, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.1, i64 0, i64 0), i8* %265, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.19, i64 0, i64 0))
%267 = trunc i64 %266 to i32
%268 = add i32 %256, %267
%269 = load i64, i64* @O_WRONLY
%270 = xor i64 %269, -1
%271 = and i64 %255, %270
br label %272
272: ; preds = %260, %254
%273 = phi i64 [ %271, %260 ], [ %255, %254 ]
%274 = phi i32 [ %268, %260 ], [ %256, %254 ]
%275 = icmp eq i64 %273, 0
br i1 %275, label %285, label %276
276: ; preds = %272
%277 = sext i32 %274 to i64
%278 = getelementptr inbounds i8, i8* %1, i64 %277
%279 = sub i64 %2, %277
%280 = icmp eq i32 %274, 0
%281 = select i1 %280, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @.str.3, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0)
%282 = tail call i64 (i8*, i64, i8*, ...) @scnprintf(i8* %278, i64 %279, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.20, i64 0, i64 0), i8* %281, i64 %273)
%283 = trunc i64 %282 to i32
%284 = add i32 %274, %283
br label %285
285: ; preds = %276, %272
%286 = phi i32 [ %284, %276 ], [ %274, %272 ]
%287 = sext i32 %286 to i64
br label %288
288: ; preds = %285, %5
%289 = phi i64 [ %6, %5 ], [ %287, %285 ]
ret i64 %289
}