#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 */
int MS_BIND;
int MS_NODEV;
int MS_NOEXEC;
int MS_NOSUID;
int bind_mount(char *, char *);
int errno;
int /*<<< orphan*/ fprintf(int /*<<< orphan*/, char *, char *);
int /*<<< orphan*/ fputs(char const *, int /*<<< orphan*/);
scalar_t__ mkdir(char *, int);
scalar_t__ mount(char *, char *, char *, int, char *);
int /*<<< orphan*/ stderr;
char *strerror(int const);
scalar_t__ symlink(char *, char *);
int touch(char *);
int populate_root(void) {
  int ret;
  do {
    const int ON_ERROR_ret =
        (ret = (symlink("usr/bin", "bin")) < 0 ? -errno : 0);
    if (ON_ERROR_ret < 0) {
      const char *ON_ERROR_message = ("symlink(\"usr/bin\", \"bin\")");
      if (ON_ERROR_message) {
        fputs(ON_ERROR_message, stderr);
        fprintf(stderr, ": %s\n", strerror(-ON_ERROR_ret));
      }
      return ret;
    }
  } while (0);
  do {
    const int ON_ERROR_ret =
        (ret = (symlink("usr/bin", "sbin")) < 0 ? -errno : 0);
    if (ON_ERROR_ret < 0) {
      const char *ON_ERROR_message = ("symlink(\"usr/bin\", \"sbin\")");
      if (ON_ERROR_message) {
        fputs(ON_ERROR_message, stderr);
        fprintf(stderr, ": %s\n", strerror(-ON_ERROR_ret));
      }
      return ret;
    }
  } while (0);
  do {
    const int ON_ERROR_ret =
        (ret = (symlink("usr/lib", "lib")) < 0 ? -errno : 0);
    if (ON_ERROR_ret < 0) {
      const char *ON_ERROR_message = ("symlink(\"usr/lib\", \"lib\")");
      if (ON_ERROR_message) {
        fputs(ON_ERROR_message, stderr);
        fprintf(stderr, ": %s\n", strerror(-ON_ERROR_ret));
      }
      return ret;
    }
  } while (0);
  do {
    const int ON_ERROR_ret =
        (ret = (symlink("usr/lib", "lib64")) < 0 ? -errno : 0);
    if (ON_ERROR_ret < 0) {
      const char *ON_ERROR_message = ("symlink(\"usr/lib\", \"lib64\")");
      if (ON_ERROR_message) {
        fputs(ON_ERROR_message, stderr);
        fprintf(stderr, ": %s\n", strerror(-ON_ERROR_ret));
      }
      return ret;
    }
  } while (0);
  do {
    const int ON_ERROR_ret = (ret = (mkdir("dev", 0755)) < 0 ? -errno : 0);
    if (ON_ERROR_ret < 0) {
      const char *ON_ERROR_message = ("mkdir(\"dev\", 0755)");
      if (ON_ERROR_message) {
        fputs(ON_ERROR_message, stderr);
        fprintf(stderr, ": %s\n", strerror(-ON_ERROR_ret));
      }
      return ret;
    }
  } while (0);
  do {
    const int ON_ERROR_ret =
        (ret = (symlink("/proc/self/fd", "dev/fd")) < 0 ? -errno : 0);
    if (ON_ERROR_ret < 0) {
      const char *ON_ERROR_message = ("symlink(\"/proc/self/fd\", \"dev/fd\")");
      if (ON_ERROR_message) {
        fputs(ON_ERROR_message, stderr);
        fprintf(stderr, ": %s\n", strerror(-ON_ERROR_ret));
      }
      return ret;
    }
  } while (0);
  do {
    const int ON_ERROR_ret =
        (ret = (symlink("/proc/self/fd/0", "dev/stdin")) < 0 ? -errno : 0);
    if (ON_ERROR_ret < 0) {
      const char *ON_ERROR_message =
          ("symlink(\"/proc/self/fd/0\", \"dev/stdin\")");
      if (ON_ERROR_message) {
        fputs(ON_ERROR_message, stderr);
        fprintf(stderr, ": %s\n", strerror(-ON_ERROR_ret));
      }
      return ret;
    }
  } while (0);
  do {
    const int ON_ERROR_ret =
        (ret = (symlink("/proc/self/fd/1", "dev/stdout")) < 0 ? -errno : 0);
    if (ON_ERROR_ret < 0) {
      const char *ON_ERROR_message =
          ("symlink(\"/proc/self/fd/1\", \"dev/stdout\")");
      if (ON_ERROR_message) {
        fputs(ON_ERROR_message, stderr);
        fprintf(stderr, ": %s\n", strerror(-ON_ERROR_ret));
      }
      return ret;
    }
  } while (0);
  do {
    const int ON_ERROR_ret =
        (ret = (symlink("/proc/self/fd/2", "dev/stderr")) < 0 ? -errno : 0);
    if (ON_ERROR_ret < 0) {
      const char *ON_ERROR_message =
          ("symlink(\"/proc/self/fd/2\", \"dev/stderr\")");
      if (ON_ERROR_message) {
        fputs(ON_ERROR_message, stderr);
        fprintf(stderr, ": %s\n", strerror(-ON_ERROR_ret));
      }
      return ret;
    }
  } while (0);
  do {
    do {
      const int ON_ERROR_ret = (ret = touch("dev/null"));
      if (ON_ERROR_ret < 0) {
        const char *ON_ERROR_message = ("touch(\"dev/null\")");
        if (ON_ERROR_message) {
          fputs(ON_ERROR_message, stderr);
          fprintf(stderr, ": %s\n", strerror(-ON_ERROR_ret));
        }
        return ret;
      }
    } while (0);
    do {
      const int ON_ERROR_ret = (ret = bind_mount("/"
                                                 "dev/null",
                                                 "dev/null"));
      if (ON_ERROR_ret < 0) {
        const char *ON_ERROR_message =
            ("bind_mount(\"/\" \"dev/null\", \"dev/null\")");
        if (ON_ERROR_message) {
          fputs(ON_ERROR_message, stderr);
          fprintf(stderr, ": %s\n", strerror(-ON_ERROR_ret));
        }
        return ret;
      }
    } while (0);
  } while (0);
  do {
    do {
      const int ON_ERROR_ret = (ret = touch("dev/zero"));
      if (ON_ERROR_ret < 0) {
        const char *ON_ERROR_message = ("touch(\"dev/zero\")");
        if (ON_ERROR_message) {
          fputs(ON_ERROR_message, stderr);
          fprintf(stderr, ": %s\n", strerror(-ON_ERROR_ret));
        }
        return ret;
      }
    } while (0);
    do {
      const int ON_ERROR_ret = (ret = bind_mount("/"
                                                 "dev/zero",
                                                 "dev/zero"));
      if (ON_ERROR_ret < 0) {
        const char *ON_ERROR_message =
            ("bind_mount(\"/\" \"dev/zero\", \"dev/zero\")");
        if (ON_ERROR_message) {
          fputs(ON_ERROR_message, stderr);
          fprintf(stderr, ": %s\n", strerror(-ON_ERROR_ret));
        }
        return ret;
      }
    } while (0);
  } while (0);
  do {
    do {
      const int ON_ERROR_ret = (ret = touch("dev/full"));
      if (ON_ERROR_ret < 0) {
        const char *ON_ERROR_message = ("touch(\"dev/full\")");
        if (ON_ERROR_message) {
          fputs(ON_ERROR_message, stderr);
          fprintf(stderr, ": %s\n", strerror(-ON_ERROR_ret));
        }
        return ret;
      }
    } while (0);
    do {
      const int ON_ERROR_ret = (ret = bind_mount("/"
                                                 "dev/full",
                                                 "dev/full"));
      if (ON_ERROR_ret < 0) {
        const char *ON_ERROR_message =
            ("bind_mount(\"/\" \"dev/full\", \"dev/full\")");
        if (ON_ERROR_message) {
          fputs(ON_ERROR_message, stderr);
          fprintf(stderr, ": %s\n", strerror(-ON_ERROR_ret));
        }
        return ret;
      }
    } while (0);
  } while (0);
  do {
    do {
      const int ON_ERROR_ret = (ret = touch("dev/random"));
      if (ON_ERROR_ret < 0) {
        const char *ON_ERROR_message = ("touch(\"dev/random\")");
        if (ON_ERROR_message) {
          fputs(ON_ERROR_message, stderr);
          fprintf(stderr, ": %s\n", strerror(-ON_ERROR_ret));
        }
        return ret;
      }
    } while (0);
    do {
      const int ON_ERROR_ret = (ret = bind_mount("/"
                                                 "dev/random",
                                                 "dev/random"));
      if (ON_ERROR_ret < 0) {
        const char *ON_ERROR_message =
            ("bind_mount(\"/\" \"dev/random\", \"dev/random\")");
        if (ON_ERROR_message) {
          fputs(ON_ERROR_message, stderr);
          fprintf(stderr, ": %s\n", strerror(-ON_ERROR_ret));
        }
        return ret;
      }
    } while (0);
  } while (0);
  do {
    do {
      const int ON_ERROR_ret = (ret = touch("dev/urandom"));
      if (ON_ERROR_ret < 0) {
        const char *ON_ERROR_message = ("touch(\"dev/urandom\")");
        if (ON_ERROR_message) {
          fputs(ON_ERROR_message, stderr);
          fprintf(stderr, ": %s\n", strerror(-ON_ERROR_ret));
        }
        return ret;
      }
    } while (0);
    do {
      const int ON_ERROR_ret = (ret = bind_mount("/"
                                                 "dev/urandom",
                                                 "dev/urandom"));
      if (ON_ERROR_ret < 0) {
        const char *ON_ERROR_message =
            ("bind_mount(\"/\" \"dev/urandom\", \"dev/urandom\")");
        if (ON_ERROR_message) {
          fputs(ON_ERROR_message, stderr);
          fprintf(stderr, ": %s\n", strerror(-ON_ERROR_ret));
        }
        return ret;
      }
    } while (0);
  } while (0);
  do {
    const int ON_ERROR_ret = (ret = (mkdir("etc", 0755)) < 0 ? -errno : 0);
    if (ON_ERROR_ret < 0) {
      const char *ON_ERROR_message = ("mkdir(\"etc\", 0755)");
      if (ON_ERROR_message) {
        fputs(ON_ERROR_message, stderr);
        fprintf(stderr, ": %s\n", strerror(-ON_ERROR_ret));
      }
      return ret;
    }
  } while (0);
  do {
    const int ON_ERROR_ret =
        (ret = (symlink("../proc/self/mounts", "etc/mtab")) < 0 ? -errno : 0);
    if (ON_ERROR_ret < 0) {
      const char *ON_ERROR_message =
          ("symlink(\"../proc/self/mounts\", \"etc/mtab\")");
      if (ON_ERROR_message) {
        fputs(ON_ERROR_message, stderr);
        fprintf(stderr, ": %s\n", strerror(-ON_ERROR_ret));
      }
      return ret;
    }
  } while (0);
  do {
    const int ON_ERROR_ret = (ret = (mkdir("proc", 0755)) < 0 ? -errno : 0);
    if (ON_ERROR_ret < 0) {
      const char *ON_ERROR_message = ("mkdir(\"proc\", 0755)");
      if (ON_ERROR_message) {
        fputs(ON_ERROR_message, stderr);
        fprintf(stderr, ": %s\n", strerror(-ON_ERROR_ret));
      }
      return ret;
    }
  } while (0);
  do {
    const int ON_ERROR_ret =
        (ret = (mount("proc", "proc", "proc", MS_NOSUID | MS_NODEV | MS_NOEXEC,
                      NULL)) < 0
                   ? -errno
                   : 0);
    if (ON_ERROR_ret < 0) {
      const char *ON_ERROR_message =
          ("mount(\"proc\", \"proc\", \"proc\", MS_NOSUID | MS_NODEV | "
           "MS_NOEXEC, NULL)");
      if (ON_ERROR_message) {
        fputs(ON_ERROR_message, stderr);
        fprintf(stderr, ": %s\n", strerror(-ON_ERROR_ret));
      }
      return ret;
    }
  } while (0);
  do {
    const int ON_ERROR_ret = (ret = (mkdir("sys", 0755)) < 0 ? -errno : 0);
    if (ON_ERROR_ret < 0) {
      const char *ON_ERROR_message = ("mkdir(\"sys\", 0755)");
      if (ON_ERROR_message) {
        fputs(ON_ERROR_message, stderr);
        fprintf(stderr, ": %s\n", strerror(-ON_ERROR_ret));
      }
      return ret;
    }
  } while (0);
  do {
    const int ON_ERROR_ret = (ret = (mkdir("sys/fs", 0755)) < 0 ? -errno : 0);
    if (ON_ERROR_ret < 0) {
      const char *ON_ERROR_message = ("mkdir(\"sys/fs\", 0755)");
      if (ON_ERROR_message) {
        fputs(ON_ERROR_message, stderr);
        fprintf(stderr, ": %s\n", strerror(-ON_ERROR_ret));
      }
      return ret;
    }
  } while (0);
  do {
    const int ON_ERROR_ret =
        (ret = (mkdir("sys/fs/cgroup", 0755)) < 0 ? -errno : 0);
    if (ON_ERROR_ret < 0) {
      const char *ON_ERROR_message = ("mkdir(\"sys/fs/cgroup\", 0755)");
      if (ON_ERROR_message) {
        fputs(ON_ERROR_message, stderr);
        fprintf(stderr, ": %s\n", strerror(-ON_ERROR_ret));
      }
      return ret;
    }
  } while (0);
  do {
    const int ON_ERROR_ret =
        (ret = (mount("tmpfs", "sys/fs/cgroup", "tmpfs",
                      MS_NOSUID | MS_NODEV | MS_NOEXEC, "mode=755")) < 0
                   ? -errno
                   : 0);
    if (ON_ERROR_ret < 0) {
      const char *ON_ERROR_message =
          ("mount(\"tmpfs\", \"sys/fs/cgroup\", \"tmpfs\", MS_NOSUID | "
           "MS_NODEV | MS_NOEXEC, \"mode=755\")");
      if (ON_ERROR_message) {
        fputs(ON_ERROR_message, stderr);
        fprintf(stderr, ": %s\n", strerror(-ON_ERROR_ret));
      }
      return ret;
    }
  } while (0);
  do {
    const int ON_ERROR_ret =
        (ret = (mkdir("sys/fs/cgroup/unified", 0755)) < 0 ? -errno : 0);
    if (ON_ERROR_ret < 0) {
      const char *ON_ERROR_message = ("mkdir(\"sys/fs/cgroup/unified\", 0755)");
      if (ON_ERROR_message) {
        fputs(ON_ERROR_message, stderr);
        fprintf(stderr, ": %s\n", strerror(-ON_ERROR_ret));
      }
      return ret;
    }
  } while (0);
  do {
    const int ON_ERROR_ret =
        (ret = (mount("cgroup", "sys/fs/cgroup/unified", "cgroup2",
                      MS_NOSUID | MS_NODEV | MS_NOEXEC, NULL)) < 0
                   ? -errno
                   : 0);
    if (ON_ERROR_ret < 0) {
      const char *ON_ERROR_message =
          ("mount(\"cgroup\", \"sys/fs/cgroup/unified\", \"cgroup2\", "
           "MS_NOSUID | MS_NODEV | MS_NOEXEC, NULL)");
      if (ON_ERROR_message) {
        fputs(ON_ERROR_message, stderr);
        fprintf(stderr, ": %s\n", strerror(-ON_ERROR_ret));
      }
      return ret;
    }
  } while (0);
  do {
    do {
      const int ON_ERROR_ret = (ret = (mkdir("sys/fs/cgroup/"
                                             "freezer",
                                             0755)) < 0
                                          ? -errno
                                          : 0);
      if (ON_ERROR_ret < 0) {
        const char *ON_ERROR_message =
            ("mkdir(\"sys/fs/cgroup/\" \"freezer\", 0755)");
        if (ON_ERROR_message) {
          fputs(ON_ERROR_message, stderr);
          fprintf(stderr, ": %s\n", strerror(-ON_ERROR_ret));
        }
        return ret;
      }
    } while (0);
    do {
      const int ON_ERROR_ret =
          (ret = (mount("cgroup",
                        "sys/fs/cgroup/"
                        "freezer",
                        "cgroup", MS_NOSUID | MS_NODEV | MS_NOEXEC,
                        "freezer")) < 0
                     ? -errno
                     : 0);
      if (ON_ERROR_ret < 0) {
        const char *ON_ERROR_message =
            ("mount(\"cgroup\", \"sys/fs/cgroup/\" \"freezer\", \"cgroup\", "
             "MS_NOSUID | MS_NODEV | MS_NOEXEC, \"freezer\")");
        if (ON_ERROR_message) {
          fputs(ON_ERROR_message, stderr);
          fprintf(stderr, ": %s\n", strerror(-ON_ERROR_ret));
        }
        return ret;
      }
    } while (0);
  } while (0);
  do {
    do {
      const int ON_ERROR_ret = (ret = (mkdir("sys/fs/cgroup/"
                                             "cpu,cpuacct",
                                             0755)) < 0
                                          ? -errno
                                          : 0);
      if (ON_ERROR_ret < 0) {
        const char *ON_ERROR_message =
            ("mkdir(\"sys/fs/cgroup/\" \"cpu,cpuacct\", 0755)");
        if (ON_ERROR_message) {
          fputs(ON_ERROR_message, stderr);
          fprintf(stderr, ": %s\n", strerror(-ON_ERROR_ret));
        }
        return ret;
      }
    } while (0);
    do {
      const int ON_ERROR_ret =
          (ret = (mount("cgroup",
                        "sys/fs/cgroup/"
                        "cpu,cpuacct",
                        "cgroup", MS_NOSUID | MS_NODEV | MS_NOEXEC,
                        "cpu,cpuacct")) < 0
                     ? -errno
                     : 0);
      if (ON_ERROR_ret < 0) {
        const char *ON_ERROR_message =
            ("mount(\"cgroup\", \"sys/fs/cgroup/\" \"cpu,cpuacct\", "
             "\"cgroup\", MS_NOSUID | MS_NODEV | MS_NOEXEC, \"cpu,cpuacct\")");
        if (ON_ERROR_message) {
          fputs(ON_ERROR_message, stderr);
          fprintf(stderr, ": %s\n", strerror(-ON_ERROR_ret));
        }
        return ret;
      }
    } while (0);
  } while (0);
  do {
    do {
      const int ON_ERROR_ret = (ret = (mkdir("sys/fs/cgroup/"
                                             "cpuset",
                                             0755)) < 0
                                          ? -errno
                                          : 0);
      if (ON_ERROR_ret < 0) {
        const char *ON_ERROR_message =
            ("mkdir(\"sys/fs/cgroup/\" \"cpuset\", 0755)");
        if (ON_ERROR_message) {
          fputs(ON_ERROR_message, stderr);
          fprintf(stderr, ": %s\n", strerror(-ON_ERROR_ret));
        }
        return ret;
      }
    } while (0);
    do {
      const int ON_ERROR_ret =
          (ret =
               (mount("cgroup",
                      "sys/fs/cgroup/"
                      "cpuset",
                      "cgroup", MS_NOSUID | MS_NODEV | MS_NOEXEC, "cpuset")) < 0
                   ? -errno
                   : 0);
      if (ON_ERROR_ret < 0) {
        const char *ON_ERROR_message =
            ("mount(\"cgroup\", \"sys/fs/cgroup/\" \"cpuset\", \"cgroup\", "
             "MS_NOSUID | MS_NODEV | MS_NOEXEC, \"cpuset\")");
        if (ON_ERROR_message) {
          fputs(ON_ERROR_message, stderr);
          fprintf(stderr, ": %s\n", strerror(-ON_ERROR_ret));
        }
        return ret;
      }
    } while (0);
  } while (0);
  do {
    do {
      const int ON_ERROR_ret = (ret = (mkdir("sys/fs/cgroup/"
                                             "net_cls,net_prio",
                                             0755)) < 0
                                          ? -errno
                                          : 0);
      if (ON_ERROR_ret < 0) {
        const char *ON_ERROR_message =
            ("mkdir(\"sys/fs/cgroup/\" \"net_cls,net_prio\", 0755)");
        if (ON_ERROR_message) {
          fputs(ON_ERROR_message, stderr);
          fprintf(stderr, ": %s\n", strerror(-ON_ERROR_ret));
        }
        return ret;
      }
    } while (0);
    do {
      const int ON_ERROR_ret =
          (ret = (mount("cgroup",
                        "sys/fs/cgroup/"
                        "net_cls,net_prio",
                        "cgroup", MS_NOSUID | MS_NODEV | MS_NOEXEC,
                        "net_cls,net_prio")) < 0
                     ? -errno
                     : 0);
      if (ON_ERROR_ret < 0) {
        const char *ON_ERROR_message =
            ("mount(\"cgroup\", \"sys/fs/cgroup/\" \"net_cls,net_prio\", "
             "\"cgroup\", MS_NOSUID | MS_NODEV | MS_NOEXEC, "
             "\"net_cls,net_prio\")");
        if (ON_ERROR_message) {
          fputs(ON_ERROR_message, stderr);
          fprintf(stderr, ": %s\n", strerror(-ON_ERROR_ret));
        }
        return ret;
      }
    } while (0);
  } while (0);
  do {
    do {
      const int ON_ERROR_ret = (ret = (mkdir("sys/fs/cgroup/"
                                             "pids",
                                             0755)) < 0
                                          ? -errno
                                          : 0);
      if (ON_ERROR_ret < 0) {
        const char *ON_ERROR_message =
            ("mkdir(\"sys/fs/cgroup/\" \"pids\", 0755)");
        if (ON_ERROR_message) {
          fputs(ON_ERROR_message, stderr);
          fprintf(stderr, ": %s\n", strerror(-ON_ERROR_ret));
        }
        return ret;
      }
    } while (0);
    do {
      const int ON_ERROR_ret =
          (ret = (mount("cgroup",
                        "sys/fs/cgroup/"
                        "pids",
                        "cgroup", MS_NOSUID | MS_NODEV | MS_NOEXEC, "pids")) < 0
                     ? -errno
                     : 0);
      if (ON_ERROR_ret < 0) {
        const char *ON_ERROR_message =
            ("mount(\"cgroup\", \"sys/fs/cgroup/\" \"pids\", \"cgroup\", "
             "MS_NOSUID | MS_NODEV | MS_NOEXEC, \"pids\")");
        if (ON_ERROR_message) {
          fputs(ON_ERROR_message, stderr);
          fprintf(stderr, ": %s\n", strerror(-ON_ERROR_ret));
        }
        return ret;
      }
    } while (0);
  } while (0);
  do {
    do {
      const int ON_ERROR_ret = (ret = (mkdir("sys/fs/cgroup/"
                                             "blkio",
                                             0755)) < 0
                                          ? -errno
                                          : 0);
      if (ON_ERROR_ret < 0) {
        const char *ON_ERROR_message =
            ("mkdir(\"sys/fs/cgroup/\" \"blkio\", 0755)");
        if (ON_ERROR_message) {
          fputs(ON_ERROR_message, stderr);
          fprintf(stderr, ": %s\n", strerror(-ON_ERROR_ret));
        }
        return ret;
      }
    } while (0);
    do {
      const int ON_ERROR_ret =
          (ret =
               (mount("cgroup",
                      "sys/fs/cgroup/"
                      "blkio",
                      "cgroup", MS_NOSUID | MS_NODEV | MS_NOEXEC, "blkio")) < 0
                   ? -errno
                   : 0);
      if (ON_ERROR_ret < 0) {
        const char *ON_ERROR_message =
            ("mount(\"cgroup\", \"sys/fs/cgroup/\" \"blkio\", \"cgroup\", "
             "MS_NOSUID | MS_NODEV | MS_NOEXEC, \"blkio\")");
        if (ON_ERROR_message) {
          fputs(ON_ERROR_message, stderr);
          fprintf(stderr, ": %s\n", strerror(-ON_ERROR_ret));
        }
        return ret;
      }
    } while (0);
  } while (0);
  do {
    do {
      const int ON_ERROR_ret = (ret = (mkdir("sys/fs/cgroup/"
                                             "devices",
                                             0755)) < 0
                                          ? -errno
                                          : 0);
      if (ON_ERROR_ret < 0) {
        const char *ON_ERROR_message =
            ("mkdir(\"sys/fs/cgroup/\" \"devices\", 0755)");
        if (ON_ERROR_message) {
          fputs(ON_ERROR_message, stderr);
          fprintf(stderr, ": %s\n", strerror(-ON_ERROR_ret));
        }
        return ret;
      }
    } while (0);
    do {
      const int ON_ERROR_ret =
          (ret = (mount("cgroup",
                        "sys/fs/cgroup/"
                        "devices",
                        "cgroup", MS_NOSUID | MS_NODEV | MS_NOEXEC,
                        "devices")) < 0
                     ? -errno
                     : 0);
      if (ON_ERROR_ret < 0) {
        const char *ON_ERROR_message =
            ("mount(\"cgroup\", \"sys/fs/cgroup/\" \"devices\", \"cgroup\", "
             "MS_NOSUID | MS_NODEV | MS_NOEXEC, \"devices\")");
        if (ON_ERROR_message) {
          fputs(ON_ERROR_message, stderr);
          fprintf(stderr, ": %s\n", strerror(-ON_ERROR_ret));
        }
        return ret;
      }
    } while (0);
  } while (0);
  do {
    do {
      const int ON_ERROR_ret = (ret = (mkdir("sys/fs/cgroup/"
                                             "memory",
                                             0755)) < 0
                                          ? -errno
                                          : 0);
      if (ON_ERROR_ret < 0) {
        const char *ON_ERROR_message =
            ("mkdir(\"sys/fs/cgroup/\" \"memory\", 0755)");
        if (ON_ERROR_message) {
          fputs(ON_ERROR_message, stderr);
          fprintf(stderr, ": %s\n", strerror(-ON_ERROR_ret));
        }
        return ret;
      }
    } while (0);
    do {
      const int ON_ERROR_ret =
          (ret =
               (mount("cgroup",
                      "sys/fs/cgroup/"
                      "memory",
                      "cgroup", MS_NOSUID | MS_NODEV | MS_NOEXEC, "memory")) < 0
                   ? -errno
                   : 0);
      if (ON_ERROR_ret < 0) {
        const char *ON_ERROR_message =
            ("mount(\"cgroup\", \"sys/fs/cgroup/\" \"memory\", \"cgroup\", "
             "MS_NOSUID | MS_NODEV | MS_NOEXEC, \"memory\")");
        if (ON_ERROR_message) {
          fputs(ON_ERROR_message, stderr);
          fprintf(stderr, ": %s\n", strerror(-ON_ERROR_ret));
        }
        return ret;
      }
    } while (0);
  } while (0);
  do {
    const int ON_ERROR_ret =
        (ret = (symlink("cpu,cpuacct", "sys/fs/cgroup/cpu")) < 0 ? -errno : 0);
    if (ON_ERROR_ret < 0) {
      const char *ON_ERROR_message =
          ("symlink(\"cpu,cpuacct\", \"sys/fs/cgroup/cpu\")");
      if (ON_ERROR_message) {
        fputs(ON_ERROR_message, stderr);
        fprintf(stderr, ": %s\n", strerror(-ON_ERROR_ret));
      }
      return ret;
    }
  } while (0);
  do {
    const int ON_ERROR_ret =
        (ret = (symlink("cpu,cpuacct", "sys/fs/cgroup/cpuacct")) < 0 ? -errno
                                                                     : 0);
    if (ON_ERROR_ret < 0) {
      const char *ON_ERROR_message =
          ("symlink(\"cpu,cpuacct\", \"sys/fs/cgroup/cpuacct\")");
      if (ON_ERROR_message) {
        fputs(ON_ERROR_message, stderr);
        fprintf(stderr, ": %s\n", strerror(-ON_ERROR_ret));
      }
      return ret;
    }
  } while (0);
  do {
    const int ON_ERROR_ret =
        (ret = (symlink("net_cls,net_prio", "sys/fs/cgroup/net_cls")) < 0
                   ? -errno
                   : 0);
    if (ON_ERROR_ret < 0) {
      const char *ON_ERROR_message =
          ("symlink(\"net_cls,net_prio\", \"sys/fs/cgroup/net_cls\")");
      if (ON_ERROR_message) {
        fputs(ON_ERROR_message, stderr);
        fprintf(stderr, ": %s\n", strerror(-ON_ERROR_ret));
      }
      return ret;
    }
  } while (0);
  do {
    const int ON_ERROR_ret =
        (ret = (symlink("net_cls,net_prio", "sys/fs/cgroup/net_prio")) < 0
                   ? -errno
                   : 0);
    if (ON_ERROR_ret < 0) {
      const char *ON_ERROR_message =
          ("symlink(\"net_cls,net_prio\", \"sys/fs/cgroup/net_prio\")");
      if (ON_ERROR_message) {
        fputs(ON_ERROR_message, stderr);
        fprintf(stderr, ": %s\n", strerror(-ON_ERROR_ret));
      }
      return ret;
    }
  } while (0);
  do {
    const int ON_ERROR_ret = (ret = (mkdir("usr", 0755)) < 0 ? -errno : 0);
    if (ON_ERROR_ret < 0) {
      const char *ON_ERROR_message = ("mkdir(\"usr\", 0755)");
      if (ON_ERROR_message) {
        fputs(ON_ERROR_message, stderr);
        fprintf(stderr, ": %s\n", strerror(-ON_ERROR_ret));
      }
      return ret;
    }
  } while (0);
  do {
    const int ON_ERROR_ret =
        (ret = (mount("/usr", "usr", NULL, MS_BIND, NULL)) < 0 ? -errno : 0);
    if (ON_ERROR_ret < 0) {
      const char *ON_ERROR_message =
          ("mount(\"/usr\", \"usr\", NULL, MS_BIND, NULL)");
      if (ON_ERROR_message) {
        fputs(ON_ERROR_message, stderr);
        fprintf(stderr, ": %s\n", strerror(-ON_ERROR_ret));
      }
      return ret;
    }
  } while (0);
  do {
    const int ON_ERROR_ret = (ret = (mkdir("tmp", 01777)) < 0 ? -errno : 0);
    if (ON_ERROR_ret < 0) {
      const char *ON_ERROR_message = ("mkdir(\"tmp\", 01777)");
      if (ON_ERROR_message) {
        fputs(ON_ERROR_message, stderr);
        fprintf(stderr, ": %s\n", strerror(-ON_ERROR_ret));
      }
      return ret;
    }
  } while (0);
  do {
    const int ON_ERROR_ret = (ret = (mount("tmpfs", "tmp", "tmpfs",
                                           MS_NOSUID | MS_NODEV, "size=1g")) < 0
                                        ? -errno
                                        : 0);
    if (ON_ERROR_ret < 0) {
      const char *ON_ERROR_message = ("mount(\"tmpfs\", \"tmp\", \"tmpfs\", "
                                      "MS_NOSUID | MS_NODEV, \"size=1g\")");
      if (ON_ERROR_message) {
        fputs(ON_ERROR_message, stderr);
        fprintf(stderr, ": %s\n", strerror(-ON_ERROR_ret));
      }
      return ret;
    }
  } while (0);
  return ret;
}


