// https://syzkaller.appspot.com/bug?id=319d600149b51a6469bb9813513414e4a983e63e
// autogenerated by syzkaller (http://github.com/google/syzkaller)

#define _GNU_SOURCE
#include <dirent.h>
#include <endian.h>
#include <errno.h>
#include <linux/net.h>
#include <netinet/in.h>
#include <signal.h>
#include <stdarg.h>
#include <stdio.h>
#include <sys/mount.h>
#include <sys/prctl.h>
#include <sys/socket.h>
#include <sys/syscall.h>
#include <sys/time.h>
#include <sys/wait.h>
#include <time.h>
#include <unistd.h>

__attribute__((noreturn)) static void doexit(int status)
{
  volatile unsigned i;
  syscall(__NR_exit_group, status);
  for (i = 0;; i++) {
  }
}
#include <errno.h>
#include <setjmp.h>
#include <signal.h>
#include <stdarg.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <string.h>
#include <sys/stat.h>

const int kFailStatus = 67;
const int kRetryStatus = 69;

static void fail(const char* msg, ...)
{
  int e = errno;
  va_list args;
  va_start(args, msg);
  vfprintf(stderr, msg, args);
  va_end(args);
  fprintf(stderr, " (errno %d)\n", e);
  doexit((e == ENOMEM || e == EAGAIN) ? kRetryStatus : kFailStatus);
}

static void exitf(const char* msg, ...)
{
  int e = errno;
  va_list args;
  va_start(args, msg);
  vfprintf(stderr, msg, args);
  va_end(args);
  fprintf(stderr, " (errno %d)\n", e);
  doexit(kRetryStatus);
}

#define BITMASK_LEN(type, bf_len) (type)((1ull << (bf_len)) - 1)

#define BITMASK_LEN_OFF(type, bf_off, bf_len)                                  \
  (type)(BITMASK_LEN(type, (bf_len)) << (bf_off))

#define STORE_BY_BITMASK(type, addr, val, bf_off, bf_len)                      \
  if ((bf_off) == 0 && (bf_len) == 0) {                                        \
    *(type*)(addr) = (type)(val);                                              \
  } else {                                                                     \
    type new_val = *(type*)(addr);                                             \
    new_val &= ~BITMASK_LEN_OFF(type, (bf_off), (bf_len));                     \
    new_val |= ((type)(val)&BITMASK_LEN(type, (bf_len))) << (bf_off);          \
    *(type*)(addr) = new_val;                                                  \
  }

struct csum_inet {
  uint32_t acc;
};

static void csum_inet_init(struct csum_inet* csum)
{
  csum->acc = 0;
}

static void csum_inet_update(struct csum_inet* csum, const uint8_t* data,
                             size_t length)
{
  if (length == 0)
    return;

  size_t i;
  for (i = 0; i < length - 1; i += 2)
    csum->acc += *(uint16_t*)&data[i];

  if (length & 1)
    csum->acc += (uint16_t)data[length - 1];

  while (csum->acc > 0xffff)
    csum->acc = (csum->acc & 0xffff) + (csum->acc >> 16);
}

static uint16_t csum_inet_digest(struct csum_inet* csum)
{
  return ~csum->acc;
}

static __thread int skip_segv;
static __thread jmp_buf segv_env;

static void segv_handler(int sig, siginfo_t* info, void* uctx)
{
  uintptr_t addr = (uintptr_t)info->si_addr;
  const uintptr_t prog_start = 1 << 20;
  const uintptr_t prog_end = 100 << 20;
  if (__atomic_load_n(&skip_segv, __ATOMIC_RELAXED) &&
      (addr < prog_start || addr > prog_end)) {
    _longjmp(segv_env, 1);
  }
  doexit(sig);
}

static void install_segv_handler()
{
  struct sigaction sa;

  memset(&sa, 0, sizeof(sa));
  sa.sa_handler = SIG_IGN;
  syscall(SYS_rt_sigaction, 0x20, &sa, NULL, 8);
  syscall(SYS_rt_sigaction, 0x21, &sa, NULL, 8);

  memset(&sa, 0, sizeof(sa));
  sa.sa_sigaction = segv_handler;
  sa.sa_flags = SA_NODEFER | SA_SIGINFO;
  sigaction(SIGSEGV, &sa, NULL);
  sigaction(SIGBUS, &sa, NULL);
}

#define NONFAILING(...)                                                        \
  {                                                                            \
    __atomic_fetch_add(&skip_segv, 1, __ATOMIC_SEQ_CST);                       \
    if (_setjmp(segv_env) == 0) {                                              \
      __VA_ARGS__;                                                             \
    }                                                                          \
    __atomic_fetch_sub(&skip_segv, 1, __ATOMIC_SEQ_CST);                       \
  }

static uint64_t current_time_ms()
{
  struct timespec ts;

  if (clock_gettime(CLOCK_MONOTONIC, &ts))
    fail("clock_gettime failed");
  return (uint64_t)ts.tv_sec * 1000 + (uint64_t)ts.tv_nsec / 1000000;
}

static void use_temporary_dir()
{
  char tmpdir_template[] = "./syzkaller.XXXXXX";
  char* tmpdir = mkdtemp(tmpdir_template);
  if (!tmpdir)
    fail("failed to mkdtemp");
  if (chmod(tmpdir, 0777))
    fail("failed to chmod");
  if (chdir(tmpdir))
    fail("failed to chdir");
}

#define XT_TABLE_SIZE 1536
#define XT_MAX_ENTRIES 10

struct xt_counters {
  uint64_t pcnt, bcnt;
};

struct ipt_getinfo {
  char name[32];
  unsigned int valid_hooks;
  unsigned int hook_entry[5];
  unsigned int underflow[5];
  unsigned int num_entries;
  unsigned int size;
};

struct ipt_get_entries {
  char name[32];
  unsigned int size;
  void* entrytable[XT_TABLE_SIZE / sizeof(void*)];
};

struct ipt_replace {
  char name[32];
  unsigned int valid_hooks;
  unsigned int num_entries;
  unsigned int size;
  unsigned int hook_entry[5];
  unsigned int underflow[5];
  unsigned int num_counters;
  struct xt_counters* counters;
  char entrytable[XT_TABLE_SIZE];
};

struct ipt_table_desc {
  const char* name;
  struct ipt_getinfo info;
  struct ipt_replace replace;
};

static struct ipt_table_desc ipv4_tables[] = {
    {.name = "filter"}, {.name = "nat"},      {.name = "mangle"},
    {.name = "raw"},    {.name = "security"},
};

static struct ipt_table_desc ipv6_tables[] = {
    {.name = "filter"}, {.name = "nat"},      {.name = "mangle"},
    {.name = "raw"},    {.name = "security"},
};

#define IPT_BASE_CTL 64
#define IPT_SO_SET_REPLACE (IPT_BASE_CTL)
#define IPT_SO_GET_INFO (IPT_BASE_CTL)
#define IPT_SO_GET_ENTRIES (IPT_BASE_CTL + 1)

struct arpt_getinfo {
  char name[32];
  unsigned int valid_hooks;
  unsigned int hook_entry[3];
  unsigned int underflow[3];
  unsigned int num_entries;
  unsigned int size;
};

struct arpt_get_entries {
  char name[32];
  unsigned int size;
  void* entrytable[XT_TABLE_SIZE / sizeof(void*)];
};

struct arpt_replace {
  char name[32];
  unsigned int valid_hooks;
  unsigned int num_entries;
  unsigned int size;
  unsigned int hook_entry[3];
  unsigned int underflow[3];
  unsigned int num_counters;
  struct xt_counters* counters;
  char entrytable[XT_TABLE_SIZE];
};

struct arpt_table_desc {
  const char* name;
  struct arpt_getinfo info;
  struct arpt_replace replace;
};

static struct arpt_table_desc arpt_tables[] = {
    {.name = "filter"},
};

#define ARPT_BASE_CTL 96
#define ARPT_SO_SET_REPLACE (ARPT_BASE_CTL)
#define ARPT_SO_GET_INFO (ARPT_BASE_CTL)
#define ARPT_SO_GET_ENTRIES (ARPT_BASE_CTL + 1)

