#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 MS_ACTIVE;
unsigned long MS_BIND;
unsigned long MS_DIRSYNC;
unsigned long MS_I_VERSION;
unsigned long MS_KERNMOUNT;
unsigned long MS_MANDLOCK;
unsigned long MS_MOVE;
unsigned long MS_NOATIME;
unsigned long MS_NODEV;
unsigned long MS_NODIRATIME;
unsigned long MS_NOEXEC;
unsigned long MS_NOSUID;
unsigned long MS_NOUSER;
unsigned long MS_POSIXACL;
unsigned long MS_PRIVATE;
unsigned long MS_RDONLY;
unsigned long MS_REC;
unsigned long MS_RELATIME;
unsigned long MS_REMOUNT;
unsigned long MS_SHARED;
unsigned long MS_SILENT;
unsigned long MS_SLAVE;
unsigned long MS_STRICTATIME;
unsigned long MS_SYNCHRONOUS;
unsigned long MS_UNBINDABLE;
int /*<<< orphan*/ sc_must_snprintf(char *, int, char *, unsigned long);
int /*<<< orphan*/ sc_string_append(char *, size_t, char *);
int /*<<< orphan*/ sc_string_init(char *, size_t);
size_t strnlen(char *, size_t);
const char *sc_mount_opt2str(char *buf, size_t buf_size, unsigned long flags) {
  unsigned long used = 0;
  sc_string_init(buf, buf_size);
  do {
    if (flags & (MS_RDONLY)) {
      sc_string_append(buf, buf_size,
                       "ro"
                       ",");
      flags ^= (MS_RDONLY);
    }
  } while (0);
  do {
    if (flags & (MS_NOSUID)) {
      sc_string_append(buf, buf_size,
                       "nosuid"
                       ",");
      flags ^= (MS_NOSUID);
    }
  } while (0);
  do {
    if (flags & (MS_NODEV)) {
      sc_string_append(buf, buf_size,
                       "nodev"
                       ",");
      flags ^= (MS_NODEV);
    }
  } while (0);
  do {
    if (flags & (MS_NOEXEC)) {
      sc_string_append(buf, buf_size,
                       "noexec"
                       ",");
      flags ^= (MS_NOEXEC);
    }
  } while (0);
  do {
    if (flags & (MS_SYNCHRONOUS)) {
      sc_string_append(buf, buf_size,
                       "sync"
                       ",");
      flags ^= (MS_SYNCHRONOUS);
    }
  } while (0);
  do {
    if (flags & (MS_REMOUNT)) {
      sc_string_append(buf, buf_size,
                       "remount"
                       ",");
      flags ^= (MS_REMOUNT);
    }
  } while (0);
  do {
    if (flags & (MS_MANDLOCK)) {
      sc_string_append(buf, buf_size,
                       "mand"
                       ",");
      flags ^= (MS_MANDLOCK);
    }
  } while (0);
  do {
    if (flags & (MS_DIRSYNC)) {
      sc_string_append(buf, buf_size,
                       "dirsync"
                       ",");
      flags ^= (MS_DIRSYNC);
    }
  } while (0);
  do {
    if (flags & (MS_NOATIME)) {
      sc_string_append(buf, buf_size,
                       "noatime"
                       ",");
      flags ^= (MS_NOATIME);
    }
  } while (0);
  do {
    if (flags & (MS_NODIRATIME)) {
      sc_string_append(buf, buf_size,
                       "nodiratime"
                       ",");
      flags ^= (MS_NODIRATIME);
    }
  } while (0);
  if (flags & MS_BIND) {
    if (flags & MS_REC) {
      sc_string_append(buf, buf_size, "rbind,");
      used |= MS_REC;
    } else {
      sc_string_append(buf, buf_size, "bind,");
    }
    flags ^= MS_BIND;
  }
  do {
    if (flags & (MS_MOVE)) {
      sc_string_append(buf, buf_size,
                       "move"
                       ",");
      flags ^= (MS_MOVE);
    }
  } while (0);
  do {
    if (flags & (MS_SILENT)) {
      sc_string_append(buf, buf_size,
                       "silent"
                       ",");
      flags ^= (MS_SILENT);
    }
  } while (0);
  do {
    if (flags & (MS_POSIXACL)) {
      sc_string_append(buf, buf_size,
                       "acl"
                       ",");
      flags ^= (MS_POSIXACL);
    }
  } while (0);
  do {
    if (flags & (MS_UNBINDABLE)) {
      sc_string_append(buf, buf_size,
                       "unbindable"
                       ",");
      flags ^= (MS_UNBINDABLE);
    }
  } while (0);
  if (flags & MS_PRIVATE) {
    if (flags & MS_REC) {
      sc_string_append(buf, buf_size, "rprivate,");
      used |= MS_REC;
    } else {
      sc_string_append(buf, buf_size, "private,");
    }
    flags ^= MS_PRIVATE;
  }
  if (flags & MS_SLAVE) {
    if (flags & MS_REC) {
      sc_string_append(buf, buf_size, "rslave,");
      used |= MS_REC;
    } else {
      sc_string_append(buf, buf_size, "slave,");
    }
    flags ^= MS_SLAVE;
  }
  if (flags & MS_SHARED) {
    if (flags & MS_REC) {
      sc_string_append(buf, buf_size, "rshared,");
      used |= MS_REC;
    } else {
      sc_string_append(buf, buf_size, "shared,");
    }
    flags ^= MS_SHARED;
  }
  flags ^= used;
  do {
    if (flags & (MS_RELATIME)) {
      sc_string_append(buf, buf_size,
                       "relatime"
                       ",");
      flags ^= (MS_RELATIME);
    }
  } while (0);
  do {
    if (flags & (MS_KERNMOUNT)) {
      sc_string_append(buf, buf_size,
                       "kernmount"
                       ",");
      flags ^= (MS_KERNMOUNT);
    }
  } while (0);
  do {
    if (flags & (MS_I_VERSION)) {
      sc_string_append(buf, buf_size,
                       "iversion"
                       ",");
      flags ^= (MS_I_VERSION);
    }
  } while (0);
  do {
    if (flags & (MS_STRICTATIME)) {
      sc_string_append(buf, buf_size,
                       "strictatime"
                       ",");
      flags ^= (MS_STRICTATIME);
    }
  } while (0);
  do {
    if (flags & ((1 << 25))) {
      sc_string_append(buf, buf_size,
                       "lazytime"
                       ",");
      flags ^= ((1 << 25));
    }
  } while (0);
  do {
    if (flags & ((1 << 28))) {
      sc_string_append(buf, buf_size,
                       "nosec"
                       ",");
      flags ^= ((1 << 28));
    }
  } while (0);
  do {
    if (flags & ((1 << 29))) {
      sc_string_append(buf, buf_size,
                       "born"
                       ",");
      flags ^= ((1 << 29));
    }
  } while (0);
  do {
    if (flags & (MS_ACTIVE)) {
      sc_string_append(buf, buf_size,
                       "active"
                       ",");
      flags ^= (MS_ACTIVE);
    }
  } while (0);
  do {
    if (flags & (MS_NOUSER)) {
      sc_string_append(buf, buf_size,
                       "nouser"
                       ",");
      flags ^= (MS_NOUSER);
    }
  } while (0);
  if (flags) {
    char of[128] = {0};
    sc_must_snprintf(of, sizeof of, "%#lx", flags);
    sc_string_append(buf, buf_size, of);
  }
  size_t len = strnlen(buf, buf_size);
  if (len > 0 && buf[len - 1] == ',') {
    buf[len - 1] = 0;
  }
  return buf;
}