x86 assembly (clang, -O0):
<populate_root>:
push   %rbp
mov    %rsp,%rbp
sub    $0x4e0,%rsp
lea    0x2e6e(%rip),%rdi
lea    0x2e6b(%rip),%rsi
call   1070 <symlink@plt>
cmp    $0x0,%rax
jge    11be <populate_root+0x3e>
xor    %eax,%eax
mov    0x4e0f(%rip),%rcx
sub    (%rcx),%eax
mov    %eax,-0x35c(%rbp)
jmp    11cb <populate_root+0x4b>
xor    %eax,%eax
mov    %eax,-0x35c(%rbp)
jmp    11cb <populate_root+0x4b>
mov    -0x35c(%rbp),%eax
mov    %eax,-0x8(%rbp)
mov    %eax,-0xc(%rbp)
cmpl   $0x0,-0xc(%rbp)
jge    1242 <populate_root+0xc2>
lea    0x2e20(%rip),%rax
mov    %rax,-0x18(%rbp)
cmpq   $0x0,-0x18(%rbp)
je     1237 <populate_root+0xb7>
mov    -0x18(%rbp),%rdi
mov    0x4dc6(%rip),%rax
mov    (%rax),%esi
call   1080 <fputs@plt>
mov    0x4db8(%rip),%rax
mov    (%rax),%eax
mov    %eax,-0x360(%rbp)
xor    %edi,%edi
sub    -0xc(%rbp),%edi
call   10a0 <strerror@plt>
mov    -0x360(%rbp),%edi
mov    %rax,%rdx
lea    0x2df0(%rip),%rsi
call   1090 <fprintf@plt>
mov    -0x8(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    3cb3 <populate_root+0x2b33>
jmp    1247 <populate_root+0xc7>
jmp    124c <populate_root+0xcc>
lea    0x2dad(%rip),%rdi
lea    0x2dce(%rip),%rsi
call   1070 <symlink@plt>
cmp    $0x0,%rax
jge    127f <populate_root+0xff>
xor    %eax,%eax
mov    0x4d4e(%rip),%rcx
sub    (%rcx),%eax
mov    %eax,-0x364(%rbp)
jmp    128c <populate_root+0x10c>
xor    %eax,%eax
mov    %eax,-0x364(%rbp)
jmp    128c <populate_root+0x10c>
mov    -0x364(%rbp),%eax
mov    %eax,-0x8(%rbp)
mov    %eax,-0x1c(%rbp)
cmpl   $0x0,-0x1c(%rbp)
jge    1303 <populate_root+0x183>
lea    0x2d84(%rip),%rax
mov    %rax,-0x28(%rbp)
cmpq   $0x0,-0x28(%rbp)
je     12f8 <populate_root+0x178>
mov    -0x28(%rbp),%rdi
mov    0x4d05(%rip),%rax
mov    (%rax),%esi
call   1080 <fputs@plt>
mov    0x4cf7(%rip),%rax
mov    (%rax),%eax
mov    %eax,-0x368(%rbp)
xor    %edi,%edi
sub    -0x1c(%rbp),%edi
call   10a0 <strerror@plt>
mov    -0x368(%rbp),%edi
mov    %rax,%rdx
lea    0x2d2f(%rip),%rsi
call   1090 <fprintf@plt>
mov    -0x8(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    3cb3 <populate_root+0x2b33>
jmp    1308 <populate_root+0x188>
jmp    130d <populate_root+0x18d>
lea    0x2d34(%rip),%rdi
lea    0x2d31(%rip),%rsi
call   1070 <symlink@plt>
cmp    $0x0,%rax
jge    1340 <populate_root+0x1c0>
xor    %eax,%eax
mov    0x4c8d(%rip),%rcx
sub    (%rcx),%eax
mov    %eax,-0x36c(%rbp)
jmp    134d <populate_root+0x1cd>
xor    %eax,%eax
mov    %eax,-0x36c(%rbp)
jmp    134d <populate_root+0x1cd>
mov    -0x36c(%rbp),%eax
mov    %eax,-0x8(%rbp)
mov    %eax,-0x2c(%rbp)
cmpl   $0x0,-0x2c(%rbp)
jge    13c4 <populate_root+0x244>
lea    0x2ce6(%rip),%rax
mov    %rax,-0x38(%rbp)
cmpq   $0x0,-0x38(%rbp)
je     13b9 <populate_root+0x239>
mov    -0x38(%rbp),%rdi
mov    0x4c44(%rip),%rax
mov    (%rax),%esi
call   1080 <fputs@plt>
mov    0x4c36(%rip),%rax
mov    (%rax),%eax
mov    %eax,-0x370(%rbp)
xor    %edi,%edi
sub    -0x2c(%rbp),%edi
call   10a0 <strerror@plt>
mov    -0x370(%rbp),%edi
mov    %rax,%rdx
lea    0x2c6e(%rip),%rsi
call   1090 <fprintf@plt>
mov    -0x8(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    3cb3 <populate_root+0x2b33>
jmp    13c9 <populate_root+0x249>
jmp    13ce <populate_root+0x24e>
lea    0x2c73(%rip),%rdi
lea    0x2c8e(%rip),%rsi
call   1070 <symlink@plt>
cmp    $0x0,%rax
jge    1401 <populate_root+0x281>
xor    %eax,%eax
mov    0x4bcc(%rip),%rcx
sub    (%rcx),%eax
mov    %eax,-0x374(%rbp)
jmp    140e <populate_root+0x28e>
xor    %eax,%eax
mov    %eax,-0x374(%rbp)
jmp    140e <populate_root+0x28e>
mov    -0x374(%rbp),%eax
mov    %eax,-0x8(%rbp)
mov    %eax,-0x3c(%rbp)
cmpl   $0x0,-0x3c(%rbp)
jge    1485 <populate_root+0x305>
lea    0x2c45(%rip),%rax
mov    %rax,-0x48(%rbp)
cmpq   $0x0,-0x48(%rbp)
je     147a <populate_root+0x2fa>
mov    -0x48(%rbp),%rdi
mov    0x4b83(%rip),%rax
mov    (%rax),%esi
call   1080 <fputs@plt>
mov    0x4b75(%rip),%rax
mov    (%rax),%eax
mov    %eax,-0x378(%rbp)
xor    %edi,%edi
sub    -0x3c(%rbp),%edi
call   10a0 <strerror@plt>
mov    -0x378(%rbp),%edi
mov    %rax,%rdx
lea    0x2bad(%rip),%rsi
call   1090 <fprintf@plt>
mov    -0x8(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    3cb3 <populate_root+0x2b33>
jmp    148a <populate_root+0x30a>
jmp    148f <populate_root+0x30f>
lea    0x2bf6(%rip),%rdi
mov    $0x1ed,%esi
call   1040 <mkdir@plt>
cmp    $0x0,%rax
jge    14c0 <populate_root+0x340>
xor    %eax,%eax
mov    0x4b0d(%rip),%rcx
sub    (%rcx),%eax
mov    %eax,-0x37c(%rbp)
jmp    14cd <populate_root+0x34d>
xor    %eax,%eax
mov    %eax,-0x37c(%rbp)
jmp    14cd <populate_root+0x34d>
mov    -0x37c(%rbp),%eax
mov    %eax,-0x8(%rbp)
mov    %eax,-0x4c(%rbp)
cmpl   $0x0,-0x4c(%rbp)
jge    1544 <populate_root+0x3c4>
lea    0x2ba6(%rip),%rax
mov    %rax,-0x58(%rbp)
cmpq   $0x0,-0x58(%rbp)
je     1539 <populate_root+0x3b9>
mov    -0x58(%rbp),%rdi
mov    0x4ac4(%rip),%rax
mov    (%rax),%esi
call   1080 <fputs@plt>
mov    0x4ab6(%rip),%rax
mov    (%rax),%eax
mov    %eax,-0x380(%rbp)
xor    %edi,%edi
sub    -0x4c(%rbp),%edi
call   10a0 <strerror@plt>
mov    -0x380(%rbp),%edi
mov    %rax,%rdx
lea    0x2aee(%rip),%rsi
call   1090 <fprintf@plt>
mov    -0x8(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    3cb3 <populate_root+0x2b33>
jmp    1549 <populate_root+0x3c9>
jmp    154e <populate_root+0x3ce>
lea    0x2b4e(%rip),%rdi
lea    0x2b55(%rip),%rsi
call   1070 <symlink@plt>
cmp    $0x0,%rax
jge    1581 <populate_root+0x401>
xor    %eax,%eax
mov    0x4a4c(%rip),%rcx
sub    (%rcx),%eax
mov    %eax,-0x384(%rbp)
jmp    158e <populate_root+0x40e>
xor    %eax,%eax
mov    %eax,-0x384(%rbp)
jmp    158e <populate_root+0x40e>
mov    -0x384(%rbp),%eax
mov    %eax,-0x8(%rbp)
mov    %eax,-0x5c(%rbp)
cmpl   $0x0,-0x5c(%rbp)
jge    1605 <populate_root+0x485>
lea    0x2b0d(%rip),%rax
mov    %rax,-0x68(%rbp)
cmpq   $0x0,-0x68(%rbp)
je     15fa <populate_root+0x47a>
mov    -0x68(%rbp),%rdi
mov    0x4a03(%rip),%rax
mov    (%rax),%esi
call   1080 <fputs@plt>
mov    0x49f5(%rip),%rax
mov    (%rax),%eax
mov    %eax,-0x388(%rbp)
xor    %edi,%edi
sub    -0x5c(%rbp),%edi
call   10a0 <strerror@plt>
mov    -0x388(%rbp),%edi
mov    %rax,%rdx
lea    0x2a2d(%rip),%rsi
call   1090 <fprintf@plt>
mov    -0x8(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    3cb3 <populate_root+0x2b33>
jmp    160a <populate_root+0x48a>
jmp    160f <populate_root+0x48f>
lea    0x2ac5(%rip),%rdi
lea    0x2ace(%rip),%rsi
call   1070 <symlink@plt>
cmp    $0x0,%rax
jge    1642 <populate_root+0x4c2>
xor    %eax,%eax
mov    0x498b(%rip),%rcx
sub    (%rcx),%eax
mov    %eax,-0x38c(%rbp)
jmp    164f <populate_root+0x4cf>
xor    %eax,%eax
mov    %eax,-0x38c(%rbp)
jmp    164f <populate_root+0x4cf>
mov    -0x38c(%rbp),%eax
mov    %eax,-0x8(%rbp)
mov    %eax,-0x6c(%rbp)
cmpl   $0x0,-0x6c(%rbp)
jge    16c6 <populate_root+0x546>
lea    0x2a89(%rip),%rax
mov    %rax,-0x78(%rbp)
cmpq   $0x0,-0x78(%rbp)
je     16bb <populate_root+0x53b>
mov    -0x78(%rbp),%rdi
mov    0x4942(%rip),%rax
mov    (%rax),%esi
call   1080 <fputs@plt>
mov    0x4934(%rip),%rax
mov    (%rax),%eax
mov    %eax,-0x390(%rbp)
xor    %edi,%edi
sub    -0x6c(%rbp),%edi
call   10a0 <strerror@plt>
mov    -0x390(%rbp),%edi
mov    %rax,%rdx
lea    0x296c(%rip),%rsi
call   1090 <fprintf@plt>
mov    -0x8(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    3cb3 <populate_root+0x2b33>
jmp    16cb <populate_root+0x54b>
jmp    16d0 <populate_root+0x550>
lea    0x2a46(%rip),%rdi
lea    0x2a4f(%rip),%rsi
call   1070 <symlink@plt>
cmp    $0x0,%rax
jge    1703 <populate_root+0x583>
xor    %eax,%eax
mov    0x48ca(%rip),%rcx
sub    (%rcx),%eax
mov    %eax,-0x394(%rbp)
jmp    1710 <populate_root+0x590>
xor    %eax,%eax
mov    %eax,-0x394(%rbp)
jmp    1710 <populate_root+0x590>
mov    -0x394(%rbp),%eax
mov    %eax,-0x8(%rbp)
mov    %eax,-0x7c(%rbp)
cmpl   $0x0,-0x7c(%rbp)
jge    1790 <populate_root+0x610>
lea    0x2a0b(%rip),%rax
mov    %rax,-0x88(%rbp)
cmpq   $0x0,-0x88(%rbp)
je     1785 <populate_root+0x605>
mov    -0x88(%rbp),%rdi
mov    0x4878(%rip),%rax
mov    (%rax),%esi
call   1080 <fputs@plt>
mov    0x486a(%rip),%rax
mov    (%rax),%eax
mov    %eax,-0x398(%rbp)
xor    %edi,%edi
sub    -0x7c(%rbp),%edi
call   10a0 <strerror@plt>
mov    -0x398(%rbp),%edi
mov    %rax,%rdx
lea    0x28a2(%rip),%rsi
call   1090 <fprintf@plt>
mov    -0x8(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    3cb3 <populate_root+0x2b33>
jmp    1795 <populate_root+0x615>
jmp    179a <populate_root+0x61a>
lea    0x29c0(%rip),%rdi
lea    0x29c9(%rip),%rsi
call   1070 <symlink@plt>
cmp    $0x0,%rax
jge    17cd <populate_root+0x64d>
xor    %eax,%eax
mov    0x4800(%rip),%rcx
sub    (%rcx),%eax
mov    %eax,-0x39c(%rbp)
jmp    17da <populate_root+0x65a>
xor    %eax,%eax
mov    %eax,-0x39c(%rbp)
jmp    17da <populate_root+0x65a>
mov    -0x39c(%rbp),%eax
mov    %eax,-0x8(%rbp)
mov    %eax,-0x8c(%rbp)
cmpl   $0x0,-0x8c(%rbp)
jge    1863 <populate_root+0x6e3>
lea    0x297f(%rip),%rax
mov    %rax,-0x98(%rbp)
cmpq   $0x0,-0x98(%rbp)
je     1858 <populate_root+0x6d8>
mov    -0x98(%rbp),%rdi
mov    0x47a8(%rip),%rax
mov    (%rax),%esi
call   1080 <fputs@plt>
mov    0x479a(%rip),%rax
mov    (%rax),%eax
mov    %eax,-0x3a0(%rbp)
xor    %edi,%edi
sub    -0x8c(%rbp),%edi
call   10a0 <strerror@plt>
mov    -0x3a0(%rbp),%edi
mov    %rax,%rdx
lea    0x27cf(%rip),%rsi
call   1090 <fprintf@plt>
mov    -0x8(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    3cb3 <populate_root+0x2b33>
jmp    1868 <populate_root+0x6e8>
jmp    186d <populate_root+0x6ed>
jmp    1872 <populate_root+0x6f2>
lea    0x293f(%rip),%rdi
call   1030 <touch@plt>
mov    %eax,-0x8(%rbp)
mov    %eax,-0x9c(%rbp)
cmpl   $0x0,-0x9c(%rbp)
jge    1901 <populate_root+0x781>
lea    0x290a(%rip),%rax
mov    %rax,-0xa8(%rbp)
cmpq   $0x0,-0xa8(%rbp)
je     18f6 <populate_root+0x776>
mov    -0xa8(%rbp),%rdi
mov    0x470a(%rip),%rax
mov    (%rax),%esi
call   1080 <fputs@plt>
mov    0x46fc(%rip),%rax
mov    (%rax),%eax
mov    %eax,-0x3a4(%rbp)
xor    %edi,%edi
sub    -0x9c(%rbp),%edi
call   10a0 <strerror@plt>
mov    -0x3a4(%rbp),%edi
mov    %rax,%rdx
lea    0x2731(%rip),%rsi
call   1090 <fprintf@plt>
mov    -0x8(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    3cb3 <populate_root+0x2b33>
jmp    1906 <populate_root+0x786>
jmp    190b <populate_root+0x78b>
lea    0x28a5(%rip),%rdi
lea    0x289f(%rip),%rsi
call   1050 <bind_mount@plt>
mov    %eax,-0x8(%rbp)
mov    %eax,-0xac(%rbp)
cmpl   $0x0,-0xac(%rbp)
jge    19a1 <populate_root+0x821>
lea    0x2886(%rip),%rax
mov    %rax,-0xb8(%rbp)
cmpq   $0x0,-0xb8(%rbp)
je     1996 <populate_root+0x816>
mov    -0xb8(%rbp),%rdi
mov    0x466a(%rip),%rax
mov    (%rax),%esi
call   1080 <fputs@plt>
mov    0x465c(%rip),%rax
mov    (%rax),%eax
mov    %eax,-0x3a8(%rbp)
xor    %edi,%edi
sub    -0xac(%rbp),%edi
call   10a0 <strerror@plt>
mov    -0x3a8(%rbp),%edi
mov    %rax,%rdx
lea    0x2691(%rip),%rsi
call   1090 <fprintf@plt>
mov    -0x8(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    3cb3 <populate_root+0x2b33>
jmp    19a6 <populate_root+0x826>
jmp    19ab <populate_root+0x82b>
jmp    19b0 <populate_root+0x830>
jmp    19b5 <populate_root+0x835>
lea    0x283f(%rip),%rdi
call   1030 <touch@plt>
mov    %eax,-0x8(%rbp)
mov    %eax,-0xbc(%rbp)
cmpl   $0x0,-0xbc(%rbp)
jge    1a44 <populate_root+0x8c4>
lea    0x280a(%rip),%rax
mov    %rax,-0xc8(%rbp)
cmpq   $0x0,-0xc8(%rbp)
je     1a39 <populate_root+0x8b9>
mov    -0xc8(%rbp),%rdi
mov    0x45c7(%rip),%rax
mov    (%rax),%esi
call   1080 <fputs@plt>
mov    0x45b9(%rip),%rax
mov    (%rax),%eax
mov    %eax,-0x3ac(%rbp)
xor    %edi,%edi
sub    -0xbc(%rbp),%edi
call   10a0 <strerror@plt>
mov    -0x3ac(%rbp),%edi
mov    %rax,%rdx
lea    0x25ee(%rip),%rsi
call   1090 <fprintf@plt>
mov    -0x8(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    3cb3 <populate_root+0x2b33>
jmp    1a49 <populate_root+0x8c9>
jmp    1a4e <populate_root+0x8ce>
lea    0x27a5(%rip),%rdi
lea    0x279f(%rip),%rsi
call   1050 <bind_mount@plt>
mov    %eax,-0x8(%rbp)
mov    %eax,-0xcc(%rbp)
cmpl   $0x0,-0xcc(%rbp)
jge    1ae4 <populate_root+0x964>
lea    0x2786(%rip),%rax
mov    %rax,-0xd8(%rbp)
cmpq   $0x0,-0xd8(%rbp)
je     1ad9 <populate_root+0x959>
mov    -0xd8(%rbp),%rdi
mov    0x4527(%rip),%rax
mov    (%rax),%esi
call   1080 <fputs@plt>
mov    0x4519(%rip),%rax
mov    (%rax),%eax
mov    %eax,-0x3b0(%rbp)
xor    %edi,%edi
sub    -0xcc(%rbp),%edi
call   10a0 <strerror@plt>
mov    -0x3b0(%rbp),%edi
mov    %rax,%rdx
lea    0x254e(%rip),%rsi
call   1090 <fprintf@plt>
mov    -0x8(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    3cb3 <populate_root+0x2b33>
jmp    1ae9 <populate_root+0x969>
jmp    1aee <populate_root+0x96e>
jmp    1af3 <populate_root+0x973>
jmp    1af8 <populate_root+0x978>
lea    0x273f(%rip),%rdi
call   1030 <touch@plt>
mov    %eax,-0x8(%rbp)
mov    %eax,-0xdc(%rbp)
cmpl   $0x0,-0xdc(%rbp)
jge    1b87 <populate_root+0xa07>
lea    0x270a(%rip),%rax
mov    %rax,-0xe8(%rbp)
cmpq   $0x0,-0xe8(%rbp)
je     1b7c <populate_root+0x9fc>
mov    -0xe8(%rbp),%rdi
mov    0x4484(%rip),%rax
mov    (%rax),%esi
call   1080 <fputs@plt>
mov    0x4476(%rip),%rax
mov    (%rax),%eax
mov    %eax,-0x3b4(%rbp)
xor    %edi,%edi
sub    -0xdc(%rbp),%edi
call   10a0 <strerror@plt>
mov    -0x3b4(%rbp),%edi
mov    %rax,%rdx
lea    0x24ab(%rip),%rsi
call   1090 <fprintf@plt>
mov    -0x8(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    3cb3 <populate_root+0x2b33>
jmp    1b8c <populate_root+0xa0c>
jmp    1b91 <populate_root+0xa11>
lea    0x26a5(%rip),%rdi
lea    0x269f(%rip),%rsi
call   1050 <bind_mount@plt>
mov    %eax,-0x8(%rbp)
mov    %eax,-0xec(%rbp)
cmpl   $0x0,-0xec(%rbp)
jge    1c27 <populate_root+0xaa7>
lea    0x2686(%rip),%rax
mov    %rax,-0xf8(%rbp)
cmpq   $0x0,-0xf8(%rbp)
je     1c1c <populate_root+0xa9c>
mov    -0xf8(%rbp),%rdi
mov    0x43e4(%rip),%rax
mov    (%rax),%esi
call   1080 <fputs@plt>
mov    0x43d6(%rip),%rax
mov    (%rax),%eax
mov    %eax,-0x3b8(%rbp)
xor    %edi,%edi
sub    -0xec(%rbp),%edi
call   10a0 <strerror@plt>
mov    -0x3b8(%rbp),%edi
mov    %rax,%rdx
lea    0x240b(%rip),%rsi
call   1090 <fprintf@plt>
mov    -0x8(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    3cb3 <populate_root+0x2b33>
jmp    1c2c <populate_root+0xaac>
jmp    1c31 <populate_root+0xab1>
jmp    1c36 <populate_root+0xab6>
jmp    1c3b <populate_root+0xabb>
lea    0x2641(%rip),%rdi
call   1030 <touch@plt>
mov    %eax,-0x8(%rbp)
mov    %eax,-0xfc(%rbp)
cmpl   $0x0,-0xfc(%rbp)
jge    1cca <populate_root+0xb4a>
lea    0x260a(%rip),%rax
mov    %rax,-0x108(%rbp)
cmpq   $0x0,-0x108(%rbp)
je     1cbf <populate_root+0xb3f>
mov    -0x108(%rbp),%rdi
mov    0x4341(%rip),%rax
mov    (%rax),%esi
call   1080 <fputs@plt>
mov    0x4333(%rip),%rax
mov    (%rax),%eax
mov    %eax,-0x3bc(%rbp)
xor    %edi,%edi
sub    -0xfc(%rbp),%edi
call   10a0 <strerror@plt>
mov    -0x3bc(%rbp),%edi
mov    %rax,%rdx
lea    0x2368(%rip),%rsi
call   1090 <fprintf@plt>
mov    -0x8(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    3cb3 <populate_root+0x2b33>
jmp    1ccf <populate_root+0xb4f>
jmp    1cd4 <populate_root+0xb54>
lea    0x25a7(%rip),%rdi
lea    0x25a1(%rip),%rsi
call   1050 <bind_mount@plt>
mov    %eax,-0x8(%rbp)
mov    %eax,-0x10c(%rbp)
cmpl   $0x0,-0x10c(%rbp)
jge    1d6a <populate_root+0xbea>
lea    0x258a(%rip),%rax
mov    %rax,-0x118(%rbp)
cmpq   $0x0,-0x118(%rbp)
je     1d5f <populate_root+0xbdf>
mov    -0x118(%rbp),%rdi
mov    0x42a1(%rip),%rax
mov    (%rax),%esi
call   1080 <fputs@plt>
mov    0x4293(%rip),%rax
mov    (%rax),%eax
mov    %eax,-0x3c0(%rbp)
xor    %edi,%edi
sub    -0x10c(%rbp),%edi
call   10a0 <strerror@plt>
mov    -0x3c0(%rbp),%edi
mov    %rax,%rdx
lea    0x22c8(%rip),%rsi
call   1090 <fprintf@plt>
mov    -0x8(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    3cb3 <populate_root+0x2b33>
jmp    1d6f <populate_root+0xbef>
jmp    1d74 <populate_root+0xbf4>
jmp    1d79 <populate_root+0xbf9>
jmp    1d7e <populate_root+0xbfe>
lea    0x254a(%rip),%rdi
call   1030 <touch@plt>
mov    %eax,-0x8(%rbp)
mov    %eax,-0x11c(%rbp)
cmpl   $0x0,-0x11c(%rbp)
jge    1e0d <populate_root+0xc8d>
lea    0x2512(%rip),%rax
mov    %rax,-0x128(%rbp)
cmpq   $0x0,-0x128(%rbp)
je     1e02 <populate_root+0xc82>
mov    -0x128(%rbp),%rdi
mov    0x41fe(%rip),%rax
mov    (%rax),%esi
call   1080 <fputs@plt>
mov    0x41f0(%rip),%rax
mov    (%rax),%eax
mov    %eax,-0x3c4(%rbp)
xor    %edi,%edi
sub    -0x11c(%rbp),%edi
call   10a0 <strerror@plt>
mov    -0x3c4(%rbp),%edi
mov    %rax,%rdx
lea    0x2225(%rip),%rsi
call   1090 <fprintf@plt>
mov    -0x8(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    3cb3 <populate_root+0x2b33>
jmp    1e12 <populate_root+0xc92>
jmp    1e17 <populate_root+0xc97>
lea    0x24b0(%rip),%rdi
lea    0x24aa(%rip),%rsi
call   1050 <bind_mount@plt>
mov    %eax,-0x8(%rbp)
mov    %eax,-0x12c(%rbp)
cmpl   $0x0,-0x12c(%rbp)
jge    1ead <populate_root+0xd2d>
lea    0x2494(%rip),%rax
mov    %rax,-0x138(%rbp)
cmpq   $0x0,-0x138(%rbp)
je     1ea2 <populate_root+0xd22>
mov    -0x138(%rbp),%rdi
mov    0x415e(%rip),%rax
mov    (%rax),%esi
call   1080 <fputs@plt>
mov    0x4150(%rip),%rax
mov    (%rax),%eax
mov    %eax,-0x3c8(%rbp)
xor    %edi,%edi
sub    -0x12c(%rbp),%edi
call   10a0 <strerror@plt>
mov    -0x3c8(%rbp),%edi
mov    %rax,%rdx
lea    0x2185(%rip),%rsi
call   1090 <fprintf@plt>
mov    -0x8(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    3cb3 <populate_root+0x2b33>
jmp    1eb2 <populate_root+0xd32>
jmp    1eb7 <populate_root+0xd37>
jmp    1ebc <populate_root+0xd3c>
lea    0x2445(%rip),%rdi
mov    $0x1ed,%esi
call   1040 <mkdir@plt>
cmp    $0x0,%rax
jge    1eed <populate_root+0xd6d>
xor    %eax,%eax
mov    0x40e0(%rip),%rcx
sub    (%rcx),%eax
mov    %eax,-0x3cc(%rbp)
jmp    1efa <populate_root+0xd7a>
xor    %eax,%eax
mov    %eax,-0x3cc(%rbp)
jmp    1efa <populate_root+0xd7a>
mov    -0x3cc(%rbp),%eax
mov    %eax,-0x8(%rbp)
mov    %eax,-0x13c(%rbp)
cmpl   $0x0,-0x13c(%rbp)
jge    1f83 <populate_root+0xe03>
lea    0x23ef(%rip),%rax
mov    %rax,-0x148(%rbp)
cmpq   $0x0,-0x148(%rbp)
je     1f78 <populate_root+0xdf8>
mov    -0x148(%rbp),%rdi
mov    0x4088(%rip),%rax
mov    (%rax),%esi
call   1080 <fputs@plt>
mov    0x407a(%rip),%rax
mov    (%rax),%eax
mov    %eax,-0x3d0(%rbp)
xor    %edi,%edi
sub    -0x13c(%rbp),%edi
call   10a0 <strerror@plt>
mov    -0x3d0(%rbp),%edi
mov    %rax,%rdx
lea    0x20af(%rip),%rsi
call   1090 <fprintf@plt>
mov    -0x8(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    3cb3 <populate_root+0x2b33>
jmp    1f88 <populate_root+0xe08>
jmp    1f8d <populate_root+0xe0d>
lea    0x238b(%rip),%rdi
lea    0x2398(%rip),%rsi
call   1070 <symlink@plt>
cmp    $0x0,%rax
jge    1fc0 <populate_root+0xe40>
xor    %eax,%eax
mov    0x400d(%rip),%rcx
sub    (%rcx),%eax
mov    %eax,-0x3d4(%rbp)
jmp    1fcd <populate_root+0xe4d>
xor    %eax,%eax
mov    %eax,-0x3d4(%rbp)
jmp    1fcd <populate_root+0xe4d>
mov    -0x3d4(%rbp),%eax
mov    %eax,-0x8(%rbp)
mov    %eax,-0x14c(%rbp)
cmpl   $0x0,-0x14c(%rbp)
jge    2056 <populate_root+0xed6>
lea    0x234c(%rip),%rax
mov    %rax,-0x158(%rbp)
cmpq   $0x0,-0x158(%rbp)
je     204b <populate_root+0xecb>
mov    -0x158(%rbp),%rdi
mov    0x3fb5(%rip),%rax
mov    (%rax),%esi
call   1080 <fputs@plt>
mov    0x3fa7(%rip),%rax
mov    (%rax),%eax
mov    %eax,-0x3d8(%rbp)
xor    %edi,%edi
sub    -0x14c(%rbp),%edi
call   10a0 <strerror@plt>
mov    -0x3d8(%rbp),%edi
mov    %rax,%rdx
lea    0x1fdc(%rip),%rsi
call   1090 <fprintf@plt>
mov    -0x8(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    3cb3 <populate_root+0x2b33>
jmp    205b <populate_root+0xedb>
jmp    2060 <populate_root+0xee0>
lea    0x2300(%rip),%rdi
mov    $0x1ed,%esi
call   1040 <mkdir@plt>
cmp    $0x0,%rax
jge    2091 <populate_root+0xf11>
xor    %eax,%eax
mov    0x3f3c(%rip),%rcx
sub    (%rcx),%eax
mov    %eax,-0x3dc(%rbp)
jmp    209e <populate_root+0xf1e>
xor    %eax,%eax
mov    %eax,-0x3dc(%rbp)
jmp    209e <populate_root+0xf1e>
mov    -0x3dc(%rbp),%eax
mov    %eax,-0x8(%rbp)
mov    %eax,-0x15c(%rbp)
cmpl   $0x0,-0x15c(%rbp)
jge    2127 <populate_root+0xfa7>
lea    0x22ab(%rip),%rax
mov    %rax,-0x168(%rbp)
cmpq   $0x0,-0x168(%rbp)
je     211c <populate_root+0xf9c>
mov    -0x168(%rbp),%rdi
mov    0x3ee4(%rip),%rax
mov    (%rax),%esi
call   1080 <fputs@plt>
mov    0x3ed6(%rip),%rax
mov    (%rax),%eax
mov    %eax,-0x3e0(%rbp)
xor    %edi,%edi
sub    -0x15c(%rbp),%edi
call   10a0 <strerror@plt>
mov    -0x3e0(%rbp),%edi
mov    %rax,%rdx
lea    0x1f0b(%rip),%rsi
call   1090 <fprintf@plt>
mov    -0x8(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    3cb3 <populate_root+0x2b33>
jmp    212c <populate_root+0xfac>
jmp    2131 <populate_root+0xfb1>
mov    0x3ea8(%rip),%rax
mov    (%rax),%ecx
mov    0x3eaf(%rip),%rax
or     (%rax),%ecx
mov    0x3e66(%rip),%rax
or     (%rax),%ecx
lea    0x2214(%rip),%rdx
xor    %eax,%eax
mov    %eax,%r8d
mov    %rdx,%rdi
mov    %rdx,%rsi
call   1060 <mount@plt>
cmp    $0x0,%rax
jge    2183 <populate_root+0x1003>
xor    %eax,%eax
mov    0x3e4a(%rip),%rcx
sub    (%rcx),%eax
mov    %eax,-0x3e4(%rbp)
jmp    2190 <populate_root+0x1010>
xor    %eax,%eax
mov    %eax,-0x3e4(%rbp)
jmp    2190 <populate_root+0x1010>
mov    -0x3e4(%rbp),%eax
mov    %eax,-0x8(%rbp)
mov    %eax,-0x16c(%rbp)
cmpl   $0x0,-0x16c(%rbp)
jge    2219 <populate_root+0x1099>
lea    0x21cd(%rip),%rax
mov    %rax,-0x178(%rbp)
cmpq   $0x0,-0x178(%rbp)
je     220e <populate_root+0x108e>
mov    -0x178(%rbp),%rdi
mov    0x3df2(%rip),%rax
mov    (%rax),%esi
call   1080 <fputs@plt>
mov    0x3de4(%rip),%rax
mov    (%rax),%eax
mov    %eax,-0x3e8(%rbp)
xor    %edi,%edi
sub    -0x16c(%rbp),%edi
call   10a0 <strerror@plt>
mov    -0x3e8(%rbp),%edi
mov    %rax,%rdx
lea    0x1e19(%rip),%rsi
call   1090 <fprintf@plt>
mov    -0x8(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    3cb3 <populate_root+0x2b33>
jmp    221e <populate_root+0x109e>
jmp    2223 <populate_root+0x10a3>
lea    0x219c(%rip),%rdi
mov    $0x1ed,%esi
call   1040 <mkdir@plt>
cmp    $0x0,%rax
jge    2254 <populate_root+0x10d4>
xor    %eax,%eax
mov    0x3d79(%rip),%rcx
sub    (%rcx),%eax
mov    %eax,-0x3ec(%rbp)
jmp    2261 <populate_root+0x10e1>
xor    %eax,%eax
mov    %eax,-0x3ec(%rbp)
jmp    2261 <populate_root+0x10e1>
mov    -0x3ec(%rbp),%eax
mov    %eax,-0x8(%rbp)
mov    %eax,-0x17c(%rbp)
cmpl   $0x0,-0x17c(%rbp)
jge    22ea <populate_root+0x116a>
lea    0x2146(%rip),%rax
mov    %rax,-0x188(%rbp)
cmpq   $0x0,-0x188(%rbp)
je     22df <populate_root+0x115f>
mov    -0x188(%rbp),%rdi
mov    0x3d21(%rip),%rax
mov    (%rax),%esi
call   1080 <fputs@plt>
mov    0x3d13(%rip),%rax
mov    (%rax),%eax
mov    %eax,-0x3f0(%rbp)
xor    %edi,%edi
sub    -0x17c(%rbp),%edi
call   10a0 <strerror@plt>
mov    -0x3f0(%rbp),%edi
mov    %rax,%rdx
lea    0x1d48(%rip),%rsi
call   1090 <fprintf@plt>
mov    -0x8(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    3cb3 <populate_root+0x2b33>
jmp    22ef <populate_root+0x116f>
jmp    22f4 <populate_root+0x1174>
lea    0x20e2(%rip),%rdi
mov    $0x1ed,%esi
call   1040 <mkdir@plt>
cmp    $0x0,%rax
jge    2325 <populate_root+0x11a5>
xor    %eax,%eax
mov    0x3ca8(%rip),%rcx
sub    (%rcx),%eax
mov    %eax,-0x3f4(%rbp)
jmp    2332 <populate_root+0x11b2>
xor    %eax,%eax
mov    %eax,-0x3f4(%rbp)
jmp    2332 <populate_root+0x11b2>
mov    -0x3f4(%rbp),%eax
mov    %eax,-0x8(%rbp)
mov    %eax,-0x18c(%rbp)
cmpl   $0x0,-0x18c(%rbp)
jge    23bb <populate_root+0x123b>
lea    0x208f(%rip),%rax
mov    %rax,-0x198(%rbp)
cmpq   $0x0,-0x198(%rbp)
je     23b0 <populate_root+0x1230>
mov    -0x198(%rbp),%rdi
mov    0x3c50(%rip),%rax
mov    (%rax),%esi
call   1080 <fputs@plt>
mov    0x3c42(%rip),%rax
mov    (%rax),%eax
mov    %eax,-0x3f8(%rbp)
xor    %edi,%edi
sub    -0x18c(%rbp),%edi
call   10a0 <strerror@plt>
mov    -0x3f8(%rbp),%edi
mov    %rax,%rdx
lea    0x1c77(%rip),%rsi
call   1090 <fprintf@plt>
mov    -0x8(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    3cb3 <populate_root+0x2b33>
jmp    23c0 <populate_root+0x1240>
jmp    23c5 <populate_root+0x1245>
lea    0x202e(%rip),%rdi
mov    $0x1ed,%esi
call   1040 <mkdir@plt>
cmp    $0x0,%rax
jge    23f6 <populate_root+0x1276>
xor    %eax,%eax
mov    0x3bd7(%rip),%rcx
sub    (%rcx),%eax
mov    %eax,-0x3fc(%rbp)
jmp    2403 <populate_root+0x1283>
xor    %eax,%eax
mov    %eax,-0x3fc(%rbp)
jmp    2403 <populate_root+0x1283>
mov    -0x3fc(%rbp),%eax
mov    %eax,-0x8(%rbp)
mov    %eax,-0x19c(%rbp)
cmpl   $0x0,-0x19c(%rbp)
jge    248c <populate_root+0x130c>
lea    0x1fe2(%rip),%rax
mov    %rax,-0x1a8(%rbp)
cmpq   $0x0,-0x1a8(%rbp)
je     2481 <populate_root+0x1301>
mov    -0x1a8(%rbp),%rdi
mov    0x3b7f(%rip),%rax
mov    (%rax),%esi
call   1080 <fputs@plt>
mov    0x3b71(%rip),%rax
mov    (%rax),%eax
mov    %eax,-0x400(%rbp)
xor    %edi,%edi
sub    -0x19c(%rbp),%edi
call   10a0 <strerror@plt>
mov    -0x400(%rbp),%edi
mov    %rax,%rdx
lea    0x1ba6(%rip),%rsi
call   1090 <fprintf@plt>
mov    -0x8(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    3cb3 <populate_root+0x2b33>
jmp    2491 <populate_root+0x1311>
jmp    2496 <populate_root+0x1316>
mov    0x3b43(%rip),%rax
mov    (%rax),%ecx
mov    0x3b4a(%rip),%rax
or     (%rax),%ecx
mov    0x3b01(%rip),%rax
or     (%rax),%ecx
lea    0x1f6d(%rip),%rdx
lea    0x1f3b(%rip),%rsi
lea    0x1f65(%rip),%r8
mov    %rdx,%rdi
call   1060 <mount@plt>
cmp    $0x0,%rax
jge    24ee <populate_root+0x136e>
xor    %eax,%eax
mov    0x3adf(%rip),%rcx
sub    (%rcx),%eax
mov    %eax,-0x404(%rbp)
jmp    24fb <populate_root+0x137b>
xor    %eax,%eax
mov    %eax,-0x404(%rbp)
jmp    24fb <populate_root+0x137b>
mov    -0x404(%rbp),%eax
mov    %eax,-0x8(%rbp)
mov    %eax,-0x1ac(%rbp)
cmpl   $0x0,-0x1ac(%rbp)
jge    2584 <populate_root+0x1404>
lea    0x1f16(%rip),%rax
mov    %rax,-0x1b8(%rbp)
cmpq   $0x0,-0x1b8(%rbp)
je     2579 <populate_root+0x13f9>
mov    -0x1b8(%rbp),%rdi
mov    0x3a87(%rip),%rax
mov    (%rax),%esi
call   1080 <fputs@plt>
mov    0x3a79(%rip),%rax
mov    (%rax),%eax
mov    %eax,-0x408(%rbp)
xor    %edi,%edi
sub    -0x1ac(%rbp),%edi
call   10a0 <strerror@plt>
mov    -0x408(%rbp),%edi
mov    %rax,%rdx
lea    0x1aae(%rip),%rsi
call   1090 <fprintf@plt>
mov    -0x8(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    3cb3 <populate_root+0x2b33>
jmp    2589 <populate_root+0x1409>
jmp    258e <populate_root+0x140e>
lea    0x1ef6(%rip),%rdi
mov    $0x1ed,%esi
call   1040 <mkdir@plt>
cmp    $0x0,%rax
jge    25bf <populate_root+0x143f>
xor    %eax,%eax
mov    0x3a0e(%rip),%rcx
sub    (%rcx),%eax
mov    %eax,-0x40c(%rbp)
jmp    25cc <populate_root+0x144c>
xor    %eax,%eax
mov    %eax,-0x40c(%rbp)
jmp    25cc <populate_root+0x144c>
mov    -0x40c(%rbp),%eax
mov    %eax,-0x8(%rbp)
mov    %eax,-0x1bc(%rbp)
cmpl   $0x0,-0x1bc(%rbp)
jge    2655 <populate_root+0x14d5>
lea    0x1eb2(%rip),%rax
mov    %rax,-0x1c8(%rbp)
cmpq   $0x0,-0x1c8(%rbp)
je     264a <populate_root+0x14ca>
mov    -0x1c8(%rbp),%rdi
mov    0x39b6(%rip),%rax
mov    (%rax),%esi
call   1080 <fputs@plt>
mov    0x39a8(%rip),%rax
mov    (%rax),%eax
mov    %eax,-0x410(%rbp)
xor    %edi,%edi
sub    -0x1bc(%rbp),%edi
call   10a0 <strerror@plt>
mov    -0x410(%rbp),%edi
mov    %rax,%rdx
lea    0x19dd(%rip),%rsi
call   1090 <fprintf@plt>
mov    -0x8(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    3cb3 <populate_root+0x2b33>
jmp    265a <populate_root+0x14da>
jmp    265f <populate_root+0x14df>
mov    0x397a(%rip),%rax
mov    (%rax),%ecx
mov    0x3981(%rip),%rax
or     (%rax),%ecx
mov    0x3938(%rip),%rax
or     (%rax),%ecx
lea    0x1d80(%rip),%rdi
lea    0x1e03(%rip),%rsi
lea    0x1e37(%rip),%rdx
xor    %eax,%eax
mov    %eax,%r8d
call   1060 <mount@plt>
cmp    $0x0,%rax
jge    26b9 <populate_root+0x1539>
xor    %eax,%eax
mov    0x3914(%rip),%rcx
sub    (%rcx),%eax
mov    %eax,-0x414(%rbp)
jmp    26c6 <populate_root+0x1546>
xor    %eax,%eax
mov    %eax,-0x414(%rbp)
jmp    26c6 <populate_root+0x1546>
mov    -0x414(%rbp),%eax
mov    %eax,-0x8(%rbp)
mov    %eax,-0x1cc(%rbp)
cmpl   $0x0,-0x1cc(%rbp)
jge    274f <populate_root+0x15cf>
lea    0x1de5(%rip),%rax
mov    %rax,-0x1d8(%rbp)
cmpq   $0x0,-0x1d8(%rbp)
je     2744 <populate_root+0x15c4>
mov    -0x1d8(%rbp),%rdi
mov    0x38bc(%rip),%rax
mov    (%rax),%esi
call   1080 <fputs@plt>
mov    0x38ae(%rip),%rax
mov    (%rax),%eax
mov    %eax,-0x418(%rbp)
xor    %edi,%edi
sub    -0x1cc(%rbp),%edi
call   10a0 <strerror@plt>
mov    -0x418(%rbp),%edi
mov    %rax,%rdx
lea    0x18e3(%rip),%rsi
call   1090 <fprintf@plt>
mov    -0x8(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    3cb3 <populate_root+0x2b33>
jmp    2754 <populate_root+0x15d4>
jmp    2759 <populate_root+0x15d9>
jmp    275e <populate_root+0x15de>
lea    0x1dc5(%rip),%rdi
mov    $0x1ed,%esi
call   1040 <mkdir@plt>
cmp    $0x0,%rax
jge    278f <populate_root+0x160f>
xor    %eax,%eax
mov    0x383e(%rip),%rcx
sub    (%rcx),%eax
mov    %eax,-0x41c(%rbp)
jmp    279c <populate_root+0x161c>
xor    %eax,%eax
mov    %eax,-0x41c(%rbp)
jmp    279c <populate_root+0x161c>
mov    -0x41c(%rbp),%eax
mov    %eax,-0x8(%rbp)
mov    %eax,-0x1dc(%rbp)
cmpl   $0x0,-0x1dc(%rbp)
jge    2825 <populate_root+0x16a5>
lea    0x1d81(%rip),%rax
mov    %rax,-0x1e8(%rbp)
cmpq   $0x0,-0x1e8(%rbp)
je     281a <populate_root+0x169a>
mov    -0x1e8(%rbp),%rdi
mov    0x37e6(%rip),%rax
mov    (%rax),%esi
call   1080 <fputs@plt>
mov    0x37d8(%rip),%rax
mov    (%rax),%eax
mov    %eax,-0x420(%rbp)
xor    %edi,%edi
sub    -0x1dc(%rbp),%edi
call   10a0 <strerror@plt>
mov    -0x420(%rbp),%edi
mov    %rax,%rdx
lea    0x180d(%rip),%rsi
call   1090 <fprintf@plt>
mov    -0x8(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    3cb3 <populate_root+0x2b33>
jmp    282a <populate_root+0x16aa>
jmp    282f <populate_root+0x16af>
mov    0x37aa(%rip),%rax
mov    (%rax),%ecx
mov    0x37b1(%rip),%rax
or     (%rax),%ecx
mov    0x3768(%rip),%rax
or     (%rax),%ecx
lea    0x1bb0(%rip),%rdx
lea    0x1cd2(%rip),%rsi
lea    0x1cd9(%rip),%r8
mov    %rdx,%rdi
call   1060 <mount@plt>
cmp    $0x0,%rax
jge    2887 <populate_root+0x1707>
xor    %eax,%eax
mov    0x3746(%rip),%rcx
sub    (%rcx),%eax
mov    %eax,-0x424(%rbp)
jmp    2894 <populate_root+0x1714>
xor    %eax,%eax
mov    %eax,-0x424(%rbp)
jmp    2894 <populate_root+0x1714>
mov    -0x424(%rbp),%eax
mov    %eax,-0x8(%rbp)
mov    %eax,-0x1ec(%rbp)
cmpl   $0x0,-0x1ec(%rbp)
jge    291d <populate_root+0x179d>
lea    0x1cb1(%rip),%rax
mov    %rax,-0x1f8(%rbp)
cmpq   $0x0,-0x1f8(%rbp)
je     2912 <populate_root+0x1792>
mov    -0x1f8(%rbp),%rdi
mov    0x36ee(%rip),%rax
mov    (%rax),%esi
call   1080 <fputs@plt>
mov    0x36e0(%rip),%rax
mov    (%rax),%eax
mov    %eax,-0x428(%rbp)
xor    %edi,%edi
sub    -0x1ec(%rbp),%edi
call   10a0 <strerror@plt>
mov    -0x428(%rbp),%edi
mov    %rax,%rdx
lea    0x1715(%rip),%rsi
call   1090 <fprintf@plt>
mov    -0x8(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    3cb3 <populate_root+0x2b33>
jmp    2922 <populate_root+0x17a2>
jmp    2927 <populate_root+0x17a7>
jmp    292c <populate_root+0x17ac>
jmp    2931 <populate_root+0x17b1>
lea    0x1c93(%rip),%rdi
mov    $0x1ed,%esi
call   1040 <mkdir@plt>
cmp    $0x0,%rax
jge    2962 <populate_root+0x17e2>
xor    %eax,%eax
mov    0x366b(%rip),%rcx
sub    (%rcx),%eax
mov    %eax,-0x42c(%rbp)
jmp    296f <populate_root+0x17ef>
xor    %eax,%eax
mov    %eax,-0x42c(%rbp)
jmp    296f <populate_root+0x17ef>
mov    -0x42c(%rbp),%eax
mov    %eax,-0x8(%rbp)
mov    %eax,-0x1fc(%rbp)
cmpl   $0x0,-0x1fc(%rbp)
jge    29f8 <populate_root+0x1878>
lea    0x1c53(%rip),%rax
mov    %rax,-0x208(%rbp)
cmpq   $0x0,-0x208(%rbp)
je     29ed <populate_root+0x186d>
mov    -0x208(%rbp),%rdi
mov    0x3613(%rip),%rax
mov    (%rax),%esi
call   1080 <fputs@plt>
mov    0x3605(%rip),%rax
mov    (%rax),%eax
mov    %eax,-0x430(%rbp)
xor    %edi,%edi
sub    -0x1fc(%rbp),%edi
call   10a0 <strerror@plt>
mov    -0x430(%rbp),%edi
mov    %rax,%rdx
lea    0x163a(%rip),%rsi
call   1090 <fprintf@plt>
mov    -0x8(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    3cb3 <populate_root+0x2b33>
jmp    29fd <populate_root+0x187d>
jmp    2a02 <populate_root+0x1882>
mov    0x35d7(%rip),%rax
mov    (%rax),%ecx
mov    0x35de(%rip),%rax
or     (%rax),%ecx
mov    0x3595(%rip),%rax
or     (%rax),%ecx
lea    0x19dd(%rip),%rdx
lea    0x1ba0(%rip),%rsi
lea    0x1ba7(%rip),%r8
mov    %rdx,%rdi
call   1060 <mount@plt>
cmp    $0x0,%rax
jge    2a5a <populate_root+0x18da>
xor    %eax,%eax
mov    0x3573(%rip),%rcx
sub    (%rcx),%eax
mov    %eax,-0x434(%rbp)
jmp    2a67 <populate_root+0x18e7>
xor    %eax,%eax
mov    %eax,-0x434(%rbp)
jmp    2a67 <populate_root+0x18e7>
mov    -0x434(%rbp),%eax
mov    %eax,-0x8(%rbp)
mov    %eax,-0x20c(%rbp)
cmpl   $0x0,-0x20c(%rbp)
jge    2af0 <populate_root+0x1970>
lea    0x1b87(%rip),%rax
mov    %rax,-0x218(%rbp)
cmpq   $0x0,-0x218(%rbp)
je     2ae5 <populate_root+0x1965>
mov    -0x218(%rbp),%rdi
mov    0x351b(%rip),%rax
mov    (%rax),%esi
call   1080 <fputs@plt>
mov    0x350d(%rip),%rax
mov    (%rax),%eax
mov    %eax,-0x438(%rbp)
xor    %edi,%edi
sub    -0x20c(%rbp),%edi
call   10a0 <strerror@plt>
mov    -0x438(%rbp),%edi
mov    %rax,%rdx
lea    0x1542(%rip),%rsi
call   1090 <fprintf@plt>
mov    -0x8(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    3cb3 <populate_root+0x2b33>
jmp    2af5 <populate_root+0x1975>
jmp    2afa <populate_root+0x197a>
jmp    2aff <populate_root+0x197f>
jmp    2b04 <populate_root+0x1984>
lea    0x1b71(%rip),%rdi
mov    $0x1ed,%esi
call   1040 <mkdir@plt>
cmp    $0x0,%rax
jge    2b35 <populate_root+0x19b5>
xor    %eax,%eax
mov    0x3498(%rip),%rcx
sub    (%rcx),%eax
mov    %eax,-0x43c(%rbp)
jmp    2b42 <populate_root+0x19c2>
xor    %eax,%eax
mov    %eax,-0x43c(%rbp)
jmp    2b42 <populate_root+0x19c2>
mov    -0x43c(%rbp),%eax
mov    %eax,-0x8(%rbp)
mov    %eax,-0x21c(%rbp)
cmpl   $0x0,-0x21c(%rbp)
jge    2bcb <populate_root+0x1a4b>
lea    0x1b2c(%rip),%rax
mov    %rax,-0x228(%rbp)
cmpq   $0x0,-0x228(%rbp)
je     2bc0 <populate_root+0x1a40>
mov    -0x228(%rbp),%rdi
mov    0x3440(%rip),%rax
mov    (%rax),%esi
call   1080 <fputs@plt>
mov    0x3432(%rip),%rax
mov    (%rax),%eax
mov    %eax,-0x440(%rbp)
xor    %edi,%edi
sub    -0x21c(%rbp),%edi
call   10a0 <strerror@plt>
mov    -0x440(%rbp),%edi
mov    %rax,%rdx
lea    0x1467(%rip),%rsi
call   1090 <fprintf@plt>
mov    -0x8(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    3cb3 <populate_root+0x2b33>
jmp    2bd0 <populate_root+0x1a50>
jmp    2bd5 <populate_root+0x1a55>
mov    0x3404(%rip),%rax
mov    (%rax),%ecx
mov    0x340b(%rip),%rax
or     (%rax),%ecx
mov    0x33c2(%rip),%rax
or     (%rax),%ecx
lea    0x180a(%rip),%rdx
lea    0x1a7e(%rip),%rsi
lea    0x1a85(%rip),%r8
mov    %rdx,%rdi
call   1060 <mount@plt>
cmp    $0x0,%rax
jge    2c2d <populate_root+0x1aad>
xor    %eax,%eax
mov    0x33a0(%rip),%rcx
sub    (%rcx),%eax
mov    %eax,-0x444(%rbp)
jmp    2c3a <populate_root+0x1aba>
xor    %eax,%eax
mov    %eax,-0x444(%rbp)
jmp    2c3a <populate_root+0x1aba>
mov    -0x444(%rbp),%eax
mov    %eax,-0x8(%rbp)
mov    %eax,-0x22c(%rbp)
cmpl   $0x0,-0x22c(%rbp)
jge    2cc3 <populate_root+0x1b43>
lea    0x1a5b(%rip),%rax
mov    %rax,-0x238(%rbp)
cmpq   $0x0,-0x238(%rbp)
je     2cb8 <populate_root+0x1b38>
mov    -0x238(%rbp),%rdi
mov    0x3348(%rip),%rax
mov    (%rax),%esi
call   1080 <fputs@plt>
mov    0x333a(%rip),%rax
mov    (%rax),%eax
mov    %eax,-0x448(%rbp)
xor    %edi,%edi
sub    -0x22c(%rbp),%edi
call   10a0 <strerror@plt>
mov    -0x448(%rbp),%edi
mov    %rax,%rdx
lea    0x136f(%rip),%rsi
call   1090 <fprintf@plt>
mov    -0x8(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    3cb3 <populate_root+0x2b33>
jmp    2cc8 <populate_root+0x1b48>
jmp    2ccd <populate_root+0x1b4d>
jmp    2cd2 <populate_root+0x1b52>
jmp    2cd7 <populate_root+0x1b57>
lea    0x1a3b(%rip),%rdi
mov    $0x1ed,%esi
call   1040 <mkdir@plt>
cmp    $0x0,%rax
jge    2d08 <populate_root+0x1b88>
xor    %eax,%eax
mov    0x32c5(%rip),%rcx
sub    (%rcx),%eax
mov    %eax,-0x44c(%rbp)
jmp    2d15 <populate_root+0x1b95>
xor    %eax,%eax
mov    %eax,-0x44c(%rbp)
jmp    2d15 <populate_root+0x1b95>
mov    -0x44c(%rbp),%eax
mov    %eax,-0x8(%rbp)
mov    %eax,-0x23c(%rbp)
cmpl   $0x0,-0x23c(%rbp)
jge    2d9e <populate_root+0x1c1e>
lea    0x1a00(%rip),%rax
mov    %rax,-0x248(%rbp)
cmpq   $0x0,-0x248(%rbp)
je     2d93 <populate_root+0x1c13>
mov    -0x248(%rbp),%rdi
mov    0x326d(%rip),%rax
mov    (%rax),%esi
call   1080 <fputs@plt>
mov    0x325f(%rip),%rax
mov    (%rax),%eax
mov    %eax,-0x450(%rbp)
xor    %edi,%edi
sub    -0x23c(%rbp),%edi
call   10a0 <strerror@plt>
mov    -0x450(%rbp),%edi
mov    %rax,%rdx
lea    0x1294(%rip),%rsi
call   1090 <fprintf@plt>
mov    -0x8(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    3cb3 <populate_root+0x2b33>
jmp    2da3 <populate_root+0x1c23>
jmp    2da8 <populate_root+0x1c28>
mov    0x3231(%rip),%rax
mov    (%rax),%ecx
mov    0x3238(%rip),%rax
or     (%rax),%ecx
mov    0x31ef(%rip),%rax
or     (%rax),%ecx
lea    0x1637(%rip),%rdx
lea    0x1948(%rip),%rsi
lea    0x194f(%rip),%r8
mov    %rdx,%rdi
call   1060 <mount@plt>
cmp    $0x0,%rax
jge    2e00 <populate_root+0x1c80>
xor    %eax,%eax
mov    0x31cd(%rip),%rcx
sub    (%rcx),%eax
mov    %eax,-0x454(%rbp)
jmp    2e0d <populate_root+0x1c8d>
xor    %eax,%eax
mov    %eax,-0x454(%rbp)
jmp    2e0d <populate_root+0x1c8d>
mov    -0x454(%rbp),%eax
mov    %eax,-0x8(%rbp)
mov    %eax,-0x24c(%rbp)
cmpl   $0x0,-0x24c(%rbp)
jge    2e96 <populate_root+0x1d16>
lea    0x1939(%rip),%rax
mov    %rax,-0x258(%rbp)
cmpq   $0x0,-0x258(%rbp)
je     2e8b <populate_root+0x1d0b>
mov    -0x258(%rbp),%rdi
mov    0x3175(%rip),%rax
mov    (%rax),%esi
call   1080 <fputs@plt>
mov    0x3167(%rip),%rax
mov    (%rax),%eax
mov    %eax,-0x458(%rbp)
xor    %edi,%edi
sub    -0x24c(%rbp),%edi
call   10a0 <strerror@plt>
mov    -0x458(%rbp),%edi
mov    %rax,%rdx
lea    0x119c(%rip),%rsi
call   1090 <fprintf@plt>
mov    -0x8(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    3cb3 <populate_root+0x2b33>
jmp    2e9b <populate_root+0x1d1b>
jmp    2ea0 <populate_root+0x1d20>
jmp    2ea5 <populate_root+0x1d25>
jmp    2eaa <populate_root+0x1d2a>
lea    0x192d(%rip),%rdi
mov    $0x1ed,%esi
call   1040 <mkdir@plt>
cmp    $0x0,%rax
jge    2edb <populate_root+0x1d5b>
xor    %eax,%eax
mov    0x30f2(%rip),%rcx
sub    (%rcx),%eax
mov    %eax,-0x45c(%rbp)
jmp    2ee8 <populate_root+0x1d68>
xor    %eax,%eax
mov    %eax,-0x45c(%rbp)
jmp    2ee8 <populate_root+0x1d68>
mov    -0x45c(%rbp),%eax
mov    %eax,-0x8(%rbp)
mov    %eax,-0x25c(%rbp)
cmpl   $0x0,-0x25c(%rbp)
jge    2f71 <populate_root+0x1df1>
lea    0x18e6(%rip),%rax
mov    %rax,-0x268(%rbp)
cmpq   $0x0,-0x268(%rbp)
je     2f66 <populate_root+0x1de6>
mov    -0x268(%rbp),%rdi
mov    0x309a(%rip),%rax
mov    (%rax),%esi
call   1080 <fputs@plt>
mov    0x308c(%rip),%rax
mov    (%rax),%eax
mov    %eax,-0x460(%rbp)
xor    %edi,%edi
sub    -0x25c(%rbp),%edi
call   10a0 <strerror@plt>
mov    -0x460(%rbp),%edi
mov    %rax,%rdx
lea    0x10c1(%rip),%rsi
call   1090 <fprintf@plt>
mov    -0x8(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    3cb3 <populate_root+0x2b33>
jmp    2f76 <populate_root+0x1df6>
jmp    2f7b <populate_root+0x1dfb>
mov    0x305e(%rip),%rax
mov    (%rax),%ecx
mov    0x3065(%rip),%rax
or     (%rax),%ecx
mov    0x301c(%rip),%rax
or     (%rax),%ecx
lea    0x1464(%rip),%rdx
lea    0x183a(%rip),%rsi
lea    0x1841(%rip),%r8
mov    %rdx,%rdi
call   1060 <mount@plt>
cmp    $0x0,%rax
jge    2fd3 <populate_root+0x1e53>
xor    %eax,%eax
mov    0x2ffa(%rip),%rcx
sub    (%rcx),%eax
mov    %eax,-0x464(%rbp)
jmp    2fe0 <populate_root+0x1e60>
xor    %eax,%eax
mov    %eax,-0x464(%rbp)
jmp    2fe0 <populate_root+0x1e60>
mov    -0x464(%rbp),%eax
mov    %eax,-0x8(%rbp)
mov    %eax,-0x26c(%rbp)
cmpl   $0x0,-0x26c(%rbp)
jge    3069 <populate_root+0x1ee9>
lea    0x1813(%rip),%rax
mov    %rax,-0x278(%rbp)
cmpq   $0x0,-0x278(%rbp)
je     305e <populate_root+0x1ede>
mov    -0x278(%rbp),%rdi
mov    0x2fa2(%rip),%rax
mov    (%rax),%esi
call   1080 <fputs@plt>
mov    0x2f94(%rip),%rax
mov    (%rax),%eax
mov    %eax,-0x468(%rbp)
xor    %edi,%edi
sub    -0x26c(%rbp),%edi
call   10a0 <strerror@plt>
mov    -0x468(%rbp),%edi
mov    %rax,%rdx
lea    0xfc9(%rip),%rsi
call   1090 <fprintf@plt>
mov    -0x8(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    3cb3 <populate_root+0x2b33>
jmp    306e <populate_root+0x1eee>
jmp    3073 <populate_root+0x1ef3>
jmp    3078 <populate_root+0x1ef8>
jmp    307d <populate_root+0x1efd>
lea    0x17ef(%rip),%rdi
mov    $0x1ed,%esi
call   1040 <mkdir@plt>
cmp    $0x0,%rax
jge    30ae <populate_root+0x1f2e>
xor    %eax,%eax
mov    0x2f1f(%rip),%rcx
sub    (%rcx),%eax
mov    %eax,-0x46c(%rbp)
jmp    30bb <populate_root+0x1f3b>
xor    %eax,%eax
mov    %eax,-0x46c(%rbp)
jmp    30bb <populate_root+0x1f3b>
mov    -0x46c(%rbp),%eax
mov    %eax,-0x8(%rbp)
mov    %eax,-0x27c(%rbp)
cmpl   $0x0,-0x27c(%rbp)
jge    3144 <populate_root+0x1fc4>
lea    0x17a9(%rip),%rax
mov    %rax,-0x288(%rbp)
cmpq   $0x0,-0x288(%rbp)
je     3139 <populate_root+0x1fb9>
mov    -0x288(%rbp),%rdi
mov    0x2ec7(%rip),%rax
mov    (%rax),%esi
call   1080 <fputs@plt>
mov    0x2eb9(%rip),%rax
mov    (%rax),%eax
mov    %eax,-0x470(%rbp)
xor    %edi,%edi
sub    -0x27c(%rbp),%edi
call   10a0 <strerror@plt>
mov    -0x470(%rbp),%edi
mov    %rax,%rdx
lea    0xeee(%rip),%rsi
call   1090 <fprintf@plt>
mov    -0x8(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    3cb3 <populate_root+0x2b33>
jmp    3149 <populate_root+0x1fc9>
jmp    314e <populate_root+0x1fce>
mov    0x2e8b(%rip),%rax
mov    (%rax),%ecx
mov    0x2e92(%rip),%rax
or     (%rax),%ecx
mov    0x2e49(%rip),%rax
or     (%rax),%ecx
lea    0x1291(%rip),%rdx
lea    0x16fc(%rip),%rsi
lea    0x1703(%rip),%r8
mov    %rdx,%rdi
call   1060 <mount@plt>
cmp    $0x0,%rax
jge    31a6 <populate_root+0x2026>
xor    %eax,%eax
mov    0x2e27(%rip),%rcx
sub    (%rcx),%eax
mov    %eax,-0x474(%rbp)
jmp    31b3 <populate_root+0x2033>
xor    %eax,%eax
mov    %eax,-0x474(%rbp)
jmp    31b3 <populate_root+0x2033>
mov    -0x474(%rbp),%eax
mov    %eax,-0x8(%rbp)
mov    %eax,-0x28c(%rbp)
cmpl   $0x0,-0x28c(%rbp)
jge    323c <populate_root+0x20bc>
lea    0x16d7(%rip),%rax
mov    %rax,-0x298(%rbp)
cmpq   $0x0,-0x298(%rbp)
je     3231 <populate_root+0x20b1>
mov    -0x298(%rbp),%rdi
mov    0x2dcf(%rip),%rax
mov    (%rax),%esi
call   1080 <fputs@plt>
mov    0x2dc1(%rip),%rax
mov    (%rax),%eax
mov    %eax,-0x478(%rbp)
xor    %edi,%edi
sub    -0x28c(%rbp),%edi
call   10a0 <strerror@plt>
mov    -0x478(%rbp),%edi
mov    %rax,%rdx
lea    0xdf6(%rip),%rsi
call   1090 <fprintf@plt>
mov    -0x8(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    3cb3 <populate_root+0x2b33>
jmp    3241 <populate_root+0x20c1>
jmp    3246 <populate_root+0x20c6>
jmp    324b <populate_root+0x20cb>
jmp    3250 <populate_root+0x20d0>
lea    0x16b5(%rip),%rdi
mov    $0x1ed,%esi
call   1040 <mkdir@plt>
cmp    $0x0,%rax
jge    3281 <populate_root+0x2101>
xor    %eax,%eax
mov    0x2d4c(%rip),%rcx
sub    (%rcx),%eax
mov    %eax,-0x47c(%rbp)
jmp    328e <populate_root+0x210e>
xor    %eax,%eax
mov    %eax,-0x47c(%rbp)
jmp    328e <populate_root+0x210e>
mov    -0x47c(%rbp),%eax
mov    %eax,-0x8(%rbp)
mov    %eax,-0x29c(%rbp)
cmpl   $0x0,-0x29c(%rbp)
jge    3317 <populate_root+0x2197>
lea    0x1671(%rip),%rax
mov    %rax,-0x2a8(%rbp)
cmpq   $0x0,-0x2a8(%rbp)
je     330c <populate_root+0x218c>
mov    -0x2a8(%rbp),%rdi
mov    0x2cf4(%rip),%rax
mov    (%rax),%esi
call   1080 <fputs@plt>
mov    0x2ce6(%rip),%rax
mov    (%rax),%eax
mov    %eax,-0x480(%rbp)
xor    %edi,%edi
sub    -0x29c(%rbp),%edi
call   10a0 <strerror@plt>
mov    -0x480(%rbp),%edi
mov    %rax,%rdx
lea    0xd1b(%rip),%rsi
call   1090 <fprintf@plt>
mov    -0x8(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    3cb3 <populate_root+0x2b33>
jmp    331c <populate_root+0x219c>
jmp    3321 <populate_root+0x21a1>
mov    0x2cb8(%rip),%rax
mov    (%rax),%ecx
mov    0x2cbf(%rip),%rax
or     (%rax),%ecx
mov    0x2c76(%rip),%rax
or     (%rax),%ecx
lea    0x10be(%rip),%rdx
lea    0x15c2(%rip),%rsi
lea    0x15c9(%rip),%r8
mov    %rdx,%rdi
call   1060 <mount@plt>
cmp    $0x0,%rax
jge    3379 <populate_root+0x21f9>
xor    %eax,%eax
mov    0x2c54(%rip),%rcx
sub    (%rcx),%eax
mov    %eax,-0x484(%rbp)
jmp    3386 <populate_root+0x2206>
xor    %eax,%eax
mov    %eax,-0x484(%rbp)
jmp    3386 <populate_root+0x2206>
mov    -0x484(%rbp),%eax
mov    %eax,-0x8(%rbp)
mov    %eax,-0x2ac(%rbp)
cmpl   $0x0,-0x2ac(%rbp)
jge    340f <populate_root+0x228f>
lea    0x15a1(%rip),%rax
mov    %rax,-0x2b8(%rbp)
cmpq   $0x0,-0x2b8(%rbp)
je     3404 <populate_root+0x2284>
mov    -0x2b8(%rbp),%rdi
mov    0x2bfc(%rip),%rax
mov    (%rax),%esi
call   1080 <fputs@plt>
mov    0x2bee(%rip),%rax
mov    (%rax),%eax
mov    %eax,-0x488(%rbp)
xor    %edi,%edi
sub    -0x2ac(%rbp),%edi
call   10a0 <strerror@plt>
mov    -0x488(%rbp),%edi
mov    %rax,%rdx
lea    0xc23(%rip),%rsi
call   1090 <fprintf@plt>
mov    -0x8(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    3cb3 <populate_root+0x2b33>
jmp    3414 <populate_root+0x2294>
jmp    3419 <populate_root+0x2299>
jmp    341e <populate_root+0x229e>
jmp    3423 <populate_root+0x22a3>
lea    0x1583(%rip),%rdi
mov    $0x1ed,%esi
call   1040 <mkdir@plt>
cmp    $0x0,%rax
jge    3454 <populate_root+0x22d4>
xor    %eax,%eax
mov    0x2b79(%rip),%rcx
sub    (%rcx),%eax
mov    %eax,-0x48c(%rbp)
jmp    3461 <populate_root+0x22e1>
xor    %eax,%eax
mov    %eax,-0x48c(%rbp)
jmp    3461 <populate_root+0x22e1>
mov    -0x48c(%rbp),%eax
mov    %eax,-0x8(%rbp)
mov    %eax,-0x2bc(%rbp)
cmpl   $0x0,-0x2bc(%rbp)
jge    34ea <populate_root+0x236a>
lea    0x153e(%rip),%rax
mov    %rax,-0x2c8(%rbp)
cmpq   $0x0,-0x2c8(%rbp)
je     34df <populate_root+0x235f>
mov    -0x2c8(%rbp),%rdi
mov    0x2b21(%rip),%rax
mov    (%rax),%esi
call   1080 <fputs@plt>
mov    0x2b13(%rip),%rax
mov    (%rax),%eax
mov    %eax,-0x490(%rbp)
xor    %edi,%edi
sub    -0x2bc(%rbp),%edi
call   10a0 <strerror@plt>
mov    -0x490(%rbp),%edi
mov    %rax,%rdx
lea    0xb48(%rip),%rsi
call   1090 <fprintf@plt>
mov    -0x8(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    3cb3 <populate_root+0x2b33>
jmp    34ef <populate_root+0x236f>
jmp    34f4 <populate_root+0x2374>
mov    0x2ae5(%rip),%rax
mov    (%rax),%ecx
mov    0x2aec(%rip),%rax
or     (%rax),%ecx
mov    0x2aa3(%rip),%rax
or     (%rax),%ecx
lea    0xeeb(%rip),%rdx
lea    0x1490(%rip),%rsi
lea    0x1497(%rip),%r8
mov    %rdx,%rdi
call   1060 <mount@plt>
cmp    $0x0,%rax
jge    354c <populate_root+0x23cc>
xor    %eax,%eax
mov    0x2a81(%rip),%rcx
sub    (%rcx),%eax
mov    %eax,-0x494(%rbp)
jmp    3559 <populate_root+0x23d9>
xor    %eax,%eax
mov    %eax,-0x494(%rbp)
jmp    3559 <populate_root+0x23d9>
mov    -0x494(%rbp),%eax
mov    %eax,-0x8(%rbp)
mov    %eax,-0x2cc(%rbp)
cmpl   $0x0,-0x2cc(%rbp)
jge    35e2 <populate_root+0x2462>
lea    0x146d(%rip),%rax
mov    %rax,-0x2d8(%rbp)
cmpq   $0x0,-0x2d8(%rbp)
je     35d7 <populate_root+0x2457>
mov    -0x2d8(%rbp),%rdi
mov    0x2a29(%rip),%rax
mov    (%rax),%esi
call   1080 <fputs@plt>
mov    0x2a1b(%rip),%rax
mov    (%rax),%eax
mov    %eax,-0x498(%rbp)
xor    %edi,%edi
sub    -0x2cc(%rbp),%edi
call   10a0 <strerror@plt>
mov    -0x498(%rbp),%edi
mov    %rax,%rdx
lea    0xa50(%rip),%rsi
call   1090 <fprintf@plt>
mov    -0x8(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    3cb3 <populate_root+0x2b33>
jmp    35e7 <populate_root+0x2467>
jmp    35ec <populate_root+0x246c>
jmp    35f1 <populate_root+0x2471>
lea    0xfe1(%rip),%rdi
lea    0x144b(%rip),%rsi
call   1070 <symlink@plt>
cmp    $0x0,%rax
jge    3624 <populate_root+0x24a4>
xor    %eax,%eax
mov    0x29a9(%rip),%rcx
sub    (%rcx),%eax
mov    %eax,-0x49c(%rbp)
jmp    3631 <populate_root+0x24b1>
xor    %eax,%eax
mov    %eax,-0x49c(%rbp)
jmp    3631 <populate_root+0x24b1>
mov    -0x49c(%rbp),%eax
mov    %eax,-0x8(%rbp)
mov    %eax,-0x2dc(%rbp)
cmpl   $0x0,-0x2dc(%rbp)
jge    36ba <populate_root+0x253a>
lea    0x1408(%rip),%rax
mov    %rax,-0x2e8(%rbp)
cmpq   $0x0,-0x2e8(%rbp)
je     36af <populate_root+0x252f>
mov    -0x2e8(%rbp),%rdi
mov    0x2951(%rip),%rax
mov    (%rax),%esi
call   1080 <fputs@plt>
mov    0x2943(%rip),%rax
mov    (%rax),%eax
mov    %eax,-0x4a0(%rbp)
xor    %edi,%edi
sub    -0x2dc(%rbp),%edi
call   10a0 <strerror@plt>
mov    -0x4a0(%rbp),%edi
mov    %rax,%rdx
lea    0x978(%rip),%rsi
call   1090 <fprintf@plt>
mov    -0x8(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    3cb3 <populate_root+0x2b33>
jmp    36bf <populate_root+0x253f>
jmp    36c4 <populate_root+0x2544>
lea    0xf0e(%rip),%rdi
lea    0x13b6(%rip),%rsi
call   1070 <symlink@plt>
cmp    $0x0,%rax
jge    36f7 <populate_root+0x2577>
xor    %eax,%eax
mov    0x28d6(%rip),%rcx
sub    (%rcx),%eax
mov    %eax,-0x4a4(%rbp)
jmp    3704 <populate_root+0x2584>
xor    %eax,%eax
mov    %eax,-0x4a4(%rbp)
jmp    3704 <populate_root+0x2584>
mov    -0x4a4(%rbp),%eax
mov    %eax,-0x8(%rbp)
mov    %eax,-0x2ec(%rbp)
cmpl   $0x0,-0x2ec(%rbp)
jge    378d <populate_root+0x260d>
lea    0x1377(%rip),%rax
mov    %rax,-0x2f8(%rbp)
cmpq   $0x0,-0x2f8(%rbp)
je     3782 <populate_root+0x2602>
mov    -0x2f8(%rbp),%rdi
mov    0x287e(%rip),%rax
mov    (%rax),%esi
call   1080 <fputs@plt>
mov    0x2870(%rip),%rax
mov    (%rax),%eax
mov    %eax,-0x4a8(%rbp)
xor    %edi,%edi
sub    -0x2ec(%rbp),%edi
call   10a0 <strerror@plt>
mov    -0x4a8(%rbp),%edi
mov    %rax,%rdx
lea    0x8a5(%rip),%rsi
call   1090 <fprintf@plt>
mov    -0x8(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    3cb3 <populate_root+0x2b33>
jmp    3792 <populate_root+0x2612>
jmp    3797 <populate_root+0x2617>
lea    0xf89(%rip),%rdi
lea    0x1329(%rip),%rsi
call   1070 <symlink@plt>
cmp    $0x0,%rax
jge    37ca <populate_root+0x264a>
xor    %eax,%eax
mov    0x2803(%rip),%rcx
sub    (%rcx),%eax
mov    %eax,-0x4ac(%rbp)
jmp    37d7 <populate_root+0x2657>
xor    %eax,%eax
mov    %eax,-0x4ac(%rbp)
jmp    37d7 <populate_root+0x2657>
mov    -0x4ac(%rbp),%eax
mov    %eax,-0x8(%rbp)
mov    %eax,-0x2fc(%rbp)
cmpl   $0x0,-0x2fc(%rbp)
jge    3860 <populate_root+0x26e0>
lea    0x12ea(%rip),%rax
mov    %rax,-0x308(%rbp)
cmpq   $0x0,-0x308(%rbp)
je     3855 <populate_root+0x26d5>
mov    -0x308(%rbp),%rdi
mov    0x27ab(%rip),%rax
mov    (%rax),%esi
call   1080 <fputs@plt>
mov    0x279d(%rip),%rax
mov    (%rax),%eax
mov    %eax,-0x4b0(%rbp)
xor    %edi,%edi
sub    -0x2fc(%rbp),%edi
call   10a0 <strerror@plt>
mov    -0x4b0(%rbp),%edi
mov    %rax,%rdx
lea    0x7d2(%rip),%rsi
call   1090 <fprintf@plt>
mov    -0x8(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    3cb3 <populate_root+0x2b33>
jmp    3865 <populate_root+0x26e5>
jmp    386a <populate_root+0x26ea>
lea    0xeb6(%rip),%rdi
lea    0x12a1(%rip),%rsi
call   1070 <symlink@plt>
cmp    $0x0,%rax
jge    389d <populate_root+0x271d>
xor    %eax,%eax
mov    0x2730(%rip),%rcx
sub    (%rcx),%eax
mov    %eax,-0x4b4(%rbp)
jmp    38aa <populate_root+0x272a>
xor    %eax,%eax
mov    %eax,-0x4b4(%rbp)
jmp    38aa <populate_root+0x272a>
mov    -0x4b4(%rbp),%eax
mov    %eax,-0x8(%rbp)
mov    %eax,-0x30c(%rbp)
cmpl   $0x0,-0x30c(%rbp)
jge    3933 <populate_root+0x27b3>
lea    0x1263(%rip),%rax
mov    %rax,-0x318(%rbp)
cmpq   $0x0,-0x318(%rbp)
je     3928 <populate_root+0x27a8>
mov    -0x318(%rbp),%rdi
mov    0x26d8(%rip),%rax
mov    (%rax),%esi
call   1080 <fputs@plt>
mov    0x26ca(%rip),%rax
mov    (%rax),%eax
mov    %eax,-0x4b8(%rbp)
xor    %edi,%edi
sub    -0x30c(%rbp),%edi
call   10a0 <strerror@plt>
mov    -0x4b8(%rbp),%edi
mov    %rax,%rdx
lea    0x6ff(%rip),%rsi
call   1090 <fprintf@plt>
mov    -0x8(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    3cb3 <populate_root+0x2b33>
jmp    3938 <populate_root+0x27b8>
jmp    393d <populate_root+0x27bd>
lea    0x1236(%rip),%rdi
mov    $0x1ed,%esi
call   1040 <mkdir@plt>
cmp    $0x0,%rax
jge    396e <populate_root+0x27ee>
xor    %eax,%eax
mov    0x265f(%rip),%rcx
sub    (%rcx),%eax
mov    %eax,-0x4bc(%rbp)
jmp    397b <populate_root+0x27fb>
xor    %eax,%eax
mov    %eax,-0x4bc(%rbp)
jmp    397b <populate_root+0x27fb>
mov    -0x4bc(%rbp),%eax
mov    %eax,-0x8(%rbp)
mov    %eax,-0x31c(%rbp)
cmpl   $0x0,-0x31c(%rbp)
jge    3a04 <populate_root+0x2884>
lea    0x11c8(%rip),%rax
mov    %rax,-0x328(%rbp)
cmpq   $0x0,-0x328(%rbp)
je     39f9 <populate_root+0x2879>
mov    -0x328(%rbp),%rdi
mov    0x2607(%rip),%rax
mov    (%rax),%esi
call   1080 <fputs@plt>
mov    0x25f9(%rip),%rax
mov    (%rax),%eax
mov    %eax,-0x4c0(%rbp)
xor    %edi,%edi
sub    -0x31c(%rbp),%edi
call   10a0 <strerror@plt>
mov    -0x4c0(%rbp),%edi
mov    %rax,%rdx
lea    0x62e(%rip),%rsi
call   1090 <fprintf@plt>
mov    -0x8(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    3cb3 <populate_root+0x2b33>
jmp    3a09 <populate_root+0x2889>
jmp    3a0e <populate_root+0x288e>
mov    0x25c3(%rip),%rax
mov    (%rax),%ecx
lea    0x115b(%rip),%rdi
lea    0x1155(%rip),%rsi
xor    %eax,%eax
mov    %eax,%r8d
mov    %r8,%rdx
call   1060 <mount@plt>
cmp    $0x0,%rax
jge    3a52 <populate_root+0x28d2>
xor    %eax,%eax
mov    0x257b(%rip),%rcx
sub    (%rcx),%eax
mov    %eax,-0x4c4(%rbp)
jmp    3a5f <populate_root+0x28df>
xor    %eax,%eax
mov    %eax,-0x4c4(%rbp)
jmp    3a5f <populate_root+0x28df>
mov    -0x4c4(%rbp),%eax
mov    %eax,-0x8(%rbp)
mov    %eax,-0x32c(%rbp)
cmpl   $0x0,-0x32c(%rbp)
jge    3ae8 <populate_root+0x2968>
lea    0x10fc(%rip),%rax
mov    %rax,-0x338(%rbp)
cmpq   $0x0,-0x338(%rbp)
je     3add <populate_root+0x295d>
mov    -0x338(%rbp),%rdi
mov    0x2523(%rip),%rax
mov    (%rax),%esi
call   1080 <fputs@plt>
mov    0x2515(%rip),%rax
mov    (%rax),%eax
mov    %eax,-0x4c8(%rbp)
xor    %edi,%edi
sub    -0x32c(%rbp),%edi
call   10a0 <strerror@plt>
mov    -0x4c8(%rbp),%edi
mov    %rax,%rdx
lea    0x54a(%rip),%rsi
call   1090 <fprintf@plt>
mov    -0x8(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    3cb3 <populate_root+0x2b33>
jmp    3aed <populate_root+0x296d>
jmp    3af2 <populate_root+0x2972>
lea    0x10af(%rip),%rdi
mov    $0x3ff,%esi
call   1040 <mkdir@plt>
cmp    $0x0,%rax
jge    3b23 <populate_root+0x29a3>
xor    %eax,%eax
mov    0x24aa(%rip),%rcx
sub    (%rcx),%eax
mov    %eax,-0x4cc(%rbp)
jmp    3b30 <populate_root+0x29b0>
xor    %eax,%eax
mov    %eax,-0x4cc(%rbp)
jmp    3b30 <populate_root+0x29b0>
mov    -0x4cc(%rbp),%eax
mov    %eax,-0x8(%rbp)
mov    %eax,-0x33c(%rbp)
cmpl   $0x0,-0x33c(%rbp)
jge    3bb9 <populate_root+0x2a39>
lea    0x1059(%rip),%rax
mov    %rax,-0x348(%rbp)
cmpq   $0x0,-0x348(%rbp)
je     3bae <populate_root+0x2a2e>
mov    -0x348(%rbp),%rdi
mov    0x2452(%rip),%rax
mov    (%rax),%esi
call   1080 <fputs@plt>
mov    0x2444(%rip),%rax
mov    (%rax),%eax
mov    %eax,-0x4d0(%rbp)
xor    %edi,%edi
sub    -0x33c(%rbp),%edi
call   10a0 <strerror@plt>
mov    -0x4d0(%rbp),%edi
mov    %rax,%rdx
lea    0x479(%rip),%rsi
call   1090 <fprintf@plt>
mov    -0x8(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    3cb3 <populate_root+0x2b33>
jmp    3bbe <populate_root+0x2a3e>
jmp    3bc3 <populate_root+0x2a43>
mov    0x2416(%rip),%rax
mov    (%rax),%ecx
mov    0x241d(%rip),%rax
or     (%rax),%ecx
lea    0x849(%rip),%rdx
lea    0xfc5(%rip),%rsi
lea    0xfd6(%rip),%r8
mov    %rdx,%rdi
call   1060 <mount@plt>
cmp    $0x0,%rax
jge    3c12 <populate_root+0x2a92>
xor    %eax,%eax
mov    0x23bb(%rip),%rcx
sub    (%rcx),%eax
mov    %eax,-0x4d4(%rbp)
jmp    3c1f <populate_root+0x2a9f>
xor    %eax,%eax
mov    %eax,-0x4d4(%rbp)
jmp    3c1f <populate_root+0x2a9f>
mov    -0x4d4(%rbp),%eax
mov    %eax,-0x8(%rbp)
mov    %eax,-0x34c(%rbp)
cmpl   $0x0,-0x34c(%rbp)
jge    3ca8 <populate_root+0x2b28>
lea    0xf86(%rip),%rax
mov    %rax,-0x358(%rbp)
cmpq   $0x0,-0x358(%rbp)
je     3c9d <populate_root+0x2b1d>
mov    -0x358(%rbp),%rdi
mov    0x2363(%rip),%rax
mov    (%rax),%esi
call   1080 <fputs@plt>
mov    0x2355(%rip),%rax
mov    (%rax),%eax
mov    %eax,-0x4d8(%rbp)
xor    %edi,%edi
sub    -0x34c(%rbp),%edi
call   10a0 <strerror@plt>
mov    -0x4d8(%rbp),%edi
mov    %rax,%rdx
lea    0x38a(%rip),%rsi
call   1090 <fprintf@plt>
mov    -0x8(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    3cb3 <populate_root+0x2b33>
jmp    3cad <populate_root+0x2b2d>
mov    -0x8(%rbp),%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x4e0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<populate_root>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
lea    0xe6e(%rip),%rdi
lea    0xe6b(%rip),%rsi
call   1070 <symlink@plt>
mov    %rax,%rbx
mov    0x2e18(%rip),%r15
xor    %ebp,%ebp
xor    %r13d,%r13d
sub    (%r15),%r13d
sar    $0x3f,%rbx
and    %r13d,%ebx
js     1ac3 <populate_root+0x943>
lea    0xe3c(%rip),%rdi
lea    0xe5d(%rip),%rsi
call   1070 <symlink@plt>
mov    %rax,%rbx
sub    (%r15),%ebp
sar    $0x3f,%rbx
and    %ebp,%ebx
js     1acf <populate_root+0x94f>
lea    0xe5f(%rip),%rdi
lea    0xe5c(%rip),%rsi
call   1070 <symlink@plt>
mov    %rax,%rbx
xor    %ebp,%ebp
xor    %r13d,%r13d
sub    (%r15),%r13d
sar    $0x3f,%rbx
and    %r13d,%ebx
js     1ade <populate_root+0x95e>
lea    0xe34(%rip),%rdi
lea    0xe4f(%rip),%rsi
call   1070 <symlink@plt>
mov    %rax,%rbx
sub    (%r15),%ebp
sar    $0x3f,%rbx
and    %ebp,%ebx
js     1aea <populate_root+0x96a>
lea    0xe53(%rip),%rdi
mov    $0x1ed,%esi
call   1040 <mkdir@plt>
mov    %rax,%rbx
xor    %ebp,%ebp
xor    %r13d,%r13d
sub    (%r15),%r13d
sar    $0x3f,%rbx
and    %r13d,%ebx
js     1af9 <populate_root+0x979>
lea    0xe41(%rip),%rdi
lea    0xe48(%rip),%rsi
call   1070 <symlink@plt>
mov    %rax,%rbx
sub    (%r15),%ebp
sar    $0x3f,%rbx
and    %ebp,%ebx
js     1b05 <populate_root+0x985>
lea    0xe54(%rip),%rdi
lea    0xe5d(%rip),%rsi
call   1070 <symlink@plt>
mov    %rax,%rbx
xor    %ebp,%ebp
xor    %r13d,%r13d
sub    (%r15),%r13d
sar    $0x3f,%rbx
and    %r13d,%ebx
js     1b14 <populate_root+0x994>
lea    0xe6b(%rip),%rdi
lea    0xe74(%rip),%rsi
call   1070 <symlink@plt>
mov    %rax,%rbx
sub    (%r15),%ebp
sar    $0x3f,%rbx
and    %ebp,%ebx
js     1b20 <populate_root+0x9a0>
lea    0xe8a(%rip),%rdi
lea    0xe93(%rip),%rsi
call   1070 <symlink@plt>
mov    %rax,%rbx
xor    %r13d,%r13d
sub    (%r15),%r13d
sar    $0x3f,%rbx
and    %r13d,%ebx
js     1b2f <populate_root+0x9af>
lea    0xeb8(%rip),%rdi
call   1030 <touch@plt>
test   %eax,%eax
js     1b3b <populate_root+0x9bb>
lea    0xea3(%rip),%rdi
lea    0xe9d(%rip),%rsi
call   1050 <bind_mount@plt>
test   %eax,%eax
js     1b4c <populate_root+0x9cc>
lea    0xecc(%rip),%rdi
call   1030 <touch@plt>
test   %eax,%eax
js     1b5d <populate_root+0x9dd>
lea    0xeb7(%rip),%rdi
lea    0xeb1(%rip),%rsi
call   1050 <bind_mount@plt>
test   %eax,%eax
js     1b6e <populate_root+0x9ee>
lea    0xee0(%rip),%rdi
call   1030 <touch@plt>
test   %eax,%eax
js     1b7f <populate_root+0x9ff>
lea    0xecb(%rip),%rdi
lea    0xec5(%rip),%rsi
call   1050 <bind_mount@plt>
test   %eax,%eax
js     1b90 <populate_root+0xa10>
lea    0xef6(%rip),%rdi
call   1030 <touch@plt>
test   %eax,%eax
js     1ba1 <populate_root+0xa21>
lea    0xee1(%rip),%rdi
lea    0xedb(%rip),%rsi
call   1050 <bind_mount@plt>
test   %eax,%eax
js     1bb2 <populate_root+0xa32>
lea    0xf13(%rip),%rdi
call   1030 <touch@plt>
test   %eax,%eax
js     1bc3 <populate_root+0xa43>
lea    0xefe(%rip),%rdi
lea    0xef8(%rip),%rsi
call   1050 <bind_mount@plt>
test   %eax,%eax
js     1bd4 <populate_root+0xa54>
lea    0xf1d(%rip),%rdi
mov    $0x1ed,%esi
call   1040 <mkdir@plt>
mov    %rax,%rbx
xor    %ebp,%ebp
xor    %r13d,%r13d
sub    (%r15),%r13d
sar    $0x3f,%rbx
and    %r13d,%ebx
js     1be5 <populate_root+0xa65>
lea    0xf0b(%rip),%rdi
lea    0xf18(%rip),%rsi
call   1070 <symlink@plt>
mov    %rax,%rbx
sub    (%r15),%ebp
sar    $0x3f,%rbx
and    %ebp,%ebx
js     1bf1 <populate_root+0xa71>
lea    0xf2e(%rip),%rdi
mov    $0x1ed,%esi
call   1040 <mkdir@plt>
mov    %rax,%rbx
xor    %r14d,%r14d
xor    %r13d,%r13d
sub    (%r15),%r13d
sar    $0x3f,%rbx
and    %r13d,%ebx
js     1c00 <populate_root+0xa80>
mov    0x2b7d(%rip),%rax
mov    0x2b86(%rip),%rcx
mov    (%rcx),%ecx
or     (%rax),%ecx
mov    0x2b3b(%rip),%r12
or     (%r12),%ecx
lea    0xee7(%rip),%rdi
mov    %rdi,%rsi
mov    %rdi,%rdx
xor    %r8d,%r8d
call   1060 <mount@plt>
mov    %rax,%rbx
sub    (%r15),%r14d
sar    $0x3f,%rbx
and    %r14d,%ebx
js     1c0c <populate_root+0xa8c>
lea    0xf1e(%rip),%rdi
mov    $0x1ed,%esi
call   1040 <mkdir@plt>
mov    %rax,%rbx
xor    %ebp,%ebp
xor    %r13d,%r13d
sub    (%r15),%r13d
sar    $0x3f,%rbx
and    %r13d,%ebx
js     1c1b <populate_root+0xa9b>
lea    0xf0c(%rip),%rdi
mov    $0x1ed,%esi
call   1040 <mkdir@plt>
mov    %rax,%rbx
sub    (%r15),%ebp
sar    $0x3f,%rbx
and    %ebp,%ebx
js     1c27 <populate_root+0xaa7>
lea    0xf06(%rip),%rdi
mov    $0x1ed,%esi
call   1040 <mkdir@plt>
mov    %rax,%rbx
xor    %r14d,%r14d
xor    %r13d,%r13d
sub    (%r15),%r13d
sar    $0x3f,%rbx
and    %r13d,%ebx
js     1c36 <populate_root+0xab6>
mov    0x2ad2(%rip),%rax
mov    (%rax),%ecx
mov    0x2ab9(%rip),%rax
or     (%rax),%ecx
or     (%r12),%ecx
lea    0xec6(%rip),%rsi
lea    0xeea(%rip),%rdi
lea    0xee9(%rip),%r8
mov    %rdi,%rdx
call   1060 <mount@plt>
mov    %rax,%rbx
sub    (%r15),%r14d
sar    $0x3f,%rbx
and    %r14d,%ebx
js     1c42 <populate_root+0xac2>
lea    0xf27(%rip),%rdi
mov    $0x1ed,%esi
call   1040 <mkdir@plt>
mov    %rax,%rbx
xor    %r14d,%r14d
xor    %r13d,%r13d
sub    (%r15),%r13d
sar    $0x3f,%rbx
and    %r13d,%ebx
js     1c51 <populate_root+0xad1>
mov    0x2a62(%rip),%rax
mov    (%rax),%ecx
mov    0x2a49(%rip),%rax
or     (%rax),%ecx
or     (%r12),%ecx
lea    0xe5d(%rip),%rdi
lea    0xee0(%rip),%rsi
lea    0xf14(%rip),%rdx
xor    %r8d,%r8d
call   1060 <mount@plt>
mov    %rax,%rbx
sub    (%r15),%r14d
sar    $0x3f,%rbx
and    %r14d,%ebx
js     1c5d <populate_root+0xadd>
lea    0xf56(%rip),%rdi
mov    $0x1ed,%esi
call   1040 <mkdir@plt>
mov    %rax,%rbx
xor    %r14d,%r14d
xor    %r13d,%r13d
sub    (%r15),%r13d
sar    $0x3f,%rbx
and    %r13d,%ebx
js     1c6c <populate_root+0xaec>
mov    0x29f2(%rip),%rax
mov    (%rax),%ecx
mov    0x29d9(%rip),%rax
or     (%rax),%ecx
or     (%r12),%ecx
lea    0xf16(%rip),%rsi
lea    0xde6(%rip),%rdi
lea    0xf16(%rip),%r8
mov    %rdi,%rdx
call   1060 <mount@plt>
mov    %rax,%rbx
sub    (%r15),%r14d
sar    $0x3f,%rbx
and    %r14d,%ebx
js     1c78 <populate_root+0xaf8>
lea    0xf87(%rip),%rdi
mov    $0x1ed,%esi
call   1040 <mkdir@plt>
mov    %rax,%rbx
xor    %r14d,%r14d
xor    %r13d,%r13d
sub    (%r15),%r13d
sar    $0x3f,%rbx
and    %r13d,%ebx
js     1c81 <populate_root+0xb01>
mov    0x2982(%rip),%rax
mov    (%rax),%ecx
mov    0x2969(%rip),%rax
or     (%rax),%ecx
or     (%r12),%ecx
lea    0xf47(%rip),%rsi
lea    0xd76(%rip),%rdi
lea    0xf47(%rip),%r8
mov    %rdi,%rdx
call   1060 <mount@plt>
mov    %rax,%rbx
sub    (%r15),%r14d
sar    $0x3f,%rbx
and    %r14d,%ebx
js     1c8d <populate_root+0xb0d>
lea    0xfc8(%rip),%rdi
mov    $0x1ed,%esi
call   1040 <mkdir@plt>
mov    %rax,%rbx
xor    %r14d,%r14d
xor    %r13d,%r13d
sub    (%r15),%r13d
sar    $0x3f,%rbx
and    %r13d,%ebx
js     1c96 <populate_root+0xb16>
mov    0x2912(%rip),%rax
mov    (%rax),%ecx
mov    0x28f9(%rip),%rax
or     (%rax),%ecx
or     (%r12),%ecx
lea    0xf88(%rip),%rsi
lea    0xd06(%rip),%rdi
lea    0xf88(%rip),%r8
mov    %rdi,%rdx
call   1060 <mount@plt>
mov    %rax,%rbx
sub    (%r15),%r14d
sar    $0x3f,%rbx
and    %r14d,%ebx
js     1ca2 <populate_root+0xb22>
lea    0xff5(%rip),%rdi
mov    $0x1ed,%esi
call   1040 <mkdir@plt>
mov    %rax,%rbx
xor    %r14d,%r14d
xor    %r13d,%r13d
sub    (%r15),%r13d
sar    $0x3f,%rbx
and    %r13d,%ebx
js     1cab <populate_root+0xb2b>
mov    0x28a2(%rip),%rax
mov    (%rax),%ecx
mov    0x2889(%rip),%rax
or     (%rax),%ecx
or     (%r12),%ecx
lea    0xfb5(%rip),%rsi
lea    0xc96(%rip),%rdi
lea    0xfb5(%rip),%r8
mov    %rdi,%rdx
call   1060 <mount@plt>
mov    %rax,%rbx
sub    (%r15),%r14d
sar    $0x3f,%rbx
and    %r14d,%ebx
js     1cb7 <populate_root+0xb37>
lea    0x104a(%rip),%rdi
mov    $0x1ed,%esi
call   1040 <mkdir@plt>
mov    %rax,%rbx
xor    %r14d,%r14d
xor    %r13d,%r13d
sub    (%r15),%r13d
sar    $0x3f,%rbx
and    %r13d,%ebx
js     1cc0 <populate_root+0xb40>
mov    0x2832(%rip),%rax
mov    (%rax),%ecx
mov    0x2819(%rip),%rax
or     (%rax),%ecx
or     (%r12),%ecx
lea    0x100a(%rip),%rsi
lea    0xc26(%rip),%rdi
lea    0x100a(%rip),%r8
mov    %rdi,%rdx
call   1060 <mount@plt>
mov    %rax,%rbx
sub    (%r15),%r14d
sar    $0x3f,%rbx
and    %r14d,%ebx
js     1ccc <populate_root+0xb4c>
lea    0x106f(%rip),%rdi
mov    $0x1ed,%esi
call   1040 <mkdir@plt>
mov    %rax,%rbx
xor    %r14d,%r14d
xor    %r13d,%r13d
sub    (%r15),%r13d
sar    $0x3f,%rbx
and    %r13d,%ebx
js     1cd8 <populate_root+0xb58>
mov    0x27c2(%rip),%rax
mov    (%rax),%ecx
mov    0x27a9(%rip),%rax
or     (%rax),%ecx
or     (%r12),%ecx
lea    0x102f(%rip),%rsi
lea    0xbb6(%rip),%rdi
lea    0x102f(%rip),%r8
mov    %rdi,%rdx
call   1060 <mount@plt>
mov    %rax,%rbx
sub    (%r15),%r14d
sar    $0x3f,%rbx
and    %r14d,%ebx
js     1ce1 <populate_root+0xb61>
lea    0x1098(%rip),%rdi
mov    $0x1ed,%esi
call   1040 <mkdir@plt>
mov    %rax,%rbx
xor    %r14d,%r14d
xor    %r13d,%r13d
sub    (%r15),%r13d
sar    $0x3f,%rbx
and    %r13d,%ebx
js     1ced <populate_root+0xb6d>
mov    0x2752(%rip),%rax
mov    (%rax),%ecx
mov    0x2739(%rip),%rax
or     (%rax),%ecx
or     (%r12),%ecx
lea    0x1058(%rip),%rsi
lea    0xb46(%rip),%rdi
lea    0x1058(%rip),%r8
mov    %rdi,%rdx
call   1060 <mount@plt>
mov    %rax,%rbx
sub    (%r15),%r14d
sar    $0x3f,%rbx
and    %r14d,%ebx
js     1cf6 <populate_root+0xb76>
lea    0x10c9(%rip),%rdi
mov    $0x1ed,%esi
call   1040 <mkdir@plt>
mov    %rax,%rbx
xor    %r14d,%r14d
xor    %r13d,%r13d
sub    (%r15),%r13d
sar    $0x3f,%rbx
and    %r13d,%ebx
js     1d02 <populate_root+0xb82>
mov    0x26e2(%rip),%rax
mov    (%rax),%ecx
mov    0x26c9(%rip),%rax
or     (%rax),%ecx
or     (%r12),%ecx
lea    0x1089(%rip),%rsi
lea    0xad6(%rip),%rdi
lea    0x1089(%rip),%r8
mov    %rdi,%rdx
call   1060 <mount@plt>
mov    %rax,%rbx
sub    (%r15),%r14d
sar    $0x3f,%rbx
and    %r14d,%ebx
js     1d0b <populate_root+0xb8b>
lea    0xc85(%rip),%rdi
lea    0x10ef(%rip),%rsi
call   1070 <symlink@plt>
mov    %rax,%rbx
xor    %ebp,%ebp
xor    %r13d,%r13d
sub    (%r15),%r13d
sar    $0x3f,%rbx
and    %r13d,%ebx
js     1d17 <populate_root+0xb97>
lea    0xc5a(%rip),%rdi
lea    0x1102(%rip),%rsi
call   1070 <symlink@plt>
mov    %rax,%rbx
sub    (%r15),%ebp
sar    $0x3f,%rbx
and    %ebp,%ebx
js     1d20 <populate_root+0xba0>
lea    0xd83(%rip),%rdi
lea    0x1123(%rip),%rsi
call   1070 <symlink@plt>
mov    %rax,%rbx
xor    %ebp,%ebp
xor    %r13d,%r13d
sub    (%r15),%r13d
sar    $0x3f,%rbx
and    %r13d,%ebx
js     1d2c <populate_root+0xbac>
lea    0xd58(%rip),%rdi
lea    0x1143(%rip),%rsi
call   1070 <symlink@plt>
mov    %rax,%rbx
sub    (%r15),%ebp
sar    $0x3f,%rbx
and    %ebp,%ebx
js     1d35 <populate_root+0xbb5>
lea    0x1186(%rip),%rdi
mov    $0x1ed,%esi
call   1040 <mkdir@plt>
mov    %rax,%rbx
xor    %r14d,%r14d
xor    %r13d,%r13d
sub    (%r15),%r13d
sar    $0x3f,%rbx
and    %r13d,%ebx
js     1d41 <populate_root+0xbc1>
mov    0x25ba(%rip),%rax
mov    (%rax),%ecx
lea    0x1152(%rip),%rdi
lea    0x114c(%rip),%rsi
xor    %edx,%edx
xor    %r8d,%r8d
call   1060 <mount@plt>
mov    %rax,%rbx
sub    (%r15),%r14d
sar    $0x3f,%rbx
and    %r14d,%ebx
js     1d4a <populate_root+0xbca>
lea    0x1156(%rip),%rdi
mov    $0x3ff,%esi
call   1040 <mkdir@plt>
mov    %rax,%rbx
xor    %r14d,%r14d
xor    %r13d,%r13d
sub    (%r15),%r13d
sar    $0x3f,%rbx
and    %r13d,%ebx
js     1d56 <populate_root+0xbd6>
mov    0x2574(%rip),%rax
mov    (%rax),%ecx
mov    0x255b(%rip),%rax
or     (%rax),%ecx
lea    0x111a(%rip),%rsi
lea    0x990(%rip),%rdi
lea    0x1124(%rip),%r8
mov    %rdi,%rdx
call   1060 <mount@plt>
mov    %rax,%rbx
sub    (%r15),%r14d
sar    $0x3f,%rbx
and    %r14d,%ebx
jns    1d8c <populate_root+0xc0c>
lea    0x110a(%rip),%rdi
jmp    1c49 <populate_root+0xac9>
lea    0x53e(%rip),%rdi
jmp    1d5d <populate_root+0xbdd>
lea    0x557(%rip),%rdi
mov    %ebp,%r13d
jmp    1d5d <populate_root+0xbdd>
lea    0x56b(%rip),%rdi
jmp    1d5d <populate_root+0xbdd>
lea    0x57f(%rip),%rdi
mov    %ebp,%r13d
jmp    1d5d <populate_root+0xbdd>
lea    0x590(%rip),%rdi
jmp    1d5d <populate_root+0xbdd>
lea    0x5ac(%rip),%rdi
mov    %ebp,%r13d
jmp    1d5d <populate_root+0xbdd>
lea    0x5da(%rip),%rdi
jmp    1d5d <populate_root+0xbdd>
lea    0x611(%rip),%rdi
mov    %ebp,%r13d
jmp    1d5d <populate_root+0xbdd>
lea    0x646(%rip),%rdi
jmp    1d5d <populate_root+0xbdd>
mov    %eax,%ebx
lea    0x661(%rip),%rdi
mov    %eax,%r13d
jmp    1d5d <populate_root+0xbdd>
mov    %eax,%ebx
lea    0x66c(%rip),%rdi
mov    %eax,%r13d
jmp    1d5d <populate_root+0xbdd>
mov    %eax,%ebx
lea    0x682(%rip),%rdi
mov    %eax,%r13d
jmp    1d5d <populate_root+0xbdd>
mov    %eax,%ebx
lea    0x68d(%rip),%rdi
mov    %eax,%r13d
jmp    1d5d <populate_root+0xbdd>
mov    %eax,%ebx
lea    0x6a3(%rip),%rdi
mov    %eax,%r13d
jmp    1d5d <populate_root+0xbdd>
mov    %eax,%ebx
lea    0x6ae(%rip),%rdi
mov    %eax,%r13d
jmp    1d5d <populate_root+0xbdd>
mov    %eax,%ebx
lea    0x6c4(%rip),%rdi
mov    %eax,%r13d
jmp    1d5d <populate_root+0xbdd>
mov    %eax,%ebx
lea    0x6d3(%rip),%rdi
mov    %eax,%r13d
jmp    1d5d <populate_root+0xbdd>
mov    %eax,%ebx
lea    0x6ed(%rip),%rdi
mov    %eax,%r13d
jmp    1d5d <populate_root+0xbdd>
mov    %eax,%ebx
lea    0x6fe(%rip),%rdi
mov    %eax,%r13d
jmp    1d5d <populate_root+0xbdd>
lea    0x720(%rip),%rdi
jmp    1d5d <populate_root+0xbdd>
lea    0x744(%rip),%rdi
mov    %ebp,%r13d
jmp    1d5d <populate_root+0xbdd>
lea    0x765(%rip),%rdi
jmp    1d5d <populate_root+0xbdd>
lea    0x76d(%rip),%rdi
mov    %r14d,%r13d
jmp    1d5d <populate_root+0xbdd>
lea    0x7a8(%rip),%rdi
jmp    1d5d <populate_root+0xbdd>
lea    0x7b6(%rip),%rdi
mov    %ebp,%r13d
jmp    1d5d <populate_root+0xbdd>
lea    0x7cb(%rip),%rdi
jmp    1d5d <populate_root+0xbdd>
lea    0x7eb(%rip),%rdi
mov    %r14d,%r13d
jmp    1d5d <populate_root+0xbdd>
lea    0x849(%rip),%rdi
jmp    1d5d <populate_root+0xbdd>
lea    0x86a(%rip),%rdi
mov    %r14d,%r13d
jmp    1d5d <populate_root+0xbdd>
lea    0x8cd(%rip),%rdi
jmp    1d5d <populate_root+0xbdd>
lea    0x8e9(%rip),%rdi
jmp    1c49 <populate_root+0xac9>
lea    0x95d(%rip),%rdi
jmp    1d5d <populate_root+0xbdd>
lea    0x97d(%rip),%rdi
jmp    1c49 <populate_root+0xac9>
lea    0x9f4(%rip),%rdi
jmp    1d5d <populate_root+0xbdd>
lea    0xa0f(%rip),%rdi
jmp    1c49 <populate_root+0xac9>
lea    0xa86(%rip),%rdi
jmp    1d5d <populate_root+0xbdd>
lea    0xaab(%rip),%rdi
jmp    1c49 <populate_root+0xac9>
lea    0xb2a(%rip),%rdi
jmp    1d5d <populate_root+0xbdd>
lea    0xb43(%rip),%rdi
jmp    1c49 <populate_root+0xac9>
lea    0xba8(%rip),%rdi
jmp    1d5d <populate_root+0xbdd>
lea    0xbc5(%rip),%rdi
jmp    1c49 <populate_root+0xac9>
lea    0xc2e(%rip),%rdi
jmp    1d5d <populate_root+0xbdd>
lea    0xc4d(%rip),%rdi
jmp    1c49 <populate_root+0xac9>
lea    0xcb9(%rip),%rdi
jmp    1d5d <populate_root+0xbdd>
lea    0xcd7(%rip),%rdi
jmp    1c49 <populate_root+0xac9>
lea    0xd3e(%rip),%rdi
jmp    1d5d <populate_root+0xbdd>
lea    0xd77(%rip),%rdi
mov    %ebp,%r13d
jmp    1d5d <populate_root+0xbdd>
lea    0xdb1(%rip),%rdi
jmp    1d5d <populate_root+0xbdd>
lea    0xdf4(%rip),%rdi
mov    %ebp,%r13d
jmp    1d5d <populate_root+0xbdd>
lea    0xe1e(%rip),%rdi
jmp    1d5d <populate_root+0xbdd>
lea    0xe2d(%rip),%rdi
mov    %r14d,%r13d
jmp    1d5d <populate_root+0xbdd>
lea    0xe4f(%rip),%rdi
mov    0x2264(%rip),%rbp
mov    0x0(%rbp),%esi
call   1080 <fputs@plt>
mov    0x0(%rbp),%ebp
neg    %ebx
mov    %ebx,%edi
call   10a0 <strerror@plt>
lea    0x2a3(%rip),%rsi
mov    %ebp,%edi
mov    %rax,%rdx
call   1090 <fprintf@plt>
mov    %r13d,%ebx
mov    %ebx,%eax
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [8 x i8] c"usr/bin\00"
@.str.1 = [4 x i8] c"bin\00"
@errno = global i32 0
@.str.2 = [26 x i8] c"symlink(\22usr/bin\22, \22bin\22)\00"
@stderr = global i32 0
@.str.3 = [6 x i8] c": %s\0A\00"
@.str.4 = [5 x i8] c"sbin\00"
@.str.5 = [27 x i8] c"symlink(\22usr/bin\22, \22sbin\22)\00"
@.str.6 = [8 x i8] c"usr/lib\00"
@.str.7 = [4 x i8] c"lib\00"
@.str.8 = [26 x i8] c"symlink(\22usr/lib\22, \22lib\22)\00"
@.str.9 = [6 x i8] c"lib64\00"
@.str.10 = [28 x i8] c"symlink(\22usr/lib\22, \22lib64\22)\00"
@.str.11 = [4 x i8] c"dev\00"
@.str.12 = [19 x i8] c"mkdir(\22dev\22, 0755)\00"
@.str.13 = [14 x i8] c"/proc/self/fd\00"
@.str.14 = [7 x i8] c"dev/fd\00"
@.str.15 = [35 x i8] c"symlink(\22/proc/self/fd\22, \22dev/fd\22)\00"
@.str.16 = [16 x i8] c"/proc/self/fd/0\00"
@.str.17 = [10 x i8] c"dev/stdin\00"
@.str.18 = [40 x i8] c"symlink(\22/proc/self/fd/0\22, \22dev/stdin\22)\00"
@.str.19 = [16 x i8] c"/proc/self/fd/1\00"
@.str.20 = [11 x i8] c"dev/stdout\00"
@.str.21 = [41 x i8] c"symlink(\22/proc/self/fd/1\22, \22dev/stdout\22)\00"
@.str.22 = [16 x i8] c"/proc/self/fd/2\00"
@.str.23 = [11 x i8] c"dev/stderr\00"
@.str.24 = [41 x i8] c"symlink(\22/proc/self/fd/2\22, \22dev/stderr\22)\00"
@.str.25 = [9 x i8] c"dev/null\00"
@.str.26 = [18 x i8] c"touch(\22dev/null\22)\00"
@.str.27 = [10 x i8] c"/dev/null\00"
@.str.28 = [39 x i8] c"bind_mount(\22/\22 \22dev/null\22, \22dev/null\22)\00"
@.str.29 = [9 x i8] c"dev/zero\00"
@.str.30 = [18 x i8] c"touch(\22dev/zero\22)\00"
@.str.31 = [10 x i8] c"/dev/zero\00"
@.str.32 = [39 x i8] c"bind_mount(\22/\22 \22dev/zero\22, \22dev/zero\22)\00"
@.str.33 = [9 x i8] c"dev/full\00"
@.str.34 = [18 x i8] c"touch(\22dev/full\22)\00"
@.str.35 = [10 x i8] c"/dev/full\00"
@.str.36 = [39 x i8] c"bind_mount(\22/\22 \22dev/full\22, \22dev/full\22)\00"
@.str.37 = [11 x i8] c"dev/random\00"
@.str.38 = [20 x i8] c"touch(\22dev/random\22)\00"
@.str.39 = [12 x i8] c"/dev/random\00"
@.str.40 = [43 x i8] c"bind_mount(\22/\22 \22dev/random\22, \22dev/random\22)\00"
@.str.41 = [12 x i8] c"dev/urandom\00"
@.str.42 = [21 x i8] c"touch(\22dev/urandom\22)\00"
@.str.43 = [13 x i8] c"/dev/urandom\00"
@.str.44 = [45 x i8] c"bind_mount(\22/\22 \22dev/urandom\22, \22dev/urandom\22)\00"
@.str.45 = [4 x i8] c"etc\00"
@.str.46 = [19 x i8] c"mkdir(\22etc\22, 0755)\00"
@.str.47 = [20 x i8] c"../proc/self/mounts\00"
@.str.48 = [9 x i8] c"etc/mtab\00"
@.str.49 = [43 x i8] c"symlink(\22../proc/self/mounts\22, \22etc/mtab\22)\00"
@.str.50 = [5 x i8] c"proc\00"
@.str.51 = [20 x i8] c"mkdir(\22proc\22, 0755)\00"
@MS_NOSUID = global i32 0
@MS_NODEV = global i32 0
@MS_NOEXEC = global i32 0
@.str.52 = [70 x i8] c"mount(\22proc\22, \22proc\22, \22proc\22, MS_NOSUID | MS_NODEV | MS_NOEXEC, NULL)\00"
@.str.53 = [4 x i8] c"sys\00"
@.str.54 = [19 x i8] c"mkdir(\22sys\22, 0755)\00"
@.str.55 = [7 x i8] c"sys/fs\00"
@.str.56 = [22 x i8] c"mkdir(\22sys/fs\22, 0755)\00"
@.str.57 = [14 x i8] c"sys/fs/cgroup\00"
@.str.58 = [29 x i8] c"mkdir(\22sys/fs/cgroup\22, 0755)\00"
@.str.59 = [6 x i8] c"tmpfs\00"
@.str.60 = [9 x i8] c"mode=755\00"
@.str.61 = [87 x i8] c"mount(\22tmpfs\22, \22sys/fs/cgroup\22, \22tmpfs\22, MS_NOSUID | MS_NODEV | MS_NOEXEC, \22mode=755\22)\00"
@.str.62 = [22 x i8] c"sys/fs/cgroup/unified\00"
@.str.63 = [37 x i8] c"mkdir(\22sys/fs/cgroup/unified\22, 0755)\00"
@.str.64 = [7 x i8] c"cgroup\00"
@.str.65 = [8 x i8] c"cgroup2\00"
@.str.66 = [92 x i8] c"mount(\22cgroup\22, \22sys/fs/cgroup/unified\22, \22cgroup2\22, MS_NOSUID | MS_NODEV | MS_NOEXEC, NULL)\00"
@.str.67 = [22 x i8] c"sys/fs/cgroup/freezer\00"
@.str.68 = [40 x i8] c"mkdir(\22sys/fs/cgroup/\22 \22freezer\22, 0755)\00"
@.str.69 = [8 x i8] c"freezer\00"
@.str.70 = [99 x i8] c"mount(\22cgroup\22, \22sys/fs/cgroup/\22 \22freezer\22, \22cgroup\22, MS_NOSUID | MS_NODEV | MS_NOEXEC, \22freezer\22)\00"
@.str.71 = [26 x i8] c"sys/fs/cgroup/cpu,cpuacct\00"
@.str.72 = [44 x i8] c"mkdir(\22sys/fs/cgroup/\22 \22cpu,cpuacct\22, 0755)\00"
@.str.73 = [12 x i8] c"cpu,cpuacct\00"
@.str.74 = [107 x i8] c"mount(\22cgroup\22, \22sys/fs/cgroup/\22 \22cpu,cpuacct\22, \22cgroup\22, MS_NOSUID | MS_NODEV | MS_NOEXEC, \22cpu,cpuacct\22)\00"
@.str.75 = [21 x i8] c"sys/fs/cgroup/cpuset\00"
@.str.76 = [39 x i8] c"mkdir(\22sys/fs/cgroup/\22 \22cpuset\22, 0755)\00"
@.str.77 = [7 x i8] c"cpuset\00"
@.str.78 = [97 x i8] c"mount(\22cgroup\22, \22sys/fs/cgroup/\22 \22cpuset\22, \22cgroup\22, MS_NOSUID | MS_NODEV | MS_NOEXEC, \22cpuset\22)\00"
@.str.79 = [31 x i8] c"sys/fs/cgroup/net_cls,net_prio\00"
@.str.80 = [49 x i8] c"mkdir(\22sys/fs/cgroup/\22 \22net_cls,net_prio\22, 0755)\00"
@.str.81 = [17 x i8] c"net_cls,net_prio\00"
@.str.82 = [117 x i8] c"mount(\22cgroup\22, \22sys/fs/cgroup/\22 \22net_cls,net_prio\22, \22cgroup\22, MS_NOSUID | MS_NODEV | MS_NOEXEC, \22net_cls,net_prio\22)\00"
@.str.83 = [19 x i8] c"sys/fs/cgroup/pids\00"
@.str.84 = [37 x i8] c"mkdir(\22sys/fs/cgroup/\22 \22pids\22, 0755)\00"
@.str.85 = [5 x i8] c"pids\00"
@.str.86 = [93 x i8] c"mount(\22cgroup\22, \22sys/fs/cgroup/\22 \22pids\22, \22cgroup\22, MS_NOSUID | MS_NODEV | MS_NOEXEC, \22pids\22)\00"
@.str.87 = [20 x i8] c"sys/fs/cgroup/blkio\00"
@.str.88 = [38 x i8] c"mkdir(\22sys/fs/cgroup/\22 \22blkio\22, 0755)\00"
@.str.89 = [6 x i8] c"blkio\00"
@.str.90 = [95 x i8] c"mount(\22cgroup\22, \22sys/fs/cgroup/\22 \22blkio\22, \22cgroup\22, MS_NOSUID | MS_NODEV | MS_NOEXEC, \22blkio\22)\00"
@.str.91 = [22 x i8] c"sys/fs/cgroup/devices\00"
@.str.92 = [40 x i8] c"mkdir(\22sys/fs/cgroup/\22 \22devices\22, 0755)\00"
@.str.93 = [8 x i8] c"devices\00"
@.str.94 = [99 x i8] c"mount(\22cgroup\22, \22sys/fs/cgroup/\22 \22devices\22, \22cgroup\22, MS_NOSUID | MS_NODEV | MS_NOEXEC, \22devices\22)\00"
@.str.95 = [21 x i8] c"sys/fs/cgroup/memory\00"
@.str.96 = [39 x i8] c"mkdir(\22sys/fs/cgroup/\22 \22memory\22, 0755)\00"
@.str.97 = [7 x i8] c"memory\00"
@.str.98 = [97 x i8] c"mount(\22cgroup\22, \22sys/fs/cgroup/\22 \22memory\22, \22cgroup\22, MS_NOSUID | MS_NODEV | MS_NOEXEC, \22memory\22)\00"
@.str.99 = [18 x i8] c"sys/fs/cgroup/cpu\00"
@.str.100 = [44 x i8] c"symlink(\22cpu,cpuacct\22, \22sys/fs/cgroup/cpu\22)\00"
@.str.101 = [22 x i8] c"sys/fs/cgroup/cpuacct\00"
@.str.102 = [48 x i8] c"symlink(\22cpu,cpuacct\22, \22sys/fs/cgroup/cpuacct\22)\00"
@.str.103 = [22 x i8] c"sys/fs/cgroup/net_cls\00"
@.str.104 = [53 x i8] c"symlink(\22net_cls,net_prio\22, \22sys/fs/cgroup/net_cls\22)\00"
@.str.105 = [23 x i8] c"sys/fs/cgroup/net_prio\00"
@.str.106 = [54 x i8] c"symlink(\22net_cls,net_prio\22, \22sys/fs/cgroup/net_prio\22)\00"
@.str.107 = [4 x i8] c"usr\00"
@.str.108 = [19 x i8] c"mkdir(\22usr\22, 0755)\00"
@.str.109 = [5 x i8] c"/usr\00"
@MS_BIND = global i32 0
@.str.110 = [42 x i8] c"mount(\22/usr\22, \22usr\22, NULL, MS_BIND, NULL)\00"
@.str.111 = [4 x i8] c"tmp\00"
@.str.112 = [20 x i8] c"mkdir(\22tmp\22, 01777)\00"
@.str.113 = [8 x i8] c"size=1g\00"
@.str.114 = [64 x i8] c"mount(\22tmpfs\22, \22tmp\22, \22tmpfs\22, MS_NOSUID | MS_NODEV, \22size=1g\22)\00"
define i32 @populate_root() {
%1 = alloca i32
%2 = alloca i32
%3 = alloca i32
%4 = alloca i8*
%5 = alloca i32
%6 = alloca i8*
%7 = alloca i32
%8 = alloca i8*
%9 = alloca i32
%10 = alloca i8*
%11 = alloca i32
%12 = alloca i8*
%13 = alloca i32
%14 = alloca i8*
%15 = alloca i32
%16 = alloca i8*
%17 = alloca i32
%18 = alloca i8*
%19 = alloca i32
%20 = alloca i8*
%21 = alloca i32
%22 = alloca i8*
%23 = alloca i32
%24 = alloca i8*
%25 = alloca i32
%26 = alloca i8*
%27 = alloca i32
%28 = alloca i8*
%29 = alloca i32
%30 = alloca i8*
%31 = alloca i32
%32 = alloca i8*
%33 = alloca i32
%34 = alloca i8*
%35 = alloca i32
%36 = alloca i8*
%37 = alloca i32
%38 = alloca i8*
%39 = alloca i32
%40 = alloca i8*
%41 = alloca i32
%42 = alloca i8*
%43 = alloca i32
%44 = alloca i8*
%45 = alloca i32
%46 = alloca i8*
%47 = alloca i32
%48 = alloca i8*
%49 = alloca i32
%50 = alloca i8*
%51 = alloca i32
%52 = alloca i8*
%53 = alloca i32
%54 = alloca i8*
%55 = alloca i32
%56 = alloca i8*
%57 = alloca i32
%58 = alloca i8*
%59 = alloca i32
%60 = alloca i8*
%61 = alloca i32
%62 = alloca i8*
%63 = alloca i32
%64 = alloca i8*
%65 = alloca i32
%66 = alloca i8*
%67 = alloca i32
%68 = alloca i8*
%69 = alloca i32
%70 = alloca i8*
%71 = alloca i32
%72 = alloca i8*
%73 = alloca i32
%74 = alloca i8*
%75 = alloca i32
%76 = alloca i8*
%77 = alloca i32
%78 = alloca i8*
%79 = alloca i32
%80 = alloca i8*
%81 = alloca i32
%82 = alloca i8*
%83 = alloca i32
%84 = alloca i8*
%85 = alloca i32
%86 = alloca i8*
%87 = alloca i32
%88 = alloca i8*
%89 = alloca i32
%90 = alloca i8*
%91 = alloca i32
%92 = alloca i8*
%93 = alloca i32
%94 = alloca i8*
%95 = alloca i32
%96 = alloca i8*
%97 = alloca i32
%98 = alloca i8*
%99 = alloca i32
%100 = alloca i8*
%101 = alloca i32
%102 = alloca i8*
%103 = alloca i32
%104 = alloca i8*
%105 = alloca i32
%106 = alloca i8*
%107 = alloca i32
%108 = alloca i8*
br label %109
109: ; preds = %0
%110 = call i64 @symlink(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0))
%111 = icmp slt i64 %110, 0
br i1 %111, label %112, label %115
112: ; preds = %109
%113 = load i32, i32* @errno
%114 = sub nsw i32 0, %113
br label %116
115: ; preds = %109
br label %116
116: ; preds = %115, %112
%117 = phi i32 [ %114, %112 ], [ 0, %115 ]
store i32 %117, i32* %2
store i32 %117, i32* %3
%118 = load i32, i32* %3
%119 = icmp slt i32 %118, 0
br i1 %119, label %120, label %134
120: ; preds = %116
store i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str.2, i64 0, i64 0), i8** %4
%121 = load i8*, i8** %4
%122 = icmp ne i8* %121, null
br i1 %122, label %123, label %132
123: ; preds = %120
%124 = load i8*, i8** %4
%125 = load i32, i32* @stderr
%126 = call i32 @fputs(i8* %124, i32 %125)
%127 = load i32, i32* @stderr
%128 = load i32, i32* %3
%129 = sub nsw i32 0, %128
%130 = call i8* @strerror(i32 %129)
%131 = call i32 @fprintf(i32 %127, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.3, i64 0, i64 0), i8* %130)
br label %132
132: ; preds = %123, %120
%133 = load i32, i32* %2
store i32 %133, i32* %1
br label %1556
134: ; preds = %116
br label %135
135: ; preds = %134
br label %136
136: ; preds = %135
%137 = call i64 @symlink(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.4, i64 0, i64 0))
%138 = icmp slt i64 %137, 0
br i1 %138, label %139, label %142
139: ; preds = %136
%140 = load i32, i32* @errno
%141 = sub nsw i32 0, %140
br label %143
142: ; preds = %136
br label %143
143: ; preds = %142, %139
%144 = phi i32 [ %141, %139 ], [ 0, %142 ]
store i32 %144, i32* %2
store i32 %144, i32* %5
%145 = load i32, i32* %5
%146 = icmp slt i32 %145, 0
br i1 %146, label %147, label %161
147: ; preds = %143
store i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.str.5, i64 0, i64 0), i8** %6
%148 = load i8*, i8** %6
%149 = icmp ne i8* %148, null
br i1 %149, label %150, label %159
150: ; preds = %147
%151 = load i8*, i8** %6
%152 = load i32, i32* @stderr
%153 = call i32 @fputs(i8* %151, i32 %152)
%154 = load i32, i32* @stderr
%155 = load i32, i32* %5
%156 = sub nsw i32 0, %155
%157 = call i8* @strerror(i32 %156)
%158 = call i32 @fprintf(i32 %154, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.3, i64 0, i64 0), i8* %157)
br label %159
159: ; preds = %150, %147
%160 = load i32, i32* %2
store i32 %160, i32* %1
br label %1556
161: ; preds = %143
br label %162
162: ; preds = %161
br label %163
163: ; preds = %162
%164 = call i64 @symlink(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.6, i64 0, i64 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.7, i64 0, i64 0))
%165 = icmp slt i64 %164, 0
br i1 %165, label %166, label %169
166: ; preds = %163
%167 = load i32, i32* @errno
%168 = sub nsw i32 0, %167
br label %170
169: ; preds = %163
br label %170
170: ; preds = %169, %166
%171 = phi i32 [ %168, %166 ], [ 0, %169 ]
store i32 %171, i32* %2
store i32 %171, i32* %7
%172 = load i32, i32* %7
%173 = icmp slt i32 %172, 0
br i1 %173, label %174, label %188
174: ; preds = %170
store i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str.8, i64 0, i64 0), i8** %8
%175 = load i8*, i8** %8
%176 = icmp ne i8* %175, null
br i1 %176, label %177, label %186
177: ; preds = %174
%178 = load i8*, i8** %8
%179 = load i32, i32* @stderr
%180 = call i32 @fputs(i8* %178, i32 %179)
%181 = load i32, i32* @stderr
%182 = load i32, i32* %7
%183 = sub nsw i32 0, %182
%184 = call i8* @strerror(i32 %183)
%185 = call i32 @fprintf(i32 %181, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.3, i64 0, i64 0), i8* %184)
br label %186
186: ; preds = %177, %174
%187 = load i32, i32* %2
store i32 %187, i32* %1
br label %1556
188: ; preds = %170
br label %189
189: ; preds = %188
br label %190
190: ; preds = %189
%191 = call i64 @symlink(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.6, i64 0, i64 0), i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.9, i64 0, i64 0))
%192 = icmp slt i64 %191, 0
br i1 %192, label %193, label %196
193: ; preds = %190
%194 = load i32, i32* @errno
%195 = sub nsw i32 0, %194
br label %197
196: ; preds = %190
br label %197
197: ; preds = %196, %193
%198 = phi i32 [ %195, %193 ], [ 0, %196 ]
store i32 %198, i32* %2
store i32 %198, i32* %9
%199 = load i32, i32* %9
%200 = icmp slt i32 %199, 0
br i1 %200, label %201, label %215
201: ; preds = %197
store i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str.10, i64 0, i64 0), i8** %10
%202 = load i8*, i8** %10
%203 = icmp ne i8* %202, null
br i1 %203, label %204, label %213
204: ; preds = %201
%205 = load i8*, i8** %10
%206 = load i32, i32* @stderr
%207 = call i32 @fputs(i8* %205, i32 %206)
%208 = load i32, i32* @stderr
%209 = load i32, i32* %9
%210 = sub nsw i32 0, %209
%211 = call i8* @strerror(i32 %210)
%212 = call i32 @fprintf(i32 %208, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.3, i64 0, i64 0), i8* %211)
br label %213
213: ; preds = %204, %201
%214 = load i32, i32* %2
store i32 %214, i32* %1
br label %1556
215: ; preds = %197
br label %216
216: ; preds = %215
br label %217
217: ; preds = %216
%218 = call i64 @mkdir(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.11, i64 0, i64 0), i32 493)
%219 = icmp slt i64 %218, 0
br i1 %219, label %220, label %223
220: ; preds = %217
%221 = load i32, i32* @errno
%222 = sub nsw i32 0, %221
br label %224
223: ; preds = %217
br label %224
224: ; preds = %223, %220
%225 = phi i32 [ %222, %220 ], [ 0, %223 ]
store i32 %225, i32* %2
store i32 %225, i32* %11
%226 = load i32, i32* %11
%227 = icmp slt i32 %226, 0
br i1 %227, label %228, label %242
228: ; preds = %224
store i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.12, i64 0, i64 0), i8** %12
%229 = load i8*, i8** %12
%230 = icmp ne i8* %229, null
br i1 %230, label %231, label %240
231: ; preds = %228
%232 = load i8*, i8** %12
%233 = load i32, i32* @stderr
%234 = call i32 @fputs(i8* %232, i32 %233)
%235 = load i32, i32* @stderr
%236 = load i32, i32* %11
%237 = sub nsw i32 0, %236
%238 = call i8* @strerror(i32 %237)
%239 = call i32 @fprintf(i32 %235, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.3, i64 0, i64 0), i8* %238)
br label %240
240: ; preds = %231, %228
%241 = load i32, i32* %2
store i32 %241, i32* %1
br label %1556
242: ; preds = %224
br label %243
243: ; preds = %242
br label %244
244: ; preds = %243
%245 = call i64 @symlink(i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.13, i64 0, i64 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.14, i64 0, i64 0))
%246 = icmp slt i64 %245, 0
br i1 %246, label %247, label %250
247: ; preds = %244
%248 = load i32, i32* @errno
%249 = sub nsw i32 0, %248
br label %251
250: ; preds = %244
br label %251
251: ; preds = %250, %247
%252 = phi i32 [ %249, %247 ], [ 0, %250 ]
store i32 %252, i32* %2
store i32 %252, i32* %13
%253 = load i32, i32* %13
%254 = icmp slt i32 %253, 0
br i1 %254, label %255, label %269
255: ; preds = %251
store i8* getelementptr inbounds ([35 x i8], [35 x i8]* @.str.15, i64 0, i64 0), i8** %14
%256 = load i8*, i8** %14
%257 = icmp ne i8* %256, null
br i1 %257, label %258, label %267
258: ; preds = %255
%259 = load i8*, i8** %14
%260 = load i32, i32* @stderr
%261 = call i32 @fputs(i8* %259, i32 %260)
%262 = load i32, i32* @stderr
%263 = load i32, i32* %13
%264 = sub nsw i32 0, %263
%265 = call i8* @strerror(i32 %264)
%266 = call i32 @fprintf(i32 %262, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.3, i64 0, i64 0), i8* %265)
br label %267
267: ; preds = %258, %255
%268 = load i32, i32* %2
store i32 %268, i32* %1
br label %1556
269: ; preds = %251
br label %270
270: ; preds = %269
br label %271
271: ; preds = %270
%272 = call i64 @symlink(i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.16, i64 0, i64 0), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.17, i64 0, i64 0))
%273 = icmp slt i64 %272, 0
br i1 %273, label %274, label %277
274: ; preds = %271
%275 = load i32, i32* @errno
%276 = sub nsw i32 0, %275
br label %278
277: ; preds = %271
br label %278
278: ; preds = %277, %274
%279 = phi i32 [ %276, %274 ], [ 0, %277 ]
store i32 %279, i32* %2
store i32 %279, i32* %15
%280 = load i32, i32* %15
%281 = icmp slt i32 %280, 0
br i1 %281, label %282, label %296
282: ; preds = %278
store i8* getelementptr inbounds ([40 x i8], [40 x i8]* @.str.18, i64 0, i64 0), i8** %16
%283 = load i8*, i8** %16
%284 = icmp ne i8* %283, null
br i1 %284, label %285, label %294
285: ; preds = %282
%286 = load i8*, i8** %16
%287 = load i32, i32* @stderr
%288 = call i32 @fputs(i8* %286, i32 %287)
%289 = load i32, i32* @stderr
%290 = load i32, i32* %15
%291 = sub nsw i32 0, %290
%292 = call i8* @strerror(i32 %291)
%293 = call i32 @fprintf(i32 %289, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.3, i64 0, i64 0), i8* %292)
br label %294
294: ; preds = %285, %282
%295 = load i32, i32* %2
store i32 %295, i32* %1
br label %1556
296: ; preds = %278
br label %297
297: ; preds = %296
br label %298
298: ; preds = %297
%299 = call i64 @symlink(i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.19, i64 0, i64 0), i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.20, i64 0, i64 0))
%300 = icmp slt i64 %299, 0
br i1 %300, label %301, label %304
301: ; preds = %298
%302 = load i32, i32* @errno
%303 = sub nsw i32 0, %302
br label %305
304: ; preds = %298
br label %305
305: ; preds = %304, %301
%306 = phi i32 [ %303, %301 ], [ 0, %304 ]
store i32 %306, i32* %2
store i32 %306, i32* %17
%307 = load i32, i32* %17
%308 = icmp slt i32 %307, 0
br i1 %308, label %309, label %323
309: ; preds = %305
store i8* getelementptr inbounds ([41 x i8], [41 x i8]* @.str.21, i64 0, i64 0), i8** %18
%310 = load i8*, i8** %18
%311 = icmp ne i8* %310, null
br i1 %311, label %312, label %321
312: ; preds = %309
%313 = load i8*, i8** %18
%314 = load i32, i32* @stderr
%315 = call i32 @fputs(i8* %313, i32 %314)
%316 = load i32, i32* @stderr
%317 = load i32, i32* %17
%318 = sub nsw i32 0, %317
%319 = call i8* @strerror(i32 %318)
%320 = call i32 @fprintf(i32 %316, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.3, i64 0, i64 0), i8* %319)
br label %321
321: ; preds = %312, %309
%322 = load i32, i32* %2
store i32 %322, i32* %1
br label %1556
323: ; preds = %305
br label %324
324: ; preds = %323
br label %325
325: ; preds = %324
%326 = call i64 @symlink(i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.22, i64 0, i64 0), i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.23, i64 0, i64 0))
%327 = icmp slt i64 %326, 0
br i1 %327, label %328, label %331
328: ; preds = %325
%329 = load i32, i32* @errno
%330 = sub nsw i32 0, %329
br label %332
331: ; preds = %325
br label %332
332: ; preds = %331, %328
%333 = phi i32 [ %330, %328 ], [ 0, %331 ]
store i32 %333, i32* %2
store i32 %333, i32* %19
%334 = load i32, i32* %19
%335 = icmp slt i32 %334, 0
br i1 %335, label %336, label %350
336: ; preds = %332
store i8* getelementptr inbounds ([41 x i8], [41 x i8]* @.str.24, i64 0, i64 0), i8** %20
%337 = load i8*, i8** %20
%338 = icmp ne i8* %337, null
br i1 %338, label %339, label %348
339: ; preds = %336
%340 = load i8*, i8** %20
%341 = load i32, i32* @stderr
%342 = call i32 @fputs(i8* %340, i32 %341)
%343 = load i32, i32* @stderr
%344 = load i32, i32* %19
%345 = sub nsw i32 0, %344
%346 = call i8* @strerror(i32 %345)
%347 = call i32 @fprintf(i32 %343, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.3, i64 0, i64 0), i8* %346)
br label %348
348: ; preds = %339, %336
%349 = load i32, i32* %2
store i32 %349, i32* %1
br label %1556
350: ; preds = %332
br label %351
351: ; preds = %350
br label %352
352: ; preds = %351
br label %353
353: ; preds = %352
%354 = call i32 @touch(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.25, i64 0, i64 0))
store i32 %354, i32* %2
store i32 %354, i32* %21
%355 = load i32, i32* %21
%356 = icmp slt i32 %355, 0
br i1 %356, label %357, label %371
357: ; preds = %353
store i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.26, i64 0, i64 0), i8** %22
%358 = load i8*, i8** %22
%359 = icmp ne i8* %358, null
br i1 %359, label %360, label %369
360: ; preds = %357
%361 = load i8*, i8** %22
%362 = load i32, i32* @stderr
%363 = call i32 @fputs(i8* %361, i32 %362)
%364 = load i32, i32* @stderr
%365 = load i32, i32* %21
%366 = sub nsw i32 0, %365
%367 = call i8* @strerror(i32 %366)
%368 = call i32 @fprintf(i32 %364, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.3, i64 0, i64 0), i8* %367)
br label %369
369: ; preds = %360, %357
%370 = load i32, i32* %2
store i32 %370, i32* %1
br label %1556
371: ; preds = %353
br label %372
372: ; preds = %371
br label %373
373: ; preds = %372
%374 = call i32 @bind_mount(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.27, i64 0, i64 0), i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.25, i64 0, i64 0))
store i32 %374, i32* %2
store i32 %374, i32* %23
%375 = load i32, i32* %23
%376 = icmp slt i32 %375, 0
br i1 %376, label %377, label %391
377: ; preds = %373
store i8* getelementptr inbounds ([39 x i8], [39 x i8]* @.str.28, i64 0, i64 0), i8** %24
%378 = load i8*, i8** %24
%379 = icmp ne i8* %378, null
br i1 %379, label %380, label %389
380: ; preds = %377
%381 = load i8*, i8** %24
%382 = load i32, i32* @stderr
%383 = call i32 @fputs(i8* %381, i32 %382)
%384 = load i32, i32* @stderr
%385 = load i32, i32* %23
%386 = sub nsw i32 0, %385
%387 = call i8* @strerror(i32 %386)
%388 = call i32 @fprintf(i32 %384, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.3, i64 0, i64 0), i8* %387)
br label %389
389: ; preds = %380, %377
%390 = load i32, i32* %2
store i32 %390, i32* %1
br label %1556
391: ; preds = %373
br label %392
392: ; preds = %391
br label %393
393: ; preds = %392
br label %394
394: ; preds = %393
br label %395
395: ; preds = %394
%396 = call i32 @touch(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.29, i64 0, i64 0))
store i32 %396, i32* %2
store i32 %396, i32* %25
%397 = load i32, i32* %25
%398 = icmp slt i32 %397, 0
br i1 %398, label %399, label %413
399: ; preds = %395
store i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.30, i64 0, i64 0), i8** %26
%400 = load i8*, i8** %26
%401 = icmp ne i8* %400, null
br i1 %401, label %402, label %411
402: ; preds = %399
%403 = load i8*, i8** %26
%404 = load i32, i32* @stderr
%405 = call i32 @fputs(i8* %403, i32 %404)
%406 = load i32, i32* @stderr
%407 = load i32, i32* %25
%408 = sub nsw i32 0, %407
%409 = call i8* @strerror(i32 %408)
%410 = call i32 @fprintf(i32 %406, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.3, i64 0, i64 0), i8* %409)
br label %411
411: ; preds = %402, %399
%412 = load i32, i32* %2
store i32 %412, i32* %1
br label %1556
413: ; preds = %395
br label %414
414: ; preds = %413
br label %415
415: ; preds = %414
%416 = call i32 @bind_mount(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.31, i64 0, i64 0), i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.29, i64 0, i64 0))
store i32 %416, i32* %2
store i32 %416, i32* %27
%417 = load i32, i32* %27
%418 = icmp slt i32 %417, 0
br i1 %418, label %419, label %433
419: ; preds = %415
store i8* getelementptr inbounds ([39 x i8], [39 x i8]* @.str.32, i64 0, i64 0), i8** %28
%420 = load i8*, i8** %28
%421 = icmp ne i8* %420, null
br i1 %421, label %422, label %431
422: ; preds = %419
%423 = load i8*, i8** %28
%424 = load i32, i32* @stderr
%425 = call i32 @fputs(i8* %423, i32 %424)
%426 = load i32, i32* @stderr
%427 = load i32, i32* %27
%428 = sub nsw i32 0, %427
%429 = call i8* @strerror(i32 %428)
%430 = call i32 @fprintf(i32 %426, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.3, i64 0, i64 0), i8* %429)
br label %431
431: ; preds = %422, %419
%432 = load i32, i32* %2
store i32 %432, i32* %1
br label %1556
433: ; preds = %415
br label %434
434: ; preds = %433
br label %435
435: ; preds = %434
br label %436
436: ; preds = %435
br label %437
437: ; preds = %436
%438 = call i32 @touch(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.33, i64 0, i64 0))
store i32 %438, i32* %2
store i32 %438, i32* %29
%439 = load i32, i32* %29
%440 = icmp slt i32 %439, 0
br i1 %440, label %441, label %455
441: ; preds = %437
store i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.34, i64 0, i64 0), i8** %30
%442 = load i8*, i8** %30
%443 = icmp ne i8* %442, null
br i1 %443, label %444, label %453
444: ; preds = %441
%445 = load i8*, i8** %30
%446 = load i32, i32* @stderr
%447 = call i32 @fputs(i8* %445, i32 %446)
%448 = load i32, i32* @stderr
%449 = load i32, i32* %29
%450 = sub nsw i32 0, %449
%451 = call i8* @strerror(i32 %450)
%452 = call i32 @fprintf(i32 %448, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.3, i64 0, i64 0), i8* %451)
br label %453
453: ; preds = %444, %441
%454 = load i32, i32* %2
store i32 %454, i32* %1
br label %1556
455: ; preds = %437
br label %456
456: ; preds = %455
br label %457
457: ; preds = %456
%458 = call i32 @bind_mount(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.35, i64 0, i64 0), i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.33, i64 0, i64 0))
store i32 %458, i32* %2
store i32 %458, i32* %31
%459 = load i32, i32* %31
%460 = icmp slt i32 %459, 0
br i1 %460, label %461, label %475
461: ; preds = %457
store i8* getelementptr inbounds ([39 x i8], [39 x i8]* @.str.36, i64 0, i64 0), i8** %32
%462 = load i8*, i8** %32
%463 = icmp ne i8* %462, null
br i1 %463, label %464, label %473
464: ; preds = %461
%465 = load i8*, i8** %32
%466 = load i32, i32* @stderr
%467 = call i32 @fputs(i8* %465, i32 %466)
%468 = load i32, i32* @stderr
%469 = load i32, i32* %31
%470 = sub nsw i32 0, %469
%471 = call i8* @strerror(i32 %470)
%472 = call i32 @fprintf(i32 %468, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.3, i64 0, i64 0), i8* %471)
br label %473
473: ; preds = %464, %461
%474 = load i32, i32* %2
store i32 %474, i32* %1
br label %1556
475: ; preds = %457
br label %476
476: ; preds = %475
br label %477
477: ; preds = %476
br label %478
478: ; preds = %477
br label %479
479: ; preds = %478
%480 = call i32 @touch(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.37, i64 0, i64 0))
store i32 %480, i32* %2
store i32 %480, i32* %33
%481 = load i32, i32* %33
%482 = icmp slt i32 %481, 0
br i1 %482, label %483, label %497
483: ; preds = %479
store i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.38, i64 0, i64 0), i8** %34
%484 = load i8*, i8** %34
%485 = icmp ne i8* %484, null
br i1 %485, label %486, label %495
486: ; preds = %483
%487 = load i8*, i8** %34
%488 = load i32, i32* @stderr
%489 = call i32 @fputs(i8* %487, i32 %488)
%490 = load i32, i32* @stderr
%491 = load i32, i32* %33
%492 = sub nsw i32 0, %491
%493 = call i8* @strerror(i32 %492)
%494 = call i32 @fprintf(i32 %490, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.3, i64 0, i64 0), i8* %493)
br label %495
495: ; preds = %486, %483
%496 = load i32, i32* %2
store i32 %496, i32* %1
br label %1556
497: ; preds = %479
br label %498
498: ; preds = %497
br label %499
499: ; preds = %498
%500 = call i32 @bind_mount(i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.39, i64 0, i64 0), i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.37, i64 0, i64 0))
store i32 %500, i32* %2
store i32 %500, i32* %35
%501 = load i32, i32* %35
%502 = icmp slt i32 %501, 0
br i1 %502, label %503, label %517
503: ; preds = %499
store i8* getelementptr inbounds ([43 x i8], [43 x i8]* @.str.40, i64 0, i64 0), i8** %36
%504 = load i8*, i8** %36
%505 = icmp ne i8* %504, null
br i1 %505, label %506, label %515
506: ; preds = %503
%507 = load i8*, i8** %36
%508 = load i32, i32* @stderr
%509 = call i32 @fputs(i8* %507, i32 %508)
%510 = load i32, i32* @stderr
%511 = load i32, i32* %35
%512 = sub nsw i32 0, %511
%513 = call i8* @strerror(i32 %512)
%514 = call i32 @fprintf(i32 %510, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.3, i64 0, i64 0), i8* %513)
br label %515
515: ; preds = %506, %503
%516 = load i32, i32* %2
store i32 %516, i32* %1
br label %1556
517: ; preds = %499
br label %518
518: ; preds = %517
br label %519
519: ; preds = %518
br label %520
520: ; preds = %519
br label %521
521: ; preds = %520
%522 = call i32 @touch(i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.41, i64 0, i64 0))
store i32 %522, i32* %2
store i32 %522, i32* %37
%523 = load i32, i32* %37
%524 = icmp slt i32 %523, 0
br i1 %524, label %525, label %539
525: ; preds = %521
store i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.42, i64 0, i64 0), i8** %38
%526 = load i8*, i8** %38
%527 = icmp ne i8* %526, null
br i1 %527, label %528, label %537
528: ; preds = %525
%529 = load i8*, i8** %38
%530 = load i32, i32* @stderr
%531 = call i32 @fputs(i8* %529, i32 %530)
%532 = load i32, i32* @stderr
%533 = load i32, i32* %37
%534 = sub nsw i32 0, %533
%535 = call i8* @strerror(i32 %534)
%536 = call i32 @fprintf(i32 %532, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.3, i64 0, i64 0), i8* %535)
br label %537
537: ; preds = %528, %525
%538 = load i32, i32* %2
store i32 %538, i32* %1
br label %1556
539: ; preds = %521
br label %540
540: ; preds = %539
br label %541
541: ; preds = %540
%542 = call i32 @bind_mount(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.43, i64 0, i64 0), i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.41, i64 0, i64 0))
store i32 %542, i32* %2
store i32 %542, i32* %39
%543 = load i32, i32* %39
%544 = icmp slt i32 %543, 0
br i1 %544, label %545, label %559
545: ; preds = %541
store i8* getelementptr inbounds ([45 x i8], [45 x i8]* @.str.44, i64 0, i64 0), i8** %40
%546 = load i8*, i8** %40
%547 = icmp ne i8* %546, null
br i1 %547, label %548, label %557
548: ; preds = %545
%549 = load i8*, i8** %40
%550 = load i32, i32* @stderr
%551 = call i32 @fputs(i8* %549, i32 %550)
%552 = load i32, i32* @stderr
%553 = load i32, i32* %39
%554 = sub nsw i32 0, %553
%555 = call i8* @strerror(i32 %554)
%556 = call i32 @fprintf(i32 %552, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.3, i64 0, i64 0), i8* %555)
br label %557
557: ; preds = %548, %545
%558 = load i32, i32* %2
store i32 %558, i32* %1
br label %1556
559: ; preds = %541
br label %560
560: ; preds = %559
br label %561
561: ; preds = %560
br label %562
562: ; preds = %561
%563 = call i64 @mkdir(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.45, i64 0, i64 0), i32 493)
%564 = icmp slt i64 %563, 0
br i1 %564, label %565, label %568
565: ; preds = %562
%566 = load i32, i32* @errno
%567 = sub nsw i32 0, %566
br label %569
568: ; preds = %562
br label %569
569: ; preds = %568, %565
%570 = phi i32 [ %567, %565 ], [ 0, %568 ]
store i32 %570, i32* %2
store i32 %570, i32* %41
%571 = load i32, i32* %41
%572 = icmp slt i32 %571, 0
br i1 %572, label %573, label %587
573: ; preds = %569
store i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.46, i64 0, i64 0), i8** %42
%574 = load i8*, i8** %42
%575 = icmp ne i8* %574, null
br i1 %575, label %576, label %585
576: ; preds = %573
%577 = load i8*, i8** %42
%578 = load i32, i32* @stderr
%579 = call i32 @fputs(i8* %577, i32 %578)
%580 = load i32, i32* @stderr
%581 = load i32, i32* %41
%582 = sub nsw i32 0, %581
%583 = call i8* @strerror(i32 %582)
%584 = call i32 @fprintf(i32 %580, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.3, i64 0, i64 0), i8* %583)
br label %585
585: ; preds = %576, %573
%586 = load i32, i32* %2
store i32 %586, i32* %1
br label %1556
587: ; preds = %569
br label %588
588: ; preds = %587
br label %589
589: ; preds = %588
%590 = call i64 @symlink(i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.47, i64 0, i64 0), i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.48, i64 0, i64 0))
%591 = icmp slt i64 %590, 0
br i1 %591, label %592, label %595
592: ; preds = %589
%593 = load i32, i32* @errno
%594 = sub nsw i32 0, %593
br label %596
595: ; preds = %589
br label %596
596: ; preds = %595, %592
%597 = phi i32 [ %594, %592 ], [ 0, %595 ]
store i32 %597, i32* %2
store i32 %597, i32* %43
%598 = load i32, i32* %43
%599 = icmp slt i32 %598, 0
br i1 %599, label %600, label %614
600: ; preds = %596
store i8* getelementptr inbounds ([43 x i8], [43 x i8]* @.str.49, i64 0, i64 0), i8** %44
%601 = load i8*, i8** %44
%602 = icmp ne i8* %601, null
br i1 %602, label %603, label %612
603: ; preds = %600
%604 = load i8*, i8** %44
%605 = load i32, i32* @stderr
%606 = call i32 @fputs(i8* %604, i32 %605)
%607 = load i32, i32* @stderr
%608 = load i32, i32* %43
%609 = sub nsw i32 0, %608
%610 = call i8* @strerror(i32 %609)
%611 = call i32 @fprintf(i32 %607, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.3, i64 0, i64 0), i8* %610)
br label %612
612: ; preds = %603, %600
%613 = load i32, i32* %2
store i32 %613, i32* %1
br label %1556
614: ; preds = %596
br label %615
615: ; preds = %614
br label %616
616: ; preds = %615
%617 = call i64 @mkdir(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.50, i64 0, i64 0), i32 493)
%618 = icmp slt i64 %617, 0
br i1 %618, label %619, label %622
619: ; preds = %616
%620 = load i32, i32* @errno
%621 = sub nsw i32 0, %620
br label %623
622: ; preds = %616
br label %623
623: ; preds = %622, %619
%624 = phi i32 [ %621, %619 ], [ 0, %622 ]
store i32 %624, i32* %2
store i32 %624, i32* %45
%625 = load i32, i32* %45
%626 = icmp slt i32 %625, 0
br i1 %626, label %627, label %641
627: ; preds = %623
store i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.51, i64 0, i64 0), i8** %46
%628 = load i8*, i8** %46
%629 = icmp ne i8* %628, null
br i1 %629, label %630, label %639
630: ; preds = %627
%631 = load i8*, i8** %46
%632 = load i32, i32* @stderr
%633 = call i32 @fputs(i8* %631, i32 %632)
%634 = load i32, i32* @stderr
%635 = load i32, i32* %45
%636 = sub nsw i32 0, %635
%637 = call i8* @strerror(i32 %636)
%638 = call i32 @fprintf(i32 %634, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.3, i64 0, i64 0), i8* %637)
br label %639
639: ; preds = %630, %627
%640 = load i32, i32* %2
store i32 %640, i32* %1
br label %1556
641: ; preds = %623
br label %642
642: ; preds = %641
br label %643
643: ; preds = %642
%644 = load i32, i32* @MS_NOSUID
%645 = load i32, i32* @MS_NODEV
%646 = or i32 %644, %645
%647 = load i32, i32* @MS_NOEXEC
%648 = or i32 %646, %647
%649 = call i64 @mount(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.50, i64 0, i64 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.50, i64 0, i64 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.50, i64 0, i64 0), i32 %648, i8* null)
%650 = icmp slt i64 %649, 0
br i1 %650, label %651, label %654
651: ; preds = %643
%652 = load i32, i32* @errno
%653 = sub nsw i32 0, %652
br label %655
654: ; preds = %643
br label %655
655: ; preds = %654, %651
%656 = phi i32 [ %653, %651 ], [ 0, %654 ]
store i32 %656, i32* %2
store i32 %656, i32* %47
%657 = load i32, i32* %47
%658 = icmp slt i32 %657, 0
br i1 %658, label %659, label %673
659: ; preds = %655
store i8* getelementptr inbounds ([70 x i8], [70 x i8]* @.str.52, i64 0, i64 0), i8** %48
%660 = load i8*, i8** %48
%661 = icmp ne i8* %660, null
br i1 %661, label %662, label %671
662: ; preds = %659
%663 = load i8*, i8** %48
%664 = load i32, i32* @stderr
%665 = call i32 @fputs(i8* %663, i32 %664)
%666 = load i32, i32* @stderr
%667 = load i32, i32* %47
%668 = sub nsw i32 0, %667
%669 = call i8* @strerror(i32 %668)
%670 = call i32 @fprintf(i32 %666, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.3, i64 0, i64 0), i8* %669)
br label %671
671: ; preds = %662, %659
%672 = load i32, i32* %2
store i32 %672, i32* %1
br label %1556
673: ; preds = %655
br label %674
674: ; preds = %673
br label %675
675: ; preds = %674
%676 = call i64 @mkdir(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.53, i64 0, i64 0), i32 493)
%677 = icmp slt i64 %676, 0
br i1 %677, label %678, label %681
678: ; preds = %675
%679 = load i32, i32* @errno
%680 = sub nsw i32 0, %679
br label %682
681: ; preds = %675
br label %682
682: ; preds = %681, %678
%683 = phi i32 [ %680, %678 ], [ 0, %681 ]
store i32 %683, i32* %2
store i32 %683, i32* %49
%684 = load i32, i32* %49
%685 = icmp slt i32 %684, 0
br i1 %685, label %686, label %700
686: ; preds = %682
store i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.54, i64 0, i64 0), i8** %50
%687 = load i8*, i8** %50
%688 = icmp ne i8* %687, null
br i1 %688, label %689, label %698
689: ; preds = %686
%690 = load i8*, i8** %50
%691 = load i32, i32* @stderr
%692 = call i32 @fputs(i8* %690, i32 %691)
%693 = load i32, i32* @stderr
%694 = load i32, i32* %49
%695 = sub nsw i32 0, %694
%696 = call i8* @strerror(i32 %695)
%697 = call i32 @fprintf(i32 %693, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.3, i64 0, i64 0), i8* %696)
br label %698
698: ; preds = %689, %686
%699 = load i32, i32* %2
store i32 %699, i32* %1
br label %1556
700: ; preds = %682
br label %701
701: ; preds = %700
br label %702
702: ; preds = %701
%703 = call i64 @mkdir(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.55, i64 0, i64 0), i32 493)
%704 = icmp slt i64 %703, 0
br i1 %704, label %705, label %708
705: ; preds = %702
%706 = load i32, i32* @errno
%707 = sub nsw i32 0, %706
br label %709
708: ; preds = %702
br label %709
709: ; preds = %708, %705
%710 = phi i32 [ %707, %705 ], [ 0, %708 ]
store i32 %710, i32* %2
store i32 %710, i32* %51
%711 = load i32, i32* %51
%712 = icmp slt i32 %711, 0
br i1 %712, label %713, label %727
713: ; preds = %709
store i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.56, i64 0, i64 0), i8** %52
%714 = load i8*, i8** %52
%715 = icmp ne i8* %714, null
br i1 %715, label %716, label %725
716: ; preds = %713
%717 = load i8*, i8** %52
%718 = load i32, i32* @stderr
%719 = call i32 @fputs(i8* %717, i32 %718)
%720 = load i32, i32* @stderr
%721 = load i32, i32* %51
%722 = sub nsw i32 0, %721
%723 = call i8* @strerror(i32 %722)
%724 = call i32 @fprintf(i32 %720, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.3, i64 0, i64 0), i8* %723)
br label %725
725: ; preds = %716, %713
%726 = load i32, i32* %2
store i32 %726, i32* %1
br label %1556
727: ; preds = %709
br label %728
728: ; preds = %727
br label %729
729: ; preds = %728
%730 = call i64 @mkdir(i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.57, i64 0, i64 0), i32 493)
%731 = icmp slt i64 %730, 0
br i1 %731, label %732, label %735
732: ; preds = %729
%733 = load i32, i32* @errno
%734 = sub nsw i32 0, %733
br label %736
735: ; preds = %729
br label %736
736: ; preds = %735, %732
%737 = phi i32 [ %734, %732 ], [ 0, %735 ]
store i32 %737, i32* %2
store i32 %737, i32* %53
%738 = load i32, i32* %53
%739 = icmp slt i32 %738, 0
br i1 %739, label %740, label %754
740: ; preds = %736
store i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str.58, i64 0, i64 0), i8** %54
%741 = load i8*, i8** %54
%742 = icmp ne i8* %741, null
br i1 %742, label %743, label %752
743: ; preds = %740
%744 = load i8*, i8** %54
%745 = load i32, i32* @stderr
%746 = call i32 @fputs(i8* %744, i32 %745)
%747 = load i32, i32* @stderr
%748 = load i32, i32* %53
%749 = sub nsw i32 0, %748
%750 = call i8* @strerror(i32 %749)
%751 = call i32 @fprintf(i32 %747, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.3, i64 0, i64 0), i8* %750)
br label %752
752: ; preds = %743, %740
%753 = load i32, i32* %2
store i32 %753, i32* %1
br label %1556
754: ; preds = %736
br label %755
755: ; preds = %754
br label %756
756: ; preds = %755
%757 = load i32, i32* @MS_NOSUID
%758 = load i32, i32* @MS_NODEV
%759 = or i32 %757, %758
%760 = load i32, i32* @MS_NOEXEC
%761 = or i32 %759, %760
%762 = call i64 @mount(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.59, i64 0, i64 0), i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.57, i64 0, i64 0), i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.59, i64 0, i64 0), i32 %761, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.60, i64 0, i64 0))
%763 = icmp slt i64 %762, 0
br i1 %763, label %764, label %767
764: ; preds = %756
%765 = load i32, i32* @errno
%766 = sub nsw i32 0, %765
br label %768
767: ; preds = %756
br label %768
768: ; preds = %767, %764
%769 = phi i32 [ %766, %764 ], [ 0, %767 ]
store i32 %769, i32* %2
store i32 %769, i32* %55
%770 = load i32, i32* %55
%771 = icmp slt i32 %770, 0
br i1 %771, label %772, label %786
772: ; preds = %768
store i8* getelementptr inbounds ([87 x i8], [87 x i8]* @.str.61, i64 0, i64 0), i8** %56
%773 = load i8*, i8** %56
%774 = icmp ne i8* %773, null
br i1 %774, label %775, label %784
775: ; preds = %772
%776 = load i8*, i8** %56
%777 = load i32, i32* @stderr
%778 = call i32 @fputs(i8* %776, i32 %777)
%779 = load i32, i32* @stderr
%780 = load i32, i32* %55
%781 = sub nsw i32 0, %780
%782 = call i8* @strerror(i32 %781)
%783 = call i32 @fprintf(i32 %779, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.3, i64 0, i64 0), i8* %782)
br label %784
784: ; preds = %775, %772
%785 = load i32, i32* %2
store i32 %785, i32* %1
br label %1556
786: ; preds = %768
br label %787
787: ; preds = %786
br label %788
788: ; preds = %787
%789 = call i64 @mkdir(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.62, i64 0, i64 0), i32 493)
%790 = icmp slt i64 %789, 0
br i1 %790, label %791, label %794
791: ; preds = %788
%792 = load i32, i32* @errno
%793 = sub nsw i32 0, %792
br label %795
794: ; preds = %788
br label %795
795: ; preds = %794, %791
%796 = phi i32 [ %793, %791 ], [ 0, %794 ]
store i32 %796, i32* %2
store i32 %796, i32* %57
%797 = load i32, i32* %57
%798 = icmp slt i32 %797, 0
br i1 %798, label %799, label %813
799: ; preds = %795
store i8* getelementptr inbounds ([37 x i8], [37 x i8]* @.str.63, i64 0, i64 0), i8** %58
%800 = load i8*, i8** %58
%801 = icmp ne i8* %800, null
br i1 %801, label %802, label %811
802: ; preds = %799
%803 = load i8*, i8** %58
%804 = load i32, i32* @stderr
%805 = call i32 @fputs(i8* %803, i32 %804)
%806 = load i32, i32* @stderr
%807 = load i32, i32* %57
%808 = sub nsw i32 0, %807
%809 = call i8* @strerror(i32 %808)
%810 = call i32 @fprintf(i32 %806, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.3, i64 0, i64 0), i8* %809)
br label %811
811: ; preds = %802, %799
%812 = load i32, i32* %2
store i32 %812, i32* %1
br label %1556
813: ; preds = %795
br label %814
814: ; preds = %813
br label %815
815: ; preds = %814
%816 = load i32, i32* @MS_NOSUID
%817 = load i32, i32* @MS_NODEV
%818 = or i32 %816, %817
%819 = load i32, i32* @MS_NOEXEC
%820 = or i32 %818, %819
%821 = call i64 @mount(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.64, i64 0, i64 0), i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.62, i64 0, i64 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.65, i64 0, i64 0), i32 %820, i8* null)
%822 = icmp slt i64 %821, 0
br i1 %822, label %823, label %826
823: ; preds = %815
%824 = load i32, i32* @errno
%825 = sub nsw i32 0, %824
br label %827
826: ; preds = %815
br label %827
827: ; preds = %826, %823
%828 = phi i32 [ %825, %823 ], [ 0, %826 ]
store i32 %828, i32* %2
store i32 %828, i32* %59
%829 = load i32, i32* %59
%830 = icmp slt i32 %829, 0
br i1 %830, label %831, label %845
831: ; preds = %827
store i8* getelementptr inbounds ([92 x i8], [92 x i8]* @.str.66, i64 0, i64 0), i8** %60
%832 = load i8*, i8** %60
%833 = icmp ne i8* %832, null
br i1 %833, label %834, label %843
834: ; preds = %831
%835 = load i8*, i8** %60
%836 = load i32, i32* @stderr
%837 = call i32 @fputs(i8* %835, i32 %836)
%838 = load i32, i32* @stderr
%839 = load i32, i32* %59
%840 = sub nsw i32 0, %839
%841 = call i8* @strerror(i32 %840)
%842 = call i32 @fprintf(i32 %838, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.3, i64 0, i64 0), i8* %841)
br label %843
843: ; preds = %834, %831
%844 = load i32, i32* %2
store i32 %844, i32* %1
br label %1556
845: ; preds = %827
br label %846
846: ; preds = %845
br label %847
847: ; preds = %846
br label %848
848: ; preds = %847
%849 = call i64 @mkdir(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.67, i64 0, i64 0), i32 493)
%850 = icmp slt i64 %849, 0
br i1 %850, label %851, label %854
851: ; preds = %848
%852 = load i32, i32* @errno
%853 = sub nsw i32 0, %852
br label %855
854: ; preds = %848
br label %855
855: ; preds = %854, %851
%856 = phi i32 [ %853, %851 ], [ 0, %854 ]
store i32 %856, i32* %2
store i32 %856, i32* %61
%857 = load i32, i32* %61
%858 = icmp slt i32 %857, 0
br i1 %858, label %859, label %873
859: ; preds = %855
store i8* getelementptr inbounds ([40 x i8], [40 x i8]* @.str.68, i64 0, i64 0), i8** %62
%860 = load i8*, i8** %62
%861 = icmp ne i8* %860, null
br i1 %861, label %862, label %871
862: ; preds = %859
%863 = load i8*, i8** %62
%864 = load i32, i32* @stderr
%865 = call i32 @fputs(i8* %863, i32 %864)
%866 = load i32, i32* @stderr
%867 = load i32, i32* %61
%868 = sub nsw i32 0, %867
%869 = call i8* @strerror(i32 %868)
%870 = call i32 @fprintf(i32 %866, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.3, i64 0, i64 0), i8* %869)
br label %871
871: ; preds = %862, %859
%872 = load i32, i32* %2
store i32 %872, i32* %1
br label %1556
873: ; preds = %855
br label %874
874: ; preds = %873
br label %875
875: ; preds = %874
%876 = load i32, i32* @MS_NOSUID
%877 = load i32, i32* @MS_NODEV
%878 = or i32 %876, %877
%879 = load i32, i32* @MS_NOEXEC
%880 = or i32 %878, %879
%881 = call i64 @mount(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.64, i64 0, i64 0), i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.67, i64 0, i64 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.64, i64 0, i64 0), i32 %880, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.69, i64 0, i64 0))
%882 = icmp slt i64 %881, 0
br i1 %882, label %883, label %886
883: ; preds = %875
%884 = load i32, i32* @errno
%885 = sub nsw i32 0, %884
br label %887
886: ; preds = %875
br label %887
887: ; preds = %886, %883
%888 = phi i32 [ %885, %883 ], [ 0, %886 ]
store i32 %888, i32* %2
store i32 %888, i32* %63
%889 = load i32, i32* %63
%890 = icmp slt i32 %889, 0
br i1 %890, label %891, label %905
891: ; preds = %887
store i8* getelementptr inbounds ([99 x i8], [99 x i8]* @.str.70, i64 0, i64 0), i8** %64
%892 = load i8*, i8** %64
%893 = icmp ne i8* %892, null
br i1 %893, label %894, label %903
894: ; preds = %891
%895 = load i8*, i8** %64
%896 = load i32, i32* @stderr
%897 = call i32 @fputs(i8* %895, i32 %896)
%898 = load i32, i32* @stderr
%899 = load i32, i32* %63
%900 = sub nsw i32 0, %899
%901 = call i8* @strerror(i32 %900)
%902 = call i32 @fprintf(i32 %898, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.3, i64 0, i64 0), i8* %901)
br label %903
903: ; preds = %894, %891
%904 = load i32, i32* %2
store i32 %904, i32* %1
br label %1556
905: ; preds = %887
br label %906
906: ; preds = %905
br label %907
907: ; preds = %906
br label %908
908: ; preds = %907
br label %909
909: ; preds = %908
%910 = call i64 @mkdir(i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str.71, i64 0, i64 0), i32 493)
%911 = icmp slt i64 %910, 0
br i1 %911, label %912, label %915
912: ; preds = %909
%913 = load i32, i32* @errno
%914 = sub nsw i32 0, %913
br label %916
915: ; preds = %909
br label %916
916: ; preds = %915, %912
%917 = phi i32 [ %914, %912 ], [ 0, %915 ]
store i32 %917, i32* %2
store i32 %917, i32* %65
%918 = load i32, i32* %65
%919 = icmp slt i32 %918, 0
br i1 %919, label %920, label %934
920: ; preds = %916
store i8* getelementptr inbounds ([44 x i8], [44 x i8]* @.str.72, i64 0, i64 0), i8** %66
%921 = load i8*, i8** %66
%922 = icmp ne i8* %921, null
br i1 %922, label %923, label %932
923: ; preds = %920
%924 = load i8*, i8** %66
%925 = load i32, i32* @stderr
%926 = call i32 @fputs(i8* %924, i32 %925)
%927 = load i32, i32* @stderr
%928 = load i32, i32* %65
%929 = sub nsw i32 0, %928
%930 = call i8* @strerror(i32 %929)
%931 = call i32 @fprintf(i32 %927, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.3, i64 0, i64 0), i8* %930)
br label %932
932: ; preds = %923, %920
%933 = load i32, i32* %2
store i32 %933, i32* %1
br label %1556
934: ; preds = %916
br label %935
935: ; preds = %934
br label %936
936: ; preds = %935
%937 = load i32, i32* @MS_NOSUID
%938 = load i32, i32* @MS_NODEV
%939 = or i32 %937, %938
%940 = load i32, i32* @MS_NOEXEC
%941 = or i32 %939, %940
%942 = call i64 @mount(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.64, i64 0, i64 0), i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str.71, i64 0, i64 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.64, i64 0, i64 0), i32 %941, i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.73, i64 0, i64 0))
%943 = icmp slt i64 %942, 0
br i1 %943, label %944, label %947
944: ; preds = %936
%945 = load i32, i32* @errno
%946 = sub nsw i32 0, %945
br label %948
947: ; preds = %936
br label %948
948: ; preds = %947, %944
%949 = phi i32 [ %946, %944 ], [ 0, %947 ]
store i32 %949, i32* %2
store i32 %949, i32* %67
%950 = load i32, i32* %67
%951 = icmp slt i32 %950, 0
br i1 %951, label %952, label %966
952: ; preds = %948
store i8* getelementptr inbounds ([107 x i8], [107 x i8]* @.str.74, i64 0, i64 0), i8** %68
%953 = load i8*, i8** %68
%954 = icmp ne i8* %953, null
br i1 %954, label %955, label %964
955: ; preds = %952
%956 = load i8*, i8** %68
%957 = load i32, i32* @stderr
%958 = call i32 @fputs(i8* %956, i32 %957)
%959 = load i32, i32* @stderr
%960 = load i32, i32* %67
%961 = sub nsw i32 0, %960
%962 = call i8* @strerror(i32 %961)
%963 = call i32 @fprintf(i32 %959, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.3, i64 0, i64 0), i8* %962)
br label %964
964: ; preds = %955, %952
%965 = load i32, i32* %2
store i32 %965, i32* %1
br label %1556
966: ; preds = %948
br label %967
967: ; preds = %966
br label %968
968: ; preds = %967
br label %969
969: ; preds = %968
br label %970
970: ; preds = %969
%971 = call i64 @mkdir(i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.75, i64 0, i64 0), i32 493)
%972 = icmp slt i64 %971, 0
br i1 %972, label %973, label %976
973: ; preds = %970
%974 = load i32, i32* @errno
%975 = sub nsw i32 0, %974
br label %977
976: ; preds = %970
br label %977
977: ; preds = %976, %973
%978 = phi i32 [ %975, %973 ], [ 0, %976 ]
store i32 %978, i32* %2
store i32 %978, i32* %69
%979 = load i32, i32* %69
%980 = icmp slt i32 %979, 0
br i1 %980, label %981, label %995
981: ; preds = %977
store i8* getelementptr inbounds ([39 x i8], [39 x i8]* @.str.76, i64 0, i64 0), i8** %70
%982 = load i8*, i8** %70
%983 = icmp ne i8* %982, null
br i1 %983, label %984, label %993
984: ; preds = %981
%985 = load i8*, i8** %70
%986 = load i32, i32* @stderr
%987 = call i32 @fputs(i8* %985, i32 %986)
%988 = load i32, i32* @stderr
%989 = load i32, i32* %69
%990 = sub nsw i32 0, %989
%991 = call i8* @strerror(i32 %990)
%992 = call i32 @fprintf(i32 %988, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.3, i64 0, i64 0), i8* %991)
br label %993
993: ; preds = %984, %981
%994 = load i32, i32* %2
store i32 %994, i32* %1
br label %1556
995: ; preds = %977
br label %996
996: ; preds = %995
br label %997
997: ; preds = %996
%998 = load i32, i32* @MS_NOSUID
%999 = load i32, i32* @MS_NODEV
%1000 = or i32 %998, %999
%1001 = load i32, i32* @MS_NOEXEC
%1002 = or i32 %1000, %1001
%1003 = call i64 @mount(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.64, i64 0, i64 0), i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.75, i64 0, i64 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.64, i64 0, i64 0), i32 %1002, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.77, i64 0, i64 0))
%1004 = icmp slt i64 %1003, 0
br i1 %1004, label %1005, label %1008
1005: ; preds = %997
%1006 = load i32, i32* @errno
%1007 = sub nsw i32 0, %1006
br label %1009
1008: ; preds = %997
br label %1009
1009: ; preds = %1008, %1005
%1010 = phi i32 [ %1007, %1005 ], [ 0, %1008 ]
store i32 %1010, i32* %2
store i32 %1010, i32* %71
%1011 = load i32, i32* %71
%1012 = icmp slt i32 %1011, 0
br i1 %1012, label %1013, label %1027
1013: ; preds = %1009
store i8* getelementptr inbounds ([97 x i8], [97 x i8]* @.str.78, i64 0, i64 0), i8** %72
%1014 = load i8*, i8** %72
%1015 = icmp ne i8* %1014, null
br i1 %1015, label %1016, label %1025
1016: ; preds = %1013
%1017 = load i8*, i8** %72
%1018 = load i32, i32* @stderr
%1019 = call i32 @fputs(i8* %1017, i32 %1018)
%1020 = load i32, i32* @stderr
%1021 = load i32, i32* %71
%1022 = sub nsw i32 0, %1021
%1023 = call i8* @strerror(i32 %1022)
%1024 = call i32 @fprintf(i32 %1020, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.3, i64 0, i64 0), i8* %1023)
br label %1025
1025: ; preds = %1016, %1013
%1026 = load i32, i32* %2
store i32 %1026, i32* %1
br label %1556
1027: ; preds = %1009
br label %1028
1028: ; preds = %1027
br label %1029
1029: ; preds = %1028
br label %1030
1030: ; preds = %1029
br label %1031
1031: ; preds = %1030
%1032 = call i64 @mkdir(i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str.79, i64 0, i64 0), i32 493)
%1033 = icmp slt i64 %1032, 0
br i1 %1033, label %1034, label %1037
1034: ; preds = %1031
%1035 = load i32, i32* @errno
%1036 = sub nsw i32 0, %1035
br label %1038
1037: ; preds = %1031
br label %1038
1038: ; preds = %1037, %1034
%1039 = phi i32 [ %1036, %1034 ], [ 0, %1037 ]
store i32 %1039, i32* %2
store i32 %1039, i32* %73
%1040 = load i32, i32* %73
%1041 = icmp slt i32 %1040, 0
br i1 %1041, label %1042, label %1056
1042: ; preds = %1038
store i8* getelementptr inbounds ([49 x i8], [49 x i8]* @.str.80, i64 0, i64 0), i8** %74
%1043 = load i8*, i8** %74
%1044 = icmp ne i8* %1043, null
br i1 %1044, label %1045, label %1054
1045: ; preds = %1042
%1046 = load i8*, i8** %74
%1047 = load i32, i32* @stderr
%1048 = call i32 @fputs(i8* %1046, i32 %1047)
%1049 = load i32, i32* @stderr
%1050 = load i32, i32* %73
%1051 = sub nsw i32 0, %1050
%1052 = call i8* @strerror(i32 %1051)
%1053 = call i32 @fprintf(i32 %1049, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.3, i64 0, i64 0), i8* %1052)
br label %1054
1054: ; preds = %1045, %1042
%1055 = load i32, i32* %2
store i32 %1055, i32* %1
br label %1556
1056: ; preds = %1038
br label %1057
1057: ; preds = %1056
br label %1058
1058: ; preds = %1057
%1059 = load i32, i32* @MS_NOSUID
%1060 = load i32, i32* @MS_NODEV
%1061 = or i32 %1059, %1060
%1062 = load i32, i32* @MS_NOEXEC
%1063 = or i32 %1061, %1062
%1064 = call i64 @mount(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.64, i64 0, i64 0), i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str.79, i64 0, i64 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.64, i64 0, i64 0), i32 %1063, i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.81, i64 0, i64 0))
%1065 = icmp slt i64 %1064, 0
br i1 %1065, label %1066, label %1069
1066: ; preds = %1058
%1067 = load i32, i32* @errno
%1068 = sub nsw i32 0, %1067
br label %1070
1069: ; preds = %1058
br label %1070
1070: ; preds = %1069, %1066
%1071 = phi i32 [ %1068, %1066 ], [ 0, %1069 ]
store i32 %1071, i32* %2
store i32 %1071, i32* %75
%1072 = load i32, i32* %75
%1073 = icmp slt i32 %1072, 0
br i1 %1073, label %1074, label %1088
1074: ; preds = %1070
store i8* getelementptr inbounds ([117 x i8], [117 x i8]* @.str.82, i64 0, i64 0), i8** %76
%1075 = load i8*, i8** %76
%1076 = icmp ne i8* %1075, null
br i1 %1076, label %1077, label %1086
1077: ; preds = %1074
%1078 = load i8*, i8** %76
%1079 = load i32, i32* @stderr
%1080 = call i32 @fputs(i8* %1078, i32 %1079)
%1081 = load i32, i32* @stderr
%1082 = load i32, i32* %75
%1083 = sub nsw i32 0, %1082
%1084 = call i8* @strerror(i32 %1083)
%1085 = call i32 @fprintf(i32 %1081, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.3, i64 0, i64 0), i8* %1084)
br label %1086
1086: ; preds = %1077, %1074
%1087 = load i32, i32* %2
store i32 %1087, i32* %1
br label %1556
1088: ; preds = %1070
br label %1089
1089: ; preds = %1088
br label %1090
1090: ; preds = %1089
br label %1091
1091: ; preds = %1090
br label %1092
1092: ; preds = %1091
%1093 = call i64 @mkdir(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.83, i64 0, i64 0), i32 493)
%1094 = icmp slt i64 %1093, 0
br i1 %1094, label %1095, label %1098
1095: ; preds = %1092
%1096 = load i32, i32* @errno
%1097 = sub nsw i32 0, %1096
br label %1099
1098: ; preds = %1092
br label %1099
1099: ; preds = %1098, %1095
%1100 = phi i32 [ %1097, %1095 ], [ 0, %1098 ]
store i32 %1100, i32* %2
store i32 %1100, i32* %77
%1101 = load i32, i32* %77
%1102 = icmp slt i32 %1101, 0
br i1 %1102, label %1103, label %1117
1103: ; preds = %1099
store i8* getelementptr inbounds ([37 x i8], [37 x i8]* @.str.84, i64 0, i64 0), i8** %78
%1104 = load i8*, i8** %78
%1105 = icmp ne i8* %1104, null
br i1 %1105, label %1106, label %1115
1106: ; preds = %1103
%1107 = load i8*, i8** %78
%1108 = load i32, i32* @stderr
%1109 = call i32 @fputs(i8* %1107, i32 %1108)
%1110 = load i32, i32* @stderr
%1111 = load i32, i32* %77
%1112 = sub nsw i32 0, %1111
%1113 = call i8* @strerror(i32 %1112)
%1114 = call i32 @fprintf(i32 %1110, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.3, i64 0, i64 0), i8* %1113)
br label %1115
1115: ; preds = %1106, %1103
%1116 = load i32, i32* %2
store i32 %1116, i32* %1
br label %1556
1117: ; preds = %1099
br label %1118
1118: ; preds = %1117
br label %1119
1119: ; preds = %1118
%1120 = load i32, i32* @MS_NOSUID
%1121 = load i32, i32* @MS_NODEV
%1122 = or i32 %1120, %1121
%1123 = load i32, i32* @MS_NOEXEC
%1124 = or i32 %1122, %1123
%1125 = call i64 @mount(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.64, i64 0, i64 0), i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.83, i64 0, i64 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.64, i64 0, i64 0), i32 %1124, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.85, i64 0, i64 0))
%1126 = icmp slt i64 %1125, 0
br i1 %1126, label %1127, label %1130
1127: ; preds = %1119
%1128 = load i32, i32* @errno
%1129 = sub nsw i32 0, %1128
br label %1131
1130: ; preds = %1119
br label %1131
1131: ; preds = %1130, %1127
%1132 = phi i32 [ %1129, %1127 ], [ 0, %1130 ]
store i32 %1132, i32* %2
store i32 %1132, i32* %79
%1133 = load i32, i32* %79
%1134 = icmp slt i32 %1133, 0
br i1 %1134, label %1135, label %1149
1135: ; preds = %1131
store i8* getelementptr inbounds ([93 x i8], [93 x i8]* @.str.86, i64 0, i64 0), i8** %80
%1136 = load i8*, i8** %80
%1137 = icmp ne i8* %1136, null
br i1 %1137, label %1138, label %1147
1138: ; preds = %1135
%1139 = load i8*, i8** %80
%1140 = load i32, i32* @stderr
%1141 = call i32 @fputs(i8* %1139, i32 %1140)
%1142 = load i32, i32* @stderr
%1143 = load i32, i32* %79
%1144 = sub nsw i32 0, %1143
%1145 = call i8* @strerror(i32 %1144)
%1146 = call i32 @fprintf(i32 %1142, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.3, i64 0, i64 0), i8* %1145)
br label %1147
1147: ; preds = %1138, %1135
%1148 = load i32, i32* %2
store i32 %1148, i32* %1
br label %1556
1149: ; preds = %1131
br label %1150
1150: ; preds = %1149
br label %1151
1151: ; preds = %1150
br label %1152
1152: ; preds = %1151
br label %1153
1153: ; preds = %1152
%1154 = call i64 @mkdir(i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.87, i64 0, i64 0), i32 493)
%1155 = icmp slt i64 %1154, 0
br i1 %1155, label %1156, label %1159
1156: ; preds = %1153
%1157 = load i32, i32* @errno
%1158 = sub nsw i32 0, %1157
br label %1160
1159: ; preds = %1153
br label %1160
1160: ; preds = %1159, %1156
%1161 = phi i32 [ %1158, %1156 ], [ 0, %1159 ]
store i32 %1161, i32* %2
store i32 %1161, i32* %81
%1162 = load i32, i32* %81
%1163 = icmp slt i32 %1162, 0
br i1 %1163, label %1164, label %1178
1164: ; preds = %1160
store i8* getelementptr inbounds ([38 x i8], [38 x i8]* @.str.88, i64 0, i64 0), i8** %82
%1165 = load i8*, i8** %82
%1166 = icmp ne i8* %1165, null
br i1 %1166, label %1167, label %1176
1167: ; preds = %1164
%1168 = load i8*, i8** %82
%1169 = load i32, i32* @stderr
%1170 = call i32 @fputs(i8* %1168, i32 %1169)
%1171 = load i32, i32* @stderr
%1172 = load i32, i32* %81
%1173 = sub nsw i32 0, %1172
%1174 = call i8* @strerror(i32 %1173)
%1175 = call i32 @fprintf(i32 %1171, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.3, i64 0, i64 0), i8* %1174)
br label %1176
1176: ; preds = %1167, %1164
%1177 = load i32, i32* %2
store i32 %1177, i32* %1
br label %1556
1178: ; preds = %1160
br label %1179
1179: ; preds = %1178
br label %1180
1180: ; preds = %1179
%1181 = load i32, i32* @MS_NOSUID
%1182 = load i32, i32* @MS_NODEV
%1183 = or i32 %1181, %1182
%1184 = load i32, i32* @MS_NOEXEC
%1185 = or i32 %1183, %1184
%1186 = call i64 @mount(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.64, i64 0, i64 0), i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.87, i64 0, i64 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.64, i64 0, i64 0), i32 %1185, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.89, i64 0, i64 0))
%1187 = icmp slt i64 %1186, 0
br i1 %1187, label %1188, label %1191
1188: ; preds = %1180
%1189 = load i32, i32* @errno
%1190 = sub nsw i32 0, %1189
br label %1192
1191: ; preds = %1180
br label %1192
1192: ; preds = %1191, %1188
%1193 = phi i32 [ %1190, %1188 ], [ 0, %1191 ]
store i32 %1193, i32* %2
store i32 %1193, i32* %83
%1194 = load i32, i32* %83
%1195 = icmp slt i32 %1194, 0
br i1 %1195, label %1196, label %1210
1196: ; preds = %1192
store i8* getelementptr inbounds ([95 x i8], [95 x i8]* @.str.90, i64 0, i64 0), i8** %84
%1197 = load i8*, i8** %84
%1198 = icmp ne i8* %1197, null
br i1 %1198, label %1199, label %1208
1199: ; preds = %1196
%1200 = load i8*, i8** %84
%1201 = load i32, i32* @stderr
%1202 = call i32 @fputs(i8* %1200, i32 %1201)
%1203 = load i32, i32* @stderr
%1204 = load i32, i32* %83
%1205 = sub nsw i32 0, %1204
%1206 = call i8* @strerror(i32 %1205)
%1207 = call i32 @fprintf(i32 %1203, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.3, i64 0, i64 0), i8* %1206)
br label %1208
1208: ; preds = %1199, %1196
%1209 = load i32, i32* %2
store i32 %1209, i32* %1
br label %1556
1210: ; preds = %1192
br label %1211
1211: ; preds = %1210
br label %1212
1212: ; preds = %1211
br label %1213
1213: ; preds = %1212
br label %1214
1214: ; preds = %1213
%1215 = call i64 @mkdir(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.91, i64 0, i64 0), i32 493)
%1216 = icmp slt i64 %1215, 0
br i1 %1216, label %1217, label %1220
1217: ; preds = %1214
%1218 = load i32, i32* @errno
%1219 = sub nsw i32 0, %1218
br label %1221
1220: ; preds = %1214
br label %1221
1221: ; preds = %1220, %1217
%1222 = phi i32 [ %1219, %1217 ], [ 0, %1220 ]
store i32 %1222, i32* %2
store i32 %1222, i32* %85
%1223 = load i32, i32* %85
%1224 = icmp slt i32 %1223, 0
br i1 %1224, label %1225, label %1239
1225: ; preds = %1221
store i8* getelementptr inbounds ([40 x i8], [40 x i8]* @.str.92, i64 0, i64 0), i8** %86
%1226 = load i8*, i8** %86
%1227 = icmp ne i8* %1226, null
br i1 %1227, label %1228, label %1237
1228: ; preds = %1225
%1229 = load i8*, i8** %86
%1230 = load i32, i32* @stderr
%1231 = call i32 @fputs(i8* %1229, i32 %1230)
%1232 = load i32, i32* @stderr
%1233 = load i32, i32* %85
%1234 = sub nsw i32 0, %1233
%1235 = call i8* @strerror(i32 %1234)
%1236 = call i32 @fprintf(i32 %1232, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.3, i64 0, i64 0), i8* %1235)
br label %1237
1237: ; preds = %1228, %1225
%1238 = load i32, i32* %2
store i32 %1238, i32* %1
br label %1556
1239: ; preds = %1221
br label %1240
1240: ; preds = %1239
br label %1241
1241: ; preds = %1240
%1242 = load i32, i32* @MS_NOSUID
%1243 = load i32, i32* @MS_NODEV
%1244 = or i32 %1242, %1243
%1245 = load i32, i32* @MS_NOEXEC
%1246 = or i32 %1244, %1245
%1247 = call i64 @mount(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.64, i64 0, i64 0), i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.91, i64 0, i64 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.64, i64 0, i64 0), i32 %1246, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.93, i64 0, i64 0))
%1248 = icmp slt i64 %1247, 0
br i1 %1248, label %1249, label %1252
1249: ; preds = %1241
%1250 = load i32, i32* @errno
%1251 = sub nsw i32 0, %1250
br label %1253
1252: ; preds = %1241
br label %1253
1253: ; preds = %1252, %1249
%1254 = phi i32 [ %1251, %1249 ], [ 0, %1252 ]
store i32 %1254, i32* %2
store i32 %1254, i32* %87
%1255 = load i32, i32* %87
%1256 = icmp slt i32 %1255, 0
br i1 %1256, label %1257, label %1271
1257: ; preds = %1253
store i8* getelementptr inbounds ([99 x i8], [99 x i8]* @.str.94, i64 0, i64 0), i8** %88
%1258 = load i8*, i8** %88
%1259 = icmp ne i8* %1258, null
br i1 %1259, label %1260, label %1269
1260: ; preds = %1257
%1261 = load i8*, i8** %88
%1262 = load i32, i32* @stderr
%1263 = call i32 @fputs(i8* %1261, i32 %1262)
%1264 = load i32, i32* @stderr
%1265 = load i32, i32* %87
%1266 = sub nsw i32 0, %1265
%1267 = call i8* @strerror(i32 %1266)
%1268 = call i32 @fprintf(i32 %1264, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.3, i64 0, i64 0), i8* %1267)
br label %1269
1269: ; preds = %1260, %1257
%1270 = load i32, i32* %2
store i32 %1270, i32* %1
br label %1556
1271: ; preds = %1253
br label %1272
1272: ; preds = %1271
br label %1273
1273: ; preds = %1272
br label %1274
1274: ; preds = %1273
br label %1275
1275: ; preds = %1274
%1276 = call i64 @mkdir(i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.95, i64 0, i64 0), i32 493)
%1277 = icmp slt i64 %1276, 0
br i1 %1277, label %1278, label %1281
1278: ; preds = %1275
%1279 = load i32, i32* @errno
%1280 = sub nsw i32 0, %1279
br label %1282
1281: ; preds = %1275
br label %1282
1282: ; preds = %1281, %1278
%1283 = phi i32 [ %1280, %1278 ], [ 0, %1281 ]
store i32 %1283, i32* %2
store i32 %1283, i32* %89
%1284 = load i32, i32* %89
%1285 = icmp slt i32 %1284, 0
br i1 %1285, label %1286, label %1300
1286: ; preds = %1282
store i8* getelementptr inbounds ([39 x i8], [39 x i8]* @.str.96, i64 0, i64 0), i8** %90
%1287 = load i8*, i8** %90
%1288 = icmp ne i8* %1287, null
br i1 %1288, label %1289, label %1298
1289: ; preds = %1286
%1290 = load i8*, i8** %90
%1291 = load i32, i32* @stderr
%1292 = call i32 @fputs(i8* %1290, i32 %1291)
%1293 = load i32, i32* @stderr
%1294 = load i32, i32* %89
%1295 = sub nsw i32 0, %1294
%1296 = call i8* @strerror(i32 %1295)
%1297 = call i32 @fprintf(i32 %1293, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.3, i64 0, i64 0), i8* %1296)
br label %1298
1298: ; preds = %1289, %1286
%1299 = load i32, i32* %2
store i32 %1299, i32* %1
br label %1556
1300: ; preds = %1282
br label %1301
1301: ; preds = %1300
br label %1302
1302: ; preds = %1301
%1303 = load i32, i32* @MS_NOSUID
%1304 = load i32, i32* @MS_NODEV
%1305 = or i32 %1303, %1304
%1306 = load i32, i32* @MS_NOEXEC
%1307 = or i32 %1305, %1306
%1308 = call i64 @mount(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.64, i64 0, i64 0), i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.95, i64 0, i64 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.64, i64 0, i64 0), i32 %1307, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.97, i64 0, i64 0))
%1309 = icmp slt i64 %1308, 0
br i1 %1309, label %1310, label %1313
1310: ; preds = %1302
%1311 = load i32, i32* @errno
%1312 = sub nsw i32 0, %1311
br label %1314
1313: ; preds = %1302
br label %1314
1314: ; preds = %1313, %1310
%1315 = phi i32 [ %1312, %1310 ], [ 0, %1313 ]
store i32 %1315, i32* %2
store i32 %1315, i32* %91
%1316 = load i32, i32* %91
%1317 = icmp slt i32 %1316, 0
br i1 %1317, label %1318, label %1332
1318: ; preds = %1314
store i8* getelementptr inbounds ([97 x i8], [97 x i8]* @.str.98, i64 0, i64 0), i8** %92
%1319 = load i8*, i8** %92
%1320 = icmp ne i8* %1319, null
br i1 %1320, label %1321, label %1330
1321: ; preds = %1318
%1322 = load i8*, i8** %92
%1323 = load i32, i32* @stderr
%1324 = call i32 @fputs(i8* %1322, i32 %1323)
%1325 = load i32, i32* @stderr
%1326 = load i32, i32* %91
%1327 = sub nsw i32 0, %1326
%1328 = call i8* @strerror(i32 %1327)
%1329 = call i32 @fprintf(i32 %1325, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.3, i64 0, i64 0), i8* %1328)
br label %1330
1330: ; preds = %1321, %1318
%1331 = load i32, i32* %2
store i32 %1331, i32* %1
br label %1556
1332: ; preds = %1314
br label %1333
1333: ; preds = %1332
br label %1334
1334: ; preds = %1333
br label %1335
1335: ; preds = %1334
%1336 = call i64 @symlink(i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.73, i64 0, i64 0), i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.99, i64 0, i64 0))
%1337 = icmp slt i64 %1336, 0
br i1 %1337, label %1338, label %1341
1338: ; preds = %1335
%1339 = load i32, i32* @errno
%1340 = sub nsw i32 0, %1339
br label %1342
1341: ; preds = %1335
br label %1342
1342: ; preds = %1341, %1338
%1343 = phi i32 [ %1340, %1338 ], [ 0, %1341 ]
store i32 %1343, i32* %2
store i32 %1343, i32* %93
%1344 = load i32, i32* %93
%1345 = icmp slt i32 %1344, 0
br i1 %1345, label %1346, label %1360
1346: ; preds = %1342
store i8* getelementptr inbounds ([44 x i8], [44 x i8]* @.str.100, i64 0, i64 0), i8** %94
%1347 = load i8*, i8** %94
%1348 = icmp ne i8* %1347, null
br i1 %1348, label %1349, label %1358
1349: ; preds = %1346
%1350 = load i8*, i8** %94
%1351 = load i32, i32* @stderr
%1352 = call i32 @fputs(i8* %1350, i32 %1351)
%1353 = load i32, i32* @stderr
%1354 = load i32, i32* %93
%1355 = sub nsw i32 0, %1354
%1356 = call i8* @strerror(i32 %1355)
%1357 = call i32 @fprintf(i32 %1353, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.3, i64 0, i64 0), i8* %1356)
br label %1358
1358: ; preds = %1349, %1346
%1359 = load i32, i32* %2
store i32 %1359, i32* %1
br label %1556
1360: ; preds = %1342
br label %1361
1361: ; preds = %1360
br label %1362
1362: ; preds = %1361
%1363 = call i64 @symlink(i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.73, i64 0, i64 0), i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.101, i64 0, i64 0))
%1364 = icmp slt i64 %1363, 0
br i1 %1364, label %1365, label %1368
1365: ; preds = %1362
%1366 = load i32, i32* @errno
%1367 = sub nsw i32 0, %1366
br label %1369
1368: ; preds = %1362
br label %1369
1369: ; preds = %1368, %1365
%1370 = phi i32 [ %1367, %1365 ], [ 0, %1368 ]
store i32 %1370, i32* %2
store i32 %1370, i32* %95
%1371 = load i32, i32* %95
%1372 = icmp slt i32 %1371, 0
br i1 %1372, label %1373, label %1387
1373: ; preds = %1369
store i8* getelementptr inbounds ([48 x i8], [48 x i8]* @.str.102, i64 0, i64 0), i8** %96
%1374 = load i8*, i8** %96
%1375 = icmp ne i8* %1374, null
br i1 %1375, label %1376, label %1385
1376: ; preds = %1373
%1377 = load i8*, i8** %96
%1378 = load i32, i32* @stderr
%1379 = call i32 @fputs(i8* %1377, i32 %1378)
%1380 = load i32, i32* @stderr
%1381 = load i32, i32* %95
%1382 = sub nsw i32 0, %1381
%1383 = call i8* @strerror(i32 %1382)
%1384 = call i32 @fprintf(i32 %1380, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.3, i64 0, i64 0), i8* %1383)
br label %1385
1385: ; preds = %1376, %1373
%1386 = load i32, i32* %2
store i32 %1386, i32* %1
br label %1556
1387: ; preds = %1369
br label %1388
1388: ; preds = %1387
br label %1389
1389: ; preds = %1388
%1390 = call i64 @symlink(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.81, i64 0, i64 0), i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.103, i64 0, i64 0))
%1391 = icmp slt i64 %1390, 0
br i1 %1391, label %1392, label %1395
1392: ; preds = %1389
%1393 = load i32, i32* @errno
%1394 = sub nsw i32 0, %1393
br label %1396
1395: ; preds = %1389
br label %1396
1396: ; preds = %1395, %1392
%1397 = phi i32 [ %1394, %1392 ], [ 0, %1395 ]
store i32 %1397, i32* %2
store i32 %1397, i32* %97
%1398 = load i32, i32* %97
%1399 = icmp slt i32 %1398, 0
br i1 %1399, label %1400, label %1414
1400: ; preds = %1396
store i8* getelementptr inbounds ([53 x i8], [53 x i8]* @.str.104, i64 0, i64 0), i8** %98
%1401 = load i8*, i8** %98
%1402 = icmp ne i8* %1401, null
br i1 %1402, label %1403, label %1412
1403: ; preds = %1400
%1404 = load i8*, i8** %98
%1405 = load i32, i32* @stderr
%1406 = call i32 @fputs(i8* %1404, i32 %1405)
%1407 = load i32, i32* @stderr
%1408 = load i32, i32* %97
%1409 = sub nsw i32 0, %1408
%1410 = call i8* @strerror(i32 %1409)
%1411 = call i32 @fprintf(i32 %1407, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.3, i64 0, i64 0), i8* %1410)
br label %1412
1412: ; preds = %1403, %1400
%1413 = load i32, i32* %2
store i32 %1413, i32* %1
br label %1556
1414: ; preds = %1396
br label %1415
1415: ; preds = %1414
br label %1416
1416: ; preds = %1415
%1417 = call i64 @symlink(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.81, i64 0, i64 0), i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str.105, i64 0, i64 0))
%1418 = icmp slt i64 %1417, 0
br i1 %1418, label %1419, label %1422
1419: ; preds = %1416
%1420 = load i32, i32* @errno
%1421 = sub nsw i32 0, %1420
br label %1423
1422: ; preds = %1416
br label %1423
1423: ; preds = %1422, %1419
%1424 = phi i32 [ %1421, %1419 ], [ 0, %1422 ]
store i32 %1424, i32* %2
store i32 %1424, i32* %99
%1425 = load i32, i32* %99
%1426 = icmp slt i32 %1425, 0
br i1 %1426, label %1427, label %1441
1427: ; preds = %1423
store i8* getelementptr inbounds ([54 x i8], [54 x i8]* @.str.106, i64 0, i64 0), i8** %100
%1428 = load i8*, i8** %100
%1429 = icmp ne i8* %1428, null
br i1 %1429, label %1430, label %1439
1430: ; preds = %1427
%1431 = load i8*, i8** %100
%1432 = load i32, i32* @stderr
%1433 = call i32 @fputs(i8* %1431, i32 %1432)
%1434 = load i32, i32* @stderr
%1435 = load i32, i32* %99
%1436 = sub nsw i32 0, %1435
%1437 = call i8* @strerror(i32 %1436)
%1438 = call i32 @fprintf(i32 %1434, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.3, i64 0, i64 0), i8* %1437)
br label %1439
1439: ; preds = %1430, %1427
%1440 = load i32, i32* %2
store i32 %1440, i32* %1
br label %1556
1441: ; preds = %1423
br label %1442
1442: ; preds = %1441
br label %1443
1443: ; preds = %1442
%1444 = call i64 @mkdir(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.107, i64 0, i64 0), i32 493)
%1445 = icmp slt i64 %1444, 0
br i1 %1445, label %1446, label %1449
1446: ; preds = %1443
%1447 = load i32, i32* @errno
%1448 = sub nsw i32 0, %1447
br label %1450
1449: ; preds = %1443
br label %1450
1450: ; preds = %1449, %1446
%1451 = phi i32 [ %1448, %1446 ], [ 0, %1449 ]
store i32 %1451, i32* %2
store i32 %1451, i32* %101
%1452 = load i32, i32* %101
%1453 = icmp slt i32 %1452, 0
br i1 %1453, label %1454, label %1468
1454: ; preds = %1450
store i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.108, i64 0, i64 0), i8** %102
%1455 = load i8*, i8** %102
%1456 = icmp ne i8* %1455, null
br i1 %1456, label %1457, label %1466
1457: ; preds = %1454
%1458 = load i8*, i8** %102
%1459 = load i32, i32* @stderr
%1460 = call i32 @fputs(i8* %1458, i32 %1459)
%1461 = load i32, i32* @stderr
%1462 = load i32, i32* %101
%1463 = sub nsw i32 0, %1462
%1464 = call i8* @strerror(i32 %1463)
%1465 = call i32 @fprintf(i32 %1461, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.3, i64 0, i64 0), i8* %1464)
br label %1466
1466: ; preds = %1457, %1454
%1467 = load i32, i32* %2
store i32 %1467, i32* %1
br label %1556
1468: ; preds = %1450
br label %1469
1469: ; preds = %1468
br label %1470
1470: ; preds = %1469
%1471 = load i32, i32* @MS_BIND
%1472 = call i64 @mount(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.109, i64 0, i64 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.107, i64 0, i64 0), i8* null, i32 %1471, i8* null)
%1473 = icmp slt i64 %1472, 0
br i1 %1473, label %1474, label %1477
1474: ; preds = %1470
%1475 = load i32, i32* @errno
%1476 = sub nsw i32 0, %1475
br label %1478
1477: ; preds = %1470
br label %1478
1478: ; preds = %1477, %1474
%1479 = phi i32 [ %1476, %1474 ], [ 0, %1477 ]
store i32 %1479, i32* %2
store i32 %1479, i32* %103
%1480 = load i32, i32* %103
%1481 = icmp slt i32 %1480, 0
br i1 %1481, label %1482, label %1496
1482: ; preds = %1478
store i8* getelementptr inbounds ([42 x i8], [42 x i8]* @.str.110, i64 0, i64 0), i8** %104
%1483 = load i8*, i8** %104
%1484 = icmp ne i8* %1483, null
br i1 %1484, label %1485, label %1494
1485: ; preds = %1482
%1486 = load i8*, i8** %104
%1487 = load i32, i32* @stderr
%1488 = call i32 @fputs(i8* %1486, i32 %1487)
%1489 = load i32, i32* @stderr
%1490 = load i32, i32* %103
%1491 = sub nsw i32 0, %1490
%1492 = call i8* @strerror(i32 %1491)
%1493 = call i32 @fprintf(i32 %1489, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.3, i64 0, i64 0), i8* %1492)
br label %1494
1494: ; preds = %1485, %1482
%1495 = load i32, i32* %2
store i32 %1495, i32* %1
br label %1556
1496: ; preds = %1478
br label %1497
1497: ; preds = %1496
br label %1498
1498: ; preds = %1497
%1499 = call i64 @mkdir(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.111, i64 0, i64 0), i32 1023)
%1500 = icmp slt i64 %1499, 0
br i1 %1500, label %1501, label %1504
1501: ; preds = %1498
%1502 = load i32, i32* @errno
%1503 = sub nsw i32 0, %1502
br label %1505
1504: ; preds = %1498
br label %1505
1505: ; preds = %1504, %1501
%1506 = phi i32 [ %1503, %1501 ], [ 0, %1504 ]
store i32 %1506, i32* %2
store i32 %1506, i32* %105
%1507 = load i32, i32* %105
%1508 = icmp slt i32 %1507, 0
br i1 %1508, label %1509, label %1523
1509: ; preds = %1505
store i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.112, i64 0, i64 0), i8** %106
%1510 = load i8*, i8** %106
%1511 = icmp ne i8* %1510, null
br i1 %1511, label %1512, label %1521
1512: ; preds = %1509
%1513 = load i8*, i8** %106
%1514 = load i32, i32* @stderr
%1515 = call i32 @fputs(i8* %1513, i32 %1514)
%1516 = load i32, i32* @stderr
%1517 = load i32, i32* %105
%1518 = sub nsw i32 0, %1517
%1519 = call i8* @strerror(i32 %1518)
%1520 = call i32 @fprintf(i32 %1516, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.3, i64 0, i64 0), i8* %1519)
br label %1521
1521: ; preds = %1512, %1509
%1522 = load i32, i32* %2
store i32 %1522, i32* %1
br label %1556
1523: ; preds = %1505
br label %1524
1524: ; preds = %1523
br label %1525
1525: ; preds = %1524
%1526 = load i32, i32* @MS_NOSUID
%1527 = load i32, i32* @MS_NODEV
%1528 = or i32 %1526, %1527
%1529 = call i64 @mount(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.59, i64 0, i64 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.111, i64 0, i64 0), i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.59, i64 0, i64 0), i32 %1528, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.113, i64 0, i64 0))
%1530 = icmp slt i64 %1529, 0
br i1 %1530, label %1531, label %1534
1531: ; preds = %1525
%1532 = load i32, i32* @errno
%1533 = sub nsw i32 0, %1532
br label %1535
1534: ; preds = %1525
br label %1535
1535: ; preds = %1534, %1531
%1536 = phi i32 [ %1533, %1531 ], [ 0, %1534 ]
store i32 %1536, i32* %2
store i32 %1536, i32* %107
%1537 = load i32, i32* %107
%1538 = icmp slt i32 %1537, 0
br i1 %1538, label %1539, label %1553
1539: ; preds = %1535
store i8* getelementptr inbounds ([64 x i8], [64 x i8]* @.str.114, i64 0, i64 0), i8** %108
%1540 = load i8*, i8** %108
%1541 = icmp ne i8* %1540, null
br i1 %1541, label %1542, label %1551
1542: ; preds = %1539
%1543 = load i8*, i8** %108
%1544 = load i32, i32* @stderr
%1545 = call i32 @fputs(i8* %1543, i32 %1544)
%1546 = load i32, i32* @stderr
%1547 = load i32, i32* %107
%1548 = sub nsw i32 0, %1547
%1549 = call i8* @strerror(i32 %1548)
%1550 = call i32 @fprintf(i32 %1546, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.3, i64 0, i64 0), i8* %1549)
br label %1551
1551: ; preds = %1542, %1539
%1552 = load i32, i32* %2
store i32 %1552, i32* %1
br label %1556
1553: ; preds = %1535
br label %1554
1554: ; preds = %1553
%1555 = load i32, i32* %2
store i32 %1555, i32* %1
br label %1556
1556: ; preds = %1554, %1551, %1521, %1494, %1466, %1439, %1412, %1385, %1358, %1330, %1298, %1269, %1237, %1208, %1176, %1147, %1115, %1086, %1054, %1025, %993, %964, %932, %903, %871, %843, %811, %784, %752, %725, %698, %671, %639, %612, %585, %557, %537, %515, %495, %473, %453, %431, %411, %389, %369, %348, %321, %294, %267, %240, %213, %186, %159, %132
%1557 = load i32, i32* %1
ret i32 %1557
}