static void checkpoint_iptables(struct ipt_table_desc* tables, int num_tables,
                                int family, int level)
{
  struct ipt_get_entries entries;
  socklen_t optlen;
  int fd, i;

  fd = socket(family, SOCK_STREAM, IPPROTO_TCP);
  if (fd == -1)
    fail("socket(%d, SOCK_STREAM, IPPROTO_TCP)", family);
  for (i = 0; i < num_tables; i++) {
    struct ipt_table_desc* table = &tables[i];
    strcpy(table->info.name, table->name);
    strcpy(table->replace.name, table->name);
    optlen = sizeof(table->info);
    if (getsockopt(fd, level, IPT_SO_GET_INFO, &table->info, &optlen)) {
      switch (errno) {
      case EPERM:
      case ENOENT:
      case ENOPROTOOPT:
        continue;
      }
      fail("getsockopt(IPT_SO_GET_INFO)");
    }
    if (table->info.size > sizeof(table->replace.entrytable))
      fail("table size is too large: %u", table->info.size);
    if (table->info.num_entries > XT_MAX_ENTRIES)
      fail("too many counters: %u", table->info.num_entries);
    memset(&entries, 0, sizeof(entries));
    strcpy(entries.name, table->name);
    entries.size = table->info.size;
    optlen = sizeof(entries) - sizeof(entries.entrytable) + table->info.size;
    if (getsockopt(fd, level, IPT_SO_GET_ENTRIES, &entries, &optlen))
      fail("getsockopt(IPT_SO_GET_ENTRIES)");
    table->replace.valid_hooks = table->info.valid_hooks;
    table->replace.num_entries = table->info.num_entries;
    table->replace.size = table->info.size;
    memcpy(table->replace.hook_entry, table->info.hook_entry,
           sizeof(table->replace.hook_entry));
    memcpy(table->replace.underflow, table->info.underflow,
           sizeof(table->replace.underflow));
    memcpy(table->replace.entrytable, entries.entrytable, table->info.size);
  }
  close(fd);
}

static void reset_iptables(struct ipt_table_desc* tables, int num_tables,
                           int family, int level)
{
  struct xt_counters counters[XT_MAX_ENTRIES];
  struct ipt_get_entries entries;
  struct ipt_getinfo info;
  socklen_t optlen;
  int fd, i;

  fd = socket(family, SOCK_STREAM, IPPROTO_TCP);
  if (fd == -1)
    fail("socket(%d, SOCK_STREAM, IPPROTO_TCP)", family);
  for (i = 0; i < num_tables; i++) {
    struct ipt_table_desc* table = &tables[i];
    if (table->info.valid_hooks == 0)
      continue;
    memset(&info, 0, sizeof(info));
    strcpy(info.name, table->name);
    optlen = sizeof(info);
    if (getsockopt(fd, level, IPT_SO_GET_INFO, &info, &optlen))
      fail("getsockopt(IPT_SO_GET_INFO)");
    if (memcmp(&table->info, &info, sizeof(table->info)) == 0) {
      memset(&entries, 0, sizeof(entries));
      strcpy(entries.name, table->name);
      entries.size = table->info.size;
      optlen = sizeof(entries) - sizeof(entries.entrytable) + entries.size;
      if (getsockopt(fd, level, IPT_SO_GET_ENTRIES, &entries, &optlen))
        fail("getsockopt(IPT_SO_GET_ENTRIES)");
      if (memcmp(table->replace.entrytable, entries.entrytable,
                 table->info.size) == 0)
        continue;
    }
    table->replace.num_counters = info.num_entries;
    table->replace.counters = counters;
    optlen = sizeof(table->replace) - sizeof(table->replace.entrytable) +
             table->replace.size;
    if (setsockopt(fd, level, IPT_SO_SET_REPLACE, &table->replace, optlen))
      fail("setsockopt(IPT_SO_SET_REPLACE)");
  }
  close(fd);
}

static void checkpoint_arptables(void)
{
  struct arpt_get_entries entries;
  socklen_t optlen;
  unsigned i;
  int fd;

  fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
  if (fd == -1)
    fail("socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)");
  for (i = 0; i < sizeof(arpt_tables) / sizeof(arpt_tables[0]); i++) {
    struct arpt_table_desc* table = &arpt_tables[i];
    strcpy(table->info.name, table->name);
    strcpy(table->replace.name, table->name);
    optlen = sizeof(table->info);
    if (getsockopt(fd, SOL_IP, ARPT_SO_GET_INFO, &table->info, &optlen)) {
      switch (errno) {
      case EPERM:
      case ENOENT:
      case ENOPROTOOPT:
        continue;
      }
      fail("getsockopt(ARPT_SO_GET_INFO)");
    }
    if (table->info.size > sizeof(table->replace.entrytable))
      fail("table size is too large: %u", table->info.size);
    if (table->info.num_entries > XT_MAX_ENTRIES)
      fail("too many counters: %u", table->info.num_entries);
    memset(&entries, 0, sizeof(entries));
    strcpy(entries.name, table->name);
    entries.size = table->info.size;
    optlen = sizeof(entries) - sizeof(entries.entrytable) + table->info.size;
    if (getsockopt(fd, SOL_IP, ARPT_SO_GET_ENTRIES, &entries, &optlen))
      fail("getsockopt(ARPT_SO_GET_ENTRIES)");
    table->replace.valid_hooks = table->info.valid_hooks;
    table->replace.num_entries = table->info.num_entries;
    table->replace.size = table->info.size;
    memcpy(table->replace.hook_entry, table->info.hook_entry,
           sizeof(table->replace.hook_entry));
    memcpy(table->replace.underflow, table->info.underflow,
           sizeof(table->replace.underflow));
    memcpy(table->replace.entrytable, entries.entrytable, table->info.size);
  }
  close(fd);
}

static void reset_arptables()
{
  struct xt_counters counters[XT_MAX_ENTRIES];
  struct arpt_get_entries entries;
  struct arpt_getinfo info;
  socklen_t optlen;
  unsigned i;
  int fd;

  fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
  if (fd == -1)
    fail("socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)");
  for (i = 0; i < sizeof(arpt_tables) / sizeof(arpt_tables[0]); i++) {
    struct arpt_table_desc* table = &arpt_tables[i];
    if (table->info.valid_hooks == 0)
      continue;
    memset(&info, 0, sizeof(info));
    strcpy(info.name, table->name);
    optlen = sizeof(info);
    if (getsockopt(fd, SOL_IP, ARPT_SO_GET_INFO, &info, &optlen))
      fail("getsockopt(ARPT_SO_GET_INFO)");
    if (memcmp(&table->info, &info, sizeof(table->info)) == 0) {
      memset(&entries, 0, sizeof(entries));
      strcpy(entries.name, table->name);
      entries.size = table->info.size;
      optlen = sizeof(entries) - sizeof(entries.entrytable) + entries.size;
      if (getsockopt(fd, SOL_IP, ARPT_SO_GET_ENTRIES, &entries, &optlen))
        fail("getsockopt(ARPT_SO_GET_ENTRIES)");
      if (memcmp(table->replace.entrytable, entries.entrytable,
                 table->info.size) == 0)
        continue;
    }
    table->replace.num_counters = info.num_entries;
    table->replace.counters = counters;
    optlen = sizeof(table->replace) - sizeof(table->replace.entrytable) +
             table->replace.size;
    if (setsockopt(fd, SOL_IP, ARPT_SO_SET_REPLACE, &table->replace, optlen))
      fail("setsockopt(ARPT_SO_SET_REPLACE)");
  }
  close(fd);
}
#include <linux/if.h>
#include <linux/netfilter_bridge/ebtables.h>

struct ebt_table_desc {
  const char* name;
  struct ebt_replace replace;
  char entrytable[XT_TABLE_SIZE];
};

static struct ebt_table_desc ebt_tables[] = {
    {.name = "filter"}, {.name = "nat"}, {.name = "broute"},
};

static void checkpoint_ebtables(void)
{
  socklen_t optlen;
  unsigned i;
  int fd;

  fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
  if (fd == -1)
    fail("socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)");
  for (i = 0; i < sizeof(ebt_tables) / sizeof(ebt_tables[0]); i++) {
    struct ebt_table_desc* table = &ebt_tables[i];
    strcpy(table->replace.name, table->name);
    optlen = sizeof(table->replace);
    if (getsockopt(fd, SOL_IP, EBT_SO_GET_INIT_INFO, &table->replace,
                   &optlen)) {
      switch (errno) {
      case EPERM:
      case ENOENT:
      case ENOPROTOOPT:
        continue;
      }
      fail("getsockopt(EBT_SO_GET_INIT_INFO)");
    }
    if (table->replace.entries_size > sizeof(table->entrytable))
      fail("table size is too large: %u", table->replace.entries_size);
    table->replace.num_counters = 0;
    table->replace.entries = table->entrytable;
    optlen = sizeof(table->replace) + table->replace.entries_size;
    if (getsockopt(fd, SOL_IP, EBT_SO_GET_INIT_ENTRIES, &table->replace,
                   &optlen))
      fail("getsockopt(EBT_SO_GET_INIT_ENTRIES)");
  }
  close(fd);
}

