// https://syzkaller.appspot.com/bug?id=33bc463a99d8af2e848dc3073d67a40857a65574
// autogenerated by syzkaller (https://github.com/google/syzkaller)

#define _GNU_SOURCE

#include <dirent.h>
#include <endian.h>
#include <errno.h>
#include <fcntl.h>
#include <net/if.h>
#include <netinet/in.h>
#include <pthread.h>
#include <sched.h>
#include <setjmp.h>
#include <signal.h>
#include <stdarg.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ioctl.h>
#include <sys/mount.h>
#include <sys/prctl.h>
#include <sys/resource.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <sys/syscall.h>
#include <sys/time.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <time.h>
#include <unistd.h>

#include <linux/capability.h>
#include <linux/futex.h>
#include <linux/net.h>

static unsigned long long procid;

static __thread int skip_segv;
static __thread jmp_buf segv_env;

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

static void install_segv_handler(void)
{
  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 void sleep_ms(uint64_t ms)
{
  usleep(ms * 1000);
}

static uint64_t current_time_ms(void)
{
  struct timespec ts;
  if (clock_gettime(CLOCK_MONOTONIC, &ts))
    exit(1);
  return (uint64_t)ts.tv_sec * 1000 + (uint64_t)ts.tv_nsec / 1000000;
}

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

static void thread_start(void* (*fn)(void*), void* arg)
{
  pthread_t th;
  pthread_attr_t attr;
  pthread_attr_init(&attr);
  pthread_attr_setstacksize(&attr, 128 << 10);
  int i = 0;
  for (; i < 100; i++) {
    if (pthread_create(&th, &attr, fn, arg) == 0) {
      pthread_attr_destroy(&attr);
      return;
    }
    if (errno == EAGAIN) {
      usleep(50);
      continue;
    }
    break;
  }
  exit(1);
}

#define BITMASK(bf_off, bf_len) (((1ull << (bf_len)) - 1) << (bf_off))
#define STORE_BY_BITMASK(type, htobe, addr, val, bf_off, bf_len)               \
  *(type*)(addr) =                                                             \
      htobe((htobe(*(type*)(addr)) & ~BITMASK((bf_off), (bf_len))) |           \
            (((type)(val) << (bf_off)) & BITMASK((bf_off), (bf_len))))

typedef struct {
  int state;
} event_t;

static void event_init(event_t* ev)
{
  ev->state = 0;
}

static void event_reset(event_t* ev)
{
  ev->state = 0;
}

static void event_set(event_t* ev)
{
  if (ev->state)
    exit(1);
  __atomic_store_n(&ev->state, 1, __ATOMIC_RELEASE);
  syscall(SYS_futex, &ev->state, FUTEX_WAKE | FUTEX_PRIVATE_FLAG, 1000000);
}

static void event_wait(event_t* ev)
{
  while (!__atomic_load_n(&ev->state, __ATOMIC_ACQUIRE))
    syscall(SYS_futex, &ev->state, FUTEX_WAIT | FUTEX_PRIVATE_FLAG, 0, 0);
}

static int event_isset(event_t* ev)
{
  return __atomic_load_n(&ev->state, __ATOMIC_ACQUIRE);
}

static int event_timedwait(event_t* ev, uint64_t timeout)
{
  uint64_t start = current_time_ms();
  uint64_t now = start;
  for (;;) {
    uint64_t remain = timeout - (now - start);
    struct timespec ts;
    ts.tv_sec = remain / 1000;
    ts.tv_nsec = (remain % 1000) * 1000 * 1000;
    syscall(SYS_futex, &ev->state, FUTEX_WAIT | FUTEX_PRIVATE_FLAG, 0, &ts);
    if (__atomic_load_n(&ev->state, __ATOMIC_ACQUIRE))
      return 1;
    now = current_time_ms();
    if (now - start > timeout)
      return 0;
  }
}

static bool write_file(const char* file, const char* what, ...)
{
  char buf[1024];
  va_list args;
  va_start(args, what);
  vsnprintf(buf, sizeof(buf), what, args);
  va_end(args);
  buf[sizeof(buf) - 1] = 0;
  int len = strlen(buf);
  int fd = open(file, O_WRONLY | O_CLOEXEC);
  if (fd == -1)
    return false;
  if (write(fd, buf, len) != len) {
    int err = errno;
    close(fd);
    errno = err;
    return false;
  }
  close(fd);
  return true;
}

#define MAX_FDS 30

#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)
{
  int fd = socket(family, SOCK_STREAM, IPPROTO_TCP);
  if (fd == -1) {
    switch (errno) {
    case EAFNOSUPPORT:
    case ENOPROTOOPT:
      return;
    }
    exit(1);
  }
  for (int 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);
    socklen_t optlen = sizeof(table->info);
    if (getsockopt(fd, level, IPT_SO_GET_INFO, &table->info, &optlen)) {
      switch (errno) {
      case EPERM:
      case ENOENT:
      case ENOPROTOOPT:
        continue;
      }
      exit(1);
    }
    if (table->info.size > sizeof(table->replace.entrytable))
      exit(1);
    if (table->info.num_entries > XT_MAX_ENTRIES)
      exit(1);
    struct ipt_get_entries 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))
      exit(1);
    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)
{
  int fd = socket(family, SOCK_STREAM, IPPROTO_TCP);
  if (fd == -1) {
    switch (errno) {
    case EAFNOSUPPORT:
    case ENOPROTOOPT:
      return;
    }
    exit(1);
  }
  for (int i = 0; i < num_tables; i++) {
    struct ipt_table_desc* table = &tables[i];
    if (table->info.valid_hooks == 0)
      continue;
    struct ipt_getinfo info;
    memset(&info, 0, sizeof(info));
    strcpy(info.name, table->name);
    socklen_t optlen = sizeof(info);
    if (getsockopt(fd, level, IPT_SO_GET_INFO, &info, &optlen))
      exit(1);
    if (memcmp(&table->info, &info, sizeof(table->info)) == 0) {
      struct ipt_get_entries entries;
      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))
        exit(1);
      if (memcmp(table->replace.entrytable, entries.entrytable,
                 table->info.size) == 0)
        continue;
    }
    struct xt_counters counters[XT_MAX_ENTRIES];
    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))
      exit(1);
  }
  close(fd);
}

static void checkpoint_arptables(void)
{
  int fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
  if (fd == -1) {
    switch (errno) {
    case EAFNOSUPPORT:
    case ENOPROTOOPT:
      return;
    }
    exit(1);
  }
  for (unsigned 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);
    socklen_t 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;
      }
      exit(1);
    }
    if (table->info.size > sizeof(table->replace.entrytable))
      exit(1);
    if (table->info.num_entries > XT_MAX_ENTRIES)
      exit(1);
    struct arpt_get_entries 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))
      exit(1);
    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()
{
  int fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
  if (fd == -1) {
    switch (errno) {
    case EAFNOSUPPORT:
    case ENOPROTOOPT:
      return;
    }
    exit(1);
  }
  for (unsigned 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;
    struct arpt_getinfo info;
    memset(&info, 0, sizeof(info));
    strcpy(info.name, table->name);
    socklen_t optlen = sizeof(info);
    if (getsockopt(fd, SOL_IP, ARPT_SO_GET_INFO, &info, &optlen))
      exit(1);
    if (memcmp(&table->info, &info, sizeof(table->info)) == 0) {
      struct arpt_get_entries entries;
      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))
        exit(1);
      if (memcmp(table->replace.entrytable, entries.entrytable,
                 table->info.size) == 0)
        continue;
    } else {
    }
    struct xt_counters counters[XT_MAX_ENTRIES];
    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))
      exit(1);
  }
  close(fd);
}

#define NF_BR_NUMHOOKS 6
#define EBT_TABLE_MAXNAMELEN 32
#define EBT_CHAIN_MAXNAMELEN 32
#define EBT_BASE_CTL 128
#define EBT_SO_SET_ENTRIES (EBT_BASE_CTL)
#define EBT_SO_GET_INFO (EBT_BASE_CTL)
#define EBT_SO_GET_ENTRIES (EBT_SO_GET_INFO + 1)
#define EBT_SO_GET_INIT_INFO (EBT_SO_GET_ENTRIES + 1)
#define EBT_SO_GET_INIT_ENTRIES (EBT_SO_GET_INIT_INFO + 1)

struct ebt_replace {
  char name[EBT_TABLE_MAXNAMELEN];
  unsigned int valid_hooks;
  unsigned int nentries;
  unsigned int entries_size;
  struct ebt_entries* hook_entry[NF_BR_NUMHOOKS];
  unsigned int num_counters;
  struct ebt_counter* counters;
  char* entries;
};

struct ebt_entries {
  unsigned int distinguisher;
  char name[EBT_CHAIN_MAXNAMELEN];
  unsigned int counter_offset;
  int policy;
  unsigned int nentries;
  char data[0] __attribute__((aligned(__alignof__(struct ebt_replace))));
};

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)
{
  int fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
  if (fd == -1) {
    switch (errno) {
    case EAFNOSUPPORT:
    case ENOPROTOOPT:
      return;
    }
    exit(1);
  }
  for (size_t 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);
    socklen_t 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;
      }
      exit(1);
    }
    if (table->replace.entries_size > sizeof(table->entrytable))
      exit(1);
    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))
      exit(1);
  }
  close(fd);
}

static void reset_ebtables()
{
  int fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
  if (fd == -1) {
    switch (errno) {
    case EAFNOSUPPORT:
    case ENOPROTOOPT:
      return;
    }
    exit(1);
  }
  for (unsigned 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;
    struct ebt_replace replace;
    memset(&replace, 0, sizeof(replace));
    strcpy(replace.name, table->name);
    socklen_t optlen = sizeof(replace);
    if (getsockopt(fd, SOL_IP, EBT_SO_GET_INFO, &replace, &optlen))
      exit(1);
    replace.num_counters = 0;
    table->replace.entries = 0;
    for (unsigned h = 0; h < NF_BR_NUMHOOKS; h++)
      table->replace.hook_entry[h] = 0;
    if (memcmp(&table->replace, &replace, sizeof(table->replace)) == 0) {
      char entrytable[XT_TABLE_SIZE];
      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))
        exit(1);
      if (memcmp(table->entrytable, entrytable, replace.entries_size) == 0)
        continue;
    }
    for (unsigned 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++;
      }
    }
    table->replace.entries = table->entrytable;
    optlen = sizeof(table->replace) + table->replace.entries_size;
    if (setsockopt(fd, SOL_IP, EBT_SO_SET_ENTRIES, &table->replace, optlen))
      exit(1);
  }
  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 setup_cgroups()
{
  if (mkdir("/syzcgroup", 0777)) {
  }
  if (mkdir("/syzcgroup/unified", 0777)) {
  }
  if (mount("none", "/syzcgroup/unified", "cgroup2", 0, NULL)) {
  }
  if (chmod("/syzcgroup/unified", 0777)) {
  }
  write_file("/syzcgroup/unified/cgroup.subtree_control",
             "+cpu +memory +io +pids +rdma");
  if (mkdir("/syzcgroup/cpu", 0777)) {
  }
  if (mount("none", "/syzcgroup/cpu", "cgroup", 0,
            "cpuset,cpuacct,perf_event,hugetlb")) {
  }
  write_file("/syzcgroup/cpu/cgroup.clone_children", "1");
  write_file("/syzcgroup/cpu/cpuset.memory_pressure_enabled", "1");
  if (chmod("/syzcgroup/cpu", 0777)) {
  }
  if (mkdir("/syzcgroup/net", 0777)) {
  }
  if (mount("none", "/syzcgroup/net", "cgroup", 0,
            "net_cls,net_prio,devices,freezer")) {
  }
  if (chmod("/syzcgroup/net", 0777)) {
  }
}

static void setup_cgroups_loop()
{
  int pid = getpid();
  char file[128];
  char cgroupdir[64];
  snprintf(cgroupdir, sizeof(cgroupdir), "/syzcgroup/unified/syz%llu", procid);
  if (mkdir(cgroupdir, 0777)) {
  }
  snprintf(file, sizeof(file), "%s/pids.max", cgroupdir);
  write_file(file, "32");
  snprintf(file, sizeof(file), "%s/memory.low", cgroupdir);
  write_file(file, "%d", 298 << 20);
  snprintf(file, sizeof(file), "%s/memory.high", cgroupdir);
  write_file(file, "%d", 299 << 20);
  snprintf(file, sizeof(file), "%s/memory.max", cgroupdir);
  write_file(file, "%d", 300 << 20);
  snprintf(file, sizeof(file), "%s/cgroup.procs", cgroupdir);
  write_file(file, "%d", pid);
  snprintf(cgroupdir, sizeof(cgroupdir), "/syzcgroup/cpu/syz%llu", procid);
  if (mkdir(cgroupdir, 0777)) {
  }
  snprintf(file, sizeof(file), "%s/cgroup.procs", cgroupdir);
  write_file(file, "%d", pid);
  snprintf(cgroupdir, sizeof(cgroupdir), "/syzcgroup/net/syz%llu", procid);
  if (mkdir(cgroupdir, 0777)) {
  }
  snprintf(file, sizeof(file), "%s/cgroup.procs", cgroupdir);
  write_file(file, "%d", pid);
}

static void setup_cgroups_test()
{
  char cgroupdir[64];
  snprintf(cgroupdir, sizeof(cgroupdir), "/syzcgroup/unified/syz%llu", procid);
  if (symlink(cgroupdir, "./cgroup")) {
  }
  snprintf(cgroupdir, sizeof(cgroupdir), "/syzcgroup/cpu/syz%llu", procid);
  if (symlink(cgroupdir, "./cgroup.cpu")) {
  }
  snprintf(cgroupdir, sizeof(cgroupdir), "/syzcgroup/net/syz%llu", procid);
  if (symlink(cgroupdir, "./cgroup.net")) {
  }
}

static void setup_common()
{
  if (mount(0, "/sys/fs/fuse/connections", "fusectl", 0, 0)) {
  }
  setup_cgroups();
}

static void loop();

static void sandbox_common()
{
  prctl(PR_SET_PDEATHSIG, SIGKILL, 0, 0, 0);
  setpgrp();
  setsid();
  struct rlimit rlim;
  rlim.rlim_cur = rlim.rlim_max = (200 << 20);
  setrlimit(RLIMIT_AS, &rlim);
  rlim.rlim_cur = rlim.rlim_max = 32 << 20;
  setrlimit(RLIMIT_MEMLOCK, &rlim);
  rlim.rlim_cur = rlim.rlim_max = 136 << 20;
  setrlimit(RLIMIT_FSIZE, &rlim);
  rlim.rlim_cur = rlim.rlim_max = 1 << 20;
  setrlimit(RLIMIT_STACK, &rlim);
  rlim.rlim_cur = rlim.rlim_max = 0;
  setrlimit(RLIMIT_CORE, &rlim);
  rlim.rlim_cur = rlim.rlim_max = 256;
  setrlimit(RLIMIT_NOFILE, &rlim);
  if (unshare(CLONE_NEWNS)) {
  }
  if (mount(NULL, "/", NULL, MS_REC | MS_PRIVATE, NULL)) {
  }
  if (unshare(CLONE_NEWIPC)) {
  }
  if (unshare(0x02000000)) {
  }
  if (unshare(CLONE_NEWUTS)) {
  }
  if (unshare(CLONE_SYSVSEM)) {
  }
  typedef struct {
    const char* name;
    const char* value;
  } sysctl_t;
  static const sysctl_t sysctls[] = {
      {"/proc/sys/kernel/shmmax", "16777216"},
      {"/proc/sys/kernel/shmall", "536870912"},
      {"/proc/sys/kernel/shmmni", "1024"},
      {"/proc/sys/kernel/msgmax", "8192"},
      {"/proc/sys/kernel/msgmni", "1024"},
      {"/proc/sys/kernel/msgmnb", "1024"},
      {"/proc/sys/kernel/sem", "1024 1048576 500 1024"},
  };
  unsigned i;
  for (i = 0; i < sizeof(sysctls) / sizeof(sysctls[0]); i++)
    write_file(sysctls[i].name, sysctls[i].value);
}

static int wait_for_loop(int pid)
{
  if (pid < 0)
    exit(1);
  int status = 0;
  while (waitpid(-1, &status, __WALL) != pid) {
  }
  return WEXITSTATUS(status);
}

static void drop_caps(void)
{
  struct __user_cap_header_struct cap_hdr = {};
  struct __user_cap_data_struct cap_data[2] = {};
  cap_hdr.version = _LINUX_CAPABILITY_VERSION_3;
  cap_hdr.pid = getpid();
  if (syscall(SYS_capget, &cap_hdr, &cap_data))
    exit(1);
  const int drop = (1 << CAP_SYS_PTRACE) | (1 << CAP_SYS_NICE);
  cap_data[0].effective &= ~drop;
  cap_data[0].permitted &= ~drop;
  cap_data[0].inheritable &= ~drop;
  if (syscall(SYS_capset, &cap_hdr, &cap_data))
    exit(1);
}

static int do_sandbox_none(void)
{
  if (unshare(CLONE_NEWPID)) {
  }
  int pid = fork();
  if (pid != 0)
    return wait_for_loop(pid);
  setup_common();
  sandbox_common();
  drop_caps();
  if (unshare(CLONE_NEWNET)) {
  }
  loop();
  exit(1);
}

#define FS_IOC_SETFLAGS _IOW('f', 2, long)
static void remove_dir(const char* dir)
{
  int iter = 0;
  DIR* dp = 0;
retry:
  while (umount2(dir, MNT_DETACH) == 0) {
  }
  dp = opendir(dir);
  if (dp == NULL) {
    if (errno == EMFILE) {
      exit(1);
    }
    exit(1);
  }
  struct dirent* ep = 0;
  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);
    while (umount2(filename, MNT_DETACH) == 0) {
    }
    struct stat st;
    if (lstat(filename, &st))
      exit(1);
    if (S_ISDIR(st.st_mode)) {
      remove_dir(filename);
      continue;
    }
    int i;
    for (i = 0;; i++) {
      if (unlink(filename) == 0)
        break;
      if (errno == EPERM) {
        int fd = open(filename, O_RDONLY);
        if (fd != -1) {
          long flags = 0;
          if (ioctl(fd, FS_IOC_SETFLAGS, &flags) == 0) {
          }
          close(fd);
          continue;
        }
      }
      if (errno == EROFS) {
        break;
      }
      if (errno != EBUSY || i > 100)
        exit(1);
      if (umount2(filename, MNT_DETACH))
        exit(1);
    }
  }
  closedir(dp);
  for (int i = 0;; i++) {
    if (rmdir(dir) == 0)
      break;
    if (i < 100) {
      if (errno == EPERM) {
        int fd = open(dir, O_RDONLY);
        if (fd != -1) {
          long flags = 0;
          if (ioctl(fd, FS_IOC_SETFLAGS, &flags) == 0) {
          }
          close(fd);
          continue;
        }
      }
      if (errno == EROFS) {
        break;
      }
      if (errno == EBUSY) {
        if (umount2(dir, MNT_DETACH))
          exit(1);
        continue;
      }
      if (errno == ENOTEMPTY) {
        if (iter < 100) {
          iter++;
          goto retry;
        }
      }
    }
    exit(1);
  }
}

static void kill_and_wait(int pid, int* status)
{
  kill(-pid, SIGKILL);
  kill(pid, SIGKILL);
  for (int i = 0; i < 100; i++) {
    if (waitpid(-1, status, WNOHANG | __WALL) == pid)
      return;
    usleep(1000);
  }
  DIR* dir = opendir("/sys/fs/fuse/connections");
  if (dir) {
    for (;;) {
      struct dirent* ent = readdir(dir);
      if (!ent)
        break;
      if (strcmp(ent->d_name, ".") == 0 || strcmp(ent->d_name, "..") == 0)
        continue;
      char abort[300];
      snprintf(abort, sizeof(abort), "/sys/fs/fuse/connections/%s/abort",
               ent->d_name);
      int fd = open(abort, O_WRONLY);
      if (fd == -1) {
        continue;
      }
      if (write(fd, abort, 1) < 0) {
      }
      close(fd);
    }
    closedir(dir);
  } else {
  }
  while (waitpid(-1, status, __WALL) != pid) {
  }
}

static void setup_loop()
{
  setup_cgroups_loop();
  checkpoint_net_namespace();
}

static void reset_loop()
{
  reset_net_namespace();
}

static void setup_test()
{
  prctl(PR_SET_PDEATHSIG, SIGKILL, 0, 0, 0);
  setpgrp();
  setup_cgroups_test();
  write_file("/proc/self/oom_score_adj", "1000");
}

static void close_fds()
{
  for (int fd = 3; fd < MAX_FDS; fd++)
    close(fd);
}

#define KMEMLEAK_FILE "/sys/kernel/debug/kmemleak"

static void setup_leak()
{
  if (!write_file(KMEMLEAK_FILE, "scan"))
    exit(1);
  sleep(5);
  if (!write_file(KMEMLEAK_FILE, "scan"))
    exit(1);
  if (!write_file(KMEMLEAK_FILE, "clear"))
    exit(1);
}

static void check_leaks(void)
{
  int fd = open(KMEMLEAK_FILE, O_RDWR);
  if (fd == -1)
    exit(1);
  uint64_t start = current_time_ms();
  if (write(fd, "scan", 4) != 4)
    exit(1);
  sleep(1);
  while (current_time_ms() - start < 4 * 1000)
    sleep(1);
  if (write(fd, "scan", 4) != 4)
    exit(1);
  static char buf[128 << 10];
  ssize_t n = read(fd, buf, sizeof(buf) - 1);
  if (n < 0)
    exit(1);
  int nleaks = 0;
  if (n != 0) {
    sleep(1);
    if (write(fd, "scan", 4) != 4)
      exit(1);
    if (lseek(fd, 0, SEEK_SET) < 0)
      exit(1);
    n = read(fd, buf, sizeof(buf) - 1);
    if (n < 0)
      exit(1);
    buf[n] = 0;
    char* pos = buf;
    char* end = buf + n;
    while (pos < end) {
      char* next = strstr(pos + 1, "unreferenced object");
      if (!next)
        next = end;
      char prev = *next;
      *next = 0;
      fprintf(stderr, "BUG: memory leak\n%s\n", pos);
      *next = prev;
      pos = next;
      nleaks++;
    }
  }
  if (write(fd, "clear", 5) != 5)
    exit(1);
  close(fd);
  if (nleaks)
    exit(1);
}

struct thread_t {
  int created, call;
  event_t ready, done;
};

static struct thread_t threads[16];
static void execute_call(int call);
static int running;

static void* thr(void* arg)
{
  struct thread_t* th = (struct thread_t*)arg;
  for (;;) {
    event_wait(&th->ready);
    event_reset(&th->ready);
    execute_call(th->call);
    __atomic_fetch_sub(&running, 1, __ATOMIC_RELAXED);
    event_set(&th->done);
  }
  return 0;
}

static void execute_one(void)
{
  int i, call, thread;
  int collide = 0;
again:
  for (call = 0; call < 7; call++) {
    for (thread = 0; thread < (int)(sizeof(threads) / sizeof(threads[0]));
         thread++) {
      struct thread_t* th = &threads[thread];
      if (!th->created) {
        th->created = 1;
        event_init(&th->ready);
        event_init(&th->done);
        event_set(&th->done);
        thread_start(thr, th);
      }
      if (!event_isset(&th->done))
        continue;
      event_reset(&th->done);
      th->call = call;
      __atomic_fetch_add(&running, 1, __ATOMIC_RELAXED);
      event_set(&th->ready);
      if (collide && (call % 2) == 0)
        break;
      event_timedwait(&th->done, 45);
      break;
    }
  }
  for (i = 0; i < 100 && __atomic_load_n(&running, __ATOMIC_RELAXED); i++)
    sleep_ms(1);
  close_fds();
  if (!collide) {
    collide = 1;
    goto again;
  }
}

static void execute_one(void);

#define WAIT_FLAGS __WALL

static void loop(void)
{
  setup_loop();
  int iter = 0;
  for (;; iter++) {
    char cwdbuf[32];
    sprintf(cwdbuf, "./%d", iter);
    if (mkdir(cwdbuf, 0777))
      exit(1);
    reset_loop();
    int pid = fork();
    if (pid < 0)
      exit(1);
    if (pid == 0) {
      if (chdir(cwdbuf))
        exit(1);
      setup_test();
      execute_one();
      exit(0);
    }
    int status = 0;
    uint64_t start = current_time_ms();
    for (;;) {
      if (waitpid(-1, &status, WNOHANG | WAIT_FLAGS) == pid)
        break;
      sleep_ms(1);
      if (current_time_ms() - start < 5 * 1000)
        continue;
      kill_and_wait(pid, &status);
      break;
    }
    remove_dir(cwdbuf);
    check_leaks();
  }
}

uint64_t r[4] = {0xffffffffffffffff, 0xffffffffffffffff, 0xffffffffffffffff,
                 0x0};

void execute_call(int call)
{
  intptr_t res = 0;
  switch (call) {
  case 0:
    res = syscall(__NR_socket, 0x10ul, 3ul, 0);
    if (res != -1)
      r[0] = res;
    break;
  case 1:
    res = syscall(__NR_socket, 0x10ul, 3ul, 0);
    if (res != -1)
      r[1] = res;
    break;
  case 2:
    res = syscall(__NR_socket, 0x10ul, 0x803ul, 0);
    if (res != -1)
      r[2] = res;
    break;
  case 3:
    NONFAILING(*(uint64_t*)0x20000280 = 0);
    NONFAILING(*(uint32_t*)0x20000288 = 0);
    NONFAILING(*(uint64_t*)0x20000290 = 0x20000180);
    NONFAILING(*(uint64_t*)0x20000180 = 0);
    NONFAILING(*(uint64_t*)0x20000188 = 0);
    NONFAILING(*(uint64_t*)0x20000298 = 1);
    NONFAILING(*(uint64_t*)0x200002a0 = 0);
    NONFAILING(*(uint64_t*)0x200002a8 = 0);
    NONFAILING(*(uint32_t*)0x200002b0 = 0);
    syscall(__NR_sendmsg, r[2], 0x20000280ul, 0ul);
    break;
  case 4:
    NONFAILING(*(uint32_t*)0x200002c0 = 0x14);
    res = syscall(__NR_getsockname, r[2], 0x20000200ul, 0x200002c0ul);
    if (res != -1)
      NONFAILING(r[3] = *(uint32_t*)0x20000204);
    break;
  case 5:
    NONFAILING(*(uint64_t*)0x20000240 = 0);
    NONFAILING(*(uint32_t*)0x20000248 = 0);
    NONFAILING(*(uint64_t*)0x20000250 = 0x20000140);
    NONFAILING(*(uint64_t*)0x20000140 = 0x200013c0);
    NONFAILING(memcpy((void*)0x200013c0, "\x38\x00\x00\x00\x24\x00\x07\x05\x00"
                                         "\x17\x62\x40\x07\xa2\xa3\x00\x05\x00"
                                         "\x00\x40",
                      20));
    NONFAILING(*(uint32_t*)0x200013d4 = r[3]);
    NONFAILING(memcpy((void*)0x200013d8, "\x00\x00\x00\x00\xff\xff\xff\xff\x00"
                                         "\x00\x00\x00\x09\x00\x01\x00\x68\x66"
                                         "\x73\x63\x00\x00\x00\x00\x08\x00\x02",
                      27));
    NONFAILING(*(uint64_t*)0x20000148 = 0x38);
    NONFAILING(*(uint64_t*)0x20000258 = 1);
    NONFAILING(*(uint64_t*)0x20000260 = 0);
    NONFAILING(*(uint64_t*)0x20000268 = 0);
    NONFAILING(*(uint32_t*)0x20000270 = 0);
    syscall(__NR_sendmsg, r[1], 0x20000240ul, 0ul);
    break;
  case 6:
    NONFAILING(*(uint64_t*)0x200001c0 = 0);
    NONFAILING(*(uint32_t*)0x200001c8 = 0);
    NONFAILING(*(uint64_t*)0x200001d0 = 0x20000180);
    NONFAILING(*(uint64_t*)0x20000180 = 0x20004c00);
    NONFAILING(*(uint32_t*)0x20004c00 = 0x41d8);
    NONFAILING(*(uint16_t*)0x20004c04 = 0x2c);
    NONFAILING(*(uint16_t*)0x20004c06 = 0xd27);
    NONFAILING(*(uint32_t*)0x20004c08 = 0);
    NONFAILING(*(uint32_t*)0x20004c0c = 0);
    NONFAILING(*(uint8_t*)0x20004c10 = 0);
    NONFAILING(*(uint8_t*)0x20004c11 = 0);
    NONFAILING(*(uint16_t*)0x20004c12 = 0);
    NONFAILING(*(uint32_t*)0x20004c14 = r[3]);
    NONFAILING(*(uint16_t*)0x20004c18 = 0);
    NONFAILING(*(uint16_t*)0x20004c1a = 0);
    NONFAILING(*(uint16_t*)0x20004c1c = 0);
    NONFAILING(*(uint16_t*)0x20004c1e = 0);
    NONFAILING(*(uint16_t*)0x20004c20 = 8);
    NONFAILING(*(uint16_t*)0x20004c22 = 0xfff1);
    NONFAILING(*(uint16_t*)0x20004c24 = 0xc);
    NONFAILING(*(uint16_t*)0x20004c26 = 1);
    NONFAILING(memcpy((void*)0x20004c28, "tcindex\000", 8));
    NONFAILING(*(uint16_t*)0x20004c30 = 0x41a8);
    NONFAILING(*(uint16_t*)0x20004c32 = 2);
    NONFAILING(*(uint16_t*)0x20004c34 = 6);
    NONFAILING(*(uint16_t*)0x20004c36 = 2);
    NONFAILING(*(uint16_t*)0x20004c38 = 9);
    NONFAILING(*(uint16_t*)0x20004c3c = 8);
    NONFAILING(*(uint16_t*)0x20004c3e = 1);
    NONFAILING(*(uint32_t*)0x20004c40 = 0x575c);
    NONFAILING(*(uint16_t*)0x20004c44 = 0x418c);
    NONFAILING(*(uint16_t*)0x20004c46 = 7);
    NONFAILING(*(uint16_t*)0x20004c48 = 0xa8);
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20004c4a, 0x1b, 0, 14));
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20004c4b, 0, 6, 1));
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20004c4b, 0, 7, 1));
    NONFAILING(*(uint16_t*)0x20004c4c = 9);
    NONFAILING(*(uint16_t*)0x20004c4e = 1);
    NONFAILING(memcpy((void*)0x20004c50, "gact\000", 5));
    NONFAILING(*(uint16_t*)0x20004c58 = 0x7c);
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20004c5a, 2, 0, 14));
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20004c5b, 0, 6, 1));
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20004c5b, 1, 7, 1));
    NONFAILING(*(uint16_t*)0x20004c5c = 0x18);
    NONFAILING(*(uint16_t*)0x20004c5e = 2);
    NONFAILING(*(uint32_t*)0x20004c60 = 0xfffff800);
    NONFAILING(*(uint32_t*)0x20004c64 = 0x200);
    NONFAILING(*(uint32_t*)0x20004c68 = 4);
    NONFAILING(*(uint32_t*)0x20004c6c = 0x1000);
    NONFAILING(*(uint32_t*)0x20004c70 = 0x1ff);
    NONFAILING(*(uint16_t*)0x20004c74 = 0x18);
    NONFAILING(*(uint16_t*)0x20004c76 = 2);
    NONFAILING(*(uint32_t*)0x20004c78 = 0x7fffffff);
    NONFAILING(*(uint32_t*)0x20004c7c = 9);
    NONFAILING(*(uint32_t*)0x20004c80 = 0x10000000);
    NONFAILING(*(uint32_t*)0x20004c84 = 4);
    NONFAILING(*(uint32_t*)0x20004c88 = 0xfffffffc);
    NONFAILING(*(uint16_t*)0x20004c8c = 0xc);
    NONFAILING(*(uint16_t*)0x20004c8e = 3);
    NONFAILING(*(uint16_t*)0x20004c90 = 1);
    NONFAILING(*(uint16_t*)0x20004c92 = 0x772);
    NONFAILING(*(uint32_t*)0x20004c94 = 4);
    NONFAILING(*(uint16_t*)0x20004c98 = 0xc);
    NONFAILING(*(uint16_t*)0x20004c9a = 3);
    NONFAILING(*(uint16_t*)0x20004c9c = 1);
    NONFAILING(*(uint16_t*)0x20004c9e = 0x91b);
    NONFAILING(*(uint32_t*)0x20004ca0 = 1);
    NONFAILING(*(uint16_t*)0x20004ca4 = 0x18);
    NONFAILING(*(uint16_t*)0x20004ca6 = 2);
    NONFAILING(*(uint32_t*)0x20004ca8 = 6);
    NONFAILING(*(uint32_t*)0x20004cac = 6);
    NONFAILING(*(uint32_t*)0x20004cb0 = 2);
    NONFAILING(*(uint32_t*)0x20004cb4 = 2);
    NONFAILING(*(uint32_t*)0x20004cb8 = 4);
    NONFAILING(*(uint16_t*)0x20004cbc = 0x18);
    NONFAILING(*(uint16_t*)0x20004cbe = 2);
    NONFAILING(*(uint32_t*)0x20004cc0 = 7);
    NONFAILING(*(uint32_t*)0x20004cc4 = 0x100);
    NONFAILING(*(uint32_t*)0x20004cc8 = 7);
    NONFAILING(*(uint32_t*)0x20004ccc = 0x5f);
    NONFAILING(*(uint32_t*)0x20004cd0 = 0x64);
    NONFAILING(*(uint16_t*)0x20004cd4 = 4);
    NONFAILING(*(uint16_t*)0x20004cd6 = 6);
    NONFAILING(*(uint16_t*)0x20004cd8 = 0xc);
    NONFAILING(*(uint16_t*)0x20004cda = 7);
    NONFAILING(*(uint32_t*)0x20004cdc = 0);
    NONFAILING(*(uint32_t*)0x20004ce0 = 0xc6107bc9);
    NONFAILING(*(uint16_t*)0x20004ce4 = 0xc);
    NONFAILING(*(uint16_t*)0x20004ce6 = 8);
    NONFAILING(*(uint32_t*)0x20004ce8 = 1);
    NONFAILING(*(uint32_t*)0x20004cec = 1);
    NONFAILING(*(uint16_t*)0x20004cf0 = 0xa4);
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20004cf2, 0x1f, 0, 14));
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20004cf3, 0, 6, 1));
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20004cf3, 0, 7, 1));
    NONFAILING(*(uint16_t*)0x20004cf4 = 0xd);
    NONFAILING(*(uint16_t*)0x20004cf6 = 1);
    NONFAILING(memcpy((void*)0x20004cf8, "connmark\000", 9));
    NONFAILING(*(uint16_t*)0x20004d04 = 0x74);
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20004d06, 2, 0, 14));
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20004d07, 0, 6, 1));
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20004d07, 1, 7, 1));
    NONFAILING(*(uint16_t*)0x20004d08 = 0x1c);
    NONFAILING(*(uint16_t*)0x20004d0a = 1);
    NONFAILING(*(uint32_t*)0x20004d0c = 0x4000000);
    NONFAILING(*(uint32_t*)0x20004d10 = 0x7fff);
    NONFAILING(*(uint32_t*)0x20004d14 = 0x10000000);
    NONFAILING(*(uint32_t*)0x20004d18 = 0x1ff);
    NONFAILING(*(uint32_t*)0x20004d1c = 0xd3ba);
    NONFAILING(*(uint16_t*)0x20004d20 = 0);
    NONFAILING(*(uint16_t*)0x20004d24 = 0x1c);
    NONFAILING(*(uint16_t*)0x20004d26 = 1);
    NONFAILING(*(uint32_t*)0x20004d28 = 2);
    NONFAILING(*(uint32_t*)0x20004d2c = 0x7fffffff);
    NONFAILING(*(uint32_t*)0x20004d30 = 7);
    NONFAILING(*(uint32_t*)0x20004d34 = 0x401);
    NONFAILING(*(uint32_t*)0x20004d38 = 0);
    NONFAILING(*(uint16_t*)0x20004d3c = 0x5d);
    NONFAILING(*(uint16_t*)0x20004d40 = 0x1c);
    NONFAILING(*(uint16_t*)0x20004d42 = 1);
    NONFAILING(*(uint32_t*)0x20004d44 = 5);
    NONFAILING(*(uint32_t*)0x20004d48 = 3);
    NONFAILING(*(uint32_t*)0x20004d4c = 2);
    NONFAILING(*(uint32_t*)0x20004d50 = 0x69a);
    NONFAILING(*(uint32_t*)0x20004d54 = 7);
    NONFAILING(*(uint16_t*)0x20004d58 = 8);
    NONFAILING(*(uint16_t*)0x20004d5c = 0x1c);
    NONFAILING(*(uint16_t*)0x20004d5e = 1);
    NONFAILING(*(uint32_t*)0x20004d60 = 0xff);
    NONFAILING(*(uint32_t*)0x20004d64 = 7);
    NONFAILING(*(uint32_t*)0x20004d68 = 0x20000000);
    NONFAILING(*(uint32_t*)0x20004d6c = 0xfffffffe);
    NONFAILING(*(uint32_t*)0x20004d70 = 4);
    NONFAILING(*(uint16_t*)0x20004d74 = 6);
    NONFAILING(*(uint16_t*)0x20004d78 = 4);
    NONFAILING(*(uint16_t*)0x20004d7a = 6);
    NONFAILING(*(uint16_t*)0x20004d7c = 0xc);
    NONFAILING(*(uint16_t*)0x20004d7e = 7);
    NONFAILING(*(uint32_t*)0x20004d80 = 0);
    NONFAILING(*(uint32_t*)0x20004d84 = 0);
    NONFAILING(*(uint16_t*)0x20004d88 = 0xc);
    NONFAILING(*(uint16_t*)0x20004d8a = 8);
    NONFAILING(*(uint32_t*)0x20004d8c = 1);
    NONFAILING(*(uint32_t*)0x20004d90 = 2);
    NONFAILING(*(uint16_t*)0x20004d94 = 0x50);
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20004d96, 0x20, 0, 14));
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20004d97, 0, 6, 1));
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20004d97, 0, 7, 1));
    NONFAILING(*(uint16_t*)0x20004d98 = 0xf);
    NONFAILING(*(uint16_t*)0x20004d9a = 1);
    NONFAILING(memcpy((void*)0x20004d9c, "tunnel_key\000", 11));
    NONFAILING(*(uint16_t*)0x20004da8 = 0x20);
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20004daa, 2, 0, 14));
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20004dab, 0, 6, 1));
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20004dab, 1, 7, 1));
    NONFAILING(*(uint16_t*)0x20004dac = 0x14);
    NONFAILING(*(uint16_t*)0x20004dae = 6);
    NONFAILING(*(uint8_t*)0x20004db0 = 0xfc);
    NONFAILING(*(uint8_t*)0x20004db1 = 2);
    NONFAILING(*(uint8_t*)0x20004db2 = 0);
    NONFAILING(*(uint8_t*)0x20004db3 = 0);
    NONFAILING(*(uint8_t*)0x20004db4 = 0);
    NONFAILING(*(uint8_t*)0x20004db5 = 0);
    NONFAILING(*(uint8_t*)0x20004db6 = 0);
    NONFAILING(*(uint8_t*)0x20004db7 = 0);
    NONFAILING(*(uint8_t*)0x20004db8 = 0);
    NONFAILING(*(uint8_t*)0x20004db9 = 0);
    NONFAILING(*(uint8_t*)0x20004dba = 0);
    NONFAILING(*(uint8_t*)0x20004dbb = 0);
    NONFAILING(*(uint8_t*)0x20004dbc = 0);
    NONFAILING(*(uint8_t*)0x20004dbd = 0);
    NONFAILING(*(uint8_t*)0x20004dbe = 0);
    NONFAILING(*(uint8_t*)0x20004dbf = 0);
    NONFAILING(*(uint16_t*)0x20004dc0 = 8);
    NONFAILING(*(uint16_t*)0x20004dc2 = 7);
    NONFAILING(*(uint32_t*)0x20004dc4 = 0x7ff);
    NONFAILING(*(uint16_t*)0x20004dc8 = 4);
    NONFAILING(*(uint16_t*)0x20004dca = 6);
    NONFAILING(*(uint16_t*)0x20004dcc = 0xc);
    NONFAILING(*(uint16_t*)0x20004dce = 7);
    NONFAILING(*(uint32_t*)0x20004dd0 = 0);
    NONFAILING(*(uint32_t*)0x20004dd4 = 1);
    NONFAILING(*(uint16_t*)0x20004dd8 = 0xc);
    NONFAILING(*(uint16_t*)0x20004dda = 8);
    NONFAILING(*(uint32_t*)0x20004ddc = 1);
    NONFAILING(*(uint32_t*)0x20004de0 = 1);
    NONFAILING(*(uint16_t*)0x20004de4 = 0xf8);
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20004de6, 0xd, 0, 14));
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20004de7, 0, 6, 1));
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20004de7, 0, 7, 1));
    NONFAILING(*(uint16_t*)0x20004de8 = 0xd);
    NONFAILING(*(uint16_t*)0x20004dea = 1);
    NONFAILING(memcpy((void*)0x20004dec, "connmark\000", 9));
    NONFAILING(*(uint16_t*)0x20004df8 = 0xc8);
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20004dfa, 2, 0, 14));
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20004dfb, 0, 6, 1));
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20004dfb, 1, 7, 1));
    NONFAILING(*(uint16_t*)0x20004dfc = 0x1c);
    NONFAILING(*(uint16_t*)0x20004dfe = 1);
    NONFAILING(*(uint32_t*)0x20004e00 = 0xfff);
    NONFAILING(*(uint32_t*)0x20004e04 = 8);
    NONFAILING(*(uint32_t*)0x20004e08 = 0);
    NONFAILING(*(uint32_t*)0x20004e0c = 0x945);
    NONFAILING(*(uint32_t*)0x20004e10 = 0x40);
    NONFAILING(*(uint16_t*)0x20004e14 = 6);
    NONFAILING(*(uint16_t*)0x20004e18 = 0x1c);
    NONFAILING(*(uint16_t*)0x20004e1a = 1);
    NONFAILING(*(uint32_t*)0x20004e1c = 0x800);
    NONFAILING(*(uint32_t*)0x20004e20 = 0x7fff);
    NONFAILING(*(uint32_t*)0x20004e24 = 2);
    NONFAILING(*(uint32_t*)0x20004e28 = 4);
    NONFAILING(*(uint32_t*)0x20004e2c = 4);
    NONFAILING(*(uint16_t*)0x20004e30 = 0);
    NONFAILING(*(uint16_t*)0x20004e34 = 0x1c);
    NONFAILING(*(uint16_t*)0x20004e36 = 1);
    NONFAILING(*(uint32_t*)0x20004e38 = 2);
    NONFAILING(*(uint32_t*)0x20004e3c = 3);
    NONFAILING(*(uint32_t*)0x20004e40 = 0x20000000);
    NONFAILING(*(uint32_t*)0x20004e44 = 2);
    NONFAILING(*(uint32_t*)0x20004e48 = 0x3ff);
    NONFAILING(*(uint16_t*)0x20004e4c = 1);
    NONFAILING(*(uint16_t*)0x20004e50 = 0x1c);
    NONFAILING(*(uint16_t*)0x20004e52 = 1);
    NONFAILING(*(uint32_t*)0x20004e54 = 0x7fff);
    NONFAILING(*(uint32_t*)0x20004e58 = 2);
    NONFAILING(*(uint32_t*)0x20004e5c = 4);
    NONFAILING(*(uint32_t*)0x20004e60 = 0x611cd783);
    NONFAILING(*(uint32_t*)0x20004e64 = 3);
    NONFAILING(*(uint16_t*)0x20004e68 = 0xffc1);
    NONFAILING(*(uint16_t*)0x20004e6c = 0x1c);
    NONFAILING(*(uint16_t*)0x20004e6e = 1);
    NONFAILING(*(uint32_t*)0x20004e70 = 8);
    NONFAILING(*(uint32_t*)0x20004e74 = 5);
    NONFAILING(*(uint32_t*)0x20004e78 = 7);
    NONFAILING(*(uint32_t*)0x20004e7c = 1);
    NONFAILING(*(uint32_t*)0x20004e80 = 0x7fff);
    NONFAILING(*(uint16_t*)0x20004e84 = 4);
    NONFAILING(*(uint16_t*)0x20004e88 = 0x1c);
    NONFAILING(*(uint16_t*)0x20004e8a = 1);
    NONFAILING(*(uint32_t*)0x20004e8c = 0xef);
    NONFAILING(*(uint32_t*)0x20004e90 = 0);
    NONFAILING(*(uint32_t*)0x20004e94 = 6);
    NONFAILING(*(uint32_t*)0x20004e98 = 0x3782);
    NONFAILING(*(uint32_t*)0x20004e9c = 1);
    NONFAILING(*(uint16_t*)0x20004ea0 = 0x8001);
    NONFAILING(*(uint16_t*)0x20004ea4 = 0x1c);
    NONFAILING(*(uint16_t*)0x20004ea6 = 1);
    NONFAILING(*(uint32_t*)0x20004ea8 = 0x80000000);
    NONFAILING(*(uint32_t*)0x20004eac = 0x6f);
    NONFAILING(*(uint32_t*)0x20004eb0 = 0x10000000);
    NONFAILING(*(uint32_t*)0x20004eb4 = 0);
    NONFAILING(*(uint32_t*)0x20004eb8 = 0);
    NONFAILING(*(uint16_t*)0x20004ebc = 0xf801);
    NONFAILING(*(uint16_t*)0x20004ec0 = 4);
    NONFAILING(*(uint16_t*)0x20004ec2 = 6);
    NONFAILING(*(uint16_t*)0x20004ec4 = 0xc);
    NONFAILING(*(uint16_t*)0x20004ec6 = 7);
    NONFAILING(*(uint32_t*)0x20004ec8 = 0);
    NONFAILING(*(uint32_t*)0x20004ecc = 1);
    NONFAILING(*(uint16_t*)0x20004ed0 = 0xc);
    NONFAILING(*(uint16_t*)0x20004ed2 = 8);
    NONFAILING(*(uint32_t*)0x20004ed4 = 0);
    NONFAILING(*(uint32_t*)0x20004ed8 = 3);
    NONFAILING(*(uint16_t*)0x20004edc = 0x38);
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20004ede, 0xe, 0, 14));
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20004edf, 0, 6, 1));
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20004edf, 0, 7, 1));
    NONFAILING(*(uint16_t*)0x20004ee0 = 9);
    NONFAILING(*(uint16_t*)0x20004ee2 = 1);
    NONFAILING(memcpy((void*)0x20004ee4, "mpls\000", 5));
    NONFAILING(*(uint16_t*)0x20004eec = 0xc);
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20004eee, 2, 0, 14));
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20004eef, 0, 6, 1));
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20004eef, 1, 7, 1));
    NONFAILING(*(uint16_t*)0x20004ef0 = 5);
    NONFAILING(*(uint16_t*)0x20004ef2 = 6);
    NONFAILING(*(uint8_t*)0x20004ef4 = 6);
    NONFAILING(*(uint16_t*)0x20004ef8 = 4);
    NONFAILING(*(uint16_t*)0x20004efa = 6);
    NONFAILING(*(uint16_t*)0x20004efc = 0xc);
    NONFAILING(*(uint16_t*)0x20004efe = 7);
    NONFAILING(*(uint32_t*)0x20004f00 = 0);
    NONFAILING(*(uint32_t*)0x20004f04 = 1);
    NONFAILING(*(uint16_t*)0x20004f08 = 0xc);
    NONFAILING(*(uint16_t*)0x20004f0a = 8);
    NONFAILING(*(uint32_t*)0x20004f0c = 1);
    NONFAILING(*(uint32_t*)0x20004f10 = 3);
    NONFAILING(*(uint16_t*)0x20004f14 = 0x48);
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20004f16, 0x20, 0, 14));
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20004f17, 0, 6, 1));
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20004f17, 0, 7, 1));
    NONFAILING(*(uint16_t*)0x20004f18 = 9);
    NONFAILING(*(uint16_t*)0x20004f1a = 1);
    NONFAILING(memcpy((void*)0x20004f1c, "gact\000", 5));
    NONFAILING(*(uint16_t*)0x20004f24 = 0x1c);
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20004f26, 2, 0, 14));
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20004f27, 0, 6, 1));
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20004f27, 1, 7, 1));
    NONFAILING(*(uint16_t*)0x20004f28 = 0x18);
    NONFAILING(*(uint16_t*)0x20004f2a = 2);
    NONFAILING(*(uint32_t*)0x20004f2c = 0x80000001);
    NONFAILING(*(uint32_t*)0x20004f30 = 6);
    NONFAILING(*(uint32_t*)0x20004f34 = -1);
    NONFAILING(*(uint32_t*)0x20004f38 = 0xd7);
    NONFAILING(*(uint32_t*)0x20004f3c = 2);
    NONFAILING(*(uint16_t*)0x20004f40 = 4);
    NONFAILING(*(uint16_t*)0x20004f42 = 6);
    NONFAILING(*(uint16_t*)0x20004f44 = 0xc);
    NONFAILING(*(uint16_t*)0x20004f46 = 7);
    NONFAILING(*(uint32_t*)0x20004f48 = 1);
    NONFAILING(*(uint32_t*)0x20004f4c = 0);
    NONFAILING(*(uint16_t*)0x20004f50 = 0xc);
    NONFAILING(*(uint16_t*)0x20004f52 = 8);
    NONFAILING(*(uint32_t*)0x20004f54 = 1);
    NONFAILING(*(uint32_t*)0x20004f58 = 0);
    NONFAILING(*(uint16_t*)0x20004f5c = 0x90);
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20004f5e, 0xa, 0, 14));
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20004f5f, 0, 6, 1));
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20004f5f, 0, 7, 1));
    NONFAILING(*(uint16_t*)0x20004f60 = 0xc);
    NONFAILING(*(uint16_t*)0x20004f62 = 1);
    NONFAILING(memcpy((void*)0x20004f64, "skbedit\000", 8));
    NONFAILING(*(uint16_t*)0x20004f6c = 0x64);
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20004f6e, 2, 0, 14));
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20004f6f, 0, 6, 1));
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20004f6f, 1, 7, 1));
    NONFAILING(*(uint16_t*)0x20004f70 = 6);
    NONFAILING(*(uint16_t*)0x20004f72 = 7);
    NONFAILING(*(uint16_t*)0x20004f74 = 6);
    NONFAILING(*(uint16_t*)0x20004f78 = 6);
    NONFAILING(*(uint16_t*)0x20004f7a = 4);
    NONFAILING(*(uint16_t*)0x20004f7c = 0xd4b8);
    NONFAILING(*(uint16_t*)0x20004f80 = 6);
    NONFAILING(*(uint16_t*)0x20004f82 = 4);
    NONFAILING(*(uint16_t*)0x20004f84 = 2);
    NONFAILING(*(uint16_t*)0x20004f88 = 6);
    NONFAILING(*(uint16_t*)0x20004f8a = 7);
    NONFAILING(*(uint16_t*)0x20004f8c = 4);
    NONFAILING(*(uint16_t*)0x20004f90 = 6);
    NONFAILING(*(uint16_t*)0x20004f92 = 4);
    NONFAILING(*(uint16_t*)0x20004f94 = 9);
    NONFAILING(*(uint16_t*)0x20004f98 = 0x18);
    NONFAILING(*(uint16_t*)0x20004f9a = 2);
    NONFAILING(*(uint32_t*)0x20004f9c = 0x10001);
    NONFAILING(*(uint32_t*)0x20004fa0 = 0xbfcd);
    NONFAILING(*(uint32_t*)0x20004fa4 = 0x20000000);
    NONFAILING(*(uint32_t*)0x20004fa8 = 5);
    NONFAILING(*(uint32_t*)0x20004fac = 0x7fff);
    NONFAILING(*(uint16_t*)0x20004fb0 = 0x18);
    NONFAILING(*(uint16_t*)0x20004fb2 = 2);
    NONFAILING(*(uint32_t*)0x20004fb4 = 0x1ff);
    NONFAILING(*(uint32_t*)0x20004fb8 = 0x7fff);
    NONFAILING(*(uint32_t*)0x20004fbc = 3);
    NONFAILING(*(uint32_t*)0x20004fc0 = 0x7fffffff);
    NONFAILING(*(uint32_t*)0x20004fc4 = 0x10000);
    NONFAILING(*(uint16_t*)0x20004fc8 = 8);
    NONFAILING(*(uint16_t*)0x20004fca = 3);
    NONFAILING(*(uint16_t*)0x20004fcc = -1);
    NONFAILING(*(uint16_t*)0x20004fce = 8);
    NONFAILING(*(uint16_t*)0x20004fd0 = 4);
    NONFAILING(*(uint16_t*)0x20004fd2 = 6);
    NONFAILING(*(uint16_t*)0x20004fd4 = 0xc);
    NONFAILING(*(uint16_t*)0x20004fd6 = 7);
    NONFAILING(*(uint32_t*)0x20004fd8 = 0);
    NONFAILING(*(uint32_t*)0x20004fdc = 0);
    NONFAILING(*(uint16_t*)0x20004fe0 = 0xc);
    NONFAILING(*(uint16_t*)0x20004fe2 = 8);
    NONFAILING(*(uint32_t*)0x20004fe4 = 0);
    NONFAILING(*(uint32_t*)0x20004fe8 = 1);
    NONFAILING(*(uint16_t*)0x20004fec = 0x50);
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20004fee, 0xa, 0, 14));
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20004fef, 0, 6, 1));
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20004fef, 0, 7, 1));
    NONFAILING(*(uint16_t*)0x20004ff0 = 8);
    NONFAILING(*(uint16_t*)0x20004ff2 = 1);
    NONFAILING(memcpy((void*)0x20004ff4, "bpf\000", 4));
    NONFAILING(*(uint16_t*)0x20004ff8 = 0x28);
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20004ffa, 2, 0, 14));
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20004ffb, 0, 6, 1));
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20004ffb, 1, 7, 1));
    NONFAILING(*(uint16_t*)0x20004ffc = 0x18);
    NONFAILING(*(uint16_t*)0x20004ffe = 2);
    NONFAILING(*(uint32_t*)0x20005000 = 1);
    NONFAILING(*(uint32_t*)0x20005004 = 0xffffff7f);
    NONFAILING(*(uint32_t*)0x20005008 = -1);
    NONFAILING(*(uint32_t*)0x2000500c = 0x1ff);
    NONFAILING(*(uint32_t*)0x20005010 = 7);
    NONFAILING(*(uint16_t*)0x20005014 = 0xc);
    NONFAILING(*(uint16_t*)0x20005016 = 6);
    NONFAILING(memcpy((void*)0x20005018, "./file0\000", 8));
    NONFAILING(*(uint16_t*)0x20005020 = 4);
    NONFAILING(*(uint16_t*)0x20005022 = 6);
    NONFAILING(*(uint16_t*)0x20005024 = 0xc);
    NONFAILING(*(uint16_t*)0x20005026 = 7);
    NONFAILING(*(uint32_t*)0x20005028 = 0);
    NONFAILING(*(uint32_t*)0x2000502c = 0);
    NONFAILING(*(uint16_t*)0x20005030 = 0xc);
    NONFAILING(*(uint16_t*)0x20005032 = 8);
    NONFAILING(*(uint32_t*)0x20005034 = 2);
    NONFAILING(*(uint32_t*)0x20005038 = 2);
    NONFAILING(*(uint16_t*)0x2000503c = 0x3d94);
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x2000503e, 0xb, 0, 14));
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x2000503f, 0, 6, 1));
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x2000503f, 0, 7, 1));
    NONFAILING(*(uint16_t*)0x20005040 = 0xa);
    NONFAILING(*(uint16_t*)0x20005042 = 1);
    NONFAILING(memcpy((void*)0x20005044, "pedit\000", 6));
    NONFAILING(*(uint16_t*)0x2000504c = 0x3d68);
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x2000504e, 2, 0, 14));
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x2000504f, 0, 6, 1));
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x2000504f, 1, 7, 1));
    NONFAILING(*(uint16_t*)0x20005050 = 0xe68);
    NONFAILING(*(uint16_t*)0x20005052 = 4);
    NONFAILING(*(uint32_t*)0x20005054 = 8);
    NONFAILING(*(uint32_t*)0x20005058 = 0x8151);
    NONFAILING(*(uint32_t*)0x2000505c = -1);
    NONFAILING(*(uint32_t*)0x20005060 = 0x80000000);
    NONFAILING(*(uint32_t*)0x20005064 = 0x3d03);
    NONFAILING(*(uint8_t*)0x20005068 = 0xae);
    NONFAILING(*(uint8_t*)0x20005069 = 3);
    NONFAILING(*(uint32_t*)0x2000506c = 7);
    NONFAILING(*(uint32_t*)0x20005070 = 3);
    NONFAILING(*(uint32_t*)0x20005074 = 3);
    NONFAILING(*(uint32_t*)0x20005078 = 8);
    NONFAILING(*(uint32_t*)0x2000507c = 1);
    NONFAILING(*(uint32_t*)0x20005080 = 6);
    NONFAILING(*(uint32_t*)0x20005084 = 0xd45);
    NONFAILING(*(uint32_t*)0x20005088 = 0x8001);
    NONFAILING(*(uint32_t*)0x2000508c = 0x100);
    NONFAILING(*(uint32_t*)0x20005090 = 9);
    NONFAILING(*(uint32_t*)0x20005094 = 8);
    NONFAILING(*(uint32_t*)0x20005098 = 9);
    NONFAILING(*(uint32_t*)0x2000509c = 2);
    NONFAILING(*(uint32_t*)0x200050a0 = 0x400);
    NONFAILING(*(uint32_t*)0x200050a4 = 0x3192);
    NONFAILING(*(uint32_t*)0x200050a8 = 5);
    NONFAILING(*(uint32_t*)0x200050ac = 7);
    NONFAILING(*(uint32_t*)0x200050b0 = 8);
    NONFAILING(*(uint32_t*)0x200050b4 = 0x8e5b);
    NONFAILING(*(uint32_t*)0x200050b8 = 0x20000000);
    NONFAILING(*(uint32_t*)0x200050bc = 0x200);
    NONFAILING(*(uint32_t*)0x200050c0 = 0x3f);
    NONFAILING(*(uint32_t*)0x200050c4 = 1);
    NONFAILING(*(uint32_t*)0x200050c8 = 3);
    NONFAILING(*(uint32_t*)0x200050cc = 7);
    NONFAILING(*(uint32_t*)0x200050d0 = 0x1ff);
    NONFAILING(*(uint32_t*)0x200050d4 = 0);
    NONFAILING(*(uint32_t*)0x200050d8 = 1);
    NONFAILING(*(uint32_t*)0x200050dc = 0);
    NONFAILING(*(uint32_t*)0x200050e0 = 3);
    NONFAILING(*(uint32_t*)0x200050e4 = 0x1ff);
    NONFAILING(*(uint32_t*)0x200050e8 = 0x80000000);
    NONFAILING(*(uint32_t*)0x200050ec = 0xe87d);
    NONFAILING(*(uint32_t*)0x200050f0 = 7);
    NONFAILING(*(uint32_t*)0x200050f4 = 5);
    NONFAILING(*(uint32_t*)0x200050f8 = 2);
    NONFAILING(*(uint32_t*)0x200050fc = 8);
    NONFAILING(*(uint32_t*)0x20005100 = 4);
    NONFAILING(*(uint32_t*)0x20005104 = 3);
    NONFAILING(*(uint32_t*)0x20005108 = 5);
    NONFAILING(*(uint32_t*)0x2000510c = 0x401);
    NONFAILING(*(uint32_t*)0x20005110 = 0x400);
    NONFAILING(*(uint32_t*)0x20005114 = 1);
    NONFAILING(*(uint32_t*)0x20005118 = 0xe7);
    NONFAILING(*(uint32_t*)0x2000511c = 4);
    NONFAILING(*(uint32_t*)0x20005120 = 0x3f);
    NONFAILING(*(uint32_t*)0x20005124 = 0x3f);
    NONFAILING(*(uint32_t*)0x20005128 = 0x80000001);
    NONFAILING(*(uint32_t*)0x2000512c = 0x39c075c9);
    NONFAILING(*(uint32_t*)0x20005130 = 0x57f);
    NONFAILING(*(uint32_t*)0x20005134 = 5);
    NONFAILING(*(uint32_t*)0x20005138 = 0xfffff000);
    NONFAILING(*(uint32_t*)0x2000513c = 8);
    NONFAILING(*(uint32_t*)0x20005140 = 3);
    NONFAILING(*(uint32_t*)0x20005144 = 3);
    NONFAILING(*(uint32_t*)0x20005148 = 0);
    NONFAILING(*(uint32_t*)0x2000514c = 0x1ff);
    NONFAILING(*(uint32_t*)0x20005150 = 5);
    NONFAILING(*(uint32_t*)0x20005154 = 4);
    NONFAILING(*(uint32_t*)0x20005158 = 0x800);
    NONFAILING(*(uint32_t*)0x2000515c = 0xffff);
    NONFAILING(*(uint32_t*)0x20005160 = 7);
    NONFAILING(*(uint32_t*)0x20005164 = 0);
    NONFAILING(*(uint32_t*)0x20005168 = 0x80000001);
    NONFAILING(*(uint32_t*)0x2000516c = 8);
    NONFAILING(*(uint32_t*)0x20005170 = 0x200);
    NONFAILING(*(uint32_t*)0x20005174 = 0xd);
    NONFAILING(*(uint32_t*)0x20005178 = 0x80000001);
    NONFAILING(*(uint32_t*)0x2000517c = 0x1ffe);
    NONFAILING(*(uint32_t*)0x20005180 = 9);
    NONFAILING(*(uint32_t*)0x20005184 = 0x760d3a4f);
    NONFAILING(*(uint32_t*)0x20005188 = 0xfff);
    NONFAILING(*(uint32_t*)0x2000518c = 3);
    NONFAILING(*(uint32_t*)0x20005190 = 9);
    NONFAILING(*(uint32_t*)0x20005194 = 1);
    NONFAILING(*(uint32_t*)0x20005198 = 4);
    NONFAILING(*(uint32_t*)0x2000519c = 7);
    NONFAILING(*(uint32_t*)0x200051a0 = 0x1f);
    NONFAILING(*(uint32_t*)0x200051a4 = 0);
    NONFAILING(*(uint32_t*)0x200051a8 = 0x6ce9368a);
    NONFAILING(*(uint32_t*)0x200051ac = 6);
    NONFAILING(*(uint32_t*)0x200051b0 = 4);
    NONFAILING(*(uint32_t*)0x200051b4 = 0x41);
    NONFAILING(*(uint32_t*)0x200051b8 = 1);
    NONFAILING(*(uint32_t*)0x200051bc = 4);
    NONFAILING(*(uint32_t*)0x200051c0 = 3);
    NONFAILING(*(uint32_t*)0x200051c4 = 0x53);
    NONFAILING(*(uint32_t*)0x200051c8 = 7);
    NONFAILING(*(uint32_t*)0x200051cc = 3);
    NONFAILING(*(uint32_t*)0x200051d0 = 0xffff0000);
    NONFAILING(*(uint32_t*)0x200051d4 = 0x7fffffff);
    NONFAILING(*(uint32_t*)0x200051d8 = 0xffffff80);
    NONFAILING(*(uint32_t*)0x200051dc = 2);
    NONFAILING(*(uint32_t*)0x200051e0 = 0x7f0e);
    NONFAILING(*(uint32_t*)0x200051e4 = 0xfffffffb);
    NONFAILING(*(uint32_t*)0x200051e8 = 1);
    NONFAILING(*(uint32_t*)0x200051ec = 0xffff);
    NONFAILING(*(uint32_t*)0x200051f0 = 1);
    NONFAILING(*(uint32_t*)0x200051f4 = 0x40);
    NONFAILING(*(uint32_t*)0x200051f8 = 1);
    NONFAILING(*(uint32_t*)0x200051fc = 1);
    NONFAILING(*(uint32_t*)0x20005200 = 2);
    NONFAILING(*(uint32_t*)0x20005204 = 4);
    NONFAILING(*(uint32_t*)0x20005208 = 0);
    NONFAILING(*(uint32_t*)0x2000520c = 4);
    NONFAILING(*(uint32_t*)0x20005210 = 1);
    NONFAILING(*(uint32_t*)0x20005214 = 4);
    NONFAILING(*(uint32_t*)0x20005218 = 5);
    NONFAILING(*(uint32_t*)0x2000521c = 2);
    NONFAILING(*(uint32_t*)0x20005220 = 0x7fff);
    NONFAILING(*(uint32_t*)0x20005224 = 7);
    NONFAILING(*(uint32_t*)0x20005228 = 0x8000);
    NONFAILING(*(uint32_t*)0x2000522c = 0xffffff7f);
    NONFAILING(*(uint32_t*)0x20005230 = 0x5e);
    NONFAILING(*(uint32_t*)0x20005234 = 7);
    NONFAILING(*(uint32_t*)0x20005238 = 0x1f);
    NONFAILING(*(uint32_t*)0x2000523c = 0x80);
    NONFAILING(*(uint32_t*)0x20005240 = 0x8001);
    NONFAILING(*(uint32_t*)0x20005244 = 6);
    NONFAILING(*(uint32_t*)0x20005248 = 0x7f);
    NONFAILING(*(uint32_t*)0x2000524c = 0x401);
    NONFAILING(*(uint32_t*)0x20005250 = 5);
    NONFAILING(*(uint32_t*)0x20005254 = 0x800000);
    NONFAILING(*(uint32_t*)0x20005258 = 3);
    NONFAILING(*(uint32_t*)0x2000525c = 0);
    NONFAILING(*(uint32_t*)0x20005260 = 0x9c12);
    NONFAILING(*(uint32_t*)0x20005264 = 9);
    NONFAILING(*(uint32_t*)0x20005268 = 0xc58);
    NONFAILING(*(uint32_t*)0x2000526c = 8);
    NONFAILING(*(uint32_t*)0x20005270 = 0x20);
    NONFAILING(*(uint32_t*)0x20005274 = 8);
    NONFAILING(*(uint32_t*)0x20005278 = 0x8000);
    NONFAILING(*(uint32_t*)0x2000527c = 7);
    NONFAILING(*(uint32_t*)0x20005280 = 0xc3f);
    NONFAILING(*(uint32_t*)0x20005284 = 0x6181);
    NONFAILING(*(uint32_t*)0x20005288 = 0x800);
    NONFAILING(*(uint32_t*)0x2000528c = 0x100);
    NONFAILING(*(uint32_t*)0x20005290 = 0x80);
    NONFAILING(*(uint32_t*)0x20005294 = 0x40);
    NONFAILING(*(uint32_t*)0x20005298 = 3);
    NONFAILING(*(uint32_t*)0x2000529c = 0x56);
    NONFAILING(*(uint32_t*)0x200052a0 = 0xc1);
    NONFAILING(*(uint32_t*)0x200052a4 = 0);
    NONFAILING(*(uint32_t*)0x200052a8 = 0x1ff);
    NONFAILING(*(uint32_t*)0x200052ac = 0x561);
    NONFAILING(*(uint32_t*)0x200052b0 = 0xff);
    NONFAILING(*(uint32_t*)0x200052b4 = 3);
    NONFAILING(*(uint32_t*)0x200052b8 = 0x1ff);
    NONFAILING(*(uint32_t*)0x200052bc = 0);
    NONFAILING(*(uint32_t*)0x200052c0 = 7);
    NONFAILING(*(uint32_t*)0x200052c4 = 2);
    NONFAILING(*(uint32_t*)0x200052c8 = 2);
    NONFAILING(*(uint32_t*)0x200052cc = 9);
    NONFAILING(*(uint32_t*)0x200052d0 = 0);
    NONFAILING(*(uint32_t*)0x200052d4 = 0);
    NONFAILING(*(uint32_t*)0x200052d8 = 9);
    NONFAILING(*(uint32_t*)0x200052dc = 5);
    NONFAILING(*(uint32_t*)0x200052e0 = 1);
    NONFAILING(*(uint32_t*)0x200052e4 = 8);
    NONFAILING(*(uint32_t*)0x200052e8 = 0x101);
    NONFAILING(*(uint32_t*)0x200052ec = 0x1ff);
    NONFAILING(*(uint32_t*)0x200052f0 = 0xffff7fff);
    NONFAILING(*(uint32_t*)0x200052f4 = 0x20);
    NONFAILING(*(uint32_t*)0x200052f8 = 0x800);
    NONFAILING(*(uint32_t*)0x200052fc = 0xfffffffc);
    NONFAILING(*(uint32_t*)0x20005300 = 8);
    NONFAILING(*(uint32_t*)0x20005304 = 8);
    NONFAILING(*(uint32_t*)0x20005308 = 0xff);
    NONFAILING(*(uint32_t*)0x2000530c = 0x20);
    NONFAILING(*(uint32_t*)0x20005310 = 5);
    NONFAILING(*(uint32_t*)0x20005314 = 0x1f);
    NONFAILING(*(uint32_t*)0x20005318 = 0);
    NONFAILING(*(uint32_t*)0x2000531c = 0x3f);
    NONFAILING(*(uint32_t*)0x20005320 = 8);
    NONFAILING(*(uint32_t*)0x20005324 = 8);
    NONFAILING(*(uint32_t*)0x20005328 = 5);
    NONFAILING(*(uint32_t*)0x2000532c = 7);
    NONFAILING(*(uint32_t*)0x20005330 = 2);
    NONFAILING(*(uint32_t*)0x20005334 = 4);
    NONFAILING(*(uint32_t*)0x20005338 = 8);
    NONFAILING(*(uint32_t*)0x2000533c = 2);
    NONFAILING(*(uint32_t*)0x20005340 = 5);
    NONFAILING(*(uint32_t*)0x20005344 = 0x1000);
    NONFAILING(*(uint32_t*)0x20005348 = 9);
    NONFAILING(*(uint32_t*)0x2000534c = 0x400);
    NONFAILING(*(uint32_t*)0x20005350 = 4);
    NONFAILING(*(uint32_t*)0x20005354 = 0x800);
    NONFAILING(*(uint32_t*)0x20005358 = 0xd);
    NONFAILING(*(uint32_t*)0x2000535c = 0x80);
    NONFAILING(*(uint32_t*)0x20005360 = 2);
    NONFAILING(*(uint32_t*)0x20005364 = 0x80);
    NONFAILING(*(uint32_t*)0x20005368 = 0x3f);
    NONFAILING(*(uint32_t*)0x2000536c = 0x1f);
    NONFAILING(*(uint32_t*)0x20005370 = 3);
    NONFAILING(*(uint32_t*)0x20005374 = 4);
    NONFAILING(*(uint32_t*)0x20005378 = 9);
    NONFAILING(*(uint32_t*)0x2000537c = 5);
    NONFAILING(*(uint32_t*)0x20005380 = 8);
    NONFAILING(*(uint32_t*)0x20005384 = 0xa7);
    NONFAILING(*(uint32_t*)0x20005388 = 3);
    NONFAILING(*(uint32_t*)0x2000538c = 0xffff46e8);
    NONFAILING(*(uint32_t*)0x20005390 = 3);
    NONFAILING(*(uint32_t*)0x20005394 = 3);
    NONFAILING(*(uint32_t*)0x20005398 = -1);
    NONFAILING(*(uint32_t*)0x2000539c = 0x3f);
    NONFAILING(*(uint32_t*)0x200053a0 = 0x1ff);
    NONFAILING(*(uint32_t*)0x200053a4 = 0xc9);
    NONFAILING(*(uint32_t*)0x200053a8 = 0x7ff);
    NONFAILING(*(uint32_t*)0x200053ac = 4);
    NONFAILING(*(uint32_t*)0x200053b0 = 8);
    NONFAILING(*(uint32_t*)0x200053b4 = 7);
    NONFAILING(*(uint32_t*)0x200053b8 = 0x3439cc09);
    NONFAILING(*(uint32_t*)0x200053bc = 9);
    NONFAILING(*(uint32_t*)0x200053c0 = 0xc40d);
    NONFAILING(*(uint32_t*)0x200053c4 = 0x8001);
    NONFAILING(*(uint32_t*)0x200053c8 = 6);
    NONFAILING(*(uint32_t*)0x200053cc = 0x1ff);
    NONFAILING(*(uint32_t*)0x200053d0 = 0xfffff0e3);
    NONFAILING(*(uint32_t*)0x200053d4 = 0x3bf);
    NONFAILING(*(uint32_t*)0x200053d8 = 3);
    NONFAILING(*(uint32_t*)0x200053dc = 5);
    NONFAILING(*(uint32_t*)0x200053e0 = 5);
    NONFAILING(*(uint32_t*)0x200053e4 = 0x400);
    NONFAILING(*(uint32_t*)0x200053e8 = 6);
    NONFAILING(*(uint32_t*)0x200053ec = 4);
    NONFAILING(*(uint32_t*)0x200053f0 = 1);
    NONFAILING(*(uint32_t*)0x200053f4 = 0xe7);
    NONFAILING(*(uint32_t*)0x200053f8 = 0x3ac6);
    NONFAILING(*(uint32_t*)0x200053fc = 2);
    NONFAILING(*(uint32_t*)0x20005400 = 0);
    NONFAILING(*(uint32_t*)0x20005404 = 8);
    NONFAILING(*(uint32_t*)0x20005408 = 0x7fffffff);
    NONFAILING(*(uint32_t*)0x2000540c = 6);
    NONFAILING(*(uint32_t*)0x20005410 = 6);
    NONFAILING(*(uint32_t*)0x20005414 = 0x31);
    NONFAILING(*(uint32_t*)0x20005418 = 0x80000001);
    NONFAILING(*(uint32_t*)0x2000541c = 0x4f82);
    NONFAILING(*(uint32_t*)0x20005420 = 0x1ff);
    NONFAILING(*(uint32_t*)0x20005424 = 6);
    NONFAILING(*(uint32_t*)0x20005428 = 0x400);
    NONFAILING(*(uint32_t*)0x2000542c = 0xc16a);
    NONFAILING(*(uint32_t*)0x20005430 = 0xfffffffa);
    NONFAILING(*(uint32_t*)0x20005434 = 0xfffffffd);
    NONFAILING(*(uint32_t*)0x20005438 = 0xfd);
    NONFAILING(*(uint32_t*)0x2000543c = 0x7fffffff);
    NONFAILING(*(uint32_t*)0x20005440 = 0xfffffffb);
    NONFAILING(*(uint32_t*)0x20005444 = 4);
    NONFAILING(*(uint32_t*)0x20005448 = 6);
    NONFAILING(*(uint32_t*)0x2000544c = 9);
    NONFAILING(*(uint32_t*)0x20005450 = 0x8f39);
    NONFAILING(*(uint32_t*)0x20005454 = 5);
    NONFAILING(*(uint32_t*)0x20005458 = 0x3ff);
    NONFAILING(*(uint32_t*)0x2000545c = 2);
    NONFAILING(*(uint32_t*)0x20005460 = 5);
    NONFAILING(*(uint32_t*)0x20005464 = 0x80000001);
    NONFAILING(*(uint32_t*)0x20005468 = 0x7f);
    NONFAILING(*(uint32_t*)0x2000546c = 2);
    NONFAILING(*(uint32_t*)0x20005470 = 0x40);
    NONFAILING(*(uint32_t*)0x20005474 = 0x64);
    NONFAILING(*(uint32_t*)0x20005478 = 1);
    NONFAILING(*(uint32_t*)0x2000547c = 0xff);
    NONFAILING(*(uint32_t*)0x20005480 = 0xff);
    NONFAILING(*(uint32_t*)0x20005484 = 2);
    NONFAILING(*(uint32_t*)0x20005488 = 8);
    NONFAILING(*(uint32_t*)0x2000548c = 6);
    NONFAILING(*(uint32_t*)0x20005490 = 9);
    NONFAILING(*(uint32_t*)0x20005494 = 7);
    NONFAILING(*(uint32_t*)0x20005498 = 1);
    NONFAILING(*(uint32_t*)0x2000549c = 0);
    NONFAILING(*(uint32_t*)0x200054a0 = 4);
    NONFAILING(*(uint32_t*)0x200054a4 = 3);
    NONFAILING(*(uint32_t*)0x200054a8 = 2);
    NONFAILING(*(uint32_t*)0x200054ac = 8);
    NONFAILING(*(uint32_t*)0x200054b0 = 0x36);
    NONFAILING(*(uint32_t*)0x200054b4 = 3);
    NONFAILING(*(uint32_t*)0x200054b8 = 9);
    NONFAILING(*(uint32_t*)0x200054bc = 0x3f);
    NONFAILING(*(uint32_t*)0x200054c0 = 2);
    NONFAILING(*(uint32_t*)0x200054c4 = 0);
    NONFAILING(*(uint32_t*)0x200054c8 = 7);
    NONFAILING(*(uint32_t*)0x200054cc = 0);
    NONFAILING(*(uint32_t*)0x200054d0 = 6);
    NONFAILING(*(uint32_t*)0x200054d4 = 0x11);
    NONFAILING(*(uint32_t*)0x200054d8 = 0x439);
    NONFAILING(*(uint32_t*)0x200054dc = 0x9b);
    NONFAILING(*(uint32_t*)0x200054e0 = 0x81);
    NONFAILING(*(uint32_t*)0x200054e4 = -1);
    NONFAILING(*(uint32_t*)0x200054e8 = 1);
    NONFAILING(*(uint32_t*)0x200054ec = 0x3ff);
    NONFAILING(*(uint32_t*)0x200054f0 = 7);
    NONFAILING(*(uint32_t*)0x200054f4 = 0xffffdd75);
    NONFAILING(*(uint32_t*)0x200054f8 = 4);
    NONFAILING(*(uint32_t*)0x200054fc = 8);
    NONFAILING(*(uint32_t*)0x20005500 = 0);
    NONFAILING(*(uint32_t*)0x20005504 = 0);
    NONFAILING(*(uint32_t*)0x20005508 = 3);
    NONFAILING(*(uint32_t*)0x2000550c = 0x46);
    NONFAILING(*(uint32_t*)0x20005510 = 7);
    NONFAILING(*(uint32_t*)0x20005514 = 0x200);
    NONFAILING(*(uint32_t*)0x20005518 = 0xa03);
    NONFAILING(*(uint32_t*)0x2000551c = 0);
    NONFAILING(*(uint32_t*)0x20005520 = 0xf1dc);
    NONFAILING(*(uint32_t*)0x20005524 = 3);
    NONFAILING(*(uint32_t*)0x20005528 = 9);
    NONFAILING(*(uint32_t*)0x2000552c = 9);
    NONFAILING(*(uint32_t*)0x20005530 = 1);
    NONFAILING(*(uint32_t*)0x20005534 = 0x7585c023);
    NONFAILING(*(uint32_t*)0x20005538 = 0x1b498e71);
    NONFAILING(*(uint32_t*)0x2000553c = 4);
    NONFAILING(*(uint32_t*)0x20005540 = 9);
    NONFAILING(*(uint32_t*)0x20005544 = 0xd27);
    NONFAILING(*(uint32_t*)0x20005548 = 0xfffffff7);
    NONFAILING(*(uint32_t*)0x2000554c = 0xffff);
    NONFAILING(*(uint32_t*)0x20005550 = 0x55);
    NONFAILING(*(uint32_t*)0x20005554 = 4);
    NONFAILING(*(uint32_t*)0x20005558 = 3);
    NONFAILING(*(uint32_t*)0x2000555c = 0x80000000);
    NONFAILING(*(uint32_t*)0x20005560 = 0x10000);
    NONFAILING(*(uint32_t*)0x20005564 = 2);
    NONFAILING(*(uint32_t*)0x20005568 = 0x9ec);
    NONFAILING(*(uint32_t*)0x2000556c = 0x100);
    NONFAILING(*(uint32_t*)0x20005570 = 0xd22);
    NONFAILING(*(uint32_t*)0x20005574 = 0xfffffff7);
    NONFAILING(*(uint32_t*)0x20005578 = 8);
    NONFAILING(*(uint32_t*)0x2000557c = 0x2c);
    NONFAILING(*(uint32_t*)0x20005580 = 0x3ff);
    NONFAILING(*(uint32_t*)0x20005584 = 0xfffffff7);
    NONFAILING(*(uint32_t*)0x20005588 = 0);
    NONFAILING(*(uint32_t*)0x2000558c = 0xfffc0000);
    NONFAILING(*(uint32_t*)0x20005590 = 0x10001);
    NONFAILING(*(uint32_t*)0x20005594 = 4);
    NONFAILING(*(uint32_t*)0x20005598 = 0x9c0000);
    NONFAILING(*(uint32_t*)0x2000559c = 0xe27);
    NONFAILING(*(uint32_t*)0x200055a0 = 9);
    NONFAILING(*(uint32_t*)0x200055a4 = 9);
    NONFAILING(*(uint32_t*)0x200055a8 = 3);
    NONFAILING(*(uint32_t*)0x200055ac = 0x9d6);
    NONFAILING(*(uint32_t*)0x200055b0 = 0x8a);
    NONFAILING(*(uint32_t*)0x200055b4 = 0);
    NONFAILING(*(uint32_t*)0x200055b8 = 0x69c0);
    NONFAILING(*(uint32_t*)0x200055bc = 7);
    NONFAILING(*(uint32_t*)0x200055c0 = 5);
    NONFAILING(*(uint32_t*)0x200055c4 = 0x18d);
    NONFAILING(*(uint32_t*)0x200055c8 = 0xfff);
    NONFAILING(*(uint32_t*)0x200055cc = 2);
    NONFAILING(*(uint32_t*)0x200055d0 = 4);
    NONFAILING(*(uint32_t*)0x200055d4 = 0x80);
    NONFAILING(*(uint32_t*)0x200055d8 = 6);
    NONFAILING(*(uint32_t*)0x200055dc = 7);
    NONFAILING(*(uint32_t*)0x200055e0 = 6);
    NONFAILING(*(uint32_t*)0x200055e4 = 5);
    NONFAILING(*(uint32_t*)0x200055e8 = 0x7f);
    NONFAILING(*(uint32_t*)0x200055ec = 2);
    NONFAILING(*(uint32_t*)0x200055f0 = 0xad);
    NONFAILING(*(uint32_t*)0x200055f4 = 8);
    NONFAILING(*(uint32_t*)0x200055f8 = 6);
    NONFAILING(*(uint32_t*)0x200055fc = 0x3c2);
    NONFAILING(*(uint32_t*)0x20005600 = 1);
    NONFAILING(*(uint32_t*)0x20005604 = 2);
    NONFAILING(*(uint32_t*)0x20005608 = 7);
    NONFAILING(*(uint32_t*)0x2000560c = 0x100);
    NONFAILING(*(uint32_t*)0x20005610 = 3);
    NONFAILING(*(uint32_t*)0x20005614 = 0);
    NONFAILING(*(uint32_t*)0x20005618 = 6);
    NONFAILING(*(uint32_t*)0x2000561c = 0x2ce);
    NONFAILING(*(uint32_t*)0x20005620 = 0x81);
    NONFAILING(*(uint32_t*)0x20005624 = 3);
    NONFAILING(*(uint32_t*)0x20005628 = 5);
    NONFAILING(*(uint32_t*)0x2000562c = 0x7f);
    NONFAILING(*(uint32_t*)0x20005630 = 0x10001);
    NONFAILING(*(uint32_t*)0x20005634 = 0);
    NONFAILING(*(uint32_t*)0x20005638 = 0x3d55);
    NONFAILING(*(uint32_t*)0x2000563c = -1);
    NONFAILING(*(uint32_t*)0x20005640 = 0x3f);
    NONFAILING(*(uint32_t*)0x20005644 = 9);
    NONFAILING(*(uint32_t*)0x20005648 = 5);
    NONFAILING(*(uint32_t*)0x2000564c = 7);
    NONFAILING(*(uint32_t*)0x20005650 = 8);
    NONFAILING(*(uint32_t*)0x20005654 = 0x7ff);
    NONFAILING(*(uint32_t*)0x20005658 = 0xfff);
    NONFAILING(*(uint32_t*)0x2000565c = 5);
    NONFAILING(*(uint32_t*)0x20005660 = 0xa2);
    NONFAILING(*(uint32_t*)0x20005664 = 9);
    NONFAILING(*(uint32_t*)0x20005668 = 0x10000);
    NONFAILING(*(uint32_t*)0x2000566c = 0xb76b);
    NONFAILING(*(uint32_t*)0x20005670 = 1);
    NONFAILING(*(uint32_t*)0x20005674 = 5);
    NONFAILING(*(uint32_t*)0x20005678 = 0x7fffffff);
    NONFAILING(*(uint32_t*)0x2000567c = 1);
    NONFAILING(*(uint32_t*)0x20005680 = 0x6b5935ce);
    NONFAILING(*(uint32_t*)0x20005684 = 0x206);
    NONFAILING(*(uint32_t*)0x20005688 = 0xb039);
    NONFAILING(*(uint32_t*)0x2000568c = 0x8000);
    NONFAILING(*(uint32_t*)0x20005690 = 2);
    NONFAILING(*(uint32_t*)0x20005694 = 0x33f);
    NONFAILING(*(uint32_t*)0x20005698 = 7);
    NONFAILING(*(uint32_t*)0x2000569c = 0xfff);
    NONFAILING(*(uint32_t*)0x200056a0 = 0x4d);
    NONFAILING(*(uint32_t*)0x200056a4 = -1);
    NONFAILING(*(uint32_t*)0x200056a8 = 0x390);
    NONFAILING(*(uint32_t*)0x200056ac = 9);
    NONFAILING(*(uint32_t*)0x200056b0 = 7);
    NONFAILING(*(uint32_t*)0x200056b4 = 0xffff);
    NONFAILING(*(uint32_t*)0x200056b8 = 0x100);
    NONFAILING(*(uint32_t*)0x200056bc = 0x4ede);
    NONFAILING(*(uint32_t*)0x200056c0 = 7);
    NONFAILING(*(uint32_t*)0x200056c4 = 0x80000000);
    NONFAILING(*(uint32_t*)0x200056c8 = 3);
    NONFAILING(*(uint32_t*)0x200056cc = 1);
    NONFAILING(*(uint32_t*)0x200056d0 = 0xfff);
    NONFAILING(*(uint32_t*)0x200056d4 = 9);
    NONFAILING(*(uint32_t*)0x200056d8 = 2);
    NONFAILING(*(uint32_t*)0x200056dc = 0x10001);
    NONFAILING(*(uint32_t*)0x200056e0 = 1);
    NONFAILING(*(uint32_t*)0x200056e4 = 0xffff);
    NONFAILING(*(uint32_t*)0x200056e8 = 4);
    NONFAILING(*(uint32_t*)0x200056ec = 1);
    NONFAILING(*(uint32_t*)0x200056f0 = 9);
    NONFAILING(*(uint32_t*)0x200056f4 = 0x10000);
    NONFAILING(*(uint32_t*)0x200056f8 = 0xfffffffa);
    NONFAILING(*(uint32_t*)0x200056fc = 0x40);
    NONFAILING(*(uint32_t*)0x20005700 = 0x80000000);
    NONFAILING(*(uint32_t*)0x20005704 = 0x10001);
    NONFAILING(*(uint32_t*)0x20005708 = 0);
    NONFAILING(*(uint32_t*)0x2000570c = 0x5d);
    NONFAILING(*(uint32_t*)0x20005710 = 6);
    NONFAILING(*(uint32_t*)0x20005714 = 9);
    NONFAILING(*(uint32_t*)0x20005718 = 0xffff);
    NONFAILING(*(uint32_t*)0x2000571c = 0x10000);
    NONFAILING(*(uint32_t*)0x20005720 = 8);
    NONFAILING(*(uint32_t*)0x20005724 = 3);
    NONFAILING(*(uint32_t*)0x20005728 = 3);
    NONFAILING(*(uint32_t*)0x2000572c = 2);
    NONFAILING(*(uint32_t*)0x20005730 = 0x100);
    NONFAILING(*(uint32_t*)0x20005734 = 9);
    NONFAILING(*(uint32_t*)0x20005738 = 1);
    NONFAILING(*(uint32_t*)0x2000573c = 7);
    NONFAILING(*(uint32_t*)0x20005740 = 0xfffff801);
    NONFAILING(*(uint32_t*)0x20005744 = 3);
    NONFAILING(*(uint32_t*)0x20005748 = 0xfffffffa);
    NONFAILING(*(uint32_t*)0x2000574c = 1);
    NONFAILING(*(uint32_t*)0x20005750 = 8);
    NONFAILING(*(uint32_t*)0x20005754 = 0xbc);
    NONFAILING(*(uint32_t*)0x20005758 = 0x88ce);
    NONFAILING(*(uint32_t*)0x2000575c = 7);
    NONFAILING(*(uint32_t*)0x20005760 = 0x9511);
    NONFAILING(*(uint32_t*)0x20005764 = 3);
    NONFAILING(*(uint32_t*)0x20005768 = 0x81);
    NONFAILING(*(uint32_t*)0x2000576c = 0x800);
    NONFAILING(*(uint32_t*)0x20005770 = 2);
    NONFAILING(*(uint32_t*)0x20005774 = 3);
    NONFAILING(*(uint32_t*)0x20005778 = 1);
    NONFAILING(*(uint32_t*)0x2000577c = 3);
    NONFAILING(*(uint32_t*)0x20005780 = 0x86);
    NONFAILING(*(uint32_t*)0x20005784 = 0xfffffff7);
    NONFAILING(*(uint32_t*)0x20005788 = 6);
    NONFAILING(*(uint32_t*)0x2000578c = 7);
    NONFAILING(*(uint32_t*)0x20005790 = 2);
    NONFAILING(*(uint32_t*)0x20005794 = 0x21);
    NONFAILING(*(uint32_t*)0x20005798 = 0x8000);
    NONFAILING(*(uint32_t*)0x2000579c = 4);
    NONFAILING(*(uint32_t*)0x200057a0 = 9);
    NONFAILING(*(uint32_t*)0x200057a4 = 7);
    NONFAILING(*(uint32_t*)0x200057a8 = 0x3c);
    NONFAILING(*(uint32_t*)0x200057ac = 6);
    NONFAILING(*(uint32_t*)0x200057b0 = 0xe185);
    NONFAILING(*(uint32_t*)0x200057b4 = 2);
    NONFAILING(*(uint32_t*)0x200057b8 = 0x5f);
    NONFAILING(*(uint32_t*)0x200057bc = 3);
    NONFAILING(*(uint32_t*)0x200057c0 = 5);
    NONFAILING(*(uint32_t*)0x200057c4 = 1);
    NONFAILING(*(uint32_t*)0x200057c8 = 2);
    NONFAILING(*(uint32_t*)0x200057cc = 0x101);
    NONFAILING(*(uint32_t*)0x200057d0 = 0);
    NONFAILING(*(uint32_t*)0x200057d4 = 0x2e);
    NONFAILING(*(uint32_t*)0x200057d8 = 0x5b1b3cf8);
    NONFAILING(*(uint32_t*)0x200057dc = 0x8d);
    NONFAILING(*(uint32_t*)0x200057e0 = 0x70d4);
    NONFAILING(*(uint32_t*)0x200057e4 = 4);
    NONFAILING(*(uint32_t*)0x200057e8 = 0x6f82);
    NONFAILING(*(uint32_t*)0x200057ec = 9);
    NONFAILING(*(uint32_t*)0x200057f0 = 0);
    NONFAILING(*(uint32_t*)0x200057f4 = 0x401);
    NONFAILING(*(uint32_t*)0x200057f8 = 0x80000000);
    NONFAILING(*(uint32_t*)0x200057fc = 0x800);
    NONFAILING(*(uint32_t*)0x20005800 = 9);
    NONFAILING(*(uint32_t*)0x20005804 = 0xe0000000);
    NONFAILING(*(uint32_t*)0x20005808 = 8);
    NONFAILING(*(uint32_t*)0x2000580c = 0xda63);
    NONFAILING(*(uint32_t*)0x20005810 = 0x10001);
    NONFAILING(*(uint32_t*)0x20005814 = 6);
    NONFAILING(*(uint32_t*)0x20005818 = 0x80);
    NONFAILING(*(uint32_t*)0x2000581c = 7);
    NONFAILING(*(uint32_t*)0x20005820 = 1);
    NONFAILING(*(uint32_t*)0x20005824 = 6);
    NONFAILING(*(uint32_t*)0x20005828 = 0xfffffff7);
    NONFAILING(*(uint32_t*)0x2000582c = 6);
    NONFAILING(*(uint32_t*)0x20005830 = 0xffff);
    NONFAILING(*(uint32_t*)0x20005834 = 0x80000001);
    NONFAILING(*(uint32_t*)0x20005838 = 0xa0);
    NONFAILING(*(uint32_t*)0x2000583c = 3);
    NONFAILING(*(uint32_t*)0x20005840 = 9);
    NONFAILING(*(uint32_t*)0x20005844 = 0);
    NONFAILING(*(uint32_t*)0x20005848 = 0x8000);
    NONFAILING(*(uint32_t*)0x2000584c = 0x8001);
    NONFAILING(*(uint32_t*)0x20005850 = 3);
    NONFAILING(*(uint32_t*)0x20005854 = 9);
    NONFAILING(*(uint32_t*)0x20005858 = 0xff);
    NONFAILING(*(uint32_t*)0x2000585c = 0xe54e);
    NONFAILING(*(uint32_t*)0x20005860 = 5);
    NONFAILING(*(uint32_t*)0x20005864 = 1);
    NONFAILING(*(uint32_t*)0x20005868 = 6);
    NONFAILING(*(uint32_t*)0x2000586c = 0x80000001);
    NONFAILING(*(uint32_t*)0x20005870 = 0);
    NONFAILING(*(uint32_t*)0x20005874 = 1);
    NONFAILING(*(uint32_t*)0x20005878 = 0x81);
    NONFAILING(*(uint32_t*)0x2000587c = 0x10a79bc8);
    NONFAILING(*(uint32_t*)0x20005880 = 3);
    NONFAILING(*(uint32_t*)0x20005884 = 4);
    NONFAILING(*(uint32_t*)0x20005888 = 0x7fffffff);
    NONFAILING(*(uint32_t*)0x2000588c = 9);
    NONFAILING(*(uint32_t*)0x20005890 = 0x80);
    NONFAILING(*(uint32_t*)0x20005894 = 0x10000);
    NONFAILING(*(uint32_t*)0x20005898 = 0x80000000);
    NONFAILING(*(uint32_t*)0x2000589c = 4);
    NONFAILING(*(uint32_t*)0x200058a0 = 0x7c);
    NONFAILING(*(uint32_t*)0x200058a4 = 0x3ff);
    NONFAILING(*(uint32_t*)0x200058a8 = 0);
    NONFAILING(*(uint32_t*)0x200058ac = 8);
    NONFAILING(*(uint32_t*)0x200058b0 = 8);
    NONFAILING(*(uint32_t*)0x200058b4 = 7);
    NONFAILING(*(uint32_t*)0x200058b8 = 0xabe3);
    NONFAILING(*(uint32_t*)0x200058bc = 5);
    NONFAILING(*(uint32_t*)0x200058c0 = -1);
    NONFAILING(*(uint32_t*)0x200058c4 = 6);
    NONFAILING(*(uint32_t*)0x200058c8 = 0x1c);
    NONFAILING(*(uint32_t*)0x200058cc = 0x200);
    NONFAILING(*(uint32_t*)0x200058d0 = 3);
    NONFAILING(*(uint32_t*)0x200058d4 = 0xfff);
    NONFAILING(*(uint32_t*)0x200058d8 = 0x800);
    NONFAILING(*(uint32_t*)0x200058dc = 0);
    NONFAILING(*(uint32_t*)0x200058e0 = 9);
    NONFAILING(*(uint32_t*)0x200058e4 = 6);
    NONFAILING(*(uint32_t*)0x200058e8 = 0x7f);
    NONFAILING(*(uint32_t*)0x200058ec = 0x4a00);
    NONFAILING(*(uint32_t*)0x200058f0 = 6);
    NONFAILING(*(uint32_t*)0x200058f4 = 0);
    NONFAILING(*(uint32_t*)0x200058f8 = 6);
    NONFAILING(*(uint32_t*)0x200058fc = 0xfffffff7);
    NONFAILING(*(uint32_t*)0x20005900 = 0);
    NONFAILING(*(uint32_t*)0x20005904 = 3);
    NONFAILING(*(uint32_t*)0x20005908 = 0x40);
    NONFAILING(*(uint32_t*)0x2000590c = 0x80000000);
    NONFAILING(*(uint32_t*)0x20005910 = 6);
    NONFAILING(*(uint32_t*)0x20005914 = 0x4e7e270d);
    NONFAILING(*(uint32_t*)0x20005918 = 0xff);
    NONFAILING(*(uint32_t*)0x2000591c = 6);
    NONFAILING(*(uint32_t*)0x20005920 = 0x3b);
    NONFAILING(*(uint32_t*)0x20005924 = 1);
    NONFAILING(*(uint32_t*)0x20005928 = 0x101);
    NONFAILING(*(uint32_t*)0x2000592c = 0xa5f);
    NONFAILING(*(uint32_t*)0x20005930 = 0x80);
    NONFAILING(*(uint32_t*)0x20005934 = 9);
    NONFAILING(*(uint32_t*)0x20005938 = -1);
    NONFAILING(*(uint32_t*)0x2000593c = 0x101);
    NONFAILING(*(uint32_t*)0x20005940 = 8);
    NONFAILING(*(uint32_t*)0x20005944 = 0x755e);
    NONFAILING(*(uint32_t*)0x20005948 = 0xfffffffb);
    NONFAILING(*(uint32_t*)0x2000594c = 0);
    NONFAILING(*(uint32_t*)0x20005950 = 2);
    NONFAILING(*(uint32_t*)0x20005954 = 9);
    NONFAILING(*(uint32_t*)0x20005958 = 9);
    NONFAILING(*(uint32_t*)0x2000595c = 0);
    NONFAILING(*(uint32_t*)0x20005960 = 5);
    NONFAILING(*(uint32_t*)0x20005964 = 0xea7);
    NONFAILING(*(uint32_t*)0x20005968 = 2);
    NONFAILING(*(uint32_t*)0x2000596c = 2);
    NONFAILING(*(uint32_t*)0x20005970 = 0x3ff);
    NONFAILING(*(uint32_t*)0x20005974 = 0x3f0);
    NONFAILING(*(uint32_t*)0x20005978 = 0x400);
    NONFAILING(*(uint32_t*)0x2000597c = 1);
    NONFAILING(*(uint32_t*)0x20005980 = 7);
    NONFAILING(*(uint32_t*)0x20005984 = 0x200);
    NONFAILING(*(uint32_t*)0x20005988 = 0xff);
    NONFAILING(*(uint32_t*)0x2000598c = 0x3c19);
    NONFAILING(*(uint32_t*)0x20005990 = 5);
    NONFAILING(*(uint32_t*)0x20005994 = 0x401);
    NONFAILING(*(uint32_t*)0x20005998 = 7);
    NONFAILING(*(uint32_t*)0x2000599c = 1);
    NONFAILING(*(uint32_t*)0x200059a0 = 0x8001);
    NONFAILING(*(uint32_t*)0x200059a4 = 0xbc);
    NONFAILING(*(uint32_t*)0x200059a8 = 8);
    NONFAILING(*(uint32_t*)0x200059ac = -1);
    NONFAILING(*(uint32_t*)0x200059b0 = 0xa2);
    NONFAILING(*(uint32_t*)0x200059b4 = 0x8000);
    NONFAILING(*(uint32_t*)0x200059b8 = 0x670);
    NONFAILING(*(uint32_t*)0x200059bc = 3);
    NONFAILING(*(uint32_t*)0x200059c0 = 0);
    NONFAILING(*(uint32_t*)0x200059c4 = 0x7fff);
    NONFAILING(*(uint32_t*)0x200059c8 = 0x200);
    NONFAILING(*(uint32_t*)0x200059cc = 0);
    NONFAILING(*(uint32_t*)0x200059d0 = 0x6a50);
    NONFAILING(*(uint32_t*)0x200059d4 = 0x552);
    NONFAILING(*(uint32_t*)0x200059d8 = 0x200);
    NONFAILING(*(uint32_t*)0x200059dc = 6);
    NONFAILING(*(uint32_t*)0x200059e0 = 0x8d);
    NONFAILING(*(uint32_t*)0x200059e4 = 0x66e6);
    NONFAILING(*(uint32_t*)0x200059e8 = 0xfffffff7);
    NONFAILING(*(uint32_t*)0x200059ec = 0x1000000);
    NONFAILING(*(uint32_t*)0x200059f0 = 6);
    NONFAILING(*(uint32_t*)0x200059f4 = 8);
    NONFAILING(*(uint32_t*)0x200059f8 = 0xfffffc00);
    NONFAILING(*(uint32_t*)0x200059fc = 1);
    NONFAILING(*(uint32_t*)0x20005a00 = -1);
    NONFAILING(*(uint32_t*)0x20005a04 = 8);
    NONFAILING(*(uint32_t*)0x20005a08 = 5);
    NONFAILING(*(uint32_t*)0x20005a0c = 8);
    NONFAILING(*(uint32_t*)0x20005a10 = 0xdab);
    NONFAILING(*(uint32_t*)0x20005a14 = 0x533);
    NONFAILING(*(uint32_t*)0x20005a18 = 0xe78);
    NONFAILING(*(uint32_t*)0x20005a1c = 1);
    NONFAILING(*(uint32_t*)0x20005a20 = 1);
    NONFAILING(*(uint32_t*)0x20005a24 = 0x153);
    NONFAILING(*(uint32_t*)0x20005a28 = 7);
    NONFAILING(*(uint32_t*)0x20005a2c = -1);
    NONFAILING(*(uint32_t*)0x20005a30 = 0xa2);
    NONFAILING(*(uint32_t*)0x20005a34 = 0x6f);
    NONFAILING(*(uint32_t*)0x20005a38 = 5);
    NONFAILING(*(uint32_t*)0x20005a3c = 7);
    NONFAILING(*(uint32_t*)0x20005a40 = 3);
    NONFAILING(*(uint32_t*)0x20005a44 = 0x1f);
    NONFAILING(*(uint32_t*)0x20005a48 = 0x80);
    NONFAILING(*(uint32_t*)0x20005a4c = 1);
    NONFAILING(*(uint32_t*)0x20005a50 = 0x7fffffff);
    NONFAILING(*(uint32_t*)0x20005a54 = 0x6784);
    NONFAILING(*(uint32_t*)0x20005a58 = 0);
    NONFAILING(*(uint32_t*)0x20005a5c = 0x1000);
    NONFAILING(*(uint32_t*)0x20005a60 = 8);
    NONFAILING(*(uint32_t*)0x20005a64 = 0x406a);
    NONFAILING(*(uint32_t*)0x20005a68 = 0x7f);
    NONFAILING(*(uint32_t*)0x20005a6c = 8);
    NONFAILING(*(uint32_t*)0x20005a70 = 0x1f);
    NONFAILING(*(uint32_t*)0x20005a74 = 8);
    NONFAILING(*(uint32_t*)0x20005a78 = 2);
    NONFAILING(*(uint32_t*)0x20005a7c = 0x883b);
    NONFAILING(*(uint32_t*)0x20005a80 = 0x400);
    NONFAILING(*(uint32_t*)0x20005a84 = 0xfffffff7);
    NONFAILING(*(uint32_t*)0x20005a88 = 9);
    NONFAILING(*(uint32_t*)0x20005a8c = 0x10000);
    NONFAILING(*(uint32_t*)0x20005a90 = 0x80000000);
    NONFAILING(*(uint32_t*)0x20005a94 = 6);
    NONFAILING(*(uint32_t*)0x20005a98 = 0x80);
    NONFAILING(*(uint32_t*)0x20005a9c = 0xfffffffb);
    NONFAILING(*(uint32_t*)0x20005aa0 = 0x400);
    NONFAILING(*(uint32_t*)0x20005aa4 = 4);
    NONFAILING(*(uint32_t*)0x20005aa8 = 0x7ff);
    NONFAILING(*(uint32_t*)0x20005aac = 1);
    NONFAILING(*(uint32_t*)0x20005ab0 = 0x200);
    NONFAILING(*(uint32_t*)0x20005ab4 = 0x80000001);
    NONFAILING(*(uint32_t*)0x20005ab8 = 0xfffffffc);
    NONFAILING(*(uint32_t*)0x20005abc = 3);
    NONFAILING(*(uint32_t*)0x20005ac0 = 4);
    NONFAILING(*(uint32_t*)0x20005ac4 = 0x1ff);
    NONFAILING(*(uint32_t*)0x20005ac8 = 5);
    NONFAILING(*(uint32_t*)0x20005acc = 4);
    NONFAILING(*(uint32_t*)0x20005ad0 = 0);
    NONFAILING(*(uint32_t*)0x20005ad4 = 5);
    NONFAILING(*(uint32_t*)0x20005ad8 = 2);
    NONFAILING(*(uint32_t*)0x20005adc = 0x2cdb1f36);
    NONFAILING(*(uint32_t*)0x20005ae0 = 0);
    NONFAILING(*(uint32_t*)0x20005ae4 = 0xfffffffc);
    NONFAILING(*(uint32_t*)0x20005ae8 = 4);
    NONFAILING(*(uint32_t*)0x20005aec = 0x47);
    NONFAILING(*(uint32_t*)0x20005af0 = 0xfffffffc);
    NONFAILING(*(uint32_t*)0x20005af4 = 0xffffffe0);
    NONFAILING(*(uint32_t*)0x20005af8 = 0x200);
    NONFAILING(*(uint32_t*)0x20005afc = 0x4e7);
    NONFAILING(*(uint32_t*)0x20005b00 = 0x401);
    NONFAILING(*(uint32_t*)0x20005b04 = 9);
    NONFAILING(*(uint32_t*)0x20005b08 = 9);
    NONFAILING(*(uint32_t*)0x20005b0c = 1);
    NONFAILING(*(uint32_t*)0x20005b10 = 0x100);
    NONFAILING(*(uint32_t*)0x20005b14 = 4);
    NONFAILING(*(uint32_t*)0x20005b18 = 4);
    NONFAILING(*(uint32_t*)0x20005b1c = 8);
    NONFAILING(*(uint32_t*)0x20005b20 = 0x8000);
    NONFAILING(*(uint32_t*)0x20005b24 = 6);
    NONFAILING(*(uint32_t*)0x20005b28 = 0x41);
    NONFAILING(*(uint32_t*)0x20005b2c = 0xfffffff9);
    NONFAILING(*(uint32_t*)0x20005b30 = 9);
    NONFAILING(*(uint32_t*)0x20005b34 = 8);
    NONFAILING(*(uint32_t*)0x20005b38 = 8);
    NONFAILING(*(uint32_t*)0x20005b3c = 2);
    NONFAILING(*(uint32_t*)0x20005b40 = -1);
    NONFAILING(*(uint32_t*)0x20005b44 = 4);
    NONFAILING(*(uint32_t*)0x20005b48 = 0x7fff);
    NONFAILING(*(uint32_t*)0x20005b4c = 9);
    NONFAILING(*(uint32_t*)0x20005b50 = 0x9a19);
    NONFAILING(*(uint32_t*)0x20005b54 = 0xc0);
    NONFAILING(*(uint32_t*)0x20005b58 = 0x641);
    NONFAILING(*(uint32_t*)0x20005b5c = 0);
    NONFAILING(*(uint32_t*)0x20005b60 = 0xfbc1);
    NONFAILING(*(uint32_t*)0x20005b64 = 0x400);
    NONFAILING(*(uint32_t*)0x20005b68 = 1);
    NONFAILING(*(uint32_t*)0x20005b6c = 2);
    NONFAILING(*(uint32_t*)0x20005b70 = 0x40);
    NONFAILING(*(uint32_t*)0x20005b74 = 6);
    NONFAILING(*(uint32_t*)0x20005b78 = 0xfffffffa);
    NONFAILING(*(uint32_t*)0x20005b7c = 0xf7e5);
    NONFAILING(*(uint32_t*)0x20005b80 = 0xd7);
    NONFAILING(*(uint32_t*)0x20005b84 = 8);
    NONFAILING(*(uint32_t*)0x20005b88 = 0xfffffff7);
    NONFAILING(*(uint32_t*)0x20005b8c = 2);
    NONFAILING(*(uint32_t*)0x20005b90 = 0);
    NONFAILING(*(uint32_t*)0x20005b94 = 2);
    NONFAILING(*(uint32_t*)0x20005b98 = 0);
    NONFAILING(*(uint32_t*)0x20005b9c = 8);
    NONFAILING(*(uint32_t*)0x20005ba0 = 0x101);
    NONFAILING(*(uint32_t*)0x20005ba4 = 8);
    NONFAILING(*(uint32_t*)0x20005ba8 = 6);
    NONFAILING(*(uint32_t*)0x20005bac = 8);
    NONFAILING(*(uint32_t*)0x20005bb0 = 0xfffffffe);
    NONFAILING(*(uint32_t*)0x20005bb4 = 0x20);
    NONFAILING(*(uint32_t*)0x20005bb8 = 2);
    NONFAILING(*(uint32_t*)0x20005bbc = 9);
    NONFAILING(*(uint32_t*)0x20005bc0 = 0x800);
    NONFAILING(*(uint32_t*)0x20005bc4 = 0xffffffec);
    NONFAILING(*(uint32_t*)0x20005bc8 = 0x7fff);
    NONFAILING(*(uint32_t*)0x20005bcc = 0x80000001);
    NONFAILING(*(uint32_t*)0x20005bd0 = 4);
    NONFAILING(*(uint32_t*)0x20005bd4 = 0xfffffffb);
    NONFAILING(*(uint32_t*)0x20005bd8 = 0x800);
    NONFAILING(*(uint32_t*)0x20005bdc = 9);
    NONFAILING(*(uint32_t*)0x20005be0 = 0xfffffffd);
    NONFAILING(*(uint32_t*)0x20005be4 = 3);
    NONFAILING(*(uint32_t*)0x20005be8 = 0x8205);
    NONFAILING(*(uint32_t*)0x20005bec = 0x9af);
    NONFAILING(*(uint32_t*)0x20005bf0 = 0x3f);
    NONFAILING(*(uint32_t*)0x20005bf4 = 6);
    NONFAILING(*(uint32_t*)0x20005bf8 = 0xfffffff8);
    NONFAILING(*(uint32_t*)0x20005bfc = 0x10000);
    NONFAILING(*(uint32_t*)0x20005c00 = 2);
    NONFAILING(*(uint32_t*)0x20005c04 = 5);
    NONFAILING(*(uint32_t*)0x20005c08 = 7);
    NONFAILING(*(uint32_t*)0x20005c0c = 2);
    NONFAILING(*(uint32_t*)0x20005c10 = 0);
    NONFAILING(*(uint32_t*)0x20005c14 = 0x8000);
    NONFAILING(*(uint32_t*)0x20005c18 = 0x10000);
    NONFAILING(*(uint32_t*)0x20005c1c = 8);
    NONFAILING(*(uint32_t*)0x20005c20 = 0xb1d7);
    NONFAILING(*(uint32_t*)0x20005c24 = 5);
    NONFAILING(*(uint32_t*)0x20005c28 = 4);
    NONFAILING(*(uint32_t*)0x20005c2c = 0x41);
    NONFAILING(*(uint32_t*)0x20005c30 = 5);
    NONFAILING(*(uint32_t*)0x20005c34 = 0);
    NONFAILING(*(uint32_t*)0x20005c38 = 0xae);
    NONFAILING(*(uint32_t*)0x20005c3c = 0x40);
    NONFAILING(*(uint32_t*)0x20005c40 = 5);
    NONFAILING(*(uint32_t*)0x20005c44 = 9);
    NONFAILING(*(uint32_t*)0x20005c48 = 8);
    NONFAILING(*(uint32_t*)0x20005c4c = 0x1b2d);
    NONFAILING(*(uint32_t*)0x20005c50 = 0);
    NONFAILING(*(uint32_t*)0x20005c54 = 0xffffff01);
    NONFAILING(*(uint32_t*)0x20005c58 = 2);
    NONFAILING(*(uint32_t*)0x20005c5c = 2);
    NONFAILING(*(uint32_t*)0x20005c60 = 1);
    NONFAILING(*(uint32_t*)0x20005c64 = 9);
    NONFAILING(*(uint32_t*)0x20005c68 = 4);
    NONFAILING(*(uint32_t*)0x20005c6c = 0x400);
    NONFAILING(*(uint32_t*)0x20005c70 = 0xfd4);
    NONFAILING(*(uint32_t*)0x20005c74 = 5);
    NONFAILING(*(uint32_t*)0x20005c78 = 7);
    NONFAILING(*(uint32_t*)0x20005c7c = 1);
    NONFAILING(*(uint32_t*)0x20005c80 = 3);
    NONFAILING(*(uint32_t*)0x20005c84 = 1);
    NONFAILING(*(uint32_t*)0x20005c88 = 0x7fff);
    NONFAILING(*(uint32_t*)0x20005c8c = 0x9c4);
    NONFAILING(*(uint32_t*)0x20005c90 = 2);
    NONFAILING(*(uint32_t*)0x20005c94 = 8);
    NONFAILING(*(uint32_t*)0x20005c98 = 0);
    NONFAILING(*(uint32_t*)0x20005c9c = 0xfffffffa);
    NONFAILING(*(uint32_t*)0x20005ca0 = 5);
    NONFAILING(*(uint32_t*)0x20005ca4 = 4);
    NONFAILING(*(uint32_t*)0x20005ca8 = 2);
    NONFAILING(*(uint32_t*)0x20005cac = 0x3c);
    NONFAILING(*(uint32_t*)0x20005cb0 = 0x200);
    NONFAILING(*(uint16_t*)0x20005cb4 = 0);
    NONFAILING(*(uint16_t*)0x20005cb6 = 0);
    NONFAILING(*(uint16_t*)0x20005cb8 = 5);
    NONFAILING(*(uint16_t*)0x20005cba = 0);
    NONFAILING(*(uint16_t*)0x20005cbc = 0xe);
    NONFAILING(*(uint16_t*)0x20005cbe = 0);
    NONFAILING(*(uint16_t*)0x20005cc0 = 3);
    NONFAILING(*(uint16_t*)0x20005cc2 = 1);
    NONFAILING(*(uint16_t*)0x20005cc4 = 5);
    NONFAILING(*(uint16_t*)0x20005cc6 = 0);
    NONFAILING(*(uint16_t*)0x20005cc8 = 5);
    NONFAILING(*(uint16_t*)0x20005cca = 1);
    NONFAILING(*(uint16_t*)0x20005ccc = 5);
    NONFAILING(*(uint16_t*)0x20005cce = 0);
    NONFAILING(*(uint16_t*)0x20005cd0 = 4);
    NONFAILING(*(uint16_t*)0x20005cd2 = 0);
    NONFAILING(*(uint16_t*)0x20005cd4 = 5);
    NONFAILING(*(uint16_t*)0x20005cd6 = 0);
    NONFAILING(*(uint16_t*)0x20005cd8 = 2);
    NONFAILING(*(uint16_t*)0x20005cda = 0);
    NONFAILING(*(uint16_t*)0x20005cdc = 4);
    NONFAILING(*(uint16_t*)0x20005cde = 1);
    NONFAILING(*(uint16_t*)0x20005ce0 = 2);
    NONFAILING(*(uint16_t*)0x20005ce2 = 0);
    NONFAILING(*(uint16_t*)0x20005ce4 = 0);
    NONFAILING(*(uint16_t*)0x20005ce6 = 1);
    NONFAILING(*(uint16_t*)0x20005ce8 = 1);
    NONFAILING(*(uint16_t*)0x20005cea = 0);
    NONFAILING(*(uint16_t*)0x20005cec = 4);
    NONFAILING(*(uint16_t*)0x20005cee = 0);
    NONFAILING(*(uint16_t*)0x20005cf0 = 2);
    NONFAILING(*(uint16_t*)0x20005cf2 = 1);
    NONFAILING(*(uint16_t*)0x20005cf4 = 5);
    NONFAILING(*(uint16_t*)0x20005cf6 = 1);
    NONFAILING(*(uint16_t*)0x20005cf8 = 4);
    NONFAILING(*(uint16_t*)0x20005cfa = 1);
    NONFAILING(*(uint16_t*)0x20005cfc = 5);
    NONFAILING(*(uint16_t*)0x20005cfe = 0);
    NONFAILING(*(uint16_t*)0x20005d00 = 1);
    NONFAILING(*(uint16_t*)0x20005d02 = 0);
    NONFAILING(*(uint16_t*)0x20005d04 = 5);
    NONFAILING(*(uint16_t*)0x20005d06 = 1);
    NONFAILING(*(uint16_t*)0x20005d08 = 2);
    NONFAILING(*(uint16_t*)0x20005d0a = 1);
    NONFAILING(*(uint16_t*)0x20005d0c = 1);
    NONFAILING(*(uint16_t*)0x20005d0e = 0);
    NONFAILING(*(uint16_t*)0x20005d10 = 5);
    NONFAILING(*(uint16_t*)0x20005d12 = 1);
    NONFAILING(*(uint16_t*)0x20005d14 = 5);
    NONFAILING(*(uint16_t*)0x20005d16 = 1);
    NONFAILING(*(uint16_t*)0x20005d18 = 3);
    NONFAILING(*(uint16_t*)0x20005d1a = 0);
    NONFAILING(*(uint16_t*)0x20005d1c = 1);
    NONFAILING(*(uint16_t*)0x20005d1e = 0);
    NONFAILING(*(uint16_t*)0x20005d20 = 4);
    NONFAILING(*(uint16_t*)0x20005d22 = 1);
    NONFAILING(*(uint16_t*)0x20005d24 = 3);
    NONFAILING(*(uint16_t*)0x20005d26 = 0);
    NONFAILING(*(uint16_t*)0x20005d28 = 2);
    NONFAILING(*(uint16_t*)0x20005d2a = 0);
    NONFAILING(*(uint16_t*)0x20005d2c = 4);
    NONFAILING(*(uint16_t*)0x20005d2e = 0);
    NONFAILING(*(uint16_t*)0x20005d30 = 3);
    NONFAILING(*(uint16_t*)0x20005d32 = 1);
    NONFAILING(*(uint16_t*)0x20005d34 = 6);
    NONFAILING(*(uint16_t*)0x20005d36 = 1);
    NONFAILING(*(uint16_t*)0x20005d38 = 0);
    NONFAILING(*(uint16_t*)0x20005d3a = 1);
    NONFAILING(*(uint16_t*)0x20005d3c = 1);
    NONFAILING(*(uint16_t*)0x20005d3e = 0);
    NONFAILING(*(uint16_t*)0x20005d40 = 4);
    NONFAILING(*(uint16_t*)0x20005d42 = 1);
    NONFAILING(*(uint16_t*)0x20005d44 = 2);
    NONFAILING(*(uint16_t*)0x20005d46 = 1);
    NONFAILING(*(uint16_t*)0x20005d48 = 2);
    NONFAILING(*(uint16_t*)0x20005d4a = 1);
    NONFAILING(*(uint16_t*)0x20005d4c = 5);
    NONFAILING(*(uint16_t*)0x20005d4e = 0);
    NONFAILING(*(uint16_t*)0x20005d50 = 5);
    NONFAILING(*(uint16_t*)0x20005d52 = 0);
    NONFAILING(*(uint16_t*)0x20005d54 = 5);
    NONFAILING(*(uint16_t*)0x20005d56 = 0);
    NONFAILING(*(uint16_t*)0x20005d58 = 5);
    NONFAILING(*(uint16_t*)0x20005d5a = 0);
    NONFAILING(*(uint16_t*)0x20005d5c = 0);
    NONFAILING(*(uint16_t*)0x20005d5e = 0);
    NONFAILING(*(uint16_t*)0x20005d60 = 4);
    NONFAILING(*(uint16_t*)0x20005d62 = 1);
    NONFAILING(*(uint16_t*)0x20005d64 = 1);
    NONFAILING(*(uint16_t*)0x20005d66 = 1);
    NONFAILING(*(uint16_t*)0x20005d68 = 5);
    NONFAILING(*(uint16_t*)0x20005d6a = 1);
    NONFAILING(*(uint16_t*)0x20005d6c = 0);
    NONFAILING(*(uint16_t*)0x20005d6e = 0);
    NONFAILING(*(uint16_t*)0x20005d70 = 0);
    NONFAILING(*(uint16_t*)0x20005d72 = 1);
    NONFAILING(*(uint16_t*)0x20005d74 = 3);
    NONFAILING(*(uint16_t*)0x20005d76 = 0);
    NONFAILING(*(uint16_t*)0x20005d78 = 0);
    NONFAILING(*(uint16_t*)0x20005d7a = 0);
    NONFAILING(*(uint16_t*)0x20005d7c = 2);
    NONFAILING(*(uint16_t*)0x20005d7e = 0);
    NONFAILING(*(uint16_t*)0x20005d80 = 5);
    NONFAILING(*(uint16_t*)0x20005d82 = 1);
    NONFAILING(*(uint16_t*)0x20005d84 = 4);
    NONFAILING(*(uint16_t*)0x20005d86 = 0);
    NONFAILING(*(uint16_t*)0x20005d88 = 1);
    NONFAILING(*(uint16_t*)0x20005d8a = 0);
    NONFAILING(*(uint16_t*)0x20005d8c = 0);
    NONFAILING(*(uint16_t*)0x20005d8e = 1);
    NONFAILING(*(uint16_t*)0x20005d90 = 0);
    NONFAILING(*(uint16_t*)0x20005d92 = 1);
    NONFAILING(*(uint16_t*)0x20005d94 = 1);
    NONFAILING(*(uint16_t*)0x20005d96 = 1);
    NONFAILING(*(uint16_t*)0x20005d98 = 4);
    NONFAILING(*(uint16_t*)0x20005d9a = 1);
    NONFAILING(*(uint16_t*)0x20005d9c = 0);
    NONFAILING(*(uint16_t*)0x20005d9e = 0);
    NONFAILING(*(uint16_t*)0x20005da0 = 4);
    NONFAILING(*(uint16_t*)0x20005da2 = 0);
    NONFAILING(*(uint16_t*)0x20005da4 = 2);
    NONFAILING(*(uint16_t*)0x20005da6 = 1);
    NONFAILING(*(uint16_t*)0x20005da8 = 3);
    NONFAILING(*(uint16_t*)0x20005daa = 0);
    NONFAILING(*(uint16_t*)0x20005dac = 5);
    NONFAILING(*(uint16_t*)0x20005dae = 0);
    NONFAILING(*(uint16_t*)0x20005db0 = 1);
    NONFAILING(*(uint16_t*)0x20005db2 = 0);
    NONFAILING(*(uint16_t*)0x20005db4 = 3);
    NONFAILING(*(uint16_t*)0x20005db6 = 0);
    NONFAILING(*(uint16_t*)0x20005db8 = 0);
    NONFAILING(*(uint16_t*)0x20005dba = 0);
    NONFAILING(*(uint16_t*)0x20005dbc = 3);
    NONFAILING(*(uint16_t*)0x20005dbe = 1);
    NONFAILING(*(uint16_t*)0x20005dc0 = 0);
    NONFAILING(*(uint16_t*)0x20005dc2 = 1);
    NONFAILING(*(uint16_t*)0x20005dc4 = 4);
    NONFAILING(*(uint16_t*)0x20005dc6 = 1);
    NONFAILING(*(uint16_t*)0x20005dc8 = 1);
    NONFAILING(*(uint16_t*)0x20005dca = 0);
    NONFAILING(*(uint16_t*)0x20005dcc = 3);
    NONFAILING(*(uint16_t*)0x20005dce = 0);
    NONFAILING(*(uint16_t*)0x20005dd0 = 0xbc3e);
    NONFAILING(*(uint16_t*)0x20005dd2 = 1);
    NONFAILING(*(uint16_t*)0x20005dd4 = 3);
    NONFAILING(*(uint16_t*)0x20005dd6 = 0);
    NONFAILING(*(uint16_t*)0x20005dd8 = 1);
    NONFAILING(*(uint16_t*)0x20005dda = 1);
    NONFAILING(*(uint16_t*)0x20005ddc = 2);
    NONFAILING(*(uint16_t*)0x20005dde = 0);
    NONFAILING(*(uint16_t*)0x20005de0 = 3);
    NONFAILING(*(uint16_t*)0x20005de2 = 0);
    NONFAILING(*(uint16_t*)0x20005de4 = 0);
    NONFAILING(*(uint16_t*)0x20005de6 = 1);
    NONFAILING(*(uint16_t*)0x20005de8 = 2);
    NONFAILING(*(uint16_t*)0x20005dea = 0);
    NONFAILING(*(uint16_t*)0x20005dec = 7);
    NONFAILING(*(uint16_t*)0x20005dee = 0);
    NONFAILING(*(uint16_t*)0x20005df0 = 5);
    NONFAILING(*(uint16_t*)0x20005df2 = 0);
    NONFAILING(*(uint16_t*)0x20005df4 = 2);
    NONFAILING(*(uint16_t*)0x20005df6 = 0);
    NONFAILING(*(uint16_t*)0x20005df8 = 0);
    NONFAILING(*(uint16_t*)0x20005dfa = 0);
    NONFAILING(*(uint16_t*)0x20005dfc = 3);
    NONFAILING(*(uint16_t*)0x20005dfe = 0);
    NONFAILING(*(uint16_t*)0x20005e00 = 4);
    NONFAILING(*(uint16_t*)0x20005e02 = 1);
    NONFAILING(*(uint16_t*)0x20005e04 = 5);
    NONFAILING(*(uint16_t*)0x20005e06 = 0);
    NONFAILING(*(uint16_t*)0x20005e08 = 0xcc10);
    NONFAILING(*(uint16_t*)0x20005e0a = 0);
    NONFAILING(*(uint16_t*)0x20005e0c = 4);
    NONFAILING(*(uint16_t*)0x20005e0e = 1);
    NONFAILING(*(uint16_t*)0x20005e10 = 4);
    NONFAILING(*(uint16_t*)0x20005e12 = 0);
    NONFAILING(*(uint16_t*)0x20005e14 = 3);
    NONFAILING(*(uint16_t*)0x20005e16 = 1);
    NONFAILING(*(uint16_t*)0x20005e18 = 0);
    NONFAILING(*(uint16_t*)0x20005e1a = 0);
    NONFAILING(*(uint16_t*)0x20005e1c = 1);
    NONFAILING(*(uint16_t*)0x20005e1e = 0);
    NONFAILING(*(uint16_t*)0x20005e20 = 3);
    NONFAILING(*(uint16_t*)0x20005e22 = 0);
    NONFAILING(*(uint16_t*)0x20005e24 = 2);
    NONFAILING(*(uint16_t*)0x20005e26 = 1);
    NONFAILING(*(uint16_t*)0x20005e28 = 0);
    NONFAILING(*(uint16_t*)0x20005e2a = 0);
    NONFAILING(*(uint16_t*)0x20005e2c = 5);
    NONFAILING(*(uint16_t*)0x20005e2e = 1);
    NONFAILING(*(uint16_t*)0x20005e30 = 4);
    NONFAILING(*(uint16_t*)0x20005e32 = 1);
    NONFAILING(*(uint16_t*)0x20005e34 = 7);
    NONFAILING(*(uint16_t*)0x20005e36 = 0);
    NONFAILING(*(uint16_t*)0x20005e38 = 4);
    NONFAILING(*(uint16_t*)0x20005e3a = 1);
    NONFAILING(*(uint16_t*)0x20005e3c = 1);
    NONFAILING(*(uint16_t*)0x20005e3e = 1);
    NONFAILING(*(uint16_t*)0x20005e40 = 2);
    NONFAILING(*(uint16_t*)0x20005e42 = 1);
    NONFAILING(*(uint16_t*)0x20005e44 = 5);
    NONFAILING(*(uint16_t*)0x20005e46 = 0);
    NONFAILING(*(uint16_t*)0x20005e48 = 5);
    NONFAILING(*(uint16_t*)0x20005e4a = 1);
    NONFAILING(*(uint16_t*)0x20005e4c = 5);
    NONFAILING(*(uint16_t*)0x20005e4e = 1);
    NONFAILING(*(uint16_t*)0x20005e50 = 2);
    NONFAILING(*(uint16_t*)0x20005e52 = 1);
    NONFAILING(*(uint16_t*)0x20005e54 = 5);
    NONFAILING(*(uint16_t*)0x20005e56 = 0);
    NONFAILING(*(uint16_t*)0x20005e58 = 6);
    NONFAILING(*(uint16_t*)0x20005e5a = 0);
    NONFAILING(*(uint16_t*)0x20005e5c = 3);
    NONFAILING(*(uint16_t*)0x20005e5e = 0);
    NONFAILING(*(uint16_t*)0x20005e60 = 4);
    NONFAILING(*(uint16_t*)0x20005e62 = 1);
    NONFAILING(*(uint16_t*)0x20005e64 = 1);
    NONFAILING(*(uint16_t*)0x20005e66 = 1);
    NONFAILING(*(uint16_t*)0x20005e68 = 2);
    NONFAILING(*(uint16_t*)0x20005e6a = 1);
    NONFAILING(*(uint16_t*)0x20005e6c = 0);
    NONFAILING(*(uint16_t*)0x20005e6e = 1);
    NONFAILING(*(uint16_t*)0x20005e70 = 4);
    NONFAILING(*(uint16_t*)0x20005e72 = 0);
    NONFAILING(*(uint16_t*)0x20005e74 = 0);
    NONFAILING(*(uint16_t*)0x20005e76 = 1);
    NONFAILING(*(uint16_t*)0x20005e78 = 1);
    NONFAILING(*(uint16_t*)0x20005e7a = 0);
    NONFAILING(*(uint16_t*)0x20005e7c = 2);
    NONFAILING(*(uint16_t*)0x20005e7e = 0);
    NONFAILING(*(uint16_t*)0x20005e80 = 3);
    NONFAILING(*(uint16_t*)0x20005e82 = 1);
    NONFAILING(*(uint16_t*)0x20005e84 = 2);
    NONFAILING(*(uint16_t*)0x20005e86 = 1);
    NONFAILING(*(uint16_t*)0x20005e88 = 5);
    NONFAILING(*(uint16_t*)0x20005e8a = 1);
    NONFAILING(*(uint16_t*)0x20005e8c = 4);
    NONFAILING(*(uint16_t*)0x20005e8e = 1);
    NONFAILING(*(uint16_t*)0x20005e90 = 5);
    NONFAILING(*(uint16_t*)0x20005e92 = 0);
    NONFAILING(*(uint16_t*)0x20005e94 = 0);
    NONFAILING(*(uint16_t*)0x20005e96 = 1);
    NONFAILING(*(uint16_t*)0x20005e98 = 5);
    NONFAILING(*(uint16_t*)0x20005e9a = 1);
    NONFAILING(*(uint16_t*)0x20005e9c = 0);
    NONFAILING(*(uint16_t*)0x20005e9e = 0);
    NONFAILING(*(uint16_t*)0x20005ea0 = 0);
    NONFAILING(*(uint16_t*)0x20005ea2 = 0);
    NONFAILING(*(uint16_t*)0x20005ea4 = 1);
    NONFAILING(*(uint16_t*)0x20005ea6 = 1);
    NONFAILING(*(uint16_t*)0x20005ea8 = 1);
    NONFAILING(*(uint16_t*)0x20005eaa = 1);
    NONFAILING(*(uint16_t*)0x20005eac = 4);
    NONFAILING(*(uint16_t*)0x20005eae = 0);
    NONFAILING(*(uint16_t*)0x20005eb0 = 5);
    NONFAILING(*(uint16_t*)0x20005eb2 = 0);
    NONFAILING(*(uint8_t*)0x20005eb4 = 1);
    NONFAILING(*(uint16_t*)0x20005eb8 = 0xe98);
    NONFAILING(*(uint16_t*)0x20005eba = 4);
    NONFAILING(*(uint32_t*)0x20005ebc = 3);
    NONFAILING(*(uint32_t*)0x20005ec0 = 2);
    NONFAILING(*(uint32_t*)0x20005ec4 = 2);
    NONFAILING(*(uint32_t*)0x20005ec8 = 0x80000001);
    NONFAILING(*(uint32_t*)0x20005ecc = 9);
    NONFAILING(*(uint8_t*)0x20005ed0 = 6);
    NONFAILING(*(uint8_t*)0x20005ed1 = 0x40);
    NONFAILING(*(uint32_t*)0x20005ed4 = 1);
    NONFAILING(*(uint32_t*)0x20005ed8 = 4);
    NONFAILING(*(uint32_t*)0x20005edc = 0);
    NONFAILING(*(uint32_t*)0x20005ee0 = 0x3f);
    NONFAILING(*(uint32_t*)0x20005ee4 = 4);
    NONFAILING(*(uint32_t*)0x20005ee8 = 0x40);
    NONFAILING(*(uint32_t*)0x20005eec = 6);
    NONFAILING(*(uint32_t*)0x20005ef0 = 1);
    NONFAILING(*(uint32_t*)0x20005ef4 = 0xfffffffe);
    NONFAILING(*(uint32_t*)0x20005ef8 = -1);
    NONFAILING(*(uint32_t*)0x20005efc = 9);
    NONFAILING(*(uint32_t*)0x20005f00 = 7);
    NONFAILING(*(uint32_t*)0x20005f04 = 9);
    NONFAILING(*(uint32_t*)0x20005f08 = 0x80);
    NONFAILING(*(uint32_t*)0x20005f0c = 0x7fffffff);
    NONFAILING(*(uint32_t*)0x20005f10 = 8);
    NONFAILING(*(uint32_t*)0x20005f14 = 0);
    NONFAILING(*(uint32_t*)0x20005f18 = 7);
    NONFAILING(*(uint32_t*)0x20005f1c = 3);
    NONFAILING(*(uint32_t*)0x20005f20 = 0xffff8000);
    NONFAILING(*(uint32_t*)0x20005f24 = 3);
    NONFAILING(*(uint32_t*)0x20005f28 = 8);
    NONFAILING(*(uint32_t*)0x20005f2c = 2);
    NONFAILING(*(uint32_t*)0x20005f30 = 0x8000);
    NONFAILING(*(uint32_t*)0x20005f34 = 0x10001);
    NONFAILING(*(uint32_t*)0x20005f38 = 0x7fffffff);
    NONFAILING(*(uint32_t*)0x20005f3c = 0xcf41);
    NONFAILING(*(uint32_t*)0x20005f40 = 5);
    NONFAILING(*(uint32_t*)0x20005f44 = 3);
    NONFAILING(*(uint32_t*)0x20005f48 = 3);
    NONFAILING(*(uint32_t*)0x20005f4c = 6);
    NONFAILING(*(uint32_t*)0x20005f50 = 9);
    NONFAILING(*(uint32_t*)0x20005f54 = 0x3ff);
    NONFAILING(*(uint32_t*)0x20005f58 = 9);
    NONFAILING(*(uint32_t*)0x20005f5c = 0x9f76);
    NONFAILING(*(uint32_t*)0x20005f60 = 0x10000);
    NONFAILING(*(uint32_t*)0x20005f64 = 0x8000);
    NONFAILING(*(uint32_t*)0x20005f68 = 3);
    NONFAILING(*(uint32_t*)0x20005f6c = 0);
    NONFAILING(*(uint32_t*)0x20005f70 = 3);
    NONFAILING(*(uint32_t*)0x20005f74 = 3);
    NONFAILING(*(uint32_t*)0x20005f78 = 0x890b);
    NONFAILING(*(uint32_t*)0x20005f7c = 0x7fffffff);
    NONFAILING(*(uint32_t*)0x20005f80 = 3);
    NONFAILING(*(uint32_t*)0x20005f84 = 5);
    NONFAILING(*(uint32_t*)0x20005f88 = 4);
    NONFAILING(*(uint32_t*)0x20005f8c = 4);
    NONFAILING(*(uint32_t*)0x20005f90 = 4);
    NONFAILING(*(uint32_t*)0x20005f94 = 0x20);
    NONFAILING(*(uint32_t*)0x20005f98 = 6);
    NONFAILING(*(uint32_t*)0x20005f9c = 4);
    NONFAILING(*(uint32_t*)0x20005fa0 = 6);
    NONFAILING(*(uint32_t*)0x20005fa4 = 1);
    NONFAILING(*(uint32_t*)0x20005fa8 = 3);
    NONFAILING(*(uint32_t*)0x20005fac = 1);
    NONFAILING(*(uint32_t*)0x20005fb0 = 5);
    NONFAILING(*(uint32_t*)0x20005fb4 = 2);
    NONFAILING(*(uint32_t*)0x20005fb8 = 1);
    NONFAILING(*(uint32_t*)0x20005fbc = 6);
    NONFAILING(*(uint32_t*)0x20005fc0 = 0x8000);
    NONFAILING(*(uint32_t*)0x20005fc4 = 0x20);
    NONFAILING(*(uint32_t*)0x20005fc8 = 5);
    NONFAILING(*(uint32_t*)0x20005fcc = 2);
    NONFAILING(*(uint32_t*)0x20005fd0 = 6);
    NONFAILING(*(uint32_t*)0x20005fd4 = 0x20);
    NONFAILING(*(uint32_t*)0x20005fd8 = 0x400);
    NONFAILING(*(uint32_t*)0x20005fdc = 0x80000000);
    NONFAILING(*(uint32_t*)0x20005fe0 = 0);
    NONFAILING(*(uint32_t*)0x20005fe4 = 0xffff7156);
    NONFAILING(*(uint32_t*)0x20005fe8 = 9);
    NONFAILING(*(uint32_t*)0x20005fec = 0xfffffffd);
    NONFAILING(*(uint32_t*)0x20005ff0 = 0xffff);
    NONFAILING(*(uint32_t*)0x20005ff4 = 7);
    NONFAILING(*(uint32_t*)0x20005ff8 = 5);
    NONFAILING(*(uint32_t*)0x20005ffc = 0xb1);
    NONFAILING(*(uint32_t*)0x20006000 = 7);
    NONFAILING(*(uint32_t*)0x20006004 = 0x7ff);
    NONFAILING(*(uint32_t*)0x20006008 = 0xa2);
    NONFAILING(*(uint32_t*)0x2000600c = 8);
    NONFAILING(*(uint32_t*)0x20006010 = 0x400);
    NONFAILING(*(uint32_t*)0x20006014 = 6);
    NONFAILING(*(uint32_t*)0x20006018 = 2);
    NONFAILING(*(uint32_t*)0x2000601c = 1);
    NONFAILING(*(uint32_t*)0x20006020 = 6);
    NONFAILING(*(uint32_t*)0x20006024 = 1);
    NONFAILING(*(uint32_t*)0x20006028 = 2);
    NONFAILING(*(uint32_t*)0x2000602c = 0xfffffffe);
    NONFAILING(*(uint32_t*)0x20006030 = 1);
    NONFAILING(*(uint32_t*)0x20006034 = 0x8001);
    NONFAILING(*(uint32_t*)0x20006038 = 0x4e);
    NONFAILING(*(uint32_t*)0x2000603c = 9);
    NONFAILING(*(uint32_t*)0x20006040 = 0x6548f108);
    NONFAILING(*(uint32_t*)0x20006044 = 6);
    NONFAILING(*(uint32_t*)0x20006048 = 0x7fffffff);
    NONFAILING(*(uint32_t*)0x2000604c = 0x400);
    NONFAILING(*(uint32_t*)0x20006050 = 0xffffffec);
    NONFAILING(*(uint32_t*)0x20006054 = 0x4000000);
    NONFAILING(*(uint32_t*)0x20006058 = 0x80);
    NONFAILING(*(uint32_t*)0x2000605c = 0x3f);
    NONFAILING(*(uint32_t*)0x20006060 = 7);
    NONFAILING(*(uint32_t*)0x20006064 = 6);
    NONFAILING(*(uint32_t*)0x20006068 = -1);
    NONFAILING(*(uint32_t*)0x2000606c = 3);
    NONFAILING(*(uint32_t*)0x20006070 = 0x100);
    NONFAILING(*(uint32_t*)0x20006074 = 0x20);
    NONFAILING(*(uint32_t*)0x20006078 = 0);
    NONFAILING(*(uint32_t*)0x2000607c = -1);
    NONFAILING(*(uint32_t*)0x20006080 = 0x6c5b598e);
    NONFAILING(*(uint32_t*)0x20006084 = 0xf3);
    NONFAILING(*(uint32_t*)0x20006088 = 9);
    NONFAILING(*(uint32_t*)0x2000608c = 0x80000000);
    NONFAILING(*(uint32_t*)0x20006090 = 0);
    NONFAILING(*(uint32_t*)0x20006094 = 0x1747);
    NONFAILING(*(uint32_t*)0x20006098 = 0x7fffffff);
    NONFAILING(*(uint32_t*)0x2000609c = 0xfffffffc);
    NONFAILING(*(uint32_t*)0x200060a0 = 0x3f);
    NONFAILING(*(uint32_t*)0x200060a4 = 0x73f);
    NONFAILING(*(uint32_t*)0x200060a8 = 0x1f);
    NONFAILING(*(uint32_t*)0x200060ac = 0xfffffff8);
    NONFAILING(*(uint32_t*)0x200060b0 = 0);
    NONFAILING(*(uint32_t*)0x200060b4 = 8);
    NONFAILING(*(uint32_t*)0x200060b8 = 0xcae);
    NONFAILING(*(uint32_t*)0x200060bc = 0x351);
    NONFAILING(*(uint32_t*)0x200060c0 = 0xba);
    NONFAILING(*(uint32_t*)0x200060c4 = 0x10001);
    NONFAILING(*(uint32_t*)0x200060c8 = 3);
    NONFAILING(*(uint32_t*)0x200060cc = 0x93);
    NONFAILING(*(uint32_t*)0x200060d0 = 0xffff8001);
    NONFAILING(*(uint32_t*)0x200060d4 = 2);
    NONFAILING(*(uint32_t*)0x200060d8 = 7);
    NONFAILING(*(uint32_t*)0x200060dc = 0x7fffffff);
    NONFAILING(*(uint32_t*)0x200060e0 = 9);
    NONFAILING(*(uint32_t*)0x200060e4 = 4);
    NONFAILING(*(uint32_t*)0x200060e8 = 0x10a);
    NONFAILING(*(uint32_t*)0x200060ec = 6);
    NONFAILING(*(uint32_t*)0x200060f0 = 4);
    NONFAILING(*(uint32_t*)0x200060f4 = 6);
    NONFAILING(*(uint32_t*)0x200060f8 = 0x3119);
    NONFAILING(*(uint32_t*)0x200060fc = 4);
    NONFAILING(*(uint32_t*)0x20006100 = 0x137);
    NONFAILING(*(uint32_t*)0x20006104 = 0x2b1fb19c);
    NONFAILING(*(uint32_t*)0x20006108 = 9);
    NONFAILING(*(uint32_t*)0x2000610c = 0x8000);
    NONFAILING(*(uint32_t*)0x20006110 = 0xfffeffff);
    NONFAILING(*(uint32_t*)0x20006114 = 8);
    NONFAILING(*(uint32_t*)0x20006118 = 7);
    NONFAILING(*(uint32_t*)0x2000611c = 0x8001);
    NONFAILING(*(uint32_t*)0x20006120 = 0x12);
    NONFAILING(*(uint32_t*)0x20006124 = 3);
    NONFAILING(*(uint32_t*)0x20006128 = 0);
    NONFAILING(*(uint32_t*)0x2000612c = -1);
    NONFAILING(*(uint32_t*)0x20006130 = -1);
    NONFAILING(*(uint32_t*)0x20006134 = 0x80);
    NONFAILING(*(uint32_t*)0x20006138 = 8);
    NONFAILING(*(uint32_t*)0x2000613c = 6);
    NONFAILING(*(uint32_t*)0x20006140 = 5);
    NONFAILING(*(uint32_t*)0x20006144 = 0x10001);
    NONFAILING(*(uint32_t*)0x20006148 = 0);
    NONFAILING(*(uint32_t*)0x2000614c = 4);
    NONFAILING(*(uint32_t*)0x20006150 = 3);
    NONFAILING(*(uint32_t*)0x20006154 = 0);
    NONFAILING(*(uint32_t*)0x20006158 = 0xfffffff7);
    NONFAILING(*(uint32_t*)0x2000615c = -1);
    NONFAILING(*(uint32_t*)0x20006160 = 8);
    NONFAILING(*(uint32_t*)0x20006164 = 3);
    NONFAILING(*(uint32_t*)0x20006168 = 0);
    NONFAILING(*(uint32_t*)0x2000616c = 0x23866083);
    NONFAILING(*(uint32_t*)0x20006170 = 9);
    NONFAILING(*(uint32_t*)0x20006174 = 0x100);
    NONFAILING(*(uint32_t*)0x20006178 = 9);
    NONFAILING(*(uint32_t*)0x2000617c = 3);
    NONFAILING(*(uint32_t*)0x20006180 = 1);
    NONFAILING(*(uint32_t*)0x20006184 = 9);
    NONFAILING(*(uint32_t*)0x20006188 = 7);
    NONFAILING(*(uint32_t*)0x2000618c = 5);
    NONFAILING(*(uint32_t*)0x20006190 = 5);
    NONFAILING(*(uint32_t*)0x20006194 = -1);
    NONFAILING(*(uint32_t*)0x20006198 = 0xfffffffb);
    NONFAILING(*(uint32_t*)0x2000619c = 0xfffffffd);
    NONFAILING(*(uint32_t*)0x200061a0 = 0x800);
    NONFAILING(*(uint32_t*)0x200061a4 = 0x1f);
    NONFAILING(*(uint32_t*)0x200061a8 = 0x800);
    NONFAILING(*(uint32_t*)0x200061ac = 0xf8);
    NONFAILING(*(uint32_t*)0x200061b0 = 0x80000001);
    NONFAILING(*(uint32_t*)0x200061b4 = 6);
    NONFAILING(*(uint32_t*)0x200061b8 = 7);
    NONFAILING(*(uint32_t*)0x200061bc = 0x25b);
    NONFAILING(*(uint32_t*)0x200061c0 = 0x100);
    NONFAILING(*(uint32_t*)0x200061c4 = 0x765);
    NONFAILING(*(uint32_t*)0x200061c8 = 0);
    NONFAILING(*(uint32_t*)0x200061cc = 5);
    NONFAILING(*(uint32_t*)0x200061d0 = 0xfffffffa);
    NONFAILING(*(uint32_t*)0x200061d4 = 0x1ff);
    NONFAILING(*(uint32_t*)0x200061d8 = 5);
    NONFAILING(*(uint32_t*)0x200061dc = 2);
    NONFAILING(*(uint32_t*)0x200061e0 = 6);
    NONFAILING(*(uint32_t*)0x200061e4 = 5);
    NONFAILING(*(uint32_t*)0x200061e8 = 0x33ef627c);
    NONFAILING(*(uint32_t*)0x200061ec = 3);
    NONFAILING(*(uint32_t*)0x200061f0 = 2);
    NONFAILING(*(uint32_t*)0x200061f4 = 0x401);
    NONFAILING(*(uint32_t*)0x200061f8 = 4);
    NONFAILING(*(uint32_t*)0x200061fc = 1);
    NONFAILING(*(uint32_t*)0x20006200 = 3);
    NONFAILING(*(uint32_t*)0x20006204 = 0x1000);
    NONFAILING(*(uint32_t*)0x20006208 = 0);
    NONFAILING(*(uint32_t*)0x2000620c = 5);
    NONFAILING(*(uint32_t*)0x20006210 = 2);
    NONFAILING(*(uint32_t*)0x20006214 = 4);
    NONFAILING(*(uint32_t*)0x20006218 = 1);
    NONFAILING(*(uint32_t*)0x2000621c = 2);
    NONFAILING(*(uint32_t*)0x20006220 = 7);
    NONFAILING(*(uint32_t*)0x20006224 = 0x1ff);
    NONFAILING(*(uint32_t*)0x20006228 = 7);
    NONFAILING(*(uint32_t*)0x2000622c = 5);
    NONFAILING(*(uint32_t*)0x20006230 = 0x7fff);
    NONFAILING(*(uint32_t*)0x20006234 = 0xab);
    NONFAILING(*(uint32_t*)0x20006238 = 4);
    NONFAILING(*(uint32_t*)0x2000623c = 0x101);
    NONFAILING(*(uint32_t*)0x20006240 = 5);
    NONFAILING(*(uint32_t*)0x20006244 = 0);
    NONFAILING(*(uint32_t*)0x20006248 = 0x5d9);
    NONFAILING(*(uint32_t*)0x2000624c = 0x101);
    NONFAILING(*(uint32_t*)0x20006250 = 0xff);
    NONFAILING(*(uint32_t*)0x20006254 = 6);
    NONFAILING(*(uint32_t*)0x20006258 = 0x100);
    NONFAILING(*(uint32_t*)0x2000625c = 5);
    NONFAILING(*(uint32_t*)0x20006260 = 0);
    NONFAILING(*(uint32_t*)0x20006264 = 1);
    NONFAILING(*(uint32_t*)0x20006268 = 0x101);
    NONFAILING(*(uint32_t*)0x2000626c = 8);
    NONFAILING(*(uint32_t*)0x20006270 = 1);
    NONFAILING(*(uint32_t*)0x20006274 = 2);
    NONFAILING(*(uint32_t*)0x20006278 = 0x8bc);
    NONFAILING(*(uint32_t*)0x2000627c = 9);
    NONFAILING(*(uint32_t*)0x20006280 = 1);
    NONFAILING(*(uint32_t*)0x20006284 = 4);
    NONFAILING(*(uint32_t*)0x20006288 = 8);
    NONFAILING(*(uint32_t*)0x2000628c = 2);
    NONFAILING(*(uint32_t*)0x20006290 = 8);
    NONFAILING(*(uint32_t*)0x20006294 = 5);
    NONFAILING(*(uint32_t*)0x20006298 = 9);
    NONFAILING(*(uint32_t*)0x2000629c = 0x1f);
    NONFAILING(*(uint32_t*)0x200062a0 = 0);
    NONFAILING(*(uint32_t*)0x200062a4 = 0);
    NONFAILING(*(uint32_t*)0x200062a8 = 0);
    NONFAILING(*(uint32_t*)0x200062ac = 1);
    NONFAILING(*(uint32_t*)0x200062b0 = 1);
    NONFAILING(*(uint32_t*)0x200062b4 = 0x3f);
    NONFAILING(*(uint32_t*)0x200062b8 = 0x1ff);
    NONFAILING(*(uint32_t*)0x200062bc = 0x101);
    NONFAILING(*(uint32_t*)0x200062c0 = 0x44);
    NONFAILING(*(uint32_t*)0x200062c4 = 0xffff);
    NONFAILING(*(uint32_t*)0x200062c8 = 0x1f);
    NONFAILING(*(uint32_t*)0x200062cc = 0xffff47df);
    NONFAILING(*(uint32_t*)0x200062d0 = 9);
    NONFAILING(*(uint32_t*)0x200062d4 = 0xfffffff8);
    NONFAILING(*(uint32_t*)0x200062d8 = 0xe4da);
    NONFAILING(*(uint32_t*)0x200062dc = 9);
    NONFAILING(*(uint32_t*)0x200062e0 = 4);
    NONFAILING(*(uint32_t*)0x200062e4 = 3);
    NONFAILING(*(uint32_t*)0x200062e8 = 0x81);
    NONFAILING(*(uint32_t*)0x200062ec = 0xb3);
    NONFAILING(*(uint32_t*)0x200062f0 = 0x8f);
    NONFAILING(*(uint32_t*)0x200062f4 = 0);
    NONFAILING(*(uint32_t*)0x200062f8 = 0x7ff);
    NONFAILING(*(uint32_t*)0x200062fc = 0x400);
    NONFAILING(*(uint32_t*)0x20006300 = 2);
    NONFAILING(*(uint32_t*)0x20006304 = 8);
    NONFAILING(*(uint32_t*)0x20006308 = 0x46);
    NONFAILING(*(uint32_t*)0x2000630c = 0xbb1);
    NONFAILING(*(uint32_t*)0x20006310 = 7);
    NONFAILING(*(uint32_t*)0x20006314 = 0xff);
    NONFAILING(*(uint32_t*)0x20006318 = 9);
    NONFAILING(*(uint32_t*)0x2000631c = 0x10000);
    NONFAILING(*(uint32_t*)0x20006320 = 2);
    NONFAILING(*(uint32_t*)0x20006324 = 1);
    NONFAILING(*(uint32_t*)0x20006328 = 4);
    NONFAILING(*(uint32_t*)0x2000632c = 0xffffffd8);
    NONFAILING(*(uint32_t*)0x20006330 = 6);
    NONFAILING(*(uint32_t*)0x20006334 = 1);
    NONFAILING(*(uint32_t*)0x20006338 = 0x10);
    NONFAILING(*(uint32_t*)0x2000633c = 3);
    NONFAILING(*(uint32_t*)0x20006340 = 9);
    NONFAILING(*(uint32_t*)0x20006344 = 0x101);
    NONFAILING(*(uint32_t*)0x20006348 = 0x101);
    NONFAILING(*(uint32_t*)0x2000634c = 6);
    NONFAILING(*(uint32_t*)0x20006350 = 0xfe99);
    NONFAILING(*(uint32_t*)0x20006354 = 0x40);
    NONFAILING(*(uint32_t*)0x20006358 = 3);
    NONFAILING(*(uint32_t*)0x2000635c = 6);
    NONFAILING(*(uint32_t*)0x20006360 = 0x10000);
    NONFAILING(*(uint32_t*)0x20006364 = 0x40);
    NONFAILING(*(uint32_t*)0x20006368 = 5);
    NONFAILING(*(uint32_t*)0x2000636c = -1);
    NONFAILING(*(uint32_t*)0x20006370 = 0x10000000);
    NONFAILING(*(uint32_t*)0x20006374 = 0x7d2);
    NONFAILING(*(uint32_t*)0x20006378 = 3);
    NONFAILING(*(uint32_t*)0x2000637c = 0x7fffffff);
    NONFAILING(*(uint32_t*)0x20006380 = 0x21);
    NONFAILING(*(uint32_t*)0x20006384 = 0x6f9b);
    NONFAILING(*(uint32_t*)0x20006388 = 0xf188);
    NONFAILING(*(uint32_t*)0x2000638c = 0x1af);
    NONFAILING(*(uint32_t*)0x20006390 = 3);
    NONFAILING(*(uint32_t*)0x20006394 = 4);
    NONFAILING(*(uint32_t*)0x20006398 = 8);
    NONFAILING(*(uint32_t*)0x2000639c = 9);
    NONFAILING(*(uint32_t*)0x200063a0 = 5);
    NONFAILING(*(uint32_t*)0x200063a4 = 9);
    NONFAILING(*(uint32_t*)0x200063a8 = 8);
    NONFAILING(*(uint32_t*)0x200063ac = 3);
    NONFAILING(*(uint32_t*)0x200063b0 = 3);
    NONFAILING(*(uint32_t*)0x200063b4 = 0x7c3e);
    NONFAILING(*(uint32_t*)0x200063b8 = 8);
    NONFAILING(*(uint32_t*)0x200063bc = 0x10000);
    NONFAILING(*(uint32_t*)0x200063c0 = 0x380);
    NONFAILING(*(uint32_t*)0x200063c4 = 0);
    NONFAILING(*(uint32_t*)0x200063c8 = 0x75);
    NONFAILING(*(uint32_t*)0x200063cc = 1);
    NONFAILING(*(uint32_t*)0x200063d0 = 0);
    NONFAILING(*(uint32_t*)0x200063d4 = 7);
    NONFAILING(*(uint32_t*)0x200063d8 = 3);
    NONFAILING(*(uint32_t*)0x200063dc = 0x20);
    NONFAILING(*(uint32_t*)0x200063e0 = 5);
    NONFAILING(*(uint32_t*)0x200063e4 = 0x101);
    NONFAILING(*(uint32_t*)0x200063e8 = 0x304);
    NONFAILING(*(uint32_t*)0x200063ec = 0xfff);
    NONFAILING(*(uint32_t*)0x200063f0 = 3);
    NONFAILING(*(uint32_t*)0x200063f4 = 0);
    NONFAILING(*(uint32_t*)0x200063f8 = 0x1ff);
    NONFAILING(*(uint32_t*)0x200063fc = 0xc3e8);
    NONFAILING(*(uint32_t*)0x20006400 = 0x796);
    NONFAILING(*(uint32_t*)0x20006404 = 3);
    NONFAILING(*(uint32_t*)0x20006408 = -1);
    NONFAILING(*(uint32_t*)0x2000640c = 0xf0000000);
    NONFAILING(*(uint32_t*)0x20006410 = 0x40);
    NONFAILING(*(uint32_t*)0x20006414 = 8);
    NONFAILING(*(uint32_t*)0x20006418 = 6);
    NONFAILING(*(uint32_t*)0x2000641c = 1);
    NONFAILING(*(uint32_t*)0x20006420 = 0xfffffffe);
    NONFAILING(*(uint32_t*)0x20006424 = 0xafa);
    NONFAILING(*(uint32_t*)0x20006428 = 4);
    NONFAILING(*(uint32_t*)0x2000642c = 0);
    NONFAILING(*(uint32_t*)0x20006430 = 9);
    NONFAILING(*(uint32_t*)0x20006434 = 0);
    NONFAILING(*(uint32_t*)0x20006438 = 0x400);
    NONFAILING(*(uint32_t*)0x2000643c = 0x400);
    NONFAILING(*(uint32_t*)0x20006440 = 0x57a8);
    NONFAILING(*(uint32_t*)0x20006444 = 1);
    NONFAILING(*(uint32_t*)0x20006448 = 0xffff);
    NONFAILING(*(uint32_t*)0x2000644c = 0xffff0001);
    NONFAILING(*(uint32_t*)0x20006450 = 0x1000);
    NONFAILING(*(uint32_t*)0x20006454 = 0x401);
    NONFAILING(*(uint32_t*)0x20006458 = 6);
    NONFAILING(*(uint32_t*)0x2000645c = 5);
    NONFAILING(*(uint32_t*)0x20006460 = 0x31);
    NONFAILING(*(uint32_t*)0x20006464 = 0x800);
    NONFAILING(*(uint32_t*)0x20006468 = 7);
    NONFAILING(*(uint32_t*)0x2000646c = 0);
    NONFAILING(*(uint32_t*)0x20006470 = 8);
    NONFAILING(*(uint32_t*)0x20006474 = 1);
    NONFAILING(*(uint32_t*)0x20006478 = 0x1da3);
    NONFAILING(*(uint32_t*)0x2000647c = 0x131);
    NONFAILING(*(uint32_t*)0x20006480 = 8);
    NONFAILING(*(uint32_t*)0x20006484 = 0x800);
    NONFAILING(*(uint32_t*)0x20006488 = 0xff);
    NONFAILING(*(uint32_t*)0x2000648c = 0x800);
    NONFAILING(*(uint32_t*)0x20006490 = 0xfffffff7);
    NONFAILING(*(uint32_t*)0x20006494 = 0x658d);
    NONFAILING(*(uint32_t*)0x20006498 = 4);
    NONFAILING(*(uint32_t*)0x2000649c = 0);
    NONFAILING(*(uint32_t*)0x200064a0 = 0x400);
    NONFAILING(*(uint32_t*)0x200064a4 = 6);
    NONFAILING(*(uint32_t*)0x200064a8 = 5);
    NONFAILING(*(uint32_t*)0x200064ac = 9);
    NONFAILING(*(uint32_t*)0x200064b0 = 0x100);
    NONFAILING(*(uint32_t*)0x200064b4 = 8);
    NONFAILING(*(uint32_t*)0x200064b8 = 2);
    NONFAILING(*(uint32_t*)0x200064bc = 0xffffffe0);
    NONFAILING(*(uint32_t*)0x200064c0 = 0x1000);
    NONFAILING(*(uint32_t*)0x200064c4 = 0x40);
    NONFAILING(*(uint32_t*)0x200064c8 = 0x92e);
    NONFAILING(*(uint32_t*)0x200064cc = 9);
    NONFAILING(*(uint32_t*)0x200064d0 = 7);
    NONFAILING(*(uint32_t*)0x200064d4 = 0xfffffffd);
    NONFAILING(*(uint32_t*)0x200064d8 = 0x2619);
    NONFAILING(*(uint32_t*)0x200064dc = 0xffffff0f);
    NONFAILING(*(uint32_t*)0x200064e0 = 0x300);
    NONFAILING(*(uint32_t*)0x200064e4 = 0x3ff);
    NONFAILING(*(uint32_t*)0x200064e8 = 2);
    NONFAILING(*(uint32_t*)0x200064ec = -1);
    NONFAILING(*(uint32_t*)0x200064f0 = 0x4cd5);
    NONFAILING(*(uint32_t*)0x200064f4 = 0xf796);
    NONFAILING(*(uint32_t*)0x200064f8 = 0x40);
    NONFAILING(*(uint32_t*)0x200064fc = 0xfa);
    NONFAILING(*(uint32_t*)0x20006500 = 0xd3e);
    NONFAILING(*(uint32_t*)0x20006504 = 2);
    NONFAILING(*(uint32_t*)0x20006508 = 9);
    NONFAILING(*(uint32_t*)0x2000650c = -1);
    NONFAILING(*(uint32_t*)0x20006510 = 4);
    NONFAILING(*(uint32_t*)0x20006514 = 4);
    NONFAILING(*(uint32_t*)0x20006518 = 9);
    NONFAILING(*(uint32_t*)0x2000651c = 0xeefc);
    NONFAILING(*(uint32_t*)0x20006520 = 3);
    NONFAILING(*(uint32_t*)0x20006524 = 0x1ff);
    NONFAILING(*(uint32_t*)0x20006528 = 0xfffffffb);
    NONFAILING(*(uint32_t*)0x2000652c = 4);
    NONFAILING(*(uint32_t*)0x20006530 = 0x10000);
    NONFAILING(*(uint32_t*)0x20006534 = 7);
    NONFAILING(*(uint32_t*)0x20006538 = 7);
    NONFAILING(*(uint32_t*)0x2000653c = 5);
    NONFAILING(*(uint32_t*)0x20006540 = 0x8001);
    NONFAILING(*(uint32_t*)0x20006544 = 3);
    NONFAILING(*(uint32_t*)0x20006548 = 6);
    NONFAILING(*(uint32_t*)0x2000654c = 0xf1);
    NONFAILING(*(uint32_t*)0x20006550 = 3);
    NONFAILING(*(uint32_t*)0x20006554 = 0x80);
    NONFAILING(*(uint32_t*)0x20006558 = 2);
    NONFAILING(*(uint32_t*)0x2000655c = 0xcb);
    NONFAILING(*(uint32_t*)0x20006560 = 6);
    NONFAILING(*(uint32_t*)0x20006564 = 8);
    NONFAILING(*(uint32_t*)0x20006568 = 1);
    NONFAILING(*(uint32_t*)0x2000656c = 0x7ff);
    NONFAILING(*(uint32_t*)0x20006570 = 2);
    NONFAILING(*(uint32_t*)0x20006574 = 1);
    NONFAILING(*(uint32_t*)0x20006578 = 0x46b4);
    NONFAILING(*(uint32_t*)0x2000657c = 2);
    NONFAILING(*(uint32_t*)0x20006580 = 6);
    NONFAILING(*(uint32_t*)0x20006584 = 0x73d);
    NONFAILING(*(uint32_t*)0x20006588 = 0x80000001);
    NONFAILING(*(uint32_t*)0x2000658c = 2);
    NONFAILING(*(uint32_t*)0x20006590 = 0);
    NONFAILING(*(uint32_t*)0x20006594 = 9);
    NONFAILING(*(uint32_t*)0x20006598 = 4);
    NONFAILING(*(uint32_t*)0x2000659c = 0x7fff);
    NONFAILING(*(uint32_t*)0x200065a0 = 0);
    NONFAILING(*(uint32_t*)0x200065a4 = 2);
    NONFAILING(*(uint32_t*)0x200065a8 = 0x401);
    NONFAILING(*(uint32_t*)0x200065ac = 0x3f);
    NONFAILING(*(uint32_t*)0x200065b0 = 0x7f);
    NONFAILING(*(uint32_t*)0x200065b4 = 6);
    NONFAILING(*(uint32_t*)0x200065b8 = -1);
    NONFAILING(*(uint32_t*)0x200065bc = 5);
    NONFAILING(*(uint32_t*)0x200065c0 = 8);
    NONFAILING(*(uint32_t*)0x200065c4 = 0xffff6778);
    NONFAILING(*(uint32_t*)0x200065c8 = 0xffffff00);
    NONFAILING(*(uint32_t*)0x200065cc = 0);
    NONFAILING(*(uint32_t*)0x200065d0 = 2);
    NONFAILING(*(uint32_t*)0x200065d4 = 8);
    NONFAILING(*(uint32_t*)0x200065d8 = 1);
    NONFAILING(*(uint32_t*)0x200065dc = 0x5b04);
    NONFAILING(*(uint32_t*)0x200065e0 = 6);
    NONFAILING(*(uint32_t*)0x200065e4 = 9);
    NONFAILING(*(uint32_t*)0x200065e8 = 0x10001);
    NONFAILING(*(uint32_t*)0x200065ec = 0x34c);
    NONFAILING(*(uint32_t*)0x200065f0 = 3);
    NONFAILING(*(uint32_t*)0x200065f4 = 0x1f);
    NONFAILING(*(uint32_t*)0x200065f8 = 0xfff);
    NONFAILING(*(uint32_t*)0x200065fc = 0x81);
    NONFAILING(*(uint32_t*)0x20006600 = 5);
    NONFAILING(*(uint32_t*)0x20006604 = -1);
    NONFAILING(*(uint32_t*)0x20006608 = 0x80000001);
    NONFAILING(*(uint32_t*)0x2000660c = 0x29);
    NONFAILING(*(uint32_t*)0x20006610 = 0x1ff);
    NONFAILING(*(uint32_t*)0x20006614 = 5);
    NONFAILING(*(uint32_t*)0x20006618 = 9);
    NONFAILING(*(uint32_t*)0x2000661c = 7);
    NONFAILING(*(uint32_t*)0x20006620 = 9);
    NONFAILING(*(uint32_t*)0x20006624 = 1);
    NONFAILING(*(uint32_t*)0x20006628 = 8);
    NONFAILING(*(uint32_t*)0x2000662c = 0x718);
    NONFAILING(*(uint32_t*)0x20006630 = 0xe8f);
    NONFAILING(*(uint32_t*)0x20006634 = 9);
    NONFAILING(*(uint32_t*)0x20006638 = 7);
    NONFAILING(*(uint32_t*)0x2000663c = 2);
    NONFAILING(*(uint32_t*)0x20006640 = 1);
    NONFAILING(*(uint32_t*)0x20006644 = 3);
    NONFAILING(*(uint32_t*)0x20006648 = 0x8000);
    NONFAILING(*(uint32_t*)0x2000664c = 7);
    NONFAILING(*(uint32_t*)0x20006650 = 2);
    NONFAILING(*(uint32_t*)0x20006654 = 2);
    NONFAILING(*(uint32_t*)0x20006658 = 0x1000);
    NONFAILING(*(uint32_t*)0x2000665c = 5);
    NONFAILING(*(uint32_t*)0x20006660 = 9);
    NONFAILING(*(uint32_t*)0x20006664 = 0);
    NONFAILING(*(uint32_t*)0x20006668 = 1);
    NONFAILING(*(uint32_t*)0x2000666c = 0);
    NONFAILING(*(uint32_t*)0x20006670 = 0x6c8f);
    NONFAILING(*(uint32_t*)0x20006674 = 6);
    NONFAILING(*(uint32_t*)0x20006678 = 0x6894);
    NONFAILING(*(uint32_t*)0x2000667c = 0x45f);
    NONFAILING(*(uint32_t*)0x20006680 = 9);
    NONFAILING(*(uint32_t*)0x20006684 = 3);
    NONFAILING(*(uint32_t*)0x20006688 = 4);
    NONFAILING(*(uint32_t*)0x2000668c = 6);
    NONFAILING(*(uint32_t*)0x20006690 = 0xffffda2b);
    NONFAILING(*(uint32_t*)0x20006694 = 0);
    NONFAILING(*(uint32_t*)0x20006698 = 3);
    NONFAILING(*(uint32_t*)0x2000669c = 2);
    NONFAILING(*(uint32_t*)0x200066a0 = 1);
    NONFAILING(*(uint32_t*)0x200066a4 = 0x7f);
    NONFAILING(*(uint32_t*)0x200066a8 = 3);
    NONFAILING(*(uint32_t*)0x200066ac = 0x101);
    NONFAILING(*(uint32_t*)0x200066b0 = 0xe1);
    NONFAILING(*(uint32_t*)0x200066b4 = 0x2829);
    NONFAILING(*(uint32_t*)0x200066b8 = 0x1ff);
    NONFAILING(*(uint32_t*)0x200066bc = 4);
    NONFAILING(*(uint32_t*)0x200066c0 = 7);
    NONFAILING(*(uint32_t*)0x200066c4 = 0xc000000);
    NONFAILING(*(uint32_t*)0x200066c8 = 0x567);
    NONFAILING(*(uint32_t*)0x200066cc = 0x75c);
    NONFAILING(*(uint32_t*)0x200066d0 = 5);
    NONFAILING(*(uint32_t*)0x200066d4 = 3);
    NONFAILING(*(uint32_t*)0x200066d8 = 0x81);
    NONFAILING(*(uint32_t*)0x200066dc = 0x80000000);
    NONFAILING(*(uint32_t*)0x200066e0 = 0x800);
    NONFAILING(*(uint32_t*)0x200066e4 = 0x20);
    NONFAILING(*(uint32_t*)0x200066e8 = 0x7ff);
    NONFAILING(*(uint32_t*)0x200066ec = 4);
    NONFAILING(*(uint32_t*)0x200066f0 = 0x5b8);
    NONFAILING(*(uint32_t*)0x200066f4 = 7);
    NONFAILING(*(uint32_t*)0x200066f8 = 0xfffffffb);
    NONFAILING(*(uint32_t*)0x200066fc = -1);
    NONFAILING(*(uint32_t*)0x20006700 = 0xcd);
    NONFAILING(*(uint32_t*)0x20006704 = 8);
    NONFAILING(*(uint32_t*)0x20006708 = 7);
    NONFAILING(*(uint32_t*)0x2000670c = 2);
    NONFAILING(*(uint32_t*)0x20006710 = 0x400);
    NONFAILING(*(uint32_t*)0x20006714 = 1);
    NONFAILING(*(uint32_t*)0x20006718 = 2);
    NONFAILING(*(uint32_t*)0x2000671c = 9);
    NONFAILING(*(uint32_t*)0x20006720 = 8);
    NONFAILING(*(uint32_t*)0x20006724 = 0xfffffffd);
    NONFAILING(*(uint32_t*)0x20006728 = 0xb366);
    NONFAILING(*(uint32_t*)0x2000672c = 7);
    NONFAILING(*(uint32_t*)0x20006730 = 0);
    NONFAILING(*(uint32_t*)0x20006734 = 0);
    NONFAILING(*(uint32_t*)0x20006738 = 6);
    NONFAILING(*(uint32_t*)0x2000673c = 0x3f);
    NONFAILING(*(uint32_t*)0x20006740 = 0x8000);
    NONFAILING(*(uint32_t*)0x20006744 = 8);
    NONFAILING(*(uint32_t*)0x20006748 = 0x10001);
    NONFAILING(*(uint32_t*)0x2000674c = 1);
    NONFAILING(*(uint32_t*)0x20006750 = 0xb7);
    NONFAILING(*(uint32_t*)0x20006754 = 1);
    NONFAILING(*(uint32_t*)0x20006758 = 0x7ff);
    NONFAILING(*(uint32_t*)0x2000675c = 0x80);
    NONFAILING(*(uint32_t*)0x20006760 = 0xfffffffe);
    NONFAILING(*(uint32_t*)0x20006764 = 5);
    NONFAILING(*(uint32_t*)0x20006768 = 8);
    NONFAILING(*(uint32_t*)0x2000676c = 7);
    NONFAILING(*(uint32_t*)0x20006770 = 3);
    NONFAILING(*(uint32_t*)0x20006774 = 8);
    NONFAILING(*(uint32_t*)0x20006778 = 0);
    NONFAILING(*(uint32_t*)0x2000677c = 7);
    NONFAILING(*(uint32_t*)0x20006780 = 0x84);
    NONFAILING(*(uint32_t*)0x20006784 = 0);
    NONFAILING(*(uint32_t*)0x20006788 = 0x37c);
    NONFAILING(*(uint32_t*)0x2000678c = 8);
    NONFAILING(*(uint32_t*)0x20006790 = 4);
    NONFAILING(*(uint32_t*)0x20006794 = 0x80);
    NONFAILING(*(uint32_t*)0x20006798 = 6);
    NONFAILING(*(uint32_t*)0x2000679c = 8);
    NONFAILING(*(uint32_t*)0x200067a0 = 8);
    NONFAILING(*(uint32_t*)0x200067a4 = 2);
    NONFAILING(*(uint32_t*)0x200067a8 = 8);
    NONFAILING(*(uint32_t*)0x200067ac = 1);
    NONFAILING(*(uint32_t*)0x200067b0 = 7);
    NONFAILING(*(uint32_t*)0x200067b4 = 0);
    NONFAILING(*(uint32_t*)0x200067b8 = 0x80);
    NONFAILING(*(uint32_t*)0x200067bc = 3);
    NONFAILING(*(uint32_t*)0x200067c0 = 2);
    NONFAILING(*(uint32_t*)0x200067c4 = 5);
    NONFAILING(*(uint32_t*)0x200067c8 = 4);
    NONFAILING(*(uint32_t*)0x200067cc = 0x1cdc);
    NONFAILING(*(uint32_t*)0x200067d0 = 0x40);
    NONFAILING(*(uint32_t*)0x200067d4 = 0x1f);
    NONFAILING(*(uint32_t*)0x200067d8 = 0x769);
    NONFAILING(*(uint32_t*)0x200067dc = 0x5ac);
    NONFAILING(*(uint32_t*)0x200067e0 = 7);
    NONFAILING(*(uint32_t*)0x200067e4 = 6);
    NONFAILING(*(uint32_t*)0x200067e8 = 8);
    NONFAILING(*(uint32_t*)0x200067ec = 0x7fff);
    NONFAILING(*(uint32_t*)0x200067f0 = 9);
    NONFAILING(*(uint32_t*)0x200067f4 = 0x7fffffff);
    NONFAILING(*(uint32_t*)0x200067f8 = 0x81);
    NONFAILING(*(uint32_t*)0x200067fc = 7);
    NONFAILING(*(uint32_t*)0x20006800 = 6);
    NONFAILING(*(uint32_t*)0x20006804 = 4);
    NONFAILING(*(uint32_t*)0x20006808 = 0x7fff);
    NONFAILING(*(uint32_t*)0x2000680c = 8);
    NONFAILING(*(uint32_t*)0x20006810 = -1);
    NONFAILING(*(uint32_t*)0x20006814 = 4);
    NONFAILING(*(uint32_t*)0x20006818 = 4);
    NONFAILING(*(uint32_t*)0x2000681c = 5);
    NONFAILING(*(uint32_t*)0x20006820 = 0x10000);
    NONFAILING(*(uint32_t*)0x20006824 = 5);
    NONFAILING(*(uint32_t*)0x20006828 = 0);
    NONFAILING(*(uint32_t*)0x2000682c = 8);
    NONFAILING(*(uint32_t*)0x20006830 = 1);
    NONFAILING(*(uint32_t*)0x20006834 = 0x101);
    NONFAILING(*(uint32_t*)0x20006838 = 0xdd9);
    NONFAILING(*(uint32_t*)0x2000683c = 0);
    NONFAILING(*(uint32_t*)0x20006840 = 0xcfa);
    NONFAILING(*(uint32_t*)0x20006844 = 0xf1);
    NONFAILING(*(uint32_t*)0x20006848 = 7);
    NONFAILING(*(uint32_t*)0x2000684c = 0x1f);
    NONFAILING(*(uint32_t*)0x20006850 = 5);
    NONFAILING(*(uint32_t*)0x20006854 = 6);
    NONFAILING(*(uint32_t*)0x20006858 = 0x1f);
    NONFAILING(*(uint32_t*)0x2000685c = 0x100);
    NONFAILING(*(uint32_t*)0x20006860 = 0xffffff80);
    NONFAILING(*(uint32_t*)0x20006864 = 0xfffffffd);
    NONFAILING(*(uint32_t*)0x20006868 = 0x5e9);
    NONFAILING(*(uint32_t*)0x2000686c = 8);
    NONFAILING(*(uint32_t*)0x20006870 = 7);
    NONFAILING(*(uint32_t*)0x20006874 = 3);
    NONFAILING(*(uint32_t*)0x20006878 = 1);
    NONFAILING(*(uint32_t*)0x2000687c = 6);
    NONFAILING(*(uint32_t*)0x20006880 = 0x80000001);
    NONFAILING(*(uint32_t*)0x20006884 = 7);
    NONFAILING(*(uint32_t*)0x20006888 = 0xe2f7);
    NONFAILING(*(uint32_t*)0x2000688c = 0x8df9);
    NONFAILING(*(uint32_t*)0x20006890 = 0x81);
    NONFAILING(*(uint32_t*)0x20006894 = 0);
    NONFAILING(*(uint32_t*)0x20006898 = 9);
    NONFAILING(*(uint32_t*)0x2000689c = 1);
    NONFAILING(*(uint32_t*)0x200068a0 = 0x71d);
    NONFAILING(*(uint32_t*)0x200068a4 = 0x7ff);
    NONFAILING(*(uint32_t*)0x200068a8 = 0x81);
    NONFAILING(*(uint32_t*)0x200068ac = 8);
    NONFAILING(*(uint32_t*)0x200068b0 = 1);
    NONFAILING(*(uint32_t*)0x200068b4 = 0x9e58);
    NONFAILING(*(uint32_t*)0x200068b8 = 5);
    NONFAILING(*(uint32_t*)0x200068bc = 4);
    NONFAILING(*(uint32_t*)0x200068c0 = 0x7f);
    NONFAILING(*(uint32_t*)0x200068c4 = 0x80000000);
    NONFAILING(*(uint32_t*)0x200068c8 = 5);
    NONFAILING(*(uint32_t*)0x200068cc = 5);
    NONFAILING(*(uint32_t*)0x200068d0 = 8);
    NONFAILING(*(uint32_t*)0x200068d4 = 3);
    NONFAILING(*(uint32_t*)0x200068d8 = 0xe94);
    NONFAILING(*(uint32_t*)0x200068dc = 0x101);
    NONFAILING(*(uint32_t*)0x200068e0 = 8);
    NONFAILING(*(uint32_t*)0x200068e4 = 0xfffffffc);
    NONFAILING(*(uint32_t*)0x200068e8 = 0x800);
    NONFAILING(*(uint32_t*)0x200068ec = 9);
    NONFAILING(*(uint32_t*)0x200068f0 = 0x100);
    NONFAILING(*(uint32_t*)0x200068f4 = 0x4ab6);
    NONFAILING(*(uint32_t*)0x200068f8 = 0x8001);
    NONFAILING(*(uint32_t*)0x200068fc = 1);
    NONFAILING(*(uint32_t*)0x20006900 = 0xffffff80);
    NONFAILING(*(uint32_t*)0x20006904 = -1);
    NONFAILING(*(uint32_t*)0x20006908 = 0x7fff);
    NONFAILING(*(uint32_t*)0x2000690c = 0x29);
    NONFAILING(*(uint32_t*)0x20006910 = 9);
    NONFAILING(*(uint32_t*)0x20006914 = 0x40);
    NONFAILING(*(uint32_t*)0x20006918 = 6);
    NONFAILING(*(uint32_t*)0x2000691c = 5);
    NONFAILING(*(uint32_t*)0x20006920 = 8);
    NONFAILING(*(uint32_t*)0x20006924 = 0x800000);
    NONFAILING(*(uint32_t*)0x20006928 = 0x7f);
    NONFAILING(*(uint32_t*)0x2000692c = 0x26);
    NONFAILING(*(uint32_t*)0x20006930 = 8);
    NONFAILING(*(uint32_t*)0x20006934 = 8);
    NONFAILING(*(uint32_t*)0x20006938 = 0x80000001);
    NONFAILING(*(uint32_t*)0x2000693c = 4);
    NONFAILING(*(uint32_t*)0x20006940 = 2);
    NONFAILING(*(uint32_t*)0x20006944 = 0x40);
    NONFAILING(*(uint32_t*)0x20006948 = 0xfff);
    NONFAILING(*(uint32_t*)0x2000694c = 0);
    NONFAILING(*(uint32_t*)0x20006950 = 0x3ff);
    NONFAILING(*(uint32_t*)0x20006954 = 3);
    NONFAILING(*(uint32_t*)0x20006958 = 2);
    NONFAILING(*(uint32_t*)0x2000695c = 0);
    NONFAILING(*(uint32_t*)0x20006960 = 5);
    NONFAILING(*(uint32_t*)0x20006964 = 0xfffffbff);
    NONFAILING(*(uint32_t*)0x20006968 = 0x2e);
    NONFAILING(*(uint32_t*)0x2000696c = 6);
    NONFAILING(*(uint32_t*)0x20006970 = 0xe129);
    NONFAILING(*(uint32_t*)0x20006974 = 6);
    NONFAILING(*(uint32_t*)0x20006978 = 0x800);
    NONFAILING(*(uint32_t*)0x2000697c = 0x10000);
    NONFAILING(*(uint32_t*)0x20006980 = 2);
    NONFAILING(*(uint32_t*)0x20006984 = 0xffff);
    NONFAILING(*(uint32_t*)0x20006988 = 2);
    NONFAILING(*(uint32_t*)0x2000698c = 0x153d500c);
    NONFAILING(*(uint32_t*)0x20006990 = 9);
    NONFAILING(*(uint32_t*)0x20006994 = 0x20);
    NONFAILING(*(uint32_t*)0x20006998 = 6);
    NONFAILING(*(uint32_t*)0x2000699c = 6);
    NONFAILING(*(uint32_t*)0x200069a0 = 3);
    NONFAILING(*(uint32_t*)0x200069a4 = 0x3ff);
    NONFAILING(*(uint32_t*)0x200069a8 = 7);
    NONFAILING(*(uint32_t*)0x200069ac = 0);
    NONFAILING(*(uint32_t*)0x200069b0 = 0x3ff);
    NONFAILING(*(uint32_t*)0x200069b4 = 0x80);
    NONFAILING(*(uint32_t*)0x200069b8 = 0x1ff);
    NONFAILING(*(uint32_t*)0x200069bc = 3);
    NONFAILING(*(uint32_t*)0x200069c0 = 0x400);
    NONFAILING(*(uint32_t*)0x200069c4 = 7);
    NONFAILING(*(uint32_t*)0x200069c8 = 0xfffffff7);
    NONFAILING(*(uint32_t*)0x200069cc = 3);
    NONFAILING(*(uint32_t*)0x200069d0 = 2);
    NONFAILING(*(uint32_t*)0x200069d4 = 0xaf0);
    NONFAILING(*(uint32_t*)0x200069d8 = 0);
    NONFAILING(*(uint32_t*)0x200069dc = 5);
    NONFAILING(*(uint32_t*)0x200069e0 = 0xffffff81);
    NONFAILING(*(uint32_t*)0x200069e4 = 0xcd8);
    NONFAILING(*(uint32_t*)0x200069e8 = 0);
    NONFAILING(*(uint32_t*)0x200069ec = 0x3f);
    NONFAILING(*(uint32_t*)0x200069f0 = 5);
    NONFAILING(*(uint32_t*)0x200069f4 = 0xc7dd);
    NONFAILING(*(uint32_t*)0x200069f8 = 0xa73);
    NONFAILING(*(uint32_t*)0x200069fc = 1);
    NONFAILING(*(uint32_t*)0x20006a00 = -1);
    NONFAILING(*(uint32_t*)0x20006a04 = 0x4249);
    NONFAILING(*(uint32_t*)0x20006a08 = 0);
    NONFAILING(*(uint32_t*)0x20006a0c = 0x5a);
    NONFAILING(*(uint32_t*)0x20006a10 = 0x1c8);
    NONFAILING(*(uint32_t*)0x20006a14 = 6);
    NONFAILING(*(uint32_t*)0x20006a18 = 5);
    NONFAILING(*(uint32_t*)0x20006a1c = 9);
    NONFAILING(*(uint32_t*)0x20006a20 = 9);
    NONFAILING(*(uint32_t*)0x20006a24 = 3);
    NONFAILING(*(uint32_t*)0x20006a28 = 0);
    NONFAILING(*(uint32_t*)0x20006a2c = 9);
    NONFAILING(*(uint32_t*)0x20006a30 = 0);
    NONFAILING(*(uint32_t*)0x20006a34 = 0xfffffff7);
    NONFAILING(*(uint32_t*)0x20006a38 = 4);
    NONFAILING(*(uint32_t*)0x20006a3c = 7);
    NONFAILING(*(uint32_t*)0x20006a40 = -1);
    NONFAILING(*(uint32_t*)0x20006a44 = 0xffff8001);
    NONFAILING(*(uint32_t*)0x20006a48 = 0x1064);
    NONFAILING(*(uint32_t*)0x20006a4c = 8);
    NONFAILING(*(uint32_t*)0x20006a50 = 3);
    NONFAILING(*(uint32_t*)0x20006a54 = 9);
    NONFAILING(*(uint32_t*)0x20006a58 = 0xfffffff9);
    NONFAILING(*(uint32_t*)0x20006a5c = 0xffffff4c);
    NONFAILING(*(uint32_t*)0x20006a60 = 8);
    NONFAILING(*(uint32_t*)0x20006a64 = 8);
    NONFAILING(*(uint32_t*)0x20006a68 = 0x7e5);
    NONFAILING(*(uint32_t*)0x20006a6c = 0x10001);
    NONFAILING(*(uint32_t*)0x20006a70 = 0);
    NONFAILING(*(uint32_t*)0x20006a74 = 0xdf);
    NONFAILING(*(uint32_t*)0x20006a78 = 1);
    NONFAILING(*(uint32_t*)0x20006a7c = 0x59b3);
    NONFAILING(*(uint32_t*)0x20006a80 = 0x7fffffff);
    NONFAILING(*(uint32_t*)0x20006a84 = 1);
    NONFAILING(*(uint32_t*)0x20006a88 = 0x42);
    NONFAILING(*(uint32_t*)0x20006a8c = 6);
    NONFAILING(*(uint32_t*)0x20006a90 = 3);
    NONFAILING(*(uint32_t*)0x20006a94 = 0x7fff);
    NONFAILING(*(uint32_t*)0x20006a98 = 2);
    NONFAILING(*(uint32_t*)0x20006a9c = 0x8000);
    NONFAILING(*(uint32_t*)0x20006aa0 = 0);
    NONFAILING(*(uint32_t*)0x20006aa4 = 5);
    NONFAILING(*(uint32_t*)0x20006aa8 = 6);
    NONFAILING(*(uint32_t*)0x20006aac = 0x80);
    NONFAILING(*(uint32_t*)0x20006ab0 = 5);
    NONFAILING(*(uint32_t*)0x20006ab4 = 0x80000001);
    NONFAILING(*(uint32_t*)0x20006ab8 = 0x6d);
    NONFAILING(*(uint32_t*)0x20006abc = 0xfffffff8);
    NONFAILING(*(uint32_t*)0x20006ac0 = 8);
    NONFAILING(*(uint32_t*)0x20006ac4 = 6);
    NONFAILING(*(uint32_t*)0x20006ac8 = 0x1f);
    NONFAILING(*(uint32_t*)0x20006acc = 0x540);
    NONFAILING(*(uint32_t*)0x20006ad0 = 5);
    NONFAILING(*(uint32_t*)0x20006ad4 = 8);
    NONFAILING(*(uint32_t*)0x20006ad8 = 7);
    NONFAILING(*(uint32_t*)0x20006adc = 0x80000000);
    NONFAILING(*(uint32_t*)0x20006ae0 = 7);
    NONFAILING(*(uint32_t*)0x20006ae4 = 0xff);
    NONFAILING(*(uint32_t*)0x20006ae8 = 1);
    NONFAILING(*(uint32_t*)0x20006aec = 0x101);
    NONFAILING(*(uint32_t*)0x20006af0 = 5);
    NONFAILING(*(uint32_t*)0x20006af4 = 0xf5);
    NONFAILING(*(uint32_t*)0x20006af8 = 0x1f);
    NONFAILING(*(uint32_t*)0x20006afc = 0x400);
    NONFAILING(*(uint32_t*)0x20006b00 = 7);
    NONFAILING(*(uint32_t*)0x20006b04 = 5);
    NONFAILING(*(uint32_t*)0x20006b08 = 0xdf);
    NONFAILING(*(uint32_t*)0x20006b0c = 7);
    NONFAILING(*(uint32_t*)0x20006b10 = 0);
    NONFAILING(*(uint32_t*)0x20006b14 = 5);
    NONFAILING(*(uint32_t*)0x20006b18 = 5);
    NONFAILING(*(uint32_t*)0x20006b1c = 3);
    NONFAILING(*(uint32_t*)0x20006b20 = 0);
    NONFAILING(*(uint32_t*)0x20006b24 = 0x20);
    NONFAILING(*(uint32_t*)0x20006b28 = 3);
    NONFAILING(*(uint32_t*)0x20006b2c = 8);
    NONFAILING(*(uint32_t*)0x20006b30 = 4);
    NONFAILING(*(uint32_t*)0x20006b34 = 0x1000);
    NONFAILING(*(uint32_t*)0x20006b38 = 0);
    NONFAILING(*(uint32_t*)0x20006b3c = 2);
    NONFAILING(*(uint32_t*)0x20006b40 = 0);
    NONFAILING(*(uint32_t*)0x20006b44 = 0x3ff);
    NONFAILING(*(uint32_t*)0x20006b48 = 1);
    NONFAILING(*(uint16_t*)0x20006b4c = 2);
    NONFAILING(*(uint16_t*)0x20006b4e = 1);
    NONFAILING(*(uint16_t*)0x20006b50 = 2);
    NONFAILING(*(uint16_t*)0x20006b52 = 1);
    NONFAILING(*(uint16_t*)0x20006b54 = 1);
    NONFAILING(*(uint16_t*)0x20006b56 = 1);
    NONFAILING(*(uint16_t*)0x20006b58 = 0);
    NONFAILING(*(uint16_t*)0x20006b5a = 0xec37);
    NONFAILING(*(uint16_t*)0x20006b5c = 3);
    NONFAILING(*(uint16_t*)0x20006b5e = 1);
    NONFAILING(*(uint16_t*)0x20006b60 = 4);
    NONFAILING(*(uint16_t*)0x20006b62 = 0);
    NONFAILING(*(uint16_t*)0x20006b64 = 2);
    NONFAILING(*(uint16_t*)0x20006b66 = 1);
    NONFAILING(*(uint16_t*)0x20006b68 = 7);
    NONFAILING(*(uint16_t*)0x20006b6a = 0);
    NONFAILING(*(uint16_t*)0x20006b6c = 2);
    NONFAILING(*(uint16_t*)0x20006b6e = 0);
    NONFAILING(*(uint16_t*)0x20006b70 = 1);
    NONFAILING(*(uint16_t*)0x20006b72 = 0);
    NONFAILING(*(uint16_t*)0x20006b74 = 5);
    NONFAILING(*(uint16_t*)0x20006b76 = 1);
    NONFAILING(*(uint16_t*)0x20006b78 = 4);
    NONFAILING(*(uint16_t*)0x20006b7a = 1);
    NONFAILING(*(uint16_t*)0x20006b7c = 0);
    NONFAILING(*(uint16_t*)0x20006b7e = 0);
    NONFAILING(*(uint16_t*)0x20006b80 = 0);
    NONFAILING(*(uint16_t*)0x20006b82 = 1);
    NONFAILING(*(uint16_t*)0x20006b84 = 5);
    NONFAILING(*(uint16_t*)0x20006b86 = 0);
    NONFAILING(*(uint16_t*)0x20006b88 = 3);
    NONFAILING(*(uint16_t*)0x20006b8a = 0);
    NONFAILING(*(uint16_t*)0x20006b8c = 2);
    NONFAILING(*(uint16_t*)0x20006b8e = 0);
    NONFAILING(*(uint16_t*)0x20006b90 = 4);
    NONFAILING(*(uint16_t*)0x20006b92 = 0);
    NONFAILING(*(uint16_t*)0x20006b94 = 1);
    NONFAILING(*(uint16_t*)0x20006b96 = 1);
    NONFAILING(*(uint16_t*)0x20006b98 = 1);
    NONFAILING(*(uint16_t*)0x20006b9a = 1);
    NONFAILING(*(uint16_t*)0x20006b9c = 4);
    NONFAILING(*(uint16_t*)0x20006b9e = 0);
    NONFAILING(*(uint16_t*)0x20006ba0 = 1);
    NONFAILING(*(uint16_t*)0x20006ba2 = 1);
    NONFAILING(*(uint16_t*)0x20006ba4 = 1);
    NONFAILING(*(uint16_t*)0x20006ba6 = 0);
    NONFAILING(*(uint16_t*)0x20006ba8 = 5);
    NONFAILING(*(uint16_t*)0x20006baa = 1);
    NONFAILING(*(uint16_t*)0x20006bac = 1);
    NONFAILING(*(uint16_t*)0x20006bae = 0);
    NONFAILING(*(uint16_t*)0x20006bb0 = 2);
    NONFAILING(*(uint16_t*)0x20006bb2 = 0);
    NONFAILING(*(uint16_t*)0x20006bb4 = 2);
    NONFAILING(*(uint16_t*)0x20006bb6 = 0);
    NONFAILING(*(uint16_t*)0x20006bb8 = 0);
    NONFAILING(*(uint16_t*)0x20006bba = 0);
    NONFAILING(*(uint16_t*)0x20006bbc = 1);
    NONFAILING(*(uint16_t*)0x20006bbe = 0);
    NONFAILING(*(uint16_t*)0x20006bc0 = 4);
    NONFAILING(*(uint16_t*)0x20006bc2 = 0);
    NONFAILING(*(uint16_t*)0x20006bc4 = 3);
    NONFAILING(*(uint16_t*)0x20006bc6 = 0);
    NONFAILING(*(uint16_t*)0x20006bc8 = 3);
    NONFAILING(*(uint16_t*)0x20006bca = 0);
    NONFAILING(*(uint16_t*)0x20006bcc = 4);
    NONFAILING(*(uint16_t*)0x20006bce = 0);
    NONFAILING(*(uint16_t*)0x20006bd0 = 5);
    NONFAILING(*(uint16_t*)0x20006bd2 = 1);
    NONFAILING(*(uint16_t*)0x20006bd4 = 4);
    NONFAILING(*(uint16_t*)0x20006bd6 = 1);
    NONFAILING(*(uint16_t*)0x20006bd8 = 1);
    NONFAILING(*(uint16_t*)0x20006bda = 0);
    NONFAILING(*(uint16_t*)0x20006bdc = 5);
    NONFAILING(*(uint16_t*)0x20006bde = 0);
    NONFAILING(*(uint16_t*)0x20006be0 = 4);
    NONFAILING(*(uint16_t*)0x20006be2 = 1);
    NONFAILING(*(uint16_t*)0x20006be4 = 1);
    NONFAILING(*(uint16_t*)0x20006be6 = 0);
    NONFAILING(*(uint16_t*)0x20006be8 = 1);
    NONFAILING(*(uint16_t*)0x20006bea = 1);
    NONFAILING(*(uint16_t*)0x20006bec = 0);
    NONFAILING(*(uint16_t*)0x20006bee = 0);
    NONFAILING(*(uint16_t*)0x20006bf0 = 4);
    NONFAILING(*(uint16_t*)0x20006bf2 = 1);
    NONFAILING(*(uint16_t*)0x20006bf4 = 5);
    NONFAILING(*(uint16_t*)0x20006bf6 = 1);
    NONFAILING(*(uint16_t*)0x20006bf8 = 1);
    NONFAILING(*(uint16_t*)0x20006bfa = 0);
    NONFAILING(*(uint16_t*)0x20006bfc = 5);
    NONFAILING(*(uint16_t*)0x20006bfe = 1);
    NONFAILING(*(uint16_t*)0x20006c00 = 0);
    NONFAILING(*(uint16_t*)0x20006c02 = 0);
    NONFAILING(*(uint16_t*)0x20006c04 = 1);
    NONFAILING(*(uint16_t*)0x20006c06 = 1);
    NONFAILING(*(uint16_t*)0x20006c08 = 0);
    NONFAILING(*(uint16_t*)0x20006c0a = 0);
    NONFAILING(*(uint16_t*)0x20006c0c = 2);
    NONFAILING(*(uint16_t*)0x20006c0e = 1);
    NONFAILING(*(uint16_t*)0x20006c10 = 5);
    NONFAILING(*(uint16_t*)0x20006c12 = 0);
    NONFAILING(*(uint16_t*)0x20006c14 = 3);
    NONFAILING(*(uint16_t*)0x20006c16 = 1);
    NONFAILING(*(uint16_t*)0x20006c18 = 0);
    NONFAILING(*(uint16_t*)0x20006c1a = 1);
    NONFAILING(*(uint16_t*)0x20006c1c = 0);
    NONFAILING(*(uint16_t*)0x20006c1e = 0);
    NONFAILING(*(uint16_t*)0x20006c20 = 4);
    NONFAILING(*(uint16_t*)0x20006c22 = 0x678d);
    NONFAILING(*(uint16_t*)0x20006c24 = 3);
    NONFAILING(*(uint16_t*)0x20006c26 = 0);
    NONFAILING(*(uint16_t*)0x20006c28 = 4);
    NONFAILING(*(uint16_t*)0x20006c2a = 0);
    NONFAILING(*(uint16_t*)0x20006c2c = 1);
    NONFAILING(*(uint16_t*)0x20006c2e = 1);
    NONFAILING(*(uint16_t*)0x20006c30 = 1);
    NONFAILING(*(uint16_t*)0x20006c32 = 1);
    NONFAILING(*(uint16_t*)0x20006c34 = 4);
    NONFAILING(*(uint16_t*)0x20006c36 = 0);
    NONFAILING(*(uint16_t*)0x20006c38 = 2);
    NONFAILING(*(uint16_t*)0x20006c3a = 1);
    NONFAILING(*(uint16_t*)0x20006c3c = 0);
    NONFAILING(*(uint16_t*)0x20006c3e = 1);
    NONFAILING(*(uint16_t*)0x20006c40 = 1);
    NONFAILING(*(uint16_t*)0x20006c42 = 1);
    NONFAILING(*(uint16_t*)0x20006c44 = 5);
    NONFAILING(*(uint16_t*)0x20006c46 = 0);
    NONFAILING(*(uint16_t*)0x20006c48 = 5);
    NONFAILING(*(uint16_t*)0x20006c4a = 1);
    NONFAILING(*(uint16_t*)0x20006c4c = 7);
    NONFAILING(*(uint16_t*)0x20006c4e = 0);
    NONFAILING(*(uint16_t*)0x20006c50 = 2);
    NONFAILING(*(uint16_t*)0x20006c52 = 1);
    NONFAILING(*(uint16_t*)0x20006c54 = 0);
    NONFAILING(*(uint16_t*)0x20006c56 = 1);
    NONFAILING(*(uint16_t*)0x20006c58 = 0);
    NONFAILING(*(uint16_t*)0x20006c5a = 1);
    NONFAILING(*(uint16_t*)0x20006c5c = 5);
    NONFAILING(*(uint16_t*)0x20006c5e = 0);
    NONFAILING(*(uint16_t*)0x20006c60 = 1);
    NONFAILING(*(uint16_t*)0x20006c62 = 0);
    NONFAILING(*(uint16_t*)0x20006c64 = 2);
    NONFAILING(*(uint16_t*)0x20006c66 = 1);
    NONFAILING(*(uint16_t*)0x20006c68 = 0);
    NONFAILING(*(uint16_t*)0x20006c6a = 1);
    NONFAILING(*(uint16_t*)0x20006c6c = 5);
    NONFAILING(*(uint16_t*)0x20006c6e = 1);
    NONFAILING(*(uint16_t*)0x20006c70 = 0);
    NONFAILING(*(uint16_t*)0x20006c72 = 0);
    NONFAILING(*(uint16_t*)0x20006c74 = 3);
    NONFAILING(*(uint16_t*)0x20006c76 = 0);
    NONFAILING(*(uint16_t*)0x20006c78 = 1);
    NONFAILING(*(uint16_t*)0x20006c7a = 0);
    NONFAILING(*(uint16_t*)0x20006c7c = 2);
    NONFAILING(*(uint16_t*)0x20006c7e = 0);
    NONFAILING(*(uint16_t*)0x20006c80 = 2);
    NONFAILING(*(uint16_t*)0x20006c82 = 0);
    NONFAILING(*(uint16_t*)0x20006c84 = 4);
    NONFAILING(*(uint16_t*)0x20006c86 = 0);
    NONFAILING(*(uint16_t*)0x20006c88 = 4);
    NONFAILING(*(uint16_t*)0x20006c8a = 0);
    NONFAILING(*(uint16_t*)0x20006c8c = 2);
    NONFAILING(*(uint16_t*)0x20006c8e = 0);
    NONFAILING(*(uint16_t*)0x20006c90 = 3);
    NONFAILING(*(uint16_t*)0x20006c92 = 0);
    NONFAILING(*(uint16_t*)0x20006c94 = 3);
    NONFAILING(*(uint16_t*)0x20006c96 = 1);
    NONFAILING(*(uint16_t*)0x20006c98 = 0);
    NONFAILING(*(uint16_t*)0x20006c9a = 0);
    NONFAILING(*(uint16_t*)0x20006c9c = 3);
    NONFAILING(*(uint16_t*)0x20006c9e = 1);
    NONFAILING(*(uint16_t*)0x20006ca0 = 3);
    NONFAILING(*(uint16_t*)0x20006ca2 = 0);
    NONFAILING(*(uint16_t*)0x20006ca4 = 5);
    NONFAILING(*(uint16_t*)0x20006ca6 = 1);
    NONFAILING(*(uint16_t*)0x20006ca8 = 2);
    NONFAILING(*(uint16_t*)0x20006caa = 1);
    NONFAILING(*(uint16_t*)0x20006cac = 2);
    NONFAILING(*(uint16_t*)0x20006cae = 0);
    NONFAILING(*(uint16_t*)0x20006cb0 = 1);
    NONFAILING(*(uint16_t*)0x20006cb2 = 1);
    NONFAILING(*(uint16_t*)0x20006cb4 = 2);
    NONFAILING(*(uint16_t*)0x20006cb6 = 0);
    NONFAILING(*(uint16_t*)0x20006cb8 = 4);
    NONFAILING(*(uint16_t*)0x20006cba = 1);
    NONFAILING(*(uint16_t*)0x20006cbc = 2);
    NONFAILING(*(uint16_t*)0x20006cbe = 1);
    NONFAILING(*(uint16_t*)0x20006cc0 = 3);
    NONFAILING(*(uint16_t*)0x20006cc2 = 0);
    NONFAILING(*(uint16_t*)0x20006cc4 = 0);
    NONFAILING(*(uint16_t*)0x20006cc6 = 1);
    NONFAILING(*(uint16_t*)0x20006cc8 = 1);
    NONFAILING(*(uint16_t*)0x20006cca = 1);
    NONFAILING(*(uint16_t*)0x20006ccc = 4);
    NONFAILING(*(uint16_t*)0x20006cce = 1);
    NONFAILING(*(uint16_t*)0x20006cd0 = 2);
    NONFAILING(*(uint16_t*)0x20006cd2 = 0);
    NONFAILING(*(uint16_t*)0x20006cd4 = 4);
    NONFAILING(*(uint16_t*)0x20006cd6 = 1);
    NONFAILING(*(uint16_t*)0x20006cd8 = 3);
    NONFAILING(*(uint16_t*)0x20006cda = 0);
    NONFAILING(*(uint16_t*)0x20006cdc = 3);
    NONFAILING(*(uint16_t*)0x20006cde = 1);
    NONFAILING(*(uint16_t*)0x20006ce0 = 3);
    NONFAILING(*(uint16_t*)0x20006ce2 = 1);
    NONFAILING(*(uint16_t*)0x20006ce4 = 0);
    NONFAILING(*(uint16_t*)0x20006ce6 = 0);
    NONFAILING(*(uint16_t*)0x20006ce8 = 0);
    NONFAILING(*(uint16_t*)0x20006cea = 0);
    NONFAILING(*(uint16_t*)0x20006cec = 0);
    NONFAILING(*(uint16_t*)0x20006cee = 1);
    NONFAILING(*(uint16_t*)0x20006cf0 = 0);
    NONFAILING(*(uint16_t*)0x20006cf2 = 0);
    NONFAILING(*(uint16_t*)0x20006cf4 = 3);
    NONFAILING(*(uint16_t*)0x20006cf6 = 0);
    NONFAILING(*(uint16_t*)0x20006cf8 = 5);
    NONFAILING(*(uint16_t*)0x20006cfa = 1);
    NONFAILING(*(uint16_t*)0x20006cfc = 5);
    NONFAILING(*(uint16_t*)0x20006cfe = 0);
    NONFAILING(*(uint16_t*)0x20006d00 = 5);
    NONFAILING(*(uint16_t*)0x20006d02 = 0);
    NONFAILING(*(uint16_t*)0x20006d04 = 0);
    NONFAILING(*(uint16_t*)0x20006d06 = 1);
    NONFAILING(*(uint16_t*)0x20006d08 = 3);
    NONFAILING(*(uint16_t*)0x20006d0a = 0);
    NONFAILING(*(uint16_t*)0x20006d0c = 3);
    NONFAILING(*(uint16_t*)0x20006d0e = 1);
    NONFAILING(*(uint16_t*)0x20006d10 = 5);
    NONFAILING(*(uint16_t*)0x20006d12 = 1);
    NONFAILING(*(uint16_t*)0x20006d14 = 4);
    NONFAILING(*(uint16_t*)0x20006d16 = 1);
    NONFAILING(*(uint16_t*)0x20006d18 = 5);
    NONFAILING(*(uint16_t*)0x20006d1a = 0);
    NONFAILING(*(uint16_t*)0x20006d1c = 5);
    NONFAILING(*(uint16_t*)0x20006d1e = 1);
    NONFAILING(*(uint16_t*)0x20006d20 = 2);
    NONFAILING(*(uint16_t*)0x20006d22 = 1);
    NONFAILING(*(uint16_t*)0x20006d24 = 5);
    NONFAILING(*(uint16_t*)0x20006d26 = 0);
    NONFAILING(*(uint16_t*)0x20006d28 = 2);
    NONFAILING(*(uint16_t*)0x20006d2a = 1);
    NONFAILING(*(uint16_t*)0x20006d2c = 2);
    NONFAILING(*(uint16_t*)0x20006d2e = 0);
    NONFAILING(*(uint16_t*)0x20006d30 = 1);
    NONFAILING(*(uint16_t*)0x20006d32 = 1);
    NONFAILING(*(uint16_t*)0x20006d34 = 2);
    NONFAILING(*(uint16_t*)0x20006d36 = 1);
    NONFAILING(*(uint16_t*)0x20006d38 = 0);
    NONFAILING(*(uint16_t*)0x20006d3a = 0);
    NONFAILING(*(uint16_t*)0x20006d3c = 4);
    NONFAILING(*(uint16_t*)0x20006d3e = 1);
    NONFAILING(*(uint16_t*)0x20006d40 = 0);
    NONFAILING(*(uint16_t*)0x20006d42 = 1);
    NONFAILING(*(uint16_t*)0x20006d44 = 2);
    NONFAILING(*(uint16_t*)0x20006d46 = 0);
    NONFAILING(*(uint16_t*)0x20006d48 = 5);
    NONFAILING(*(uint16_t*)0x20006d4a = 1);
    NONFAILING(*(uint8_t*)0x20006d4c = 1);
    NONFAILING(*(uint16_t*)0x20006d50 = 0x50);
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20006d52, 5, 0, 14));
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20006d53, 0, 6, 1));
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20006d53, 1, 7, 1));
    NONFAILING(*(uint16_t*)0x20006d54 = 0x14);
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20006d56, 6, 0, 14));
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20006d57, 0, 6, 1));
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20006d57, 1, 7, 1));
    NONFAILING(*(uint16_t*)0x20006d58 = 6);
    NONFAILING(*(uint16_t*)0x20006d5a = 1);
    NONFAILING(*(uint16_t*)0x20006d5c = 4);
    NONFAILING(*(uint16_t*)0x20006d60 = 6);
    NONFAILING(*(uint16_t*)0x20006d62 = 1);
    NONFAILING(*(uint16_t*)0x20006d64 = 5);
    NONFAILING(*(uint16_t*)0x20006d68 = 0x14);
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20006d6a, 6, 0, 14));
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20006d6b, 0, 6, 1));
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20006d6b, 1, 7, 1));
    NONFAILING(*(uint16_t*)0x20006d6c = 6);
    NONFAILING(*(uint16_t*)0x20006d6e = 2);
    NONFAILING(*(uint16_t*)0x20006d70 = 0);
    NONFAILING(*(uint16_t*)0x20006d74 = 6);
    NONFAILING(*(uint16_t*)0x20006d76 = 1);
    NONFAILING(*(uint16_t*)0x20006d78 = 2);
    NONFAILING(*(uint16_t*)0x20006d7c = 0x24);
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20006d7e, 6, 0, 14));
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20006d7f, 0, 6, 1));
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20006d7f, 1, 7, 1));
    NONFAILING(*(uint16_t*)0x20006d80 = 6);
    NONFAILING(*(uint16_t*)0x20006d82 = 1);
    NONFAILING(*(uint16_t*)0x20006d84 = 0);
    NONFAILING(*(uint16_t*)0x20006d88 = 6);
    NONFAILING(*(uint16_t*)0x20006d8a = 2);
    NONFAILING(*(uint16_t*)0x20006d8c = 0);
    NONFAILING(*(uint16_t*)0x20006d90 = 6);
    NONFAILING(*(uint16_t*)0x20006d92 = 1);
    NONFAILING(*(uint16_t*)0x20006d94 = 1);
    NONFAILING(*(uint16_t*)0x20006d98 = 6);
    NONFAILING(*(uint16_t*)0x20006d9a = 1);
    NONFAILING(*(uint16_t*)0x20006d9c = 3);
    NONFAILING(*(uint16_t*)0x20006da0 = 0xe98);
    NONFAILING(*(uint16_t*)0x20006da2 = 4);
    NONFAILING(*(uint32_t*)0x20006da4 = 0xfffffffa);
    NONFAILING(*(uint32_t*)0x20006da8 = 0xcebb);
    NONFAILING(*(uint32_t*)0x20006dac = 4);
    NONFAILING(*(uint32_t*)0x20006db0 = -1);
    NONFAILING(*(uint32_t*)0x20006db4 = 9);
    NONFAILING(*(uint8_t*)0x20006db8 = 0x7f);
    NONFAILING(*(uint8_t*)0x20006db9 = 2);
    NONFAILING(*(uint32_t*)0x20006dbc = 2);
    NONFAILING(*(uint32_t*)0x20006dc0 = 0x1ff);
    NONFAILING(*(uint32_t*)0x20006dc4 = 0x10000);
    NONFAILING(*(uint32_t*)0x20006dc8 = 0x1000);
    NONFAILING(*(uint32_t*)0x20006dcc = 0x34e80000);
    NONFAILING(*(uint32_t*)0x20006dd0 = 0xa9);
    NONFAILING(*(uint32_t*)0x20006dd4 = 0x9d);
    NONFAILING(*(uint32_t*)0x20006dd8 = 0x1000);
    NONFAILING(*(uint32_t*)0x20006ddc = 0xcb4);
    NONFAILING(*(uint32_t*)0x20006de0 = 8);
    NONFAILING(*(uint32_t*)0x20006de4 = 4);
    NONFAILING(*(uint32_t*)0x20006de8 = 1);
    NONFAILING(*(uint32_t*)0x20006dec = 0xffffffe1);
    NONFAILING(*(uint32_t*)0x20006df0 = 2);
    NONFAILING(*(uint32_t*)0x20006df4 = 0x800000);
    NONFAILING(*(uint32_t*)0x20006df8 = 5);
    NONFAILING(*(uint32_t*)0x20006dfc = 8);
    NONFAILING(*(uint32_t*)0x20006e00 = 0x7ff);
    NONFAILING(*(uint32_t*)0x20006e04 = 0xec800);
    NONFAILING(*(uint32_t*)0x20006e08 = 9);
    NONFAILING(*(uint32_t*)0x20006e0c = 0xfffffff9);
    NONFAILING(*(uint32_t*)0x20006e10 = 3);
    NONFAILING(*(uint32_t*)0x20006e14 = 0);
    NONFAILING(*(uint32_t*)0x20006e18 = 2);
    NONFAILING(*(uint32_t*)0x20006e1c = 0x7fff);
    NONFAILING(*(uint32_t*)0x20006e20 = 7);
    NONFAILING(*(uint32_t*)0x20006e24 = 0x50d68061);
    NONFAILING(*(uint32_t*)0x20006e28 = 4);
    NONFAILING(*(uint32_t*)0x20006e2c = 2);
    NONFAILING(*(uint32_t*)0x20006e30 = 4);
    NONFAILING(*(uint32_t*)0x20006e34 = 6);
    NONFAILING(*(uint32_t*)0x20006e38 = 0x30000000);
    NONFAILING(*(uint32_t*)0x20006e3c = 0x86);
    NONFAILING(*(uint32_t*)0x20006e40 = 0xfff);
    NONFAILING(*(uint32_t*)0x20006e44 = 0x10001);
    NONFAILING(*(uint32_t*)0x20006e48 = 4);
    NONFAILING(*(uint32_t*)0x20006e4c = 9);
    NONFAILING(*(uint32_t*)0x20006e50 = 1);
    NONFAILING(*(uint32_t*)0x20006e54 = 0x8af0);
    NONFAILING(*(uint32_t*)0x20006e58 = 0x44e8);
    NONFAILING(*(uint32_t*)0x20006e5c = 0x8000);
    NONFAILING(*(uint32_t*)0x20006e60 = 0x20);
    NONFAILING(*(uint32_t*)0x20006e64 = 0x10000);
    NONFAILING(*(uint32_t*)0x20006e68 = 7);
    NONFAILING(*(uint32_t*)0x20006e6c = 1);
    NONFAILING(*(uint32_t*)0x20006e70 = 0x74);
    NONFAILING(*(uint32_t*)0x20006e74 = 4);
    NONFAILING(*(uint32_t*)0x20006e78 = 9);
    NONFAILING(*(uint32_t*)0x20006e7c = 6);
    NONFAILING(*(uint32_t*)0x20006e80 = 5);
    NONFAILING(*(uint32_t*)0x20006e84 = 0x401);
    NONFAILING(*(uint32_t*)0x20006e88 = 9);
    NONFAILING(*(uint32_t*)0x20006e8c = 1);
    NONFAILING(*(uint32_t*)0x20006e90 = 2);
    NONFAILING(*(uint32_t*)0x20006e94 = 0x8b43);
    NONFAILING(*(uint32_t*)0x20006e98 = 0x1a);
    NONFAILING(*(uint32_t*)0x20006e9c = 0xffff);
    NONFAILING(*(uint32_t*)0x20006ea0 = 8);
    NONFAILING(*(uint32_t*)0x20006ea4 = 5);
    NONFAILING(*(uint32_t*)0x20006ea8 = 1);
    NONFAILING(*(uint32_t*)0x20006eac = 0xb90);
    NONFAILING(*(uint32_t*)0x20006eb0 = 8);
    NONFAILING(*(uint32_t*)0x20006eb4 = 0x7f);
    NONFAILING(*(uint32_t*)0x20006eb8 = 0x13a4);
    NONFAILING(*(uint32_t*)0x20006ebc = 0x81);
    NONFAILING(*(uint32_t*)0x20006ec0 = 0);
    NONFAILING(*(uint32_t*)0x20006ec4 = 3);
    NONFAILING(*(uint32_t*)0x20006ec8 = 1);
    NONFAILING(*(uint32_t*)0x20006ecc = 0x4000000);
    NONFAILING(*(uint32_t*)0x20006ed0 = 3);
    NONFAILING(*(uint32_t*)0x20006ed4 = 0x81);
    NONFAILING(*(uint32_t*)0x20006ed8 = 0x800);
    NONFAILING(*(uint32_t*)0x20006edc = 2);
    NONFAILING(*(uint32_t*)0x20006ee0 = 6);
    NONFAILING(*(uint32_t*)0x20006ee4 = 0x7fffffff);
    NONFAILING(*(uint32_t*)0x20006ee8 = 0xfb1);
    NONFAILING(*(uint32_t*)0x20006eec = 7);
    NONFAILING(*(uint32_t*)0x20006ef0 = 0xfffffffb);
    NONFAILING(*(uint32_t*)0x20006ef4 = 2);
    NONFAILING(*(uint32_t*)0x20006ef8 = 0x305);
    NONFAILING(*(uint32_t*)0x20006efc = 0x80000001);
    NONFAILING(*(uint32_t*)0x20006f00 = 0x200);
    NONFAILING(*(uint32_t*)0x20006f04 = 9);
    NONFAILING(*(uint32_t*)0x20006f08 = 5);
    NONFAILING(*(uint32_t*)0x20006f0c = 9);
    NONFAILING(*(uint32_t*)0x20006f10 = 5);
    NONFAILING(*(uint32_t*)0x20006f14 = 8);
    NONFAILING(*(uint32_t*)0x20006f18 = 6);
    NONFAILING(*(uint32_t*)0x20006f1c = 0x200);
    NONFAILING(*(uint32_t*)0x20006f20 = 0xd26f);
    NONFAILING(*(uint32_t*)0x20006f24 = 9);
    NONFAILING(*(uint32_t*)0x20006f28 = 1);
    NONFAILING(*(uint32_t*)0x20006f2c = 2);
    NONFAILING(*(uint32_t*)0x20006f30 = 4);
    NONFAILING(*(uint32_t*)0x20006f34 = 3);
    NONFAILING(*(uint32_t*)0x20006f38 = 1);
    NONFAILING(*(uint32_t*)0x20006f3c = 7);
    NONFAILING(*(uint32_t*)0x20006f40 = 3);
    NONFAILING(*(uint32_t*)0x20006f44 = 8);
    NONFAILING(*(uint32_t*)0x20006f48 = 6);
    NONFAILING(*(uint32_t*)0x20006f4c = 0xfffffeff);
    NONFAILING(*(uint32_t*)0x20006f50 = 0xa163);
    NONFAILING(*(uint32_t*)0x20006f54 = -1);
    NONFAILING(*(uint32_t*)0x20006f58 = 5);
    NONFAILING(*(uint32_t*)0x20006f5c = 8);
    NONFAILING(*(uint32_t*)0x20006f60 = 0xec3e);
    NONFAILING(*(uint32_t*)0x20006f64 = 5);
    NONFAILING(*(uint32_t*)0x20006f68 = 4);
    NONFAILING(*(uint32_t*)0x20006f6c = 9);
    NONFAILING(*(uint32_t*)0x20006f70 = 0x10001);
    NONFAILING(*(uint32_t*)0x20006f74 = 8);
    NONFAILING(*(uint32_t*)0x20006f78 = 0x61);
    NONFAILING(*(uint32_t*)0x20006f7c = 9);
    NONFAILING(*(uint32_t*)0x20006f80 = 0x100);
    NONFAILING(*(uint32_t*)0x20006f84 = 4);
    NONFAILING(*(uint32_t*)0x20006f88 = 0xf054);
    NONFAILING(*(uint32_t*)0x20006f8c = 0x101);
    NONFAILING(*(uint32_t*)0x20006f90 = 0x800);
    NONFAILING(*(uint32_t*)0x20006f94 = 3);
    NONFAILING(*(uint32_t*)0x20006f98 = 0);
    NONFAILING(*(uint32_t*)0x20006f9c = 6);
    NONFAILING(*(uint32_t*)0x20006fa0 = -1);
    NONFAILING(*(uint32_t*)0x20006fa4 = 0x92);
    NONFAILING(*(uint32_t*)0x20006fa8 = 0x7fff);
    NONFAILING(*(uint32_t*)0x20006fac = 4);
    NONFAILING(*(uint32_t*)0x20006fb0 = 0x10000);
    NONFAILING(*(uint32_t*)0x20006fb4 = 0);
    NONFAILING(*(uint32_t*)0x20006fb8 = 8);
    NONFAILING(*(uint32_t*)0x20006fbc = 0);
    NONFAILING(*(uint32_t*)0x20006fc0 = 0x100);
    NONFAILING(*(uint32_t*)0x20006fc4 = 0x8000);
    NONFAILING(*(uint32_t*)0x20006fc8 = 3);
    NONFAILING(*(uint32_t*)0x20006fcc = 3);
    NONFAILING(*(uint32_t*)0x20006fd0 = 6);
    NONFAILING(*(uint32_t*)0x20006fd4 = 5);
    NONFAILING(*(uint32_t*)0x20006fd8 = 0xf0000000);
    NONFAILING(*(uint32_t*)0x20006fdc = 0);
    NONFAILING(*(uint32_t*)0x20006fe0 = 3);
    NONFAILING(*(uint32_t*)0x20006fe4 = 1);
    NONFAILING(*(uint32_t*)0x20006fe8 = 4);
    NONFAILING(*(uint32_t*)0x20006fec = 0xffffa5c2);
    NONFAILING(*(uint32_t*)0x20006ff0 = 6);
    NONFAILING(*(uint32_t*)0x20006ff4 = 2);
    NONFAILING(*(uint32_t*)0x20006ff8 = 0x100);
    NONFAILING(*(uint32_t*)0x20006ffc = 0);
    NONFAILING(*(uint32_t*)0x20007000 = 2);
    NONFAILING(*(uint32_t*)0x20007004 = 2);
    NONFAILING(*(uint32_t*)0x20007008 = 0x1000);
    NONFAILING(*(uint32_t*)0x2000700c = 0x68a9739f);
    NONFAILING(*(uint32_t*)0x20007010 = 0xffff);
    NONFAILING(*(uint32_t*)0x20007014 = 0x7fffffff);
    NONFAILING(*(uint32_t*)0x20007018 = 0x7fffffff);
    NONFAILING(*(uint32_t*)0x2000701c = 0);
    NONFAILING(*(uint32_t*)0x20007020 = 0x1f);
    NONFAILING(*(uint32_t*)0x20007024 = 0);
    NONFAILING(*(uint32_t*)0x20007028 = 4);
    NONFAILING(*(uint32_t*)0x2000702c = 8);
    NONFAILING(*(uint32_t*)0x20007030 = 0x56);
    NONFAILING(*(uint32_t*)0x20007034 = 0x80000001);
    NONFAILING(*(uint32_t*)0x20007038 = 1);
    NONFAILING(*(uint32_t*)0x2000703c = 9);
    NONFAILING(*(uint32_t*)0x20007040 = 0x1f);
    NONFAILING(*(uint32_t*)0x20007044 = 1);
    NONFAILING(*(uint32_t*)0x20007048 = 0x5f);
    NONFAILING(*(uint32_t*)0x2000704c = 0x371);
    NONFAILING(*(uint32_t*)0x20007050 = 9);
    NONFAILING(*(uint32_t*)0x20007054 = 0x401);
    NONFAILING(*(uint32_t*)0x20007058 = -1);
    NONFAILING(*(uint32_t*)0x2000705c = 9);
    NONFAILING(*(uint32_t*)0x20007060 = 5);
    NONFAILING(*(uint32_t*)0x20007064 = 0);
    NONFAILING(*(uint32_t*)0x20007068 = 0xd3f);
    NONFAILING(*(uint32_t*)0x2000706c = 0x441);
    NONFAILING(*(uint32_t*)0x20007070 = 4);
    NONFAILING(*(uint32_t*)0x20007074 = 0xffffff80);
    NONFAILING(*(uint32_t*)0x20007078 = 1);
    NONFAILING(*(uint32_t*)0x2000707c = 9);
    NONFAILING(*(uint32_t*)0x20007080 = 6);
    NONFAILING(*(uint32_t*)0x20007084 = 0xfffffff8);
    NONFAILING(*(uint32_t*)0x20007088 = 0x101);
    NONFAILING(*(uint32_t*)0x2000708c = 6);
    NONFAILING(*(uint32_t*)0x20007090 = 1);
    NONFAILING(*(uint32_t*)0x20007094 = 9);
    NONFAILING(*(uint32_t*)0x20007098 = 4);
    NONFAILING(*(uint32_t*)0x2000709c = 0xcf);
    NONFAILING(*(uint32_t*)0x200070a0 = 0);
    NONFAILING(*(uint32_t*)0x200070a4 = 6);
    NONFAILING(*(uint32_t*)0x200070a8 = 0);
    NONFAILING(*(uint32_t*)0x200070ac = 0xf9f3);
    NONFAILING(*(uint32_t*)0x200070b0 = 0);
    NONFAILING(*(uint32_t*)0x200070b4 = 4);
    NONFAILING(*(uint32_t*)0x200070b8 = 0x3f);
    NONFAILING(*(uint32_t*)0x200070bc = 1);
    NONFAILING(*(uint32_t*)0x200070c0 = 9);
    NONFAILING(*(uint32_t*)0x200070c4 = 0x1142);
    NONFAILING(*(uint32_t*)0x200070c8 = 0);
    NONFAILING(*(uint32_t*)0x200070cc = 2);
    NONFAILING(*(uint32_t*)0x200070d0 = 0);
    NONFAILING(*(uint32_t*)0x200070d4 = 0x93a2);
    NONFAILING(*(uint32_t*)0x200070d8 = 4);
    NONFAILING(*(uint32_t*)0x200070dc = 9);
    NONFAILING(*(uint32_t*)0x200070e0 = 8);
    NONFAILING(*(uint32_t*)0x200070e4 = 0x80);
    NONFAILING(*(uint32_t*)0x200070e8 = 0x401);
    NONFAILING(*(uint32_t*)0x200070ec = 0x78);
    NONFAILING(*(uint32_t*)0x200070f0 = 5);
    NONFAILING(*(uint32_t*)0x200070f4 = 0x800);
    NONFAILING(*(uint32_t*)0x200070f8 = 2);
    NONFAILING(*(uint32_t*)0x200070fc = 0x81);
    NONFAILING(*(uint32_t*)0x20007100 = 4);
    NONFAILING(*(uint32_t*)0x20007104 = 0x3ff);
    NONFAILING(*(uint32_t*)0x20007108 = 0x1f);
    NONFAILING(*(uint32_t*)0x2000710c = -1);
    NONFAILING(*(uint32_t*)0x20007110 = 5);
    NONFAILING(*(uint32_t*)0x20007114 = 4);
    NONFAILING(*(uint32_t*)0x20007118 = 0x401);
    NONFAILING(*(uint32_t*)0x2000711c = 0xffffff81);
    NONFAILING(*(uint32_t*)0x20007120 = 1);
    NONFAILING(*(uint32_t*)0x20007124 = 4);
    NONFAILING(*(uint32_t*)0x20007128 = 9);
    NONFAILING(*(uint32_t*)0x2000712c = 9);
    NONFAILING(*(uint32_t*)0x20007130 = 0xb22a);
    NONFAILING(*(uint32_t*)0x20007134 = 0x6ab8);
    NONFAILING(*(uint32_t*)0x20007138 = 0x3ff);
    NONFAILING(*(uint32_t*)0x2000713c = 8);
    NONFAILING(*(uint32_t*)0x20007140 = 0x60f);
    NONFAILING(*(uint32_t*)0x20007144 = 0x8001);
    NONFAILING(*(uint32_t*)0x20007148 = 0xfffffffb);
    NONFAILING(*(uint32_t*)0x2000714c = 0xfa);
    NONFAILING(*(uint32_t*)0x20007150 = 0x8001);
    NONFAILING(*(uint32_t*)0x20007154 = 0x3ff);
    NONFAILING(*(uint32_t*)0x20007158 = 0x200);
    NONFAILING(*(uint32_t*)0x2000715c = 9);
    NONFAILING(*(uint32_t*)0x20007160 = 0x1ff);
    NONFAILING(*(uint32_t*)0x20007164 = 2);
    NONFAILING(*(uint32_t*)0x20007168 = 0x8001);
    NONFAILING(*(uint32_t*)0x2000716c = 0xfff);
    NONFAILING(*(uint32_t*)0x20007170 = -1);
    NONFAILING(*(uint32_t*)0x20007174 = 0x2f);
    NONFAILING(*(uint32_t*)0x20007178 = 0x7ff);
    NONFAILING(*(uint32_t*)0x2000717c = 0xfff);
    NONFAILING(*(uint32_t*)0x20007180 = 0);
    NONFAILING(*(uint32_t*)0x20007184 = 0x28d);
    NONFAILING(*(uint32_t*)0x20007188 = 0x3f);
    NONFAILING(*(uint32_t*)0x2000718c = 0x81);
    NONFAILING(*(uint32_t*)0x20007190 = 7);
    NONFAILING(*(uint32_t*)0x20007194 = 0xa33c);
    NONFAILING(*(uint32_t*)0x20007198 = 9);
    NONFAILING(*(uint32_t*)0x2000719c = 0x9116);
    NONFAILING(*(uint32_t*)0x200071a0 = 0x80);
    NONFAILING(*(uint32_t*)0x200071a4 = 3);
    NONFAILING(*(uint32_t*)0x200071a8 = 7);
    NONFAILING(*(uint32_t*)0x200071ac = 0x7ff);
    NONFAILING(*(uint32_t*)0x200071b0 = 0x10000);
    NONFAILING(*(uint32_t*)0x200071b4 = 0x6b26);
    NONFAILING(*(uint32_t*)0x200071b8 = 6);
    NONFAILING(*(uint32_t*)0x200071bc = 7);
    NONFAILING(*(uint32_t*)0x200071c0 = 0xfffff087);
    NONFAILING(*(uint32_t*)0x200071c4 = 8);
    NONFAILING(*(uint32_t*)0x200071c8 = 3);
    NONFAILING(*(uint32_t*)0x200071cc = 5);
    NONFAILING(*(uint32_t*)0x200071d0 = 0x40);
    NONFAILING(*(uint32_t*)0x200071d4 = 0xfffffff8);
    NONFAILING(*(uint32_t*)0x200071d8 = 3);
    NONFAILING(*(uint32_t*)0x200071dc = 0x101);
    NONFAILING(*(uint32_t*)0x200071e0 = 2);
    NONFAILING(*(uint32_t*)0x200071e4 = 3);
    NONFAILING(*(uint32_t*)0x200071e8 = 0x56fe6350);
    NONFAILING(*(uint32_t*)0x200071ec = 5);
    NONFAILING(*(uint32_t*)0x200071f0 = 0xfffff2da);
    NONFAILING(*(uint32_t*)0x200071f4 = 5);
    NONFAILING(*(uint32_t*)0x200071f8 = 0);
    NONFAILING(*(uint32_t*)0x200071fc = 4);
    NONFAILING(*(uint32_t*)0x20007200 = 2);
    NONFAILING(*(uint32_t*)0x20007204 = 6);
    NONFAILING(*(uint32_t*)0x20007208 = 0x1000);
    NONFAILING(*(uint32_t*)0x2000720c = 2);
    NONFAILING(*(uint32_t*)0x20007210 = 0xd4);
    NONFAILING(*(uint32_t*)0x20007214 = 7);
    NONFAILING(*(uint32_t*)0x20007218 = 9);
    NONFAILING(*(uint32_t*)0x2000721c = 6);
    NONFAILING(*(uint32_t*)0x20007220 = 0x1ff);
    NONFAILING(*(uint32_t*)0x20007224 = 0);
    NONFAILING(*(uint32_t*)0x20007228 = 0x81);
    NONFAILING(*(uint32_t*)0x2000722c = 1);
    NONFAILING(*(uint32_t*)0x20007230 = 1);
    NONFAILING(*(uint32_t*)0x20007234 = 4);
    NONFAILING(*(uint32_t*)0x20007238 = 9);
    NONFAILING(*(uint32_t*)0x2000723c = 7);
    NONFAILING(*(uint32_t*)0x20007240 = 0x80000000);
    NONFAILING(*(uint32_t*)0x20007244 = 0x88ea);
    NONFAILING(*(uint32_t*)0x20007248 = 0x606);
    NONFAILING(*(uint32_t*)0x2000724c = 0);
    NONFAILING(*(uint32_t*)0x20007250 = 0);
    NONFAILING(*(uint32_t*)0x20007254 = 0x400);
    NONFAILING(*(uint32_t*)0x20007258 = 2);
    NONFAILING(*(uint32_t*)0x2000725c = 0x124d7203);
    NONFAILING(*(uint32_t*)0x20007260 = 0x7ff);
    NONFAILING(*(uint32_t*)0x20007264 = 7);
    NONFAILING(*(uint32_t*)0x20007268 = 5);
    NONFAILING(*(uint32_t*)0x2000726c = 8);
    NONFAILING(*(uint32_t*)0x20007270 = 0x1f);
    NONFAILING(*(uint32_t*)0x20007274 = 0x86c);
    NONFAILING(*(uint32_t*)0x20007278 = 7);
    NONFAILING(*(uint32_t*)0x2000727c = 4);
    NONFAILING(*(uint32_t*)0x20007280 = 0xb47);
    NONFAILING(*(uint32_t*)0x20007284 = 8);
    NONFAILING(*(uint32_t*)0x20007288 = 0x1ff);
    NONFAILING(*(uint32_t*)0x2000728c = 0x7fff);
    NONFAILING(*(uint32_t*)0x20007290 = 1);
    NONFAILING(*(uint32_t*)0x20007294 = 0x7fff);
    NONFAILING(*(uint32_t*)0x20007298 = 0x80000000);
    NONFAILING(*(uint32_t*)0x2000729c = 0x100);
    NONFAILING(*(uint32_t*)0x200072a0 = 0x401);
    NONFAILING(*(uint32_t*)0x200072a4 = 3);
    NONFAILING(*(uint32_t*)0x200072a8 = 2);
    NONFAILING(*(uint32_t*)0x200072ac = 5);
    NONFAILING(*(uint32_t*)0x200072b0 = 0x1ff);
    NONFAILING(*(uint32_t*)0x200072b4 = 4);
    NONFAILING(*(uint32_t*)0x200072b8 = 6);
    NONFAILING(*(uint32_t*)0x200072bc = 4);
    NONFAILING(*(uint32_t*)0x200072c0 = -1);
    NONFAILING(*(uint32_t*)0x200072c4 = 9);
    NONFAILING(*(uint32_t*)0x200072c8 = 6);
    NONFAILING(*(uint32_t*)0x200072cc = 0x60dea9ff);
    NONFAILING(*(uint32_t*)0x200072d0 = 0x101);
    NONFAILING(*(uint32_t*)0x200072d4 = 9);
    NONFAILING(*(uint32_t*)0x200072d8 = 2);
    NONFAILING(*(uint32_t*)0x200072dc = 9);
    NONFAILING(*(uint32_t*)0x200072e0 = 0xfff);
    NONFAILING(*(uint32_t*)0x200072e4 = 5);
    NONFAILING(*(uint32_t*)0x200072e8 = 0xc0);
    NONFAILING(*(uint32_t*)0x200072ec = 0x1e);
    NONFAILING(*(uint32_t*)0x200072f0 = 8);
    NONFAILING(*(uint32_t*)0x200072f4 = 8);
    NONFAILING(*(uint32_t*)0x200072f8 = 0);
    NONFAILING(*(uint32_t*)0x200072fc = 1);
    NONFAILING(*(uint32_t*)0x20007300 = 9);
    NONFAILING(*(uint32_t*)0x20007304 = 0xba0);
    NONFAILING(*(uint32_t*)0x20007308 = 0xe38);
    NONFAILING(*(uint32_t*)0x2000730c = 0x44);
    NONFAILING(*(uint32_t*)0x20007310 = 0xfff);
    NONFAILING(*(uint32_t*)0x20007314 = 1);
    NONFAILING(*(uint32_t*)0x20007318 = 9);
    NONFAILING(*(uint32_t*)0x2000731c = 9);
    NONFAILING(*(uint32_t*)0x20007320 = 0x22);
    NONFAILING(*(uint32_t*)0x20007324 = 7);
    NONFAILING(*(uint32_t*)0x20007328 = 6);
    NONFAILING(*(uint32_t*)0x2000732c = 0x1000);
    NONFAILING(*(uint32_t*)0x20007330 = 0x89);
    NONFAILING(*(uint32_t*)0x20007334 = 4);
    NONFAILING(*(uint32_t*)0x20007338 = 0x3ff);
    NONFAILING(*(uint32_t*)0x2000733c = 0);
    NONFAILING(*(uint32_t*)0x20007340 = 6);
    NONFAILING(*(uint32_t*)0x20007344 = 6);
    NONFAILING(*(uint32_t*)0x20007348 = 7);
    NONFAILING(*(uint32_t*)0x2000734c = 6);
    NONFAILING(*(uint32_t*)0x20007350 = 0);
    NONFAILING(*(uint32_t*)0x20007354 = 7);
    NONFAILING(*(uint32_t*)0x20007358 = 3);
    NONFAILING(*(uint32_t*)0x2000735c = 4);
    NONFAILING(*(uint32_t*)0x20007360 = 2);
    NONFAILING(*(uint32_t*)0x20007364 = 9);
    NONFAILING(*(uint32_t*)0x20007368 = 6);
    NONFAILING(*(uint32_t*)0x2000736c = 0xb32d);
    NONFAILING(*(uint32_t*)0x20007370 = 0);
    NONFAILING(*(uint32_t*)0x20007374 = 7);
    NONFAILING(*(uint32_t*)0x20007378 = 0x1e);
    NONFAILING(*(uint32_t*)0x2000737c = 8);
    NONFAILING(*(uint32_t*)0x20007380 = 0x3ff);
    NONFAILING(*(uint32_t*)0x20007384 = 5);
    NONFAILING(*(uint32_t*)0x20007388 = 4);
    NONFAILING(*(uint32_t*)0x2000738c = 8);
    NONFAILING(*(uint32_t*)0x20007390 = 1);
    NONFAILING(*(uint32_t*)0x20007394 = 3);
    NONFAILING(*(uint32_t*)0x20007398 = 0x646);
    NONFAILING(*(uint32_t*)0x2000739c = 3);
    NONFAILING(*(uint32_t*)0x200073a0 = 0x792e5d12);
    NONFAILING(*(uint32_t*)0x200073a4 = 0x10001);
    NONFAILING(*(uint32_t*)0x200073a8 = 0xe72);
    NONFAILING(*(uint32_t*)0x200073ac = 1);
    NONFAILING(*(uint32_t*)0x200073b0 = 0xab7);
    NONFAILING(*(uint32_t*)0x200073b4 = 0x80000001);
    NONFAILING(*(uint32_t*)0x200073b8 = 4);
    NONFAILING(*(uint32_t*)0x200073bc = 9);
    NONFAILING(*(uint32_t*)0x200073c0 = 0x1ff);
    NONFAILING(*(uint32_t*)0x200073c4 = 6);
    NONFAILING(*(uint32_t*)0x200073c8 = 0xedc2);
    NONFAILING(*(uint32_t*)0x200073cc = 7);
    NONFAILING(*(uint32_t*)0x200073d0 = 0x8001);
    NONFAILING(*(uint32_t*)0x200073d4 = 0x1000);
    NONFAILING(*(uint32_t*)0x200073d8 = 0x40);
    NONFAILING(*(uint32_t*)0x200073dc = 7);
    NONFAILING(*(uint32_t*)0x200073e0 = 0x61ab);
    NONFAILING(*(uint32_t*)0x200073e4 = 3);
    NONFAILING(*(uint32_t*)0x200073e8 = 1);
    NONFAILING(*(uint32_t*)0x200073ec = 0x3b99);
    NONFAILING(*(uint32_t*)0x200073f0 = 5);
    NONFAILING(*(uint32_t*)0x200073f4 = 0);
    NONFAILING(*(uint32_t*)0x200073f8 = 1);
    NONFAILING(*(uint32_t*)0x200073fc = 0xfffffff9);
    NONFAILING(*(uint32_t*)0x20007400 = 0x20);
    NONFAILING(*(uint32_t*)0x20007404 = 9);
    NONFAILING(*(uint32_t*)0x20007408 = 0xabf9);
    NONFAILING(*(uint32_t*)0x2000740c = 1);
    NONFAILING(*(uint32_t*)0x20007410 = 0x800);
    NONFAILING(*(uint32_t*)0x20007414 = 0x81);
    NONFAILING(*(uint32_t*)0x20007418 = 0xfffffff8);
    NONFAILING(*(uint32_t*)0x2000741c = 0x10000);
    NONFAILING(*(uint32_t*)0x20007420 = 0xa36d);
    NONFAILING(*(uint32_t*)0x20007424 = 0xb1b);
    NONFAILING(*(uint32_t*)0x20007428 = 4);
    NONFAILING(*(uint32_t*)0x2000742c = 0x1f);
    NONFAILING(*(uint32_t*)0x20007430 = 1);
    NONFAILING(*(uint32_t*)0x20007434 = 0x7ff);
    NONFAILING(*(uint32_t*)0x20007438 = 2);
    NONFAILING(*(uint32_t*)0x2000743c = 1);
    NONFAILING(*(uint32_t*)0x20007440 = 8);
    NONFAILING(*(uint32_t*)0x20007444 = 1);
    NONFAILING(*(uint32_t*)0x20007448 = 0);
    NONFAILING(*(uint32_t*)0x2000744c = 6);
    NONFAILING(*(uint32_t*)0x20007450 = 0xfffffffc);
    NONFAILING(*(uint32_t*)0x20007454 = 0x7c000000);
    NONFAILING(*(uint32_t*)0x20007458 = 0x5513);
    NONFAILING(*(uint32_t*)0x2000745c = 0xff);
    NONFAILING(*(uint32_t*)0x20007460 = 6);
    NONFAILING(*(uint32_t*)0x20007464 = 0x1f);
    NONFAILING(*(uint32_t*)0x20007468 = 2);
    NONFAILING(*(uint32_t*)0x2000746c = 3);
    NONFAILING(*(uint32_t*)0x20007470 = 9);
    NONFAILING(*(uint32_t*)0x20007474 = 0);
    NONFAILING(*(uint32_t*)0x20007478 = 0xfff);
    NONFAILING(*(uint32_t*)0x2000747c = 0xc67);
    NONFAILING(*(uint32_t*)0x20007480 = 0x7fffffff);
    NONFAILING(*(uint32_t*)0x20007484 = 0xfff);
    NONFAILING(*(uint32_t*)0x20007488 = 1);
    NONFAILING(*(uint32_t*)0x2000748c = 5);
    NONFAILING(*(uint32_t*)0x20007490 = 0x80);
    NONFAILING(*(uint32_t*)0x20007494 = 5);
    NONFAILING(*(uint32_t*)0x20007498 = 0x80);
    NONFAILING(*(uint32_t*)0x2000749c = 0x3ff);
    NONFAILING(*(uint32_t*)0x200074a0 = 0x3ff);
    NONFAILING(*(uint32_t*)0x200074a4 = 0xfffffffd);
    NONFAILING(*(uint32_t*)0x200074a8 = 0xc0);
    NONFAILING(*(uint32_t*)0x200074ac = 0x2a38);
    NONFAILING(*(uint32_t*)0x200074b0 = 4);
    NONFAILING(*(uint32_t*)0x200074b4 = 0x9d);
    NONFAILING(*(uint32_t*)0x200074b8 = 0x10000);
    NONFAILING(*(uint32_t*)0x200074bc = 0x10000000);
    NONFAILING(*(uint32_t*)0x200074c0 = 9);
    NONFAILING(*(uint32_t*)0x200074c4 = 0xf58);
    NONFAILING(*(uint32_t*)0x200074c8 = 0x20);
    NONFAILING(*(uint32_t*)0x200074cc = 0);
    NONFAILING(*(uint32_t*)0x200074d0 = 0xfff);
    NONFAILING(*(uint32_t*)0x200074d4 = 0x7ff);
    NONFAILING(*(uint32_t*)0x200074d8 = 2);
    NONFAILING(*(uint32_t*)0x200074dc = -1);
    NONFAILING(*(uint32_t*)0x200074e0 = 0x8001);
    NONFAILING(*(uint32_t*)0x200074e4 = 0x80);
    NONFAILING(*(uint32_t*)0x200074e8 = 0x7ff);
    NONFAILING(*(uint32_t*)0x200074ec = 1);
    NONFAILING(*(uint32_t*)0x200074f0 = 8);
    NONFAILING(*(uint32_t*)0x200074f4 = 5);
    NONFAILING(*(uint32_t*)0x200074f8 = 0xb0);
    NONFAILING(*(uint32_t*)0x200074fc = 7);
    NONFAILING(*(uint32_t*)0x20007500 = 0xa7);
    NONFAILING(*(uint32_t*)0x20007504 = 3);
    NONFAILING(*(uint32_t*)0x20007508 = 3);
    NONFAILING(*(uint32_t*)0x2000750c = 6);
    NONFAILING(*(uint32_t*)0x20007510 = 8);
    NONFAILING(*(uint32_t*)0x20007514 = 0x80000000);
    NONFAILING(*(uint32_t*)0x20007518 = 0xc84d);
    NONFAILING(*(uint32_t*)0x2000751c = 0xbb);
    NONFAILING(*(uint32_t*)0x20007520 = 0x10000);
    NONFAILING(*(uint32_t*)0x20007524 = 7);
    NONFAILING(*(uint32_t*)0x20007528 = 2);
    NONFAILING(*(uint32_t*)0x2000752c = 1);
    NONFAILING(*(uint32_t*)0x20007530 = 2);
    NONFAILING(*(uint32_t*)0x20007534 = 0x81);
    NONFAILING(*(uint32_t*)0x20007538 = 0);
    NONFAILING(*(uint32_t*)0x2000753c = 4);
    NONFAILING(*(uint32_t*)0x20007540 = 0x30);
    NONFAILING(*(uint32_t*)0x20007544 = 7);
    NONFAILING(*(uint32_t*)0x20007548 = 8);
    NONFAILING(*(uint32_t*)0x2000754c = 0x80);
    NONFAILING(*(uint32_t*)0x20007550 = 1);
    NONFAILING(*(uint32_t*)0x20007554 = 7);
    NONFAILING(*(uint32_t*)0x20007558 = 2);
    NONFAILING(*(uint32_t*)0x2000755c = 2);
    NONFAILING(*(uint32_t*)0x20007560 = 0xfff);
    NONFAILING(*(uint32_t*)0x20007564 = 3);
    NONFAILING(*(uint32_t*)0x20007568 = 0x80000000);
    NONFAILING(*(uint32_t*)0x2000756c = 5);
    NONFAILING(*(uint32_t*)0x20007570 = 2);
    NONFAILING(*(uint32_t*)0x20007574 = 0x6e);
    NONFAILING(*(uint32_t*)0x20007578 = 8);
    NONFAILING(*(uint32_t*)0x2000757c = 0x10000);
    NONFAILING(*(uint32_t*)0x20007580 = 5);
    NONFAILING(*(uint32_t*)0x20007584 = 3);
    NONFAILING(*(uint32_t*)0x20007588 = 7);
    NONFAILING(*(uint32_t*)0x2000758c = 0x8001);
    NONFAILING(*(uint32_t*)0x20007590 = 2);
    NONFAILING(*(uint32_t*)0x20007594 = -1);
    NONFAILING(*(uint32_t*)0x20007598 = 0xfffff000);
    NONFAILING(*(uint32_t*)0x2000759c = 0x23);
    NONFAILING(*(uint32_t*)0x200075a0 = 3);
    NONFAILING(*(uint32_t*)0x200075a4 = 4);
    NONFAILING(*(uint32_t*)0x200075a8 = 0x709);
    NONFAILING(*(uint32_t*)0x200075ac = 0xffff);
    NONFAILING(*(uint32_t*)0x200075b0 = 0x31);
    NONFAILING(*(uint32_t*)0x200075b4 = 0xc24);
    NONFAILING(*(uint32_t*)0x200075b8 = 3);
    NONFAILING(*(uint32_t*)0x200075bc = 0);
    NONFAILING(*(uint32_t*)0x200075c0 = 0x59);
    NONFAILING(*(uint32_t*)0x200075c4 = 9);
    NONFAILING(*(uint32_t*)0x200075c8 = 0xffff8000);
    NONFAILING(*(uint32_t*)0x200075cc = 0x1ff);
    NONFAILING(*(uint32_t*)0x200075d0 = 0x81);
    NONFAILING(*(uint32_t*)0x200075d4 = 0);
    NONFAILING(*(uint32_t*)0x200075d8 = 8);
    NONFAILING(*(uint32_t*)0x200075dc = 2);
    NONFAILING(*(uint32_t*)0x200075e0 = 0);
    NONFAILING(*(uint32_t*)0x200075e4 = 4);
    NONFAILING(*(uint32_t*)0x200075e8 = 0);
    NONFAILING(*(uint32_t*)0x200075ec = 9);
    NONFAILING(*(uint32_t*)0x200075f0 = 0);
    NONFAILING(*(uint32_t*)0x200075f4 = 0x80);
    NONFAILING(*(uint32_t*)0x200075f8 = 0);
    NONFAILING(*(uint32_t*)0x200075fc = 0x3e5);
    NONFAILING(*(uint32_t*)0x20007600 = 0x48a);
    NONFAILING(*(uint32_t*)0x20007604 = 2);
    NONFAILING(*(uint32_t*)0x20007608 = 0x8000);
    NONFAILING(*(uint32_t*)0x2000760c = 0x10001);
    NONFAILING(*(uint32_t*)0x20007610 = 2);
    NONFAILING(*(uint32_t*)0x20007614 = 9);
    NONFAILING(*(uint32_t*)0x20007618 = 0x81);
    NONFAILING(*(uint32_t*)0x2000761c = 7);
    NONFAILING(*(uint32_t*)0x20007620 = 0x88);
    NONFAILING(*(uint32_t*)0x20007624 = 3);
    NONFAILING(*(uint32_t*)0x20007628 = 0xd1);
    NONFAILING(*(uint32_t*)0x2000762c = 0x72);
    NONFAILING(*(uint32_t*)0x20007630 = 0x80);
    NONFAILING(*(uint32_t*)0x20007634 = 2);
    NONFAILING(*(uint32_t*)0x20007638 = 1);
    NONFAILING(*(uint32_t*)0x2000763c = 6);
    NONFAILING(*(uint32_t*)0x20007640 = 0xfffffffc);
    NONFAILING(*(uint32_t*)0x20007644 = 1);
    NONFAILING(*(uint32_t*)0x20007648 = 4);
    NONFAILING(*(uint32_t*)0x2000764c = 8);
    NONFAILING(*(uint32_t*)0x20007650 = 4);
    NONFAILING(*(uint32_t*)0x20007654 = 8);
    NONFAILING(*(uint32_t*)0x20007658 = 0x101);
    NONFAILING(*(uint32_t*)0x2000765c = 3);
    NONFAILING(*(uint32_t*)0x20007660 = 8);
    NONFAILING(*(uint32_t*)0x20007664 = 6);
    NONFAILING(*(uint32_t*)0x20007668 = 0xfffffff9);
    NONFAILING(*(uint32_t*)0x2000766c = 0x8000);
    NONFAILING(*(uint32_t*)0x20007670 = 0x8001);
    NONFAILING(*(uint32_t*)0x20007674 = 0x800);
    NONFAILING(*(uint32_t*)0x20007678 = 1);
    NONFAILING(*(uint32_t*)0x2000767c = 0x90);
    NONFAILING(*(uint32_t*)0x20007680 = 0xbc);
    NONFAILING(*(uint32_t*)0x20007684 = 3);
    NONFAILING(*(uint32_t*)0x20007688 = 0x9308);
    NONFAILING(*(uint32_t*)0x2000768c = 5);
    NONFAILING(*(uint32_t*)0x20007690 = 4);
    NONFAILING(*(uint32_t*)0x20007694 = 4);
    NONFAILING(*(uint32_t*)0x20007698 = 0xf800);
    NONFAILING(*(uint32_t*)0x2000769c = 5);
    NONFAILING(*(uint32_t*)0x200076a0 = 5);
    NONFAILING(*(uint32_t*)0x200076a4 = 3);
    NONFAILING(*(uint32_t*)0x200076a8 = 0);
    NONFAILING(*(uint32_t*)0x200076ac = 0x9f5);
    NONFAILING(*(uint32_t*)0x200076b0 = 0x401);
    NONFAILING(*(uint32_t*)0x200076b4 = 0x5d);
    NONFAILING(*(uint32_t*)0x200076b8 = 8);
    NONFAILING(*(uint32_t*)0x200076bc = 0x80);
    NONFAILING(*(uint32_t*)0x200076c0 = 4);
    NONFAILING(*(uint32_t*)0x200076c4 = 6);
    NONFAILING(*(uint32_t*)0x200076c8 = 0x3ff);
    NONFAILING(*(uint32_t*)0x200076cc = 0x6eb0);
    NONFAILING(*(uint32_t*)0x200076d0 = 6);
    NONFAILING(*(uint32_t*)0x200076d4 = 1);
    NONFAILING(*(uint32_t*)0x200076d8 = 0x400);
    NONFAILING(*(uint32_t*)0x200076dc = 0x100);
    NONFAILING(*(uint32_t*)0x200076e0 = 0x10001);
    NONFAILING(*(uint32_t*)0x200076e4 = 0x1000);
    NONFAILING(*(uint32_t*)0x200076e8 = 0x7fff);
    NONFAILING(*(uint32_t*)0x200076ec = 0xb4a5);
    NONFAILING(*(uint32_t*)0x200076f0 = 0x7fffffff);
    NONFAILING(*(uint32_t*)0x200076f4 = 0x7fffffff);
    NONFAILING(*(uint32_t*)0x200076f8 = 8);
    NONFAILING(*(uint32_t*)0x200076fc = 0);
    NONFAILING(*(uint32_t*)0x20007700 = 0xfffff800);
    NONFAILING(*(uint32_t*)0x20007704 = 0x11a);
    NONFAILING(*(uint32_t*)0x20007708 = 0x7fff);
    NONFAILING(*(uint32_t*)0x2000770c = 2);
    NONFAILING(*(uint32_t*)0x20007710 = 0);
    NONFAILING(*(uint32_t*)0x20007714 = 0);
    NONFAILING(*(uint32_t*)0x20007718 = 0x8001);
    NONFAILING(*(uint32_t*)0x2000771c = 0);
    NONFAILING(*(uint32_t*)0x20007720 = 7);
    NONFAILING(*(uint32_t*)0x20007724 = 0xa762);
    NONFAILING(*(uint32_t*)0x20007728 = 1);
    NONFAILING(*(uint32_t*)0x2000772c = 0x400);
    NONFAILING(*(uint32_t*)0x20007730 = 9);
    NONFAILING(*(uint32_t*)0x20007734 = 0);
    NONFAILING(*(uint32_t*)0x20007738 = 4);
    NONFAILING(*(uint32_t*)0x2000773c = 3);
    NONFAILING(*(uint32_t*)0x20007740 = 0);
    NONFAILING(*(uint32_t*)0x20007744 = 3);
    NONFAILING(*(uint32_t*)0x20007748 = 5);
    NONFAILING(*(uint32_t*)0x2000774c = 0x81);
    NONFAILING(*(uint32_t*)0x20007750 = 0x1f);
    NONFAILING(*(uint32_t*)0x20007754 = 0x7f);
    NONFAILING(*(uint32_t*)0x20007758 = 2);
    NONFAILING(*(uint32_t*)0x2000775c = 5);
    NONFAILING(*(uint32_t*)0x20007760 = 0x1ff);
    NONFAILING(*(uint32_t*)0x20007764 = 6);
    NONFAILING(*(uint32_t*)0x20007768 = -1);
    NONFAILING(*(uint32_t*)0x2000776c = 0x7f);
    NONFAILING(*(uint32_t*)0x20007770 = 0x400);
    NONFAILING(*(uint32_t*)0x20007774 = 9);
    NONFAILING(*(uint32_t*)0x20007778 = 2);
    NONFAILING(*(uint32_t*)0x2000777c = 6);
    NONFAILING(*(uint32_t*)0x20007780 = 6);
    NONFAILING(*(uint32_t*)0x20007784 = 6);
    NONFAILING(*(uint32_t*)0x20007788 = 0x95);
    NONFAILING(*(uint32_t*)0x2000778c = 2);
    NONFAILING(*(uint32_t*)0x20007790 = 0);
    NONFAILING(*(uint32_t*)0x20007794 = 0);
    NONFAILING(*(uint32_t*)0x20007798 = 0x40);
    NONFAILING(*(uint32_t*)0x2000779c = 4);
    NONFAILING(*(uint32_t*)0x200077a0 = 6);
    NONFAILING(*(uint32_t*)0x200077a4 = 4);
    NONFAILING(*(uint32_t*)0x200077a8 = 2);
    NONFAILING(*(uint32_t*)0x200077ac = 8);
    NONFAILING(*(uint32_t*)0x200077b0 = 5);
    NONFAILING(*(uint32_t*)0x200077b4 = 0xa49b);
    NONFAILING(*(uint32_t*)0x200077b8 = 0x322e);
    NONFAILING(*(uint32_t*)0x200077bc = 0x4707);
    NONFAILING(*(uint32_t*)0x200077c0 = 9);
    NONFAILING(*(uint32_t*)0x200077c4 = 0x4ce2);
    NONFAILING(*(uint32_t*)0x200077c8 = 3);
    NONFAILING(*(uint32_t*)0x200077cc = 6);
    NONFAILING(*(uint32_t*)0x200077d0 = 0x101);
    NONFAILING(*(uint32_t*)0x200077d4 = 0x101);
    NONFAILING(*(uint32_t*)0x200077d8 = 0xffffff00);
    NONFAILING(*(uint32_t*)0x200077dc = 4);
    NONFAILING(*(uint32_t*)0x200077e0 = 8);
    NONFAILING(*(uint32_t*)0x200077e4 = 0x80000001);
    NONFAILING(*(uint32_t*)0x200077e8 = 6);
    NONFAILING(*(uint32_t*)0x200077ec = 0xa118);
    NONFAILING(*(uint32_t*)0x200077f0 = 0x9ffb);
    NONFAILING(*(uint32_t*)0x200077f4 = 6);
    NONFAILING(*(uint32_t*)0x200077f8 = 6);
    NONFAILING(*(uint32_t*)0x200077fc = 0x100);
    NONFAILING(*(uint32_t*)0x20007800 = 0xffff);
    NONFAILING(*(uint32_t*)0x20007804 = 0xda);
    NONFAILING(*(uint32_t*)0x20007808 = 9);
    NONFAILING(*(uint32_t*)0x2000780c = 2);
    NONFAILING(*(uint32_t*)0x20007810 = 0x80000000);
    NONFAILING(*(uint32_t*)0x20007814 = 0x1a);
    NONFAILING(*(uint32_t*)0x20007818 = 9);
    NONFAILING(*(uint32_t*)0x2000781c = 0x800);
    NONFAILING(*(uint32_t*)0x20007820 = 2);
    NONFAILING(*(uint32_t*)0x20007824 = 0xc8e6);
    NONFAILING(*(uint32_t*)0x20007828 = 0xff9);
    NONFAILING(*(uint32_t*)0x2000782c = 0x7f);
    NONFAILING(*(uint32_t*)0x20007830 = 0xc2);
    NONFAILING(*(uint32_t*)0x20007834 = 4);
    NONFAILING(*(uint32_t*)0x20007838 = 3);
    NONFAILING(*(uint32_t*)0x2000783c = 0x5f2d);
    NONFAILING(*(uint32_t*)0x20007840 = 0xfffffe40);
    NONFAILING(*(uint32_t*)0x20007844 = 7);
    NONFAILING(*(uint32_t*)0x20007848 = 0x80000001);
    NONFAILING(*(uint32_t*)0x2000784c = 0xfffffff7);
    NONFAILING(*(uint32_t*)0x20007850 = 0x80);
    NONFAILING(*(uint32_t*)0x20007854 = 9);
    NONFAILING(*(uint32_t*)0x20007858 = 0);
    NONFAILING(*(uint32_t*)0x2000785c = 0x10001);
    NONFAILING(*(uint32_t*)0x20007860 = 4);
    NONFAILING(*(uint32_t*)0x20007864 = 0x385);
    NONFAILING(*(uint32_t*)0x20007868 = 0xffffff7f);
    NONFAILING(*(uint32_t*)0x2000786c = 0x800);
    NONFAILING(*(uint32_t*)0x20007870 = 9);
    NONFAILING(*(uint32_t*)0x20007874 = 9);
    NONFAILING(*(uint32_t*)0x20007878 = 2);
    NONFAILING(*(uint32_t*)0x2000787c = 6);
    NONFAILING(*(uint32_t*)0x20007880 = 0);
    NONFAILING(*(uint32_t*)0x20007884 = 0xff);
    NONFAILING(*(uint32_t*)0x20007888 = 4);
    NONFAILING(*(uint32_t*)0x2000788c = 4);
    NONFAILING(*(uint32_t*)0x20007890 = 8);
    NONFAILING(*(uint32_t*)0x20007894 = 6);
    NONFAILING(*(uint32_t*)0x20007898 = 0);
    NONFAILING(*(uint32_t*)0x2000789c = 0x10000);
    NONFAILING(*(uint32_t*)0x200078a0 = 0x7fffffff);
    NONFAILING(*(uint32_t*)0x200078a4 = 9);
    NONFAILING(*(uint32_t*)0x200078a8 = 1);
    NONFAILING(*(uint32_t*)0x200078ac = 0);
    NONFAILING(*(uint32_t*)0x200078b0 = 0);
    NONFAILING(*(uint32_t*)0x200078b4 = 0x200);
    NONFAILING(*(uint32_t*)0x200078b8 = 1);
    NONFAILING(*(uint32_t*)0x200078bc = 1);
    NONFAILING(*(uint32_t*)0x200078c0 = 0x3ff);
    NONFAILING(*(uint32_t*)0x200078c4 = 0);
    NONFAILING(*(uint32_t*)0x200078c8 = 8);
    NONFAILING(*(uint32_t*)0x200078cc = 0x7fffffff);
    NONFAILING(*(uint32_t*)0x200078d0 = 0x81);
    NONFAILING(*(uint32_t*)0x200078d4 = 0xb9);
    NONFAILING(*(uint32_t*)0x200078d8 = 3);
    NONFAILING(*(uint32_t*)0x200078dc = 6);
    NONFAILING(*(uint32_t*)0x200078e0 = 0x7a3);
    NONFAILING(*(uint32_t*)0x200078e4 = 0x11);
    NONFAILING(*(uint32_t*)0x200078e8 = 0x80000000);
    NONFAILING(*(uint32_t*)0x200078ec = 5);
    NONFAILING(*(uint32_t*)0x200078f0 = 0xb49);
    NONFAILING(*(uint32_t*)0x200078f4 = 0x800);
    NONFAILING(*(uint32_t*)0x200078f8 = 3);
    NONFAILING(*(uint32_t*)0x200078fc = 0);
    NONFAILING(*(uint32_t*)0x20007900 = 4);
    NONFAILING(*(uint32_t*)0x20007904 = 1);
    NONFAILING(*(uint32_t*)0x20007908 = 3);
    NONFAILING(*(uint32_t*)0x2000790c = 0x7f);
    NONFAILING(*(uint32_t*)0x20007910 = 3);
    NONFAILING(*(uint32_t*)0x20007914 = 1);
    NONFAILING(*(uint32_t*)0x20007918 = 5);
    NONFAILING(*(uint32_t*)0x2000791c = 0x1620baeb);
    NONFAILING(*(uint32_t*)0x20007920 = 1);
    NONFAILING(*(uint32_t*)0x20007924 = -1);
    NONFAILING(*(uint32_t*)0x20007928 = 0x7812ae3a);
    NONFAILING(*(uint32_t*)0x2000792c = 0x1000);
    NONFAILING(*(uint32_t*)0x20007930 = 0x7fffffff);
    NONFAILING(*(uint32_t*)0x20007934 = 0x401);
    NONFAILING(*(uint32_t*)0x20007938 = 7);
    NONFAILING(*(uint32_t*)0x2000793c = 0x600);
    NONFAILING(*(uint32_t*)0x20007940 = 0);
    NONFAILING(*(uint32_t*)0x20007944 = 0xffffffc0);
    NONFAILING(*(uint32_t*)0x20007948 = 0xd95);
    NONFAILING(*(uint32_t*)0x2000794c = 9);
    NONFAILING(*(uint32_t*)0x20007950 = 0x8000);
    NONFAILING(*(uint32_t*)0x20007954 = 0x3f);
    NONFAILING(*(uint32_t*)0x20007958 = 0x1e4);
    NONFAILING(*(uint32_t*)0x2000795c = 0x200);
    NONFAILING(*(uint32_t*)0x20007960 = 0x80000000);
    NONFAILING(*(uint32_t*)0x20007964 = 0xa06);
    NONFAILING(*(uint32_t*)0x20007968 = 1);
    NONFAILING(*(uint32_t*)0x2000796c = 8);
    NONFAILING(*(uint32_t*)0x20007970 = 3);
    NONFAILING(*(uint32_t*)0x20007974 = 0x7f);
    NONFAILING(*(uint32_t*)0x20007978 = 4);
    NONFAILING(*(uint32_t*)0x2000797c = 9);
    NONFAILING(*(uint32_t*)0x20007980 = 5);
    NONFAILING(*(uint32_t*)0x20007984 = 6);
    NONFAILING(*(uint32_t*)0x20007988 = 0);
    NONFAILING(*(uint32_t*)0x2000798c = 4);
    NONFAILING(*(uint32_t*)0x20007990 = 0xffff);
    NONFAILING(*(uint32_t*)0x20007994 = -1);
    NONFAILING(*(uint32_t*)0x20007998 = 0x80a1);
    NONFAILING(*(uint32_t*)0x2000799c = 0xfff);
    NONFAILING(*(uint32_t*)0x200079a0 = 0xe35);
    NONFAILING(*(uint32_t*)0x200079a4 = 9);
    NONFAILING(*(uint32_t*)0x200079a8 = 0xbe);
    NONFAILING(*(uint32_t*)0x200079ac = 0x81);
    NONFAILING(*(uint32_t*)0x200079b0 = 0);
    NONFAILING(*(uint32_t*)0x200079b4 = 7);
    NONFAILING(*(uint32_t*)0x200079b8 = 6);
    NONFAILING(*(uint32_t*)0x200079bc = 0x10001);
    NONFAILING(*(uint32_t*)0x200079c0 = 0x10000);
    NONFAILING(*(uint32_t*)0x200079c4 = 0x33);
    NONFAILING(*(uint32_t*)0x200079c8 = 0x800);
    NONFAILING(*(uint32_t*)0x200079cc = 0x401);
    NONFAILING(*(uint32_t*)0x200079d0 = 3);
    NONFAILING(*(uint32_t*)0x200079d4 = -1);
    NONFAILING(*(uint32_t*)0x200079d8 = 0x101);
    NONFAILING(*(uint32_t*)0x200079dc = 0x51f);
    NONFAILING(*(uint32_t*)0x200079e0 = 0x10000);
    NONFAILING(*(uint32_t*)0x200079e4 = 0x7fff);
    NONFAILING(*(uint32_t*)0x200079e8 = 0x36);
    NONFAILING(*(uint32_t*)0x200079ec = 4);
    NONFAILING(*(uint32_t*)0x200079f0 = 0x101);
    NONFAILING(*(uint32_t*)0x200079f4 = 9);
    NONFAILING(*(uint32_t*)0x200079f8 = 0x3f);
    NONFAILING(*(uint32_t*)0x200079fc = 4);
    NONFAILING(*(uint32_t*)0x20007a00 = 0);
    NONFAILING(*(uint32_t*)0x20007a04 = 1);
    NONFAILING(*(uint32_t*)0x20007a08 = 0x8000);
    NONFAILING(*(uint32_t*)0x20007a0c = 0xe2);
    NONFAILING(*(uint32_t*)0x20007a10 = 0xd38);
    NONFAILING(*(uint32_t*)0x20007a14 = 0x3f);
    NONFAILING(*(uint32_t*)0x20007a18 = 0x80000000);
    NONFAILING(*(uint32_t*)0x20007a1c = 7);
    NONFAILING(*(uint32_t*)0x20007a20 = 2);
    NONFAILING(*(uint32_t*)0x20007a24 = 8);
    NONFAILING(*(uint32_t*)0x20007a28 = 0x80000000);
    NONFAILING(*(uint32_t*)0x20007a2c = 6);
    NONFAILING(*(uint32_t*)0x20007a30 = 8);
    NONFAILING(*(uint16_t*)0x20007a34 = 1);
    NONFAILING(*(uint16_t*)0x20007a36 = 0);
    NONFAILING(*(uint16_t*)0x20007a38 = 3);
    NONFAILING(*(uint16_t*)0x20007a3a = 0);
    NONFAILING(*(uint16_t*)0x20007a3c = 2);
    NONFAILING(*(uint16_t*)0x20007a3e = 0);
    NONFAILING(*(uint16_t*)0x20007a40 = 3);
    NONFAILING(*(uint16_t*)0x20007a42 = 0);
    NONFAILING(*(uint16_t*)0x20007a44 = 1);
    NONFAILING(*(uint16_t*)0x20007a46 = 0);
    NONFAILING(*(uint16_t*)0x20007a48 = 3);
    NONFAILING(*(uint16_t*)0x20007a4a = 1);
    NONFAILING(*(uint16_t*)0x20007a4c = 0);
    NONFAILING(*(uint16_t*)0x20007a4e = 1);
    NONFAILING(*(uint16_t*)0x20007a50 = 5);
    NONFAILING(*(uint16_t*)0x20007a52 = 1);
    NONFAILING(*(uint16_t*)0x20007a54 = 0);
    NONFAILING(*(uint16_t*)0x20007a56 = 1);
    NONFAILING(*(uint16_t*)0x20007a58 = 3);
    NONFAILING(*(uint16_t*)0x20007a5a = 0);
    NONFAILING(*(uint16_t*)0x20007a5c = 0);
    NONFAILING(*(uint16_t*)0x20007a5e = 0);
    NONFAILING(*(uint16_t*)0x20007a60 = 5);
    NONFAILING(*(uint16_t*)0x20007a62 = 1);
    NONFAILING(*(uint16_t*)0x20007a64 = 2);
    NONFAILING(*(uint16_t*)0x20007a66 = 0);
    NONFAILING(*(uint16_t*)0x20007a68 = 1);
    NONFAILING(*(uint16_t*)0x20007a6a = 1);
    NONFAILING(*(uint16_t*)0x20007a6c = 1);
    NONFAILING(*(uint16_t*)0x20007a6e = 1);
    NONFAILING(*(uint16_t*)0x20007a70 = 1);
    NONFAILING(*(uint16_t*)0x20007a72 = 0);
    NONFAILING(*(uint16_t*)0x20007a74 = 5);
    NONFAILING(*(uint16_t*)0x20007a76 = 0);
    NONFAILING(*(uint16_t*)0x20007a78 = 3);
    NONFAILING(*(uint16_t*)0x20007a7a = 1);
    NONFAILING(*(uint16_t*)0x20007a7c = 1);
    NONFAILING(*(uint16_t*)0x20007a7e = 0);
    NONFAILING(*(uint16_t*)0x20007a80 = 1);
    NONFAILING(*(uint16_t*)0x20007a82 = 0);
    NONFAILING(*(uint16_t*)0x20007a84 = 2);
    NONFAILING(*(uint16_t*)0x20007a86 = 0);
    NONFAILING(*(uint16_t*)0x20007a88 = 0xd820);
    NONFAILING(*(uint16_t*)0x20007a8a = 1);
    NONFAILING(*(uint16_t*)0x20007a8c = 1);
    NONFAILING(*(uint16_t*)0x20007a8e = 0);
    NONFAILING(*(uint16_t*)0x20007a90 = 0);
    NONFAILING(*(uint16_t*)0x20007a92 = 1);
    NONFAILING(*(uint16_t*)0x20007a94 = 1);
    NONFAILING(*(uint16_t*)0x20007a96 = 0);
    NONFAILING(*(uint16_t*)0x20007a98 = 5);
    NONFAILING(*(uint16_t*)0x20007a9a = 1);
    NONFAILING(*(uint16_t*)0x20007a9c = 1);
    NONFAILING(*(uint16_t*)0x20007a9e = 1);
    NONFAILING(*(uint16_t*)0x20007aa0 = 5);
    NONFAILING(*(uint16_t*)0x20007aa2 = 0);
    NONFAILING(*(uint16_t*)0x20007aa4 = 5);
    NONFAILING(*(uint16_t*)0x20007aa6 = 1);
    NONFAILING(*(uint16_t*)0x20007aa8 = 5);
    NONFAILING(*(uint16_t*)0x20007aaa = 1);
    NONFAILING(*(uint16_t*)0x20007aac = 0);
    NONFAILING(*(uint16_t*)0x20007aae = 0);
    NONFAILING(*(uint16_t*)0x20007ab0 = 4);
    NONFAILING(*(uint16_t*)0x20007ab2 = 0);
    NONFAILING(*(uint16_t*)0x20007ab4 = 0);
    NONFAILING(*(uint16_t*)0x20007ab6 = 0);
    NONFAILING(*(uint16_t*)0x20007ab8 = 1);
    NONFAILING(*(uint16_t*)0x20007aba = 1);
    NONFAILING(*(uint16_t*)0x20007abc = 5);
    NONFAILING(*(uint16_t*)0x20007abe = 0);
    NONFAILING(*(uint16_t*)0x20007ac0 = 1);
    NONFAILING(*(uint16_t*)0x20007ac2 = 0);
    NONFAILING(*(uint16_t*)0x20007ac4 = 4);
    NONFAILING(*(uint16_t*)0x20007ac6 = 0);
    NONFAILING(*(uint16_t*)0x20007ac8 = 5);
    NONFAILING(*(uint16_t*)0x20007aca = 1);
    NONFAILING(*(uint16_t*)0x20007acc = 5);
    NONFAILING(*(uint16_t*)0x20007ace = 0);
    NONFAILING(*(uint16_t*)0x20007ad0 = 4);
    NONFAILING(*(uint16_t*)0x20007ad2 = 1);
    NONFAILING(*(uint16_t*)0x20007ad4 = 3);
    NONFAILING(*(uint16_t*)0x20007ad6 = 0);
    NONFAILING(*(uint16_t*)0x20007ad8 = 3);
    NONFAILING(*(uint16_t*)0x20007ada = 1);
    NONFAILING(*(uint16_t*)0x20007adc = 2);
    NONFAILING(*(uint16_t*)0x20007ade = 1);
    NONFAILING(*(uint16_t*)0x20007ae0 = 4);
    NONFAILING(*(uint16_t*)0x20007ae2 = 1);
    NONFAILING(*(uint16_t*)0x20007ae4 = 0);
    NONFAILING(*(uint16_t*)0x20007ae6 = 1);
    NONFAILING(*(uint16_t*)0x20007ae8 = 3);
    NONFAILING(*(uint16_t*)0x20007aea = 0);
    NONFAILING(*(uint16_t*)0x20007aec = 3);
    NONFAILING(*(uint16_t*)0x20007aee = 1);
    NONFAILING(*(uint16_t*)0x20007af0 = 1);
    NONFAILING(*(uint16_t*)0x20007af2 = 1);
    NONFAILING(*(uint16_t*)0x20007af4 = 0);
    NONFAILING(*(uint16_t*)0x20007af6 = 0);
    NONFAILING(*(uint16_t*)0x20007af8 = 3);
    NONFAILING(*(uint16_t*)0x20007afa = 1);
    NONFAILING(*(uint16_t*)0x20007afc = 5);
    NONFAILING(*(uint16_t*)0x20007afe = 1);
    NONFAILING(*(uint16_t*)0x20007b00 = 0);
    NONFAILING(*(uint16_t*)0x20007b02 = 0);
    NONFAILING(*(uint16_t*)0x20007b04 = 2);
    NONFAILING(*(uint16_t*)0x20007b06 = 0);
    NONFAILING(*(uint16_t*)0x20007b08 = 2);
    NONFAILING(*(uint16_t*)0x20007b0a = 1);
    NONFAILING(*(uint16_t*)0x20007b0c = 1);
    NONFAILING(*(uint16_t*)0x20007b0e = 0);
    NONFAILING(*(uint16_t*)0x20007b10 = 2);
    NONFAILING(*(uint16_t*)0x20007b12 = 1);
    NONFAILING(*(uint16_t*)0x20007b14 = 1);
    NONFAILING(*(uint16_t*)0x20007b16 = 1);
    NONFAILING(*(uint16_t*)0x20007b18 = 0);
    NONFAILING(*(uint16_t*)0x20007b1a = 0);
    NONFAILING(*(uint16_t*)0x20007b1c = 5);
    NONFAILING(*(uint16_t*)0x20007b1e = 0);
    NONFAILING(*(uint16_t*)0x20007b20 = 3);
    NONFAILING(*(uint16_t*)0x20007b22 = 1);
    NONFAILING(*(uint16_t*)0x20007b24 = 1);
    NONFAILING(*(uint16_t*)0x20007b26 = 0);
    NONFAILING(*(uint16_t*)0x20007b28 = 2);
    NONFAILING(*(uint16_t*)0x20007b2a = 0);
    NONFAILING(*(uint16_t*)0x20007b2c = 5);
    NONFAILING(*(uint16_t*)0x20007b2e = 1);
    NONFAILING(*(uint16_t*)0x20007b30 = 3);
    NONFAILING(*(uint16_t*)0x20007b32 = 1);
    NONFAILING(*(uint16_t*)0x20007b34 = 5);
    NONFAILING(*(uint16_t*)0x20007b36 = 0);
    NONFAILING(*(uint16_t*)0x20007b38 = 5);
    NONFAILING(*(uint16_t*)0x20007b3a = 1);
    NONFAILING(*(uint16_t*)0x20007b3c = 1);
    NONFAILING(*(uint16_t*)0x20007b3e = 1);
    NONFAILING(*(uint16_t*)0x20007b40 = 2);
    NONFAILING(*(uint16_t*)0x20007b42 = 1);
    NONFAILING(*(uint16_t*)0x20007b44 = 1);
    NONFAILING(*(uint16_t*)0x20007b46 = 0);
    NONFAILING(*(uint16_t*)0x20007b48 = 5);
    NONFAILING(*(uint16_t*)0x20007b4a = 0);
    NONFAILING(*(uint16_t*)0x20007b4c = 2);
    NONFAILING(*(uint16_t*)0x20007b4e = 0);
    NONFAILING(*(uint16_t*)0x20007b50 = 0xa7fa);
    NONFAILING(*(uint16_t*)0x20007b52 = 0);
    NONFAILING(*(uint16_t*)0x20007b54 = 3);
    NONFAILING(*(uint16_t*)0x20007b56 = 1);
    NONFAILING(*(uint16_t*)0x20007b58 = 3);
    NONFAILING(*(uint16_t*)0x20007b5a = 1);
    NONFAILING(*(uint16_t*)0x20007b5c = 3);
    NONFAILING(*(uint16_t*)0x20007b5e = 0);
    NONFAILING(*(uint16_t*)0x20007b60 = 5);
    NONFAILING(*(uint16_t*)0x20007b62 = 0);
    NONFAILING(*(uint16_t*)0x20007b64 = 4);
    NONFAILING(*(uint16_t*)0x20007b66 = 1);
    NONFAILING(*(uint16_t*)0x20007b68 = 1);
    NONFAILING(*(uint16_t*)0x20007b6a = 1);
    NONFAILING(*(uint16_t*)0x20007b6c = 3);
    NONFAILING(*(uint16_t*)0x20007b6e = 1);
    NONFAILING(*(uint16_t*)0x20007b70 = 0);
    NONFAILING(*(uint16_t*)0x20007b72 = 0);
    NONFAILING(*(uint16_t*)0x20007b74 = 2);
    NONFAILING(*(uint16_t*)0x20007b76 = 1);
    NONFAILING(*(uint16_t*)0x20007b78 = 2);
    NONFAILING(*(uint16_t*)0x20007b7a = 1);
    NONFAILING(*(uint16_t*)0x20007b7c = 6);
    NONFAILING(*(uint16_t*)0x20007b7e = 0);
    NONFAILING(*(uint16_t*)0x20007b80 = 3);
    NONFAILING(*(uint16_t*)0x20007b82 = 0);
    NONFAILING(*(uint16_t*)0x20007b84 = 2);
    NONFAILING(*(uint16_t*)0x20007b86 = 1);
    NONFAILING(*(uint16_t*)0x20007b88 = 1);
    NONFAILING(*(uint16_t*)0x20007b8a = 0);
    NONFAILING(*(uint16_t*)0x20007b8c = 2);
    NONFAILING(*(uint16_t*)0x20007b8e = 0);
    NONFAILING(*(uint16_t*)0x20007b90 = 4);
    NONFAILING(*(uint16_t*)0x20007b92 = 0);
    NONFAILING(*(uint16_t*)0x20007b94 = 5);
    NONFAILING(*(uint16_t*)0x20007b96 = 1);
    NONFAILING(*(uint16_t*)0x20007b98 = 0);
    NONFAILING(*(uint16_t*)0x20007b9a = 0);
    NONFAILING(*(uint16_t*)0x20007b9c = 2);
    NONFAILING(*(uint16_t*)0x20007b9e = 0);
    NONFAILING(*(uint16_t*)0x20007ba0 = 5);
    NONFAILING(*(uint16_t*)0x20007ba2 = 1);
    NONFAILING(*(uint16_t*)0x20007ba4 = 2);
    NONFAILING(*(uint16_t*)0x20007ba6 = 0);
    NONFAILING(*(uint16_t*)0x20007ba8 = 0);
    NONFAILING(*(uint16_t*)0x20007baa = 1);
    NONFAILING(*(uint16_t*)0x20007bac = 0);
    NONFAILING(*(uint16_t*)0x20007bae = 1);
    NONFAILING(*(uint16_t*)0x20007bb0 = 3);
    NONFAILING(*(uint16_t*)0x20007bb2 = 0);
    NONFAILING(*(uint16_t*)0x20007bb4 = 0);
    NONFAILING(*(uint16_t*)0x20007bb6 = 1);
    NONFAILING(*(uint16_t*)0x20007bb8 = 3);
    NONFAILING(*(uint16_t*)0x20007bba = 0);
    NONFAILING(*(uint16_t*)0x20007bbc = 5);
    NONFAILING(*(uint16_t*)0x20007bbe = 0);
    NONFAILING(*(uint16_t*)0x20007bc0 = 3);
    NONFAILING(*(uint16_t*)0x20007bc2 = 1);
    NONFAILING(*(uint16_t*)0x20007bc4 = 1);
    NONFAILING(*(uint16_t*)0x20007bc6 = 1);
    NONFAILING(*(uint16_t*)0x20007bc8 = 5);
    NONFAILING(*(uint16_t*)0x20007bca = 0);
    NONFAILING(*(uint16_t*)0x20007bcc = 1);
    NONFAILING(*(uint16_t*)0x20007bce = 0);
    NONFAILING(*(uint16_t*)0x20007bd0 = 3);
    NONFAILING(*(uint16_t*)0x20007bd2 = 1);
    NONFAILING(*(uint16_t*)0x20007bd4 = 7);
    NONFAILING(*(uint16_t*)0x20007bd6 = 0);
    NONFAILING(*(uint16_t*)0x20007bd8 = 4);
    NONFAILING(*(uint16_t*)0x20007bda = 0);
    NONFAILING(*(uint16_t*)0x20007bdc = 3);
    NONFAILING(*(uint16_t*)0x20007bde = 0);
    NONFAILING(*(uint16_t*)0x20007be0 = 2);
    NONFAILING(*(uint16_t*)0x20007be2 = 1);
    NONFAILING(*(uint16_t*)0x20007be4 = 3);
    NONFAILING(*(uint16_t*)0x20007be6 = 0);
    NONFAILING(*(uint16_t*)0x20007be8 = 5);
    NONFAILING(*(uint16_t*)0x20007bea = 0);
    NONFAILING(*(uint16_t*)0x20007bec = 1);
    NONFAILING(*(uint16_t*)0x20007bee = 0x8c72);
    NONFAILING(*(uint16_t*)0x20007bf0 = 2);
    NONFAILING(*(uint16_t*)0x20007bf2 = 0);
    NONFAILING(*(uint16_t*)0x20007bf4 = 4);
    NONFAILING(*(uint16_t*)0x20007bf6 = 0);
    NONFAILING(*(uint16_t*)0x20007bf8 = 5);
    NONFAILING(*(uint16_t*)0x20007bfa = 1);
    NONFAILING(*(uint16_t*)0x20007bfc = 5);
    NONFAILING(*(uint16_t*)0x20007bfe = 0);
    NONFAILING(*(uint16_t*)0x20007c00 = 0);
    NONFAILING(*(uint16_t*)0x20007c02 = 0);
    NONFAILING(*(uint16_t*)0x20007c04 = 3);
    NONFAILING(*(uint16_t*)0x20007c06 = 1);
    NONFAILING(*(uint16_t*)0x20007c08 = 4);
    NONFAILING(*(uint16_t*)0x20007c0a = 0);
    NONFAILING(*(uint16_t*)0x20007c0c = 0);
    NONFAILING(*(uint16_t*)0x20007c0e = 1);
    NONFAILING(*(uint16_t*)0x20007c10 = 5);
    NONFAILING(*(uint16_t*)0x20007c12 = 0);
    NONFAILING(*(uint16_t*)0x20007c14 = 4);
    NONFAILING(*(uint16_t*)0x20007c16 = 0);
    NONFAILING(*(uint16_t*)0x20007c18 = 0);
    NONFAILING(*(uint16_t*)0x20007c1a = 0);
    NONFAILING(*(uint16_t*)0x20007c1c = 4);
    NONFAILING(*(uint16_t*)0x20007c1e = 1);
    NONFAILING(*(uint16_t*)0x20007c20 = 0);
    NONFAILING(*(uint16_t*)0x20007c22 = 0);
    NONFAILING(*(uint16_t*)0x20007c24 = 7);
    NONFAILING(*(uint16_t*)0x20007c26 = 1);
    NONFAILING(*(uint16_t*)0x20007c28 = 5);
    NONFAILING(*(uint16_t*)0x20007c2a = 1);
    NONFAILING(*(uint16_t*)0x20007c2c = 2);
    NONFAILING(*(uint16_t*)0x20007c2e = 0xa7c4);
    NONFAILING(*(uint16_t*)0x20007c30 = 2);
    NONFAILING(*(uint16_t*)0x20007c32 = 1);
    NONFAILING(*(uint8_t*)0x20007c34 = 0);
    NONFAILING(*(uint16_t*)0x20007c38 = 0xdc);
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20007c3a, 5, 0, 14));
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20007c3b, 0, 6, 1));
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20007c3b, 1, 7, 1));
    NONFAILING(*(uint16_t*)0x20007c3c = 0x54);
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20007c3e, 6, 0, 14));
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20007c3f, 0, 6, 1));
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20007c3f, 1, 7, 1));
    NONFAILING(*(uint16_t*)0x20007c40 = 6);
    NONFAILING(*(uint16_t*)0x20007c42 = 1);
    NONFAILING(*(uint16_t*)0x20007c44 = 1);
    NONFAILING(*(uint16_t*)0x20007c48 = 6);
    NONFAILING(*(uint16_t*)0x20007c4a = 2);
    NONFAILING(*(uint16_t*)0x20007c4c = 1);
    NONFAILING(*(uint16_t*)0x20007c50 = 6);
    NONFAILING(*(uint16_t*)0x20007c52 = 2);
    NONFAILING(*(uint16_t*)0x20007c54 = 1);
    NONFAILING(*(uint16_t*)0x20007c58 = 6);
    NONFAILING(*(uint16_t*)0x20007c5a = 2);
    NONFAILING(*(uint16_t*)0x20007c5c = 0);
    NONFAILING(*(uint16_t*)0x20007c60 = 6);
    NONFAILING(*(uint16_t*)0x20007c62 = 2);
    NONFAILING(*(uint16_t*)0x20007c64 = 0);
    NONFAILING(*(uint16_t*)0x20007c68 = 6);
    NONFAILING(*(uint16_t*)0x20007c6a = 1);
    NONFAILING(*(uint16_t*)0x20007c6c = 4);
    NONFAILING(*(uint16_t*)0x20007c70 = 6);
    NONFAILING(*(uint16_t*)0x20007c72 = 2);
    NONFAILING(*(uint16_t*)0x20007c74 = 1);
    NONFAILING(*(uint16_t*)0x20007c78 = 6);
    NONFAILING(*(uint16_t*)0x20007c7a = 1);
    NONFAILING(*(uint16_t*)0x20007c7c = 4);
    NONFAILING(*(uint16_t*)0x20007c80 = 6);
    NONFAILING(*(uint16_t*)0x20007c82 = 2);
    NONFAILING(*(uint16_t*)0x20007c84 = 0);
    NONFAILING(*(uint16_t*)0x20007c88 = 6);
    NONFAILING(*(uint16_t*)0x20007c8a = 2);
    NONFAILING(*(uint16_t*)0x20007c8c = 1);
    NONFAILING(*(uint16_t*)0x20007c90 = 0x44);
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20007c92, 6, 0, 14));
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20007c93, 0, 6, 1));
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20007c93, 1, 7, 1));
    NONFAILING(*(uint16_t*)0x20007c94 = 6);
    NONFAILING(*(uint16_t*)0x20007c96 = 2);
    NONFAILING(*(uint16_t*)0x20007c98 = 1);
    NONFAILING(*(uint16_t*)0x20007c9c = 6);
    NONFAILING(*(uint16_t*)0x20007c9e = 1);
    NONFAILING(*(uint16_t*)0x20007ca0 = 5);
    NONFAILING(*(uint16_t*)0x20007ca4 = 6);
    NONFAILING(*(uint16_t*)0x20007ca6 = 1);
    NONFAILING(*(uint16_t*)0x20007ca8 = 0);
    NONFAILING(*(uint16_t*)0x20007cac = 6);
    NONFAILING(*(uint16_t*)0x20007cae = 2);
    NONFAILING(*(uint16_t*)0x20007cb0 = 1);
    NONFAILING(*(uint16_t*)0x20007cb4 = 6);
    NONFAILING(*(uint16_t*)0x20007cb6 = 2);
    NONFAILING(*(uint16_t*)0x20007cb8 = 0);
    NONFAILING(*(uint16_t*)0x20007cbc = 6);
    NONFAILING(*(uint16_t*)0x20007cbe = 2);
    NONFAILING(*(uint16_t*)0x20007cc0 = 1);
    NONFAILING(*(uint16_t*)0x20007cc4 = 6);
    NONFAILING(*(uint16_t*)0x20007cc6 = 1);
    NONFAILING(*(uint16_t*)0x20007cc8 = 5);
    NONFAILING(*(uint16_t*)0x20007ccc = 6);
    NONFAILING(*(uint16_t*)0x20007cce = 2);
    NONFAILING(*(uint16_t*)0x20007cd0 = 0);
    NONFAILING(*(uint16_t*)0x20007cd4 = 0xc);
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20007cd6, 6, 0, 14));
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20007cd7, 0, 6, 1));
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20007cd7, 1, 7, 1));
    NONFAILING(*(uint16_t*)0x20007cd8 = 6);
    NONFAILING(*(uint16_t*)0x20007cda = 1);
    NONFAILING(*(uint16_t*)0x20007cdc = 0);
    NONFAILING(*(uint16_t*)0x20007ce0 = 0x34);
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20007ce2, 6, 0, 14));
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20007ce3, 0, 6, 1));
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20007ce3, 1, 7, 1));
    NONFAILING(*(uint16_t*)0x20007ce4 = 6);
    NONFAILING(*(uint16_t*)0x20007ce6 = 1);
    NONFAILING(*(uint16_t*)0x20007ce8 = 4);
    NONFAILING(*(uint16_t*)0x20007cec = 6);
    NONFAILING(*(uint16_t*)0x20007cee = 1);
    NONFAILING(*(uint16_t*)0x20007cf0 = 5);
    NONFAILING(*(uint16_t*)0x20007cf4 = 6);
    NONFAILING(*(uint16_t*)0x20007cf6 = 1);
    NONFAILING(*(uint16_t*)0x20007cf8 = 0);
    NONFAILING(*(uint16_t*)0x20007cfc = 6);
    NONFAILING(*(uint16_t*)0x20007cfe = 2);
    NONFAILING(*(uint16_t*)0x20007d00 = 1);
    NONFAILING(*(uint16_t*)0x20007d04 = 6);
    NONFAILING(*(uint16_t*)0x20007d06 = 1);
    NONFAILING(*(uint16_t*)0x20007d08 = 4);
    NONFAILING(*(uint16_t*)0x20007d0c = 6);
    NONFAILING(*(uint16_t*)0x20007d0e = 2);
    NONFAILING(*(uint16_t*)0x20007d10 = 1);
    NONFAILING(*(uint16_t*)0x20007d14 = 0xa8);
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20007d16, 5, 0, 14));
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20007d17, 0, 6, 1));
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20007d17, 1, 7, 1));
    NONFAILING(*(uint16_t*)0x20007d18 = 0x2c);
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20007d1a, 6, 0, 14));
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20007d1b, 0, 6, 1));
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20007d1b, 1, 7, 1));
    NONFAILING(*(uint16_t*)0x20007d1c = 6);
    NONFAILING(*(uint16_t*)0x20007d1e = 1);
    NONFAILING(*(uint16_t*)0x20007d20 = 5);
    NONFAILING(*(uint16_t*)0x20007d24 = 6);
    NONFAILING(*(uint16_t*)0x20007d26 = 1);
    NONFAILING(*(uint16_t*)0x20007d28 = 0);
    NONFAILING(*(uint16_t*)0x20007d2c = 6);
    NONFAILING(*(uint16_t*)0x20007d2e = 2);
    NONFAILING(*(uint16_t*)0x20007d30 = 1);
    NONFAILING(*(uint16_t*)0x20007d34 = 6);
    NONFAILING(*(uint16_t*)0x20007d36 = 1);
    NONFAILING(*(uint16_t*)0x20007d38 = 2);
    NONFAILING(*(uint16_t*)0x20007d3c = 6);
    NONFAILING(*(uint16_t*)0x20007d3e = 1);
    NONFAILING(*(uint16_t*)0x20007d40 = 2);
    NONFAILING(*(uint16_t*)0x20007d44 = 0x4c);
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20007d46, 6, 0, 14));
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20007d47, 0, 6, 1));
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20007d47, 1, 7, 1));
    NONFAILING(*(uint16_t*)0x20007d48 = 6);
    NONFAILING(*(uint16_t*)0x20007d4a = 1);
    NONFAILING(*(uint16_t*)0x20007d4c = 3);
    NONFAILING(*(uint16_t*)0x20007d50 = 6);
    NONFAILING(*(uint16_t*)0x20007d52 = 2);
    NONFAILING(*(uint16_t*)0x20007d54 = 1);
    NONFAILING(*(uint16_t*)0x20007d58 = 6);
    NONFAILING(*(uint16_t*)0x20007d5a = 1);
    NONFAILING(*(uint16_t*)0x20007d5c = 1);
    NONFAILING(*(uint16_t*)0x20007d60 = 6);
    NONFAILING(*(uint16_t*)0x20007d62 = 1);
    NONFAILING(*(uint16_t*)0x20007d64 = 2);
    NONFAILING(*(uint16_t*)0x20007d68 = 6);
    NONFAILING(*(uint16_t*)0x20007d6a = 2);
    NONFAILING(*(uint16_t*)0x20007d6c = 0);
    NONFAILING(*(uint16_t*)0x20007d70 = 6);
    NONFAILING(*(uint16_t*)0x20007d72 = 2);
    NONFAILING(*(uint16_t*)0x20007d74 = 1);
    NONFAILING(*(uint16_t*)0x20007d78 = 6);
    NONFAILING(*(uint16_t*)0x20007d7a = 1);
    NONFAILING(*(uint16_t*)0x20007d7c = 2);
    NONFAILING(*(uint16_t*)0x20007d80 = 6);
    NONFAILING(*(uint16_t*)0x20007d82 = 1);
    NONFAILING(*(uint16_t*)0x20007d84 = 0);
    NONFAILING(*(uint16_t*)0x20007d88 = 6);
    NONFAILING(*(uint16_t*)0x20007d8a = 2);
    NONFAILING(*(uint16_t*)0x20007d8c = 0);
    NONFAILING(*(uint16_t*)0x20007d90 = 0x2c);
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20007d92, 6, 0, 14));
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20007d93, 0, 6, 1));
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20007d93, 1, 7, 1));
    NONFAILING(*(uint16_t*)0x20007d94 = 6);
    NONFAILING(*(uint16_t*)0x20007d96 = 1);
    NONFAILING(*(uint16_t*)0x20007d98 = 1);
    NONFAILING(*(uint16_t*)0x20007d9c = 6);
    NONFAILING(*(uint16_t*)0x20007d9e = 1);
    NONFAILING(*(uint16_t*)0x20007da0 = 5);
    NONFAILING(*(uint16_t*)0x20007da4 = 6);
    NONFAILING(*(uint16_t*)0x20007da6 = 1);
    NONFAILING(*(uint16_t*)0x20007da8 = 0);
    NONFAILING(*(uint16_t*)0x20007dac = 6);
    NONFAILING(*(uint16_t*)0x20007dae = 2);
    NONFAILING(*(uint16_t*)0x20007db0 = 1);
    NONFAILING(*(uint16_t*)0x20007db4 = 6);
    NONFAILING(*(uint16_t*)0x20007db6 = 2);
    NONFAILING(*(uint16_t*)0x20007db8 = 1);
    NONFAILING(*(uint16_t*)0x20007dbc = 0x118);
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20007dbe, 5, 0, 14));
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20007dbf, 0, 6, 1));
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20007dbf, 1, 7, 1));
    NONFAILING(*(uint16_t*)0x20007dc0 = 0xc);
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20007dc2, 6, 0, 14));
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20007dc3, 0, 6, 1));
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20007dc3, 1, 7, 1));
    NONFAILING(*(uint16_t*)0x20007dc4 = 6);
    NONFAILING(*(uint16_t*)0x20007dc6 = 1);
    NONFAILING(*(uint16_t*)0x20007dc8 = 1);
    NONFAILING(*(uint16_t*)0x20007dcc = 0x14);
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20007dce, 6, 0, 14));
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20007dcf, 0, 6, 1));
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20007dcf, 1, 7, 1));
    NONFAILING(*(uint16_t*)0x20007dd0 = 6);
    NONFAILING(*(uint16_t*)0x20007dd2 = 1);
    NONFAILING(*(uint16_t*)0x20007dd4 = 1);
    NONFAILING(*(uint16_t*)0x20007dd8 = 6);
    NONFAILING(*(uint16_t*)0x20007dda = 2);
    NONFAILING(*(uint16_t*)0x20007ddc = 0);
    NONFAILING(*(uint16_t*)0x20007de0 = 0x24);
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20007de2, 6, 0, 14));
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20007de3, 0, 6, 1));
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20007de3, 1, 7, 1));
    NONFAILING(*(uint16_t*)0x20007de4 = 6);
    NONFAILING(*(uint16_t*)0x20007de6 = 2);
    NONFAILING(*(uint16_t*)0x20007de8 = 0);
    NONFAILING(*(uint16_t*)0x20007dec = 6);
    NONFAILING(*(uint16_t*)0x20007dee = 1);
    NONFAILING(*(uint16_t*)0x20007df0 = 1);
    NONFAILING(*(uint16_t*)0x20007df4 = 6);
    NONFAILING(*(uint16_t*)0x20007df6 = 2);
    NONFAILING(*(uint16_t*)0x20007df8 = 0);
    NONFAILING(*(uint16_t*)0x20007dfc = 6);
    NONFAILING(*(uint16_t*)0x20007dfe = 1);
    NONFAILING(*(uint16_t*)0x20007e00 = 3);
    NONFAILING(*(uint16_t*)0x20007e04 = 0x1c);
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20007e06, 6, 0, 14));
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20007e07, 0, 6, 1));
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20007e07, 1, 7, 1));
    NONFAILING(*(uint16_t*)0x20007e08 = 6);
    NONFAILING(*(uint16_t*)0x20007e0a = 2);
    NONFAILING(*(uint16_t*)0x20007e0c = 1);
    NONFAILING(*(uint16_t*)0x20007e10 = 6);
    NONFAILING(*(uint16_t*)0x20007e12 = 1);
    NONFAILING(*(uint16_t*)0x20007e14 = 5);
    NONFAILING(*(uint16_t*)0x20007e18 = 6);
    NONFAILING(*(uint16_t*)0x20007e1a = 1);
    NONFAILING(*(uint16_t*)0x20007e1c = 1);
    NONFAILING(*(uint16_t*)0x20007e20 = 0x4c);
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20007e22, 6, 0, 14));
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20007e23, 0, 6, 1));
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20007e23, 1, 7, 1));
    NONFAILING(*(uint16_t*)0x20007e24 = 6);
    NONFAILING(*(uint16_t*)0x20007e26 = 1);
    NONFAILING(*(uint16_t*)0x20007e28 = 5);
    NONFAILING(*(uint16_t*)0x20007e2c = 6);
    NONFAILING(*(uint16_t*)0x20007e2e = 1);
    NONFAILING(*(uint16_t*)0x20007e30 = 2);
    NONFAILING(*(uint16_t*)0x20007e34 = 6);
    NONFAILING(*(uint16_t*)0x20007e36 = 2);
    NONFAILING(*(uint16_t*)0x20007e38 = 1);
    NONFAILING(*(uint16_t*)0x20007e3c = 6);
    NONFAILING(*(uint16_t*)0x20007e3e = 2);
    NONFAILING(*(uint16_t*)0x20007e40 = 1);
    NONFAILING(*(uint16_t*)0x20007e44 = 6);
    NONFAILING(*(uint16_t*)0x20007e46 = 1);
    NONFAILING(*(uint16_t*)0x20007e48 = 1);
    NONFAILING(*(uint16_t*)0x20007e4c = 6);
    NONFAILING(*(uint16_t*)0x20007e4e = 2);
    NONFAILING(*(uint16_t*)0x20007e50 = 1);
    NONFAILING(*(uint16_t*)0x20007e54 = 6);
    NONFAILING(*(uint16_t*)0x20007e56 = 2);
    NONFAILING(*(uint16_t*)0x20007e58 = 1);
    NONFAILING(*(uint16_t*)0x20007e5c = 6);
    NONFAILING(*(uint16_t*)0x20007e5e = 2);
    NONFAILING(*(uint16_t*)0x20007e60 = 1);
    NONFAILING(*(uint16_t*)0x20007e64 = 6);
    NONFAILING(*(uint16_t*)0x20007e66 = 1);
    NONFAILING(*(uint16_t*)0x20007e68 = 0);
    NONFAILING(*(uint16_t*)0x20007e6c = 0x14);
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20007e6e, 6, 0, 14));
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20007e6f, 0, 6, 1));
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20007e6f, 1, 7, 1));
    NONFAILING(*(uint16_t*)0x20007e70 = 6);
    NONFAILING(*(uint16_t*)0x20007e72 = 2);
    NONFAILING(*(uint16_t*)0x20007e74 = 0);
    NONFAILING(*(uint16_t*)0x20007e78 = 6);
    NONFAILING(*(uint16_t*)0x20007e7a = 1);
    NONFAILING(*(uint16_t*)0x20007e7c = 3);
    NONFAILING(*(uint16_t*)0x20007e80 = 0x54);
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20007e82, 6, 0, 14));
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20007e83, 0, 6, 1));
    NONFAILING(STORE_BY_BITMASK(uint16_t, , 0x20007e83, 1, 7, 1));
    NONFAILING(*(uint16_t*)0x20007e84 = 6);
    NONFAILING(*(uint16_t*)0x20007e86 = 1);
    NONFAILING(*(uint16_t*)0x20007e88 = 2);
    NONFAILING(*(uint16_t*)0x20007e8c = 6);
    NONFAILING(*(uint16_t*)0x20007e8e = 2);
    NONFAILING(*(uint16_t*)0x20007e90 = 0);
    NONFAILING(*(uint16_t*)0x20007e94 = 6);
    NONFAILING(*(uint16_t*)0x20007e96 = 1);
    NONFAILING(*(uint16_t*)0x20007e98 = 0);
    NONFAILING(*(uint16_t*)0x20007e9c = 6);
    NONFAILING(*(uint16_t*)0x20007e9e = 1);
    NONFAILING(*(uint16_t*)0x20007ea0 = 2);
    NONFAILING(*(uint16_t*)0x20007ea4 = 6);
    NONFAILING(*(uint16_t*)0x20007ea6 = 1);
    NONFAILING(*(uint16_t*)0x20007ea8 = 0);
    NONFAILING(*(uint16_t*)0x20007eac = 6);
    NONFAILING(*(uint16_t*)0x20007eae = 2);
    NONFAILING(*(uint16_t*)0x20007eb0 = 0);
    NONFAILING(*(uint16_t*)0x20007eb4 = 6);
    NONFAILING(*(uint16_t*)0x20007eb6 = 2);
    NONFAILING(*(uint16_t*)0x20007eb8 = 0);
    NONFAILING(*(uint16_t*)0x20007ebc = 6);
    NONFAILING(*(uint16_t*)0x20007ebe = 2);
    NONFAILING(*(uint16_t*)0x20007ec0 = 0);
    NONFAILING(*(uint16_t*)0x20007ec4 = 6);
    NONFAILING(*(uint16_t*)0x20007ec6 = 1);
    NONFAILING(*(uint16_t*)0x20007ec8 = 2);
    NONFAILING(*(uint16_t*)0x20007ecc = 6);
    NONFAILING(*(uint16_t*)0x20007ece = 1);
    NONFAILING(*(uint16_t*)0x20007ed0 = 2);
    NONFAILING(*(uint16_t*)0x20007ed4 = 0xee0);
    NONFAILING(*(uint16_t*)0x20007ed6 = 4);
    NONFAILING(*(uint32_t*)0x20007ed8 = 1);
    NONFAILING(*(uint32_t*)0x20007edc = 0);
    NONFAILING(*(uint32_t*)0x20007ee0 = -1);
    NONFAILING(*(uint32_t*)0x20007ee4 = 0);
    NONFAILING(*(uint32_t*)0x20007ee8 = 0xfff);
    NONFAILING(*(uint8_t*)0x20007eec = 1);
    NONFAILING(*(uint8_t*)0x20007eed = 2);
    NONFAILING(*(uint32_t*)0x20007ef0 = 0x80);
    NONFAILING(*(uint32_t*)0x20007ef4 = 0x888);
    NONFAILING(*(uint32_t*)0x20007ef8 = 2);
    NONFAILING(*(uint32_t*)0x20007efc = 2);
    NONFAILING(*(uint32_t*)0x20007f00 = 0x40);
    NONFAILING(*(uint32_t*)0x20007f04 = 1);
    NONFAILING(*(uint32_t*)0x20007f08 = 0x1000);
    NONFAILING(*(uint32_t*)0x20007f0c = 0x80);
    NONFAILING(*(uint32_t*)0x20007f10 = 0);
    NONFAILING(*(uint32_t*)0x20007f14 = 8);
    NONFAILING(*(uint32_t*)0x20007f18 = 1);
    NONFAILING(*(uint32_t*)0x20007f1c = 5);
    NONFAILING(*(uint32_t*)0x20007f20 = 8);
    NONFAILING(*(uint32_t*)0x20007f24 = 6);
    NONFAILING(*(uint32_t*)0x20007f28 = 0x200);
    NONFAILING(*(uint32_t*)0x20007f2c = 4);
    NONFAILING(*(uint32_t*)0x20007f30 = 0xc0000);
    NONFAILING(*(uint32_t*)0x20007f34 = 8);
    NONFAILING(*(uint32_t*)0x20007f38 = 6);
    NONFAILING(*(uint32_t*)0x20007f3c = 0x7fff);
    NONFAILING(*(uint32_t*)0x20007f40 = 0);
    NONFAILING(*(uint32_t*)0x20007f44 = 7);
    NONFAILING(*(uint32_t*)0x20007f48 = 0x3f);
    NONFAILING(*(uint32_t*)0x20007f4c = 0xfffff2bd);
    NONFAILING(*(uint32_t*)0x20007f50 = 0);
    NONFAILING(*(uint32_t*)0x20007f54 = 0x280000);
    NONFAILING(*(uint32_t*)0x20007f58 = 8);
    NONFAILING(*(uint32_t*)0x20007f5c = 0x400);
    NONFAILING(*(uint32_t*)0x20007f60 = 8);
    NONFAILING(*(uint32_t*)0x20007f64 = 0x4abe4aea);
    NONFAILING(*(uint32_t*)0x20007f68 = 9);
    NONFAILING(*(uint32_t*)0x20007f6c = 0x8000);
    NONFAILING(*(uint32_t*)0x20007f70 = 0xff);
    NONFAILING(*(uint32_t*)0x20007f74 = 2);
    NONFAILING(*(uint32_t*)0x20007f78 = 1);
    NONFAILING(*(uint32_t*)0x20007f7c = 8);
    NONFAILING(*(uint32_t*)0x20007f80 = 0xffff67c5);
    NONFAILING(*(uint32_t*)0x20007f84 = 5);
    NONFAILING(*(uint32_t*)0x20007f88 = 0x80);
    NONFAILING(*(uint32_t*)0x20007f8c = 0xff);
    NONFAILING(*(uint32_t*)0x20007f90 = 0x7f);
    NONFAILING(*(uint32_t*)0x20007f94 = 0x80000000);
    NONFAILING(*(uint32_t*)0x20007f98 = 7);
    NONFAILING(*(uint32_t*)0x20007f9c = 0x8ff);
    NONFAILING(*(uint32_t*)0x20007fa0 = 6);
    NONFAILING(*(uint32_t*)0x20007fa4 = 0x800);
    NONFAILING(*(uint32_t*)0x20007fa8 = 6);
    NONFAILING(*(uint32_t*)0x20007fac = 0x7ff);
    NONFAILING(*(uint32_t*)0x20007fb0 = 0xfffffbff);
    NONFAILING(*(uint32_t*)0x20007fb4 = 0x7ff);
    NONFAILING(*(uint32_t*)0x20007fb8 = 0x40);
    NONFAILING(*(uint32_t*)0x20007fbc = 0xfffffff8);
    NONFAILING(*(uint32_t*)0x20007fc0 = 0x7fff);
    NONFAILING(*(uint32_t*)0x20007fc4 = 7);
    NONFAILING(*(uint32_t*)0x20007fc8 = 4);
    NONFAILING(*(uint32_t*)0x20007fcc = 0x3f);
    NONFAILING(*(uint32_t*)0x20007fd0 = 0x356);
    NONFAILING(*(uint32_t*)0x20007fd4 = 0xb35);
    NONFAILING(*(uint32_t*)0x20007fd8 = 0xc946);
    NONFAILING(*(uint32_t*)0x20007fdc = 0xc71f);
    NONFAILING(*(uint32_t*)0x20007fe0 = 2);
    NONFAILING(*(uint32_t*)0x20007fe4 = 5);
    NONFAILING(*(uint32_t*)0x20007fe8 = 2);
    NONFAILING(*(uint32_t*)0x20007fec = 0x7fa);
    NONFAILING(*(uint32_t*)0x20007ff0 = 0);
    NONFAILING(*(uint32_t*)0x20007ff4 = 0x10000);
    NONFAILING(*(uint32_t*)0x20007ff8 = 0xfffffff7);
    NONFAILING(*(uint32_t*)0x20007ffc = 0x7ff);
    NONFAILING(*(uint32_t*)0x20008000 = 0x81);
    NONFAILING(*(uint32_t*)0x20008004 = 7);
    NONFAILING(*(uint32_t*)0x20008008 = 0xbf65);
    NONFAILING(*(uint32_t*)0x2000800c = 0x80000001);
    NONFAILING(*(uint32_t*)0x20008010 = 0x80000000);
    NONFAILING(*(uint32_t*)0x20008014 = 0xff);
    NONFAILING(*(uint32_t*)0x20008018 = 0x30);
    NONFAILING(*(uint32_t*)0x2000801c = 2);
    NONFAILING(*(uint32_t*)0x20008020 = 0x5a);
    NONFAILING(*(uint32_t*)0x20008024 = 0xffff);
    NONFAILING(*(uint32_t*)0x20008028 = 0x800);
    NONFAILING(*(uint32_t*)0x2000802c = 0x401);
    NONFAILING(*(uint32_t*)0x20008030 = 0xff);
    NONFAILING(*(uint32_t*)0x20008034 = 0x7f);
    NONFAILING(*(uint32_t*)0x20008038 = 0x451);
    NONFAILING(*(uint32_t*)0x2000803c = 0x1000);
    NONFAILING(*(uint32_t*)0x20008040 = 7);
    NONFAILING(*(uint32_t*)0x20008044 = 4);
    NONFAILING(*(uint32_t*)0x20008048 = 0x10000);
    NONFAILING(*(uint32_t*)0x2000804c = -1);
    NONFAILING(*(uint32_t*)0x20008050 = 8);
    NONFAILING(*(uint32_t*)0x20008054 = 0x8001);
    NONFAILING(*(uint32_t*)0x20008058 = 3);
    NONFAILING(*(uint32_t*)0x2000805c = 9);
    NONFAILING(*(uint32_t*)0x20008060 = 7);
    NONFAILING(*(uint32_t*)0x20008064 = 0xd);
    NONFAILING(*(uint32_t*)0x20008068 = 0xfffffff7);
    NONFAILING(*(uint32_t*)0x2000806c = 8);
    NONFAILING(*(uint32_t*)0x20008070 = 0x200);
    NONFAILING(*(uint32_t*)0x20008074 = 0xc5b);
    NONFAILING(*(uint32_t*)0x20008078 = 4);
    NONFAILING(*(uint32_t*)0x2000807c = 0x7f);
    NONFAILING(*(uint32_t*)0x20008080 = 2);
    NONFAILING(*(uint32_t*)0x20008084 = 0);
    NONFAILING(*(uint32_t*)0x20008088 = 0x1000);
    NONFAILING(*(uint32_t*)0x2000808c = 0xfffffff8);
    NONFAILING(*(uint32_t*)0x20008090 = 0xc000000);
    NONFAILING(*(uint32_t*)0x20008094 = 0x80000000);
    NONFAILING(*(uint32_t*)0x20008098 = 6);
    NONFAILING(*(uint32_t*)0x2000809c = 3);
    NONFAILING(*(uint32_t*)0x200080a0 = 0x7fff);
    NONFAILING(*(uint32_t*)0x200080a4 = 0xad4);
    NONFAILING(*(uint32_t*)0x200080a8 = 0xd4);
    NONFAILING(*(uint32_t*)0x200080ac = 0);
    NONFAILING(*(uint32_t*)0x200080b0 = 0x7fffffff);
    NONFAILING(*(uint32_t*)0x200080b4 = 0x20);
    NONFAILING(*(uint32_t*)0x200080b8 = 0x1000);
    NONFAILING(*(uint32_t*)0x200080bc = 7);
    NONFAILING(*(uint32_t*)0x200080c0 = 5);
    NONFAILING(*(uint32_t*)0x200080c4 = 0x1f);
    NONFAILING(*(uint32_t*)0x200080c8 = 5);
    NONFAILING(*(uint32_t*)0x200080cc = 9);
    NONFAILING(*(uint32_t*)0x200080d0 = 0x15b);
    NONFAILING(*(uint32_t*)0x200080d4 = 0);
    NONFAILING(*(uint32_t*)0x200080d8 = 8);
    NONFAILING(*(uint32_t*)0x200080dc = 0x90);
    NONFAILING(*(uint32_t*)0x200080e0 = 0x455);
    NONFAILING(*(uint32_t*)0x200080e4 = 5);
    NONFAILING(*(uint32_t*)0x200080e8 = -1);
    NONFAILING(*(uint32_t*)0x200080ec = 0x7fff);
    NONFAILING(*(uint32_t*)0x200080f0 = 0x7fffffff);
    NONFAILING(*(uint32_t*)0x200080f4 = 0xff);
    NONFAILING(*(uint32_t*)0x200080f8 = 0x3f);
    NONFAILING(*(uint32_t*)0x200080fc = 0x10001);
    NONFAILING(*(uint32_t*)0x20008100 = 0xb46e);
    NONFAILING(*(uint32_t*)0x20008104 = 0xc806);
    NONFAILING(*(uint32_t*)0x20008108 = 8);
    NONFAILING(*(uint32_t*)0x2000810c = 0x18b);
    NONFAILING(*(uint32_t*)0x20008110 = 0xbe);
    NONFAILING(*(uint32_t*)0x20008114 = 9);
    NONFAILING(*(uint32_t*)0x20008118 = 0x100);
    NONFAILING(*(uint32_t*)0x2000811c = 0x1f);
    NONFAILING(*(uint32_t*)0x20008120 = 0xa000);
    NONFAILING(*(uint32_t*)0x20008124 = 2);
    NONFAILING(*(uint32_t*)0x20008128 = 0x6386bf74);
    NONFAILING(*(uint32_t*)0x2000812c = 7);
    NONFAILING(*(uint32_t*)0x20008130 = 1);
    NONFAILING(*(uint32_t*)0x20008134 = 0x101);
    NONFAILING(*(uint32_t*)0x20008138 = 0x55);
    NONFAILING(*(uint32_t*)0x2000813c = 2);
    NONFAILING(*(uint32_t*)0x20008140 = 7);
    NONFAILING(*(uint32_t*)0x20008144 = 0xca7);
    NONFAILING(*(uint32_t*)0x20008148 = 1);
    NONFAILING(*(uint32_t*)0x2000814c = 3);
    NONFAILING(*(uint32_t*)0x20008150 = 0x800);
    NONFAILING(*(uint32_t*)0x20008154 = 9);
    NONFAILING(*(uint32_t*)0x20008158 = 8);
    NONFAILING(*(uint32_t*)0x2000815c = 4);
    NONFAILING(*(uint32_t*)0x20008160 = 4);
    NONFAILING(*(uint32_t*)0x20008164 = 7);
    NONFAILING(*(uint32_t*)0x20008168 = 5);
    NONFAILING(*(uint32_t*)0x2000816c = 0x81);
    NONFAILING(*(uint32_t*)0x20008170 = 7);
    NONFAILING(*(uint32_t*)0x20008174 = 8);
    NONFAILING(*(uint32_t*)0x20008178 = 0x401);
    NONFAILING(*(uint32_t*)0x2000817c = 3);
    NONFAILING(*(uint32_t*)0x20008180 = 0xfffffff7);
    NONFAILING(*(uint32_t*)0x20008184 = 1);
    NONFAILING(*(uint32_t*)0x20008188 = 0x1000200);
    NONFAILING(*(uint32_t*)0x2000818c = 5);
    NONFAILING(*(uint32_t*)0x20008190 = 7);
    NONFAILING(*(uint32_t*)0x20008194 = 0xfff);
    NONFAILING(*(uint32_t*)0x20008198 = 0x101);
    NONFAILING(*(uint32_t*)0x2000819c = 6);
    NONFAILING(*(uint32_t*)0x200081a0 = 0x40);
    NONFAILING(*(uint32_t*)0x200081a4 = 0x8000);
    NONFAILING(*(uint32_t*)0x200081a8 = 0x101);
    NONFAILING(*(uint32_t*)0x200081ac = 6);
    NONFAILING(*(uint32_t*)0x200081b0 = 5);
    NONFAILING(*(uint32_t*)0x200081b4 = 0x7e43f5a8);
    NONFAILING(*(uint32_t*)0x200081b8 = 0xb176);
    NONFAILING(*(uint32_t*)0x200081bc = 0xffff);
    NONFAILING(*(uint32_t*)0x200081c0 = 0x80000001);
    NONFAILING(*(uint32_t*)0x200081c4 = 9);
    NONFAILING(*(uint32_t*)0x200081c8 = 0x38);
    NONFAILING(*(uint32_t*)0x200081cc = 0x27);
    NONFAILING(*(uint32_t*)0x200081d0 = 1);
    NONFAILING(*(uint32_t*)0x200081d4 = 8);
    NONFAILING(*(uint32_t*)0x200081d8 = 7);
    NONFAILING(*(uint32_t*)0x200081dc = 0x8000);
    NONFAILING(*(uint32_t*)0x200081e0 = 0);
    NONFAILING(*(uint32_t*)0x200081e4 = 0x6b9);
    NONFAILING(*(uint32_t*)0x200081e8 = 0);
    NONFAILING(*(uint32_t*)0x200081ec = 0x401);
    NONFAILING(*(uint32_t*)0x200081f0 = 0x40);
    NONFAILING(*(uint32_t*)0x200081f4 = 1);
    NONFAILING(*(uint32_t*)0x200081f8 = 8);
    NONFAILING(*(uint32_t*)0x200081fc = 0x10000);
    NONFAILING(*(uint32_t*)0x20008200 = 3);
    NONFAILING(*(uint32_t*)0x20008204 = 0xb5a);
    NONFAILING(*(uint32_t*)0x20008208 = 0x1ff);
    NONFAILING(*(uint32_t*)0x2000820c = 3);
    NONFAILING(*(uint32_t*)0x20008210 = 0x1000);
    NONFAILING(*(uint32_t*)0x20008214 = 5);
    NONFAILING(*(uint32_t*)0x20008218 = 0xd5);
    NONFAILING(*(uint32_t*)0x2000821c = 0xfffffe01);
    NONFAILING(*(uint32_t*)0x20008220 = 5);
    NONFAILING(*(uint32_t*)0x20008224 = 8);
    NONFAILING(*(uint32_t*)0x20008228 = 8);
    NONFAILING(*(uint32_t*)0x2000822c = 0x40);
    NONFAILING(*(uint32_t*)0x20008230 = 0x80000001);
    NONFAILING(*(uint32_t*)0x20008234 = 0x7f);
    NONFAILING(*(uint32_t*)0x20008238 = 0xfb75);
    NONFAILING(*(uint32_t*)0x2000823c = 3);
    NONFAILING(*(uint32_t*)0x20008240 = 3);
    NONFAILING(*(uint32_t*)0x20008244 = 0x401);
    NONFAILING(*(uint32_t*)0x20008248 = 0x10000000);
    NONFAILING(*(uint32_t*)0x2000824c = 8);
    NONFAILING(*(uint32_t*)0x20008250 = 0x101);
    NONFAILING(*(uint32_t*)0x20008254 = 1);
    NONFAILING(*(uint32_t*)0x20008258 = 6);
    NONFAILING(*(uint32_t*)0x2000825c = 8);
    NONFAILING(*(uint32_t*)0x20008260 = 6);
    NONFAILING(*(uint32_t*)0x20008264 = 4);
    NONFAILING(*(uint32_t*)0x20008268 = 0xc89a);
    NONFAILING(*(uint32_t*)0x2000826c = 7);
    NONFAILING(*(uint32_t*)0x20008270 = 0xfffffff9);
    NONFAILING(*(uint32_t*)0x20008274 = 0x20);
    NONFAILING(*(uint32_t*)0x20008278 = 5);
    NONFAILING(*(uint32_t*)0x2000827c = 8);
    NONFAILING(*(uint32_t*)0x20008280 = 0);
    NONFAILING(*(uint32_t*)0x20008284 = 0x64);
    NONFAILING(*(uint32_t*)0x20008288 = 0x10001);
    NONFAILING(*(uint32_t*)0x2000828c = 0x1f);
    NONFAILING(*(uint32_t*)0x20008290 = 0x7fff);
    NONFAILING(*(uint32_t*)0x20008294 = 0x20);
    NONFAILING(*(uint32_t*)0x20008298 = 1);
    NONFAILING(*(uint32_t*)0x2000829c = 4);
    NONFAILING(*(uint32_t*)0x200082a0 = 4);
    NONFAILING(*(uint32_t*)0x200082a4 = 0x2dd4662e);
    NONFAILING(*(uint32_t*)0x200082a8 = 0x7ff);
    NONFAILING(*(uint32_t*)0x200082ac = 0x80000001);
    NONFAILING(*(uint32_t*)0x200082b0 = 0x8001);
    NONFAILING(*(uint32_t*)0x200082b4 = 7);
    NONFAILING(*(uint32_t*)0x200082b8 = 4);
    NONFAILING(*(uint32_t*)0x200082bc = 0x8001);
    NONFAILING(*(uint32_t*)0x200082c0 = 1);
    NONFAILING(*(uint32_t*)0x200082c4 = 2);
    NONFAILING(*(uint32_t*)0x200082c8 = 2);
    NONFAILING(*(uint32_t*)0x200082cc = 3);
    NONFAILING(*(uint32_t*)0x200082d0 = 3);
    NONFAILING(*(uint32_t*)0x200082d4 = 0);
    NONFAILING(*(uint32_t*)0x200082d8 = 0);
    NONFAILING(*(uint32_t*)0x200082dc = 0xc0000);
    NONFAILING(*(uint32_t*)0x200082e0 = 2);
    NONFAILING(*(uint32_t*)0x200082e4 = 0x200);
    NONFAILING(*(uint32_t*)0x200082e8 = 0xfffffffa);
    NONFAILING(*(uint32_t*)0x200082ec = 0xdb);
    NONFAILING(*(uint32_t*)0x200082f0 = 0x7f);
    NONFAILING(*(uint32_t*)0x200082f4 = -1);
    NONFAILING(*(uint32_t*)0x200082f8 = 8);
    NONFAILING(*(uint32_t*)0x200082fc = 8);
    NONFAILING(*(uint32_t*)0x20008300 = 0);
    NONFAILING(*(uint32_t*)0x20008304 = 5);
    NONFAILING(*(uint32_t*)0x20008308 = 0x8001);
    NONFAILING(*(uint32_t*)0x2000830c = 0x10000);
    NONFAILING(*(uint32_t*)0x20008310 = 0x1000);
    NONFAILING(*(uint32_t*)0x20008314 = 0x81);
    NONFAILING(*(uint32_t*)0x20008318 = 0x1ff);
    NONFAILING(*(uint32_t*)0x2000831c = 0);
    NONFAILING(*(uint32_t*)0x20008320 = 0x40);
    NONFAILING(*(uint32_t*)0x20008324 = 7);
    NONFAILING(*(uint32_t*)0x20008328 = 0xea0f);
    NONFAILING(*(uint32_t*)0x2000832c = 0x80);
    NONFAILING(*(uint32_t*)0x20008330 = 1);
    NONFAILING(*(uint32_t*)0x20008334 = 3);
    NONFAILING(*(uint32_t*)0x20008338 = 0);
    NONFAILING(*(uint32_t*)0x2000833c = 0xfff);
    NONFAILING(*(uint32_t*)0x20008340 = 6);
    NONFAILING(*(uint32_t*)0x20008344 = 1);
    NONFAILING(*(uint32_t*)0x20008348 = 0xfffffa7b);
    NONFAILING(*(uint32_t*)0x2000834c = 6);
    NONFAILING(*(uint32_t*)0x20008350 = 0x80000001);
    NONFAILING(*(uint32_t*)0x20008354 = 0x23281998);
    NONFAILING(*(uint32_t*)0x20008358 = 2);
    NONFAILING(*(uint32_t*)0x2000835c = 0xea);
    NONFAILING(*(uint32_t*)0x20008360 = 0x7ce8);
    NONFAILING(*(uint32_t*)0x20008364 = 0xfff);
    NONFAILING(*(uint32_t*)0x20008368 = 0x70000000);
    NONFAILING(*(uint32_t*)0x2000836c = 3);
    NONFAILING(*(uint32_t*)0x20008370 = 0xfffffffa);
    NONFAILING(*(uint32_t*)0x20008374 = 7);
    NONFAILING(*(uint32_t*)0x20008378 = 5);
    NONFAILING(*(uint32_t*)0x2000837c = 4);
    NONFAILING(*(uint32_t*)0x20008380 = 5);
    NONFAILING(*(uint32_t*)0x20008384 = 0xfff);
    NONFAILING(*(uint32_t*)0x20008388 = 0xfffff552);
    NONFAILING(*(uint32_t*)0x2000838c = 1);
    NONFAILING(*(uint32_t*)0x20008390 = 5);
    NONFAILING(*(uint32_t*)0x20008394 = 5);
    NONFAILING(*(uint32_t*)0x20008398 = 5);
    NONFAILING(*(uint32_t*)0x2000839c = 8);
    NONFAILING(*(uint32_t*)0x200083a0 = 4);
    NONFAILING(*(uint32_t*)0x200083a4 = 0x8001);
    NONFAILING(*(uint32_t*)0x200083a8 = 1);
    NONFAILING(*(uint32_t*)0x200083ac = 0x3ff);
    NONFAILING(*(uint32_t*)0x200083b0 = 0x20000);
    NONFAILING(*(uint32_t*)0x200083b4 = 2);
    NONFAILING(*(uint32_t*)0x200083b8 = 2);
    NONFAILING(*(uint32_t*)0x200083bc = 0);
    NONFAILING(*(uint32_t*)0x200083c0 = 0x7ff);
    NONFAILING(*(uint32_t*)0x200083c4 = 8);
    NONFAILING(*(uint32_t*)0x200083c8 = 1);
    NONFAILING(*(uint32_t*)0x200083cc = 0x3ff);
    NONFAILING(*(uint32_t*)0x200083d0 = 5);
    NONFAILING(*(uint32_t*)0x200083d4 = 3);
    NONFAILING(*(uint32_t*)0x200083d8 = 0x40);
    NONFAILING(*(uint32_t*)0x200083dc = 0x7ff);
    NONFAILING(*(uint32_t*)0x200083e0 = 0x1000);
    NONFAILING(*(uint32_t*)0x200083e4 = 2);
    NONFAILING(*(uint32_t*)0x200083e8 = 0);
    NONFAILING(*(uint32_t*)0x200083ec = 9);
    NONFAILING(*(uint32_t*)0x200083f0 = 9);
    NONFAILING(*(uint32_t*)0x200083f4 = 9);
    NONFAILING(*(uint32_t*)0x200083f8 = 0xc18);
    NONFAILING(*(uint32_t*)0x200083fc = 0);
    NONFAILING(*(uint32_t*)0x20008400 = 1);
    NONFAILING(*(uint32_t*)0x20008404 = 3);
    NONFAILING(*(uint32_t*)0x20008408 = 0);
    NONFAILING(*(uint32_t*)0x2000840c = 3);
    NONFAILING(*(uint32_t*)0x20008410 = 0xfffffffc);
    NONFAILING(*(uint32_t*)0x20008414 = 0x5f2c);
    NONFAILING(*(uint32_t*)0x20008418 = 0xc42);
    NONFAILING(*(uint32_t*)0x2000841c = 7);
    NONFAILING(*(uint32_t*)0x20008420 = 6);
    NONFAILING(*(uint32_t*)0x20008424 = 2);
    NONFAILING(*(uint32_t*)0x20008428 = 4);
    NONFAILING(*(uint32_t*)0x2000842c = 0x200);
    NONFAILING(*(uint32_t*)0x20008430 = 3);
    NONFAILING(*(uint32_t*)0x20008434 = 8);
    NONFAILING(*(uint32_t*)0x20008438 = 0x1f);
    NONFAILING(*(uint32_t*)0x2000843c = 0x400);
    NONFAILING(*(uint32_t*)0x20008440 = 0x8b);
    NONFAILING(*(uint32_t*)0x20008444 = 8);
    NONFAILING(*(uint32_t*)0x20008448 = 9);
    NONFAILING(*(uint32_t*)0x2000844c = 3);
    NONFAILING(*(uint32_t*)0x20008450 = 4);
    NONFAILING(*(uint32_t*)0x20008454 = 6);
    NONFAILING(*(uint32_t*)0x20008458 = 0x36a41fc5);
    NONFAILING(*(uint32_t*)0x2000845c = 0x8d8d);
    NONFAILING(*(uint32_t*)0x20008460 = 0xfffffff7);
    NONFAILING(*(uint32_t*)0x20008464 = 5);
    NONFAILING(*(uint32_t*)0x20008468 = 5);
    NONFAILING(*(uint32_t*)0x2000846c = 9);
    NONFAILING(*(uint32_t*)0x20008470 = 6);
    NONFAILING(*(uint32_t*)0x20008474 = 6);
    NONFAILING(*(uint32_t*)0x20008478 = 0);
    NONFAILING(*(uint32_t*)0x2000847c = 0x8000);
    NONFAILING(*(uint32_t*)0x20008480 = 2);
    NONFAILING(*(uint32_t*)0x20008484 = 1);
    NONFAILING(*(uint32_t*)0x20008488 = 0x7ff);
    NONFAILING(*(uint32_t*)0x2000848c = 0);
    NONFAILING(*(uint32_t*)0x20008490 = 2);
    NONFAILING(*(uint32_t*)0x20008494 = 9);
    NONFAILING(*(uint32_t*)0x20008498 = 8);
    NONFAILING(*(uint32_t*)0x2000849c = 6);
    NONFAILING(*(uint32_t*)0x200084a0 = 0x811);
    NONFAILING(*(uint32_t*)0x200084a4 = 8);
    NONFAILING(*(uint32_t*)0x200084a8 = 3);
    NONFAILING(*(uint32_t*)0x200084ac = 0xb15);
    NONFAILING(*(uint32_t*)0x200084b0 = 0x762a);
    NONFAILING(*(uint32_t*)0x200084b4 = 1);
    NONFAILING(*(uint32_t*)0x200084b8 = 0x10000);
    NONFAILING(*(uint32_t*)0x200084bc = 0x7fffffff);
    NONFAILING(*(uint32_t*)0x200084c0 = 0xc3b5);
    NONFAILING(*(uint32_t*)0x200084c4 = 0);
    NONFAILING(*(uint32_t*)0x200084c8 = 0x7f);
    NONFAILING(*(uint32_t*)0x200084cc = 0x1f);
    NONFAILING(*(uint32_t*)0x200084d0 = 0x897a);
    NONFAILING(*(uint32_t*)0x200084d4 = 3);
    NONFAILING(*(uint32_t*)0x200084d8 = 0xffff);
    NONFAILING(*(uint32_t*)0x200084dc = 3);
    NONFAILING(*(uint32_t*)0x200084e0 = 6);
    NONFAILING(*(uint32_t*)0x200084e4 = 7);
    NONFAILING(*(uint32_t*)0x200084e8 = 4);
    NONFAILING(*(uint32_t*)0x200084ec = 5);
    NONFAILING(*(uint32_t*)0x200084f0 = 7);
    NONFAILING(*(uint32_t*)0x200084f4 = 3);
    NONFAILING(*(uint32_t*)0x200084f8 = 0x7f);
    NONFAILING(*(uint32_t*)0x200084fc = 0xfffffff7);
    NONFAILING(*(uint32_t*)0x20008500 = 5);
    NONFAILING(*(uint32_t*)0x20008504 = 5);
    NONFAILING(*(uint32_t*)0x20008508 = 9);
    NONFAILING(*(uint32_t*)0x2000850c = 0x959);
    NONFAILING(*(uint32_t*)0x20008510 = 0xc8);
    NONFAILING(*(uint32_t*)0x20008514 = 0x401);
    NONFAILING(*(uint32_t*)0x20008518 = 0x7fffffff);
    NONFAILING(*(uint32_t*)0x2000851c = 7);
    NONFAILING(*(uint32_t*)0x20008520 = 0xfffffffe);
    NONFAILING(*(uint32_t*)0x20008524 = 6);
    NONFAILING(*(uint32_t*)0x20008528 = 5);
    NONFAILING(*(uint32_t*)0x2000852c = 0x40c9);
    NONFAILING(*(uint32_t*)0x20008530 = 0xb750);
    NONFAILING(*(uint32_t*)0x20008534 = 6);
    NONFAILING(*(uint32_t*)0x20008538 = 0x400);
    NONFAILING(*(uint32_t*)0x2000853c = 1);
    NONFAILING(*(uint32_t*)0x20008540 = 0x9cf);
    NONFAILING(*(uint32_t*)0x20008544 = 1);
    NONFAILING(*(uint32_t*)0x20008548 = 0);
    NONFAILING(*(uint32_t*)0x2000854c = 0xffff);
    NONFAILING(*(uint32_t*)0x20008550 = 9);
    NONFAILING(*(uint32_t*)0x20008554 = 6);
    NONFAILING(*(uint32_t*)0x20008558 = 8);
    NONFAILING(*(uint32_t*)0x2000855c = 0xd13);
    NONFAILING(*(uint32_t*)0x20008560 = 9);
    NONFAILING(*(uint32_t*)0x20008564 = 0xf737);
    NONFAILING(*(uint32_t*)0x20008568 = 0x49);
    NONFAILING(*(uint32_t*)0x2000856c = 0xb9b);
    NONFAILING(*(uint32_t*)0x20008570 = 0xe3);
    NONFAILING(*(uint32_t*)0x20008574 = 0x12da);
    NONFAILING(*(uint32_t*)0x20008578 = 0x10f);
    NONFAILING(*(uint32_t*)0x2000857c = 0x9c);
    NONFAILING(*(uint32_t*)0x20008580 = 0xf5d);
    NONFAILING(*(uint32_t*)0x20008584 = 9);
    NONFAILING(*(uint32_t*)0x20008588 = 0x80000000);
    NONFAILING(*(uint32_t*)0x2000858c = 0x3f);
    NONFAILING(*(uint32_t*)0x20008590 = 3);
    NONFAILING(*(uint32_t*)0x20008594 = 9);
    NONFAILING(*(uint32_t*)0x20008598 = 0x99);
    NONFAILING(*(uint32_t*)0x2000859c = 0xffff);
    NONFAILING(*(uint32_t*)0x200085a0 = 7);
    NONFAILING(*(uint32_t*)0x200085a4 = 0xffff);
    NONFAILING(*(uint32_t*)0x200085a8 = 4);
    NONFAILING(*(uint32_t*)0x200085ac = 0x80000000);
    NONFAILING(*(uint32_t*)0x200085b0 = 4);
    NONFAILING(*(uint32_t*)0x200085b4 = 4);
    NONFAILING(*(uint32_t*)0x200085b8 = -1);
    NONFAILING(*(uint32_t*)0x200085bc = 3);
    NONFAILING(*(uint32_t*)0x200085c0 = 0x1e);
    NONFAILING(*(uint32_t*)0x200085c4 = 0x80000001);
    NONFAILING(*(uint32_t*)0x200085c8 = 0x9f);
    NONFAILING(*(uint32_t*)0x200085cc = 5);
    NONFAILING(*(uint32_t*)0x200085d0 = 7);
    NONFAILING(*(uint32_t*)0x200085d4 = 6);
    NONFAILING(*(uint32_t*)0x200085d8 = 0x5a5a11cf);
    NONFAILING(*(uint32_t*)0x200085dc = 0x78dd);
    NONFAILING(*(uint32_t*)0x200085e0 = 7);
    NONFAILING(*(uint32_t*)0x200085e4 = 4);
    NONFAILING(*(uint32_t*)0x200085e8 = 0x80000000);
    NONFAILING(*(uint32_t*)0x200085ec = 2);
    NONFAILING(*(uint32_t*)0x200085f0 = 0x40400);
    NONFAILING(*(uint32_t*)0x200085f4 = 3);
    NONFAILING(*(uint32_t*)0x200085f8 = 0x4be3);
    NONFAILING(*(uint32_t*)0x200085fc = 0x1a);
    NONFAILING(*(uint32_t*)0x20008600 = 8);
    NONFAILING(*(uint32_t*)0x20008604 = -1);
    NONFAILING(*(uint32_t*)0x20008608 = 6);
    NONFAILING(*(uint32_t*)0x2000860c = 1);
    NONFAILING(*(uint32_t*)0x20008610 = 1);
    NONFAILING(*(uint32_t*)0x20008614 = 1);
    NONFAILING(*(uint32_t*)0x20008618 = 0x7fff);
    NONFAILING(*(uint32_t*)0x2000861c = -1);
    NONFAILING(*(uint32_t*)0x20008620 = 2);
    NONFAILING(*(uint32_t*)0x20008624 = 0x10001);
    NONFAILING(*(uint32_t*)0x20008628 = 9);
    NONFAILING(*(uint32_t*)0x2000862c = 0);
    NONFAILING(*(uint32_t*)0x20008630 = 6);
    NONFAILING(*(uint32_t*)0x20008634 = 7);
    NONFAILING(*(uint32_t*)0x20008638 = 0x80);
    NONFAILING(*(uint32_t*)0x2000863c = 9);
    NONFAILING(*(uint32_t*)0x20008640 = 9);
    NONFAILING(*(uint32_t*)0x20008644 = 0x800);
    NONFAILING(*(uint32_t*)0x20008648 = 0x81);
    NONFAILING(*(uint32_t*)0x2000864c = 0x401);
    NONFAILING(*(uint32_t*)0x20008650 = 7);
    NONFAILING(*(uint32_t*)0x20008654 = 0x80000000);
    NONFAILING(*(uint32_t*)0x20008658 = 5);
    NONFAILING(*(uint32_t*)0x2000865c = 0x6d47);
    NONFAILING(*(uint32_t*)0x20008660 = 0x7fffffff);
    NONFAILING(*(uint32_t*)0x20008664 = 0);
    NONFAILING(*(uint32_t*)0x20008668 = 0x80);
    NONFAILING(*(uint32_t*)0x2000866c = 0xfffffff8);
    NONFAILING(*(uint32_t*)0x20008670 = 1);
    NONFAILING(*(uint32_t*)0x20008674 = 5);
    NONFAILING(*(uint32_t*)0x20008678 = 2);
    NONFAILING(*(uint32_t*)0x2000867c = 0xcb);
    NONFAILING(*(uint32_t*)0x20008680 = 7);
    NONFAILING(*(uint32_t*)0x20008684 = 0xffff19d0);
    NONFAILING(*(uint32_t*)0x20008688 = 0x10000);
    NONFAILING(*(uint32_t*)0x2000868c = 0x49b);
    NONFAILING(*(uint32_t*)0x20008690 = 0x80000000);
    NONFAILING(*(uint32_t*)0x20008694 = 6);
    NONFAILING(*(uint32_t*)0x20008698 = 8);
    NONFAILING(*(uint32_t*)0x2000869c = 8);
    NONFAILING(*(uint32_t*)0x200086a0 = 6);
    NONFAILING(*(uint32_t*)0x200086a4 = 2);
    NONFAILING(*(uint32_t*)0x200086a8 = 6);
    NONFAILING(*(uint32_t*)0x200086ac = 0x20);
    NONFAILING(*(uint32_t*)0x200086b0 = -1);
    NONFAILING(*(uint32_t*)0x200086b4 = 9);
    NONFAILING(*(uint32_t*)0x200086b8 = 0xfffffffb);
    NONFAILING(*(uint32_t*)0x200086bc = 0);
    NONFAILING(*(uint32_t*)0x200086c0 = 4);
    NONFAILING(*(uint32_t*)0x200086c4 = 6);
    NONFAILING(*(uint32_t*)0x200086c8 = 4);
    NONFAILING(*(uint32_t*)0x200086cc = 0xfffffffb);
    NONFAILING(*(uint32_t*)0x200086d0 = 0xfffffffc);
    NONFAILING(*(uint32_t*)0x200086d4 = 0x82);
    NONFAILING(*(uint32_t*)0x200086d8 = 0x758e);
    NONFAILING(*(uint32_t*)0x200086dc = 4);
    NONFAILING(*(uint32_t*)0x200086e0 = 9);
    NONFAILING(*(uint32_t*)0x200086e4 = 7);
    NONFAILING(*(uint32_t*)0x200086e8 = 7);
    NONFAILING(*(uint32_t*)0x200086ec = 0);
    NONFAILING(*(uint32_t*)0x200086f0 = 0x240000);
    NONFAILING(*(uint32_t*)0x200086f4 = 0x85);
    NONFAILING(*(uint32_t*)0x200086f8 = 4);
    NONFAILING(*(uint32_t*)0x200086fc = 0x81);
    NONFAILING(*(uint32_t*)0x20008700 = 4);
    NONFAILING(*(uint32_t*)0x20008704 = 0x7fff);
    NONFAILING(*(uint32_t*)0x20008708 = 0x10001);
    NONFAILING(*(uint32_t*)0x2000870c = 1);
    NONFAILING(*(uint32_t*)0x20008710 = 0x7f);
    NONFAILING(*(uint32_t*)0x20008714 = 3);
    NONFAILING(*(uint32_t*)0x20008718 = 0xa45c);
    NONFAILING(*(uint32_t*)0x2000871c = 0);
    NONFAILING(*(uint32_t*)0x20008720 = 7);
    NONFAILING(*(uint32_t*)0x20008724 = 0x7fff);
    NONFAILING(*(uint32_t*)0x20008728 = 0x7fffffff);
    NONFAILING(*(uint32_t*)0x2000872c = 0x32);
    NONFAILING(*(uint32_t*)0x20008730 = 0xfff);
    NONFAILING(*(uint32_t*)0x20008734 = 5);
    NONFAILING(*(uint32_t*)0x20008738 = 2);
    NONFAILING(*(uint32_t*)0x2000873c = 0x10001);
    NONFAILING(*(uint32_t*)0x20008740 = 8);
    NONFAILING(*(uint32_t*)0x20008744 = 6);
    NONFAILING(*(uint32_t*)0x20008748 = 0x7f);
    NONFAILING(*(uint32_t*)0x2000874c = 2);
    NONFAILING(*(uint32_t*)0x20008750 = 0);
    NONFAILING(*(uint32_t*)0x20008754 = 4);
    NONFAILING(*(uint32_t*)0x20008758 = 6);
    NONFAILING(*(uint32_t*)0x2000875c = 0xfffffffd);
    NONFAILING(*(uint32_t*)0x20008760 = 1);
    NONFAILING(*(uint32_t*)0x20008764 = 7);
    NONFAILING(*(uint32_t*)0x20008768 = 0x3f);
    NONFAILING(*(uint32_t*)0x2000876c = 9);
    NONFAILING(*(uint32_t*)0x20008770 = 1);
    NONFAILING(*(uint32_t*)0x20008774 = 2);
    NONFAILING(*(uint32_t*)0x20008778 = 0x382);
    NONFAILING(*(uint32_t*)0x2000877c = 0x2540);
    NONFAILING(*(uint32_t*)0x20008780 = 0x81);
    NONFAILING(*(uint32_t*)0x20008784 = 7);
    NONFAILING(*(uint32_t*)0x20008788 = 0x1000);
    NONFAILING(*(uint32_t*)0x2000878c = 2);
    NONFAILING(*(uint32_t*)0x20008790 = 4);
    NONFAILING(*(uint32_t*)0x20008794 = 0x20);
    NONFAILING(*(uint32_t*)0x20008798 = 5);
    NONFAILING(*(uint32_t*)0x2000879c = 3);
    NONFAILING(*(uint32_t*)0x200087a0 = 0x8c);
    NONFAILING(*(uint32_t*)0x200087a4 = 1);
    NONFAILING(*(uint32_t*)0x200087a8 = 0x49);
    NONFAILING(*(uint32_t*)0x200087ac = 5);
    NONFAILING(*(uint32_t*)0x200087b0 = 8);
    NONFAILING(*(uint32_t*)0x200087b4 = 0x1ff);
    NONFAILING(*(uint32_t*)0x200087b8 = 5);
    NONFAILING(*(uint32_t*)0x200087bc = 0xffffff7f);
    NONFAILING(*(uint32_t*)0x200087c0 = 3);
    NONFAILING(*(uint32_t*)0x200087c4 = 5);
    NONFAILING(*(uint32_t*)0x200087c8 = 0x3ff);
    NONFAILING(*(uint32_t*)0x200087cc = 8);
    NONFAILING(*(uint32_t*)0x200087d0 = -1);
    NONFAILING(*(uint32_t*)0x200087d4 = 5);
    NONFAILING(*(uint32_t*)0x200087d8 = 4);
    NONFAILING(*(uint32_t*)0x200087dc = 1);
    NONFAILING(*(uint32_t*)0x200087e0 = 0x7ff);
    NONFAILING(*(uint32_t*)0x200087e4 = 2);
    NONFAILING(*(uint32_t*)0x200087e8 = 0);
    NONFAILING(*(uint32_t*)0x200087ec = 0x3ff);
    NONFAILING(*(uint32_t*)0x200087f0 = 8);
    NONFAILING(*(uint32_t*)0x200087f4 = 0x101);
    NONFAILING(*(uint32_t*)0x200087f8 = 0x73);
    NONFAILING(*(uint32_t*)0x200087fc = 0xffffff85);
    NONFAILING(*(uint32_t*)0x20008800 = 4);
    NONFAILING(*(uint32_t*)0x20008804 = 8);
    NONFAILING(*(uint32_t*)0x20008808 = 0x161);
    NONFAILING(*(uint32_t*)0x2000880c = 0x401);
    NONFAILING(*(uint32_t*)0x20008810 = 0x5c62);
    NONFAILING(*(uint32_t*)0x20008814 = 0x9b);
    NONFAILING(*(uint32_t*)0x20008818 = 0x3ff);
    NONFAILING(*(uint32_t*)0x2000881c = 5);
    NONFAILING(*(uint32_t*)0x20008820 = 0x3f);
    NONFAILING(*(uint32_t*)0x20008824 = 0);
    NONFAILING(*(uint32_t*)0x20008828 = 5);
    NONFAILING(*(uint32_t*)0x2000882c = 0);
    NONFAILING(*(uint32_t*)0x20008830 = 2);
    NONFAILING(*(uint32_t*)0x20008834 = 0x20);
    NONFAILING(*(uint32_t*)0x20008838 = 6);
    NONFAILING(*(uint32_t*)0x2000883c = 6);
    NONFAILING(*(uint32_t*)0x20008840 = 0xb6);
    NONFAILING(*(uint32_t*)0x20008844 = 5);
    NONFAILING(*(uint32_t*)0x20008848 = 9);
    NONFAILING(*(uint32_t*)0x2000884c = 9);
    NONFAILING(*(uint32_t*)0x20008850 = 0);
    NONFAILING(*(uint32_t*)0x20008854 = 0x401);
    NONFAILING(*(uint32_t*)0x20008858 = 0x10000);
    NONFAILING(*(uint32_t*)0x2000885c = 8);
    NONFAILING(*(uint32_t*)0x20008860 = 0x75);
    NONFAILING(*(uint32_t*)0x20008864 = 0x10000);
    NONFAILING(*(uint32_t*)0x20008868 = 3);
    NONFAILING(*(uint32_t*)0x2000886c = 4);
    NONFAILING(*(uint32_t*)0x20008870 = 0x6d7a);
    NONFAILING(*(uint32_t*)0x20008874 = 3);
    NONFAILING(*(uint32_t*)0x20008878 = 0xfa);
    NONFAILING(*(uint32_t*)0x2000887c = 0x6264);
    NONFAILING(*(uint32_t*)0x20008880 = 0xc0000000);
    NONFAILING(*(uint32_t*)0x20008884 = 3);
    NONFAILING(*(uint32_t*)0x20008888 = 7);
    NONFAILING(*(uint32_t*)0x2000888c = 0xfffffffa);
    NONFAILING(*(uint32_t*)0x20008890 = 0x233);
    NONFAILING(*(uint32_t*)0x20008894 = 6);
    NONFAILING(*(uint32_t*)0x20008898 = 0xc00000);
    NONFAILING(*(uint32_t*)0x2000889c = 4);
    NONFAILING(*(uint32_t*)0x200088a0 = 4);
    NONFAILING(*(uint32_t*)0x200088a4 = 0xfffffffe);
    NONFAILING(*(uint32_t*)0x200088a8 = 1);
    NONFAILING(*(uint32_t*)0x200088ac = 0xfb4);
    NONFAILING(*(uint32_t*)0x200088b0 = 0x4feb);
    NONFAILING(*(uint32_t*)0x200088b4 = 2);
    NONFAILING(*(uint32_t*)0x200088b8 = 0);
    NONFAILING(*(uint32_t*)0x200088bc = 8);
    NONFAILING(*(uint32_t*)0x200088c0 = 0x8b1);
    NONFAILING(*(uint32_t*)0x200088c4 = 6);
    NONFAILING(*(uint32_t*)0x200088c8 = 3);
    NONFAILING(*(uint32_t*)0x200088cc = 0xffffff01);
    NONFAILING(*(uint32_t*)0x200088d0 = 0x401);
    NONFAILING(*(uint32_t*)0x200088d4 = 0x3d30);
    NONFAILING(*(uint32_t*)0x200088d8 = 0x102);
    NONFAILING(*(uint32_t*)0x200088dc = 0x9c9);
    NONFAILING(*(uint32_t*)0x200088e0 = 0x800);
    NONFAILING(*(uint32_t*)0x200088e4 = 0xffff);
    NONFAILING(*(uint32_t*)0x200088e8 = 0);
    NONFAILING(*(uint32_t*)0x200088ec = 0x7f);
    NONFAILING(*(uint32_t*)0x200088f0 = 7);
    NONFAILING(*(uint32_t*)0x200088f4 = 8);
    NONFAILING(*(uint32_t*)0x200088f8 = 7);
    NONFAILING(*(uint32_t*)0x200088fc = 0xc16c);
    NONFAILING(*(uint32_t*)0x20008900 = 7);
    NONFAILING(*(uint32_t*)0x20008904 = 2);
    NONFAILING(*(uint32_t*)0x20008908 = 0x640);
    NONFAILING(*(uint32_t*)0x2000890c = 0x100);
    NONFAILING(*(uint32_t*)0x20008910 = 0x1000);
    NONFAILING(*(uint32_t*)0x20008914 = 7);
    NONFAILING(*(uint32_t*)0x20008918 = 0xfffffc01);
    NONFAILING(*(uint32_t*)0x2000891c = 0x80000000);
    NONFAILING(*(uint32_t*)0x20008920 = 0x611f4195);
    NONFAILING(*(uint32_t*)0x20008924 = 0xfc3);
    NONFAILING(*(uint32_t*)0x20008928 = 9);
    NONFAILING(*(uint32_t*)0x2000892c = 0xffffffc0);
    NONFAILING(*(uint32_t*)0x20008930 = 3);
    NONFAILING(*(uint32_t*)0x20008934 = 4);
    NONFAILING(*(uint32_t*)0x20008938 = 0x20);
    NONFAILING(*(uint32_t*)0x2000893c = 0);
    NONFAILING(*(uint32_t*)0x20008940 = 1);
    NONFAILING(*(uint32_t*)0x20008944 = 3);
    NONFAILING(*(uint32_t*)0x20008948 = 1);
    NONFAILING(*(uint32_t*)0x2000894c = 6);
    NONFAILING(*(uint32_t*)0x20008950 = 0x3ff);
    NONFAILING(*(uint32_t*)0x20008954 = 0x8001);
    NONFAILING(*(uint32_t*)0x20008958 = 0x3ff);
    NONFAILING(*(uint32_t*)0x2000895c = 0x6d);
    NONFAILING(*(uint32_t*)0x20008960 = 0x100);
    NONFAILING(*(uint32_t*)0x20008964 = 0x8ea);
    NONFAILING(*(uint32_t*)0x20008968 = 9);
    NONFAILING(*(uint32_t*)0x2000896c = 0);
    NONFAILING(*(uint32_t*)0x20008970 = 5);
    NONFAILING(*(uint32_t*)0x20008974 = 3);
    NONFAILING(*(uint32_t*)0x20008978 = 0);
    NONFAILING(*(uint32_t*)0x2000897c = 2);
    NONFAILING(*(uint32_t*)0x20008980 = 0x80000000);
    NONFAILING(*(uint32_t*)0x20008984 = 0);
    NONFAILING(*(uint32_t*)0x20008988 = 1);
    NONFAILING(*(uint32_t*)0x2000898c = 0x7ff);
    NONFAILING(*(uint32_t*)0x20008990 = 0x766);
    NONFAILING(*(uint32_t*)0x20008994 = 6);
    NONFAILING(*(uint32_t*)0x20008998 = 2);
    NONFAILING(*(uint32_t*)0x2000899c = 0x1a89f8f2);
    NONFAILING(*(uint32_t*)0x200089a0 = 0x6d66983e);
    NONFAILING(*(uint32_t*)0x200089a4 = 3);
    NONFAILING(*(uint32_t*)0x200089a8 = 0xc3);
    NONFAILING(*(uint32_t*)0x200089ac = 6);
    NONFAILING(*(uint32_t*)0x200089b0 = 4);
    NONFAILING(*(uint32_t*)0x200089b4 = 0x1ff);
    NONFAILING(*(uint32_t*)0x200089b8 = 6);
    NONFAILING(*(uint32_t*)0x200089bc = 3);
    NONFAILING(*(uint32_t*)0x200089c0 = 0xfffffff8);
    NONFAILING(*(uint32_t*)0x200089c4 = 0);
    NONFAILING(*(uint32_t*)0x200089c8 = 9);
    NONFAILING(*(uint32_t*)0x200089cc = 0x1620);
    NONFAILING(*(uint32_t*)0x200089d0 = 0);
    NONFAILING(*(uint32_t*)0x200089d4 = 8);
    NONFAILING(*(uint32_t*)0x200089d8 = 0x12c);
    NONFAILING(*(uint32_t*)0x200089dc = 0xffffffe1);
    NONFAILING(*(uint32_t*)0x200089e0 = 4);
    NONFAILING(*(uint32_t*)0x200089e4 = 9);
    NONFAILING(*(uint32_t*)0x200089e8 = 0x8000);
    NONFAILING(*(uint32_t*)0x200089ec = 0x5b);
    NONFAILING(*(uint32_t*)0x200089f0 = 4);
    NONFAILING(*(uint32_t*)0x200089f4 = 3);
    NONFAILING(*(uint32_t*)0x200089f8 = 5);
    NONFAILING(*(uint32_t*)0x200089fc = 0x80000000);
    NONFAILING(*(uint32_t*)0x20008a00 = 0x80000000);
    NONFAILING(*(uint32_t*)0x20008a04 = 0);
    NONFAILING(*(uint32_t*)0x20008a08 = 7);
    NONFAILING(*(uint32_t*)0x20008a0c = 0x7fff);
    NONFAILING(*(uint32_t*)0x20008a10 = 3);
    NONFAILING(*(uint32_t*)0x20008a14 = 0);
    NONFAILING(*(uint32_t*)0x20008a18 = 0xfffffffe);
    NONFAILING(*(uint32_t*)0x20008a1c = 0x516);
    NONFAILING(*(uint32_t*)0x20008a20 = 8);
    NONFAILING(*(uint32_t*)0x20008a24 = 8);
    NONFAILING(*(uint32_t*)0x20008a28 = 0xff);
    NONFAILING(*(uint32_t*)0x20008a2c = 0xe3);
    NONFAILING(*(uint32_t*)0x20008a30 = 0);
    NONFAILING(*(uint32_t*)0x20008a34 = 2);
    NONFAILING(*(uint32_t*)0x20008a38 = 0x401);
    NONFAILING(*(uint32_t*)0x20008a3c = 0x831);
    NONFAILING(*(uint32_t*)0x20008a40 = 5);
    NONFAILING(*(uint32_t*)0x20008a44 = 0xa0000);
    NONFAILING(*(uint32_t*)0x20008a48 = 0x80000000);
    NONFAILING(*(uint32_t*)0x20008a4c = 0x12);
    NONFAILING(*(uint32_t*)0x20008a50 = 6);
    NONFAILING(*(uint32_t*)0x20008a54 = 0x80);
    NONFAILING(*(uint32_t*)0x20008a58 = 9);
    NONFAILING(*(uint32_t*)0x20008a5c = 0x10001);
    NONFAILING(*(uint32_t*)0x20008a60 = 0xfffff9ba);
    NONFAILING(*(uint32_t*)0x20008a64 = 0xc4c);
    NONFAILING(*(uint32_t*)0x20008a68 = 0xfffff5f6);
    NONFAILING(*(uint32_t*)0x20008a6c = 1);
    NONFAILING(*(uint32_t*)0x20008a70 = 7);
    NONFAILING(*(uint32_t*)0x20008a74 = 0x1ff);
    NONFAILING(*(uint32_t*)0x20008a78 = 0x7f);
    NONFAILING(*(uint32_t*)0x20008a7c = 0x8e7c);
    NONFAILING(*(uint32_t*)0x20008a80 = 0x28f);
    NONFAILING(*(uint32_t*)0x20008a84 = 0);
    NONFAILING(*(uint32_t*)0x20008a88 = 0x7f);
    NONFAILING(*(uint32_t*)0x20008a8c = 2);
    NONFAILING(*(uint32_t*)0x20008a90 = 0x1000);
    NONFAILING(*(uint32_t*)0x20008a94 = 0x800);
    NONFAILING(*(uint32_t*)0x20008a98 = 5);
    NONFAILING(*(uint32_t*)0x20008a9c = 0x2f);
    NONFAILING(*(uint32_t*)0x20008aa0 = 0xffffdacb);
    NONFAILING(*(uint32_t*)0x20008aa4 = 0);
    NONFAILING(*(uint32_t*)0x20008aa8 = 0x80);
    NONFAILING(*(uint32_t*)0x20008aac = -1);
    NONFAILING(*(uint32_t*)0x20008ab0 = 4);
    NONFAILING(*(uint32_t*)0x20008ab4 = 6);
    NONFAILING(*(uint32_t*)0x20008ab8 = 4);
    NONFAILING(*(uint32_t*)0x20008abc = 0);
    NONFAILING(*(uint32_t*)0x20008ac0 = 7);
    NONFAILING(*(uint32_t*)0x20008ac4 = 7);
    NONFAILING(*(uint32_t*)0x20008ac8 = 2);
    NONFAILING(*(uint32_t*)0x20008acc = 0);
    NONFAILING(*(uint32_t*)0x20008ad0 = 5);
    NONFAILING(*(uint32_t*)0x20008ad4 = 3);
    NONFAILING(*(uint32_t*)0x20008ad8 = 0x100);
    NONFAILING(*(uint32_t*)0x20008adc = 3);
    NONFAILING(*(uint32_t*)0x20008ae0 = 9);
    NONFAILING(*(uint32_t*)0x20008ae4 = 0xfff);
    NONFAILING(*(uint32_t*)0x20008ae8 = 6);
    NONFAILING(*(uint32_t*)0x20008aec = 4);
    NONFAILING(*(uint32_t*)0x20008af0 = 0x401);
    NONFAILING(*(uint32_t*)0x20008af4 = 0x14);
    NONFAILING(*(uint32_t*)0x20008af8 = 0xdc8);
    NONFAILING(*(uint32_t*)0x20008afc = 8);
    NONFAILING(*(uint32_t*)0x20008b00 = 0x7f);
    NONFAILING(*(uint32_t*)0x20008b04 = 9);
    NONFAILING(*(uint32_t*)0x20008b08 = 0x8c);
    NONFAILING(*(uint32_t*)0x20008b0c = 7);
    NONFAILING(*(uint32_t*)0x20008b10 = 0xbab);
    NONFAILING(*(uint32_t*)0x20008b14 = 4);
    NONFAILING(*(uint32_t*)0x20008b18 = 0x67);
    NONFAILING(*(uint32_t*)0x20008b1c = 0xb51);
    NONFAILING(*(uint32_t*)0x20008b20 = 0x7ff);
    NONFAILING(*(uint32_t*)0x20008b24 = 0xddb);
    NONFAILING(*(uint32_t*)0x20008b28 = 2);
    NONFAILING(*(uint32_t*)0x20008b2c = 2);
    NONFAILING(*(uint32_t*)0x20008b30 = 8);
    NONFAILING(*(uint32_t*)0x20008b34 = -1);
    NONFAILING(*(uint32_t*)0x20008b38 = 6);
    NONFAILING(*(uint32_t*)0x20008b3c = 2);
    NONFAILING(*(uint32_t*)0x20008b40 = 8);
    NONFAILING(*(uint32_t*)0x20008b44 = 0x8000);
    NONFAILING(*(uint32_t*)0x20008b48 = 4);
    NONFAILING(*(uint32_t*)0x20008b4c = 0x101);
    NONFAILING(*(uint32_t*)0x20008b50 = 0);
    NONFAILING(*(uint32_t*)0x20008b54 = 0);
    NONFAILING(*(uint32_t*)0x20008b58 = 0x101);
    NONFAILING(*(uint32_t*)0x20008b5c = 0x40);
    NONFAILING(*(uint32_t*)0x20008b60 = 7);
    NONFAILING(*(uint32_t*)0x20008b64 = 8);
    NONFAILING(*(uint32_t*)0x20008b68 = 0x8000);
    NONFAILING(*(uint32_t*)0x20008b6c = 3);
    NONFAILING(*(uint32_t*)0x20008b70 = 3);
    NONFAILING(*(uint32_t*)0x20008b74 = 2);
    NONFAILING(*(uint32_t*)0x20008b78 = 8);
    NONFAILING(*(uint32_t*)0x20008b7c = 1);
    NONFAILING(*(uint32_t*)0x20008b80 = 0x954);
    NONFAILING(*(uint32_t*)0x20008b84 = 0);
    NONFAILING(*(uint32_t*)0x20008b88 = 0xfffffe01);
    NONFAILING(*(uint32_t*)0x20008b8c = 0);
    NONFAILING(*(uint32_t*)0x20008b90 = 0x8000);
    NONFAILING(*(uint32_t*)0x20008b94 = 7);
    NONFAILING(*(uint32_t*)0x20008b98 = 0);
    NONFAILING(*(uint32_t*)0x20008b9c = 2);
    NONFAILING(*(uint32_t*)0x20008ba0 = 5);
    NONFAILING(*(uint32_t*)0x20008ba4 = 1);
    NONFAILING(*(uint32_t*)0x20008ba8 = 9);
    NONFAILING(*(uint32_t*)0x20008bac = 0xfff);
    NONFAILING(*(uint16_t*)0x20008bb0 = 4);
    NONFAILING(*(uint16_t*)0x20008bb2 = 0);
    NONFAILING(*(uint16_t*)0x20008bb4 = 4);
    NONFAILING(*(uint16_t*)0x20008bb6 = 1);
    NONFAILING(*(uint16_t*)0x20008bb8 = 5);
    NONFAILING(*(uint16_t*)0x20008bba = 1);
    NONFAILING(*(uint16_t*)0x20008bbc = 5);
    NONFAILING(*(uint16_t*)0x20008bbe = 0);
    NONFAILING(*(uint16_t*)0x20008bc0 = 2);
    NONFAILING(*(uint16_t*)0x20008bc2 = 1);
    NONFAILING(*(uint16_t*)0x20008bc4 = 5);
    NONFAILING(*(uint16_t*)0x20008bc6 = 1);
    NONFAILING(*(uint16_t*)0x20008bc8 = 5);
    NONFAILING(*(uint16_t*)0x20008bca = 0);
    NONFAILING(*(uint16_t*)0x20008bcc = 4);
    NONFAILING(*(uint16_t*)0x20008bce = 0);
    NONFAILING(*(uint16_t*)0x20008bd0 = 4);
    NONFAILING(*(uint16_t*)0x20008bd2 = 0);
    NONFAILING(*(uint16_t*)0x20008bd4 = 0);
    NONFAILING(*(uint16_t*)0x20008bd6 = 0);
    NONFAILING(*(uint16_t*)0x20008bd8 = 5);
    NONFAILING(*(uint16_t*)0x20008bda = 0);
    NONFAILING(*(uint16_t*)0x20008bdc = 1);
    NONFAILING(*(uint16_t*)0x20008bde = 1);
    NONFAILING(*(uint16_t*)0x20008be0 = 0);
    NONFAILING(*(uint16_t*)0x20008be2 = 0);
    NONFAILING(*(uint16_t*)0x20008be4 = 0);
    NONFAILING(*(uint16_t*)0x20008be6 = 0);
    NONFAILING(*(uint16_t*)0x20008be8 = 1);
    NONFAILING(*(uint16_t*)0x20008bea = 1);
    NONFAILING(*(uint16_t*)0x20008bec = 2);
    NONFAILING(*(uint16_t*)0x20008bee = 1);
    NONFAILING(*(uint16_t*)0x20008bf0 = 1);
    NONFAILING(*(uint16_t*)0x20008bf2 = 0);
    NONFAILING(*(uint16_t*)0x20008bf4 = 0);
    NONFAILING(*(uint16_t*)0x20008bf6 = 1);
    NONFAILING(*(uint16_t*)0x20008bf8 = 4);
    NONFAILING(*(uint16_t*)0x20008bfa = 0);
    NONFAILING(*(uint16_t*)0x20008bfc = 0);
    NONFAILING(*(uint16_t*)0x20008bfe = 1);
    NONFAILING(*(uint16_t*)0x20008c00 = 5);
    NONFAILING(*(uint16_t*)0x20008c02 = 1);
    NONFAILING(*(uint16_t*)0x20008c04 = 3);
    NONFAILING(*(uint16_t*)0x20008c06 = 1);
    NONFAILING(*(uint16_t*)0x20008c08 = 3);
    NONFAILING(*(uint16_t*)0x20008c0a = 0);
    NONFAILING(*(uint16_t*)0x20008c0c = 0);
    NONFAILING(*(uint16_t*)0x20008c0e = 0);
    NONFAILING(*(uint16_t*)0x20008c10 = 5);
    NONFAILING(*(uint16_t*)0x20008c12 = 1);
    NONFAILING(*(uint16_t*)0x20008c14 = 4);
    NONFAILING(*(uint16_t*)0x20008c16 = 1);
    NONFAILING(*(uint16_t*)0x20008c18 = 3);
    NONFAILING(*(uint16_t*)0x20008c1a = 1);
    NONFAILING(*(uint16_t*)0x20008c1c = 5);
    NONFAILING(*(uint16_t*)0x20008c1e = 0);
    NONFAILING(*(uint16_t*)0x20008c20 = 5);
    NONFAILING(*(uint16_t*)0x20008c22 = 1);
    NONFAILING(*(uint16_t*)0x20008c24 = 3);
    NONFAILING(*(uint16_t*)0x20008c26 = 1);
    NONFAILING(*(uint16_t*)0x20008c28 = 4);
    NONFAILING(*(uint16_t*)0x20008c2a = 0);
    NONFAILING(*(uint16_t*)0x20008c2c = 0);
    NONFAILING(*(uint16_t*)0x20008c2e = 1);
    NONFAILING(*(uint16_t*)0x20008c30 = 5);
    NONFAILING(*(uint16_t*)0x20008c32 = 0);
    NONFAILING(*(uint16_t*)0x20008c34 = 1);
    NONFAILING(*(uint16_t*)0x20008c36 = 1);
    NONFAILING(*(uint16_t*)0x20008c38 = 1);
    NONFAILING(*(uint16_t*)0x20008c3a = 0);
    NONFAILING(*(uint16_t*)0x20008c3c = 2);
    NONFAILING(*(uint16_t*)0x20008c3e = 1);
    NONFAILING(*(uint16_t*)0x20008c40 = 3);
    NONFAILING(*(uint16_t*)0x20008c42 = 1);
    NONFAILING(*(uint16_t*)0x20008c44 = 1);
    NONFAILING(*(uint16_t*)0x20008c46 = 0);
    NONFAILING(*(uint16_t*)0x20008c48 = 4);
    NONFAILING(*(uint16_t*)0x20008c4a = 1);
    NONFAILING(*(uint16_t*)0x20008c4c = 2);
    NONFAILING(*(uint16_t*)0x20008c4e = 0);
    NONFAILING(*(uint16_t*)0x20008c50 = 2);
    NONFAILING(*(uint16_t*)0x20008c52 = 0);
    NONFAILING(*(uint16_t*)0x20008c54 = 4);
    NONFAILING(*(uint16_t*)0x20008c56 = 1);
    NONFAILING(*(uint16_t*)0x20008c58 = 4);
    NONFAILING(*(uint16_t*)0x20008c5a = 1);
    NONFAILING(*(uint16_t*)0x20008c5c = 2);
    NONFAILING(*(uint16_t*)0x20008c5e = 1);
    NONFAILING(*(uint16_t*)0x20008c60 = 3);
    NONFAILING(*(uint16_t*)0x20008c62 = 1);
    NONFAILING(*(uint16_t*)0x20008c64 = 2);
    NONFAILING(*(uint16_t*)0x20008c66 = 0);
    NONFAILING(*(uint16_t*)0x20008c68 = 2);
    NONFAILING(*(uint16_t*)0x20008c6a = 0);
    NONFAILING(*(uint16_t*)0x20008c6c = 1);
    NONFAILING(*(uint16_t*)0x20008c6e = 0);
    NONFAILING(*(uint16_t*)0x20008c70 = 3);
    NONFAILING(*(uint16_t*)0x20008c72 = 1);
    NONFAILING(*(uint16_t*)0x20008c74 = 4);
    NONFAILING(*(uint16_t*)0x20008c76 = 0);
    NONFAILING(*(uint16_t*)0x20008c78 = 2);
    NONFAILING(*(uint16_t*)0x20008c7a = 0);
    NONFAILING(*(uint16_t*)0x20008c7c = 6);
    NONFAILING(*(uint16_t*)0x20008c7e = 1);
    NONFAILING(*(uint16_t*)0x20008c80 = 5);
    NONFAILING(*(uint16_t*)0x20008c82 = 1);
    NONFAILING(*(uint16_t*)0x20008c84 = 2);
    NONFAILING(*(uint16_t*)0x20008c86 = 1);
    NONFAILING(*(uint16_t*)0x20008c88 = 4);
    NONFAILING(*(uint16_t*)0x20008c8a = 0);
    NONFAILING(*(uint16_t*)0x20008c8c = 2);
    NONFAILING(*(uint16_t*)0x20008c8e = 0);
    NONFAILING(*(uint16_t*)0x20008c90 = 0);
    NONFAILING(*(uint16_t*)0x20008c92 = 0);
    NONFAILING(*(uint16_t*)0x20008c94 = 0);
    NONFAILING(*(uint16_t*)0x20008c96 = 1);
    NONFAILING(*(uint16_t*)0x20008c98 = 3);
    NONFAILING(*(uint16_t*)0x20008c9a = 1);
    NONFAILING(*(uint16_t*)0x20008c9c = 0);
    NONFAILING(*(uint16_t*)0x20008c9e = 0);
    NONFAILING(*(uint16_t*)0x20008ca0 = 3);
    NONFAILING(*(uint16_t*)0x20008ca2 = 0);
    NONFAILING(*(uint16_t*)0x20008ca4 = 2);
    NONFAILING(*(uint16_t*)0x20008ca6 = 0);
    NONFAILING(*(uint16_t*)0x20008ca8 = 0);
    NONFAILING(*(uint16_t*)0x20008caa = 1);
    NONFAILING(*(uint16_t*)0x20008cac = 0);
    NONFAILING(*(uint16_t*)0x20008cae = 1);
    NONFAILING(*(uint16_t*)0x20008cb0 = 0);
    NONFAILING(*(uint16_t*)0x20008cb2 = 0);
    NONFAILING(*(uint16_t*)0x20008cb4 = 5);
    NONFAILING(*(uint16_t*)0x20008cb6 = 0);
    NONFAILING(*(uint16_t*)0x20008cb8 = 1);
    NONFAILING(*(uint16_t*)0x20008cba = 0);
    NONFAILING(*(uint16_t*)0x20008cbc = 0);
    NONFAILING(*(uint16_t*)0x20008cbe = 1);
    NONFAILING(*(uint16_t*)0x20008cc0 = 4);
    NONFAILING(*(uint16_t*)0x20008cc2 = 0);
    NONFAILING(*(uint16_t*)0x20008cc4 = 2);
    NONFAILING(*(uint16_t*)0x20008cc6 = 0);
    NONFAILING(*(uint16_t*)0x20008cc8 = 4);
    NONFAILING(*(uint16_t*)0x20008cca = 0);
    NONFAILING(*(uint16_t*)0x20008ccc = 0);
    NONFAILING(*(uint16_t*)0x20008cce = 0);
    NONFAILING(*(uint16_t*)0x20008cd0 = 5);
    NONFAILING(*(uint16_t*)0x20008cd2 = 0);
    NONFAILING(*(uint16_t*)0x20008cd4 = 3);
    NONFAILING(*(uint16_t*)0x20008cd6 = 0);
    NONFAILING(*(uint16_t*)0x20008cd8 = 4);
    NONFAILING(*(uint16_t*)0x20008cda = 0);
    NONFAILING(*(uint16_t*)0x20008cdc = 1);
    NONFAILING(*(uint16_t*)0x20008cde = 0);
    NONFAILING(*(uint16_t*)0x20008ce0 = 5);
    NONFAILING(*(uint16_t*)0x20008ce2 = 0);
    NONFAILING(*(uint16_t*)0x20008ce4 = 3);
    NONFAILING(*(uint16_t*)0x20008ce6 = 0);
    NONFAILING(*(uint16_t*)0x20008ce8 = 1);
    NONFAILING(*(uint16_t*)0x20008cea = 0);
    NONFAILING(*(uint16_t*)0x20008cec = 1);
    NONFAILING(*(uint16_t*)0x20008cee = 0);
    NONFAILING(*(uint16_t*)0x20008cf0 = 5);
    NONFAILING(*(uint16_t*)0x20008cf2 = 0);
    NONFAILING(*(uint16_t*)0x20008cf4 = 0);
    NONFAILING(*(uint16_t*)0x20008cf6 = 0);
    NONFAILING(*(uint16_t*)0x20008cf8 = 1);
    NONFAILING(*(uint16_t*)0x20008cfa = 0);
    NONFAILING(*(uint16_t*)0x20008cfc = 2);
    NONFAILING(*(uint16_t*)0x20008cfe = 0);
    NONFAILING(*(uint16_t*)0x20008d00 = 5);
    NONFAILING(*(uint16_t*)0x20008d02 = 0);
    NONFAILING(*(uint16_t*)0x20008d04 = 1);
    NONFAILING(*(uint16_t*)0x20008d06 = 0);
    NONFAILING(*(uint16_t*)0x20008d08 = 1);
    NONFAILING(*(uint16_t*)0x20008d0a = 0);
    NONFAILING(*(uint16_t*)0x20008d0c = 3);
    NONFAILING(*(uint16_t*)0x20008d0e = 0);
    NONFAILING(*(uint16_t*)0x20008d10 = 5);
    NONFAILING(*(uint16_t*)0x20008d12 = 1);
    NONFAILING(*(uint16_t*)0x20008d14 = 1);
    NONFAILING(*(uint16_t*)0x20008d16 = 0);
    NONFAILING(*(uint16_t*)0x20008d18 = 4);
    NONFAILING(*(uint16_t*)0x20008d1a = 0);
    NONFAILING(*(uint16_t*)0x20008d1c = 0);
    NONFAILING(*(uint16_t*)0x20008d1e = 1);
    NONFAILING(*(uint16_t*)0x20008d20 = 7);
    NONFAILING(*(uint16_t*)0x20008d22 = 0);
    NONFAILING(*(uint16_t*)0x20008d24 = 4);
    NONFAILING(*(uint16_t*)0x20008d26 = 0);
    NONFAILING(*(uint16_t*)0x20008d28 = 5);
    NONFAILING(*(uint16_t*)0x20008d2a = 1);
    NONFAILING(*(uint16_t*)0x20008d2c = 1);
    NONFAILING(*(uint16_t*)0x20008d2e = 1);
    NONFAILING(*(uint16_t*)0x20008d30 = 4);
    NONFAILING(*(uint16_t*)0x20008d32 = 0);
    NONFAILING(*(uint16_t*)0x20008d34 = 4);
    NONFAILING(*(uint16_t*)0x20008d36 = 2);
    NONFAILING(*(uint16_t*)0x20008d38 = 3);
    NONFAILING(*(uint16_t*)0x20008d3a = 1);
    NONFAILING(*(uint16_t*)0x20008d3c = 5);
    NONFAILING(*(uint16_t*)0x20008d3e = 0);
    NONFAILING(*(uint16_t*)0x20008d40 = 5);
    NONFAILING(*(uint16_t*)0x20008d42 = 1);
    NONFAILING(*(uint16_t*)0x20008d44 = 4);
    NONFAILING(*(uint16_t*)0x20008d46 = 0);
    NONFAILING(*(uint16_t*)0x20008d48 = 5);
    NONFAILING(*(uint16_t*)0x20008d4a = 0);
    NONFAILING(*(uint16_t*)0x20008d4c = 2);
    NONFAILING(*(uint16_t*)0x20008d4e = 0);
    NONFAILING(*(uint16_t*)0x20008d50 = 2);
    NONFAILING(*(uint16_t*)0x20008d52 = 0);
    NONFAILING(*(uint16_t*)0x20008d54 = 2);
    NONFAILING(*(uint16_t*)0x20008d56 = 0);
    NONFAILING(*(uint16_t*)0x20008d58 = 4);
    NONFAILING(*(uint16_t*)0x20008d5a = 0);
    NONFAILING(*(uint16_t*)0x20008d5c = 3);
    NONFAILING(*(uint16_t*)0x20008d5e = 0);
    NONFAILING(*(uint16_t*)0x20008d60 = 4);
    NONFAILING(*(uint16_t*)0x20008d62 = 0);
    NONFAILING(*(uint16_t*)0x20008d64 = 3);
    NONFAILING(*(uint16_t*)0x20008d66 = 1);
    NONFAILING(*(uint16_t*)0x20008d68 = 4);
    NONFAILING(*(uint16_t*)0x20008d6a = 1);
    NONFAILING(*(uint16_t*)0x20008d6c = 6);
    NONFAILING(*(uint16_t*)0x20008d6e = 0);
    NONFAILING(*(uint16_t*)0x20008d70 = 7);
    NONFAILING(*(uint16_t*)0x20008d72 = 1);
    NONFAILING(*(uint16_t*)0x20008d74 = 0);
    NONFAILING(*(uint16_t*)0x20008d76 = 1);
    NONFAILING(*(uint16_t*)0x20008d78 = 2);
    NONFAILING(*(uint16_t*)0x20008d7a = 1);
    NONFAILING(*(uint16_t*)0x20008d7c = 0);
    NONFAILING(*(uint16_t*)0x20008d7e = 0);
    NONFAILING(*(uint16_t*)0x20008d80 = 2);
    NONFAILING(*(uint16_t*)0x20008d82 = 0);
    NONFAILING(*(uint16_t*)0x20008d84 = 5);
    NONFAILING(*(uint16_t*)0x20008d86 = 0);
    NONFAILING(*(uint16_t*)0x20008d88 = 2);
    NONFAILING(*(uint16_t*)0x20008d8a = 0);
    NONFAILING(*(uint16_t*)0x20008d8c = 4);
    NONFAILING(*(uint16_t*)0x20008d8e = 0);
    NONFAILING(*(uint16_t*)0x20008d90 = 4);
    NONFAILING(*(uint16_t*)0x20008d92 = 0);
    NONFAILING(*(uint16_t*)0x20008d94 = 4);
    NONFAILING(*(uint16_t*)0x20008d96 = 0);
    NONFAILING(*(uint16_t*)0x20008d98 = 1);
    NONFAILING(*(uint16_t*)0x20008d9a = 0);
    NONFAILING(*(uint16_t*)0x20008d9c = 5);
    NONFAILING(*(uint16_t*)0x20008d9e = 1);
    NONFAILING(*(uint16_t*)0x20008da0 = 0);
    NONFAILING(*(uint16_t*)0x20008da2 = 1);
    NONFAILING(*(uint16_t*)0x20008da4 = 4);
    NONFAILING(*(uint16_t*)0x20008da6 = 1);
    NONFAILING(*(uint16_t*)0x20008da8 = 1);
    NONFAILING(*(uint16_t*)0x20008daa = 0);
    NONFAILING(*(uint16_t*)0x20008dac = 1);
    NONFAILING(*(uint16_t*)0x20008dae = 0);
    NONFAILING(*(uint8_t*)0x20008db0 = 1);
    NONFAILING(*(uint16_t*)0x20008db4 = 4);
    NONFAILING(*(uint16_t*)0x20008db6 = 6);
    NONFAILING(*(uint16_t*)0x20008db8 = 0xc);
    NONFAILING(*(uint16_t*)0x20008dba = 7);
    NONFAILING(*(uint32_t*)0x20008dbc = 0);
    NONFAILING(*(uint32_t*)0x20008dc0 = 0);
    NONFAILING(*(uint16_t*)0x20008dc4 = 0xc);
    NONFAILING(*(uint16_t*)0x20008dc6 = 8);
    NONFAILING(*(uint32_t*)0x20008dc8 = 3);
    NONFAILING(*(uint32_t*)0x20008dcc = 1);
    NONFAILING(*(uint16_t*)0x20008dd0 = 6);
    NONFAILING(*(uint16_t*)0x20008dd2 = 2);
    NONFAILING(*(uint16_t*)0x20008dd4 = 2);
    NONFAILING(*(uint64_t*)0x20000188 = 0x41d8);
    NONFAILING(*(uint64_t*)0x200001d8 = 1);
    NONFAILING(*(uint64_t*)0x200001e0 = 0);
    NONFAILING(*(uint64_t*)0x200001e8 = 0);
    NONFAILING(*(uint32_t*)0x200001f0 = 0);
    syscall(__NR_sendmsg, r[0], 0x200001c0ul, 0ul);
    break;
  }
}
int main(void)
{
  syscall(__NR_mmap, 0x1ffff000ul, 0x1000ul, 0ul, 0x32ul, -1, 0ul);
  syscall(__NR_mmap, 0x20000000ul, 0x1000000ul, 7ul, 0x32ul, -1, 0ul);
  syscall(__NR_mmap, 0x21000000ul, 0x1000ul, 0ul, 0x32ul, -1, 0ul);
  setup_leak();
  install_segv_handler();
  use_temporary_dir();
  do_sandbox_none();
  return 0;
}