LLVM IR (-O2):
@.str = [8 x i8] c"usr/bin\00"
@.str.1 = [4 x i8] c"bin\00"
@errno = global i32 0
@.str.2 = [26 x i8] c"symlink(\22usr/bin\22, \22bin\22)\00"
@stderr = global i32 0
@.str.3 = [6 x i8] c": %s\0A\00"
@.str.4 = [5 x i8] c"sbin\00"
@.str.5 = [27 x i8] c"symlink(\22usr/bin\22, \22sbin\22)\00"
@.str.6 = [8 x i8] c"usr/lib\00"
@.str.7 = [4 x i8] c"lib\00"
@.str.8 = [26 x i8] c"symlink(\22usr/lib\22, \22lib\22)\00"
@.str.9 = [6 x i8] c"lib64\00"
@.str.10 = [28 x i8] c"symlink(\22usr/lib\22, \22lib64\22)\00"
@.str.11 = [4 x i8] c"dev\00"
@.str.12 = [19 x i8] c"mkdir(\22dev\22, 0755)\00"
@.str.13 = [14 x i8] c"/proc/self/fd\00"
@.str.14 = [7 x i8] c"dev/fd\00"
@.str.15 = [35 x i8] c"symlink(\22/proc/self/fd\22, \22dev/fd\22)\00"
@.str.16 = [16 x i8] c"/proc/self/fd/0\00"
@.str.17 = [10 x i8] c"dev/stdin\00"
@.str.18 = [40 x i8] c"symlink(\22/proc/self/fd/0\22, \22dev/stdin\22)\00"
@.str.19 = [16 x i8] c"/proc/self/fd/1\00"
@.str.20 = [11 x i8] c"dev/stdout\00"
@.str.21 = [41 x i8] c"symlink(\22/proc/self/fd/1\22, \22dev/stdout\22)\00"
@.str.22 = [16 x i8] c"/proc/self/fd/2\00"
@.str.23 = [11 x i8] c"dev/stderr\00"
@.str.24 = [41 x i8] c"symlink(\22/proc/self/fd/2\22, \22dev/stderr\22)\00"
@.str.25 = [9 x i8] c"dev/null\00"
@.str.26 = [18 x i8] c"touch(\22dev/null\22)\00"
@.str.27 = [10 x i8] c"/dev/null\00"
@.str.28 = [39 x i8] c"bind_mount(\22/\22 \22dev/null\22, \22dev/null\22)\00"
@.str.29 = [9 x i8] c"dev/zero\00"
@.str.30 = [18 x i8] c"touch(\22dev/zero\22)\00"
@.str.31 = [10 x i8] c"/dev/zero\00"
@.str.32 = [39 x i8] c"bind_mount(\22/\22 \22dev/zero\22, \22dev/zero\22)\00"
@.str.33 = [9 x i8] c"dev/full\00"
@.str.34 = [18 x i8] c"touch(\22dev/full\22)\00"
@.str.35 = [10 x i8] c"/dev/full\00"
@.str.36 = [39 x i8] c"bind_mount(\22/\22 \22dev/full\22, \22dev/full\22)\00"
@.str.37 = [11 x i8] c"dev/random\00"
@.str.38 = [20 x i8] c"touch(\22dev/random\22)\00"
@.str.39 = [12 x i8] c"/dev/random\00"
@.str.40 = [43 x i8] c"bind_mount(\22/\22 \22dev/random\22, \22dev/random\22)\00"
@.str.41 = [12 x i8] c"dev/urandom\00"
@.str.42 = [21 x i8] c"touch(\22dev/urandom\22)\00"
@.str.43 = [13 x i8] c"/dev/urandom\00"
@.str.44 = [45 x i8] c"bind_mount(\22/\22 \22dev/urandom\22, \22dev/urandom\22)\00"
@.str.45 = [4 x i8] c"etc\00"
@.str.46 = [19 x i8] c"mkdir(\22etc\22, 0755)\00"
@.str.47 = [20 x i8] c"../proc/self/mounts\00"
@.str.48 = [9 x i8] c"etc/mtab\00"
@.str.49 = [43 x i8] c"symlink(\22../proc/self/mounts\22, \22etc/mtab\22)\00"
@.str.50 = [5 x i8] c"proc\00"
@.str.51 = [20 x i8] c"mkdir(\22proc\22, 0755)\00"
@MS_NOSUID = global i32 0
@MS_NODEV = global i32 0
@MS_NOEXEC = global i32 0
@.str.52 = [70 x i8] c"mount(\22proc\22, \22proc\22, \22proc\22, MS_NOSUID | MS_NODEV | MS_NOEXEC, NULL)\00"
@.str.53 = [4 x i8] c"sys\00"
@.str.54 = [19 x i8] c"mkdir(\22sys\22, 0755)\00"
@.str.55 = [7 x i8] c"sys/fs\00"
@.str.56 = [22 x i8] c"mkdir(\22sys/fs\22, 0755)\00"
@.str.57 = [14 x i8] c"sys/fs/cgroup\00"
@.str.58 = [29 x i8] c"mkdir(\22sys/fs/cgroup\22, 0755)\00"
@.str.59 = [6 x i8] c"tmpfs\00"
@.str.60 = [9 x i8] c"mode=755\00"
@.str.61 = [87 x i8] c"mount(\22tmpfs\22, \22sys/fs/cgroup\22, \22tmpfs\22, MS_NOSUID | MS_NODEV | MS_NOEXEC, \22mode=755\22)\00"
@.str.62 = [22 x i8] c"sys/fs/cgroup/unified\00"
@.str.63 = [37 x i8] c"mkdir(\22sys/fs/cgroup/unified\22, 0755)\00"
@.str.64 = [7 x i8] c"cgroup\00"
@.str.65 = [8 x i8] c"cgroup2\00"
@.str.66 = [92 x i8] c"mount(\22cgroup\22, \22sys/fs/cgroup/unified\22, \22cgroup2\22, MS_NOSUID | MS_NODEV | MS_NOEXEC, NULL)\00"
@.str.67 = [22 x i8] c"sys/fs/cgroup/freezer\00"
@.str.68 = [40 x i8] c"mkdir(\22sys/fs/cgroup/\22 \22freezer\22, 0755)\00"
@.str.69 = [8 x i8] c"freezer\00"
@.str.70 = [99 x i8] c"mount(\22cgroup\22, \22sys/fs/cgroup/\22 \22freezer\22, \22cgroup\22, MS_NOSUID | MS_NODEV | MS_NOEXEC, \22freezer\22)\00"
@.str.71 = [26 x i8] c"sys/fs/cgroup/cpu,cpuacct\00"
@.str.72 = [44 x i8] c"mkdir(\22sys/fs/cgroup/\22 \22cpu,cpuacct\22, 0755)\00"
@.str.73 = [12 x i8] c"cpu,cpuacct\00"
@.str.74 = [107 x i8] c"mount(\22cgroup\22, \22sys/fs/cgroup/\22 \22cpu,cpuacct\22, \22cgroup\22, MS_NOSUID | MS_NODEV | MS_NOEXEC, \22cpu,cpuacct\22)\00"
@.str.75 = [21 x i8] c"sys/fs/cgroup/cpuset\00"
@.str.76 = [39 x i8] c"mkdir(\22sys/fs/cgroup/\22 \22cpuset\22, 0755)\00"
@.str.77 = [7 x i8] c"cpuset\00"
@.str.78 = [97 x i8] c"mount(\22cgroup\22, \22sys/fs/cgroup/\22 \22cpuset\22, \22cgroup\22, MS_NOSUID | MS_NODEV | MS_NOEXEC, \22cpuset\22)\00"
@.str.79 = [31 x i8] c"sys/fs/cgroup/net_cls,net_prio\00"
@.str.80 = [49 x i8] c"mkdir(\22sys/fs/cgroup/\22 \22net_cls,net_prio\22, 0755)\00"
@.str.81 = [17 x i8] c"net_cls,net_prio\00"
@.str.82 = [117 x i8] c"mount(\22cgroup\22, \22sys/fs/cgroup/\22 \22net_cls,net_prio\22, \22cgroup\22, MS_NOSUID | MS_NODEV | MS_NOEXEC, \22net_cls,net_prio\22)\00"
@.str.83 = [19 x i8] c"sys/fs/cgroup/pids\00"
@.str.84 = [37 x i8] c"mkdir(\22sys/fs/cgroup/\22 \22pids\22, 0755)\00"
@.str.85 = [5 x i8] c"pids\00"
@.str.86 = [93 x i8] c"mount(\22cgroup\22, \22sys/fs/cgroup/\22 \22pids\22, \22cgroup\22, MS_NOSUID | MS_NODEV | MS_NOEXEC, \22pids\22)\00"
@.str.87 = [20 x i8] c"sys/fs/cgroup/blkio\00"
@.str.88 = [38 x i8] c"mkdir(\22sys/fs/cgroup/\22 \22blkio\22, 0755)\00"
@.str.89 = [6 x i8] c"blkio\00"
@.str.90 = [95 x i8] c"mount(\22cgroup\22, \22sys/fs/cgroup/\22 \22blkio\22, \22cgroup\22, MS_NOSUID | MS_NODEV | MS_NOEXEC, \22blkio\22)\00"
@.str.91 = [22 x i8] c"sys/fs/cgroup/devices\00"
@.str.92 = [40 x i8] c"mkdir(\22sys/fs/cgroup/\22 \22devices\22, 0755)\00"
@.str.93 = [8 x i8] c"devices\00"
@.str.94 = [99 x i8] c"mount(\22cgroup\22, \22sys/fs/cgroup/\22 \22devices\22, \22cgroup\22, MS_NOSUID | MS_NODEV | MS_NOEXEC, \22devices\22)\00"
@.str.95 = [21 x i8] c"sys/fs/cgroup/memory\00"
@.str.96 = [39 x i8] c"mkdir(\22sys/fs/cgroup/\22 \22memory\22, 0755)\00"
@.str.97 = [7 x i8] c"memory\00"
@.str.98 = [97 x i8] c"mount(\22cgroup\22, \22sys/fs/cgroup/\22 \22memory\22, \22cgroup\22, MS_NOSUID | MS_NODEV | MS_NOEXEC, \22memory\22)\00"
@.str.99 = [18 x i8] c"sys/fs/cgroup/cpu\00"
@.str.100 = [44 x i8] c"symlink(\22cpu,cpuacct\22, \22sys/fs/cgroup/cpu\22)\00"
@.str.101 = [22 x i8] c"sys/fs/cgroup/cpuacct\00"
@.str.102 = [48 x i8] c"symlink(\22cpu,cpuacct\22, \22sys/fs/cgroup/cpuacct\22)\00"
@.str.103 = [22 x i8] c"sys/fs/cgroup/net_cls\00"
@.str.104 = [53 x i8] c"symlink(\22net_cls,net_prio\22, \22sys/fs/cgroup/net_cls\22)\00"
@.str.105 = [23 x i8] c"sys/fs/cgroup/net_prio\00"
@.str.106 = [54 x i8] c"symlink(\22net_cls,net_prio\22, \22sys/fs/cgroup/net_prio\22)\00"
@.str.107 = [4 x i8] c"usr\00"
@.str.108 = [19 x i8] c"mkdir(\22usr\22, 0755)\00"
@.str.109 = [5 x i8] c"/usr\00"
@MS_BIND = global i32 0
@.str.110 = [42 x i8] c"mount(\22/usr\22, \22usr\22, NULL, MS_BIND, NULL)\00"
@.str.111 = [4 x i8] c"tmp\00"
@.str.112 = [20 x i8] c"mkdir(\22tmp\22, 01777)\00"
@.str.113 = [8 x i8] c"size=1g\00"
@.str.114 = [64 x i8] c"mount(\22tmpfs\22, \22tmp\22, \22tmpfs\22, MS_NOSUID | MS_NODEV, \22size=1g\22)\00"
define i32 @populate_root() {
%1 = tail call i64 @symlink(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0))
%2 = icmp slt i64 %1, 0
%3 = load i32, i32* @errno
%4 = sub nsw i32 0, %3
%5 = select i1 %2, i32 %4, i32 0
%6 = icmp slt i32 %5, 0
br i1 %6, label %390, label %7
7: ; preds = %0
%8 = tail call i64 @symlink(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.4, i64 0, i64 0))
%9 = icmp slt i64 %8, 0
%10 = load i32, i32* @errno
%11 = sub nsw i32 0, %10
%12 = select i1 %9, i32 %11, i32 0
%13 = icmp slt i32 %12, 0
br i1 %13, label %390, label %14
14: ; preds = %7
%15 = tail call i64 @symlink(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.6, i64 0, i64 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.7, i64 0, i64 0))
%16 = icmp slt i64 %15, 0
%17 = load i32, i32* @errno
%18 = sub nsw i32 0, %17
%19 = select i1 %16, i32 %18, i32 0
%20 = icmp slt i32 %19, 0
br i1 %20, label %390, label %21
21: ; preds = %14
%22 = tail call i64 @symlink(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.6, i64 0, i64 0), i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.9, i64 0, i64 0))
%23 = icmp slt i64 %22, 0
%24 = load i32, i32* @errno
%25 = sub nsw i32 0, %24
%26 = select i1 %23, i32 %25, i32 0
%27 = icmp slt i32 %26, 0
br i1 %27, label %390, label %28
28: ; preds = %21
%29 = tail call i64 @mkdir(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.11, i64 0, i64 0), i32 493)
%30 = icmp slt i64 %29, 0
%31 = load i32, i32* @errno
%32 = sub nsw i32 0, %31
%33 = select i1 %30, i32 %32, i32 0
%34 = icmp slt i32 %33, 0
br i1 %34, label %390, label %35
35: ; preds = %28
%36 = tail call i64 @symlink(i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.13, i64 0, i64 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.14, i64 0, i64 0))
%37 = icmp slt i64 %36, 0
%38 = load i32, i32* @errno
%39 = sub nsw i32 0, %38
%40 = select i1 %37, i32 %39, i32 0
%41 = icmp slt i32 %40, 0
br i1 %41, label %390, label %42
42: ; preds = %35
%43 = tail call i64 @symlink(i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.16, i64 0, i64 0), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.17, i64 0, i64 0))
%44 = icmp slt i64 %43, 0
%45 = load i32, i32* @errno
%46 = sub nsw i32 0, %45
%47 = select i1 %44, i32 %46, i32 0
%48 = icmp slt i32 %47, 0
br i1 %48, label %390, label %49
49: ; preds = %42
%50 = tail call i64 @symlink(i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.19, i64 0, i64 0), i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.20, i64 0, i64 0))
%51 = icmp slt i64 %50, 0
%52 = load i32, i32* @errno
%53 = sub nsw i32 0, %52
%54 = select i1 %51, i32 %53, i32 0
%55 = icmp slt i32 %54, 0
br i1 %55, label %390, label %56
56: ; preds = %49
%57 = tail call i64 @symlink(i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.22, i64 0, i64 0), i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.23, i64 0, i64 0))
%58 = icmp slt i64 %57, 0
%59 = load i32, i32* @errno
%60 = sub nsw i32 0, %59
%61 = select i1 %58, i32 %60, i32 0
%62 = icmp slt i32 %61, 0
br i1 %62, label %390, label %63
63: ; preds = %56
%64 = tail call i32 @touch(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.25, i64 0, i64 0))
%65 = icmp slt i32 %64, 0
br i1 %65, label %390, label %66
66: ; preds = %63
%67 = tail call i32 @bind_mount(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.27, i64 0, i64 0), i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.25, i64 0, i64 0))
%68 = icmp slt i32 %67, 0
br i1 %68, label %390, label %69
69: ; preds = %66
%70 = tail call i32 @touch(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.29, i64 0, i64 0))
%71 = icmp slt i32 %70, 0
br i1 %71, label %390, label %72
72: ; preds = %69
%73 = tail call i32 @bind_mount(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.31, i64 0, i64 0), i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.29, i64 0, i64 0))
%74 = icmp slt i32 %73, 0
br i1 %74, label %390, label %75
75: ; preds = %72
%76 = tail call i32 @touch(i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.33, i64 0, i64 0))
%77 = icmp slt i32 %76, 0
br i1 %77, label %390, label %78
78: ; preds = %75
%79 = tail call i32 @bind_mount(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.35, i64 0, i64 0), i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.33, i64 0, i64 0))
%80 = icmp slt i32 %79, 0
br i1 %80, label %390, label %81
81: ; preds = %78
%82 = tail call i32 @touch(i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.37, i64 0, i64 0))
%83 = icmp slt i32 %82, 0
br i1 %83, label %390, label %84
84: ; preds = %81
%85 = tail call i32 @bind_mount(i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.39, i64 0, i64 0), i8* getelementptr inbounds ([11 x i8], [11 x i8]* @.str.37, i64 0, i64 0))
%86 = icmp slt i32 %85, 0
br i1 %86, label %390, label %87
87: ; preds = %84
%88 = tail call i32 @touch(i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.41, i64 0, i64 0))
%89 = icmp slt i32 %88, 0
br i1 %89, label %390, label %90
90: ; preds = %87
%91 = tail call i32 @bind_mount(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.43, i64 0, i64 0), i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.41, i64 0, i64 0))
%92 = icmp slt i32 %91, 0
br i1 %92, label %390, label %93
93: ; preds = %90
%94 = tail call i64 @mkdir(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.45, i64 0, i64 0), i32 493)
%95 = icmp slt i64 %94, 0
%96 = load i32, i32* @errno
%97 = sub nsw i32 0, %96
%98 = select i1 %95, i32 %97, i32 0
%99 = icmp slt i32 %98, 0
br i1 %99, label %390, label %100
100: ; preds = %93
%101 = tail call i64 @symlink(i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.47, i64 0, i64 0), i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.48, i64 0, i64 0))
%102 = icmp slt i64 %101, 0
%103 = load i32, i32* @errno
%104 = sub nsw i32 0, %103
%105 = select i1 %102, i32 %104, i32 0
%106 = icmp slt i32 %105, 0
br i1 %106, label %390, label %107
107: ; preds = %100
%108 = tail call i64 @mkdir(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.50, i64 0, i64 0), i32 493)
%109 = icmp slt i64 %108, 0
%110 = load i32, i32* @errno
%111 = sub nsw i32 0, %110
%112 = select i1 %109, i32 %111, i32 0
%113 = icmp slt i32 %112, 0
br i1 %113, label %390, label %114
114: ; preds = %107
%115 = load i32, i32* @MS_NOSUID
%116 = load i32, i32* @MS_NODEV
%117 = or i32 %116, %115
%118 = load i32, i32* @MS_NOEXEC
%119 = or i32 %117, %118
%120 = tail call i64 @mount(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.50, i64 0, i64 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.50, i64 0, i64 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.50, i64 0, i64 0), i32 %119, i8* null)
%121 = icmp slt i64 %120, 0
%122 = load i32, i32* @errno
%123 = sub nsw i32 0, %122
%124 = select i1 %121, i32 %123, i32 0
%125 = icmp slt i32 %124, 0
br i1 %125, label %390, label %126
126: ; preds = %114
%127 = tail call i64 @mkdir(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.53, i64 0, i64 0), i32 493)
%128 = icmp slt i64 %127, 0
%129 = load i32, i32* @errno
%130 = sub nsw i32 0, %129
%131 = select i1 %128, i32 %130, i32 0
%132 = icmp slt i32 %131, 0
br i1 %132, label %390, label %133
133: ; preds = %126
%134 = tail call i64 @mkdir(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.55, i64 0, i64 0), i32 493)
%135 = icmp slt i64 %134, 0
%136 = load i32, i32* @errno
%137 = sub nsw i32 0, %136
%138 = select i1 %135, i32 %137, i32 0
%139 = icmp slt i32 %138, 0
br i1 %139, label %390, label %140
140: ; preds = %133
%141 = tail call i64 @mkdir(i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.57, i64 0, i64 0), i32 493)
%142 = icmp slt i64 %141, 0
%143 = load i32, i32* @errno
%144 = sub nsw i32 0, %143
%145 = select i1 %142, i32 %144, i32 0
%146 = icmp slt i32 %145, 0
br i1 %146, label %390, label %147
147: ; preds = %140
%148 = load i32, i32* @MS_NOSUID
%149 = load i32, i32* @MS_NODEV
%150 = or i32 %149, %148
%151 = load i32, i32* @MS_NOEXEC
%152 = or i32 %150, %151
%153 = tail call i64 @mount(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.59, i64 0, i64 0), i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.57, i64 0, i64 0), i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.59, i64 0, i64 0), i32 %152, i8* getelementptr inbounds ([9 x i8], [9 x i8]* @.str.60, i64 0, i64 0))
%154 = icmp slt i64 %153, 0
%155 = load i32, i32* @errno
%156 = sub nsw i32 0, %155
%157 = select i1 %154, i32 %156, i32 0
%158 = icmp slt i32 %157, 0
br i1 %158, label %390, label %159
159: ; preds = %147
%160 = tail call i64 @mkdir(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.62, i64 0, i64 0), i32 493)
%161 = icmp slt i64 %160, 0
%162 = load i32, i32* @errno
%163 = sub nsw i32 0, %162
%164 = select i1 %161, i32 %163, i32 0
%165 = icmp slt i32 %164, 0
br i1 %165, label %390, label %166
166: ; preds = %159
%167 = load i32, i32* @MS_NOSUID
%168 = load i32, i32* @MS_NODEV
%169 = or i32 %168, %167
%170 = load i32, i32* @MS_NOEXEC
%171 = or i32 %169, %170
%172 = tail call i64 @mount(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.64, i64 0, i64 0), i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.62, i64 0, i64 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.65, i64 0, i64 0), i32 %171, i8* null)
%173 = icmp slt i64 %172, 0
%174 = load i32, i32* @errno
%175 = sub nsw i32 0, %174
%176 = select i1 %173, i32 %175, i32 0
%177 = icmp slt i32 %176, 0
br i1 %177, label %390, label %178
178: ; preds = %166
%179 = tail call i64 @mkdir(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.67, i64 0, i64 0), i32 493)
%180 = icmp slt i64 %179, 0
%181 = load i32, i32* @errno
%182 = sub nsw i32 0, %181
%183 = select i1 %180, i32 %182, i32 0
%184 = icmp slt i32 %183, 0
br i1 %184, label %390, label %185
185: ; preds = %178
%186 = load i32, i32* @MS_NOSUID
%187 = load i32, i32* @MS_NODEV
%188 = or i32 %187, %186
%189 = load i32, i32* @MS_NOEXEC
%190 = or i32 %188, %189
%191 = tail call i64 @mount(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.64, i64 0, i64 0), i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.67, i64 0, i64 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.64, i64 0, i64 0), i32 %190, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.69, i64 0, i64 0))
%192 = icmp slt i64 %191, 0
%193 = load i32, i32* @errno
%194 = sub nsw i32 0, %193
%195 = select i1 %192, i32 %194, i32 0
%196 = icmp slt i32 %195, 0
br i1 %196, label %390, label %197
197: ; preds = %185
%198 = tail call i64 @mkdir(i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str.71, i64 0, i64 0), i32 493)
%199 = icmp slt i64 %198, 0
%200 = load i32, i32* @errno
%201 = sub nsw i32 0, %200
%202 = select i1 %199, i32 %201, i32 0
%203 = icmp slt i32 %202, 0
br i1 %203, label %390, label %204
204: ; preds = %197
%205 = load i32, i32* @MS_NOSUID
%206 = load i32, i32* @MS_NODEV
%207 = or i32 %206, %205
%208 = load i32, i32* @MS_NOEXEC
%209 = or i32 %207, %208
%210 = tail call i64 @mount(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.64, i64 0, i64 0), i8* getelementptr inbounds ([26 x i8], [26 x i8]* @.str.71, i64 0, i64 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.64, i64 0, i64 0), i32 %209, i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.73, i64 0, i64 0))
%211 = icmp slt i64 %210, 0
%212 = load i32, i32* @errno
%213 = sub nsw i32 0, %212
%214 = select i1 %211, i32 %213, i32 0
%215 = icmp slt i32 %214, 0
br i1 %215, label %390, label %216
216: ; preds = %204
%217 = tail call i64 @mkdir(i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.75, i64 0, i64 0), i32 493)
%218 = icmp slt i64 %217, 0
%219 = load i32, i32* @errno
%220 = sub nsw i32 0, %219
%221 = select i1 %218, i32 %220, i32 0
%222 = icmp slt i32 %221, 0
br i1 %222, label %390, label %223
223: ; preds = %216
%224 = load i32, i32* @MS_NOSUID
%225 = load i32, i32* @MS_NODEV
%226 = or i32 %225, %224
%227 = load i32, i32* @MS_NOEXEC
%228 = or i32 %226, %227
%229 = tail call i64 @mount(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.64, i64 0, i64 0), i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.75, i64 0, i64 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.64, i64 0, i64 0), i32 %228, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.77, i64 0, i64 0))
%230 = icmp slt i64 %229, 0
%231 = load i32, i32* @errno
%232 = sub nsw i32 0, %231
%233 = select i1 %230, i32 %232, i32 0
%234 = icmp slt i32 %233, 0
br i1 %234, label %390, label %235
235: ; preds = %223
%236 = tail call i64 @mkdir(i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str.79, i64 0, i64 0), i32 493)
%237 = icmp slt i64 %236, 0
%238 = load i32, i32* @errno
%239 = sub nsw i32 0, %238
%240 = select i1 %237, i32 %239, i32 0
%241 = icmp slt i32 %240, 0
br i1 %241, label %390, label %242
242: ; preds = %235
%243 = load i32, i32* @MS_NOSUID
%244 = load i32, i32* @MS_NODEV
%245 = or i32 %244, %243
%246 = load i32, i32* @MS_NOEXEC
%247 = or i32 %245, %246
%248 = tail call i64 @mount(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.64, i64 0, i64 0), i8* getelementptr inbounds ([31 x i8], [31 x i8]* @.str.79, i64 0, i64 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.64, i64 0, i64 0), i32 %247, i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.81, i64 0, i64 0))
%249 = icmp slt i64 %248, 0
%250 = load i32, i32* @errno
%251 = sub nsw i32 0, %250
%252 = select i1 %249, i32 %251, i32 0
%253 = icmp slt i32 %252, 0
br i1 %253, label %390, label %254
254: ; preds = %242
%255 = tail call i64 @mkdir(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.83, i64 0, i64 0), i32 493)
%256 = icmp slt i64 %255, 0
%257 = load i32, i32* @errno
%258 = sub nsw i32 0, %257
%259 = select i1 %256, i32 %258, i32 0
%260 = icmp slt i32 %259, 0
br i1 %260, label %390, label %261
261: ; preds = %254
%262 = load i32, i32* @MS_NOSUID
%263 = load i32, i32* @MS_NODEV
%264 = or i32 %263, %262
%265 = load i32, i32* @MS_NOEXEC
%266 = or i32 %264, %265
%267 = tail call i64 @mount(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.64, i64 0, i64 0), i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.83, i64 0, i64 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.64, i64 0, i64 0), i32 %266, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.85, i64 0, i64 0))
%268 = icmp slt i64 %267, 0
%269 = load i32, i32* @errno
%270 = sub nsw i32 0, %269
%271 = select i1 %268, i32 %270, i32 0
%272 = icmp slt i32 %271, 0
br i1 %272, label %390, label %273
273: ; preds = %261
%274 = tail call i64 @mkdir(i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.87, i64 0, i64 0), i32 493)
%275 = icmp slt i64 %274, 0
%276 = load i32, i32* @errno
%277 = sub nsw i32 0, %276
%278 = select i1 %275, i32 %277, i32 0
%279 = icmp slt i32 %278, 0
br i1 %279, label %390, label %280
280: ; preds = %273
%281 = load i32, i32* @MS_NOSUID
%282 = load i32, i32* @MS_NODEV
%283 = or i32 %282, %281
%284 = load i32, i32* @MS_NOEXEC
%285 = or i32 %283, %284
%286 = tail call i64 @mount(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.64, i64 0, i64 0), i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str.87, i64 0, i64 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.64, i64 0, i64 0), i32 %285, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.89, i64 0, i64 0))
%287 = icmp slt i64 %286, 0
%288 = load i32, i32* @errno
%289 = sub nsw i32 0, %288
%290 = select i1 %287, i32 %289, i32 0
%291 = icmp slt i32 %290, 0
br i1 %291, label %390, label %292
292: ; preds = %280
%293 = tail call i64 @mkdir(i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.91, i64 0, i64 0), i32 493)
%294 = icmp slt i64 %293, 0
%295 = load i32, i32* @errno
%296 = sub nsw i32 0, %295
%297 = select i1 %294, i32 %296, i32 0
%298 = icmp slt i32 %297, 0
br i1 %298, label %390, label %299
299: ; preds = %292
%300 = load i32, i32* @MS_NOSUID
%301 = load i32, i32* @MS_NODEV
%302 = or i32 %301, %300
%303 = load i32, i32* @MS_NOEXEC
%304 = or i32 %302, %303
%305 = tail call i64 @mount(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.64, i64 0, i64 0), i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.91, i64 0, i64 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.64, i64 0, i64 0), i32 %304, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.93, i64 0, i64 0))
%306 = icmp slt i64 %305, 0
%307 = load i32, i32* @errno
%308 = sub nsw i32 0, %307
%309 = select i1 %306, i32 %308, i32 0
%310 = icmp slt i32 %309, 0
br i1 %310, label %390, label %311
311: ; preds = %299
%312 = tail call i64 @mkdir(i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.95, i64 0, i64 0), i32 493)
%313 = icmp slt i64 %312, 0
%314 = load i32, i32* @errno
%315 = sub nsw i32 0, %314
%316 = select i1 %313, i32 %315, i32 0
%317 = icmp slt i32 %316, 0
br i1 %317, label %390, label %318
318: ; preds = %311
%319 = load i32, i32* @MS_NOSUID
%320 = load i32, i32* @MS_NODEV
%321 = or i32 %320, %319
%322 = load i32, i32* @MS_NOEXEC
%323 = or i32 %321, %322
%324 = tail call i64 @mount(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.64, i64 0, i64 0), i8* getelementptr inbounds ([21 x i8], [21 x i8]* @.str.95, i64 0, i64 0), i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.64, i64 0, i64 0), i32 %323, i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.97, i64 0, i64 0))
%325 = icmp slt i64 %324, 0
%326 = load i32, i32* @errno
%327 = sub nsw i32 0, %326
%328 = select i1 %325, i32 %327, i32 0
%329 = icmp slt i32 %328, 0
br i1 %329, label %390, label %330
330: ; preds = %318
%331 = tail call i64 @symlink(i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.73, i64 0, i64 0), i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str.99, i64 0, i64 0))
%332 = icmp slt i64 %331, 0
%333 = load i32, i32* @errno
%334 = sub nsw i32 0, %333
%335 = select i1 %332, i32 %334, i32 0
%336 = icmp slt i32 %335, 0
br i1 %336, label %390, label %337
337: ; preds = %330
%338 = tail call i64 @symlink(i8* getelementptr inbounds ([12 x i8], [12 x i8]* @.str.73, i64 0, i64 0), i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.101, i64 0, i64 0))
%339 = icmp slt i64 %338, 0
%340 = load i32, i32* @errno
%341 = sub nsw i32 0, %340
%342 = select i1 %339, i32 %341, i32 0
%343 = icmp slt i32 %342, 0
br i1 %343, label %390, label %344
344: ; preds = %337
%345 = tail call i64 @symlink(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.81, i64 0, i64 0), i8* getelementptr inbounds ([22 x i8], [22 x i8]* @.str.103, i64 0, i64 0))
%346 = icmp slt i64 %345, 0
%347 = load i32, i32* @errno
%348 = sub nsw i32 0, %347
%349 = select i1 %346, i32 %348, i32 0
%350 = icmp slt i32 %349, 0
br i1 %350, label %390, label %351
351: ; preds = %344
%352 = tail call i64 @symlink(i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.81, i64 0, i64 0), i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str.105, i64 0, i64 0))
%353 = icmp slt i64 %352, 0
%354 = load i32, i32* @errno
%355 = sub nsw i32 0, %354
%356 = select i1 %353, i32 %355, i32 0
%357 = icmp slt i32 %356, 0
br i1 %357, label %390, label %358
358: ; preds = %351
%359 = tail call i64 @mkdir(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.107, i64 0, i64 0), i32 493)
%360 = icmp slt i64 %359, 0
%361 = load i32, i32* @errno
%362 = sub nsw i32 0, %361
%363 = select i1 %360, i32 %362, i32 0
%364 = icmp slt i32 %363, 0
br i1 %364, label %390, label %365
365: ; preds = %358
%366 = load i32, i32* @MS_BIND
%367 = tail call i64 @mount(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.109, i64 0, i64 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.107, i64 0, i64 0), i8* null, i32 %366, i8* null)
%368 = icmp slt i64 %367, 0
%369 = load i32, i32* @errno
%370 = sub nsw i32 0, %369
%371 = select i1 %368, i32 %370, i32 0
%372 = icmp slt i32 %371, 0
br i1 %372, label %390, label %373
373: ; preds = %365
%374 = tail call i64 @mkdir(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.111, i64 0, i64 0), i32 1023)
%375 = icmp slt i64 %374, 0
%376 = load i32, i32* @errno
%377 = sub nsw i32 0, %376
%378 = select i1 %375, i32 %377, i32 0
%379 = icmp slt i32 %378, 0
br i1 %379, label %390, label %380
380: ; preds = %373
%381 = load i32, i32* @MS_NOSUID
%382 = load i32, i32* @MS_NODEV
%383 = or i32 %382, %381
%384 = tail call i64 @mount(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.59, i64 0, i64 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.111, i64 0, i64 0), i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.59, i64 0, i64 0), i32 %383, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.113, i64 0, i64 0))
%385 = icmp slt i64 %384, 0
%386 = load i32, i32* @errno
%387 = sub nsw i32 0, %386
%388 = select i1 %385, i32 %387, i32 0
%389 = icmp slt i32 %388, 0
br i1 %389, label %390, label %400
390: ; preds = %380, %373, %365, %358, %351, %344, %337, %330, %318, %311, %299, %292, %280, %273, %261, %254, %242, %235, %223, %216, %204, %197, %185, %178, %166, %159, %147, %140, %133, %126, %114, %107, %100, %93, %90, %87, %84, %81, %78, %75, %72, %69, %66, %63, %56, %49, %42, %35, %28, %21, %14, %7, %0
%391 = phi i8* [ getelementptr inbounds ([26 x i8], [26 x i8]* @.str.2, i64 0, i64 0), %0 ], [ getelementptr inbounds ([27 x i8], [27 x i8]* @.str.5, i64 0, i64 0), %7 ], [ getelementptr inbounds ([26 x i8], [26 x i8]* @.str.8, i64 0, i64 0), %14 ], [ getelementptr inbounds ([28 x i8], [28 x i8]* @.str.10, i64 0, i64 0), %21 ], [ getelementptr inbounds ([19 x i8], [19 x i8]* @.str.12, i64 0, i64 0), %28 ], [ getelementptr inbounds ([35 x i8], [35 x i8]* @.str.15, i64 0, i64 0), %35 ], [ getelementptr inbounds ([40 x i8], [40 x i8]* @.str.18, i64 0, i64 0), %42 ], [ getelementptr inbounds ([41 x i8], [41 x i8]* @.str.21, i64 0, i64 0), %49 ], [ getelementptr inbounds ([41 x i8], [41 x i8]* @.str.24, i64 0, i64 0), %56 ], [ getelementptr inbounds ([18 x i8], [18 x i8]* @.str.26, i64 0, i64 0), %63 ], [ getelementptr inbounds ([39 x i8], [39 x i8]* @.str.28, i64 0, i64 0), %66 ], [ getelementptr inbounds ([18 x i8], [18 x i8]* @.str.30, i64 0, i64 0), %69 ], [ getelementptr inbounds ([39 x i8], [39 x i8]* @.str.32, i64 0, i64 0), %72 ], [ getelementptr inbounds ([18 x i8], [18 x i8]* @.str.34, i64 0, i64 0), %75 ], [ getelementptr inbounds ([39 x i8], [39 x i8]* @.str.36, i64 0, i64 0), %78 ], [ getelementptr inbounds ([20 x i8], [20 x i8]* @.str.38, i64 0, i64 0), %81 ], [ getelementptr inbounds ([43 x i8], [43 x i8]* @.str.40, i64 0, i64 0), %84 ], [ getelementptr inbounds ([21 x i8], [21 x i8]* @.str.42, i64 0, i64 0), %87 ], [ getelementptr inbounds ([45 x i8], [45 x i8]* @.str.44, i64 0, i64 0), %90 ], [ getelementptr inbounds ([19 x i8], [19 x i8]* @.str.46, i64 0, i64 0), %93 ], [ getelementptr inbounds ([43 x i8], [43 x i8]* @.str.49, i64 0, i64 0), %100 ], [ getelementptr inbounds ([20 x i8], [20 x i8]* @.str.51, i64 0, i64 0), %107 ], [ getelementptr inbounds ([70 x i8], [70 x i8]* @.str.52, i64 0, i64 0), %114 ], [ getelementptr inbounds ([19 x i8], [19 x i8]* @.str.54, i64 0, i64 0), %126 ], [ getelementptr inbounds ([22 x i8], [22 x i8]* @.str.56, i64 0, i64 0), %133 ], [ getelementptr inbounds ([29 x i8], [29 x i8]* @.str.58, i64 0, i64 0), %140 ], [ getelementptr inbounds ([87 x i8], [87 x i8]* @.str.61, i64 0, i64 0), %147 ], [ getelementptr inbounds ([37 x i8], [37 x i8]* @.str.63, i64 0, i64 0), %159 ], [ getelementptr inbounds ([92 x i8], [92 x i8]* @.str.66, i64 0, i64 0), %166 ], [ getelementptr inbounds ([40 x i8], [40 x i8]* @.str.68, i64 0, i64 0), %178 ], [ getelementptr inbounds ([99 x i8], [99 x i8]* @.str.70, i64 0, i64 0), %185 ], [ getelementptr inbounds ([44 x i8], [44 x i8]* @.str.72, i64 0, i64 0), %197 ], [ getelementptr inbounds ([107 x i8], [107 x i8]* @.str.74, i64 0, i64 0), %204 ], [ getelementptr inbounds ([39 x i8], [39 x i8]* @.str.76, i64 0, i64 0), %216 ], [ getelementptr inbounds ([97 x i8], [97 x i8]* @.str.78, i64 0, i64 0), %223 ], [ getelementptr inbounds ([49 x i8], [49 x i8]* @.str.80, i64 0, i64 0), %235 ], [ getelementptr inbounds ([117 x i8], [117 x i8]* @.str.82, i64 0, i64 0), %242 ], [ getelementptr inbounds ([37 x i8], [37 x i8]* @.str.84, i64 0, i64 0), %254 ], [ getelementptr inbounds ([93 x i8], [93 x i8]* @.str.86, i64 0, i64 0), %261 ], [ getelementptr inbounds ([38 x i8], [38 x i8]* @.str.88, i64 0, i64 0), %273 ], [ getelementptr inbounds ([95 x i8], [95 x i8]* @.str.90, i64 0, i64 0), %280 ], [ getelementptr inbounds ([40 x i8], [40 x i8]* @.str.92, i64 0, i64 0), %292 ], [ getelementptr inbounds ([99 x i8], [99 x i8]* @.str.94, i64 0, i64 0), %299 ], [ getelementptr inbounds ([39 x i8], [39 x i8]* @.str.96, i64 0, i64 0), %311 ], [ getelementptr inbounds ([97 x i8], [97 x i8]* @.str.98, i64 0, i64 0), %318 ], [ getelementptr inbounds ([44 x i8], [44 x i8]* @.str.100, i64 0, i64 0), %330 ], [ getelementptr inbounds ([48 x i8], [48 x i8]* @.str.102, i64 0, i64 0), %337 ], [ getelementptr inbounds ([53 x i8], [53 x i8]* @.str.104, i64 0, i64 0), %344 ], [ getelementptr inbounds ([54 x i8], [54 x i8]* @.str.106, i64 0, i64 0), %351 ], [ getelementptr inbounds ([19 x i8], [19 x i8]* @.str.108, i64 0, i64 0), %358 ], [ getelementptr inbounds ([42 x i8], [42 x i8]* @.str.110, i64 0, i64 0), %365 ], [ getelementptr inbounds ([20 x i8], [20 x i8]* @.str.112, i64 0, i64 0), %373 ], [ getelementptr inbounds ([64 x i8], [64 x i8]* @.str.114, i64 0, i64 0), %380 ]
%392 = phi i32 [ %5, %0 ], [ %12, %7 ], [ %19, %14 ], [ %26, %21 ], [ %33, %28 ], [ %40, %35 ], [ %47, %42 ], [ %54, %49 ], [ %61, %56 ], [ %64, %63 ], [ %67, %66 ], [ %70, %69 ], [ %73, %72 ], [ %76, %75 ], [ %79, %78 ], [ %82, %81 ], [ %85, %84 ], [ %88, %87 ], [ %91, %90 ], [ %98, %93 ], [ %105, %100 ], [ %112, %107 ], [ %124, %114 ], [ %131, %126 ], [ %138, %133 ], [ %145, %140 ], [ %157, %147 ], [ %164, %159 ], [ %176, %166 ], [ %183, %178 ], [ %195, %185 ], [ %202, %197 ], [ %214, %204 ], [ %221, %216 ], [ %233, %223 ], [ %240, %235 ], [ %252, %242 ], [ %259, %254 ], [ %271, %261 ], [ %278, %273 ], [ %290, %280 ], [ %297, %292 ], [ %309, %299 ], [ %316, %311 ], [ %328, %318 ], [ %335, %330 ], [ %342, %337 ], [ %349, %344 ], [ %356, %351 ], [ %363, %358 ], [ %371, %365 ], [ %378, %373 ], [ %388, %380 ]
%393 = phi i32 [ %4, %0 ], [ %11, %7 ], [ %18, %14 ], [ %25, %21 ], [ %32, %28 ], [ %39, %35 ], [ %46, %42 ], [ %53, %49 ], [ %60, %56 ], [ %64, %63 ], [ %67, %66 ], [ %70, %69 ], [ %73, %72 ], [ %76, %75 ], [ %79, %78 ], [ %82, %81 ], [ %85, %84 ], [ %88, %87 ], [ %91, %90 ], [ %97, %93 ], [ %104, %100 ], [ %111, %107 ], [ %123, %114 ], [ %130, %126 ], [ %137, %133 ], [ %144, %140 ], [ %156, %147 ], [ %163, %159 ], [ %175, %166 ], [ %182, %178 ], [ %194, %185 ], [ %201, %197 ], [ %213, %204 ], [ %220, %216 ], [ %232, %223 ], [ %239, %235 ], [ %251, %242 ], [ %258, %254 ], [ %270, %261 ], [ %277, %273 ], [ %289, %280 ], [ %296, %292 ], [ %308, %299 ], [ %315, %311 ], [ %327, %318 ], [ %334, %330 ], [ %341, %337 ], [ %348, %344 ], [ %355, %351 ], [ %362, %358 ], [ %370, %365 ], [ %377, %373 ], [ %387, %380 ]
%394 = load i32, i32* @stderr
%395 = tail call i32 @fputs(i8* %391, i32 %394)
%396 = load i32, i32* @stderr
%397 = sub nsw i32 0, %392
%398 = tail call i8* @strerror(i32 %397)
%399 = tail call i32 @fprintf(i32 %396, i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.3, i64 0, i64 0), i8* %398)
br label %400
400: ; preds = %390, %380
%401 = phi i32 [ %388, %380 ], [ %393, %390 ]
ret i32 %401
}