static void reset_ebtables()
{
  struct ebt_replace replace;
  char entrytable[XT_TABLE_SIZE];
  socklen_t optlen;
  unsigned i, j, h;
  int fd;

  fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
  if (fd == -1)
    fail("socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)");
  for (i = 0; i < sizeof(ebt_tables) / sizeof(ebt_tables[0]); i++) {
    struct ebt_table_desc* table = &ebt_tables[i];
    if (table->replace.valid_hooks == 0)
      continue;
    memset(&replace, 0, sizeof(replace));
    strcpy(replace.name, table->name);
    optlen = sizeof(replace);
    if (getsockopt(fd, SOL_IP, EBT_SO_GET_INFO, &replace, &optlen))
      fail("getsockopt(EBT_SO_GET_INFO)");
    replace.num_counters = 0;
    for (h = 0; h < NF_BR_NUMHOOKS; h++)
      table->replace.hook_entry[h] = 0;
    if (memcmp(&table->replace, &replace, sizeof(table->replace)) == 0) {
      memset(&entrytable, 0, sizeof(entrytable));
      replace.entries = entrytable;
      optlen = sizeof(replace) + replace.entries_size;
      if (getsockopt(fd, SOL_IP, EBT_SO_GET_ENTRIES, &replace, &optlen))
        fail("getsockopt(EBT_SO_GET_ENTRIES)");
      if (memcmp(table->entrytable, entrytable, replace.entries_size) == 0)
        continue;
    }
    for (j = 0, h = 0; h < NF_BR_NUMHOOKS; h++) {
      if (table->replace.valid_hooks & (1 << h)) {
        table->replace.hook_entry[h] =
            (struct ebt_entries*)table->entrytable + j;
        j++;
      }
    }
    optlen = sizeof(table->replace) + table->replace.entries_size;
    if (setsockopt(fd, SOL_IP, EBT_SO_SET_ENTRIES, &table->replace, optlen))
      fail("setsockopt(EBT_SO_SET_ENTRIES)");
  }
  close(fd);
}

static void checkpoint_net_namespace(void)
{
  checkpoint_ebtables();
  checkpoint_arptables();
  checkpoint_iptables(ipv4_tables, sizeof(ipv4_tables) / sizeof(ipv4_tables[0]),
                      AF_INET, SOL_IP);
  checkpoint_iptables(ipv6_tables, sizeof(ipv6_tables) / sizeof(ipv6_tables[0]),
                      AF_INET6, SOL_IPV6);
}

static void reset_net_namespace(void)
{
  reset_ebtables();
  reset_arptables();
  reset_iptables(ipv4_tables, sizeof(ipv4_tables) / sizeof(ipv4_tables[0]),
                 AF_INET, SOL_IP);
  reset_iptables(ipv6_tables, sizeof(ipv6_tables) / sizeof(ipv6_tables[0]),
                 AF_INET6, SOL_IPV6);
}

static void remove_dir(const char* dir)
{
  DIR* dp;
  struct dirent* ep;
  int iter = 0;
retry:
  dp = opendir(dir);
  if (dp == NULL) {
    if (errno == EMFILE) {
      exitf("opendir(%s) failed due to NOFILE, exiting", dir);
    }
    exitf("opendir(%s) failed", dir);
  }
  while ((ep = readdir(dp))) {
    if (strcmp(ep->d_name, ".") == 0 || strcmp(ep->d_name, "..") == 0)
      continue;
    char filename[FILENAME_MAX];
    snprintf(filename, sizeof(filename), "%s/%s", dir, ep->d_name);
    struct stat st;
    if (lstat(filename, &st))
      exitf("lstat(%s) failed", filename);
    if (S_ISDIR(st.st_mode)) {
      remove_dir(filename);
      continue;
    }
    int i;
    for (i = 0;; i++) {
      if (unlink(filename) == 0)
        break;
      if (errno == EROFS) {
        break;
      }
      if (errno != EBUSY || i > 100)
        exitf("unlink(%s) failed", filename);
      if (umount2(filename, MNT_DETACH))
        exitf("umount(%s) failed", filename);
    }
  }
  closedir(dp);
  int i;
  for (i = 0;; i++) {
    if (rmdir(dir) == 0)
      break;
    if (i < 100) {
      if (errno == EROFS) {
        break;
      }
      if (errno == EBUSY) {
        if (umount2(dir, MNT_DETACH))
          exitf("umount(%s) failed", dir);
        continue;
      }
      if (errno == ENOTEMPTY) {
        if (iter < 100) {
          iter++;
          goto retry;
        }
      }
    }
    exitf("rmdir(%s) failed", dir);
  }
}

static void test();

void loop()
{
  int iter;
  checkpoint_net_namespace();
  for (iter = 0;; iter++) {
    char cwdbuf[256];
    sprintf(cwdbuf, "./%d", iter);
    if (mkdir(cwdbuf, 0777))
      fail("failed to mkdir");
    int pid = fork();
    if (pid < 0)
      fail("loop fork failed");
    if (pid == 0) {
      prctl(PR_SET_PDEATHSIG, SIGKILL, 0, 0, 0);
      setpgrp();
      if (chdir(cwdbuf))
        fail("failed to chdir");
      test();
      doexit(0);
    }
    int status = 0;
    uint64_t start = current_time_ms();
    for (;;) {
      int res = waitpid(-1, &status, __WALL | WNOHANG);
      if (res == pid)
        break;
      usleep(1000);
      if (current_time_ms() - start > 5 * 1000) {
        kill(-pid, SIGKILL);
        kill(pid, SIGKILL);
        while (waitpid(-1, &status, __WALL) != pid) {
        }
        break;
      }
    }
    remove_dir(cwdbuf);
    reset_net_namespace();
  }
}