x86 assembly (clang, -O0):
<sc_mount_opt2str>:
push   %rbp
mov    %rsp,%rbp
sub    $0xb0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
movq   $0x0,-0x20(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
call   1070 <sc_string_init@plt>
mov    -0x18(%rbp),%rax
mov    0x2df1(%rip),%rcx
and    (%rcx),%rax
cmp    $0x0,%rax
je     11ba <sc_mount_opt2str+0x6a>
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
lea    0xe5d(%rip),%rdx
call   1060 <sc_string_append@plt>
mov    0x2dc9(%rip),%rax
mov    (%rax),%rax
xor    -0x18(%rbp),%rax
mov    %rax,-0x18(%rbp)
jmp    11bf <sc_mount_opt2str+0x6f>
jmp    11c4 <sc_mount_opt2str+0x74>
mov    -0x18(%rbp),%rax
mov    0x2de9(%rip),%rcx
and    (%rcx),%rax
cmp    $0x0,%rax
je     1202 <sc_mount_opt2str+0xb2>
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
lea    0xe19(%rip),%rdx
call   1060 <sc_string_append@plt>
mov    0x2dc1(%rip),%rax
mov    (%rax),%rax
xor    -0x18(%rbp),%rax
mov    %rax,-0x18(%rbp)
jmp    1207 <sc_mount_opt2str+0xb7>
jmp    120c <sc_mount_opt2str+0xbc>
mov    -0x18(%rbp),%rax
mov    0x2dd9(%rip),%rcx
and    (%rcx),%rax
cmp    $0x0,%rax
je     124a <sc_mount_opt2str+0xfa>
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
lea    0xdd9(%rip),%rdx
call   1060 <sc_string_append@plt>
mov    0x2db1(%rip),%rax
mov    (%rax),%rax
xor    -0x18(%rbp),%rax
mov    %rax,-0x18(%rbp)
jmp    124f <sc_mount_opt2str+0xff>
jmp    1254 <sc_mount_opt2str+0x104>
mov    -0x18(%rbp),%rax
mov    0x2cb9(%rip),%rcx
and    (%rcx),%rax
cmp    $0x0,%rax
je     1292 <sc_mount_opt2str+0x142>
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
lea    0xd98(%rip),%rdx
call   1060 <sc_string_append@plt>
mov    0x2c91(%rip),%rax
mov    (%rax),%rax
xor    -0x18(%rbp),%rax
mov    %rax,-0x18(%rbp)
jmp    1297 <sc_mount_opt2str+0x147>
jmp    129c <sc_mount_opt2str+0x14c>
mov    -0x18(%rbp),%rax
mov    0x2cd9(%rip),%rcx
and    (%rcx),%rax
cmp    $0x0,%rax
je     12da <sc_mount_opt2str+0x18a>
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
lea    0xd6a(%rip),%rdx
call   1060 <sc_string_append@plt>
mov    0x2cb1(%rip),%rax
mov    (%rax),%rax
xor    -0x18(%rbp),%rax
mov    %rax,-0x18(%rbp)
jmp    12df <sc_mount_opt2str+0x18f>
jmp    12e4 <sc_mount_opt2str+0x194>
mov    -0x18(%rbp),%rax
mov    0x2c41(%rip),%rcx
and    (%rcx),%rax
cmp    $0x0,%rax
je     1322 <sc_mount_opt2str+0x1d2>
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
lea    0xd10(%rip),%rdx
call   1060 <sc_string_append@plt>
mov    0x2c19(%rip),%rax
mov    (%rax),%rax
xor    -0x18(%rbp),%rax
mov    %rax,-0x18(%rbp)
jmp    1327 <sc_mount_opt2str+0x1d7>
jmp    132c <sc_mount_opt2str+0x1dc>
mov    -0x18(%rbp),%rax
mov    0x2c79(%rip),%rcx
and    (%rcx),%rax
cmp    $0x0,%rax
je     136a <sc_mount_opt2str+0x21a>
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
lea    0xcd1(%rip),%rdx
call   1060 <sc_string_append@plt>
mov    0x2c51(%rip),%rax
mov    (%rax),%rax
xor    -0x18(%rbp),%rax
mov    %rax,-0x18(%rbp)
jmp    136f <sc_mount_opt2str+0x21f>
jmp    1374 <sc_mount_opt2str+0x224>
mov    -0x18(%rbp),%rax
mov    0x2c29(%rip),%rcx
and    (%rcx),%rax
cmp    $0x0,%rax
je     13b2 <sc_mount_opt2str+0x262>
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
lea    0xc8f(%rip),%rdx
call   1060 <sc_string_append@plt>
mov    0x2c01(%rip),%rax
mov    (%rax),%rax
xor    -0x18(%rbp),%rax
mov    %rax,-0x18(%rbp)
jmp    13b7 <sc_mount_opt2str+0x267>
jmp    13bc <sc_mount_opt2str+0x26c>
mov    -0x18(%rbp),%rax
mov    0x2c19(%rip),%rcx
and    (%rcx),%rax
cmp    $0x0,%rax
je     13fa <sc_mount_opt2str+0x2aa>
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
lea    0xc50(%rip),%rdx
call   1060 <sc_string_append@plt>
mov    0x2bf1(%rip),%rax
mov    (%rax),%rax
xor    -0x18(%rbp),%rax
mov    %rax,-0x18(%rbp)
jmp    13ff <sc_mount_opt2str+0x2af>
jmp    1404 <sc_mount_opt2str+0x2b4>
mov    -0x18(%rbp),%rax
mov    0x2b29(%rip),%rcx
and    (%rcx),%rax
cmp    $0x0,%rax
je     1442 <sc_mount_opt2str+0x2f2>
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
lea    0xc11(%rip),%rdx
call   1060 <sc_string_append@plt>
mov    0x2b01(%rip),%rax
mov    (%rax),%rax
xor    -0x18(%rbp),%rax
mov    %rax,-0x18(%rbp)
jmp    1447 <sc_mount_opt2str+0x2f7>
mov    -0x18(%rbp),%rax
mov    0x2b4e(%rip),%rcx
and    (%rcx),%rax
cmp    $0x0,%rax
je     14c8 <sc_mount_opt2str+0x378>
mov    -0x18(%rbp),%rax
mov    0x2b26(%rip),%rcx
and    (%rcx),%rax
cmp    $0x0,%rax
je     14a2 <sc_mount_opt2str+0x352>
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
lea    0xbc2(%rip),%rdx
call   1060 <sc_string_append@plt>
mov    0x2afe(%rip),%rax
mov    (%rax),%rax
or     -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
jmp    14b6 <sc_mount_opt2str+0x366>
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
lea    0xb98(%rip),%rdx
call   1060 <sc_string_append@plt>
mov    0x2ae3(%rip),%rax
mov    (%rax),%rax
xor    -0x18(%rbp),%rax
mov    %rax,-0x18(%rbp)
jmp    14cd <sc_mount_opt2str+0x37d>
mov    -0x18(%rbp),%rax
mov    0x2a80(%rip),%rcx
and    (%rcx),%rax
cmp    $0x0,%rax
je     150b <sc_mount_opt2str+0x3bb>
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
lea    0xb5b(%rip),%rdx
call   1060 <sc_string_append@plt>
mov    0x2a58(%rip),%rax
mov    (%rax),%rax
xor    -0x18(%rbp),%rax
mov    %rax,-0x18(%rbp)
jmp    1510 <sc_mount_opt2str+0x3c0>
jmp    1515 <sc_mount_opt2str+0x3c5>
mov    -0x18(%rbp),%rax
mov    0x2aa0(%rip),%rcx
and    (%rcx),%rax
cmp    $0x0,%rax
je     1553 <sc_mount_opt2str+0x403>
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
lea    0xb19(%rip),%rdx
call   1060 <sc_string_append@plt>
mov    0x2a78(%rip),%rax
mov    (%rax),%rax
xor    -0x18(%rbp),%rax
mov    %rax,-0x18(%rbp)
jmp    1558 <sc_mount_opt2str+0x408>
jmp    155d <sc_mount_opt2str+0x40d>
mov    -0x18(%rbp),%rax
mov    0x29f8(%rip),%rcx
and    (%rcx),%rax
cmp    $0x0,%rax
je     159b <sc_mount_opt2str+0x44b>
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
lea    0xad9(%rip),%rdx
call   1060 <sc_string_append@plt>
mov    0x29d0(%rip),%rax
mov    (%rax),%rax
xor    -0x18(%rbp),%rax
mov    %rax,-0x18(%rbp)
jmp    15a0 <sc_mount_opt2str+0x450>
jmp    15a5 <sc_mount_opt2str+0x455>
mov    -0x18(%rbp),%rax
mov    0x2a18(%rip),%rcx
and    (%rcx),%rax
cmp    $0x0,%rax
je     15e3 <sc_mount_opt2str+0x493>
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
lea    0xa96(%rip),%rdx
call   1060 <sc_string_append@plt>
mov    0x29f0(%rip),%rax
mov    (%rax),%rax
xor    -0x18(%rbp),%rax
mov    %rax,-0x18(%rbp)
jmp    15e8 <sc_mount_opt2str+0x498>
mov    -0x18(%rbp),%rax
mov    0x2975(%rip),%rcx
and    (%rcx),%rax
cmp    $0x0,%rax
je     1669 <sc_mount_opt2str+0x519>
mov    -0x18(%rbp),%rax
mov    0x2985(%rip),%rcx
and    (%rcx),%rax
cmp    $0x0,%rax
je     1643 <sc_mount_opt2str+0x4f3>
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
lea    0xa47(%rip),%rdx
call   1060 <sc_string_append@plt>
mov    0x295d(%rip),%rax
mov    (%rax),%rax
or     -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
jmp    1657 <sc_mount_opt2str+0x507>
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
lea    0xa1d(%rip),%rdx
call   1060 <sc_string_append@plt>
mov    0x290a(%rip),%rax
mov    (%rax),%rax
xor    -0x18(%rbp),%rax
mov    %rax,-0x18(%rbp)
mov    -0x18(%rbp),%rax
mov    0x28cc(%rip),%rcx
and    (%rcx),%rax
cmp    $0x0,%rax
je     16ea <sc_mount_opt2str+0x59a>
mov    -0x18(%rbp),%rax
mov    0x2904(%rip),%rcx
and    (%rcx),%rax
cmp    $0x0,%rax
je     16c4 <sc_mount_opt2str+0x574>
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
lea    0x9d0(%rip),%rdx
call   1060 <sc_string_append@plt>
mov    0x28dc(%rip),%rax
mov    (%rax),%rax
or     -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
jmp    16d8 <sc_mount_opt2str+0x588>
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
lea    0x9a6(%rip),%rdx
call   1060 <sc_string_append@plt>
mov    0x2861(%rip),%rax
mov    (%rax),%rax
xor    -0x18(%rbp),%rax
mov    %rax,-0x18(%rbp)
mov    -0x18(%rbp),%rax
mov    0x28a3(%rip),%rcx
and    (%rcx),%rax
cmp    $0x0,%rax
je     176b <sc_mount_opt2str+0x61b>
mov    -0x18(%rbp),%rax
mov    0x2883(%rip),%rcx
and    (%rcx),%rax
cmp    $0x0,%rax
je     1745 <sc_mount_opt2str+0x5f5>
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
lea    0x957(%rip),%rdx
call   1060 <sc_string_append@plt>
mov    0x285b(%rip),%rax
mov    (%rax),%rax
or     -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
jmp    1759 <sc_mount_opt2str+0x609>
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
lea    0x92d(%rip),%rdx
call   1060 <sc_string_append@plt>
mov    0x2838(%rip),%rax
mov    (%rax),%rax
xor    -0x18(%rbp),%rax
mov    %rax,-0x18(%rbp)
mov    -0x20(%rbp),%rax
xor    -0x18(%rbp),%rax
mov    %rax,-0x18(%rbp)
mov    -0x18(%rbp),%rax
mov    0x27ce(%rip),%rcx
and    (%rcx),%rax
cmp    $0x0,%rax
je     17b5 <sc_mount_opt2str+0x665>
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
lea    0x8eb(%rip),%rdx
call   1060 <sc_string_append@plt>
mov    0x27a6(%rip),%rax
mov    (%rax),%rax
xor    -0x18(%rbp),%rax
mov    %rax,-0x18(%rbp)
jmp    17ba <sc_mount_opt2str+0x66a>
jmp    17bf <sc_mount_opt2str+0x66f>
mov    -0x18(%rbp),%rax
mov    0x27be(%rip),%rcx
and    (%rcx),%rax
cmp    $0x0,%rax
je     17fd <sc_mount_opt2str+0x6ad>
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
lea    0x8ad(%rip),%rdx
call   1060 <sc_string_append@plt>
mov    0x2796(%rip),%rax
mov    (%rax),%rax
xor    -0x18(%rbp),%rax
mov    %rax,-0x18(%rbp)
jmp    1802 <sc_mount_opt2str+0x6b2>
jmp    1807 <sc_mount_opt2str+0x6b7>
mov    -0x18(%rbp),%rax
mov    0x27d6(%rip),%rcx
and    (%rcx),%rax
cmp    $0x0,%rax
je     1845 <sc_mount_opt2str+0x6f5>
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
lea    0x870(%rip),%rdx
call   1060 <sc_string_append@plt>
mov    0x27ae(%rip),%rax
mov    (%rax),%rax
xor    -0x18(%rbp),%rax
mov    %rax,-0x18(%rbp)
jmp    184a <sc_mount_opt2str+0x6fa>
jmp    184f <sc_mount_opt2str+0x6ff>
mov    -0x18(%rbp),%rax
mov    0x2776(%rip),%rcx
and    (%rcx),%rax
cmp    $0x0,%rax
je     188d <sc_mount_opt2str+0x73d>
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
lea    0x832(%rip),%rdx
call   1060 <sc_string_append@plt>
mov    0x274e(%rip),%rax
mov    (%rax),%rax
xor    -0x18(%rbp),%rax
mov    %rax,-0x18(%rbp)
jmp    1892 <sc_mount_opt2str+0x742>
jmp    1897 <sc_mount_opt2str+0x747>
mov    -0x18(%rbp),%rax
and    $0x2000000,%rax
cmp    $0x0,%rax
je     18cd <sc_mount_opt2str+0x77d>
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
lea    0x7fb(%rip),%rdx
call   1060 <sc_string_append@plt>
mov    -0x18(%rbp),%rax
xor    $0x2000000,%rax
mov    %rax,-0x18(%rbp)
jmp    18d2 <sc_mount_opt2str+0x782>
jmp    18d7 <sc_mount_opt2str+0x787>
mov    -0x18(%rbp),%rax
and    $0x10000000,%rax
cmp    $0x0,%rax
je     190d <sc_mount_opt2str+0x7bd>
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
lea    0x7c5(%rip),%rdx
call   1060 <sc_string_append@plt>
mov    -0x18(%rbp),%rax
xor    $0x10000000,%rax
mov    %rax,-0x18(%rbp)
jmp    1912 <sc_mount_opt2str+0x7c2>
jmp    1917 <sc_mount_opt2str+0x7c7>
mov    -0x18(%rbp),%rax
and    $0x20000000,%rax
cmp    $0x0,%rax
je     194d <sc_mount_opt2str+0x7fd>
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
lea    0x78c(%rip),%rdx
call   1060 <sc_string_append@plt>
mov    -0x18(%rbp),%rax
xor    $0x20000000,%rax
mov    %rax,-0x18(%rbp)
jmp    1952 <sc_mount_opt2str+0x802>
jmp    1957 <sc_mount_opt2str+0x807>
mov    -0x18(%rbp),%rax
mov    0x25c6(%rip),%rcx
and    (%rcx),%rax
cmp    $0x0,%rax
je     1995 <sc_mount_opt2str+0x845>
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
lea    0x74e(%rip),%rdx
call   1060 <sc_string_append@plt>
mov    0x259e(%rip),%rax
mov    (%rax),%rax
xor    -0x18(%rbp),%rax
mov    %rax,-0x18(%rbp)
jmp    199a <sc_mount_opt2str+0x84a>
jmp    199f <sc_mount_opt2str+0x84f>
mov    -0x18(%rbp),%rax
mov    0x259e(%rip),%rcx
and    (%rcx),%rax
cmp    $0x0,%rax
je     19dd <sc_mount_opt2str+0x88d>
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
lea    0x70e(%rip),%rdx
call   1060 <sc_string_append@plt>
mov    0x2576(%rip),%rax
mov    (%rax),%rax
xor    -0x18(%rbp),%rax
mov    %rax,-0x18(%rbp)
jmp    19e2 <sc_mount_opt2str+0x892>
cmpq   $0x0,-0x18(%rbp)
je     1a30 <sc_mount_opt2str+0x8e0>
lea    -0xa0(%rbp),%rdi
xor    %esi,%esi
mov    $0x80,%edx
call   1030 <memset@plt>
lea    -0xa0(%rbp),%rdi
mov    -0x18(%rbp),%rcx
mov    $0x80,%esi
lea    0x6c5(%rip),%rdx
call   1050 <sc_must_snprintf@plt>
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
lea    -0xa0(%rbp),%rdx
call   1060 <sc_string_append@plt>
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
call   1040 <strnlen@plt>
mov    %rax,-0xa8(%rbp)
cmpq   $0x0,-0xa8(%rbp)
jbe    1a81 <sc_mount_opt2str+0x931>
mov    -0x8(%rbp),%rax
mov    -0xa8(%rbp),%rcx
sub    $0x1,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x2c,%eax
jne    1a81 <sc_mount_opt2str+0x931>
mov    -0x8(%rbp),%rax
mov    -0xa8(%rbp),%rcx
sub    $0x1,%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x8(%rbp),%rax
add    $0xb0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<sc_mount_opt2str>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x88,%rsp
mov    %rdx,%rbx
mov    %rsi,%r14
mov    %rdi,%r15
call   1060 <sc_string_init@plt>
mov    0x2e12(%rip),%rbp
test   %rbx,0x0(%rbp)
je     1182 <sc_mount_opt2str+0x42>
lea    0xe8d(%rip),%rdx
mov    %r15,%rdi
mov    %r14,%rsi
call   1050 <sc_string_append@plt>
xor    0x0(%rbp),%rbx
mov    0x2e2f(%rip),%rbp
test   %rbx,0x0(%rbp)
je     11a5 <sc_mount_opt2str+0x65>
lea    0xe6e(%rip),%rdx
mov    %r15,%rdi
mov    %r14,%rsi
call   1050 <sc_string_append@plt>
xor    0x0(%rbp),%rbx
mov    0x2e44(%rip),%rbp
test   %rbx,0x0(%rbp)
je     11c8 <sc_mount_opt2str+0x88>
lea    0xe53(%rip),%rdx
mov    %r15,%rdi
mov    %r14,%rsi
call   1050 <sc_string_append@plt>
xor    0x0(%rbp),%rbx
mov    0x2d49(%rip),%rbp
test   %rbx,0x0(%rbp)
je     11eb <sc_mount_opt2str+0xab>
lea    0xe37(%rip),%rdx
mov    %r15,%rdi
mov    %r14,%rsi
call   1050 <sc_string_append@plt>
xor    0x0(%rbp),%rbx
mov    0x2d8e(%rip),%rbp
test   %rbx,0x0(%rbp)
je     120e <sc_mount_opt2str+0xce>
lea    0xe2e(%rip),%rdx
mov    %r15,%rdi
mov    %r14,%rsi
call   1050 <sc_string_append@plt>
xor    0x0(%rbp),%rbx
mov    0x2d1b(%rip),%rbp
test   %rbx,0x0(%rbp)
je     1231 <sc_mount_opt2str+0xf1>
lea    0xdf9(%rip),%rdx
mov    %r15,%rdi
mov    %r14,%rsi
call   1050 <sc_string_append@plt>
xor    0x0(%rbp),%rbx
mov    0x2d78(%rip),%rbp
test   %rbx,0x0(%rbp)
je     1254 <sc_mount_opt2str+0x114>
lea    0xddf(%rip),%rdx
mov    %r15,%rdi
mov    %r14,%rsi
call   1050 <sc_string_append@plt>
xor    0x0(%rbp),%rbx
mov    0x2d4d(%rip),%rbp
test   %rbx,0x0(%rbp)
je     1277 <sc_mount_opt2str+0x137>
lea    0xdc2(%rip),%rdx
mov    %r15,%rdi
mov    %r14,%rsi
call   1050 <sc_string_append@plt>
xor    0x0(%rbp),%rbx
mov    0x2d62(%rip),%rbp
test   %rbx,0x0(%rbp)
je     129a <sc_mount_opt2str+0x15a>
lea    0xda8(%rip),%rdx
mov    %r15,%rdi
mov    %r14,%rsi
call   1050 <sc_string_append@plt>
xor    0x0(%rbp),%rbx
mov    0x2c97(%rip),%rbp
test   %rbx,0x0(%rbp)
je     12bd <sc_mount_opt2str+0x17d>
lea    0xd8e(%rip),%rdx
mov    %r15,%rdi
mov    %r14,%rsi
call   1050 <sc_string_append@plt>
xor    0x0(%rbp),%rbx
mov    0x2cdc(%rip),%r13
test   %rbx,0x0(%r13)
je     12ef <sc_mount_opt2str+0x1af>
mov    0x2cbf(%rip),%rbp
test   %rbx,0x0(%rbp)
je     12f4 <sc_mount_opt2str+0x1b4>
lea    0xd6a(%rip),%rdx
mov    %r15,%rdi
mov    %r14,%rsi
call   1050 <sc_string_append@plt>
mov    0x0(%rbp),%r12
jmp    1309 <sc_mount_opt2str+0x1c9>
xor    %r12d,%r12d
jmp    130d <sc_mount_opt2str+0x1cd>
lea    0xd4e(%rip),%rdx
mov    %r15,%rdi
mov    %r14,%rsi
call   1050 <sc_string_append@plt>
xor    %r12d,%r12d
xor    0x0(%r13),%rbx
mov    0x2c44(%rip),%rbp
test   %rbx,0x0(%rbp)
je     1330 <sc_mount_opt2str+0x1f0>
lea    0xd2e(%rip),%rdx
mov    %r15,%rdi
mov    %r14,%rsi
call   1050 <sc_string_append@plt>
xor    0x0(%rbp),%rbx
mov    0x2c89(%rip),%rbp
test   %rbx,0x0(%rbp)
je     1353 <sc_mount_opt2str+0x213>
lea    0xd11(%rip),%rdx
mov    %r15,%rdi
mov    %r14,%rsi
call   1050 <sc_string_append@plt>
xor    0x0(%rbp),%rbx
mov    0x2c06(%rip),%rbp
test   %rbx,0x0(%rbp)
je     1376 <sc_mount_opt2str+0x236>
lea    0xcf6(%rip),%rdx
mov    %r15,%rdi
mov    %r14,%rsi
call   1050 <sc_string_append@plt>
xor    0x0(%rbp),%rbx
mov    0x2c4b(%rip),%rbp
test   %rbx,0x0(%rbp)
je     1399 <sc_mount_opt2str+0x259>
lea    0xcd8(%rip),%rdx
mov    %r15,%rdi
mov    %r14,%rsi
call   1050 <sc_string_append@plt>
xor    0x0(%rbp),%rbx
mov    0x2bc8(%rip),%r13
test   %rbx,0x0(%r13)
je     13e1 <sc_mount_opt2str+0x2a1>
mov    0x2be3(%rip),%rbp
test   %rbx,0x0(%rbp)
je     13cb <sc_mount_opt2str+0x28b>
lea    0xcb4(%rip),%rdx
mov    %r15,%rdi
mov    %r14,%rsi
call   1050 <sc_string_append@plt>
or     0x0(%rbp),%r12
jmp    13dd <sc_mount_opt2str+0x29d>
lea    0xc9d(%rip),%rdx
mov    %r15,%rdi
mov    %r14,%rsi
call   1050 <sc_string_append@plt>
xor    0x0(%r13),%rbx
mov    0x2b58(%rip),%r13
test   %rbx,0x0(%r13)
je     1429 <sc_mount_opt2str+0x2e9>
mov    0x2b9b(%rip),%rbp
test   %rbx,0x0(%rbp)
je     1413 <sc_mount_opt2str+0x2d3>
lea    0xc76(%rip),%rdx
mov    %r15,%rdi
mov    %r14,%rsi
call   1050 <sc_string_append@plt>
or     0x0(%rbp),%r12
jmp    1425 <sc_mount_opt2str+0x2e5>
lea    0xc5f(%rip),%rdx
mov    %r15,%rdi
mov    %r14,%rsi
call   1050 <sc_string_append@plt>
xor    0x0(%r13),%rbx
mov    0x2b68(%rip),%r13
test   %rbx,0x0(%r13)
je     1471 <sc_mount_opt2str+0x331>
mov    0x2b53(%rip),%rbp
test   %rbx,0x0(%rbp)
je     145b <sc_mount_opt2str+0x31b>
lea    0xc36(%rip),%rdx
mov    %r15,%rdi
mov    %r14,%rsi
call   1050 <sc_string_append@plt>
or     0x0(%rbp),%r12
jmp    146d <sc_mount_opt2str+0x32d>
lea    0xc1f(%rip),%rdx
mov    %r15,%rdi
mov    %r14,%rsi
call   1050 <sc_string_append@plt>
xor    0x0(%r13),%rbx
xor    %rbx,%r12
mov    0x2ad5(%rip),%rbx
test   %r12,(%rbx)
je     1495 <sc_mount_opt2str+0x355>
lea    0xc02(%rip),%rdx
mov    %r15,%rdi
mov    %r14,%rsi
call   1050 <sc_string_append@plt>
xor    (%rbx),%r12
mov    0x2aec(%rip),%rbx
test   %r12,(%rbx)
je     14b6 <sc_mount_opt2str+0x376>
lea    0xbeb(%rip),%rdx
mov    %r15,%rdi
mov    %r14,%rsi
call   1050 <sc_string_append@plt>
xor    (%rbx),%r12
mov    0x2b2b(%rip),%rbx
test   %r12,(%rbx)
je     14d7 <sc_mount_opt2str+0x397>
lea    0xbd5(%rip),%rdx
mov    %r15,%rdi
mov    %r14,%rsi
call   1050 <sc_string_append@plt>
xor    (%rbx),%r12
mov    0x2af2(%rip),%rbx
test   %r12,(%rbx)
je     14f8 <sc_mount_opt2str+0x3b8>
lea    0xbbe(%rip),%rdx
mov    %r15,%rdi
mov    %r14,%rsi
call   1050 <sc_string_append@plt>
xor    (%rbx),%r12
test   $0x2000000,%r12d
jne    1600 <sc_mount_opt2str+0x4c0>
test   $0x10000000,%r12d
jne    1626 <sc_mount_opt2str+0x4e6>
test   $0x20000000,%r12d
je     1534 <sc_mount_opt2str+0x3f4>
lea    0xba4(%rip),%rdx
mov    %r15,%rdi
mov    %r14,%rsi
call   1050 <sc_string_append@plt>
xor    $0x20000000,%r12
mov    0x29ed(%rip),%rbx
test   %r12,(%rbx)
je     1555 <sc_mount_opt2str+0x415>
lea    0xb85(%rip),%rdx
mov    %r15,%rdi
mov    %r14,%rsi
call   1050 <sc_string_append@plt>
xor    (%rbx),%r12
mov    0x29ec(%rip),%rbx
test   %r12,(%rbx)
je     1576 <sc_mount_opt2str+0x436>
lea    0xb6c(%rip),%rdx
mov    %r15,%rdi
mov    %r14,%rsi
call   1050 <sc_string_append@plt>
xor    (%rbx),%r12
test   %r12,%r12
je     15cd <sc_mount_opt2str+0x48d>
xorps  %xmm0,%xmm0
movaps %xmm0,0x70(%rsp)
movaps %xmm0,0x60(%rsp)
movaps %xmm0,0x50(%rsp)
movaps %xmm0,0x40(%rsp)
movaps %xmm0,0x30(%rsp)
movaps %xmm0,0x20(%rsp)
movaps %xmm0,0x10(%rsp)
movaps %xmm0,(%rsp)
lea    0xb30(%rip),%rdx
mov    %rsp,%rbx
mov    %rbx,%rdi
mov    $0x80,%esi
mov    %r12,%rcx
call   1040 <sc_must_snprintf@plt>
mov    %r15,%rdi
mov    %r14,%rsi
mov    %rbx,%rdx
call   1050 <sc_string_append@plt>
mov    %r15,%rdi
mov    %r14,%rsi
call   1030 <strnlen@plt>
test   %rax,%rax
je     15eb <sc_mount_opt2str+0x4ab>
cmpb   $0x2c,-0x1(%rax,%r15,1)
jne    15eb <sc_mount_opt2str+0x4ab>
movb   $0x0,-0x1(%r15,%rax,1)
mov    %r15,%rax
add    $0x88,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    0xaae(%rip),%rdx
mov    %r15,%rdi
mov    %r14,%rsi
call   1050 <sc_string_append@plt>
xor    $0x2000000,%r12
test   $0x10000000,%r12d
je     1512 <sc_mount_opt2str+0x3d2>
lea    0xa92(%rip),%rdx
mov    %r15,%rdi
mov    %r14,%rsi
call   1050 <sc_string_append@plt>
xor    $0x10000000,%r12
test   $0x20000000,%r12d
jne    151b <sc_mount_opt2str+0x3db>
jmp    1534 <sc_mount_opt2str+0x3f4>

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

LLVM IR (-O2):
@MS_RDONLY = global i64 0
@.str = [4 x i8] c"ro,\00"
@MS_NOSUID = global i64 0
@.str.1 = [8 x i8] c"nosuid,\00"
@MS_NODEV = global i64 0
@.str.2 = [7 x i8] c"nodev,\00"
@MS_NOEXEC = global i64 0
@.str.3 = [8 x i8] c"noexec,\00"
@MS_SYNCHRONOUS = global i64 0
@.str.4 = [6 x i8] c"sync,\00"
@MS_REMOUNT = global i64 0
@.str.5 = [9 x i8] c"remount,\00"
@MS_MANDLOCK = global i64 0
@.str.6 = [6 x i8] c"mand,\00"
@MS_DIRSYNC = global i64 0
@.str.7 = [9 x i8] c"dirsync,\00"
@MS_NOATIME = global i64 0
@.str.8 = [9 x i8] c"noatime,\00"
@MS_NODIRATIME = global i64 0
@.str.9 = [12 x i8] c"nodiratime,\00"
@MS_BIND = global i64 0
@MS_REC = global i64 0
@.str.10 = [7 x i8] c"rbind,\00"
@.str.11 = [6 x i8] c"bind,\00"
@MS_MOVE = global i64 0
@.str.12 = [6 x i8] c"move,\00"
@MS_SILENT = global i64 0
@.str.13 = [8 x i8] c"silent,\00"
@MS_POSIXACL = global i64 0
@.str.14 = [5 x i8] c"acl,\00"
@MS_UNBINDABLE = global i64 0
@.str.15 = [12 x i8] c"unbindable,\00"
@MS_PRIVATE = global i64 0
@.str.16 = [10 x i8] c"rprivate,\00"
@.str.17 = [9 x i8] c"private,\00"
@MS_SLAVE = global i64 0
@.str.18 = [8 x i8] c"rslave,\00"
@.str.19 = [7 x i8] c"slave,\00"
@MS_SHARED = global i64 0
@.str.20 = [9 x i8] c"rshared,\00"
@.str.21 = [8 x i8] c"shared,\00"
@MS_RELATIME = global i64 0
@.str.22 = [10 x i8] c"relatime,\00"
@MS_KERNMOUNT = global i64 0
@.str.23 = [11 x i8] c"kernmount,\00"
@MS_I_VERSION = global i64 0
@.str.24 = [10 x i8] c"iversion,\00"
@MS_STRICTATIME = global i64 0
@.str.25 = [13 x i8] c"strictatime,\00"
@.str.26 = [10 x i8] c"lazytime,\00"
@.str.27 = [7 x i8] c"nosec,\00"
@.str.28 = [6 x i8] c"born,\00"
@MS_ACTIVE = global i64 0
@.str.29 = [8 x i8] c"active,\00"
@MS_NOUSER = global i64 0
@.str.30 = [8 x i8] c"nouser,\00"
@.str.31 = [5 x i8] c"%#lx\00"
define i8* @sc_mount_opt2str(i8* returned %0, i64 %1, i64 %2) {
%4 = alloca [128 x i8]
%5 = tail call i32 @sc_string_init(i8* %0, i64 %1)
%6 = load i64, i64* @MS_RDONLY
%7 = and i64 %6, %2
%8 = icmp eq i64 %7, 0
br i1 %8, label %13, label %9
9: ; preds = %3
%10 = tail call i32 @sc_string_append(i8* %0, i64 %1, i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0))
%11 = load i64, i64* @MS_RDONLY
%12 = xor i64 %11, %2
br label %13
13: ; preds = %3, %9
%14 = phi i64 [ %12, %9 ], [ %2, %3 ]
%15 = load i64, i64* @MS_NOSUID
%16 = and i64 %15, %14
%17 = icmp eq i64 %16, 0
br i1 %17, label %22, label %18
18: ; preds = %13
%19 = tail call i32 @sc_string_append(i8* %0, i64 %1, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.1, i64 0, i64 0))
%20 = load i64, i64* @MS_NOSUID
%21 = xor i64 %20, %14
br label %22
22: ; preds = %13, %18
%23 = phi i64 [ %21, %18 ], [ %14, %13 ]
%24 = load i64, i64* @MS_NODEV
%25 = and i64 %24, %23
%26 = icmp eq i64 %25, 0
br i1 %26, label %31, label %27
27: ; preds = %22
%28 = tail call i32 @sc_string_append(i8* %0, i64 %1, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.2, i64 0, i64 0))
%29 = load i64, i64* @MS_NODEV
%30 = xor i64 %29, %23
br label %31
31: ; preds = %22, %27
%32 = phi i64 [ %30, %27 ], [ %23, %22 ]
%33 = load i64, i64* @MS_NOEXEC
%34 = and i64 %33, %32
%35 = icmp eq i64 %34, 0
br i1 %35, label %40, label %36
36: ; preds = %31
%37 = tail call i32 @sc_string_append(i8* %0, i64 %1, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.3, i64 0, i64 0))
%38 = load i64, i64* @MS_NOEXEC
%39 = xor i64 %38, %32
br label %40
40: ; preds = %31, %36
%41 = phi i64 [ %39, %36 ], [ %32, %31 ]
%42 = load i64, i64* @MS_SYNCHRONOUS
%43 = and i64 %42, %41
%44 = icmp eq i64 %43, 0
br i1 %44, label %49, label %45
45: ; preds = %40
%46 = tail call i32 @sc_string_append(i8* %0, i64 %1, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.4, i64 0, i64 0))
%47 = load i64, i64* @MS_SYNCHRONOUS
%48 = xor i64 %47, %41
br label %49
49: ; preds = %40, %45
%50 = phi i64 [ %48, %45 ], [ %41, %40 ]
%51 = load i64, i64* @MS_REMOUNT
%52 = and i64 %51, %50
%53 = icmp eq i64 %52, 0
br i1 %53, label %58, label %54
54: ; preds = %49
%55 = tail call i32 @sc_string_append(i8* %0, i64 %1, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.5, i64 0, i64 0))
%56 = load i64, i64* @MS_REMOUNT
%57 = xor i64 %56, %50
br label %58
58: ; preds = %49, %54
%59 = phi i64 [ %57, %54 ], [ %50, %49 ]
%60 = load i64, i64* @MS_MANDLOCK
%61 = and i64 %60, %59
%62 = icmp eq i64 %61, 0
br i1 %62, label %67, label %63
63: ; preds = %58
%64 = tail call i32 @sc_string_append(i8* %0, i64 %1, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.6, i64 0, i64 0))
%65 = load i64, i64* @MS_MANDLOCK
%66 = xor i64 %65, %59
br label %67
67: ; preds = %58, %63
%68 = phi i64 [ %66, %63 ], [ %59, %58 ]
%69 = load i64, i64* @MS_DIRSYNC
%70 = and i64 %69, %68
%71 = icmp eq i64 %70, 0
br i1 %71, label %76, label %72
72: ; preds = %67
%73 = tail call i32 @sc_string_append(i8* %0, i64 %1, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.7, i64 0, i64 0))
%74 = load i64, i64* @MS_DIRSYNC
%75 = xor i64 %74, %68
br label %76
76: ; preds = %67, %72
%77 = phi i64 [ %75, %72 ], [ %68, %67 ]
%78 = load i64, i64* @MS_NOATIME
%79 = and i64 %78, %77
%80 = icmp eq i64 %79, 0
br i1 %80, label %85, label %81
81: ; preds = %76
%82 = tail call i32 @sc_string_append(i8* %0, i64 %1, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.8, i64 0, i64 0))
%83 = load i64, i64* @MS_NOATIME
%84 = xor i64 %83, %77
br label %85
85: ; preds = %76, %81
%86 = phi i64 [ %84, %81 ], [ %77, %76 ]
%87 = load i64, i64* @MS_NODIRATIME
%88 = and i64 %87, %86
%89 = icmp eq i64 %88, 0
br i1 %89, label %94, label %90
90: ; preds = %85
%91 = tail call i32 @sc_string_append(i8* %0, i64 %1, i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.9, i64 0, i64 0))
%92 = load i64, i64* @MS_NODIRATIME
%93 = xor i64 %92, %86
br label %94
94: ; preds = %90, %85
%95 = phi i64 [ %93, %90 ], [ %86, %85 ]
%96 = load i64, i64* @MS_BIND
%97 = and i64 %96, %95
%98 = icmp eq i64 %97, 0
br i1 %98, label %112, label %99
99: ; preds = %94
%100 = load i64, i64* @MS_REC
%101 = and i64 %100, %95
%102 = icmp eq i64 %101, 0
br i1 %102, label %106, label %103
103: ; preds = %99
%104 = tail call i32 @sc_string_append(i8* %0, i64 %1, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.10, i64 0, i64 0))
%105 = load i64, i64* @MS_REC
br label %108
106: ; preds = %99
%107 = tail call i32 @sc_string_append(i8* %0, i64 %1, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.11, i64 0, i64 0))
br label %108
108: ; preds = %106, %103
%109 = phi i64 [ %105, %103 ], [ 0, %106 ]
%110 = load i64, i64* @MS_BIND
%111 = xor i64 %110, %95
br label %112
112: ; preds = %94, %108
%113 = phi i64 [ %109, %108 ], [ 0, %94 ]
%114 = phi i64 [ %111, %108 ], [ %95, %94 ]
%115 = load i64, i64* @MS_MOVE
%116 = and i64 %115, %114
%117 = icmp eq i64 %116, 0
br i1 %117, label %122, label %118
118: ; preds = %112
%119 = tail call i32 @sc_string_append(i8* %0, i64 %1, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.12, i64 0, i64 0))
%120 = load i64, i64* @MS_MOVE
%121 = xor i64 %120, %114
br label %122
122: ; preds = %112, %118
%123 = phi i64 [ %121, %118 ], [ %114, %112 ]
%124 = load i64, i64* @MS_SILENT
%125 = and i64 %124, %123
%126 = icmp eq i64 %125, 0
br i1 %126, label %131, label %127
127: ; preds = %122
%128 = tail call i32 @sc_string_append(i8* %0, i64 %1, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.13, i64 0, i64 0))
%129 = load i64, i64* @MS_SILENT
%130 = xor i64 %129, %123
br label %131
131: ; preds = %122, %127
%132 = phi i64 [ %130, %127 ], [ %123, %122 ]
%133 = load i64, i64* @MS_POSIXACL
%134 = and i64 %133, %132
%135 = icmp eq i64 %134, 0
br i1 %135, label %140, label %136
136: ; preds = %131
%137 = tail call i32 @sc_string_append(i8* %0, i64 %1, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.14, i64 0, i64 0))
%138 = load i64, i64* @MS_POSIXACL
%139 = xor i64 %138, %132
br label %140
140: ; preds = %131, %136
%141 = phi i64 [ %139, %136 ], [ %132, %131 ]
%142 = load i64, i64* @MS_UNBINDABLE
%143 = and i64 %142, %141
%144 = icmp eq i64 %143, 0
br i1 %144, label %149, label %145
145: ; preds = %140
%146 = tail call i32 @sc_string_append(i8* %0, i64 %1, i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.15, i64 0, i64 0))
%147 = load i64, i64* @MS_UNBINDABLE
%148 = xor i64 %147, %141
br label %149
149: ; preds = %145, %140
%150 = phi i64 [ %148, %145 ], [ %141, %140 ]
%151 = load i64, i64* @MS_PRIVATE
%152 = and i64 %151, %150
%153 = icmp eq i64 %152, 0
br i1 %153, label %168, label %154
154: ; preds = %149
%155 = load i64, i64* @MS_REC
%156 = and i64 %155, %150
%157 = icmp eq i64 %156, 0
br i1 %157, label %162, label %158
158: ; preds = %154
%159 = tail call i32 @sc_string_append(i8* %0, i64 %1, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.16, i64 0, i64 0))
%160 = load i64, i64* @MS_REC
%161 = or i64 %160, %113
br label %164
162: ; preds = %154
%163 = tail call i32 @sc_string_append(i8* %0, i64 %1, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.17, i64 0, i64 0))
br label %164
164: ; preds = %162, %158
%165 = phi i64 [ %161, %158 ], [ %113, %162 ]
%166 = load i64, i64* @MS_PRIVATE
%167 = xor i64 %166, %150
br label %168
168: ; preds = %164, %149
%169 = phi i64 [ %165, %164 ], [ %113, %149 ]
%170 = phi i64 [ %167, %164 ], [ %150, %149 ]
%171 = load i64, i64* @MS_SLAVE
%172 = and i64 %171, %170
%173 = icmp eq i64 %172, 0
br i1 %173, label %188, label %174
174: ; preds = %168
%175 = load i64, i64* @MS_REC
%176 = and i64 %175, %170
%177 = icmp eq i64 %176, 0
br i1 %177, label %182, label %178
178: ; preds = %174
%179 = tail call i32 @sc_string_append(i8* %0, i64 %1, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.18, i64 0, i64 0))
%180 = load i64, i64* @MS_REC
%181 = or i64 %180, %169
br label %184
182: ; preds = %174
%183 = tail call i32 @sc_string_append(i8* %0, i64 %1, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.19, i64 0, i64 0))
br label %184
184: ; preds = %182, %178
%185 = phi i64 [ %181, %178 ], [ %169, %182 ]
%186 = load i64, i64* @MS_SLAVE
%187 = xor i64 %186, %170
br label %188
188: ; preds = %184, %168
%189 = phi i64 [ %185, %184 ], [ %169, %168 ]
%190 = phi i64 [ %187, %184 ], [ %170, %168 ]
%191 = load i64, i64* @MS_SHARED
%192 = and i64 %191, %190
%193 = icmp eq i64 %192, 0
br i1 %193, label %208, label %194
194: ; preds = %188
%195 = load i64, i64* @MS_REC
%196 = and i64 %195, %190
%197 = icmp eq i64 %196, 0
br i1 %197, label %202, label %198
198: ; preds = %194
%199 = tail call i32 @sc_string_append(i8* %0, i64 %1, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.20, i64 0, i64 0))
%200 = load i64, i64* @MS_REC
%201 = or i64 %200, %189
br label %204
202: ; preds = %194
%203 = tail call i32 @sc_string_append(i8* %0, i64 %1, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.21, i64 0, i64 0))
br label %204
204: ; preds = %202, %198
%205 = phi i64 [ %201, %198 ], [ %189, %202 ]
%206 = load i64, i64* @MS_SHARED
%207 = xor i64 %206, %190
br label %208
208: ; preds = %204, %188
%209 = phi i64 [ %205, %204 ], [ %189, %188 ]
%210 = phi i64 [ %207, %204 ], [ %190, %188 ]
%211 = xor i64 %210, %209
%212 = load i64, i64* @MS_RELATIME
%213 = and i64 %211, %212
%214 = icmp eq i64 %213, 0
br i1 %214, label %219, label %215
215: ; preds = %208
%216 = tail call i32 @sc_string_append(i8* %0, i64 %1, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.22, i64 0, i64 0))
%217 = load i64, i64* @MS_RELATIME
%218 = xor i64 %217, %211
br label %219
219: ; preds = %208, %215
%220 = phi i64 [ %218, %215 ], [ %211, %208 ]
%221 = load i64, i64* @MS_KERNMOUNT
%222 = and i64 %221, %220
%223 = icmp eq i64 %222, 0
br i1 %223, label %228, label %224
224: ; preds = %219
%225 = tail call i32 @sc_string_append(i8* %0, i64 %1, i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.23, i64 0, i64 0))
%226 = load i64, i64* @MS_KERNMOUNT
%227 = xor i64 %226, %220
br label %228
228: ; preds = %219, %224
%229 = phi i64 [ %227, %224 ], [ %220, %219 ]
%230 = load i64, i64* @MS_I_VERSION
%231 = and i64 %230, %229
%232 = icmp eq i64 %231, 0
br i1 %232, label %237, label %233
233: ; preds = %228
%234 = tail call i32 @sc_string_append(i8* %0, i64 %1, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.24, i64 0, i64 0))
%235 = load i64, i64* @MS_I_VERSION
%236 = xor i64 %235, %229
br label %237
237: ; preds = %228, %233
%238 = phi i64 [ %236, %233 ], [ %229, %228 ]
%239 = load i64, i64* @MS_STRICTATIME
%240 = and i64 %239, %238
%241 = icmp eq i64 %240, 0
br i1 %241, label %246, label %242
242: ; preds = %237
%243 = tail call i32 @sc_string_append(i8* %0, i64 %1, i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.25, i64 0, i64 0))
%244 = load i64, i64* @MS_STRICTATIME
%245 = xor i64 %244, %238
br label %246
246: ; preds = %237, %242
%247 = phi i64 [ %245, %242 ], [ %238, %237 ]
%248 = and i64 %247, 33554432
%249 = icmp eq i64 %248, 0
br i1 %249, label %253, label %250
250: ; preds = %246
%251 = tail call i32 @sc_string_append(i8* %0, i64 %1, i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.26, i64 0, i64 0))
%252 = xor i64 %247, 33554432
br label %253
253: ; preds = %246, %250
%254 = phi i64 [ %252, %250 ], [ %247, %246 ]
%255 = and i64 %254, 268435456
%256 = icmp eq i64 %255, 0
br i1 %256, label %260, label %257
257: ; preds = %253
%258 = tail call i32 @sc_string_append(i8* %0, i64 %1, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.27, i64 0, i64 0))
%259 = xor i64 %254, 268435456
br label %260
260: ; preds = %253, %257
%261 = phi i64 [ %259, %257 ], [ %254, %253 ]
%262 = and i64 %261, 536870912
%263 = icmp eq i64 %262, 0
br i1 %263, label %267, label %264
264: ; preds = %260
%265 = tail call i32 @sc_string_append(i8* %0, i64 %1, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.28, i64 0, i64 0))
%266 = xor i64 %261, 536870912
br label %267
267: ; preds = %260, %264
%268 = phi i64 [ %266, %264 ], [ %261, %260 ]
%269 = load i64, i64* @MS_ACTIVE
%270 = and i64 %269, %268
%271 = icmp eq i64 %270, 0
br i1 %271, label %276, label %272
272: ; preds = %267
%273 = tail call i32 @sc_string_append(i8* %0, i64 %1, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.29, i64 0, i64 0))
%274 = load i64, i64* @MS_ACTIVE
%275 = xor i64 %274, %268
br label %276
276: ; preds = %267, %272
%277 = phi i64 [ %275, %272 ], [ %268, %267 ]
%278 = load i64, i64* @MS_NOUSER
%279 = and i64 %278, %277
%280 = icmp eq i64 %279, 0
br i1 %280, label %285, label %281
281: ; preds = %276
%282 = tail call i32 @sc_string_append(i8* %0, i64 %1, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.30, i64 0, i64 0))
%283 = load i64, i64* @MS_NOUSER
%284 = xor i64 %283, %277
br label %285
285: ; preds = %281, %276
%286 = phi i64 [ %284, %281 ], [ %277, %276 ]
%287 = icmp eq i64 %286, 0
br i1 %287, label %292, label %288
288: ; preds = %285
%289 = getelementptr inbounds [128 x i8], [128 x i8]* %4, i64 0, i64 0
%290 = call i32 @sc_must_snprintf(i8* %289, i32 128, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.31, i64 0, i64 0), i64 %286)
%291 = call i32 @sc_string_append(i8* %0, i64 %1, i8* %289)
br label %292
292: ; preds = %288, %285
%293 = call i64 @strnlen(i8* %0, i64 %1)
%294 = icmp eq i64 %293, 0
br i1 %294, label %301, label %295
295: ; preds = %292
%296 = add i64 %293, -1
%297 = getelementptr inbounds i8, i8* %0, i64 %296
%298 = load i8, i8* %297
%299 = icmp eq i8 %298, 44
br i1 %299, label %300, label %301
300: ; preds = %295
store i8 0, i8* %297
br label %301
301: ; preds = %300, %295, %292
ret i8* %0
}