long r[1];
void test()
{
  memset(r, -1, sizeof(r));
  r[0] = syscall(__NR_socket, 0xa, 2, 0);
  NONFAILING(memcpy((void*)0x20000000, "\x66\x69\x6c\x74\x65\x72\x00\x00\x00"
                                       "\x00\x00\x00\x00\x00\x00\x00\x00\x00"
                                       "\x00\x00\x00\x00\x00\x00\x00\x00\x00"
                                       "\x00\x00\x00\x00\x00",
                    32));
  NONFAILING(*(uint32_t*)0x20000020 = 0xe);
  NONFAILING(*(uint32_t*)0x20000024 = 4);
  NONFAILING(*(uint32_t*)0x20000028 = 0x510);
  NONFAILING(*(uint32_t*)0x2000002c = -1);
  NONFAILING(*(uint32_t*)0x20000030 = 0xd0);
  NONFAILING(*(uint32_t*)0x20000034 = 0xd0);
  NONFAILING(*(uint32_t*)0x20000038 = 0xd0);
  NONFAILING(*(uint32_t*)0x2000003c = -1);
  NONFAILING(*(uint32_t*)0x20000040 = -1);
  NONFAILING(*(uint32_t*)0x20000044 = 0x440);
  NONFAILING(*(uint32_t*)0x20000048 = 0x440);
  NONFAILING(*(uint32_t*)0x2000004c = 0x440);
  NONFAILING(*(uint32_t*)0x20000050 = -1);
  NONFAILING(*(uint32_t*)0x20000054 = 4);
  NONFAILING(*(uint64_t*)0x20000058 = 0x20c6a000);
  NONFAILING(*(uint8_t*)0x20000060 = 0xfe);
  NONFAILING(*(uint8_t*)0x20000061 = 0x80);
  NONFAILING(*(uint8_t*)0x20000062 = 0);
  NONFAILING(*(uint8_t*)0x20000063 = 0);
  NONFAILING(*(uint8_t*)0x20000064 = 0);
  NONFAILING(*(uint8_t*)0x20000065 = 0);
  NONFAILING(*(uint8_t*)0x20000066 = 0);
  NONFAILING(*(uint8_t*)0x20000067 = 0);
  NONFAILING(*(uint8_t*)0x20000068 = 0);
  NONFAILING(*(uint8_t*)0x20000069 = 0);
  NONFAILING(*(uint8_t*)0x2000006a = 0);
  NONFAILING(*(uint8_t*)0x2000006b = 0);
  NONFAILING(*(uint8_t*)0x2000006c = 0);
  NONFAILING(*(uint8_t*)0x2000006d = 0);
  NONFAILING(*(uint8_t*)0x2000006e = 0);
  NONFAILING(*(uint8_t*)0x2000006f = 0xaa);
  NONFAILING(*(uint8_t*)0x20000070 = 0);
  NONFAILING(*(uint8_t*)0x20000071 = 0);
  NONFAILING(*(uint8_t*)0x20000072 = 0);
  NONFAILING(*(uint8_t*)0x20000073 = 0);
  NONFAILING(*(uint8_t*)0x20000074 = 0);
  NONFAILING(*(uint8_t*)0x20000075 = 0);
  NONFAILING(*(uint8_t*)0x20000076 = 0);
  NONFAILING(*(uint8_t*)0x20000077 = 0);
  NONFAILING(*(uint8_t*)0x20000078 = 0);
  NONFAILING(*(uint8_t*)0x20000079 = 0);
  NONFAILING(*(uint8_t*)0x2000007a = -1);
  NONFAILING(*(uint8_t*)0x2000007b = -1);
  NONFAILING(*(uint32_t*)0x2000007c = htobe32(0));
  NONFAILING(*(uint32_t*)0x20000080 = htobe32(0));
  NONFAILING(*(uint32_t*)0x20000084 = htobe32(0));
  NONFAILING(*(uint32_t*)0x20000088 = htobe32(0));
  NONFAILING(*(uint32_t*)0x2000008c = htobe32(0));
  NONFAILING(*(uint32_t*)0x20000090 = htobe32(0));
  NONFAILING(*(uint32_t*)0x20000094 = htobe32(0));
  NONFAILING(*(uint32_t*)0x20000098 = htobe32(0));
  NONFAILING(*(uint32_t*)0x2000009c = htobe32(0));
  NONFAILING(memcpy(
      (void*)0x200000a0,
      "\x65\x72\x73\x70\x61\x6e\x30\x00\x00\x00\x00\x00\x00\x00\x00\x00", 16));
  NONFAILING(*(uint8_t*)0x200000b0 = 0x73);
  NONFAILING(*(uint8_t*)0x200000b1 = 0x79);
  NONFAILING(*(uint8_t*)0x200000b2 = 0x7a);
  NONFAILING(*(uint8_t*)0x200000b3 = 0);
  NONFAILING(*(uint8_t*)0x200000b4 = 0);
  NONFAILING(*(uint8_t*)0x200000c0 = 0);
  NONFAILING(*(uint8_t*)0x200000c1 = 0);
  NONFAILING(*(uint8_t*)0x200000c2 = 0);
  NONFAILING(*(uint8_t*)0x200000c3 = 0);
  NONFAILING(*(uint8_t*)0x200000c4 = 0);
  NONFAILING(*(uint8_t*)0x200000c5 = 0);
  NONFAILING(*(uint8_t*)0x200000c6 = 0);
  NONFAILING(*(uint8_t*)0x200000c7 = 0);
  NONFAILING(*(uint8_t*)0x200000c8 = 0);
  NONFAILING(*(uint8_t*)0x200000c9 = 0);
  NONFAILING(*(uint8_t*)0x200000ca = 0);
  NONFAILING(*(uint8_t*)0x200000cb = 0);
  NONFAILING(*(uint8_t*)0x200000cc = 0);
  NONFAILING(*(uint8_t*)0x200000cd = 0);
  NONFAILING(*(uint8_t*)0x200000ce = 0);
  NONFAILING(*(uint8_t*)0x200000cf = 0);
  NONFAILING(*(uint8_t*)0x200000d0 = 0);
  NONFAILING(*(uint8_t*)0x200000d1 = 0);
  NONFAILING(*(uint8_t*)0x200000d2 = 0);
  NONFAILING(*(uint8_t*)0x200000d3 = 0);
  NONFAILING(*(uint8_t*)0x200000d4 = 0);
  NONFAILING(*(uint8_t*)0x200000d5 = 0);
  NONFAILING(*(uint8_t*)0x200000d6 = 0);
  NONFAILING(*(uint8_t*)0x200000d7 = 0);
  NONFAILING(*(uint8_t*)0x200000d8 = 0);
  NONFAILING(*(uint8_t*)0x200000d9 = 0);
  NONFAILING(*(uint8_t*)0x200000da = 0);
  NONFAILING(*(uint8_t*)0x200000db = 0);
  NONFAILING(*(uint8_t*)0x200000dc = 0);
  NONFAILING(*(uint8_t*)0x200000dd = 0);
  NONFAILING(*(uint8_t*)0x200000de = 0);
  NONFAILING(*(uint8_t*)0x200000df = 0);
  NONFAILING(*(uint16_t*)0x200000e0 = 0);
  NONFAILING(*(uint8_t*)0x200000e2 = 0);
  NONFAILING(*(uint8_t*)0x200000e3 = 0);
  NONFAILING(*(uint8_t*)0x200000e4 = 0);
  NONFAILING(*(uint32_t*)0x200000e8 = 0);
  NONFAILING(*(uint16_t*)0x200000ec = 0xa8);
  NONFAILING(*(uint16_t*)0x200000ee = 0xd0);
  NONFAILING(*(uint32_t*)0x200000f0 = 0);
  NONFAILING(*(uint64_t*)0x200000f8 = 0);
  NONFAILING(*(uint64_t*)0x20000100 = 0);
  NONFAILING(*(uint16_t*)0x20000108 = 0x28);
  NONFAILING(memcpy((void*)0x2000010a, "\x52\x45\x4a\x45\x43\x54\x00\x00\x00"
                                       "\x00\x00\x00\x00\x00\x00\x00\x00\x00"
                                       "\x00\x00\x00\x00\x00\x00\x00\x00\x00"
                                       "\x00\x00",
                    29));
  NONFAILING(*(uint8_t*)0x20000127 = 0);
  NONFAILING(*(uint32_t*)0x20000128 = 0);
  NONFAILING(*(uint8_t*)0x20000130 = 0);
  NONFAILING(*(uint8_t*)0x20000131 = 0);
  NONFAILING(*(uint8_t*)0x20000132 = 0);
  NONFAILING(*(uint8_t*)0x20000133 = 0);
  NONFAILING(*(uint8_t*)0x20000134 = 0);
  NONFAILING(*(uint8_t*)0x20000135 = 0);
  NONFAILING(*(uint8_t*)0x20000136 = 0);
  NONFAILING(*(uint8_t*)0x20000137 = 0);
  NONFAILING(*(uint8_t*)0x20000138 = 0);
  NONFAILING(*(uint8_t*)0x20000139 = 0);
  NONFAILING(*(uint8_t*)0x2000013a = 0);
  NONFAILING(*(uint8_t*)0x2000013b = 0);
  NONFAILING(*(uint8_t*)0x2000013c = 0);
  NONFAILING(*(uint8_t*)0x2000013d = 0);
  NONFAILING(*(uint8_t*)0x2000013e = 0);
  NONFAILING(*(uint8_t*)0x2000013f = 0);
  NONFAILING(*(uint8_t*)0x20000140 = 0);
  NONFAILING(*(uint8_t*)0x20000141 = 0);
  NONFAILING(*(uint8_t*)0x20000142 = 0);
  NONFAILING(*(uint8_t*)0x20000143 = 0);
  NONFAILING(*(uint8_t*)0x20000144 = 0);
  NONFAILING(*(uint8_t*)0x20000145 = 0);
  NONFAILING(*(uint8_t*)0x20000146 = 0);
  NONFAILING(*(uint8_t*)0x20000147 = 0);
  NONFAILING(*(uint8_t*)0x20000148 = 0);
  NONFAILING(*(uint8_t*)0x20000149 = 0);
  NONFAILING(*(uint8_t*)0x2000014a = 0);
  NONFAILING(*(uint8_t*)0x2000014b = 0);
  NONFAILING(*(uint8_t*)0x2000014c = 0);
  NONFAILING(*(uint8_t*)0x2000014d = 0);
  NONFAILING(*(uint8_t*)0x2000014e = 0);
  NONFAILING(*(uint8_t*)0x2000014f = 0);
  NONFAILING(*(uint8_t*)0x20000150 = 0);
  NONFAILING(*(uint8_t*)0x20000151 = 0);
  NONFAILING(*(uint8_t*)0x20000152 = 0);
  NONFAILING(*(uint8_t*)0x20000153 = 0);
  NONFAILING(*(uint8_t*)0x20000154 = 0);
  NONFAILING(*(uint8_t*)0x20000155 = 0);
  NONFAILING(*(uint8_t*)0x20000156 = 0);
  NONFAILING(*(uint8_t*)0x20000157 = 0);
  NONFAILING(*(uint8_t*)0x20000158 = 0);
  NONFAILING(*(uint8_t*)0x20000159 = 0);
  NONFAILING(*(uint8_t*)0x2000015a = 0);
  NONFAILING(*(uint8_t*)0x2000015b = 0);
  NONFAILING(*(uint8_t*)0x2000015c = 0);
  NONFAILING(*(uint8_t*)0x2000015d = 0);
  NONFAILING(*(uint8_t*)0x2000015e = 0);
  NONFAILING(*(uint8_t*)0x2000015f = 0);
  NONFAILING(*(uint8_t*)0x20000160 = 0);
  NONFAILING(*(uint8_t*)0x20000161 = 0);
  NONFAILING(*(uint8_t*)0x20000162 = 0);
  NONFAILING(*(uint8_t*)0x20000163 = 0);
  NONFAILING(*(uint8_t*)0x20000164 = 0);
  NONFAILING(*(uint8_t*)0x20000165 = 0);
  NONFAILING(*(uint8_t*)0x20000166 = 0);
  NONFAILING(*(uint8_t*)0x20000167 = 0);
  NONFAILING(*(uint8_t*)0x20000168 = 0);
  NONFAILING(*(uint8_t*)0x20000169 = 0);
  NONFAILING(*(uint8_t*)0x2000016a = 0);
  NONFAILING(*(uint8_t*)0x2000016b = 0);
  NONFAILING(*(uint8_t*)0x2000016c = 0);
  NONFAILING(*(uint8_t*)0x2000016d = 0);
  NONFAILING(*(uint8_t*)0x2000016e = 0);
  NONFAILING(*(uint8_t*)0x2000016f = 0);
  NONFAILING(*(uint8_t*)0x20000170 = 0);
  NONFAILING(*(uint8_t*)0x20000171 = 0);
  NONFAILING(*(uint8_t*)0x20000172 = 0);
  NONFAILING(*(uint8_t*)0x20000173 = 0);
  NONFAILING(*(uint8_t*)0x20000174 = 0);
  NONFAILING(*(uint8_t*)0x20000175 = 0);
  NONFAILING(*(uint8_t*)0x20000176 = 0);
  NONFAILING(*(uint8_t*)0x20000177 = 0);
  NONFAILING(*(uint8_t*)0x20000178 = 0);
  NONFAILING(*(uint8_t*)0x20000179 = 0);
  NONFAILING(*(uint8_t*)0x2000017a = 0);
  NONFAILING(*(uint8_t*)0x2000017b = 0);
  NONFAILING(*(uint8_t*)0x2000017c = 0);
  NONFAILING(*(uint8_t*)0x2000017d = 0);
  NONFAILING(*(uint8_t*)0x2000017e = 0);
  NONFAILING(*(uint8_t*)0x2000017f = 0);
  NONFAILING(*(uint8_t*)0x20000180 = 0);
  NONFAILING(*(uint8_t*)0x20000181 = 0);
  NONFAILING(*(uint8_t*)0x20000182 = 0);
  NONFAILING(*(uint8_t*)0x20000183 = 0);
  NONFAILING(*(uint8_t*)0x20000184 = 0);
  NONFAILING(*(uint8_t*)0x20000185 = 0);
  NONFAILING(*(uint8_t*)0x20000186 = 0);
  NONFAILING(*(uint8_t*)0x20000187 = 0);
  NONFAILING(*(uint8_t*)0x20000188 = 0);
  NONFAILING(*(uint8_t*)0x20000189 = 0);
  NONFAILING(*(uint8_t*)0x2000018a = 0);
  NONFAILING(*(uint8_t*)0x2000018b = 0);
  NONFAILING(*(uint8_t*)0x2000018c = 0);
  NONFAILING(*(uint8_t*)0x2000018d = 0);
  NONFAILING(*(uint8_t*)0x2000018e = 0);
  NONFAILING(*(uint8_t*)0x2000018f = 0);
  NONFAILING(*(uint8_t*)0x20000190 = 0);
  NONFAILING(*(uint8_t*)0x20000191 = 0);
  NONFAILING(*(uint8_t*)0x20000192 = 0);
  NONFAILING(*(uint8_t*)0x20000193 = 0);
  NONFAILING(*(uint8_t*)0x20000194 = 0);
  NONFAILING(*(uint8_t*)0x20000195 = 0);
  NONFAILING(*(uint8_t*)0x20000196 = 0);
  NONFAILING(*(uint8_t*)0x20000197 = 0);
  NONFAILING(*(uint8_t*)0x20000198 = 0);
  NONFAILING(*(uint8_t*)0x20000199 = 0);
  NONFAILING(*(uint8_t*)0x2000019a = 0);
  NONFAILING(*(uint8_t*)0x2000019b = 0);
  NONFAILING(*(uint8_t*)0x2000019c = 0);
  NONFAILING(*(uint8_t*)0x2000019d = 0);
  NONFAILING(*(uint8_t*)0x2000019e = 0);
  NONFAILING(*(uint8_t*)0x2000019f = 0);
  NONFAILING(*(uint8_t*)0x200001a0 = 0);
  NONFAILING(*(uint8_t*)0x200001a1 = 0);
  NONFAILING(*(uint8_t*)0x200001a2 = 0);
  NONFAILING(*(uint8_t*)0x200001a3 = 0);
  NONFAILING(*(uint8_t*)0x200001a4 = 0);
  NONFAILING(*(uint8_t*)0x200001a5 = 0);
  NONFAILING(*(uint8_t*)0x200001a6 = 0);
  NONFAILING(*(uint8_t*)0x200001a7 = 0);
  NONFAILING(*(uint8_t*)0x200001a8 = 0);
  NONFAILING(*(uint8_t*)0x200001a9 = 0);
  NONFAILING(*(uint8_t*)0x200001aa = 0);
  NONFAILING(*(uint8_t*)0x200001ab = 0);
  NONFAILING(*(uint8_t*)0x200001ac = 0);
  NONFAILING(*(uint8_t*)0x200001ad = 0);
  NONFAILING(*(uint8_t*)0x200001ae = 0);
  NONFAILING(*(uint8_t*)0x200001af = 0);
  NONFAILING(*(uint8_t*)0x200001b0 = 0);
  NONFAILING(*(uint8_t*)0x200001b1 = 0);
  NONFAILING(*(uint8_t*)0x200001b2 = 0);
  NONFAILING(*(uint8_t*)0x200001b3 = 0);
  NONFAILING(*(uint8_t*)0x200001b4 = 0);
  NONFAILING(*(uint8_t*)0x200001b5 = 0);
  NONFAILING(*(uint8_t*)0x200001b6 = 0);
  NONFAILING(*(uint8_t*)0x200001b7 = 0);
  NONFAILING(*(uint32_t*)0x200001b8 = 0);
  NONFAILING(*(uint16_t*)0x200001bc = 0x240);
  NONFAILING(*(uint16_t*)0x200001be = 0x268);
  NONFAILING(*(uint32_t*)0x200001c0 = 0);
  NONFAILING(*(uint64_t*)0x200001c8 = 0);
  NONFAILING(*(uint64_t*)0x200001d0 = 0);
  NONFAILING(*(uint16_t*)0x200001d8 = 0x158);
  NONFAILING(memcpy((void*)0x200001da, "\x68\x61\x73\x68\x6c\x69\x6d\x69\x74"
                                       "\x00\x00\x00\x00\x00\x00\x00\x00\x00"
                                       "\x00\x00\x00\x00\x00\x00\x00\x00\x00"
                                       "\x00\x00",
                    29));
  NONFAILING(*(uint8_t*)0x200001f7 = 3);
  NONFAILING(memcpy(
      (void*)0x200001f8,
      "\x64\x75\x6d\x6d\x79\x30\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
      "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
      "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
      "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
      "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
      "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
      "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
      "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
      "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
      "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
      "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
      "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
      "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
      "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
      "\x00\x00\x00",
      255));
  NONFAILING(*(uint64_t*)0x200002f8 = 6);
  NONFAILING(*(uint64_t*)0x20000300 = 9);
  NONFAILING(*(uint32_t*)0x20000308 = 0x62);
  NONFAILING(*(uint32_t*)0x2000030c = 0);
  NONFAILING(*(uint32_t*)0x20000310 = 0);
  NONFAILING(*(uint32_t*)0x20000314 = 0x80000001);
  NONFAILING(*(uint32_t*)0x20000318 = 0x10000);
  NONFAILING(*(uint32_t*)0x2000031c = 0x10000);
  NONFAILING(*(uint8_t*)0x20000320 = 0);
  NONFAILING(*(uint8_t*)0x20000321 = 0);
  NONFAILING(*(uint64_t*)0x20000328 = 0);
  NONFAILING(*(uint16_t*)0x20000330 = 0x40);
  NONFAILING(memcpy((void*)0x20000332, "\x63\x6f\x6e\x6e\x6c\x69\x6d\x69\x74"
                                       "\x00\x00\x00\x00\x00\x00\x00\x00\x00"
                                       "\x00\x00\x00\x00\x00\x00\x00\x00\x00"
                                       "\x00\x00",
                    29));
  NONFAILING(*(uint8_t*)0x2000034f = 1);
  NONFAILING(*(uint32_t*)0x20000350 = htobe32(0));
  NONFAILING(*(uint32_t*)0x20000354 = htobe32(0));
  NONFAILING(*(uint32_t*)0x20000358 = htobe32(0));
  NONFAILING(*(uint32_t*)0x2000035c = htobe32(0));
  NONFAILING(*(uint32_t*)0x20000360 = 0);
  NONFAILING(*(uint32_t*)0x20000364 = 1);
  NONFAILING(*(uint64_t*)0x20000368 = 0);
  NONFAILING(*(uint16_t*)0x20000370 = 0x28);
  NONFAILING(memcpy((void*)0x20000372, "\x52\x45\x4a\x45\x43\x54\x00\x00\x00"
                                       "\x00\x00\x00\x00\x00\x00\x00\x00\x00"
                                       "\x00\x00\x00\x00\x00\x00\x00\x00\x00"
                                       "\x00\x00",
                    29));
  NONFAILING(*(uint8_t*)0x2000038f = 0);
  NONFAILING(*(uint32_t*)0x20000390 = 0);
  NONFAILING(*(uint8_t*)0x20000398 = 0);
  NONFAILING(*(uint8_t*)0x20000399 = 0);
  NONFAILING(*(uint8_t*)0x2000039a = 0);
  NONFAILING(*(uint8_t*)0x2000039b = 0);
  NONFAILING(*(uint8_t*)0x2000039c = 0);
  NONFAILING(*(uint8_t*)0x2000039d = 0);
  NONFAILING(*(uint8_t*)0x2000039e = 0);
  NONFAILING(*(uint8_t*)0x2000039f = 0);
  NONFAILING(*(uint8_t*)0x200003a0 = 0);
  NONFAILING(*(uint8_t*)0x200003a1 = 0);
  NONFAILING(*(uint8_t*)0x200003a2 = 0);
  NONFAILING(*(uint8_t*)0x200003a3 = 0);
  NONFAILING(*(uint8_t*)0x200003a4 = 0);
  NONFAILING(*(uint8_t*)0x200003a5 = 0);
  NONFAILING(*(uint8_t*)0x200003a6 = 0);
  NONFAILING(*(uint8_t*)0x200003a7 = 0);
  NONFAILING(*(uint8_t*)0x200003a8 = 0);
  NONFAILING(*(uint8_t*)0x200003a9 = 0);
  NONFAILING(*(uint8_t*)0x200003aa = 0);
  NONFAILING(*(uint8_t*)0x200003ab = 0);
  NONFAILING(*(uint8_t*)0x200003ac = 0);
  NONFAILING(*(uint8_t*)0x200003ad = 0);
  NONFAILING(*(uint8_t*)0x200003ae = 0);
  NONFAILING(*(uint8_t*)0x200003af = 0);
  NONFAILING(*(uint8_t*)0x200003b0 = 0);
  NONFAILING(*(uint8_t*)0x200003b1 = 0);
  NONFAILING(*(uint8_t*)0x200003b2 = 0);
  NONFAILING(*(uint8_t*)0x200003b3 = 0);
  NONFAILING(*(uint8_t*)0x200003b4 = 0);
  NONFAILING(*(uint8_t*)0x200003b5 = 0);
  NONFAILING(*(uint8_t*)0x200003b6 = 0);
  NONFAILING(*(uint8_t*)0x200003b7 = 0);
  NONFAILING(*(uint8_t*)0x200003b8 = 0);
  NONFAILING(*(uint8_t*)0x200003b9 = 0);
  NONFAILING(*(uint8_t*)0x200003ba = 0);
  NONFAILING(*(uint8_t*)0x200003bb = 0);
  NONFAILING(*(uint8_t*)0x200003bc = 0);
  NONFAILING(*(uint8_t*)0x200003bd = 0);
  NONFAILING(*(uint8_t*)0x200003be = 0);
  NONFAILING(*(uint8_t*)0x200003bf = 0);
  NONFAILING(*(uint8_t*)0x200003c0 = 0);
  NONFAILING(*(uint8_t*)0x200003c1 = 0);
  NONFAILING(*(uint8_t*)0x200003c2 = 0);
  NONFAILING(*(uint8_t*)0x200003c3 = 0);
  NONFAILING(*(uint8_t*)0x200003c4 = 0);
  NONFAILING(*(uint8_t*)0x200003c5 = 0);
  NONFAILING(*(uint8_t*)0x200003c6 = 0);
  NONFAILING(*(uint8_t*)0x200003c7 = 0);
  NONFAILING(*(uint8_t*)0x200003c8 = 0);
  NONFAILING(*(uint8_t*)0x200003c9 = 0);
  NONFAILING(*(uint8_t*)0x200003ca = 0);
  NONFAILING(*(uint8_t*)0x200003cb = 0);
  NONFAILING(*(uint8_t*)0x200003cc = 0);
  NONFAILING(*(uint8_t*)0x200003cd = 0);
  NONFAILING(*(uint8_t*)0x200003ce = 0);
  NONFAILING(*(uint8_t*)0x200003cf = 0);
  NONFAILING(*(uint8_t*)0x200003d0 = 0);
  NONFAILING(*(uint8_t*)0x200003d1 = 0);
  NONFAILING(*(uint8_t*)0x200003d2 = 0);
  NONFAILING(*(uint8_t*)0x200003d3 = 0);
  NONFAILING(*(uint8_t*)0x200003d4 = 0);
  NONFAILING(*(uint8_t*)0x200003d5 = 0);
  NONFAILING(*(uint8_t*)0x200003d6 = 0);
  NONFAILING(*(uint8_t*)0x200003d7 = 0);
  NONFAILING(*(uint8_t*)0x200003d8 = 0);
  NONFAILING(*(uint8_t*)0x200003d9 = 0);
  NONFAILING(*(uint8_t*)0x200003da = 0);
  NONFAILING(*(uint8_t*)0x200003db = 0);
  NONFAILING(*(uint8_t*)0x200003dc = 0);
  NONFAILING(*(uint8_t*)0x200003dd = 0);
  NONFAILING(*(uint8_t*)0x200003de = 0);
  NONFAILING(*(uint8_t*)0x200003df = 0);
  NONFAILING(*(uint8_t*)0x200003e0 = 0);
  NONFAILING(*(uint8_t*)0x200003e1 = 0);
  NONFAILING(*(uint8_t*)0x200003e2 = 0);
  NONFAILING(*(uint8_t*)0x200003e3 = 0);
  NONFAILING(*(uint8_t*)0x200003e4 = 0);
  NONFAILING(*(uint8_t*)0x200003e5 = 0);
  NONFAILING(*(uint8_t*)0x200003e6 = 0);
  NONFAILING(*(uint8_t*)0x200003e7 = 0);
  NONFAILING(*(uint8_t*)0x200003e8 = 0);
  NONFAILING(*(uint8_t*)0x200003e9 = 0);
  NONFAILING(*(uint8_t*)0x200003ea = 0);
  NONFAILING(*(uint8_t*)0x200003eb = 0);
  NONFAILING(*(uint8_t*)0x200003ec = 0);
  NONFAILING(*(uint8_t*)0x200003ed = 0);
  NONFAILING(*(uint8_t*)0x200003ee = 0);
  NONFAILING(*(uint8_t*)0x200003ef = 0);
  NONFAILING(*(uint8_t*)0x200003f0 = 0);
  NONFAILING(*(uint8_t*)0x200003f1 = 0);
  NONFAILING(*(uint8_t*)0x200003f2 = 0);
  NONFAILING(*(uint8_t*)0x200003f3 = 0);
  NONFAILING(*(uint8_t*)0x200003f4 = 0);
  NONFAILING(*(uint8_t*)0x200003f5 = 0);
  NONFAILING(*(uint8_t*)0x200003f6 = 0);
  NONFAILING(*(uint8_t*)0x200003f7 = 0);
  NONFAILING(*(uint8_t*)0x200003f8 = 0);
  NONFAILING(*(uint8_t*)0x200003f9 = 0);
  NONFAILING(*(uint8_t*)0x200003fa = 0);
  NONFAILING(*(uint8_t*)0x200003fb = 0);
  NONFAILING(*(uint8_t*)0x200003fc = 0);
  NONFAILING(*(uint8_t*)0x200003fd = 0);
  NONFAILING(*(uint8_t*)0x200003fe = 0);
  NONFAILING(*(uint8_t*)0x200003ff = 0);
  NONFAILING(*(uint8_t*)0x20000400 = 0);
  NONFAILING(*(uint8_t*)0x20000401 = 0);
  NONFAILING(*(uint8_t*)0x20000402 = 0);
  NONFAILING(*(uint8_t*)0x20000403 = 0);
  NONFAILING(*(uint8_t*)0x20000404 = 0);
  NONFAILING(*(uint8_t*)0x20000405 = 0);
  NONFAILING(*(uint8_t*)0x20000406 = 0);
  NONFAILING(*(uint8_t*)0x20000407 = 0);
  NONFAILING(*(uint8_t*)0x20000408 = 0);
  NONFAILING(*(uint8_t*)0x20000409 = 0);
  NONFAILING(*(uint8_t*)0x2000040a = 0);
  NONFAILING(*(uint8_t*)0x2000040b = 0);
  NONFAILING(*(uint8_t*)0x2000040c = 0);
  NONFAILING(*(uint8_t*)0x2000040d = 0);
  NONFAILING(*(uint8_t*)0x2000040e = 0);
  NONFAILING(*(uint8_t*)0x2000040f = 0);
  NONFAILING(*(uint8_t*)0x20000410 = 0);
  NONFAILING(*(uint8_t*)0x20000411 = 0);
  NONFAILING(*(uint8_t*)0x20000412 = 0);
  NONFAILING(*(uint8_t*)0x20000413 = 0);
  NONFAILING(*(uint8_t*)0x20000414 = 0);
  NONFAILING(*(uint8_t*)0x20000415 = 0);
  NONFAILING(*(uint8_t*)0x20000416 = 0);
  NONFAILING(*(uint8_t*)0x20000417 = 0);
  NONFAILING(*(uint8_t*)0x20000418 = 0);
  NONFAILING(*(uint8_t*)0x20000419 = 0);
  NONFAILING(*(uint8_t*)0x2000041a = 0);
  NONFAILING(*(uint8_t*)0x2000041b = 0);
  NONFAILING(*(uint8_t*)0x2000041c = 0);
  NONFAILING(*(uint8_t*)0x2000041d = 0);
  NONFAILING(*(uint8_t*)0x2000041e = 0);
  NONFAILING(*(uint8_t*)0x2000041f = 0);
  NONFAILING(*(uint32_t*)0x20000420 = 0);
  NONFAILING(*(uint16_t*)0x20000424 = 0xe0);
  NONFAILING(*(uint16_t*)0x20000426 = 0x108);
  NONFAILING(*(uint32_t*)0x20000428 = 0);
  NONFAILING(*(uint64_t*)0x20000430 = 0);
  NONFAILING(*(uint64_t*)0x20000438 = 0);
  NONFAILING(*(uint16_t*)0x20000440 = 0x38);
  NONFAILING(memcpy((void*)0x20000442, "\x63\x6f\x6e\x6e\x62\x79\x74\x65\x73"
                                       "\x00\x00\x00\x00\x00\x00\x00\x00\x00"
                                       "\x00\x00\x00\x00\x00\x00\x00\x00\x00"
                                       "\x00\x00",
                    29));
  NONFAILING(*(uint8_t*)0x2000045f = 0);
  NONFAILING(*(uint64_t*)0x20000460 = 0);
  NONFAILING(*(uint64_t*)0x20000468 = 0);
  NONFAILING(*(uint8_t*)0x20000470 = 0);
  NONFAILING(*(uint8_t*)0x20000471 = 0);
  NONFAILING(*(uint16_t*)0x20000478 = 0x28);
  NONFAILING(memcpy((void*)0x2000047a, "\x52\x45\x4a\x45\x43\x54\x00\x00\x00"
                                       "\x00\x00\x00\x00\x00\x00\x00\x00\x00"
                                       "\x00\x00\x00\x00\x00\x00\x00\x00\x00"
                                       "\x00\x00",
                    29));
  NONFAILING(*(uint8_t*)0x20000497 = 0);
  NONFAILING(*(uint32_t*)0x20000498 = 0);
  NONFAILING(*(uint8_t*)0x200004a0 = 0);
  NONFAILING(*(uint8_t*)0x200004a1 = 0);
  NONFAILING(*(uint8_t*)0x200004a2 = 0);
  NONFAILING(*(uint8_t*)0x200004a3 = 0);
  NONFAILING(*(uint8_t*)0x200004a4 = 0);
  NONFAILING(*(uint8_t*)0x200004a5 = 0);
  NONFAILING(*(uint8_t*)0x200004a6 = 0);
  NONFAILING(*(uint8_t*)0x200004a7 = 0);
  NONFAILING(*(uint8_t*)0x200004a8 = 0);
  NONFAILING(*(uint8_t*)0x200004a9 = 0);
  NONFAILING(*(uint8_t*)0x200004aa = 0);
  NONFAILING(*(uint8_t*)0x200004ab = 0);
  NONFAILING(*(uint8_t*)0x200004ac = 0);
  NONFAILING(*(uint8_t*)0x200004ad = 0);
  NONFAILING(*(uint8_t*)0x200004ae = 0);
  NONFAILING(*(uint8_t*)0x200004af = 0);
  NONFAILING(*(uint8_t*)0x200004b0 = 0);
  NONFAILING(*(uint8_t*)0x200004b1 = 0);
  NONFAILING(*(uint8_t*)0x200004b2 = 0);
  NONFAILING(*(uint8_t*)0x200004b3 = 0);
  NONFAILING(*(uint8_t*)0x200004b4 = 0);
  NONFAILING(*(uint8_t*)0x200004b5 = 0);
  NONFAILING(*(uint8_t*)0x200004b6 = 0);
  NONFAILING(*(uint8_t*)0x200004b7 = 0);
  NONFAILING(*(uint8_t*)0x200004b8 = 0);
  NONFAILING(*(uint8_t*)0x200004b9 = 0);
  NONFAILING(*(uint8_t*)0x200004ba = 0);
  NONFAILING(*(uint8_t*)0x200004bb = 0);
  NONFAILING(*(uint8_t*)0x200004bc = 0);
  NONFAILING(*(uint8_t*)0x200004bd = 0);
  NONFAILING(*(uint8_t*)0x200004be = 0);
  NONFAILING(*(uint8_t*)0x200004bf = 0);
  NONFAILING(*(uint8_t*)0x200004c0 = 0);
  NONFAILING(*(uint8_t*)0x200004c1 = 0);
  NONFAILING(*(uint8_t*)0x200004c2 = 0);
  NONFAILING(*(uint8_t*)0x200004c3 = 0);
  NONFAILING(*(uint8_t*)0x200004c4 = 0);
  NONFAILING(*(uint8_t*)0x200004c5 = 0);
  NONFAILING(*(uint8_t*)0x200004c6 = 0);
  NONFAILING(*(uint8_t*)0x200004c7 = 0);
  NONFAILING(*(uint8_t*)0x200004c8 = 0);
  NONFAILING(*(uint8_t*)0x200004c9 = 0);
  NONFAILING(*(uint8_t*)0x200004ca = 0);
  NONFAILING(*(uint8_t*)0x200004cb = 0);
  NONFAILING(*(uint8_t*)0x200004cc = 0);
  NONFAILING(*(uint8_t*)0x200004cd = 0);
  NONFAILING(*(uint8_t*)0x200004ce = 0);
  NONFAILING(*(uint8_t*)0x200004cf = 0);
  NONFAILING(*(uint8_t*)0x200004d0 = 0);
  NONFAILING(*(uint8_t*)0x200004d1 = 0);
  NONFAILING(*(uint8_t*)0x200004d2 = 0);
  NONFAILING(*(uint8_t*)0x200004d3 = 0);
  NONFAILING(*(uint8_t*)0x200004d4 = 0);
  NONFAILING(*(uint8_t*)0x200004d5 = 0);
  NONFAILING(*(uint8_t*)0x200004d6 = 0);
  NONFAILING(*(uint8_t*)0x200004d7 = 0);
  NONFAILING(*(uint8_t*)0x200004d8 = 0);
  NONFAILING(*(uint8_t*)0x200004d9 = 0);
  NONFAILING(*(uint8_t*)0x200004da = 0);
  NONFAILING(*(uint8_t*)0x200004db = 0);
  NONFAILING(*(uint8_t*)0x200004dc = 0);
  NONFAILING(*(uint8_t*)0x200004dd = 0);
  NONFAILING(*(uint8_t*)0x200004de = 0);
  NONFAILING(*(uint8_t*)0x200004df = 0);
  NONFAILING(*(uint8_t*)0x200004e0 = 0);
  NONFAILING(*(uint8_t*)0x200004e1 = 0);
  NONFAILING(*(uint8_t*)0x200004e2 = 0);
  NONFAILING(*(uint8_t*)0x200004e3 = 0);
  NONFAILING(*(uint8_t*)0x200004e4 = 0);
  NONFAILING(*(uint8_t*)0x200004e5 = 0);
  NONFAILING(*(uint8_t*)0x200004e6 = 0);
  NONFAILING(*(uint8_t*)0x200004e7 = 0);
  NONFAILING(*(uint8_t*)0x200004e8 = 0);
  NONFAILING(*(uint8_t*)0x200004e9 = 0);
  NONFAILING(*(uint8_t*)0x200004ea = 0);
  NONFAILING(*(uint8_t*)0x200004eb = 0);
  NONFAILING(*(uint8_t*)0x200004ec = 0);
  NONFAILING(*(uint8_t*)0x200004ed = 0);
  NONFAILING(*(uint8_t*)0x200004ee = 0);
  NONFAILING(*(uint8_t*)0x200004ef = 0);
  NONFAILING(*(uint8_t*)0x200004f0 = 0);
  NONFAILING(*(uint8_t*)0x200004f1 = 0);
  NONFAILING(*(uint8_t*)0x200004f2 = 0);
  NONFAILING(*(uint8_t*)0x200004f3 = 0);
  NONFAILING(*(uint8_t*)0x200004f4 = 0);
  NONFAILING(*(uint8_t*)0x200004f5 = 0);
  NONFAILING(*(uint8_t*)0x200004f6 = 0);
  NONFAILING(*(uint8_t*)0x200004f7 = 0);
  NONFAILING(*(uint8_t*)0x200004f8 = 0);
  NONFAILING(*(uint8_t*)0x200004f9 = 0);
  NONFAILING(*(uint8_t*)0x200004fa = 0);
  NONFAILING(*(uint8_t*)0x200004fb = 0);
  NONFAILING(*(uint8_t*)0x200004fc = 0);
  NONFAILING(*(uint8_t*)0x200004fd = 0);
  NONFAILING(*(uint8_t*)0x200004fe = 0);
  NONFAILING(*(uint8_t*)0x200004ff = 0);
  NONFAILING(*(uint8_t*)0x20000500 = 0);
  NONFAILING(*(uint8_t*)0x20000501 = 0);
  NONFAILING(*(uint8_t*)0x20000502 = 0);
  NONFAILING(*(uint8_t*)0x20000503 = 0);
  NONFAILING(*(uint8_t*)0x20000504 = 0);
  NONFAILING(*(uint8_t*)0x20000505 = 0);
  NONFAILING(*(uint8_t*)0x20000506 = 0);
  NONFAILING(*(uint8_t*)0x20000507 = 0);
  NONFAILING(*(uint8_t*)0x20000508 = 0);
  NONFAILING(*(uint8_t*)0x20000509 = 0);
  NONFAILING(*(uint8_t*)0x2000050a = 0);
  NONFAILING(*(uint8_t*)0x2000050b = 0);
  NONFAILING(*(uint8_t*)0x2000050c = 0);
  NONFAILING(*(uint8_t*)0x2000050d = 0);
  NONFAILING(*(uint8_t*)0x2000050e = 0);
  NONFAILING(*(uint8_t*)0x2000050f = 0);
  NONFAILING(*(uint8_t*)0x20000510 = 0);
  NONFAILING(*(uint8_t*)0x20000511 = 0);
  NONFAILING(*(uint8_t*)0x20000512 = 0);
  NONFAILING(*(uint8_t*)0x20000513 = 0);
  NONFAILING(*(uint8_t*)0x20000514 = 0);
  NONFAILING(*(uint8_t*)0x20000515 = 0);
  NONFAILING(*(uint8_t*)0x20000516 = 0);
  NONFAILING(*(uint8_t*)0x20000517 = 0);
  NONFAILING(*(uint8_t*)0x20000518 = 0);
  NONFAILING(*(uint8_t*)0x20000519 = 0);
  NONFAILING(*(uint8_t*)0x2000051a = 0);
  NONFAILING(*(uint8_t*)0x2000051b = 0);
  NONFAILING(*(uint8_t*)0x2000051c = 0);
  NONFAILING(*(uint8_t*)0x2000051d = 0);
  NONFAILING(*(uint8_t*)0x2000051e = 0);
  NONFAILING(*(uint8_t*)0x2000051f = 0);
  NONFAILING(*(uint8_t*)0x20000520 = 0);
  NONFAILING(*(uint8_t*)0x20000521 = 0);
  NONFAILING(*(uint8_t*)0x20000522 = 0);
  NONFAILING(*(uint8_t*)0x20000523 = 0);
  NONFAILING(*(uint8_t*)0x20000524 = 0);
  NONFAILING(*(uint8_t*)0x20000525 = 0);
  NONFAILING(*(uint8_t*)0x20000526 = 0);
  NONFAILING(*(uint8_t*)0x20000527 = 0);
  NONFAILING(*(uint32_t*)0x20000528 = 0);
  NONFAILING(*(uint16_t*)0x2000052c = 0xa8);
  NONFAILING(*(uint16_t*)0x2000052e = 0xd0);
  NONFAILING(*(uint32_t*)0x20000530 = 0);
  NONFAILING(*(uint64_t*)0x20000538 = 0);
  NONFAILING(*(uint64_t*)0x20000540 = 0);
  NONFAILING(*(uint16_t*)0x20000548 = 0x28);
  NONFAILING(memcpy((void*)0x2000054a, "\x00\x00\x00\x00\x00\x00\x00\x00\x00"
                                       "\x00\x00\x00\x00\x00\x00\x00\x00\x00"
                                       "\x00\x00\x00\x00\x00\x00\x00\x00\x00"
                                       "\x00\x00",
                    29));
  NONFAILING(*(uint8_t*)0x20000567 = 0);
  NONFAILING(*(uint32_t*)0x20000568 = 0xfffffffe);
  syscall(__NR_setsockopt, r[0], 0x29, 0x40, 0x20000000, 0x570);
  NONFAILING(*(uint8_t*)0x20000000 = 1);
  NONFAILING(*(uint8_t*)0x20000001 = 0x80);
  NONFAILING(*(uint8_t*)0x20000002 = 0xc2);
  NONFAILING(*(uint8_t*)0x20000003 = 0);
  NONFAILING(*(uint8_t*)0x20000004 = 0);
  NONFAILING(*(uint8_t*)0x20000005 = 0);
  NONFAILING(*(uint8_t*)0x20000006 = 0xaa);
  NONFAILING(*(uint8_t*)0x20000007 = 0xaa);
  NONFAILING(*(uint8_t*)0x20000008 = 0xaa);
  NONFAILING(*(uint8_t*)0x20000009 = 0xaa);
  NONFAILING(*(uint8_t*)0x2000000a = 0);
  NONFAILING(*(uint8_t*)0x2000000b = 0xaa);
  NONFAILING(*(uint16_t*)0x2000000c = htobe16(0x800));
  NONFAILING(STORE_BY_BITMASK(uint8_t, 0x2000000e, 5, 0, 4));
  NONFAILING(STORE_BY_BITMASK(uint8_t, 0x2000000e, 4, 4, 4));
  NONFAILING(STORE_BY_BITMASK(uint8_t, 0x2000000f, 0, 0, 2));
  NONFAILING(STORE_BY_BITMASK(uint8_t, 0x2000000f, 0, 2, 6));
  NONFAILING(*(uint16_t*)0x20000010 = htobe16(0x1c));
  NONFAILING(*(uint16_t*)0x20000012 = 0);
  NONFAILING(*(uint16_t*)0x20000014 = htobe16(0));
  NONFAILING(*(uint8_t*)0x20000016 = 0);
  NONFAILING(*(uint8_t*)0x20000017 = 0);
  NONFAILING(*(uint16_t*)0x20000018 = 0);
  NONFAILING(*(uint8_t*)0x2000001a = 0xac);
  NONFAILING(*(uint8_t*)0x2000001b = 0x14);
  NONFAILING(*(uint8_t*)0x2000001c = 0);
  NONFAILING(*(uint8_t*)0x2000001d = 0xbb);
  NONFAILING(*(uint8_t*)0x2000001e = 0xac);
  NONFAILING(*(uint8_t*)0x2000001f = 0x14);
  NONFAILING(*(uint8_t*)0x20000020 = 0);
  NONFAILING(*(uint8_t*)0x20000021 = 0);
  NONFAILING(*(uint8_t*)0x20000022 = 0);
  NONFAILING(*(uint8_t*)0x20000023 = 0);
  NONFAILING(*(uint16_t*)0x20000024 = 0);
  NONFAILING(*(uint32_t*)0x20000026 = htobe32(0xe0000001));
  NONFAILING(*(uint32_t*)0x20232000 = 0);
  NONFAILING(*(uint32_t*)0x20232004 = 0x40000088);
  struct csum_inet csum_1;
  csum_inet_init(&csum_1);
  NONFAILING(csum_inet_update(&csum_1, (const uint8_t*)0x20000022, 8));
  NONFAILING(*(uint16_t*)0x20000024 = csum_inet_digest(&csum_1));
  struct csum_inet csum_2;
  csum_inet_init(&csum_2);
  NONFAILING(csum_inet_update(&csum_2, (const uint8_t*)0x2000000e, 20));
  NONFAILING(*(uint16_t*)0x20000018 = csum_inet_digest(&csum_2));
}

int main()
{
  syscall(__NR_mmap, 0x20000000, 0x1000000, 3, 0x32, -1, 0);
  install_segv_handler();
  char* cwd = get_current_dir_name();
  for (;;) {
    if (chdir(cwd))
      fail("failed to chdir");
    use_temporary_dir();
    loop();
  }
}