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

#define _GNU_SOURCE

#include <arpa/inet.h>
#include <dirent.h>
#include <endian.h>
#include <errno.h>
#include <fcntl.h>
#include <net/if.h>
#include <net/if_arp.h>
#include <netinet/in.h>
#include <pthread.h>
#include <sched.h>
#include <signal.h>
#include <stdarg.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/epoll.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/uio.h>
#include <sys/wait.h>
#include <time.h>
#include <unistd.h>

#include <linux/capability.h>
#include <linux/futex.h>
#include <linux/genetlink.h>
#include <linux/if_addr.h>
#include <linux/if_ether.h>
#include <linux/if_link.h>
#include <linux/if_tun.h>
#include <linux/in6.h>
#include <linux/ip.h>
#include <linux/neighbour.h>
#include <linux/net.h>
#include <linux/netlink.h>
#include <linux/rfkill.h>
#include <linux/rtnetlink.h>
#include <linux/tcp.h>
#include <linux/veth.h>

static unsigned long long procid;

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;
}

struct nlmsg {
  char* pos;
  int nesting;
  struct nlattr* nested[8];
  char buf[4096];
};

static void netlink_init(struct nlmsg* nlmsg, int typ, int flags,
                         const void* data, int size)
{
  memset(nlmsg, 0, sizeof(*nlmsg));
  struct nlmsghdr* hdr = (struct nlmsghdr*)nlmsg->buf;
  hdr->nlmsg_type = typ;
  hdr->nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK | flags;
  memcpy(hdr + 1, data, size);
  nlmsg->pos = (char*)(hdr + 1) + NLMSG_ALIGN(size);
}

static void netlink_attr(struct nlmsg* nlmsg, int typ, const void* data,
                         int size)
{
  struct nlattr* attr = (struct nlattr*)nlmsg->pos;
  attr->nla_len = sizeof(*attr) + size;
  attr->nla_type = typ;
  if (size > 0)
    memcpy(attr + 1, data, size);
  nlmsg->pos += NLMSG_ALIGN(attr->nla_len);
}

static void netlink_nest(struct nlmsg* nlmsg, int typ)
{
  struct nlattr* attr = (struct nlattr*)nlmsg->pos;
  attr->nla_type = typ;
  nlmsg->pos += sizeof(*attr);
  nlmsg->nested[nlmsg->nesting++] = attr;
}

static void netlink_done(struct nlmsg* nlmsg)
{
  struct nlattr* attr = nlmsg->nested[--nlmsg->nesting];
  attr->nla_len = nlmsg->pos - (char*)attr;
}

static int netlink_send_ext(struct nlmsg* nlmsg, int sock, uint16_t reply_type,
                            int* reply_len)
{
  if (nlmsg->pos > nlmsg->buf + sizeof(nlmsg->buf) || nlmsg->nesting)
    exit(1);
  struct nlmsghdr* hdr = (struct nlmsghdr*)nlmsg->buf;
  hdr->nlmsg_len = nlmsg->pos - nlmsg->buf;
  struct sockaddr_nl addr;
  memset(&addr, 0, sizeof(addr));
  addr.nl_family = AF_NETLINK;
  unsigned n = sendto(sock, nlmsg->buf, hdr->nlmsg_len, 0,
                      (struct sockaddr*)&addr, sizeof(addr));
  if (n != hdr->nlmsg_len)
    exit(1);
  n = recv(sock, nlmsg->buf, sizeof(nlmsg->buf), 0);
  if (reply_len)
    *reply_len = 0;
  if (hdr->nlmsg_type == NLMSG_DONE)
    return 0;
  if (n < sizeof(struct nlmsghdr))
    exit(1);
  if (reply_len && hdr->nlmsg_type == reply_type) {
    *reply_len = n;
    return 0;
  }
  if (n < sizeof(struct nlmsghdr) + sizeof(struct nlmsgerr))
    exit(1);
  if (hdr->nlmsg_type != NLMSG_ERROR)
    exit(1);
  return ((struct nlmsgerr*)(hdr + 1))->error;
}

static int netlink_send(struct nlmsg* nlmsg, int sock)
{
  return netlink_send_ext(nlmsg, sock, 0, NULL);
}

static int netlink_query_family_id(struct nlmsg* nlmsg, int sock,
                                   const char* family_name)
{
  struct genlmsghdr genlhdr;
  memset(&genlhdr, 0, sizeof(genlhdr));
  genlhdr.cmd = CTRL_CMD_GETFAMILY;
  netlink_init(nlmsg, GENL_ID_CTRL, 0, &genlhdr, sizeof(genlhdr));
  netlink_attr(nlmsg, CTRL_ATTR_FAMILY_NAME, family_name,
               strnlen(family_name, GENL_NAMSIZ - 1) + 1);
  int n = 0;
  int err = netlink_send_ext(nlmsg, sock, GENL_ID_CTRL, &n);
  if (err < 0) {
    return -1;
  }
  uint16_t id = 0;
  struct nlattr* attr = (struct nlattr*)(nlmsg->buf + NLMSG_HDRLEN +
                                         NLMSG_ALIGN(sizeof(genlhdr)));
  for (; (char*)attr < nlmsg->buf + n;
       attr = (struct nlattr*)((char*)attr + NLMSG_ALIGN(attr->nla_len))) {
    if (attr->nla_type == CTRL_ATTR_FAMILY_ID) {
      id = *(uint16_t*)(attr + 1);
      break;
    }
  }
  if (!id) {
    return -1;
  }
  recv(sock, nlmsg->buf, sizeof(nlmsg->buf), 0);
  return id;
}

static int netlink_next_msg(struct nlmsg* nlmsg, unsigned int offset,
                            unsigned int total_len)
{
  struct nlmsghdr* hdr = (struct nlmsghdr*)(nlmsg->buf + offset);
  if (offset == total_len || offset + hdr->nlmsg_len > total_len)
    return -1;
  return hdr->nlmsg_len;
}

static void netlink_add_device_impl(struct nlmsg* nlmsg, const char* type,
                                    const char* name)
{
  struct ifinfomsg hdr;
  memset(&hdr, 0, sizeof(hdr));
  netlink_init(nlmsg, RTM_NEWLINK, NLM_F_EXCL | NLM_F_CREATE, &hdr,
               sizeof(hdr));
  if (name)
    netlink_attr(nlmsg, IFLA_IFNAME, name, strlen(name));
  netlink_nest(nlmsg, IFLA_LINKINFO);
  netlink_attr(nlmsg, IFLA_INFO_KIND, type, strlen(type));
}

static void netlink_add_device(struct nlmsg* nlmsg, int sock, const char* type,
                               const char* name)
{
  netlink_add_device_impl(nlmsg, type, name);
  netlink_done(nlmsg);
  int err = netlink_send(nlmsg, sock);
  (void)err;
}

static void netlink_add_veth(struct nlmsg* nlmsg, int sock, const char* name,
                             const char* peer)
{
  netlink_add_device_impl(nlmsg, "veth", name);
  netlink_nest(nlmsg, IFLA_INFO_DATA);
  netlink_nest(nlmsg, VETH_INFO_PEER);
  nlmsg->pos += sizeof(struct ifinfomsg);
  netlink_attr(nlmsg, IFLA_IFNAME, peer, strlen(peer));
  netlink_done(nlmsg);
  netlink_done(nlmsg);
  netlink_done(nlmsg);
  int err = netlink_send(nlmsg, sock);
  (void)err;
}

static void netlink_add_hsr(struct nlmsg* nlmsg, int sock, const char* name,
                            const char* slave1, const char* slave2)
{
  netlink_add_device_impl(nlmsg, "hsr", name);
  netlink_nest(nlmsg, IFLA_INFO_DATA);
  int ifindex1 = if_nametoindex(slave1);
  netlink_attr(nlmsg, IFLA_HSR_SLAVE1, &ifindex1, sizeof(ifindex1));
  int ifindex2 = if_nametoindex(slave2);
  netlink_attr(nlmsg, IFLA_HSR_SLAVE2, &ifindex2, sizeof(ifindex2));
  netlink_done(nlmsg);
  netlink_done(nlmsg);
  int err = netlink_send(nlmsg, sock);
  (void)err;
}

static void netlink_add_linked(struct nlmsg* nlmsg, int sock, const char* type,
                               const char* name, const char* link)
{
  netlink_add_device_impl(nlmsg, type, name);
  netlink_done(nlmsg);
  int ifindex = if_nametoindex(link);
  netlink_attr(nlmsg, IFLA_LINK, &ifindex, sizeof(ifindex));
  int err = netlink_send(nlmsg, sock);
  (void)err;
}

static void netlink_add_vlan(struct nlmsg* nlmsg, int sock, const char* name,
                             const char* link, uint16_t id, uint16_t proto)
{
  netlink_add_device_impl(nlmsg, "vlan", name);
  netlink_nest(nlmsg, IFLA_INFO_DATA);
  netlink_attr(nlmsg, IFLA_VLAN_ID, &id, sizeof(id));
  netlink_attr(nlmsg, IFLA_VLAN_PROTOCOL, &proto, sizeof(proto));
  netlink_done(nlmsg);
  netlink_done(nlmsg);
  int ifindex = if_nametoindex(link);
  netlink_attr(nlmsg, IFLA_LINK, &ifindex, sizeof(ifindex));
  int err = netlink_send(nlmsg, sock);
  (void)err;
}

static void netlink_add_macvlan(struct nlmsg* nlmsg, int sock, const char* name,
                                const char* link)
{
  netlink_add_device_impl(nlmsg, "macvlan", name);
  netlink_nest(nlmsg, IFLA_INFO_DATA);
  uint32_t mode = MACVLAN_MODE_BRIDGE;
  netlink_attr(nlmsg, IFLA_MACVLAN_MODE, &mode, sizeof(mode));
  netlink_done(nlmsg);
  netlink_done(nlmsg);
  int ifindex = if_nametoindex(link);
  netlink_attr(nlmsg, IFLA_LINK, &ifindex, sizeof(ifindex));
  int err = netlink_send(nlmsg, sock);
  (void)err;
}

static void netlink_add_geneve(struct nlmsg* nlmsg, int sock, const char* name,
                               uint32_t vni, struct in_addr* addr4,
                               struct in6_addr* addr6)
{
  netlink_add_device_impl(nlmsg, "geneve", name);
  netlink_nest(nlmsg, IFLA_INFO_DATA);
  netlink_attr(nlmsg, IFLA_GENEVE_ID, &vni, sizeof(vni));
  if (addr4)
    netlink_attr(nlmsg, IFLA_GENEVE_REMOTE, addr4, sizeof(*addr4));
  if (addr6)
    netlink_attr(nlmsg, IFLA_GENEVE_REMOTE6, addr6, sizeof(*addr6));
  netlink_done(nlmsg);
  netlink_done(nlmsg);
  int err = netlink_send(nlmsg, sock);
  (void)err;
}

#define IFLA_IPVLAN_FLAGS 2
#define IPVLAN_MODE_L3S 2
#undef IPVLAN_F_VEPA
#define IPVLAN_F_VEPA 2

static void netlink_add_ipvlan(struct nlmsg* nlmsg, int sock, const char* name,
                               const char* link, uint16_t mode, uint16_t flags)
{
  netlink_add_device_impl(nlmsg, "ipvlan", name);
  netlink_nest(nlmsg, IFLA_INFO_DATA);
  netlink_attr(nlmsg, IFLA_IPVLAN_MODE, &mode, sizeof(mode));
  netlink_attr(nlmsg, IFLA_IPVLAN_FLAGS, &flags, sizeof(flags));
  netlink_done(nlmsg);
  netlink_done(nlmsg);
  int ifindex = if_nametoindex(link);
  netlink_attr(nlmsg, IFLA_LINK, &ifindex, sizeof(ifindex));
  int err = netlink_send(nlmsg, sock);
  (void)err;
}

static void netlink_device_change(struct nlmsg* nlmsg, int sock,
                                  const char* name, bool up, const char* master,
                                  const void* mac, int macsize,
                                  const char* new_name)
{
  struct ifinfomsg hdr;
  memset(&hdr, 0, sizeof(hdr));
  if (up)
    hdr.ifi_flags = hdr.ifi_change = IFF_UP;
  hdr.ifi_index = if_nametoindex(name);
  netlink_init(nlmsg, RTM_NEWLINK, 0, &hdr, sizeof(hdr));
  if (new_name)
    netlink_attr(nlmsg, IFLA_IFNAME, new_name, strlen(new_name));
  if (master) {
    int ifindex = if_nametoindex(master);
    netlink_attr(nlmsg, IFLA_MASTER, &ifindex, sizeof(ifindex));
  }
  if (macsize)
    netlink_attr(nlmsg, IFLA_ADDRESS, mac, macsize);
  int err = netlink_send(nlmsg, sock);
  (void)err;
}

static int netlink_add_addr(struct nlmsg* nlmsg, int sock, const char* dev,
                            const void* addr, int addrsize)
{
  struct ifaddrmsg hdr;
  memset(&hdr, 0, sizeof(hdr));
  hdr.ifa_family = addrsize == 4 ? AF_INET : AF_INET6;
  hdr.ifa_prefixlen = addrsize == 4 ? 24 : 120;
  hdr.ifa_scope = RT_SCOPE_UNIVERSE;
  hdr.ifa_index = if_nametoindex(dev);
  netlink_init(nlmsg, RTM_NEWADDR, NLM_F_CREATE | NLM_F_REPLACE, &hdr,
               sizeof(hdr));
  netlink_attr(nlmsg, IFA_LOCAL, addr, addrsize);
  netlink_attr(nlmsg, IFA_ADDRESS, addr, addrsize);
  return netlink_send(nlmsg, sock);
}

static void netlink_add_addr4(struct nlmsg* nlmsg, int sock, const char* dev,
                              const char* addr)
{
  struct in_addr in_addr;
  inet_pton(AF_INET, addr, &in_addr);
  int err = netlink_add_addr(nlmsg, sock, dev, &in_addr, sizeof(in_addr));
  (void)err;
}

static void netlink_add_addr6(struct nlmsg* nlmsg, int sock, const char* dev,
                              const char* addr)
{
  struct in6_addr in6_addr;
  inet_pton(AF_INET6, addr, &in6_addr);
  int err = netlink_add_addr(nlmsg, sock, dev, &in6_addr, sizeof(in6_addr));
  (void)err;
}

static void netlink_add_neigh(struct nlmsg* nlmsg, int sock, const char* name,
                              const void* addr, int addrsize, const void* mac,
                              int macsize)
{
  struct ndmsg hdr;
  memset(&hdr, 0, sizeof(hdr));
  hdr.ndm_family = addrsize == 4 ? AF_INET : AF_INET6;
  hdr.ndm_ifindex = if_nametoindex(name);
  hdr.ndm_state = NUD_PERMANENT;
  netlink_init(nlmsg, RTM_NEWNEIGH, NLM_F_EXCL | NLM_F_CREATE, &hdr,
               sizeof(hdr));
  netlink_attr(nlmsg, NDA_DST, addr, addrsize);
  netlink_attr(nlmsg, NDA_LLADDR, mac, macsize);
  int err = netlink_send(nlmsg, sock);
  (void)err;
}

static struct nlmsg nlmsg;

static int tunfd = -1;

#define TUN_IFACE "syz_tun"
#define LOCAL_MAC 0xaaaaaaaaaaaa
#define REMOTE_MAC 0xaaaaaaaaaabb
#define LOCAL_IPV4 "172.20.20.170"
#define REMOTE_IPV4 "172.20.20.187"
#define LOCAL_IPV6 "fe80::aa"
#define REMOTE_IPV6 "fe80::bb"

#define IFF_NAPI 0x0010

static void initialize_tun(void)
{
  tunfd = open("/dev/net/tun", O_RDWR | O_NONBLOCK);
  if (tunfd == -1) {
    printf("tun: can't open /dev/net/tun: please enable CONFIG_TUN=y\n");
    printf("otherwise fuzzing or reproducing might not work as intended\n");
    return;
  }
  const int kTunFd = 240;
  if (dup2(tunfd, kTunFd) < 0)
    exit(1);
  close(tunfd);
  tunfd = kTunFd;
  struct ifreq ifr;
  memset(&ifr, 0, sizeof(ifr));
  strncpy(ifr.ifr_name, TUN_IFACE, IFNAMSIZ);
  ifr.ifr_flags = IFF_TAP | IFF_NO_PI;
  if (ioctl(tunfd, TUNSETIFF, (void*)&ifr) < 0) {
    exit(1);
  }
  char sysctl[64];
  sprintf(sysctl, "/proc/sys/net/ipv6/conf/%s/accept_dad", TUN_IFACE);
  write_file(sysctl, "0");
  sprintf(sysctl, "/proc/sys/net/ipv6/conf/%s/router_solicitations", TUN_IFACE);
  write_file(sysctl, "0");
  int sock = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
  if (sock == -1)
    exit(1);
  netlink_add_addr4(&nlmsg, sock, TUN_IFACE, LOCAL_IPV4);
  netlink_add_addr6(&nlmsg, sock, TUN_IFACE, LOCAL_IPV6);
  uint64_t macaddr = REMOTE_MAC;
  struct in_addr in_addr;
  inet_pton(AF_INET, REMOTE_IPV4, &in_addr);
  netlink_add_neigh(&nlmsg, sock, TUN_IFACE, &in_addr, sizeof(in_addr),
                    &macaddr, ETH_ALEN);
  struct in6_addr in6_addr;
  inet_pton(AF_INET6, REMOTE_IPV6, &in6_addr);
  netlink_add_neigh(&nlmsg, sock, TUN_IFACE, &in6_addr, sizeof(in6_addr),
                    &macaddr, ETH_ALEN);
  macaddr = LOCAL_MAC;
  netlink_device_change(&nlmsg, sock, TUN_IFACE, true, 0, &macaddr, ETH_ALEN,
                        NULL);
  close(sock);
}

const int kInitNetNsFd = 239;

#define DEVLINK_FAMILY_NAME "devlink"

#define DEVLINK_CMD_PORT_GET 5
#define DEVLINK_ATTR_BUS_NAME 1
#define DEVLINK_ATTR_DEV_NAME 2
#define DEVLINK_ATTR_NETDEV_NAME 7

static struct nlmsg nlmsg2;

static void initialize_devlink_ports(const char* bus_name, const char* dev_name,
                                     const char* netdev_prefix)
{
  struct genlmsghdr genlhdr;
  int len, total_len, id, err, offset;
  uint16_t netdev_index;
  int sock = socket(AF_NETLINK, SOCK_RAW, NETLINK_GENERIC);
  if (sock == -1)
    exit(1);
  int rtsock = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
  if (rtsock == -1)
    exit(1);
  id = netlink_query_family_id(&nlmsg, sock, DEVLINK_FAMILY_NAME);
  if (id == -1)
    goto error;
  memset(&genlhdr, 0, sizeof(genlhdr));
  genlhdr.cmd = DEVLINK_CMD_PORT_GET;
  netlink_init(&nlmsg, id, NLM_F_DUMP, &genlhdr, sizeof(genlhdr));
  netlink_attr(&nlmsg, DEVLINK_ATTR_BUS_NAME, bus_name, strlen(bus_name) + 1);
  netlink_attr(&nlmsg, DEVLINK_ATTR_DEV_NAME, dev_name, strlen(dev_name) + 1);
  err = netlink_send_ext(&nlmsg, sock, id, &total_len);
  if (err < 0) {
    goto error;
  }
  offset = 0;
  netdev_index = 0;
  while ((len = netlink_next_msg(&nlmsg, offset, total_len)) != -1) {
    struct nlattr* attr = (struct nlattr*)(nlmsg.buf + offset + NLMSG_HDRLEN +
                                           NLMSG_ALIGN(sizeof(genlhdr)));
    for (; (char*)attr < nlmsg.buf + offset + len;
         attr = (struct nlattr*)((char*)attr + NLMSG_ALIGN(attr->nla_len))) {
      if (attr->nla_type == DEVLINK_ATTR_NETDEV_NAME) {
        char* port_name;
        char netdev_name[IFNAMSIZ];
        port_name = (char*)(attr + 1);
        snprintf(netdev_name, sizeof(netdev_name), "%s%d", netdev_prefix,
                 netdev_index);
        netlink_device_change(&nlmsg2, rtsock, port_name, true, 0, 0, 0,
                              netdev_name);
        break;
      }
    }
    offset += len;
    netdev_index++;
  }
error:
  close(rtsock);
  close(sock);
}

#define DEV_IPV4 "172.20.20.%d"
#define DEV_IPV6 "fe80::%02x"
#define DEV_MAC 0x00aaaaaaaaaa

static void netdevsim_add(unsigned int addr, unsigned int port_count)
{
  char buf[16];
  sprintf(buf, "%u %u", addr, port_count);
  if (write_file("/sys/bus/netdevsim/new_device", buf)) {
    snprintf(buf, sizeof(buf), "netdevsim%d", addr);
    initialize_devlink_ports("netdevsim", buf, "netdevsim");
  }
}

#define WG_GENL_NAME "wireguard"
enum wg_cmd {
  WG_CMD_GET_DEVICE,
  WG_CMD_SET_DEVICE,
};
enum wgdevice_attribute {
  WGDEVICE_A_UNSPEC,
  WGDEVICE_A_IFINDEX,
  WGDEVICE_A_IFNAME,
  WGDEVICE_A_PRIVATE_KEY,
  WGDEVICE_A_PUBLIC_KEY,
  WGDEVICE_A_FLAGS,
  WGDEVICE_A_LISTEN_PORT,
  WGDEVICE_A_FWMARK,
  WGDEVICE_A_PEERS,
};
enum wgpeer_attribute {
  WGPEER_A_UNSPEC,
  WGPEER_A_PUBLIC_KEY,
  WGPEER_A_PRESHARED_KEY,
  WGPEER_A_FLAGS,
  WGPEER_A_ENDPOINT,
  WGPEER_A_PERSISTENT_KEEPALIVE_INTERVAL,
  WGPEER_A_LAST_HANDSHAKE_TIME,
  WGPEER_A_RX_BYTES,
  WGPEER_A_TX_BYTES,
  WGPEER_A_ALLOWEDIPS,
  WGPEER_A_PROTOCOL_VERSION,
};
enum wgallowedip_attribute {
  WGALLOWEDIP_A_UNSPEC,
  WGALLOWEDIP_A_FAMILY,
  WGALLOWEDIP_A_IPADDR,
  WGALLOWEDIP_A_CIDR_MASK,
};

static void netlink_wireguard_setup(void)
{
  const char ifname_a[] = "wg0";
  const char ifname_b[] = "wg1";
  const char ifname_c[] = "wg2";
  const char private_a[] = "\xa0\x5c\xa8\x4f\x6c\x9c\x8e\x38\x53\xe2\xfd\x7a"
                           "\x70\xae\x0f\xb2\x0f\xa1\x52\x60\x0c\xb0\x08\x45"
                           "\x17\x4f\x08\x07\x6f\x8d\x78\x43";
  const char private_b[] = "\xb0\x80\x73\xe8\xd4\x4e\x91\xe3\xda\x92\x2c\x22"
                           "\x43\x82\x44\xbb\x88\x5c\x69\xe2\x69\xc8\xe9\xd8"
                           "\x35\xb1\x14\x29\x3a\x4d\xdc\x6e";
  const char private_c[] = "\xa0\xcb\x87\x9a\x47\xf5\xbc\x64\x4c\x0e\x69\x3f"
                           "\xa6\xd0\x31\xc7\x4a\x15\x53\xb6\xe9\x01\xb9\xff"
                           "\x2f\x51\x8c\x78\x04\x2f\xb5\x42";
  const char public_a[] = "\x97\x5c\x9d\x81\xc9\x83\xc8\x20\x9e\xe7\x81\x25\x4b"
                          "\x89\x9f\x8e\xd9\x25\xae\x9f\x09\x23\xc2\x3c\x62\xf5"
                          "\x3c\x57\xcd\xbf\x69\x1c";
  const char public_b[] = "\xd1\x73\x28\x99\xf6\x11\xcd\x89\x94\x03\x4d\x7f\x41"
                          "\x3d\xc9\x57\x63\x0e\x54\x93\xc2\x85\xac\xa4\x00\x65"
                          "\xcb\x63\x11\xbe\x69\x6b";
  const char public_c[] = "\xf4\x4d\xa3\x67\xa8\x8e\xe6\x56\x4f\x02\x02\x11\x45"
                          "\x67\x27\x08\x2f\x5c\xeb\xee\x8b\x1b\xf5\xeb\x73\x37"
                          "\x34\x1b\x45\x9b\x39\x22";
  const uint16_t listen_a = 20001;
  const uint16_t listen_b = 20002;
  const uint16_t listen_c = 20003;
  const uint16_t af_inet = AF_INET;
  const uint16_t af_inet6 = AF_INET6;
  const struct sockaddr_in endpoint_b_v4 = {
      .sin_family = AF_INET,
      .sin_port = htons(listen_b),
      .sin_addr = {htonl(INADDR_LOOPBACK)}};
  const struct sockaddr_in endpoint_c_v4 = {
      .sin_family = AF_INET,
      .sin_port = htons(listen_c),
      .sin_addr = {htonl(INADDR_LOOPBACK)}};
  struct sockaddr_in6 endpoint_a_v6 = {.sin6_family = AF_INET6,
                                       .sin6_port = htons(listen_a)};
  endpoint_a_v6.sin6_addr = in6addr_loopback;
  struct sockaddr_in6 endpoint_c_v6 = {.sin6_family = AF_INET6,
                                       .sin6_port = htons(listen_c)};
  endpoint_c_v6.sin6_addr = in6addr_loopback;
  const struct in_addr first_half_v4 = {0};
  const struct in_addr second_half_v4 = {(uint32_t)htonl(128 << 24)};
  const struct in6_addr first_half_v6 = {{{0}}};
  const struct in6_addr second_half_v6 = {{{0x80}}};
  const uint8_t half_cidr = 1;
  const uint16_t persistent_keepalives[] = {1, 3, 7, 9, 14, 19};
  struct genlmsghdr genlhdr = {.cmd = WG_CMD_SET_DEVICE, .version = 1};
  int sock;
  int id, err;
  sock = socket(AF_NETLINK, SOCK_RAW, NETLINK_GENERIC);
  if (sock == -1) {
    return;
  }
  id = netlink_query_family_id(&nlmsg, sock, WG_GENL_NAME);
  if (id == -1)
    goto error;
  netlink_init(&nlmsg, id, 0, &genlhdr, sizeof(genlhdr));
  netlink_attr(&nlmsg, WGDEVICE_A_IFNAME, ifname_a, strlen(ifname_a) + 1);
  netlink_attr(&nlmsg, WGDEVICE_A_PRIVATE_KEY, private_a, 32);
  netlink_attr(&nlmsg, WGDEVICE_A_LISTEN_PORT, &listen_a, 2);
  netlink_nest(&nlmsg, NLA_F_NESTED | WGDEVICE_A_PEERS);
  netlink_nest(&nlmsg, NLA_F_NESTED | 0);
  netlink_attr(&nlmsg, WGPEER_A_PUBLIC_KEY, public_b, 32);
  netlink_attr(&nlmsg, WGPEER_A_ENDPOINT, &endpoint_b_v4,
               sizeof(endpoint_b_v4));
  netlink_attr(&nlmsg, WGPEER_A_PERSISTENT_KEEPALIVE_INTERVAL,
               &persistent_keepalives[0], 2);
  netlink_nest(&nlmsg, NLA_F_NESTED | WGPEER_A_ALLOWEDIPS);
  netlink_nest(&nlmsg, NLA_F_NESTED | 0);
  netlink_attr(&nlmsg, WGALLOWEDIP_A_FAMILY, &af_inet, 2);
  netlink_attr(&nlmsg, WGALLOWEDIP_A_IPADDR, &first_half_v4,
               sizeof(first_half_v4));
  netlink_attr(&nlmsg, WGALLOWEDIP_A_CIDR_MASK, &half_cidr, 1);
  netlink_done(&nlmsg);
  netlink_nest(&nlmsg, NLA_F_NESTED | 0);
  netlink_attr(&nlmsg, WGALLOWEDIP_A_FAMILY, &af_inet6, 2);
  netlink_attr(&nlmsg, WGALLOWEDIP_A_IPADDR, &first_half_v6,
               sizeof(first_half_v6));
  netlink_attr(&nlmsg, WGALLOWEDIP_A_CIDR_MASK, &half_cidr, 1);
  netlink_done(&nlmsg);
  netlink_done(&nlmsg);
  netlink_done(&nlmsg);
  netlink_nest(&nlmsg, NLA_F_NESTED | 0);
  netlink_attr(&nlmsg, WGPEER_A_PUBLIC_KEY, public_c, 32);
  netlink_attr(&nlmsg, WGPEER_A_ENDPOINT, &endpoint_c_v6,
               sizeof(endpoint_c_v6));
  netlink_attr(&nlmsg, WGPEER_A_PERSISTENT_KEEPALIVE_INTERVAL,
               &persistent_keepalives[1], 2);
  netlink_nest(&nlmsg, NLA_F_NESTED | WGPEER_A_ALLOWEDIPS);
  netlink_nest(&nlmsg, NLA_F_NESTED | 0);
  netlink_attr(&nlmsg, WGALLOWEDIP_A_FAMILY, &af_inet, 2);
  netlink_attr(&nlmsg, WGALLOWEDIP_A_IPADDR, &second_half_v4,
               sizeof(second_half_v4));
  netlink_attr(&nlmsg, WGALLOWEDIP_A_CIDR_MASK, &half_cidr, 1);
  netlink_done(&nlmsg);
  netlink_nest(&nlmsg, NLA_F_NESTED | 0);
  netlink_attr(&nlmsg, WGALLOWEDIP_A_FAMILY, &af_inet6, 2);
  netlink_attr(&nlmsg, WGALLOWEDIP_A_IPADDR, &second_half_v6,
               sizeof(second_half_v6));
  netlink_attr(&nlmsg, WGALLOWEDIP_A_CIDR_MASK, &half_cidr, 1);
  netlink_done(&nlmsg);
  netlink_done(&nlmsg);
  netlink_done(&nlmsg);
  netlink_done(&nlmsg);
  err = netlink_send(&nlmsg, sock);
  if (err < 0) {
  }
  netlink_init(&nlmsg, id, 0, &genlhdr, sizeof(genlhdr));
  netlink_attr(&nlmsg, WGDEVICE_A_IFNAME, ifname_b, strlen(ifname_b) + 1);
  netlink_attr(&nlmsg, WGDEVICE_A_PRIVATE_KEY, private_b, 32);
  netlink_attr(&nlmsg, WGDEVICE_A_LISTEN_PORT, &listen_b, 2);
  netlink_nest(&nlmsg, NLA_F_NESTED | WGDEVICE_A_PEERS);
  netlink_nest(&nlmsg, NLA_F_NESTED | 0);
  netlink_attr(&nlmsg, WGPEER_A_PUBLIC_KEY, public_a, 32);
  netlink_attr(&nlmsg, WGPEER_A_ENDPOINT, &endpoint_a_v6,
               sizeof(endpoint_a_v6));
  netlink_attr(&nlmsg, WGPEER_A_PERSISTENT_KEEPALIVE_INTERVAL,
               &persistent_keepalives[2], 2);
  netlink_nest(&nlmsg, NLA_F_NESTED | WGPEER_A_ALLOWEDIPS);
  netlink_nest(&nlmsg, NLA_F_NESTED | 0);
  netlink_attr(&nlmsg, WGALLOWEDIP_A_FAMILY, &af_inet, 2);
  netlink_attr(&nlmsg, WGALLOWEDIP_A_IPADDR, &first_half_v4,
               sizeof(first_half_v4));
  netlink_attr(&nlmsg, WGALLOWEDIP_A_CIDR_MASK, &half_cidr, 1);
  netlink_done(&nlmsg);
  netlink_nest(&nlmsg, NLA_F_NESTED | 0);
  netlink_attr(&nlmsg, WGALLOWEDIP_A_FAMILY, &af_inet6, 2);
  netlink_attr(&nlmsg, WGALLOWEDIP_A_IPADDR, &first_half_v6,
               sizeof(first_half_v6));
  netlink_attr(&nlmsg, WGALLOWEDIP_A_CIDR_MASK, &half_cidr, 1);
  netlink_done(&nlmsg);
  netlink_done(&nlmsg);
  netlink_done(&nlmsg);
  netlink_nest(&nlmsg, NLA_F_NESTED | 0);
  netlink_attr(&nlmsg, WGPEER_A_PUBLIC_KEY, public_c, 32);
  netlink_attr(&nlmsg, WGPEER_A_ENDPOINT, &endpoint_c_v4,
               sizeof(endpoint_c_v4));
  netlink_attr(&nlmsg, WGPEER_A_PERSISTENT_KEEPALIVE_INTERVAL,
               &persistent_keepalives[3], 2);
  netlink_nest(&nlmsg, NLA_F_NESTED | WGPEER_A_ALLOWEDIPS);
  netlink_nest(&nlmsg, NLA_F_NESTED | 0);
  netlink_attr(&nlmsg, WGALLOWEDIP_A_FAMILY, &af_inet, 2);
  netlink_attr(&nlmsg, WGALLOWEDIP_A_IPADDR, &second_half_v4,
               sizeof(second_half_v4));
  netlink_attr(&nlmsg, WGALLOWEDIP_A_CIDR_MASK, &half_cidr, 1);
  netlink_done(&nlmsg);
  netlink_nest(&nlmsg, NLA_F_NESTED | 0);
  netlink_attr(&nlmsg, WGALLOWEDIP_A_FAMILY, &af_inet6, 2);
  netlink_attr(&nlmsg, WGALLOWEDIP_A_IPADDR, &second_half_v6,
               sizeof(second_half_v6));
  netlink_attr(&nlmsg, WGALLOWEDIP_A_CIDR_MASK, &half_cidr, 1);
  netlink_done(&nlmsg);
  netlink_done(&nlmsg);
  netlink_done(&nlmsg);
  netlink_done(&nlmsg);
  err = netlink_send(&nlmsg, sock);
  if (err < 0) {
  }
  netlink_init(&nlmsg, id, 0, &genlhdr, sizeof(genlhdr));
  netlink_attr(&nlmsg, WGDEVICE_A_IFNAME, ifname_c, strlen(ifname_c) + 1);
  netlink_attr(&nlmsg, WGDEVICE_A_PRIVATE_KEY, private_c, 32);
  netlink_attr(&nlmsg, WGDEVICE_A_LISTEN_PORT, &listen_c, 2);
  netlink_nest(&nlmsg, NLA_F_NESTED | WGDEVICE_A_PEERS);
  netlink_nest(&nlmsg, NLA_F_NESTED | 0);
  netlink_attr(&nlmsg, WGPEER_A_PUBLIC_KEY, public_a, 32);
  netlink_attr(&nlmsg, WGPEER_A_ENDPOINT, &endpoint_a_v6,
               sizeof(endpoint_a_v6));
  netlink_attr(&nlmsg, WGPEER_A_PERSISTENT_KEEPALIVE_INTERVAL,
               &persistent_keepalives[4], 2);
  netlink_nest(&nlmsg, NLA_F_NESTED | WGPEER_A_ALLOWEDIPS);
  netlink_nest(&nlmsg, NLA_F_NESTED | 0);
  netlink_attr(&nlmsg, WGALLOWEDIP_A_FAMILY, &af_inet, 2);
  netlink_attr(&nlmsg, WGALLOWEDIP_A_IPADDR, &first_half_v4,
               sizeof(first_half_v4));
  netlink_attr(&nlmsg, WGALLOWEDIP_A_CIDR_MASK, &half_cidr, 1);
  netlink_done(&nlmsg);
  netlink_nest(&nlmsg, NLA_F_NESTED | 0);
  netlink_attr(&nlmsg, WGALLOWEDIP_A_FAMILY, &af_inet6, 2);
  netlink_attr(&nlmsg, WGALLOWEDIP_A_IPADDR, &first_half_v6,
               sizeof(first_half_v6));
  netlink_attr(&nlmsg, WGALLOWEDIP_A_CIDR_MASK, &half_cidr, 1);
  netlink_done(&nlmsg);
  netlink_done(&nlmsg);
  netlink_done(&nlmsg);
  netlink_nest(&nlmsg, NLA_F_NESTED | 0);
  netlink_attr(&nlmsg, WGPEER_A_PUBLIC_KEY, public_b, 32);
  netlink_attr(&nlmsg, WGPEER_A_ENDPOINT, &endpoint_b_v4,
               sizeof(endpoint_b_v4));
  netlink_attr(&nlmsg, WGPEER_A_PERSISTENT_KEEPALIVE_INTERVAL,
               &persistent_keepalives[5], 2);
  netlink_nest(&nlmsg, NLA_F_NESTED | WGPEER_A_ALLOWEDIPS);
  netlink_nest(&nlmsg, NLA_F_NESTED | 0);
  netlink_attr(&nlmsg, WGALLOWEDIP_A_FAMILY, &af_inet, 2);
  netlink_attr(&nlmsg, WGALLOWEDIP_A_IPADDR, &second_half_v4,
               sizeof(second_half_v4));
  netlink_attr(&nlmsg, WGALLOWEDIP_A_CIDR_MASK, &half_cidr, 1);
  netlink_done(&nlmsg);
  netlink_nest(&nlmsg, NLA_F_NESTED | 0);
  netlink_attr(&nlmsg, WGALLOWEDIP_A_FAMILY, &af_inet6, 2);
  netlink_attr(&nlmsg, WGALLOWEDIP_A_IPADDR, &second_half_v6,
               sizeof(second_half_v6));
  netlink_attr(&nlmsg, WGALLOWEDIP_A_CIDR_MASK, &half_cidr, 1);
  netlink_done(&nlmsg);
  netlink_done(&nlmsg);
  netlink_done(&nlmsg);
  netlink_done(&nlmsg);
  err = netlink_send(&nlmsg, sock);
  if (err < 0) {
  }

error:
  close(sock);
}
static void initialize_netdevices(void)
{
  char netdevsim[16];
  sprintf(netdevsim, "netdevsim%d", (int)procid);
  struct {
    const char* type;
    const char* dev;
  } devtypes[] = {
      {"ip6gretap", "ip6gretap0"}, {"bridge", "bridge0"},
      {"vcan", "vcan0"},           {"bond", "bond0"},
      {"team", "team0"},           {"dummy", "dummy0"},
      {"nlmon", "nlmon0"},         {"caif", "caif0"},
      {"batadv", "batadv0"},       {"vxcan", "vxcan1"},
      {"netdevsim", netdevsim},    {"veth", 0},
      {"xfrm", "xfrm0"},           {"wireguard", "wg0"},
      {"wireguard", "wg1"},        {"wireguard", "wg2"},
  };
  const char* devmasters[] = {"bridge", "bond", "team", "batadv"};
  struct {
    const char* name;
    int macsize;
    bool noipv6;
  } devices[] = {
      {"lo", ETH_ALEN},
      {"sit0", 0},
      {"bridge0", ETH_ALEN},
      {"vcan0", 0, true},
      {"tunl0", 0},
      {"gre0", 0},
      {"gretap0", ETH_ALEN},
      {"ip_vti0", 0},
      {"ip6_vti0", 0},
      {"ip6tnl0", 0},
      {"ip6gre0", 0},
      {"ip6gretap0", ETH_ALEN},
      {"erspan0", ETH_ALEN},
      {"bond0", ETH_ALEN},
      {"veth0", ETH_ALEN},
      {"veth1", ETH_ALEN},
      {"team0", ETH_ALEN},
      {"veth0_to_bridge", ETH_ALEN},
      {"veth1_to_bridge", ETH_ALEN},
      {"veth0_to_bond", ETH_ALEN},
      {"veth1_to_bond", ETH_ALEN},
      {"veth0_to_team", ETH_ALEN},
      {"veth1_to_team", ETH_ALEN},
      {"veth0_to_hsr", ETH_ALEN},
      {"veth1_to_hsr", ETH_ALEN},
      {"hsr0", 0},
      {"dummy0", ETH_ALEN},
      {"nlmon0", 0},
      {"vxcan0", 0, true},
      {"vxcan1", 0, true},
      {"caif0", ETH_ALEN},
      {"batadv0", ETH_ALEN},
      {netdevsim, ETH_ALEN},
      {"xfrm0", ETH_ALEN},
      {"veth0_virt_wifi", ETH_ALEN},
      {"veth1_virt_wifi", ETH_ALEN},
      {"virt_wifi0", ETH_ALEN},
      {"veth0_vlan", ETH_ALEN},
      {"veth1_vlan", ETH_ALEN},
      {"vlan0", ETH_ALEN},
      {"vlan1", ETH_ALEN},
      {"macvlan0", ETH_ALEN},
      {"macvlan1", ETH_ALEN},
      {"ipvlan0", ETH_ALEN},
      {"ipvlan1", ETH_ALEN},
      {"veth0_macvtap", ETH_ALEN},
      {"veth1_macvtap", ETH_ALEN},
      {"macvtap0", ETH_ALEN},
      {"macsec0", ETH_ALEN},
      {"veth0_to_batadv", ETH_ALEN},
      {"veth1_to_batadv", ETH_ALEN},
      {"batadv_slave_0", ETH_ALEN},
      {"batadv_slave_1", ETH_ALEN},
      {"geneve0", ETH_ALEN},
      {"geneve1", ETH_ALEN},
      {"wg0", 0},
      {"wg1", 0},
      {"wg2", 0},
  };
  int sock = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
  if (sock == -1)
    exit(1);
  unsigned i;
  for (i = 0; i < sizeof(devtypes) / sizeof(devtypes[0]); i++)
    netlink_add_device(&nlmsg, sock, devtypes[i].type, devtypes[i].dev);
  for (i = 0; i < sizeof(devmasters) / (sizeof(devmasters[0])); i++) {
    char master[32], slave0[32], veth0[32], slave1[32], veth1[32];
    sprintf(slave0, "%s_slave_0", devmasters[i]);
    sprintf(veth0, "veth0_to_%s", devmasters[i]);
    netlink_add_veth(&nlmsg, sock, slave0, veth0);
    sprintf(slave1, "%s_slave_1", devmasters[i]);
    sprintf(veth1, "veth1_to_%s", devmasters[i]);
    netlink_add_veth(&nlmsg, sock, slave1, veth1);
    sprintf(master, "%s0", devmasters[i]);
    netlink_device_change(&nlmsg, sock, slave0, false, master, 0, 0, NULL);
    netlink_device_change(&nlmsg, sock, slave1, false, master, 0, 0, NULL);
  }
  netlink_device_change(&nlmsg, sock, "bridge_slave_0", true, 0, 0, 0, NULL);
  netlink_device_change(&nlmsg, sock, "bridge_slave_1", true, 0, 0, 0, NULL);
  netlink_add_veth(&nlmsg, sock, "hsr_slave_0", "veth0_to_hsr");
  netlink_add_veth(&nlmsg, sock, "hsr_slave_1", "veth1_to_hsr");
  netlink_add_hsr(&nlmsg, sock, "hsr0", "hsr_slave_0", "hsr_slave_1");
  netlink_device_change(&nlmsg, sock, "hsr_slave_0", true, 0, 0, 0, NULL);
  netlink_device_change(&nlmsg, sock, "hsr_slave_1", true, 0, 0, 0, NULL);
  netlink_add_veth(&nlmsg, sock, "veth0_virt_wifi", "veth1_virt_wifi");
  netlink_add_linked(&nlmsg, sock, "virt_wifi", "virt_wifi0",
                     "veth1_virt_wifi");
  netlink_add_veth(&nlmsg, sock, "veth0_vlan", "veth1_vlan");
  netlink_add_vlan(&nlmsg, sock, "vlan0", "veth0_vlan", 0, htons(ETH_P_8021Q));
  netlink_add_vlan(&nlmsg, sock, "vlan1", "veth0_vlan", 1, htons(ETH_P_8021AD));
  netlink_add_macvlan(&nlmsg, sock, "macvlan0", "veth1_vlan");
  netlink_add_macvlan(&nlmsg, sock, "macvlan1", "veth1_vlan");
  netlink_add_ipvlan(&nlmsg, sock, "ipvlan0", "veth0_vlan", IPVLAN_MODE_L2, 0);
  netlink_add_ipvlan(&nlmsg, sock, "ipvlan1", "veth0_vlan", IPVLAN_MODE_L3S,
                     IPVLAN_F_VEPA);
  netlink_add_veth(&nlmsg, sock, "veth0_macvtap", "veth1_macvtap");
  netlink_add_linked(&nlmsg, sock, "macvtap", "macvtap0", "veth0_macvtap");
  netlink_add_linked(&nlmsg, sock, "macsec", "macsec0", "veth1_macvtap");
  char addr[32];
  sprintf(addr, DEV_IPV4, 14 + 10);
  struct in_addr geneve_addr4;
  if (inet_pton(AF_INET, addr, &geneve_addr4) <= 0)
    exit(1);
  struct in6_addr geneve_addr6;
  if (inet_pton(AF_INET6, "fc00::01", &geneve_addr6) <= 0)
    exit(1);
  netlink_add_geneve(&nlmsg, sock, "geneve0", 0, &geneve_addr4, 0);
  netlink_add_geneve(&nlmsg, sock, "geneve1", 1, 0, &geneve_addr6);
  netdevsim_add((int)procid, 4);
  netlink_wireguard_setup();
  for (i = 0; i < sizeof(devices) / (sizeof(devices[0])); i++) {
    char addr[32];
    sprintf(addr, DEV_IPV4, i + 10);
    netlink_add_addr4(&nlmsg, sock, devices[i].name, addr);
    if (!devices[i].noipv6) {
      sprintf(addr, DEV_IPV6, i + 10);
      netlink_add_addr6(&nlmsg, sock, devices[i].name, addr);
    }
    uint64_t macaddr = DEV_MAC + ((i + 10ull) << 40);
    netlink_device_change(&nlmsg, sock, devices[i].name, true, 0, &macaddr,
                          devices[i].macsize, NULL);
  }
  close(sock);
}
static void initialize_netdevices_init(void)
{
  int sock = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
  if (sock == -1)
    exit(1);
  struct {
    const char* type;
    int macsize;
    bool noipv6;
    bool noup;
  } devtypes[] = {
      {"nr", 7, true}, {"rose", 5, true, true},
  };
  unsigned i;
  for (i = 0; i < sizeof(devtypes) / sizeof(devtypes[0]); i++) {
    char dev[32], addr[32];
    sprintf(dev, "%s%d", devtypes[i].type, (int)procid);
    sprintf(addr, "172.30.%d.%d", i, (int)procid + 1);
    netlink_add_addr4(&nlmsg, sock, dev, addr);
    if (!devtypes[i].noipv6) {
      sprintf(addr, "fe88::%02x:%02x", i, (int)procid + 1);
      netlink_add_addr6(&nlmsg, sock, dev, addr);
    }
    int macsize = devtypes[i].macsize;
    uint64_t macaddr = 0xbbbbbb +
                       ((unsigned long long)i << (8 * (macsize - 2))) +
                       (procid << (8 * (macsize - 1)));
    netlink_device_change(&nlmsg, sock, dev, !devtypes[i].noup, 0, &macaddr,
                          macsize, NULL);
  }
  close(sock);
}

static int read_tun(char* data, int size)
{
  if (tunfd < 0)
    return -1;
  int rv = read(tunfd, data, size);
  if (rv < 0) {
    if (errno == EAGAIN || errno == EBADFD)
      return -1;
    exit(1);
  }
  return rv;
}

static void flush_tun()
{
  char data[1000];
  while (read_tun(&data[0], sizeof(data)) != -1) {
  }
}

#define MAX_FDS 30

static long syz_init_net_socket(volatile long domain, volatile long type,
                                volatile long proto)
{
  int netns = open("/proc/self/ns/net", O_RDONLY);
  if (netns == -1)
    return netns;
  if (setns(kInitNetNsFd, 0))
    return -1;
  int sock = syscall(__NR_socket, domain, type, proto);
  int err = errno;
  if (setns(netns, 0))
    exit(1);
  close(netns);
  errno = err;
  return sock;
}

#define BTPROTO_HCI 1
#define ACL_LINK 1
#define SCAN_PAGE 2

typedef struct {
  uint8_t b[6];
} __attribute__((packed)) bdaddr_t;

#define HCI_COMMAND_PKT 1
#define HCI_EVENT_PKT 4
#define HCI_VENDOR_PKT 0xff

struct hci_command_hdr {
  uint16_t opcode;
  uint8_t plen;
} __attribute__((packed));

struct hci_event_hdr {
  uint8_t evt;
  uint8_t plen;
} __attribute__((packed));

#define HCI_EV_CONN_COMPLETE 0x03
struct hci_ev_conn_complete {
  uint8_t status;
  uint16_t handle;
  bdaddr_t bdaddr;
  uint8_t link_type;
  uint8_t encr_mode;
} __attribute__((packed));

#define HCI_EV_CONN_REQUEST 0x04
struct hci_ev_conn_request {
  bdaddr_t bdaddr;
  uint8_t dev_class[3];
  uint8_t link_type;
} __attribute__((packed));

#define HCI_EV_REMOTE_FEATURES 0x0b
struct hci_ev_remote_features {
  uint8_t status;
  uint16_t handle;
  uint8_t features[8];
} __attribute__((packed));

#define HCI_EV_CMD_COMPLETE 0x0e
struct hci_ev_cmd_complete {
  uint8_t ncmd;
  uint16_t opcode;
} __attribute__((packed));

#define HCI_OP_WRITE_SCAN_ENABLE 0x0c1a

#define HCI_OP_READ_BUFFER_SIZE 0x1005
struct hci_rp_read_buffer_size {
  uint8_t status;
  uint16_t acl_mtu;
  uint8_t sco_mtu;
  uint16_t acl_max_pkt;
  uint16_t sco_max_pkt;
} __attribute__((packed));

#define HCI_OP_READ_BD_ADDR 0x1009
struct hci_rp_read_bd_addr {
  uint8_t status;
  bdaddr_t bdaddr;
} __attribute__((packed));

#define HCI_EV_LE_META 0x3e
struct hci_ev_le_meta {
  uint8_t subevent;
} __attribute__((packed));

#define HCI_EV_LE_CONN_COMPLETE 0x01
struct hci_ev_le_conn_complete {
  uint8_t status;
  uint16_t handle;
  uint8_t role;
  uint8_t bdaddr_type;
  bdaddr_t bdaddr;
  uint16_t interval;
  uint16_t latency;
  uint16_t supervision_timeout;
  uint8_t clk_accurancy;
} __attribute__((packed));

struct hci_dev_req {
  uint16_t dev_id;
  uint32_t dev_opt;
};

struct vhci_vendor_pkt {
  uint8_t type;
  uint8_t opcode;
  uint16_t id;
};

#define HCIDEVUP _IOW('H', 201, int)
#define HCISETSCAN _IOW('H', 221, int)

static int vhci_fd = -1;

static void rfkill_unblock_all()
{
  int fd = open("/dev/rfkill", O_WRONLY);
  if (fd < 0)
    exit(1);
  struct rfkill_event event = {0};
  event.idx = 0;
  event.type = RFKILL_TYPE_ALL;
  event.op = RFKILL_OP_CHANGE_ALL;
  event.soft = 0;
  event.hard = 0;
  if (write(fd, &event, sizeof(event)) < 0)
    exit(1);
  close(fd);
}

static void hci_send_event_packet(int fd, uint8_t evt, void* data,
                                  size_t data_len)
{
  struct iovec iv[3];
  struct hci_event_hdr hdr;
  hdr.evt = evt;
  hdr.plen = data_len;
  uint8_t type = HCI_EVENT_PKT;
  iv[0].iov_base = &type;
  iv[0].iov_len = sizeof(type);
  iv[1].iov_base = &hdr;
  iv[1].iov_len = sizeof(hdr);
  iv[2].iov_base = data;
  iv[2].iov_len = data_len;
  if (writev(fd, iv, sizeof(iv) / sizeof(struct iovec)) < 0)
    exit(1);
}

static void hci_send_event_cmd_complete(int fd, uint16_t opcode, void* data,
                                        size_t data_len)
{
  struct iovec iv[4];
  struct hci_event_hdr hdr;
  hdr.evt = HCI_EV_CMD_COMPLETE;
  hdr.plen = sizeof(struct hci_ev_cmd_complete) + data_len;
  struct hci_ev_cmd_complete evt_hdr;
  evt_hdr.ncmd = 1;
  evt_hdr.opcode = opcode;
  uint8_t type = HCI_EVENT_PKT;
  iv[0].iov_base = &type;
  iv[0].iov_len = sizeof(type);
  iv[1].iov_base = &hdr;
  iv[1].iov_len = sizeof(hdr);
  iv[2].iov_base = &evt_hdr;
  iv[2].iov_len = sizeof(evt_hdr);
  iv[3].iov_base = data;
  iv[3].iov_len = data_len;
  if (writev(fd, iv, sizeof(iv) / sizeof(struct iovec)) < 0)
    exit(1);
}

static bool process_command_pkt(int fd, char* buf, ssize_t buf_size)
{
  struct hci_command_hdr* hdr = (struct hci_command_hdr*)buf;
  if (buf_size < (ssize_t)sizeof(struct hci_command_hdr) ||
      hdr->plen != buf_size - sizeof(struct hci_command_hdr)) {
    exit(1);
  }
  switch (hdr->opcode) {
  case HCI_OP_WRITE_SCAN_ENABLE: {
    uint8_t status = 0;
    hci_send_event_cmd_complete(fd, hdr->opcode, &status, sizeof(status));
    return true;
  }
  case HCI_OP_READ_BD_ADDR: {
    struct hci_rp_read_bd_addr rp = {0};
    rp.status = 0;
    memset(&rp.bdaddr, 0xaa, 6);
    hci_send_event_cmd_complete(fd, hdr->opcode, &rp, sizeof(rp));
    return false;
  }
  case HCI_OP_READ_BUFFER_SIZE: {
    struct hci_rp_read_buffer_size rp = {0};
    rp.status = 0;
    rp.acl_mtu = 1021;
    rp.sco_mtu = 96;
    rp.acl_max_pkt = 4;
    rp.sco_max_pkt = 6;
    hci_send_event_cmd_complete(fd, hdr->opcode, &rp, sizeof(rp));
    return false;
  }
  }
  char dummy[0xf9] = {0};
  hci_send_event_cmd_complete(fd, hdr->opcode, dummy, sizeof(dummy));
  return false;
}

static void* event_thread(void* arg)
{
  while (1) {
    char buf[1024] = {0};
    ssize_t buf_size = read(vhci_fd, buf, sizeof(buf));
    if (buf_size < 0)
      exit(1);
    if (buf_size > 0 && buf[0] == HCI_COMMAND_PKT) {
      if (process_command_pkt(vhci_fd, buf + 1, buf_size - 1))
        break;
    }
  }
  return NULL;
}
#define HCI_HANDLE_1 200
#define HCI_HANDLE_2 201

static void initialize_vhci()
{
  int hci_sock = socket(AF_BLUETOOTH, SOCK_RAW, BTPROTO_HCI);
  if (hci_sock < 0)
    exit(1);
  vhci_fd = open("/dev/vhci", O_RDWR);
  if (vhci_fd == -1)
    exit(1);
  const int kVhciFd = 241;
  if (dup2(vhci_fd, kVhciFd) < 0)
    exit(1);
  close(vhci_fd);
  vhci_fd = kVhciFd;
  struct vhci_vendor_pkt vendor_pkt;
  if (read(vhci_fd, &vendor_pkt, sizeof(vendor_pkt)) != sizeof(vendor_pkt))
    exit(1);
  if (vendor_pkt.type != HCI_VENDOR_PKT)
    exit(1);
  pthread_t th;
  if (pthread_create(&th, NULL, event_thread, NULL))
    exit(1);
  int ret = ioctl(hci_sock, HCIDEVUP, vendor_pkt.id);
  if (ret) {
    if (errno == ERFKILL) {
      rfkill_unblock_all();
      ret = ioctl(hci_sock, HCIDEVUP, vendor_pkt.id);
    }
    if (ret && errno != EALREADY)
      exit(1);
  }
  struct hci_dev_req dr = {0};
  dr.dev_id = vendor_pkt.id;
  dr.dev_opt = SCAN_PAGE;
  if (ioctl(hci_sock, HCISETSCAN, &dr))
    exit(1);
  struct hci_ev_conn_request request;
  memset(&request, 0, sizeof(request));
  memset(&request.bdaddr, 0xaa, 6);
  *(uint8_t*)&request.bdaddr.b[5] = 0x10;
  request.link_type = ACL_LINK;
  hci_send_event_packet(vhci_fd, HCI_EV_CONN_REQUEST, &request,
                        sizeof(request));
  struct hci_ev_conn_complete complete;
  memset(&complete, 0, sizeof(complete));
  complete.status = 0;
  complete.handle = HCI_HANDLE_1;
  memset(&complete.bdaddr, 0xaa, 6);
  *(uint8_t*)&complete.bdaddr.b[5] = 0x10;
  complete.link_type = ACL_LINK;
  complete.encr_mode = 0;
  hci_send_event_packet(vhci_fd, HCI_EV_CONN_COMPLETE, &complete,
                        sizeof(complete));
  struct hci_ev_remote_features features;
  memset(&features, 0, sizeof(features));
  features.status = 0;
  features.handle = HCI_HANDLE_1;
  hci_send_event_packet(vhci_fd, HCI_EV_REMOTE_FEATURES, &features,
                        sizeof(features));
  struct {
    struct hci_ev_le_meta le_meta;
    struct hci_ev_le_conn_complete le_conn;
  } le_conn;
  memset(&le_conn, 0, sizeof(le_conn));
  le_conn.le_meta.subevent = HCI_EV_LE_CONN_COMPLETE;
  memset(&le_conn.le_conn.bdaddr, 0xaa, 6);
  *(uint8_t*)&le_conn.le_conn.bdaddr.b[5] = 0x11;
  le_conn.le_conn.role = 1;
  le_conn.le_conn.handle = HCI_HANDLE_2;
  hci_send_event_packet(vhci_fd, HCI_EV_LE_META, &le_conn, sizeof(le_conn));
  pthread_join(th, NULL);
  close(hci_sock);
}

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);
  setsid();
  int netns = open("/proc/self/ns/net", O_RDONLY);
  if (netns == -1)
    exit(1);
  if (dup2(netns, kInitNetNsFd) < 0)
    exit(1);
  close(netns);
  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();
  initialize_vhci();
  sandbox_common();
  drop_caps();
  initialize_netdevices_init();
  if (unshare(CLONE_NEWNET)) {
  }
  initialize_tun();
  initialize_netdevices();
  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();
}

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

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);
}

static void setup_binfmt_misc()
{
  if (mount(0, "/proc/sys/fs/binfmt_misc", "binfmt_misc", 0, 0)) {
  }
  write_file("/proc/sys/fs/binfmt_misc/register", ":syz0:M:0:\x01::./file0:");
  write_file("/proc/sys/fs/binfmt_misc/register",
             ":syz1:M:1:\x02::./file0:POC");
}

static void setup_sysctl()
{
  static struct {
    const char* name;
    const char* data;
  } files[] = {
      {"/sys/kernel/debug/x86/nmi_longest_ns", "10000000000"},
      {"/proc/sys/kernel/hung_task_check_interval_secs", "20"},
      {"/proc/sys/net/core/bpf_jit_enable", "1"},
      {"/proc/sys/net/core/bpf_jit_kallsyms", "1"},
      {"/proc/sys/net/core/bpf_jit_harden", "0"},
      {"/proc/sys/kernel/kptr_restrict", "0"},
      {"/proc/sys/kernel/softlockup_all_cpu_backtrace", "1"},
      {"/proc/sys/fs/mount-max", "100"},
      {"/proc/sys/vm/oom_dump_tasks", "0"},
      {"/proc/sys/debug/exception-trace", "0"},
      {"/proc/sys/kernel/printk", "7 4 1 3"},
      {"/proc/sys/net/ipv4/ping_group_range", "0 65535"},
      {"/proc/sys/kernel/keys/gc_delay", "1"},
      {"/proc/sys/vm/nr_overcommit_hugepages", "4"},
      {"/proc/sys/vm/oom_kill_allocating_task", "1"},
  };
  for (size_t i = 0; i < sizeof(files) / sizeof(files[0]); i++) {
    if (!write_file(files[i].name, files[i].data))
      printf("write to %s failed: %s\n", files[i].name, strerror(errno));
  }
}

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 < 9; 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, 50);
      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);
    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 < 5000) {
        continue;
      }
      kill_and_wait(pid, &status);
      break;
    }
    remove_dir(cwdbuf);
    check_leaks();
  }
}

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

void execute_call(int call)
{
  intptr_t res = 0;
  switch (call) {
  case 0:
    res = -1;
    res = syz_init_net_socket(6, 5, 0);
    if (res != -1)
      r[0] = res;
    break;
  case 1:
    *(uint16_t*)0x20000000 = 6;
    *(uint8_t*)0x20000002 = 0xbb;
    *(uint8_t*)0x20000003 = 0xbb;
    *(uint8_t*)0x20000004 = 0xbb;
    *(uint8_t*)0x20000005 = 1;
    *(uint8_t*)0x20000006 = 0;
    *(uint32_t*)0x2000000c = 0;
    *(uint8_t*)0x20000010 = 0xcc;
    *(uint8_t*)0x20000011 = 0xcc;
    *(uint8_t*)0x20000012 = 0xcc;
    *(uint8_t*)0x20000013 = 0xcc;
    *(uint8_t*)0x20000014 = 0xcc;
    *(uint8_t*)0x20000015 = 0xcc;
    *(uint8_t*)0x20000016 = 3 + procid * 4;
    *(uint8_t*)0x20000017 = 0x98;
    *(uint8_t*)0x20000018 = 0x92;
    *(uint8_t*)0x20000019 = 0x9c;
    *(uint8_t*)0x2000001a = 0xaa;
    *(uint8_t*)0x2000001b = 0xb0;
    *(uint8_t*)0x2000001c = 0x40;
    *(uint8_t*)0x2000001d = 2;
    *(uint8_t*)0x2000001e = 0x98;
    *(uint8_t*)0x2000001f = 0x92;
    *(uint8_t*)0x20000020 = 0x9c;
    *(uint8_t*)0x20000021 = 0xaa;
    *(uint8_t*)0x20000022 = 0xb0;
    *(uint8_t*)0x20000023 = 0x40;
    *(uint8_t*)0x20000024 = 2;
    *(uint8_t*)0x20000025 = 0xa2;
    *(uint8_t*)0x20000026 = 0xa6;
    *(uint8_t*)0x20000027 = 0xa8;
    *(uint8_t*)0x20000028 = 0x40;
    *(uint8_t*)0x20000029 = 0x40;
    *(uint8_t*)0x2000002a = 0x40;
    *(uint8_t*)0x2000002b = 0;
    *(uint8_t*)0x2000002c = 0xa2;
    *(uint8_t*)0x2000002d = 0xa6;
    *(uint8_t*)0x2000002e = 0xa8;
    *(uint8_t*)0x2000002f = 0x40;
    *(uint8_t*)0x20000030 = 0x40;
    *(uint8_t*)0x20000031 = 0x40;
    *(uint8_t*)0x20000032 = 0;
    *(uint8_t*)0x20000033 = 0x40;
    *(uint8_t*)0x20000034 = 0x40;
    *(uint8_t*)0x20000035 = 0x40;
    *(uint8_t*)0x20000036 = 0x40;
    *(uint8_t*)0x20000037 = 0x40;
    *(uint8_t*)0x20000038 = 0x40;
    *(uint8_t*)0x20000039 = 0;
    *(uint8_t*)0x2000003a = 0x40;
    *(uint8_t*)0x2000003b = 0x40;
    *(uint8_t*)0x2000003c = 0x40;
    *(uint8_t*)0x2000003d = 0x40;
    *(uint8_t*)0x2000003e = 0x40;
    *(uint8_t*)0x2000003f = 0x40;
    *(uint8_t*)0x20000040 = 0;
    *(uint8_t*)0x20000041 = 0xcc;
    *(uint8_t*)0x20000042 = 0xcc;
    *(uint8_t*)0x20000043 = 0xcc;
    *(uint8_t*)0x20000044 = 0xcc;
    *(uint8_t*)0x20000045 = 0xcc;
    *(uint8_t*)0x20000046 = 0xcc;
    *(uint8_t*)0x20000047 = 1 + procid * 4;
    syscall(__NR_connect, r[0], 0x20000000ul, 0x48ul);
    break;
  case 2:
    syscall(__NR_listen, r[0], 0);
    break;
  case 3:
    *(uint32_t*)0x20000280 = 0x80;
    res = syscall(__NR_getsockname, r[0], 0x20000200ul, 0x20000280ul);
    if (res != -1)
      r[1] = *(uint32_t*)0x20000204;
    break;
  case 4:
    res = syscall(__NR_socket, 0x10ul, 3ul, 0);
    if (res != -1)
      r[2] = res;
    break;
  case 5:
    syscall(__NR_socket, 0x10ul, 3ul, 0);
    break;
  case 6:
    syscall(__NR_socket, 0x10ul, 0x803ul, 0);
    break;
  case 7:
    *(uint64_t*)0x200007c0 = 0;
    *(uint32_t*)0x200007c8 = 0;
    *(uint64_t*)0x200007d0 = 0x20000780;
    *(uint64_t*)0x20000780 = 0x20000480;
    *(uint32_t*)0x20000480 = 0x38;
    *(uint16_t*)0x20000484 = 0x24;
    *(uint16_t*)0x20000486 = 0xe0b;
    *(uint32_t*)0x20000488 = 0;
    *(uint32_t*)0x2000048c = 0;
    *(uint8_t*)0x20000490 = 0;
    *(uint8_t*)0x20000491 = 0;
    *(uint16_t*)0x20000492 = 0;
    *(uint32_t*)0x20000494 = 0;
    *(uint16_t*)0x20000498 = 0;
    *(uint16_t*)0x2000049a = 0;
    *(uint16_t*)0x2000049c = -1;
    *(uint16_t*)0x2000049e = -1;
    *(uint16_t*)0x200004a0 = 0;
    *(uint16_t*)0x200004a2 = 0;
    *(uint16_t*)0x200004a4 = 0xc;
    *(uint16_t*)0x200004a6 = 1;
    memcpy((void*)0x200004a8, "skbprio\000", 8);
    *(uint16_t*)0x200004b0 = 3;
    *(uint16_t*)0x200004b2 = 2;
    *(uint32_t*)0x200004b4 = 0;
    *(uint64_t*)0x20000788 = 0x38;
    *(uint64_t*)0x200007d8 = 1;
    *(uint64_t*)0x200007e0 = 0;
    *(uint64_t*)0x200007e8 = 0;
    *(uint32_t*)0x200007f0 = 0;
    syscall(__NR_sendmsg, r[2], 0x200007c0ul, 0ul);
    break;
  case 8:
    *(uint64_t*)0x200056c0 = 0;
    *(uint32_t*)0x200056c8 = 0;
    *(uint64_t*)0x200056d0 = 0x20005680;
    *(uint64_t*)0x20005680 = 0x20000380;
    *(uint32_t*)0x20000380 = 0x4f94;
    *(uint16_t*)0x20000384 = 0x2d;
    *(uint16_t*)0x20000386 = 2;
    *(uint32_t*)0x20000388 = 0x70bd2d;
    *(uint32_t*)0x2000038c = 0x25dfdbfe;
    *(uint8_t*)0x20000390 = 0;
    *(uint8_t*)0x20000391 = 0;
    *(uint16_t*)0x20000392 = 0;
    *(uint32_t*)0x20000394 = 0;
    *(uint16_t*)0x20000398 = 2;
    *(uint16_t*)0x2000039a = 0xc;
    *(uint16_t*)0x2000039c = 2;
    *(uint16_t*)0x2000039e = 0xb;
    *(uint16_t*)0x200003a0 = 0xe;
    *(uint16_t*)0x200003a2 = 6;
    *(uint16_t*)0x200003a4 = 8;
    *(uint16_t*)0x200003a6 = 0xb;
    *(uint32_t*)0x200003a8 = 0x600f;
    *(uint16_t*)0x200003ac = 9;
    *(uint16_t*)0x200003ae = 1;
    memcpy((void*)0x200003b0, "rsvp\000", 5);
    *(uint16_t*)0x200003b8 = 0x2c;
    *(uint16_t*)0x200003ba = 2;
    *(uint16_t*)0x200003bc = 0x20;
    *(uint16_t*)0x200003be = 5;
    *(uint16_t*)0x200003c0 = 0xc;
    *(uint16_t*)0x200003c2 = 8;
    *(uint64_t*)0x200003c4 = 0x7ff;
    *(uint16_t*)0x200003cc = 8;
    *(uint16_t*)0x200003ce = 5;
    *(uint32_t*)0x200003d0 = 0x800;
    *(uint16_t*)0x200003d4 = 8;
    *(uint16_t*)0x200003d6 = 4;
    *(uint32_t*)0x200003d8 = 0x89f;
    *(uint16_t*)0x200003dc = 8;
    *(uint16_t*)0x200003de = 3;
    *(uint32_t*)0x200003e0 = htobe32(0x64010100);
    *(uint16_t*)0x200003e4 = 6;
    *(uint16_t*)0x200003e6 = 5;
    *(uint8_t*)0x200003e8 = 0x40;
    *(uint8_t*)0x200003e9 = 7;
    *(uint16_t*)0x200003ec = 6;
    *(uint16_t*)0x200003ee = 5;
    *(uint8_t*)0x200003f0 = 8;
    *(uint8_t*)0x200003f1 = 3;
    *(uint16_t*)0x200003f4 = 0xb;
    *(uint16_t*)0x200003f6 = 1;
    memcpy((void*)0x200003f8, "cgroup\000", 7);
    *(uint16_t*)0x20000400 = 0x35a8;
    *(uint16_t*)0x20000402 = 2;
    *(uint16_t*)0x20000404 = 0x518;
    STORE_BY_BITMASK(uint16_t, , 0x20000406, 3, 0, 14);
    STORE_BY_BITMASK(uint16_t, , 0x20000407, 0, 6, 1);
    STORE_BY_BITMASK(uint16_t, , 0x20000407, 1, 7, 1);
    *(uint16_t*)0x20000408 = 8;
    *(uint16_t*)0x2000040a = 1;
    *(uint16_t*)0x2000040c = 0x3ff;
    *(uint16_t*)0x2000040e = 0;
    *(uint16_t*)0x20000410 = 0x25c;
    STORE_BY_BITMASK(uint16_t, , 0x20000412, 2, 0, 14);
    STORE_BY_BITMASK(uint16_t, , 0x20000413, 0, 6, 1);
    STORE_BY_BITMASK(uint16_t, , 0x20000413, 1, 7, 1);
    *(uint16_t*)0x20000414 = 0x94;
    STORE_BY_BITMASK(uint16_t, , 0x20000416, 2, 0, 14);
    STORE_BY_BITMASK(uint16_t, , 0x20000417, 0, 6, 1);
    STORE_BY_BITMASK(uint16_t, , 0x20000417, 0, 7, 1);
    *(uint16_t*)0x20000418 = 7;
    *(uint16_t*)0x2000041a = 9;
    *(uint16_t*)0x2000041c = 0x4000;
    *(uint16_t*)0x2000041e = 0;
    *(uint16_t*)0x20000420 = 0x71;
    *(uint16_t*)0x20000422 = 5;
    memcpy((void*)0x20000424,
           "\xd0\x8d\xc1\x3f\xb1\x4c\x95\x96\x0c\x6a\xe4\x4c\xff\x9c\x4f\x15"
           "\x9b\xcc\x64\xe6\xd9\x83\xea\x2f\x47\xbd\xfb\x65\x28\x05\x60\x3a"
           "\xd2\xa2\x12\x56\xf4\x68\x71\x28\x2e\xcc\x2d\x0d\x7a\xb8\x21\x07"
           "\xd2\xbb\x06\x27\xcf\x6d\xab\x74\x74\xde\x46\xc7\x4d\x4e\x62\x1c"
           "\xf0\x75\xa5\x7c\xb6\x70\x84\x3a\x0c\x61\x8b\x63\xcd\x9e\xed\x4f"
           "\xaf\x92\x44\x16\x9c\xee\x5c\xbd\x2b\x20\x61\xd3\xc1\xc8\xa1\x8a"
           "\x2f\xbd\x33\x28\x2a\xa4\xf5\xb9\xfb\xf8\x2f\xd1\xa8",
           109);
    *(uint16_t*)0x20000494 = 0xb;
    *(uint16_t*)0x20000496 = 2;
    memcpy((void*)0x20000498, "policy\000", 7);
    *(uint16_t*)0x200004a0 = 8;
    *(uint16_t*)0x200004a2 = 1;
    *(uint32_t*)0x200004a4 = 3;
    *(uint16_t*)0x200004a8 = 0x14;
    STORE_BY_BITMASK(uint16_t, , 0x200004aa, 3, 0, 14);
    STORE_BY_BITMASK(uint16_t, , 0x200004ab, 0, 6, 1);
    STORE_BY_BITMASK(uint16_t, , 0x200004ab, 0, 7, 1);
    *(uint16_t*)0x200004ac = 1;
    *(uint16_t*)0x200004ae = 7;
    *(uint16_t*)0x200004b0 = 0x1245;
    *(uint16_t*)0x200004b2 = 0;
    STORE_BY_BITMASK(uint32_t, , 0x200004b4, 0, 0, 29);
    STORE_BY_BITMASK(uint32_t, , 0x200004b4, 1, 29, 1);
    STORE_BY_BITMASK(uint32_t, , 0x200004b4, 1, 30, 1);
    STORE_BY_BITMASK(uint32_t, , 0x200004b4, 0, 31, 1);
    STORE_BY_BITMASK(uint32_t, , 0x200004b8, 1, 0, 29);
    STORE_BY_BITMASK(uint32_t, , 0x200004b8, 1, 29, 1);
    STORE_BY_BITMASK(uint32_t, , 0x200004b8, 1, 30, 1);
    STORE_BY_BITMASK(uint32_t, , 0x200004b8, 1, 31, 1);
    *(uint16_t*)0x200004bc = 0x1b0;
    STORE_BY_BITMASK(uint16_t, , 0x200004be, 3, 0, 14);
    STORE_BY_BITMASK(uint16_t, , 0x200004bf, 0, 6, 1);
    STORE_BY_BITMASK(uint16_t, , 0x200004bf, 0, 7, 1);
    *(uint16_t*)0x200004c0 = 0xd8;
    *(uint16_t*)0x200004c2 = 9;
    *(uint16_t*)0x200004c4 = 1;
    *(uint16_t*)0x200004c6 = 0;
    *(uint16_t*)0x200004c8 = 5;
    *(uint16_t*)0x200004ca = 3;
    *(uint8_t*)0x200004cc = 0xb7;
    *(uint16_t*)0x200004d0 = 5;
    *(uint16_t*)0x200004d2 = 4;
    *(uint8_t*)0x200004d4 = 0;
    *(uint16_t*)0x200004d8 = 5;
    *(uint16_t*)0x200004da = 4;
    *(uint8_t*)0x200004dc = 7;
    *(uint16_t*)0x200004e0 = 0xc7;
    *(uint16_t*)0x200004e2 = 5;
    memcpy((void*)0x200004e4,
           "\x88\xe5\xf8\x75\x61\x9a\x05\xc9\xf5\x9f\xcc\x2c\xf6\x5f\xbf\xf9"
           "\x65\xc3\x29\xc1\xf4\xe2\xd9\x83\x20\x53\x69\xaf\x53\x06\xdf\xba"
           "\xee\x3c\xee\xa9\x52\x87\x8f\xa3\x9f\x48\xe1\xfa\x42\x1d\xcc\x62"
           "\x64\x43\x1b\x04\xdf\x76\x28\xc0\x94\xe1\x5c\xaa\x2d\x04\xf4\x6b"
           "\xc4\x21\xf4\xb9\xeb\x5e\xd3\x96\xac\xb4\x85\xb7\xdb\x0b\xe0\xdb"
           "\x56\xf9\x82\x44\x39\x66\xa6\xa9\x09\x70\xb6\x0f\xea\xcd\xfb\xb5"
           "\xfa\xf8\xa3\xe4\xd1\x70\x48\x5b\xc2\x02\xc3\x89\x6b\x73\x71\x7c"
           "\x45\x94\xc1\xb6\x08\xf4\x53\x3c\xdb\x5e\x2a\x56\x38\x8b\xd1\x13"
           "\xa2\x27\x64\xe2\xa7\xf9\x82\x6e\xfe\xc4\x88\x82\xf6\xae\xc0\xe8"
           "\x78\x49\xa9\xae\xa3\x3f\x35\x40\x2c\x70\xba\x65\x33\x5b\x0d\xf3"
           "\x4b\x82\xe0\xdd\xd1\x6c\x48\xfc\x34\x6a\xf6\x34\x0a\xa6\x6f\x95"
           "\xec\x58\x6e\x92\x0e\x9c\x31\x39\xd6\x74\xac\xe5\x9e\xc8\xa9\x54"
           "\x36\x0b\xbc",
           195);
    *(uint16_t*)0x200005a8 = 5;
    *(uint16_t*)0x200005aa = 3;
    *(uint8_t*)0x200005ac = 2;
    *(uint16_t*)0x200005b0 = 0xbc;
    *(uint16_t*)0x200005b2 = 5;
    memcpy((void*)0x200005b4,
           "\x73\x3e\x91\x21\x9f\x73\xc5\xfc\x9b\x07\x2b\x1b\xc4\x53\x22\x10"
           "\xaa\x91\xaf\x43\xd0\x6a\x5c\x54\x45\x03\xa6\xa4\xbb\xc7\xce\x6d"
           "\xa2\x40\x76\x4a\x18\x8b\xdd\x78\x30\x91\x40\x7c\x7d\xbe\x0d\x83"
           "\xaa\x37\x8d\x75\x4d\x55\x54\xb4\xe0\xa6\x78\xb2\xf0\x58\x79\xda"
           "\xb4\x49\x4b\x4e\xef\x23\xde\x2b\xf2\xf4\xad\x4d\x43\x98\xb4\xc0"
           "\x87\x20\x0a\x5b\x1a\x6e\xe7\x80\xeb\x6f\xf3\x8b\x0c\xe4\x93\x6c"
           "\xe9\x4b\x6b\x80\x35\xff\xb6\x8b\x6b\xc2\x42\xf0\x53\x27\x46\x36"
           "\xb6\x52\x6d\x4a\x2f\x1b\x5c\x3f\xf8\xa1\xaa\x73\xcb\x95\x00\xcb"
           "\xa1\xd9\x23\xa3\xfe\x83\xa8\xea\x00\xd1\xe6\xa7\xc9\xd9\xd6\x1e"
           "\x24\xc4\x34\xac\x23\xf3\x2d\x5b\x5b\xdd\x87\x9d\xac\x0c\xad\x02"
           "\x8f\x8f\xb0\x4e\xb6\xbd\x47\xf8\x11\x17\x5e\x56\xcf\x59\x4b\xff"
           "\x2f\xc3\x09\x73\x04\x59\x7c\x41",
           184);
    *(uint16_t*)0x2000066c = 0x170;
    STORE_BY_BITMASK(uint16_t, , 0x2000066e, 2, 0, 14);
    STORE_BY_BITMASK(uint16_t, , 0x2000066f, 0, 6, 1);
    STORE_BY_BITMASK(uint16_t, , 0x2000066f, 1, 7, 1);
    *(uint16_t*)0x20000670 = 0x10;
    STORE_BY_BITMASK(uint16_t, , 0x20000672, 2, 0, 14);
    STORE_BY_BITMASK(uint16_t, , 0x20000673, 0, 6, 1);
    STORE_BY_BITMASK(uint16_t, , 0x20000673, 0, 7, 1);
    *(uint16_t*)0x20000674 = 0x440;
    *(uint16_t*)0x20000676 = 8;
    *(uint16_t*)0x20000678 = 1;
    *(uint16_t*)0x2000067a = 0;
    *(uint16_t*)0x2000067c = 0;
    *(uint8_t*)0x2000067e = 3;
    *(uint8_t*)0x2000067f = 4;
    *(uint16_t*)0x20000680 = 0xc;
    STORE_BY_BITMASK(uint16_t, , 0x20000682, 3, 0, 14);
    STORE_BY_BITMASK(uint16_t, , 0x20000683, 0, 6, 1);
    STORE_BY_BITMASK(uint16_t, , 0x20000683, 0, 7, 1);
    *(uint16_t*)0x20000684 = 0x2f;
    *(uint16_t*)0x20000686 = 0;
    *(uint16_t*)0x20000688 = 0x99;
    *(uint16_t*)0x2000068a = 0;
    *(uint16_t*)0x2000068c = 0x18;
    STORE_BY_BITMASK(uint16_t, , 0x2000068e, 2, 0, 14);
    STORE_BY_BITMASK(uint16_t, , 0x2000068f, 0, 6, 1);
    STORE_BY_BITMASK(uint16_t, , 0x2000068f, 0, 7, 1);
    *(uint16_t*)0x20000690 = 0x7ff;
    *(uint16_t*)0x20000692 = 2;
    *(uint16_t*)0x20000694 = 9;
    *(uint16_t*)0x20000696 = 0;
    *(uint32_t*)0x20000698 = 5;
    STORE_BY_BITMASK(uint16_t, , 0x2000069c, 6, 0, 12);
    STORE_BY_BITMASK(uint8_t, , 0x2000069d, 0, 4, 4);
    memcpy((void*)0x2000069e, "\x4b\x22\xbf\xb7\x90\x08", 6);
    *(uint16_t*)0x200006a4 = 0x10;
    STORE_BY_BITMASK(uint16_t, , 0x200006a6, 1, 0, 14);
    STORE_BY_BITMASK(uint16_t, , 0x200006a7, 0, 6, 1);
    STORE_BY_BITMASK(uint16_t, , 0x200006a7, 0, 7, 1);
    *(uint16_t*)0x200006a8 = 0x20;
    *(uint16_t*)0x200006aa = 8;
    *(uint16_t*)0x200006ac = 7;
    *(uint16_t*)0x200006ae = 0;
    *(uint16_t*)0x200006b0 = -1;
    *(uint8_t*)0x200006b2 = 5;
    *(uint8_t*)0x200006b3 = 6;
    *(uint16_t*)0x200006b4 = 0x14;
    STORE_BY_BITMASK(uint16_t, , 0x200006b6, 1, 0, 14);
    STORE_BY_BITMASK(uint16_t, , 0x200006b7, 0, 6, 1);
    STORE_BY_BITMASK(uint16_t, , 0x200006b7, 0, 7, 1);
    *(uint16_t*)0x200006b8 = 6;
    *(uint16_t*)0x200006ba = 2;
    *(uint16_t*)0x200006bc = 1;
    *(uint16_t*)0x200006be = 0;
    *(uint32_t*)0x200006c0 = 4;
    STORE_BY_BITMASK(uint16_t, , 0x200006c4, 0, 0, 12);
    STORE_BY_BITMASK(uint8_t, , 0x200006c5, 0, 4, 4);
    *(uint16_t*)0x200006c8 = 0x18;
    STORE_BY_BITMASK(uint16_t, , 0x200006ca, 2, 0, 14);
    STORE_BY_BITMASK(uint16_t, , 0x200006cb, 0, 6, 1);
    STORE_BY_BITMASK(uint16_t, , 0x200006cb, 0, 7, 1);
    *(uint16_t*)0x200006cc = 0x7f;
    *(uint16_t*)0x200006ce = 1;
    *(uint16_t*)0x200006d0 = 1;
    *(uint16_t*)0x200006d2 = 0;
    *(uint32_t*)0x200006d4 = 0x2700;
    *(uint32_t*)0x200006d8 = 1;
    *(uint16_t*)0x200006dc = 1;
    STORE_BY_BITMASK(uint8_t, , 0x200006de, 1, 0, 4);
    STORE_BY_BITMASK(uint8_t, , 0x200006de, 0, 4, 4);
    STORE_BY_BITMASK(uint8_t, , 0x200006df, 1, 0, 4);
    STORE_BY_BITMASK(uint8_t, , 0x200006df, 1, 4, 4);
    *(uint16_t*)0x200006e0 = 0x90;
    STORE_BY_BITMASK(uint16_t, , 0x200006e2, 3, 0, 14);
    STORE_BY_BITMASK(uint16_t, , 0x200006e3, 0, 6, 1);
    STORE_BY_BITMASK(uint16_t, , 0x200006e3, 0, 7, 1);
    *(uint16_t*)0x200006e4 = 0;
    *(uint16_t*)0x200006e6 = 9;
    *(uint16_t*)0x200006e8 = 0;
    *(uint16_t*)0x200006ea = 0;
    *(uint16_t*)0x200006ec = 8;
    *(uint16_t*)0x200006ee = 1;
    *(uint32_t*)0x200006f0 = 1;
    *(uint16_t*)0x200006f4 = 5;
    *(uint16_t*)0x200006f6 = 4;
    *(uint8_t*)0x200006f8 = 0xa;
    *(uint16_t*)0x200006fc = 5;
    *(uint16_t*)0x200006fe = 3;
    *(uint8_t*)0x20000700 = 3;
    *(uint16_t*)0x20000704 = 0x58;
    *(uint16_t*)0x20000706 = 5;
    memcpy((void*)0x20000708,
           "\xb3\x82\x93\x7e\x71\x3f\xf4\xf7\x51\x4d\x0c\x14\x1a\x77\x61\xed"
           "\x6c\xd0\xcc\x3c\x24\x85\x83\x91\x62\x4a\xb7\x03\x44\x1a\xce\xb1"
           "\xa3\x2f\xbc\x01\xf5\x72\x84\xc9\x32\x64\x4f\x71\x24\xe6\x83\xed"
           "\x86\xea\x29\xc6\x82\x4b\x3a\x60\xa6\x4a\xef\xbc\x41\xb8\x83\x8d"
           "\xc1\x70\x96\xb1\x48\xf8\x4f\x0d\xb3\xc5\xa1\x64\x0b\xf6\xdb\x31"
           "\x2a\x09\xc8\x1e",
           84);
    *(uint16_t*)0x2000075c = 5;
    *(uint16_t*)0x2000075e = 3;
    *(uint8_t*)0x20000760 = 0x49;
    *(uint16_t*)0x20000764 = 8;
    *(uint16_t*)0x20000766 = 1;
    *(uint32_t*)0x20000768 = 1;
    *(uint16_t*)0x2000076c = 4;
    *(uint16_t*)0x2000076e = 5;
    *(uint16_t*)0x20000770 = 0x60;
    STORE_BY_BITMASK(uint16_t, , 0x20000772, 1, 0, 14);
    STORE_BY_BITMASK(uint16_t, , 0x20000773, 0, 6, 1);
    STORE_BY_BITMASK(uint16_t, , 0x20000773, 0, 7, 1);
    *(uint16_t*)0x20000774 = 0xca6;
    *(uint16_t*)0x20000776 = 9;
    *(uint16_t*)0x20000778 = 4;
    *(uint16_t*)0x2000077a = 0;
    *(uint16_t*)0x2000077c = 5;
    *(uint16_t*)0x2000077e = 4;
    *(uint8_t*)0x20000780 = 7;
    *(uint16_t*)0x20000784 = 0xb;
    *(uint16_t*)0x20000786 = 2;
    memcpy((void*)0x20000788, "policy\000", 7);
    *(uint16_t*)0x20000790 = 5;
    *(uint16_t*)0x20000792 = 4;
    *(uint8_t*)0x20000794 = 0xa;
    *(uint16_t*)0x20000798 = 5;
    *(uint16_t*)0x2000079a = 3;
    *(uint8_t*)0x2000079c = 0x81;
    *(uint16_t*)0x200007a0 = 0xb;
    *(uint16_t*)0x200007a2 = 2;
    memcpy((void*)0x200007a4, "policy\000", 7);
    *(uint16_t*)0x200007ac = 5;
    *(uint16_t*)0x200007ae = 3;
    *(uint8_t*)0x200007b0 = -1;
    *(uint16_t*)0x200007b4 = 5;
    *(uint16_t*)0x200007b6 = 3;
    *(uint8_t*)0x200007b8 = 3;
    *(uint16_t*)0x200007bc = 5;
    *(uint16_t*)0x200007be = 3;
    *(uint8_t*)0x200007c0 = 0x50;
    *(uint16_t*)0x200007c4 = 0xb;
    *(uint16_t*)0x200007c6 = 2;
    memcpy((void*)0x200007c8, "policy\000", 7);
    *(uint16_t*)0x200007d0 = 0xc;
    STORE_BY_BITMASK(uint16_t, , 0x200007d2, 2, 0, 14);
    STORE_BY_BITMASK(uint16_t, , 0x200007d3, 0, 6, 1);
    STORE_BY_BITMASK(uint16_t, , 0x200007d3, 0, 7, 1);
    *(uint16_t*)0x200007d4 = 9;
    *(uint16_t*)0x200007d6 = 0;
    *(uint16_t*)0x200007d8 = 2;
    *(uint16_t*)0x200007da = 0;
    *(uint16_t*)0x200007dc = 8;
    *(uint16_t*)0x200007de = 1;
    *(uint16_t*)0x200007e0 = 0x6a09;
    *(uint16_t*)0x200007e2 = 0;
    *(uint16_t*)0x200007e4 = 8;
    *(uint16_t*)0x200007e6 = 1;
    *(uint16_t*)0x200007e8 = 0x101;
    *(uint16_t*)0x200007ea = 0;
    *(uint16_t*)0x200007ec = 8;
    *(uint16_t*)0x200007ee = 1;
    *(uint16_t*)0x200007f0 = 7;
    *(uint16_t*)0x200007f2 = 0;
    *(uint16_t*)0x200007f4 = 8;
    *(uint16_t*)0x200007f6 = 1;
    *(uint16_t*)0x200007f8 = 7;
    *(uint16_t*)0x200007fa = 0;
    *(uint16_t*)0x200007fc = 8;
    *(uint16_t*)0x200007fe = 1;
    *(uint16_t*)0x20000800 = 8;
    *(uint16_t*)0x20000802 = 0;
    *(uint16_t*)0x20000804 = 0x110;
    STORE_BY_BITMASK(uint16_t, , 0x20000806, 2, 0, 14);
    STORE_BY_BITMASK(uint16_t, , 0x20000807, 0, 6, 1);
    STORE_BY_BITMASK(uint16_t, , 0x20000807, 1, 7, 1);
    *(uint16_t*)0x20000808 = 0x1c;
    STORE_BY_BITMASK(uint16_t, , 0x2000080a, 1, 0, 14);
    STORE_BY_BITMASK(uint16_t, , 0x2000080b, 0, 6, 1);
    STORE_BY_BITMASK(uint16_t, , 0x2000080b, 0, 7, 1);
    *(uint16_t*)0x2000080c = 6;
    *(uint16_t*)0x2000080e = 3;
    *(uint16_t*)0x20000810 = 0x20;
    *(uint16_t*)0x20000812 = 0;
    *(uint32_t*)0x20000814 = htobe32(4);
    *(uint32_t*)0x20000818 = htobe32(0);
    *(uint32_t*)0x2000081c = -1;
    *(uint32_t*)0x20000820 = 6;
    *(uint16_t*)0x20000824 = 0x1c;
    STORE_BY_BITMASK(uint16_t, , 0x20000826, 3, 0, 14);
    STORE_BY_BITMASK(uint16_t, , 0x20000827, 0, 6, 1);
    STORE_BY_BITMASK(uint16_t, , 0x20000827, 0, 7, 1);
    *(uint16_t*)0x20000828 = 0;
    *(uint16_t*)0x2000082a = 3;
    *(uint16_t*)0x2000082c = 0x8001;
    *(uint16_t*)0x2000082e = 0;
    *(uint32_t*)0x20000830 = htobe32(0x13);
    *(uint32_t*)0x20000834 = htobe32(0x1ff);
    *(uint32_t*)0x20000838 = 0x90;
    *(uint32_t*)0x2000083c = 0x7134;
    *(uint16_t*)0x20000840 = 0xd4;
    STORE_BY_BITMASK(uint16_t, , 0x20000842, 2, 0, 14);
    STORE_BY_BITMASK(uint16_t, , 0x20000843, 0, 6, 1);
    STORE_BY_BITMASK(uint16_t, , 0x20000843, 0, 7, 1);
    *(uint16_t*)0x20000844 = 4;
    *(uint16_t*)0x20000846 = 4;
    *(uint16_t*)0x20000848 = 5;
    *(uint16_t*)0x2000084a = 0;
    *(uint16_t*)0x2000084c = 0x1e;
    *(uint16_t*)0x2000084e = 3;
    *(uint32_t*)0x20000850 = 4;
    memcpy((void*)0x20000854, "\xc8", 1);
    memcpy((void*)0x20000855, "\x27\x3f\xe7\xb7\x34\xad\x54\x8a\x67", 9);
    *(uint32_t*)0x2000085e = 0;
    *(uint32_t*)0x20000862 = 0x3f;
    *(uint32_t*)0x20000866 = 1;
    *(uint16_t*)0x2000086c = 0xc;
    *(uint16_t*)0x2000086e = 1;
    *(uint16_t*)0x20000870 = 0x7fff;
    *(uint8_t*)0x20000872 = 7;
    *(uint8_t*)0x20000873 = 0;
    *(uint16_t*)0x20000874 = 8;
    *(uint8_t*)0x20000876 = -1;
    *(uint8_t*)0x20000877 = 0;
    *(uint16_t*)0x20000878 = 0x14;
    *(uint16_t*)0x2000087a = 3;
    *(uint32_t*)0x2000087c = 9;
    memcpy((void*)0x20000880, "\x55\xb9\x00\xb8", 4);
    *(uint32_t*)0x20000884 = 4;
    *(uint32_t*)0x20000888 = 1;
    *(uint16_t*)0x2000088c = 0x33;
    *(uint16_t*)0x2000088e = 3;
    memcpy((void*)0x20000890, "\xac\x38\xdb\x8d\x90\xa5\xf4\x6b\xe6\xdb", 10);
    *(uint32_t*)0x2000089a = 5;
    memcpy((void*)0x2000089e, "\x76\x25\xf2\x30\xd7", 5);
    *(uint32_t*)0x200008a3 = 5;
    *(uint32_t*)0x200008a7 = 4;
    *(uint32_t*)0x200008ab = 8;
    *(uint32_t*)0x200008af = 0;
    *(uint32_t*)0x200008b3 = 5;
    memcpy((void*)0x200008b7, "\x9e\x5c\x0f\x4e\x3d\xb7\x40\xe1", 8);
    *(uint16_t*)0x200008c0 = 0xc;
    *(uint16_t*)0x200008c2 = 1;
    *(uint16_t*)0x200008c4 = 9;
    *(uint8_t*)0x200008c6 = 0;
    *(uint8_t*)0x200008c7 = 1;
    *(uint16_t*)0x200008c8 = 0xfff;
    *(uint8_t*)0x200008ca = 5;
    *(uint8_t*)0x200008cb = 1;
    *(uint16_t*)0x200008cc = 0xc;
    *(uint16_t*)0x200008ce = 1;
    *(uint16_t*)0x200008d0 = 7;
    *(uint8_t*)0x200008d2 = 0x40;
    *(uint8_t*)0x200008d3 = 5;
    *(uint16_t*)0x200008d4 = 0x20;
    *(uint8_t*)0x200008d6 = 2;
    *(uint8_t*)0x200008d7 = 2;
    *(uint16_t*)0x200008d8 = 8;
    *(uint16_t*)0x200008da = 2;
    *(uint32_t*)0x200008dc = 8;
    *(uint16_t*)0x200008e0 = 0xc;
    *(uint16_t*)0x200008e2 = 1;
    *(uint16_t*)0x200008e4 = 6;
    *(uint8_t*)0x200008e6 = 0x86;
    *(uint8_t*)0x200008e7 = 2;
    *(uint16_t*)0x200008e8 = 6;
    *(uint8_t*)0x200008ea = 0x81;
    *(uint8_t*)0x200008eb = 1;
    *(uint16_t*)0x200008ec = 0x27;
    *(uint16_t*)0x200008ee = 2;
    *(uint32_t*)0x200008f0 = 9;
    *(uint32_t*)0x200008f4 = 3;
    memcpy((void*)0x200008f8, "\x81\xe1\xd6\x24\xb3\x1e\xed\x9a\xfb\xc5", 10);
    memcpy((void*)0x20000902, "\xff\x4f\x3f\xb8\xe1\x65\x74\x73\x00", 9);
    *(uint32_t*)0x2000090b = 9;
    *(uint32_t*)0x2000090f = 9;
    *(uint16_t*)0x20000914 = 8;
    *(uint16_t*)0x20000916 = 1;
    *(uint16_t*)0x20000918 = 0x7f;
    *(uint16_t*)0x2000091a = 0;
    *(uint16_t*)0x2000091c = 0x1034;
    *(uint16_t*)0x2000091e = 2;
    *(uint16_t*)0x20000920 = 0x404;
    *(uint16_t*)0x20000922 = 3;
    *(uint32_t*)0x20000924 = 6;
    *(uint32_t*)0x20000928 = 0;
    *(uint32_t*)0x2000092c = 5;
    *(uint32_t*)0x20000930 = 0x8c0;
    *(uint32_t*)0x20000934 = 0x1f;
    *(uint32_t*)0x20000938 = 3;
    *(uint32_t*)0x2000093c = 0x47c;
    *(uint32_t*)0x20000940 = 0x3cbd;
    *(uint32_t*)0x20000944 = 0x80000001;
    *(uint32_t*)0x20000948 = 9;
    *(uint32_t*)0x2000094c = 3;
    *(uint32_t*)0x20000950 = 4;
    *(uint32_t*)0x20000954 = 0;
    *(uint32_t*)0x20000958 = 6;
    *(uint32_t*)0x2000095c = 0;
    *(uint32_t*)0x20000960 = 0x10000;
    *(uint32_t*)0x20000964 = 0;
    *(uint32_t*)0x20000968 = 0xfffffff9;
    *(uint32_t*)0x2000096c = 0x60;
    *(uint32_t*)0x20000970 = 0x3f;
    *(uint32_t*)0x20000974 = 1;
    *(uint32_t*)0x20000978 = 0x101;
    *(uint32_t*)0x2000097c = 0;
    *(uint32_t*)0x20000980 = 7;
    *(uint32_t*)0x20000984 = 0xff;
    *(uint32_t*)0x20000988 = 9;
    *(uint32_t*)0x2000098c = 6;
    *(uint32_t*)0x20000990 = 6;
    *(uint32_t*)0x20000994 = 3;
    *(uint32_t*)0x20000998 = 0x8000009;
    *(uint32_t*)0x2000099c = 0x20;
    *(uint32_t*)0x200009a0 = 8;
    *(uint32_t*)0x200009a4 = 7;
    *(uint32_t*)0x200009a8 = 0xc6;
    *(uint32_t*)0x200009ac = 0x10;
    *(uint32_t*)0x200009b0 = 9;
    *(uint32_t*)0x200009b4 = 0x81;
    *(uint32_t*)0x200009b8 = -1;
    *(uint32_t*)0x200009bc = 7;
    *(uint32_t*)0x200009c0 = 0x8a;
    *(uint32_t*)0x200009c4 = 0x1ff;
    *(uint32_t*)0x200009c8 = 0x80;
    *(uint32_t*)0x200009cc = 0x400;
    *(uint32_t*)0x200009d0 = 0xffff;
    *(uint32_t*)0x200009d4 = 3;
    *(uint32_t*)0x200009d8 = 5;
    *(uint32_t*)0x200009dc = 0x400;
    *(uint32_t*)0x200009e0 = 7;
    *(uint32_t*)0x200009e4 = 5;
    *(uint32_t*)0x200009e8 = 1;
    *(uint32_t*)0x200009ec = 3;
    *(uint32_t*)0x200009f0 = 6;
    *(uint32_t*)0x200009f4 = 0;
    *(uint32_t*)0x200009f8 = 0x80000000;
    *(uint32_t*)0x200009fc = 9;
    *(uint32_t*)0x20000a00 = 0x40;
    *(uint32_t*)0x20000a04 = 9;
    *(uint32_t*)0x20000a08 = 8;
    *(uint32_t*)0x20000a0c = 0x1f;
    *(uint32_t*)0x20000a10 = 2;
    *(uint32_t*)0x20000a14 = 1;
    *(uint32_t*)0x20000a18 = 0x8001;
    *(uint32_t*)0x20000a1c = 3;
    *(uint32_t*)0x20000a20 = 1;
    *(uint32_t*)0x20000a24 = 0xffffffc0;
    *(uint32_t*)0x20000a28 = 0;
    *(uint32_t*)0x20000a2c = 9;
    *(uint32_t*)0x20000a30 = 0xd273;
    *(uint32_t*)0x20000a34 = 0x74;
    *(uint32_t*)0x20000a38 = 4;
    *(uint32_t*)0x20000a3c = 0;
    *(uint32_t*)0x20000a40 = 0xfffff000;
    *(uint32_t*)0x20000a44 = 0xee;
    *(uint32_t*)0x20000a48 = 4;
    *(uint32_t*)0x20000a4c = 0x9db6;
    *(uint32_t*)0x20000a50 = 7;
    *(uint32_t*)0x20000a54 = 2;
    *(uint32_t*)0x20000a58 = 7;
    *(uint32_t*)0x20000a5c = 0x10000;
    *(uint32_t*)0x20000a60 = 0xa23;
    *(uint32_t*)0x20000a64 = 5;
    *(uint32_t*)0x20000a68 = 1;
    *(uint32_t*)0x20000a6c = 0x8000;
    *(uint32_t*)0x20000a70 = 0xd472;
    *(uint32_t*)0x20000a74 = 1;
    *(uint32_t*)0x20000a78 = 0xd45;
    *(uint32_t*)0x20000a7c = 7;
    *(uint32_t*)0x20000a80 = 3;
    *(uint32_t*)0x20000a84 = 0x7d55;
    *(uint32_t*)0x20000a88 = 3;
    *(uint32_t*)0x20000a8c = 0x400;
    *(uint32_t*)0x20000a90 = 0x4b;
    *(uint32_t*)0x20000a94 = 0x80000001;
    *(uint32_t*)0x20000a98 = 0x80000000;
    *(uint32_t*)0x20000a9c = 7;
    *(uint32_t*)0x20000aa0 = 2;
    *(uint32_t*)0x20000aa4 = 1;
    *(uint32_t*)0x20000aa8 = 7;
    *(uint32_t*)0x20000aac = 0x6a9d8437;
    *(uint32_t*)0x20000ab0 = 9;
    *(uint32_t*)0x20000ab4 = 8;
    *(uint32_t*)0x20000ab8 = 0x10001;
    *(uint32_t*)0x20000abc = 0xfffff0a1;
    *(uint32_t*)0x20000ac0 = 0x81;
    *(uint32_t*)0x20000ac4 = 7;
    *(uint32_t*)0x20000ac8 = 3;
    *(uint32_t*)0x20000acc = 0x7ff;
    *(uint32_t*)0x20000ad0 = 1;
    *(uint32_t*)0x20000ad4 = 5;
    *(uint32_t*)0x20000ad8 = 0x7fffffff;
    *(uint32_t*)0x20000adc = 0x7f;
    *(uint32_t*)0x20000ae0 = 0x80;
    *(uint32_t*)0x20000ae4 = 2;
    *(uint32_t*)0x20000ae8 = 0xfffffffd;
    *(uint32_t*)0x20000aec = 0x6de;
    *(uint32_t*)0x20000af0 = 3;
    *(uint32_t*)0x20000af4 = 7;
    *(uint32_t*)0x20000af8 = 0x7f;
    *(uint32_t*)0x20000afc = 8;
    *(uint32_t*)0x20000b00 = 2;
    *(uint32_t*)0x20000b04 = 0;
    *(uint32_t*)0x20000b08 = 8;
    *(uint32_t*)0x20000b0c = 0x8000;
    *(uint32_t*)0x20000b10 = 0x5e9;
    *(uint32_t*)0x20000b14 = 0x800;
    *(uint32_t*)0x20000b18 = 0;
    *(uint32_t*)0x20000b1c = 7;
    *(uint32_t*)0x20000b20 = 0x3000000;
    *(uint32_t*)0x20000b24 = 4;
    *(uint32_t*)0x20000b28 = 0x80000001;
    *(uint32_t*)0x20000b2c = 2;
    *(uint32_t*)0x20000b30 = -1;
    *(uint32_t*)0x20000b34 = 0x7ff;
    *(uint32_t*)0x20000b38 = 0x80;
    *(uint32_t*)0x20000b3c = 0xffffffe1;
    *(uint32_t*)0x20000b40 = 0x200;
    *(uint32_t*)0x20000b44 = 1;
    *(uint32_t*)0x20000b48 = 5;
    *(uint32_t*)0x20000b4c = 0;
    *(uint32_t*)0x20000b50 = 0x3f;
    *(uint32_t*)0x20000b54 = 5;
    *(uint32_t*)0x20000b58 = 0x3ff;
    *(uint32_t*)0x20000b5c = 8;
    *(uint32_t*)0x20000b60 = 0xff;
    *(uint32_t*)0x20000b64 = 0x45f;
    *(uint32_t*)0x20000b68 = 0x10000;
    *(uint32_t*)0x20000b6c = 0;
    *(uint32_t*)0x20000b70 = 0xc0;
    *(uint32_t*)0x20000b74 = 2;
    *(uint32_t*)0x20000b78 = 0x20;
    *(uint32_t*)0x20000b7c = 0x200;
    *(uint32_t*)0x20000b80 = -1;
    *(uint32_t*)0x20000b84 = -1;
    *(uint32_t*)0x20000b88 = 9;
    *(uint32_t*)0x20000b8c = 0xfffffffe;
    *(uint32_t*)0x20000b90 = 6;
    *(uint32_t*)0x20000b94 = 2;
    *(uint32_t*)0x20000b98 = 0x9b32;
    *(uint32_t*)0x20000b9c = 6;
    *(uint32_t*)0x20000ba0 = 0xc3;
    *(uint32_t*)0x20000ba4 = 7;
    *(uint32_t*)0x20000ba8 = 2;
    *(uint32_t*)0x20000bac = 9;
    *(uint32_t*)0x20000bb0 = 0xfd52;
    *(uint32_t*)0x20000bb4 = 9;
    *(uint32_t*)0x20000bb8 = 3;
    *(uint32_t*)0x20000bbc = 0x64;
    *(uint32_t*)0x20000bc0 = 7;
    *(uint32_t*)0x20000bc4 = 0xffff9689;
    *(uint32_t*)0x20000bc8 = 0x80;
    *(uint32_t*)0x20000bcc = 1;
    *(uint32_t*)0x20000bd0 = 0x25;
    *(uint32_t*)0x20000bd4 = 0x10000;
    *(uint32_t*)0x20000bd8 = 1;
    *(uint32_t*)0x20000bdc = 2;
    *(uint32_t*)0x20000be0 = 0x1f;
    *(uint32_t*)0x20000be4 = 0x80000000;
    *(uint32_t*)0x20000be8 = 2;
    *(uint32_t*)0x20000bec = 3;
    *(uint32_t*)0x20000bf0 = 0x20;
    *(uint32_t*)0x20000bf4 = 0x80000001;
    *(uint32_t*)0x20000bf8 = 0x1add;
    *(uint32_t*)0x20000bfc = 0;
    *(uint32_t*)0x20000c00 = 0;
    *(uint32_t*)0x20000c04 = 0x8000;
    *(uint32_t*)0x20000c08 = 0;
    *(uint32_t*)0x20000c0c = 0x7ff;
    *(uint32_t*)0x20000c10 = 0x401;
    *(uint32_t*)0x20000c14 = 1;
    *(uint32_t*)0x20000c18 = 0xc1bd;
    *(uint32_t*)0x20000c1c = 0x1ff;
    *(uint32_t*)0x20000c20 = 0xfffffff7;
    *(uint32_t*)0x20000c24 = 5;
    *(uint32_t*)0x20000c28 = 0x86b;
    *(uint32_t*)0x20000c2c = 0;
    *(uint32_t*)0x20000c30 = 7;
    *(uint32_t*)0x20000c34 = 2;
    *(uint32_t*)0x20000c38 = 0x1ed;
    *(uint32_t*)0x20000c3c = 1;
    *(uint32_t*)0x20000c40 = 0xfffff080;
    *(uint32_t*)0x20000c44 = 0x40;
    *(uint32_t*)0x20000c48 = 0x10001;
    *(uint32_t*)0x20000c4c = 0x94;
    *(uint32_t*)0x20000c50 = 0x5c1;
    *(uint32_t*)0x20000c54 = 0x1f80000;
    *(uint32_t*)0x20000c58 = 0x40;
    *(uint32_t*)0x20000c5c = 0;
    *(uint32_t*)0x20000c60 = 0xd1b6;
    *(uint32_t*)0x20000c64 = 7;
    *(uint32_t*)0x20000c68 = 0x7f;
    *(uint32_t*)0x20000c6c = 0x8001;
    *(uint32_t*)0x20000c70 = 3;
    *(uint32_t*)0x20000c74 = 0xbda0;
    *(uint32_t*)0x20000c78 = 0;
    *(uint32_t*)0x20000c7c = 0xfffff837;
    *(uint32_t*)0x20000c80 = 3;
    *(uint32_t*)0x20000c84 = 0;
    *(uint32_t*)0x20000c88 = 3;
    *(uint32_t*)0x20000c8c = 1;
    *(uint32_t*)0x20000c90 = 0x56;
    *(uint32_t*)0x20000c94 = 4;
    *(uint32_t*)0x20000c98 = 3;
    *(uint32_t*)0x20000c9c = 0x401;
    *(uint32_t*)0x20000ca0 = 8;
    *(uint32_t*)0x20000ca4 = 6;
    *(uint32_t*)0x20000ca8 = 1;
    *(uint32_t*)0x20000cac = 0;
    *(uint32_t*)0x20000cb0 = 4;
    *(uint32_t*)0x20000cb4 = 1;
    *(uint32_t*)0x20000cb8 = 9;
    *(uint32_t*)0x20000cbc = 0x636;
    *(uint32_t*)0x20000cc0 = 0x7f;
    *(uint32_t*)0x20000cc4 = 7;
    *(uint32_t*)0x20000cc8 = 0x10;
    *(uint32_t*)0x20000ccc = 0;
    *(uint32_t*)0x20000cd0 = 0x800;
    *(uint32_t*)0x20000cd4 = 0x1e2;
    *(uint32_t*)0x20000cd8 = 0x10001;
    *(uint32_t*)0x20000cdc = 0x80;
    *(uint32_t*)0x20000ce0 = 0x7f;
    *(uint32_t*)0x20000ce4 = 0x400;
    *(uint32_t*)0x20000ce8 = 0x101;
    *(uint32_t*)0x20000cec = 0x3ff;
    *(uint32_t*)0x20000cf0 = 0x10000;
    *(uint32_t*)0x20000cf4 = 5;
    *(uint32_t*)0x20000cf8 = 2;
    *(uint32_t*)0x20000cfc = 8;
    *(uint32_t*)0x20000d00 = 9;
    *(uint32_t*)0x20000d04 = 0;
    *(uint32_t*)0x20000d08 = 2;
    *(uint32_t*)0x20000d0c = 0xbc8;
    *(uint32_t*)0x20000d10 = 0x401;
    *(uint32_t*)0x20000d14 = 1;
    *(uint32_t*)0x20000d18 = 2;
    *(uint32_t*)0x20000d1c = 7;
    *(uint32_t*)0x20000d20 = 0xfffffffa;
    *(uint16_t*)0x20000d24 = 0xc;
    *(uint16_t*)0x20000d26 = 9;
    *(uint64_t*)0x20000d28 = 0xd4e;
    *(uint16_t*)0x20000d30 = 0xc;
    *(uint16_t*)0x20000d32 = 8;
    *(uint64_t*)0x20000d34 = 8;
    *(uint16_t*)0x20000d3c = 8;
    *(uint16_t*)0x20000d3e = 5;
    *(uint32_t*)0x20000d40 = 3;
    *(uint16_t*)0x20000d44 = 0x404;
    *(uint16_t*)0x20000d46 = 3;
    *(uint32_t*)0x20000d48 = 9;
    *(uint32_t*)0x20000d4c = 0x2ec6;
    *(uint32_t*)0x20000d50 = 3;
    *(uint32_t*)0x20000d54 = 8;
    *(uint32_t*)0x20000d58 = 1;
    *(uint32_t*)0x20000d5c = 0;
    *(uint32_t*)0x20000d60 = 2;
    *(uint32_t*)0x20000d64 = 0;
    *(uint32_t*)0x20000d68 = 2;
    *(uint32_t*)0x20000d6c = 0x20;
    *(uint32_t*)0x20000d70 = 7;
    *(uint32_t*)0x20000d74 = -1;
    *(uint32_t*)0x20000d78 = 4;
    *(uint32_t*)0x20000d7c = 0;
    *(uint32_t*)0x20000d80 = 2;
    *(uint32_t*)0x20000d84 = 0x1063;
    *(uint32_t*)0x20000d88 = 8;
    *(uint32_t*)0x20000d8c = 0x4f0f;
    *(uint32_t*)0x20000d90 = 0x9eef;
    *(uint32_t*)0x20000d94 = 2;
    *(uint32_t*)0x20000d98 = 0x3f;
    *(uint32_t*)0x20000d9c = 2;
    *(uint32_t*)0x20000da0 = 7;
    *(uint32_t*)0x20000da4 = 2;
    *(uint32_t*)0x20000da8 = 0x1f;
    *(uint32_t*)0x20000dac = 0;
    *(uint32_t*)0x20000db0 = 1;
    *(uint32_t*)0x20000db4 = 1;
    *(uint32_t*)0x20000db8 = 0xdad3;
    *(uint32_t*)0x20000dbc = 5;
    *(uint32_t*)0x20000dc0 = 0xc3;
    *(uint32_t*)0x20000dc4 = 5;
    *(uint32_t*)0x20000dc8 = 0x3f;
    *(uint32_t*)0x20000dcc = 0x1ff;
    *(uint32_t*)0x20000dd0 = 4;
    *(uint32_t*)0x20000dd4 = 4;
    *(uint32_t*)0x20000dd8 = 0x40;
    *(uint32_t*)0x20000ddc = 3;
    *(uint32_t*)0x20000de0 = 5;
    *(uint32_t*)0x20000de4 = 5;
    *(uint32_t*)0x20000de8 = 0x200;
    *(uint32_t*)0x20000dec = 1;
    *(uint32_t*)0x20000df0 = 0;
    *(uint32_t*)0x20000df4 = 0x10000;
    *(uint32_t*)0x20000df8 = 0;
    *(uint32_t*)0x20000dfc = 5;
    *(uint32_t*)0x20000e00 = 0x4800000;
    *(uint32_t*)0x20000e04 = 0x800;
    *(uint32_t*)0x20000e08 = 6;
    *(uint32_t*)0x20000e0c = 3;
    *(uint32_t*)0x20000e10 = 9;
    *(uint32_t*)0x20000e14 = 5;
    *(uint32_t*)0x20000e18 = 0x94;
    *(uint32_t*)0x20000e1c = 0x10000;
    *(uint32_t*)0x20000e20 = 6;
    *(uint32_t*)0x20000e24 = 0x8506;
    *(uint32_t*)0x20000e28 = 0x9d7;
    *(uint32_t*)0x20000e2c = 1;
    *(uint32_t*)0x20000e30 = 0x6926;
    *(uint32_t*)0x20000e34 = 7;
    *(uint32_t*)0x20000e38 = 0x45;
    *(uint32_t*)0x20000e3c = 2;
    *(uint32_t*)0x20000e40 = 1;
    *(uint32_t*)0x20000e44 = 1;
    *(uint32_t*)0x20000e48 = 0x81;
    *(uint32_t*)0x20000e4c = 9;
    *(uint32_t*)0x20000e50 = 3;
    *(uint32_t*)0x20000e54 = 6;
    *(uint32_t*)0x20000e58 = 0;
    *(uint32_t*)0x20000e5c = 2;
    *(uint32_t*)0x20000e60 = 5;
    *(uint32_t*)0x20000e64 = 2;
    *(uint32_t*)0x20000e68 = 8;
    *(uint32_t*)0x20000e6c = 1;
    *(uint32_t*)0x20000e70 = 3;
    *(uint32_t*)0x20000e74 = 1;
    *(uint32_t*)0x20000e78 = 4;
    *(uint32_t*)0x20000e7c = 0x80;
    *(uint32_t*)0x20000e80 = 1;
    *(uint32_t*)0x20000e84 = 7;
    *(uint32_t*)0x20000e88 = 0x2ff716fc;
    *(uint32_t*)0x20000e8c = 5;
    *(uint32_t*)0x20000e90 = 1;
    *(uint32_t*)0x20000e94 = 4;
    *(uint32_t*)0x20000e98 = 9;
    *(uint32_t*)0x20000e9c = 0xbe4f;
    *(uint32_t*)0x20000ea0 = 0;
    *(uint32_t*)0x20000ea4 = 0x80000001;
    *(uint32_t*)0x20000ea8 = 0x10001;
    *(uint32_t*)0x20000eac = 0x3f;
    *(uint32_t*)0x20000eb0 = 5;
    *(uint32_t*)0x20000eb4 = 0x400;
    *(uint32_t*)0x20000eb8 = 2;
    *(uint32_t*)0x20000ebc = 1;
    *(uint32_t*)0x20000ec0 = 0x7f;
    *(uint32_t*)0x20000ec4 = 0x101;
    *(uint32_t*)0x20000ec8 = 0x1f;
    *(uint32_t*)0x20000ecc = 0x200;
    *(uint32_t*)0x20000ed0 = 0xfd;
    *(uint32_t*)0x20000ed4 = 3;
    *(uint32_t*)0x20000ed8 = 0;
    *(uint32_t*)0x20000edc = 9;
    *(uint32_t*)0x20000ee0 = 0x1f;
    *(uint32_t*)0x20000ee4 = 6;
    *(uint32_t*)0x20000ee8 = 0x100;
    *(uint32_t*)0x20000eec = 0xfff;
    *(uint32_t*)0x20000ef0 = 4;
    *(uint32_t*)0x20000ef4 = 0xf00;
    *(uint32_t*)0x20000ef8 = 9;
    *(uint32_t*)0x20000efc = 0xed;
    *(uint32_t*)0x20000f00 = 8;
    *(uint32_t*)0x20000f04 = 0x8e;
    *(uint32_t*)0x20000f08 = 0;
    *(uint32_t*)0x20000f0c = 3;
    *(uint32_t*)0x20000f10 = 0xc9;
    *(uint32_t*)0x20000f14 = 0;
    *(uint32_t*)0x20000f18 = 8;
    *(uint32_t*)0x20000f1c = 4;
    *(uint32_t*)0x20000f20 = 0xfffffffb;
    *(uint32_t*)0x20000f24 = 0x800;
    *(uint32_t*)0x20000f28 = 0x7351;
    *(uint32_t*)0x20000f2c = 8;
    *(uint32_t*)0x20000f30 = 0x1ff;
    *(uint32_t*)0x20000f34 = 0;
    *(uint32_t*)0x20000f38 = 0x80;
    *(uint32_t*)0x20000f3c = 0x80000001;
    *(uint32_t*)0x20000f40 = 0x51;
    *(uint32_t*)0x20000f44 = 5;
    *(uint32_t*)0x20000f48 = 6;
    *(uint32_t*)0x20000f4c = 6;
    *(uint32_t*)0x20000f50 = 1;
    *(uint32_t*)0x20000f54 = 3;
    *(uint32_t*)0x20000f58 = 0xf33;
    *(uint32_t*)0x20000f5c = 7;
    *(uint32_t*)0x20000f60 = 0x55ac718b;
    *(uint32_t*)0x20000f64 = 0xe6;
    *(uint32_t*)0x20000f68 = 0xfff;
    *(uint32_t*)0x20000f6c = 0xc1;
    *(uint32_t*)0x20000f70 = 0xff;
    *(uint32_t*)0x20000f74 = 2;
    *(uint32_t*)0x20000f78 = 0x7fffffff;
    *(uint32_t*)0x20000f7c = 0x9ef7;
    *(uint32_t*)0x20000f80 = 0xfffffff8;
    *(uint32_t*)0x20000f84 = 1;
    *(uint32_t*)0x20000f88 = 3;
    *(uint32_t*)0x20000f8c = 9;
    *(uint32_t*)0x20000f90 = 0x4d;
    *(uint32_t*)0x20000f94 = 0;
    *(uint32_t*)0x20000f98 = 0;
    *(uint32_t*)0x20000f9c = 0;
    *(uint32_t*)0x20000fa0 = 0xb7;
    *(uint32_t*)0x20000fa4 = 3;
    *(uint32_t*)0x20000fa8 = 0x101;
    *(uint32_t*)0x20000fac = 0;
    *(uint32_t*)0x20000fb0 = 4;
    *(uint32_t*)0x20000fb4 = 0x1c000000;
    *(uint32_t*)0x20000fb8 = 0x1633;
    *(uint32_t*)0x20000fbc = 2;
    *(uint32_t*)0x20000fc0 = 8;
    *(uint32_t*)0x20000fc4 = 2;
    *(uint32_t*)0x20000fc8 = 9;
    *(uint32_t*)0x20000fcc = -1;
    *(uint32_t*)0x20000fd0 = 0x1f;
    *(uint32_t*)0x20000fd4 = 4;
    *(uint32_t*)0x20000fd8 = 0xcce8;
    *(uint32_t*)0x20000fdc = 0x1ff;
    *(uint32_t*)0x20000fe0 = 4;
    *(uint32_t*)0x20000fe4 = 0xfe000000;
    *(uint32_t*)0x20000fe8 = 1;
    *(uint32_t*)0x20000fec = 0x40;
    *(uint32_t*)0x20000ff0 = 0x3f;
    *(uint32_t*)0x20000ff4 = 2;
    *(uint32_t*)0x20000ff8 = 6;
    *(uint32_t*)0x20000ffc = 0xfffffff9;
    *(uint32_t*)0x20001000 = 5;
    *(uint32_t*)0x20001004 = 8;
    *(uint32_t*)0x20001008 = 0x100;
    *(uint32_t*)0x2000100c = 1;
    *(uint32_t*)0x20001010 = 2;
    *(uint32_t*)0x20001014 = 4;
    *(uint32_t*)0x20001018 = 0xe3ec;
    *(uint32_t*)0x2000101c = 0x200;
    *(uint32_t*)0x20001020 = 0x1e10;
    *(uint32_t*)0x20001024 = 8;
    *(uint32_t*)0x20001028 = 0x3f;
    *(uint32_t*)0x2000102c = 3;
    *(uint32_t*)0x20001030 = 0x488;
    *(uint32_t*)0x20001034 = 7;
    *(uint32_t*)0x20001038 = 2;
    *(uint32_t*)0x2000103c = 5;
    *(uint32_t*)0x20001040 = 0xffffffc1;
    *(uint32_t*)0x20001044 = 0x2800;
    *(uint32_t*)0x20001048 = 0;
    *(uint32_t*)0x2000104c = 0x7fffffff;
    *(uint32_t*)0x20001050 = 0xfffffe01;
    *(uint32_t*)0x20001054 = 0x3200000;
    *(uint32_t*)0x20001058 = 5;
    *(uint32_t*)0x2000105c = -1;
    *(uint32_t*)0x20001060 = 5;
    *(uint32_t*)0x20001064 = 9;
    *(uint32_t*)0x20001068 = 7;
    *(uint32_t*)0x2000106c = 1;
    *(uint32_t*)0x20001070 = 0x72;
    *(uint32_t*)0x20001074 = 0xfffffffd;
    *(uint32_t*)0x20001078 = 0x48b;
    *(uint32_t*)0x2000107c = 0x3ff;
    *(uint32_t*)0x20001080 = 0x8001;
    *(uint32_t*)0x20001084 = 7;
    *(uint32_t*)0x20001088 = 0x80;
    *(uint32_t*)0x2000108c = 0x401;
    *(uint32_t*)0x20001090 = 0x10000;
    *(uint32_t*)0x20001094 = 3;
    *(uint32_t*)0x20001098 = 0xfffff000;
    *(uint32_t*)0x2000109c = 0x53a2ba1c;
    *(uint32_t*)0x200010a0 = 5;
    *(uint32_t*)0x200010a4 = 7;
    *(uint32_t*)0x200010a8 = 0x4c;
    *(uint32_t*)0x200010ac = 4;
    *(uint32_t*)0x200010b0 = 0xcfec;
    *(uint32_t*)0x200010b4 = 6;
    *(uint32_t*)0x200010b8 = 9;
    *(uint32_t*)0x200010bc = 1;
    *(uint32_t*)0x200010c0 = 0x80000001;
    *(uint32_t*)0x200010c4 = 8;
    *(uint32_t*)0x200010c8 = 6;
    *(uint32_t*)0x200010cc = 6;
    *(uint32_t*)0x200010d0 = 2;
    *(uint32_t*)0x200010d4 = 6;
    *(uint32_t*)0x200010d8 = 9;
    *(uint32_t*)0x200010dc = 0;
    *(uint32_t*)0x200010e0 = 4;
    *(uint32_t*)0x200010e4 = 6;
    *(uint32_t*)0x200010e8 = 0x800;
    *(uint32_t*)0x200010ec = 0xf6d8;
    *(uint32_t*)0x200010f0 = 0x800;
    *(uint32_t*)0x200010f4 = 5;
    *(uint32_t*)0x200010f8 = 0x80000001;
    *(uint32_t*)0x200010fc = 0x7fff;
    *(uint32_t*)0x20001100 = 0;
    *(uint32_t*)0x20001104 = 0x800;
    *(uint32_t*)0x20001108 = 0x10000;
    *(uint32_t*)0x2000110c = 4;
    *(uint32_t*)0x20001110 = 0xfff;
    *(uint32_t*)0x20001114 = 4;
    *(uint32_t*)0x20001118 = 0;
    *(uint32_t*)0x2000111c = -1;
    *(uint32_t*)0x20001120 = 0xfff;
    *(uint32_t*)0x20001124 = 3;
    *(uint32_t*)0x20001128 = 0x3f;
    *(uint32_t*)0x2000112c = 6;
    *(uint32_t*)0x20001130 = 9;
    *(uint32_t*)0x20001134 = 1;
    *(uint32_t*)0x20001138 = 0x2e0;
    *(uint32_t*)0x2000113c = 0x7fffffff;
    *(uint32_t*)0x20001140 = 2;
    *(uint32_t*)0x20001144 = 3;
    *(uint16_t*)0x20001148 = 0x404;
    *(uint16_t*)0x2000114a = 2;
    *(uint32_t*)0x2000114c = 0x7158d5a7;
    *(uint32_t*)0x20001150 = 2;
    *(uint32_t*)0x20001154 = 2;
    *(uint32_t*)0x20001158 = 0x6f;
    *(uint32_t*)0x2000115c = 0xfffffc01;
    *(uint32_t*)0x20001160 = 0xffff87d3;
    *(uint32_t*)0x20001164 = 0xc9;
    *(uint32_t*)0x20001168 = -1;
    *(uint32_t*)0x2000116c = 0xffff;
    *(uint32_t*)0x20001170 = 0x401;
    *(uint32_t*)0x20001174 = 5;
    *(uint32_t*)0x20001178 = 0xffff;
    *(uint32_t*)0x2000117c = 0x81;
    *(uint32_t*)0x20001180 = 7;
    *(uint32_t*)0x20001184 = 6;
    *(uint32_t*)0x20001188 = 1;
    *(uint32_t*)0x2000118c = 0xffff;
    *(uint32_t*)0x20001190 = 0;
    *(uint32_t*)0x20001194 = 0x3ff;
    *(uint32_t*)0x20001198 = 0xe2;
    *(uint32_t*)0x2000119c = 1;
    *(uint32_t*)0x200011a0 = 0x261fe47d;
    *(uint32_t*)0x200011a4 = 0xffff;
    *(uint32_t*)0x200011a8 = 8;
    *(uint32_t*)0x200011ac = 0xffff8001;
    *(uint32_t*)0x200011b0 = 4;
    *(uint32_t*)0x200011b4 = 0x3a5;
    *(uint32_t*)0x200011b8 = 2;
    *(uint32_t*)0x200011bc = 0;
    *(uint32_t*)0x200011c0 = 1;
    *(uint32_t*)0x200011c4 = 7;
    *(uint32_t*)0x200011c8 = 8;
    *(uint32_t*)0x200011cc = 9;
    *(uint32_t*)0x200011d0 = 7;
    *(uint32_t*)0x200011d4 = 4;
    *(uint32_t*)0x200011d8 = 0x4000;
    *(uint32_t*)0x200011dc = 1;
    *(uint32_t*)0x200011e0 = 0x80;
    *(uint32_t*)0x200011e4 = 7;
    *(uint32_t*)0x200011e8 = 0xc17;
    *(uint32_t*)0x200011ec = 0;
    *(uint32_t*)0x200011f0 = 0x80000001;
    *(uint32_t*)0x200011f4 = 1;
    *(uint32_t*)0x200011f8 = 0xffff;
    *(uint32_t*)0x200011fc = 0x7f;
    *(uint32_t*)0x20001200 = 9;
    *(uint32_t*)0x20001204 = 0xe806a35;
    *(uint32_t*)0x20001208 = 0xba;
    *(uint32_t*)0x2000120c = 8;
    *(uint32_t*)0x20001210 = 4;
    *(uint32_t*)0x20001214 = 0;
    *(uint32_t*)0x20001218 = 0xca;
    *(uint32_t*)0x2000121c = 0xff;
    *(uint32_t*)0x20001220 = 0x10001;
    *(uint32_t*)0x20001224 = 6;
    *(uint32_t*)0x20001228 = 2;
    *(uint32_t*)0x2000122c = 0;
    *(uint32_t*)0x20001230 = 6;
    *(uint32_t*)0x20001234 = 2;
    *(uint32_t*)0x20001238 = 5;
    *(uint32_t*)0x2000123c = 0x80000001;
    *(uint32_t*)0x20001240 = 1;
    *(uint32_t*)0x20001244 = 0x25f;
    *(uint32_t*)0x20001248 = 0;
    *(uint32_t*)0x2000124c = 0xb45;
    *(uint32_t*)0x20001250 = 0x10001;
    *(uint32_t*)0x20001254 = 0x7ff;
    *(uint32_t*)0x20001258 = 5;
    *(uint32_t*)0x2000125c = 0x7f;
    *(uint32_t*)0x20001260 = 9;
    *(uint32_t*)0x20001264 = 0xff;
    *(uint32_t*)0x20001268 = 4;
    *(uint32_t*)0x2000126c = 6;
    *(uint32_t*)0x20001270 = 8;
    *(uint32_t*)0x20001274 = 0xa6;
    *(uint32_t*)0x20001278 = 7;
    *(uint32_t*)0x2000127c = 0x1f;
    *(uint32_t*)0x20001280 = 3;
    *(uint32_t*)0x20001284 = 0x100;
    *(uint32_t*)0x20001288 = 0;
    *(uint32_t*)0x2000128c = 0x900000;
    *(uint32_t*)0x20001290 = 3;
    *(uint32_t*)0x20001294 = 0xffff;
    *(uint32_t*)0x20001298 = 0x10000;
    *(uint32_t*)0x2000129c = 0x2527;
    *(uint32_t*)0x200012a0 = 0x81;
    *(uint32_t*)0x200012a4 = 6;
    *(uint32_t*)0x200012a8 = 9;
    *(uint32_t*)0x200012ac = -1;
    *(uint32_t*)0x200012b0 = 0x37a;
    *(uint32_t*)0x200012b4 = 5;
    *(uint32_t*)0x200012b8 = 4;
    *(uint32_t*)0x200012bc = 3;
    *(uint32_t*)0x200012c0 = 0x7f;
    *(uint32_t*)0x200012c4 = 0;
    *(uint32_t*)0x200012c8 = 0xae;
    *(uint32_t*)0x200012cc = 8;
    *(uint32_t*)0x200012d0 = 7;
    *(uint32_t*)0x200012d4 = 0x1ff;
    *(uint32_t*)0x200012d8 = 6;
    *(uint32_t*)0x200012dc = 8;
    *(uint32_t*)0x200012e0 = 1;
    *(uint32_t*)0x200012e4 = 0x2ca;
    *(uint32_t*)0x200012e8 = 0xff;
    *(uint32_t*)0x200012ec = 0xbba8;
    *(uint32_t*)0x200012f0 = 8;
    *(uint32_t*)0x200012f4 = 0;
    *(uint32_t*)0x200012f8 = 9;
    *(uint32_t*)0x200012fc = 6;
    *(uint32_t*)0x20001300 = 0x80000001;
    *(uint32_t*)0x20001304 = 0xee;
    *(uint32_t*)0x20001308 = 0xeb5;
    *(uint32_t*)0x2000130c = 0x80;
    *(uint32_t*)0x20001310 = 0x76d;
    *(uint32_t*)0x20001314 = 0x1f;
    *(uint32_t*)0x20001318 = 0;
    *(uint32_t*)0x2000131c = 0;
    *(uint32_t*)0x20001320 = 0xa23;
    *(uint32_t*)0x20001324 = -1;
    *(uint32_t*)0x20001328 = -1;
    *(uint32_t*)0x2000132c = 0xb18;
    *(uint32_t*)0x20001330 = 6;
    *(uint32_t*)0x20001334 = 0x4fe526e5;
    *(uint32_t*)0x20001338 = 1;
    *(uint32_t*)0x2000133c = 8;
    *(uint32_t*)0x20001340 = 3;
    *(uint32_t*)0x20001344 = 0;
    *(uint32_t*)0x20001348 = 7;
    *(uint32_t*)0x2000134c = 0x10000;
    *(uint32_t*)0x20001350 = 0;
    *(uint32_t*)0x20001354 = 0xebd;
    *(uint32_t*)0x20001358 = 0x3bb;
    *(uint32_t*)0x2000135c = 9;
    *(uint32_t*)0x20001360 = 4;
    *(uint32_t*)0x20001364 = 0x3f;
    *(uint32_t*)0x20001368 = 0x1e2;
    *(uint32_t*)0x2000136c = 1;
    *(uint32_t*)0x20001370 = 5;
    *(uint32_t*)0x20001374 = 0;
    *(uint32_t*)0x20001378 = 0xa35;
    *(uint32_t*)0x2000137c = 0x101;
    *(uint32_t*)0x20001380 = 0x200;
    *(uint32_t*)0x20001384 = 0x10000;
    *(uint32_t*)0x20001388 = 2;
    *(uint32_t*)0x2000138c = 1;
    *(uint32_t*)0x20001390 = 0;
    *(uint32_t*)0x20001394 = 4;
    *(uint32_t*)0x20001398 = 7;
    *(uint32_t*)0x2000139c = 0;
    *(uint32_t*)0x200013a0 = 9;
    *(uint32_t*)0x200013a4 = 7;
    *(uint32_t*)0x200013a8 = 0x40;
    *(uint32_t*)0x200013ac = 6;
    *(uint32_t*)0x200013b0 = 2;
    *(uint32_t*)0x200013b4 = 2;
    *(uint32_t*)0x200013b8 = 6;
    *(uint32_t*)0x200013bc = 0;
    *(uint32_t*)0x200013c0 = 0x7d;
    *(uint32_t*)0x200013c4 = 0;
    *(uint32_t*)0x200013c8 = 0;
    *(uint32_t*)0x200013cc = 9;
    *(uint32_t*)0x200013d0 = 9;
    *(uint32_t*)0x200013d4 = 0x100;
    *(uint32_t*)0x200013d8 = 0;
    *(uint32_t*)0x200013dc = 0x10001;
    *(uint32_t*)0x200013e0 = 0xffffff8e;
    *(uint32_t*)0x200013e4 = 6;
    *(uint32_t*)0x200013e8 = 3;
    *(uint32_t*)0x200013ec = 0x200;
    *(uint32_t*)0x200013f0 = 0xef;
    *(uint32_t*)0x200013f4 = 0;
    *(uint32_t*)0x200013f8 = 3;
    *(uint32_t*)0x200013fc = 2;
    *(uint32_t*)0x20001400 = 0x7fff;
    *(uint32_t*)0x20001404 = 3;
    *(uint32_t*)0x20001408 = 6;
    *(uint32_t*)0x2000140c = 0x8cc;
    *(uint32_t*)0x20001410 = 0x7fffffff;
    *(uint32_t*)0x20001414 = 5;
    *(uint32_t*)0x20001418 = 0x800;
    *(uint32_t*)0x2000141c = 0x7fff;
    *(uint32_t*)0x20001420 = 0x1000;
    *(uint32_t*)0x20001424 = 0x1ff;
    *(uint32_t*)0x20001428 = 7;
    *(uint32_t*)0x2000142c = 0xffffff01;
    *(uint32_t*)0x20001430 = 0x4c;
    *(uint32_t*)0x20001434 = 0x1000;
    *(uint32_t*)0x20001438 = 4;
    *(uint32_t*)0x2000143c = 0;
    *(uint32_t*)0x20001440 = 0x7fff;
    *(uint32_t*)0x20001444 = 0x3ff;
    *(uint32_t*)0x20001448 = 5;
    *(uint32_t*)0x2000144c = 6;
    *(uint32_t*)0x20001450 = 6;
    *(uint32_t*)0x20001454 = 0x6fe;
    *(uint32_t*)0x20001458 = 0x10000;
    *(uint32_t*)0x2000145c = 0xfd4d;
    *(uint32_t*)0x20001460 = 0xfffffffa;
    *(uint32_t*)0x20001464 = -1;
    *(uint32_t*)0x20001468 = 0xe0;
    *(uint32_t*)0x2000146c = 0xd730;
    *(uint32_t*)0x20001470 = 0x80000001;
    *(uint32_t*)0x20001474 = 0x5b;
    *(uint32_t*)0x20001478 = 0x668;
    *(uint32_t*)0x2000147c = 8;
    *(uint32_t*)0x20001480 = 1;
    *(uint32_t*)0x20001484 = 0xbcad;
    *(uint32_t*)0x20001488 = 0x39c2;
    *(uint32_t*)0x2000148c = 0xffffffe1;
    *(uint32_t*)0x20001490 = 0;
    *(uint32_t*)0x20001494 = 0x3d4;
    *(uint32_t*)0x20001498 = 0x100;
    *(uint32_t*)0x2000149c = 2;
    *(uint32_t*)0x200014a0 = 0xfb;
    *(uint32_t*)0x200014a4 = 5;
    *(uint32_t*)0x200014a8 = 0;
    *(uint32_t*)0x200014ac = 2;
    *(uint32_t*)0x200014b0 = 2;
    *(uint32_t*)0x200014b4 = 4;
    *(uint32_t*)0x200014b8 = 0;
    *(uint32_t*)0x200014bc = 0x7b;
    *(uint32_t*)0x200014c0 = 0xffffff27;
    *(uint32_t*)0x200014c4 = 2;
    *(uint32_t*)0x200014c8 = 0xc9da;
    *(uint32_t*)0x200014cc = 5;
    *(uint32_t*)0x200014d0 = 4;
    *(uint32_t*)0x200014d4 = -1;
    *(uint32_t*)0x200014d8 = 0x7ebe;
    *(uint32_t*)0x200014dc = 9;
    *(uint32_t*)0x200014e0 = 5;
    *(uint32_t*)0x200014e4 = 4;
    *(uint32_t*)0x200014e8 = 9;
    *(uint32_t*)0x200014ec = 7;
    *(uint32_t*)0x200014f0 = 2;
    *(uint32_t*)0x200014f4 = 0x8f27;
    *(uint32_t*)0x200014f8 = 0xfffffffa;
    *(uint32_t*)0x200014fc = 0xfffffff9;
    *(uint32_t*)0x20001500 = 7;
    *(uint32_t*)0x20001504 = -1;
    *(uint32_t*)0x20001508 = 0xfffff907;
    *(uint32_t*)0x2000150c = 6;
    *(uint32_t*)0x20001510 = 0x7ff;
    *(uint32_t*)0x20001514 = 0x200;
    *(uint32_t*)0x20001518 = 2;
    *(uint32_t*)0x2000151c = 0;
    *(uint32_t*)0x20001520 = 0x95b;
    *(uint32_t*)0x20001524 = 4;
    *(uint32_t*)0x20001528 = 0;
    *(uint32_t*)0x2000152c = 3;
    *(uint32_t*)0x20001530 = 0x3f;
    *(uint32_t*)0x20001534 = 0x100;
    *(uint32_t*)0x20001538 = 0xc1;
    *(uint32_t*)0x2000153c = 2;
    *(uint32_t*)0x20001540 = 5;
    *(uint32_t*)0x20001544 = 0xfffffffc;
    *(uint32_t*)0x20001548 = 4;
    *(uint16_t*)0x2000154c = 0x404;
    *(uint16_t*)0x2000154e = 2;
    *(uint32_t*)0x20001550 = 3;
    *(uint32_t*)0x20001554 = 6;
    *(uint32_t*)0x20001558 = 0x1ff;
    *(uint32_t*)0x2000155c = 2;
    *(uint32_t*)0x20001560 = 6;
    *(uint32_t*)0x20001564 = 1;
    *(uint32_t*)0x20001568 = 0x3ff;
    *(uint32_t*)0x2000156c = 4;
    *(uint32_t*)0x20001570 = 5;
    *(uint32_t*)0x20001574 = 4;
    *(uint32_t*)0x20001578 = 0;
    *(uint32_t*)0x2000157c = 0xfffffe01;
    *(uint32_t*)0x20001580 = 0;
    *(uint32_t*)0x20001584 = 2;
    *(uint32_t*)0x20001588 = 0xfffffffa;
    *(uint32_t*)0x2000158c = 0x7fff;
    *(uint32_t*)0x20001590 = 0;
    *(uint32_t*)0x20001594 = 0x1000;
    *(uint32_t*)0x20001598 = 9;
    *(uint32_t*)0x2000159c = 0xbd;
    *(uint32_t*)0x200015a0 = 4;
    *(uint32_t*)0x200015a4 = 0x2000000;
    *(uint32_t*)0x200015a8 = 0x40;
    *(uint32_t*)0x200015ac = 0x81;
    *(uint32_t*)0x200015b0 = 8;
    *(uint32_t*)0x200015b4 = 0x400;
    *(uint32_t*)0x200015b8 = 9;
    *(uint32_t*)0x200015bc = 7;
    *(uint32_t*)0x200015c0 = 1;
    *(uint32_t*)0x200015c4 = 7;
    *(uint32_t*)0x200015c8 = 6;
    *(uint32_t*)0x200015cc = 0x400;
    *(uint32_t*)0x200015d0 = 7;
    *(uint32_t*)0x200015d4 = 7;
    *(uint32_t*)0x200015d8 = 4;
    *(uint32_t*)0x200015dc = 1;
    *(uint32_t*)0x200015e0 = 1;
    *(uint32_t*)0x200015e4 = 0xc469;
    *(uint32_t*)0x200015e8 = 0x7fffffff;
    *(uint32_t*)0x200015ec = 0x8c1d;
    *(uint32_t*)0x200015f0 = 3;
    *(uint32_t*)0x200015f4 = 9;
    *(uint32_t*)0x200015f8 = 3;
    *(uint32_t*)0x200015fc = 0x1f;
    *(uint32_t*)0x20001600 = 0;
    *(uint32_t*)0x20001604 = 0x400;
    *(uint32_t*)0x20001608 = 5;
    *(uint32_t*)0x2000160c = 0x383f;
    *(uint32_t*)0x20001610 = 2;
    *(uint32_t*)0x20001614 = 7;
    *(uint32_t*)0x20001618 = 0x20;
    *(uint32_t*)0x2000161c = 3;
    *(uint32_t*)0x20001620 = 0x7fff;
    *(uint32_t*)0x20001624 = 2;
    *(uint32_t*)0x20001628 = 0xd;
    *(uint32_t*)0x2000162c = 2;
    *(uint32_t*)0x20001630 = 0xa73;
    *(uint32_t*)0x20001634 = 0x9b82;
    *(uint32_t*)0x20001638 = 0xfff;
    *(uint32_t*)0x2000163c = 9;
    *(uint32_t*)0x20001640 = 6;
    *(uint32_t*)0x20001644 = 8;
    *(uint32_t*)0x20001648 = 6;
    *(uint32_t*)0x2000164c = 0;
    *(uint32_t*)0x20001650 = 0xdc;
    *(uint32_t*)0x20001654 = 0xffffc000;
    *(uint32_t*)0x20001658 = 0;
    *(uint32_t*)0x2000165c = 0x1000;
    *(uint32_t*)0x20001660 = 0x45a8;
    *(uint32_t*)0x20001664 = 0x8001;
    *(uint32_t*)0x20001668 = 0x401;
    *(uint32_t*)0x2000166c = 0x3ff;
    *(uint32_t*)0x20001670 = 0x10000;
    *(uint32_t*)0x20001674 = 3;
    *(uint32_t*)0x20001678 = 5;
    *(uint32_t*)0x2000167c = 0x821;
    *(uint32_t*)0x20001680 = 0x17;
    *(uint32_t*)0x20001684 = 8;
    *(uint32_t*)0x20001688 = 0xfffffffc;
    *(uint32_t*)0x2000168c = 3;
    *(uint32_t*)0x20001690 = 0x20000;
    *(uint32_t*)0x20001694 = 5;
    *(uint32_t*)0x20001698 = 6;
    *(uint32_t*)0x2000169c = 0;
    *(uint32_t*)0x200016a0 = 0;
    *(uint32_t*)0x200016a4 = 0x5e41b76b;
    *(uint32_t*)0x200016a8 = 0x5e9;
    *(uint32_t*)0x200016ac = 7;
    *(uint32_t*)0x200016b0 = 0xffff;
    *(uint32_t*)0x200016b4 = 0xc7e;
    *(uint32_t*)0x200016b8 = 8;
    *(uint32_t*)0x200016bc = 7;
    *(uint32_t*)0x200016c0 = 0xfff;
    *(uint32_t*)0x200016c4 = 6;
    *(uint32_t*)0x200016c8 = 2;
    *(uint32_t*)0x200016cc = 6;
    *(uint32_t*)0x200016d0 = 0x10;
    *(uint32_t*)0x200016d4 = 4;
    *(uint32_t*)0x200016d8 = 0xfffffffe;
    *(uint32_t*)0x200016dc = 8;
    *(uint32_t*)0x200016e0 = 0x401;
    *(uint32_t*)0x200016e4 = 8;
    *(uint32_t*)0x200016e8 = 2;
    *(uint32_t*)0x200016ec = 0x401;
    *(uint32_t*)0x200016f0 = 0x800;
    *(uint32_t*)0x200016f4 = 6;
    *(uint32_t*)0x200016f8 = 2;
    *(uint32_t*)0x200016fc = 0x20;
    *(uint32_t*)0x20001700 = 9;
    *(uint32_t*)0x20001704 = 5;
    *(uint32_t*)0x20001708 = 0x80;
    *(uint32_t*)0x2000170c = 0xc000;
    *(uint32_t*)0x20001710 = 0x101;
    *(uint32_t*)0x20001714 = 0xfffff747;
    *(uint32_t*)0x20001718 = 0x80000001;
    *(uint32_t*)0x2000171c = 9;
    *(uint32_t*)0x20001720 = 1;
    *(uint32_t*)0x20001724 = 0xab62;
    *(uint32_t*)0x20001728 = 0;
    *(uint32_t*)0x2000172c = 2;
    *(uint32_t*)0x20001730 = 0x38;
    *(uint32_t*)0x20001734 = 7;
    *(uint32_t*)0x20001738 = 3;
    *(uint32_t*)0x2000173c = 0x3d;
    *(uint32_t*)0x20001740 = 8;
    *(uint32_t*)0x20001744 = 0xe99;
    *(uint32_t*)0x20001748 = 0x3d;
    *(uint32_t*)0x2000174c = 3;
    *(uint32_t*)0x20001750 = 0x66789b85;
    *(uint32_t*)0x20001754 = 0x8001;
    *(uint32_t*)0x20001758 = 1;
    *(uint32_t*)0x2000175c = 3;
    *(uint32_t*)0x20001760 = 4;
    *(uint32_t*)0x20001764 = 4;
    *(uint32_t*)0x20001768 = 6;
    *(uint32_t*)0x2000176c = 1;
    *(uint32_t*)0x20001770 = 0xfffffffd;
    *(uint32_t*)0x20001774 = 0x401;
    *(uint32_t*)0x20001778 = 0x14;
    *(uint32_t*)0x2000177c = 7;
    *(uint32_t*)0x20001780 = 0x600000;
    *(uint32_t*)0x20001784 = 3;
    *(uint32_t*)0x20001788 = 6;
    *(uint32_t*)0x2000178c = 0x401;
    *(uint32_t*)0x20001790 = 4;
    *(uint32_t*)0x20001794 = 0;
    *(uint32_t*)0x20001798 = 1;
    *(uint32_t*)0x2000179c = 0xda;
    *(uint32_t*)0x200017a0 = 0xfffffff7;
    *(uint32_t*)0x200017a4 = 0x80000000;
    *(uint32_t*)0x200017a8 = 0x5b000000;
    *(uint32_t*)0x200017ac = 4;
    *(uint32_t*)0x200017b0 = 0x100;
    *(uint32_t*)0x200017b4 = 0x28;
    *(uint32_t*)0x200017b8 = 9;
    *(uint32_t*)0x200017bc = 3;
    *(uint32_t*)0x200017c0 = 0x1000;
    *(uint32_t*)0x200017c4 = 0x5040;
    *(uint32_t*)0x200017c8 = 0xeb;
    *(uint32_t*)0x200017cc = 0x61;
    *(uint32_t*)0x200017d0 = 2;
    *(uint32_t*)0x200017d4 = 4;
    *(uint32_t*)0x200017d8 = 8;
    *(uint32_t*)0x200017dc = 5;
    *(uint32_t*)0x200017e0 = 0x3ff;
    *(uint32_t*)0x200017e4 = 7;
    *(uint32_t*)0x200017e8 = 0xfffff001;
    *(uint32_t*)0x200017ec = 2;
    *(uint32_t*)0x200017f0 = 3;
    *(uint32_t*)0x200017f4 = 1;
    *(uint32_t*)0x200017f8 = 0xffffdeee;
    *(uint32_t*)0x200017fc = 6;
    *(uint32_t*)0x20001800 = 0x200;
    *(uint32_t*)0x20001804 = 0;
    *(uint32_t*)0x20001808 = 3;
    *(uint32_t*)0x2000180c = 0x7ff;
    *(uint32_t*)0x20001810 = 7;
    *(uint32_t*)0x20001814 = 5;
    *(uint32_t*)0x20001818 = -1;
    *(uint32_t*)0x2000181c = 0xff;
    *(uint32_t*)0x20001820 = 6;
    *(uint32_t*)0x20001824 = 0x624;
    *(uint32_t*)0x20001828 = 5;
    *(uint32_t*)0x2000182c = 0x3ccf9ea9;
    *(uint32_t*)0x20001830 = 0xd49;
    *(uint32_t*)0x20001834 = 2;
    *(uint32_t*)0x20001838 = 8;
    *(uint32_t*)0x2000183c = 0xff;
    *(uint32_t*)0x20001840 = 0x7ff;
    *(uint32_t*)0x20001844 = 2;
    *(uint32_t*)0x20001848 = 0x80000000;
    *(uint32_t*)0x2000184c = 4;
    *(uint32_t*)0x20001850 = 0x7fff;
    *(uint32_t*)0x20001854 = 0x7fffffff;
    *(uint32_t*)0x20001858 = 0xdb;
    *(uint32_t*)0x2000185c = 3;
    *(uint32_t*)0x20001860 = 8;
    *(uint32_t*)0x20001864 = 0x739;
    *(uint32_t*)0x20001868 = 9;
    *(uint32_t*)0x2000186c = 0x7ff;
    *(uint32_t*)0x20001870 = 0x9676;
    *(uint32_t*)0x20001874 = 0x1ff;
    *(uint32_t*)0x20001878 = 0x40;
    *(uint32_t*)0x2000187c = 0x80000000;
    *(uint32_t*)0x20001880 = 8;
    *(uint32_t*)0x20001884 = 1;
    *(uint32_t*)0x20001888 = 0xff;
    *(uint32_t*)0x2000188c = 0x3ea8;
    *(uint32_t*)0x20001890 = 0;
    *(uint32_t*)0x20001894 = 0x4bd;
    *(uint32_t*)0x20001898 = 0xfc00000;
    *(uint32_t*)0x2000189c = 0xab8;
    *(uint32_t*)0x200018a0 = 0x88;
    *(uint32_t*)0x200018a4 = 0x200;
    *(uint32_t*)0x200018a8 = 1;
    *(uint32_t*)0x200018ac = 0x19;
    *(uint32_t*)0x200018b0 = 0x9576;
    *(uint32_t*)0x200018b4 = 6;
    *(uint32_t*)0x200018b8 = 2;
    *(uint32_t*)0x200018bc = 2;
    *(uint32_t*)0x200018c0 = 2;
    *(uint32_t*)0x200018c4 = 3;
    *(uint32_t*)0x200018c8 = 0x80000001;
    *(uint32_t*)0x200018cc = 0x30000000;
    *(uint32_t*)0x200018d0 = 0x8001;
    *(uint32_t*)0x200018d4 = 7;
    *(uint32_t*)0x200018d8 = 8;
    *(uint32_t*)0x200018dc = 0xebd7;
    *(uint32_t*)0x200018e0 = 0xc96;
    *(uint32_t*)0x200018e4 = 4;
    *(uint32_t*)0x200018e8 = 2;
    *(uint32_t*)0x200018ec = 6;
    *(uint32_t*)0x200018f0 = 0xffff0001;
    *(uint32_t*)0x200018f4 = 0x200;
    *(uint32_t*)0x200018f8 = -1;
    *(uint32_t*)0x200018fc = 0x3ff;
    *(uint32_t*)0x20001900 = 0x84;
    *(uint32_t*)0x20001904 = 0;
    *(uint32_t*)0x20001908 = 7;
    *(uint32_t*)0x2000190c = 0xa93c;
    *(uint32_t*)0x20001910 = 0x3d;
    *(uint32_t*)0x20001914 = 0;
    *(uint32_t*)0x20001918 = 0x323;
    *(uint32_t*)0x2000191c = 0;
    *(uint32_t*)0x20001920 = 0;
    *(uint32_t*)0x20001924 = 4;
    *(uint32_t*)0x20001928 = 0x8001;
    *(uint32_t*)0x2000192c = 0x3f;
    *(uint32_t*)0x20001930 = 0xc1;
    *(uint32_t*)0x20001934 = 4;
    *(uint32_t*)0x20001938 = 4;
    *(uint32_t*)0x2000193c = 0x7fffffff;
    *(uint32_t*)0x20001940 = 1;
    *(uint32_t*)0x20001944 = 7;
    *(uint32_t*)0x20001948 = 0x401;
    *(uint32_t*)0x2000194c = 0x1000;
    *(uint16_t*)0x20001950 = 0x410;
    *(uint16_t*)0x20001952 = 1;
    *(uint16_t*)0x20001954 = 0x50;
    STORE_BY_BITMASK(uint16_t, , 0x20001956, 0x16, 0, 14);
    STORE_BY_BITMASK(uint16_t, , 0x20001957, 0, 6, 1);
    STORE_BY_BITMASK(uint16_t, , 0x20001957, 0, 7, 1);
    *(uint16_t*)0x20001958 = 0xb;
    *(uint16_t*)0x2000195a = 1;
    memcpy((void*)0x2000195c, "ctinfo\000", 7);
    *(uint16_t*)0x20001964 = 0x24;
    STORE_BY_BITMASK(uint16_t, , 0x20001966, 2, 0, 14);
    STORE_BY_BITMASK(uint16_t, , 0x20001967, 0, 6, 1);
    STORE_BY_BITMASK(uint16_t, , 0x20001967, 1, 7, 1);
    *(uint16_t*)0x20001968 = 0x18;
    *(uint16_t*)0x2000196a = 3;
    *(uint32_t*)0x2000196c = 0x400;
    *(uint32_t*)0x20001970 = 5;
    *(uint32_t*)0x20001974 = 4;
    *(uint32_t*)0x20001978 = 4;
    *(uint32_t*)0x2000197c = 8;
    *(uint16_t*)0x20001980 = 8;
    *(uint16_t*)0x20001982 = 5;
    *(uint32_t*)0x20001984 = 5;
    *(uint16_t*)0x20001988 = 4;
    *(uint16_t*)0x2000198a = 6;
    *(uint16_t*)0x2000198c = 0xc;
    *(uint16_t*)0x2000198e = 7;
    *(uint32_t*)0x20001990 = 0x2cbd6949;
    *(uint32_t*)0x20001994 = 0;
    *(uint16_t*)0x20001998 = 0xc;
    *(uint16_t*)0x2000199a = 8;
    *(uint32_t*)0x2000199c = 2;
    *(uint32_t*)0x200019a0 = 1;
    *(uint16_t*)0x200019a4 = 0xa4;
    STORE_BY_BITMASK(uint16_t, , 0x200019a6, 0x1a, 0, 14);
    STORE_BY_BITMASK(uint16_t, , 0x200019a7, 0, 6, 1);
    STORE_BY_BITMASK(uint16_t, , 0x200019a7, 0, 7, 1);
    *(uint16_t*)0x200019a8 = 0xc;
    *(uint16_t*)0x200019aa = 1;
    memcpy((void*)0x200019ac, "skbedit\000", 8);
    *(uint16_t*)0x200019b4 = 0x64;
    STORE_BY_BITMASK(uint16_t, , 0x200019b6, 2, 0, 14);
    STORE_BY_BITMASK(uint16_t, , 0x200019b7, 0, 6, 1);
    STORE_BY_BITMASK(uint16_t, , 0x200019b7, 1, 7, 1);
    *(uint16_t*)0x200019b8 = 6;
    *(uint16_t*)0x200019ba = 4;
    *(uint16_t*)0x200019bc = 3;
    *(uint16_t*)0x200019c0 = 0x18;
    *(uint16_t*)0x200019c2 = 2;
    *(uint32_t*)0x200019c4 = 5;
    *(uint32_t*)0x200019c8 = 0x8001;
    *(uint32_t*)0x200019cc = 6;
    *(uint32_t*)0x200019d0 = 0x688;
    *(uint32_t*)0x200019d4 = 6;
    *(uint16_t*)0x200019d8 = 6;
    *(uint16_t*)0x200019da = 7;
    *(uint16_t*)0x200019dc = 1;
    *(uint16_t*)0x200019e0 = 6;
    *(uint16_t*)0x200019e2 = 7;
    *(uint16_t*)0x200019e4 = 4;
    *(uint16_t*)0x200019e8 = 8;
    *(uint16_t*)0x200019ea = 3;
    *(uint16_t*)0x200019ec = 0xe;
    *(uint16_t*)0x200019ee = 0xfff3;
    *(uint16_t*)0x200019f0 = 8;
    *(uint16_t*)0x200019f2 = 5;
    *(uint32_t*)0x200019f4 = 8;
    *(uint16_t*)0x200019f8 = 0x18;
    *(uint16_t*)0x200019fa = 2;
    *(uint32_t*)0x200019fc = 8;
    *(uint32_t*)0x20001a00 = 0x6dd;
    *(uint32_t*)0x20001a04 = 2;
    *(uint32_t*)0x20001a08 = 1;
    *(uint32_t*)0x20001a0c = 2;
    *(uint16_t*)0x20001a10 = 8;
    *(uint16_t*)0x20001a12 = 5;
    *(uint32_t*)0x20001a14 = 0x5d00cbba;
    *(uint16_t*)0x20001a18 = 0x16;
    *(uint16_t*)0x20001a1a = 6;
    memcpy((void*)0x20001a1c, "\xdf\x3a\x85\x96\xaf\xa4\x54\xd9\x30\x0b\x59\xfe"
                              "\x1d\xbb\xa7\x3e\x01\xa6",
           18);
    *(uint16_t*)0x20001a30 = 0xc;
    *(uint16_t*)0x20001a32 = 7;
    *(uint32_t*)0x20001a34 = 1;
    *(uint32_t*)0x20001a38 = 0;
    *(uint16_t*)0x20001a3c = 0xc;
    *(uint16_t*)0x20001a3e = 8;
    *(uint32_t*)0x20001a40 = 0;
    *(uint32_t*)0x20001a44 = 3;
    *(uint16_t*)0x20001a48 = 0xe8;
    STORE_BY_BITMASK(uint16_t, , 0x20001a4a, 4, 0, 14);
    STORE_BY_BITMASK(uint16_t, , 0x20001a4b, 0, 6, 1);
    STORE_BY_BITMASK(uint16_t, , 0x20001a4b, 0, 7, 1);
    *(uint16_t*)0x20001a4c = 8;
    *(uint16_t*)0x20001a4e = 1;
    memcpy((void*)0x20001a50, "bpf\000", 4);
    *(uint16_t*)0x20001a54 = 0xc;
    STORE_BY_BITMASK(uint16_t, , 0x20001a56, 2, 0, 14);
    STORE_BY_BITMASK(uint16_t, , 0x20001a57, 0, 6, 1);
    STORE_BY_BITMASK(uint16_t, , 0x20001a57, 1, 7, 1);
    *(uint16_t*)0x20001a58 = 6;
    *(uint16_t*)0x20001a5a = 3;
    *(uint16_t*)0x20001a5c = 2;
    *(uint16_t*)0x20001a60 = 0xb8;
    *(uint16_t*)0x20001a62 = 6;
    memcpy((void*)0x20001a64,
           "\x94\xac\xdc\xb8\x23\x11\x17\x3a\xdd\xc3\x39\x6f\x25\x91\x5b\xc1"
           "\x31\x72\x71\xc8\xeb\x36\xc6\xe2\xcf\xef\x08\x1b\x61\xec\x5a\x90"
           "\x69\xc2\x49\x48\xf5\x68\xb1\x32\x8d\xbf\xe5\x57\xc4\x92\x15\x29"
           "\x1c\x1a\x7e\x3b\xbd\x41\xcb\xf1\xb9\xc7\xb1\x54\xa8\x1e\x2b\x5c"
           "\xcf\xc2\x8d\x68\xda\xe4\x0a\x4f\x59\xaf\x95\xa0\x6f\x22\x75\x23"
           "\x27\x32\x05\x0b\xa5\x85\x99\xc1\x11\xb8\x43\xc3\x1a\x31\x90\xde"
           "\xa1\x09\xd6\x66\x7f\xd8\xb1\x5d\x16\x64\xca\x28\x35\xe9\x17\x1f"
           "\x00\x99\x8d\xee\x76\x9e\xe2\x5f\x79\xda\x0b\x0b\x38\x67\x3d\xa5"
           "\x49\x10\x9a\x8c\xb4\x58\x21\x23\x4f\x30\x65\x57\xf8\x16\x43\xa7"
           "\xa3\x61\xb2\x5d\x97\x02\x8f\x8b\xa9\x32\xd3\xd8\xe1\xc7\xfe\x00"
           "\xfd\xf7\xe6\x87\x8e\xd7\xa9\xea\x1d\x85\x85\x94\x77\x32\x80\xf5"
           "\x72\x63\x77\xbe",
           180);
    *(uint16_t*)0x20001b18 = 0xc;
    *(uint16_t*)0x20001b1a = 7;
    *(uint32_t*)0x20001b1c = 1;
    *(uint32_t*)0x20001b20 = 0;
    *(uint16_t*)0x20001b24 = 0xc;
    *(uint16_t*)0x20001b26 = 8;
    *(uint32_t*)0x20001b28 = 2;
    *(uint32_t*)0x20001b2c = 3;
    *(uint16_t*)0x20001b30 = 0xbc;
    STORE_BY_BITMASK(uint16_t, , 0x20001b32, 0xa, 0, 14);
    STORE_BY_BITMASK(uint16_t, , 0x20001b33, 0, 6, 1);
    STORE_BY_BITMASK(uint16_t, , 0x20001b33, 0, 7, 1);
    *(uint16_t*)0x20001b34 = 0xb;
    *(uint16_t*)0x20001b36 = 1;
    memcpy((void*)0x20001b38, "sample\000", 7);
    *(uint16_t*)0x20001b40 = 0x2c;
    STORE_BY_BITMASK(uint16_t, , 0x20001b42, 2, 0, 14);
    STORE_BY_BITMASK(uint16_t, , 0x20001b43, 0, 6, 1);
    STORE_BY_BITMASK(uint16_t, , 0x20001b43, 1, 7, 1);
    *(uint16_t*)0x20001b44 = 0x18;
    *(uint16_t*)0x20001b46 = 2;
    *(uint32_t*)0x20001b48 = 0x50d1;
    *(uint32_t*)0x20001b4c = 4;
    *(uint32_t*)0x20001b50 = 0x20000000;
    *(uint32_t*)0x20001b54 = 0;
    *(uint32_t*)0x20001b58 = 8;
    *(uint16_t*)0x20001b5c = 8;
    *(uint16_t*)0x20001b5e = 3;
    *(uint32_t*)0x20001b60 = 4;
    *(uint16_t*)0x20001b64 = 8;
    *(uint16_t*)0x20001b66 = 3;
    *(uint32_t*)0x20001b68 = 5;
    *(uint16_t*)0x20001b6c = 0x66;
    *(uint16_t*)0x20001b6e = 6;
    memcpy((void*)0x20001b70,
           "\x45\xf2\x4e\x12\x28\x6d\xcc\xd3\x60\x07\xbd\xb8\xe5\x56\x1f\xfd"
           "\x09\x1f\x01\x60\x71\x54\x43\xe9\xe0\xae\xf4\xe0\x5d\x69\x9a\xf0"
           "\x7e\x96\x77\x00\x03\xc3\x39\x20\xf4\xd6\xf4\x53\xd9\x1c\x37\x8b"
           "\xbc\xd3\x40\x5e\xf8\x85\xaf\x4d\x7c\x9b\x64\x5a\x3d\x0f\x57\xb1"
           "\x3d\x2e\x0c\xf4\x85\xe7\x5a\x8f\x9e\x7d\x8f\x01\xef\x9e\xcf\x0a"
           "\x68\x2d\x57\x47\x64\x40\x8e\x53\x21\x14\x67\xf3\xb0\x79\x60\x9f"
           "\xca\x83",
           98);
    *(uint16_t*)0x20001bd4 = 0xc;
    *(uint16_t*)0x20001bd6 = 7;
    *(uint32_t*)0x20001bd8 = 0;
    *(uint32_t*)0x20001bdc = 1;
    *(uint16_t*)0x20001be0 = 0xc;
    *(uint16_t*)0x20001be2 = 8;
    *(uint32_t*)0x20001be4 = 2;
    *(uint32_t*)0x20001be8 = 2;
    *(uint16_t*)0x20001bec = 0x174;
    STORE_BY_BITMASK(uint16_t, , 0x20001bee, 0x12, 0, 14);
    STORE_BY_BITMASK(uint16_t, , 0x20001bef, 0, 6, 1);
    STORE_BY_BITMASK(uint16_t, , 0x20001bef, 0, 7, 1);
    *(uint16_t*)0x20001bf0 = 0xa;
    *(uint16_t*)0x20001bf2 = 1;
    memcpy((void*)0x20001bf4, "pedit\000", 6);
    *(uint16_t*)0x20001bfc = 0x148;
    STORE_BY_BITMASK(uint16_t, , 0x20001bfe, 2, 0, 14);
    STORE_BY_BITMASK(uint16_t, , 0x20001bff, 0, 6, 1);
    STORE_BY_BITMASK(uint16_t, , 0x20001bff, 1, 7, 1);
    *(uint16_t*)0x20001c00 = 0x7c;
    STORE_BY_BITMASK(uint16_t, , 0x20001c02, 5, 0, 14);
    STORE_BY_BITMASK(uint16_t, , 0x20001c03, 0, 6, 1);
    STORE_BY_BITMASK(uint16_t, , 0x20001c03, 1, 7, 1);
    *(uint16_t*)0x20001c04 = 0xc;
    STORE_BY_BITMASK(uint16_t, , 0x20001c06, 6, 0, 14);
    STORE_BY_BITMASK(uint16_t, , 0x20001c07, 0, 6, 1);
    STORE_BY_BITMASK(uint16_t, , 0x20001c07, 1, 7, 1);
    *(uint16_t*)0x20001c08 = 6;
    *(uint16_t*)0x20001c0a = 1;
    *(uint16_t*)0x20001c0c = 5;
    *(uint16_t*)0x20001c10 = 0x3c;
    STORE_BY_BITMASK(uint16_t, , 0x20001c12, 6, 0, 14);
    STORE_BY_BITMASK(uint16_t, , 0x20001c13, 0, 6, 1);
    STORE_BY_BITMASK(uint16_t, , 0x20001c13, 1, 7, 1);
    *(uint16_t*)0x20001c14 = 6;
    *(uint16_t*)0x20001c16 = 2;
    *(uint16_t*)0x20001c18 = 1;
    *(uint16_t*)0x20001c1c = 6;
    *(uint16_t*)0x20001c1e = 2;
    *(uint16_t*)0x20001c20 = 1;
    *(uint16_t*)0x20001c24 = 6;
    *(uint16_t*)0x20001c26 = 1;
    *(uint16_t*)0x20001c28 = 4;
    *(uint16_t*)0x20001c2c = 6;
    *(uint16_t*)0x20001c2e = 2;
    *(uint16_t*)0x20001c30 = 0;
    *(uint16_t*)0x20001c34 = 6;
    *(uint16_t*)0x20001c36 = 1;
    *(uint16_t*)0x20001c38 = 2;
    *(uint16_t*)0x20001c3c = 6;
    *(uint16_t*)0x20001c3e = 1;
    *(uint16_t*)0x20001c40 = 3;
    *(uint16_t*)0x20001c44 = 6;
    *(uint16_t*)0x20001c46 = 2;
    *(uint16_t*)0x20001c48 = 1;
    *(uint16_t*)0x20001c4c = 0xc;
    STORE_BY_BITMASK(uint16_t, , 0x20001c4e, 6, 0, 14);
    STORE_BY_BITMASK(uint16_t, , 0x20001c4f, 0, 6, 1);
    STORE_BY_BITMASK(uint16_t, , 0x20001c4f, 1, 7, 1);
    *(uint16_t*)0x20001c50 = 6;
    *(uint16_t*)0x20001c52 = 2;
    *(uint16_t*)0x20001c54 = 1;
    *(uint16_t*)0x20001c58 = 0x24;
    STORE_BY_BITMASK(uint16_t, , 0x20001c5a, 6, 0, 14);
    STORE_BY_BITMASK(uint16_t, , 0x20001c5b, 0, 6, 1);
    STORE_BY_BITMASK(uint16_t, , 0x20001c5b, 1, 7, 1);
    *(uint16_t*)0x20001c5c = 6;
    *(uint16_t*)0x20001c5e = 1;
    *(uint16_t*)0x20001c60 = 1;
    *(uint16_t*)0x20001c64 = 6;
    *(uint16_t*)0x20001c66 = 2;
    *(uint16_t*)0x20001c68 = 0;
    *(uint16_t*)0x20001c6c = 6;
    *(uint16_t*)0x20001c6e = 2;
    *(uint16_t*)0x20001c70 = 0;
    *(uint16_t*)0x20001c74 = 6;
    *(uint16_t*)0x20001c76 = 2;
    *(uint16_t*)0x20001c78 = 0;
    *(uint16_t*)0x20001c7c = 0xa8;
    STORE_BY_BITMASK(uint16_t, , 0x20001c7e, 5, 0, 14);
    STORE_BY_BITMASK(uint16_t, , 0x20001c7f, 0, 6, 1);
    STORE_BY_BITMASK(uint16_t, , 0x20001c7f, 1, 7, 1);
    *(uint16_t*)0x20001c80 = 0x14;
    STORE_BY_BITMASK(uint16_t, , 0x20001c82, 6, 0, 14);
    STORE_BY_BITMASK(uint16_t, , 0x20001c83, 0, 6, 1);
    STORE_BY_BITMASK(uint16_t, , 0x20001c83, 1, 7, 1);
    *(uint16_t*)0x20001c84 = 6;
    *(uint16_t*)0x20001c86 = 1;
    *(uint16_t*)0x20001c88 = 4;
    *(uint16_t*)0x20001c8c = 6;
    *(uint16_t*)0x20001c8e = 1;
    *(uint16_t*)0x20001c90 = 3;
    *(uint16_t*)0x20001c94 = 0x3c;
    STORE_BY_BITMASK(uint16_t, , 0x20001c96, 6, 0, 14);
    STORE_BY_BITMASK(uint16_t, , 0x20001c97, 0, 6, 1);
    STORE_BY_BITMASK(uint16_t, , 0x20001c97, 1, 7, 1);
    *(uint16_t*)0x20001c98 = 6;
    *(uint16_t*)0x20001c9a = 1;
    *(uint16_t*)0x20001c9c = 2;
    *(uint16_t*)0x20001ca0 = 6;
    *(uint16_t*)0x20001ca2 = 1;
    *(uint16_t*)0x20001ca4 = 0;
    *(uint16_t*)0x20001ca8 = 6;
    *(uint16_t*)0x20001caa = 2;
    *(uint16_t*)0x20001cac = 1;
    *(uint16_t*)0x20001cb0 = 6;
    *(uint16_t*)0x20001cb2 = 2;
    *(uint16_t*)0x20001cb4 = 1;
    *(uint16_t*)0x20001cb8 = 6;
    *(uint16_t*)0x20001cba = 1;
    *(uint16_t*)0x20001cbc = 2;
    *(uint16_t*)0x20001cc0 = 6;
    *(uint16_t*)0x20001cc2 = 2;
    *(uint16_t*)0x20001cc4 = 0;
    *(uint16_t*)0x20001cc8 = 6;
    *(uint16_t*)0x20001cca = 2;
    *(uint16_t*)0x20001ccc = 0;
    *(uint16_t*)0x20001cd0 = 0x54;
    STORE_BY_BITMASK(uint16_t, , 0x20001cd2, 6, 0, 14);
    STORE_BY_BITMASK(uint16_t, , 0x20001cd3, 0, 6, 1);
    STORE_BY_BITMASK(uint16_t, , 0x20001cd3, 1, 7, 1);
    *(uint16_t*)0x20001cd4 = 6;
    *(uint16_t*)0x20001cd6 = 2;
    *(uint16_t*)0x20001cd8 = 1;
    *(uint16_t*)0x20001cdc = 6;
    *(uint16_t*)0x20001cde = 2;
    *(uint16_t*)0x20001ce0 = 0;
    *(uint16_t*)0x20001ce4 = 6;
    *(uint16_t*)0x20001ce6 = 2;
    *(uint16_t*)0x20001ce8 = 1;
    *(uint16_t*)0x20001cec = 6;
    *(uint16_t*)0x20001cee = 2;
    *(uint16_t*)0x20001cf0 = 1;
    *(uint16_t*)0x20001cf4 = 6;
    *(uint16_t*)0x20001cf6 = 2;
    *(uint16_t*)0x20001cf8 = 1;
    *(uint16_t*)0x20001cfc = 6;
    *(uint16_t*)0x20001cfe = 1;
    *(uint16_t*)0x20001d00 = 2;
    *(uint16_t*)0x20001d04 = 6;
    *(uint16_t*)0x20001d06 = 1;
    *(uint16_t*)0x20001d08 = 1;
    *(uint16_t*)0x20001d0c = 6;
    *(uint16_t*)0x20001d0e = 2;
    *(uint16_t*)0x20001d10 = 1;
    *(uint16_t*)0x20001d14 = 6;
    *(uint16_t*)0x20001d16 = 2;
    *(uint16_t*)0x20001d18 = 1;
    *(uint16_t*)0x20001d1c = 6;
    *(uint16_t*)0x20001d1e = 1;
    *(uint16_t*)0x20001d20 = 2;
    *(uint16_t*)0x20001d24 = 0x20;
    STORE_BY_BITMASK(uint16_t, , 0x20001d26, 5, 0, 14);
    STORE_BY_BITMASK(uint16_t, , 0x20001d27, 0, 6, 1);
    STORE_BY_BITMASK(uint16_t, , 0x20001d27, 1, 7, 1);
    *(uint16_t*)0x20001d28 = 0x1c;
    STORE_BY_BITMASK(uint16_t, , 0x20001d2a, 6, 0, 14);
    STORE_BY_BITMASK(uint16_t, , 0x20001d2b, 0, 6, 1);
    STORE_BY_BITMASK(uint16_t, , 0x20001d2b, 1, 7, 1);
    *(uint16_t*)0x20001d2c = 6;
    *(uint16_t*)0x20001d2e = 2;
    *(uint16_t*)0x20001d30 = 0;
    *(uint16_t*)0x20001d34 = 6;
    *(uint16_t*)0x20001d36 = 1;
    *(uint16_t*)0x20001d38 = 5;
    *(uint16_t*)0x20001d3c = 6;
    *(uint16_t*)0x20001d3e = 1;
    *(uint16_t*)0x20001d40 = 2;
    *(uint16_t*)0x20001d44 = 4;
    *(uint16_t*)0x20001d46 = 6;
    *(uint16_t*)0x20001d48 = 0xc;
    *(uint16_t*)0x20001d4a = 7;
    *(uint32_t*)0x20001d4c = 0;
    *(uint32_t*)0x20001d50 = 1;
    *(uint16_t*)0x20001d54 = 0xc;
    *(uint16_t*)0x20001d56 = 8;
    *(uint32_t*)0x20001d58 = 2;
    *(uint32_t*)0x20001d5c = 2;
    *(uint16_t*)0x20001d60 = 0x18a8;
    *(uint16_t*)0x20001d62 = 2;
    *(uint16_t*)0x20001d64 = 0x404;
    *(uint16_t*)0x20001d66 = 3;
    *(uint32_t*)0x20001d68 = 8;
    *(uint32_t*)0x20001d6c = 4;
    *(uint32_t*)0x20001d70 = 0xfff;
    *(uint32_t*)0x20001d74 = 0;
    *(uint32_t*)0x20001d78 = 6;
    *(uint32_t*)0x20001d7c = 0xfffffff8;
    *(uint32_t*)0x20001d80 = 0xc581;
    *(uint32_t*)0x20001d84 = 4;
    *(uint32_t*)0x20001d88 = 0x32cfd740;
    *(uint32_t*)0x20001d8c = 0x8000;
    *(uint32_t*)0x20001d90 = 0x1400000;
    *(uint32_t*)0x20001d94 = 0xfffff854;
    *(uint32_t*)0x20001d98 = 0xc13;
    *(uint32_t*)0x20001d9c = 9;
    *(uint32_t*)0x20001da0 = 0xfffffffa;
    *(uint32_t*)0x20001da4 = 4;
    *(uint32_t*)0x20001da8 = 0x1000;
    *(uint32_t*)0x20001dac = 0x1f4b;
    *(uint32_t*)0x20001db0 = 3;
    *(uint32_t*)0x20001db4 = 8;
    *(uint32_t*)0x20001db8 = 2;
    *(uint32_t*)0x20001dbc = 4;
    *(uint32_t*)0x20001dc0 = 0xff;
    *(uint32_t*)0x20001dc4 = 2;
    *(uint32_t*)0x20001dc8 = 0x101;
    *(uint32_t*)0x20001dcc = 2;
    *(uint32_t*)0x20001dd0 = 0x2d1;
    *(uint32_t*)0x20001dd4 = 5;
    *(uint32_t*)0x20001dd8 = 8;
    *(uint32_t*)0x20001ddc = 0;
    *(uint32_t*)0x20001de0 = 7;
    *(uint32_t*)0x20001de4 = 0x24a0;
    *(uint32_t*)0x20001de8 = 0xfff;
    *(uint32_t*)0x20001dec = 2;
    *(uint32_t*)0x20001df0 = 5;
    *(uint32_t*)0x20001df4 = 0xfffffffc;
    *(uint32_t*)0x20001df8 = 2;
    *(uint32_t*)0x20001dfc = 7;
    *(uint32_t*)0x20001e00 = 5;
    *(uint32_t*)0x20001e04 = 6;
    *(uint32_t*)0x20001e08 = 0x80000000;
    *(uint32_t*)0x20001e0c = 0xc0000000;
    *(uint32_t*)0x20001e10 = 0;
    *(uint32_t*)0x20001e14 = 8;
    *(uint32_t*)0x20001e18 = 0;
    *(uint32_t*)0x20001e1c = 3;
    *(uint32_t*)0x20001e20 = 5;
    *(uint32_t*)0x20001e24 = 5;
    *(uint32_t*)0x20001e28 = 0;
    *(uint32_t*)0x20001e2c = 3;
    *(uint32_t*)0x20001e30 = 0xdd6f;
    *(uint32_t*)0x20001e34 = 7;
    *(uint32_t*)0x20001e38 = 3;
    *(uint32_t*)0x20001e3c = 0x8000000;
    *(uint32_t*)0x20001e40 = 7;
    *(uint32_t*)0x20001e44 = 4;
    *(uint32_t*)0x20001e48 = 0x10001;
    *(uint32_t*)0x20001e4c = 5;
    *(uint32_t*)0x20001e50 = 0x7ff;
    *(uint32_t*)0x20001e54 = -1;
    *(uint32_t*)0x20001e58 = 0x7ff;
    *(uint32_t*)0x20001e5c = 0xfffffffd;
    *(uint32_t*)0x20001e60 = 0x40;
    *(uint32_t*)0x20001e64 = 7;
    *(uint32_t*)0x20001e68 = 0;
    *(uint32_t*)0x20001e6c = 6;
    *(uint32_t*)0x20001e70 = 0;
    *(uint32_t*)0x20001e74 = 0x7ff;
    *(uint32_t*)0x20001e78 = 0x1ff;
    *(uint32_t*)0x20001e7c = 0;
    *(uint32_t*)0x20001e80 = 0xee4;
    *(uint32_t*)0x20001e84 = 0x1f;
    *(uint32_t*)0x20001e88 = 4;
    *(uint32_t*)0x20001e8c = 2;
    *(uint32_t*)0x20001e90 = 4;
    *(uint32_t*)0x20001e94 = 0;
    *(uint32_t*)0x20001e98 = 0xfffffff7;
    *(uint32_t*)0x20001e9c = 0xec5;
    *(uint32_t*)0x20001ea0 = 7;
    *(uint32_t*)0x20001ea4 = 0x6f;
    *(uint32_t*)0x20001ea8 = 0x101;
    *(uint32_t*)0x20001eac = 0xffff;
    *(uint32_t*)0x20001eb0 = 0;
    *(uint32_t*)0x20001eb4 = 0x7fffffff;
    *(uint32_t*)0x20001eb8 = 0xe5;
    *(uint32_t*)0x20001ebc = 0x80000001;
    *(uint32_t*)0x20001ec0 = 0x100;
    *(uint32_t*)0x20001ec4 = 5;
    *(uint32_t*)0x20001ec8 = 4;
    *(uint32_t*)0x20001ecc = 7;
    *(uint32_t*)0x20001ed0 = 0xd6ac;
    *(uint32_t*)0x20001ed4 = 8;
    *(uint32_t*)0x20001ed8 = 0x40;
    *(uint32_t*)0x20001edc = 8;
    *(uint32_t*)0x20001ee0 = 0xffffff92;
    *(uint32_t*)0x20001ee4 = 0x8000;
    *(uint32_t*)0x20001ee8 = 0x224000;
    *(uint32_t*)0x20001eec = 1;
    *(uint32_t*)0x20001ef0 = 0x8656;
    *(uint32_t*)0x20001ef4 = 0x7fffffff;
    *(uint32_t*)0x20001ef8 = 1;
    *(uint32_t*)0x20001efc = 0x80000001;
    *(uint32_t*)0x20001f00 = 0x65f;
    *(uint32_t*)0x20001f04 = 8;
    *(uint32_t*)0x20001f08 = 0x400;
    *(uint32_t*)0x20001f0c = 3;
    *(uint32_t*)0x20001f10 = 0x8001;
    *(uint32_t*)0x20001f14 = 3;
    *(uint32_t*)0x20001f18 = 0;
    *(uint32_t*)0x20001f1c = 0x7ff;
    *(uint32_t*)0x20001f20 = 0;
    *(uint32_t*)0x20001f24 = 4;
    *(uint32_t*)0x20001f28 = 7;
    *(uint32_t*)0x20001f2c = 0xcf7;
    *(uint32_t*)0x20001f30 = 6;
    *(uint32_t*)0x20001f34 = 3;
    *(uint32_t*)0x20001f38 = 0x7fff;
    *(uint32_t*)0x20001f3c = 0x1ff;
    *(uint32_t*)0x20001f40 = 1;
    *(uint32_t*)0x20001f44 = 6;
    *(uint32_t*)0x20001f48 = 1;
    *(uint32_t*)0x20001f4c = 0xe2ba;
    *(uint32_t*)0x20001f50 = 3;
    *(uint32_t*)0x20001f54 = 0xfffffffd;
    *(uint32_t*)0x20001f58 = 0xfff;
    *(uint32_t*)0x20001f5c = 0;
    *(uint32_t*)0x20001f60 = 0x2c;
    *(uint32_t*)0x20001f64 = 0x88;
    *(uint32_t*)0x20001f68 = 7;
    *(uint32_t*)0x20001f6c = 4;
    *(uint32_t*)0x20001f70 = 9;
    *(uint32_t*)0x20001f74 = 0;
    *(uint32_t*)0x20001f78 = 0x4c1c4a2d;
    *(uint32_t*)0x20001f7c = 0x3f;
    *(uint32_t*)0x20001f80 = 1;
    *(uint32_t*)0x20001f84 = 0x100;
    *(uint32_t*)0x20001f88 = 8;
    *(uint32_t*)0x20001f8c = 0x26;
    *(uint32_t*)0x20001f90 = 0;
    *(uint32_t*)0x20001f94 = 4;
    *(uint32_t*)0x20001f98 = 0x1020000;
    *(uint32_t*)0x20001f9c = 2;
    *(uint32_t*)0x20001fa0 = 7;
    *(uint32_t*)0x20001fa4 = 0x9a;
    *(uint32_t*)0x20001fa8 = 0x10000;
    *(uint32_t*)0x20001fac = 0xd1679da4;
    *(uint32_t*)0x20001fb0 = 0x7fffffff;
    *(uint32_t*)0x20001fb4 = 9;
    *(uint32_t*)0x20001fb8 = 8;
    *(uint32_t*)0x20001fbc = 0xc5;
    *(uint32_t*)0x20001fc0 = 8;
    *(uint32_t*)0x20001fc4 = 0x5f;
    *(uint32_t*)0x20001fc8 = 9;
    *(uint32_t*)0x20001fcc = 0x79f9;
    *(uint32_t*)0x20001fd0 = 9;
    *(uint32_t*)0x20001fd4 = 0x401;
    *(uint32_t*)0x20001fd8 = 0xa534ed;
    *(uint32_t*)0x20001fdc = 0x20;
    *(uint32_t*)0x20001fe0 = 8;
    *(uint32_t*)0x20001fe4 = 6;
    *(uint32_t*)0x20001fe8 = 0x8001;
    *(uint32_t*)0x20001fec = 8;
    *(uint32_t*)0x20001ff0 = 6;
    *(uint32_t*)0x20001ff4 = 0;
    *(uint32_t*)0x20001ff8 = 9;
    *(uint32_t*)0x20001ffc = 5;
    *(uint32_t*)0x20002000 = 7;
    *(uint32_t*)0x20002004 = 9;
    *(uint32_t*)0x20002008 = 3;
    *(uint32_t*)0x2000200c = 0xf20;
    *(uint32_t*)0x20002010 = 0x200;
    *(uint32_t*)0x20002014 = 9;
    *(uint32_t*)0x20002018 = 0;
    *(uint32_t*)0x2000201c = 4;
    *(uint32_t*)0x20002020 = 0xfffff800;
    *(uint32_t*)0x20002024 = 0x33;
    *(uint32_t*)0x20002028 = 4;
    *(uint32_t*)0x2000202c = 0xfffffffc;
    *(uint32_t*)0x20002030 = 2;
    *(uint32_t*)0x20002034 = 0x101;
    *(uint32_t*)0x20002038 = 7;
    *(uint32_t*)0x2000203c = 0;
    *(uint32_t*)0x20002040 = 8;
    *(uint32_t*)0x20002044 = 9;
    *(uint32_t*)0x20002048 = 0xffffffc1;
    *(uint32_t*)0x2000204c = 0xe8;
    *(uint32_t*)0x20002050 = 0x7f;
    *(uint32_t*)0x20002054 = 7;
    *(uint32_t*)0x20002058 = 2;
    *(uint32_t*)0x2000205c = 3;
    *(uint32_t*)0x20002060 = 0x953;
    *(uint32_t*)0x20002064 = 0x7f;
    *(uint32_t*)0x20002068 = 0xd2;
    *(uint32_t*)0x2000206c = 0x800;
    *(uint32_t*)0x20002070 = 0x40;
    *(uint32_t*)0x20002074 = 5;
    *(uint32_t*)0x20002078 = 0x80000000;
    *(uint32_t*)0x2000207c = 0;
    *(uint32_t*)0x20002080 = 0x200;
    *(uint32_t*)0x20002084 = 2;
    *(uint32_t*)0x20002088 = 0xa7;
    *(uint32_t*)0x2000208c = 0x80;
    *(uint32_t*)0x20002090 = 6;
    *(uint32_t*)0x20002094 = 0xcb;
    *(uint32_t*)0x20002098 = 0x38ec037d;
    *(uint32_t*)0x2000209c = 0x100;
    *(uint32_t*)0x200020a0 = 0;
    *(uint32_t*)0x200020a4 = 3;
    *(uint32_t*)0x200020a8 = 9;
    *(uint32_t*)0x200020ac = 2;
    *(uint32_t*)0x200020b0 = 2;
    *(uint32_t*)0x200020b4 = 3;
    *(uint32_t*)0x200020b8 = 0x12;
    *(uint32_t*)0x200020bc = 0x10001;
    *(uint32_t*)0x200020c0 = 0xfffffff0;
    *(uint32_t*)0x200020c4 = 7;
    *(uint32_t*)0x200020c8 = 2;
    *(uint32_t*)0x200020cc = 6;
    *(uint32_t*)0x200020d0 = 0xa23;
    *(uint32_t*)0x200020d4 = 8;
    *(uint32_t*)0x200020d8 = 0xffff;
    *(uint32_t*)0x200020dc = 0x9425;
    *(uint32_t*)0x200020e0 = 8;
    *(uint32_t*)0x200020e4 = 0xffffffe0;
    *(uint32_t*)0x200020e8 = 0x101;
    *(uint32_t*)0x200020ec = 0xad;
    *(uint32_t*)0x200020f0 = 0x7f;
    *(uint32_t*)0x200020f4 = -1;
    *(uint32_t*)0x200020f8 = 0x1f;
    *(uint32_t*)0x200020fc = 3;
    *(uint32_t*)0x20002100 = 0xff;
    *(uint32_t*)0x20002104 = 2;
    *(uint32_t*)0x20002108 = 7;
    *(uint32_t*)0x2000210c = 0xfffffffc;
    *(uint32_t*)0x20002110 = 3;
    *(uint32_t*)0x20002114 = 7;
    *(uint32_t*)0x20002118 = 0x80000001;
    *(uint32_t*)0x2000211c = 9;
    *(uint32_t*)0x20002120 = 7;
    *(uint32_t*)0x20002124 = 0x346;
    *(uint32_t*)0x20002128 = 7;
    *(uint32_t*)0x2000212c = 0;
    *(uint32_t*)0x20002130 = 6;
    *(uint32_t*)0x20002134 = 0x4cd4;
    *(uint32_t*)0x20002138 = 0x612;
    *(uint32_t*)0x2000213c = 0xfffffffd;
    *(uint32_t*)0x20002140 = 0x800;
    *(uint32_t*)0x20002144 = 0x7fff;
    *(uint32_t*)0x20002148 = 0x401;
    *(uint32_t*)0x2000214c = 0xdd;
    *(uint32_t*)0x20002150 = 1;
    *(uint32_t*)0x20002154 = 0x7f;
    *(uint32_t*)0x20002158 = 0;
    *(uint32_t*)0x2000215c = 8;
    *(uint32_t*)0x20002160 = 1;
    *(uint32_t*)0x20002164 = 8;
    *(uint16_t*)0x20002168 = 0xc;
    *(uint16_t*)0x2000216a = 8;
    *(uint64_t*)0x2000216c = 1;
    *(uint16_t*)0x20002174 = 8;
    *(uint16_t*)0x20002176 = 4;
    *(uint32_t*)0x20002178 = 4;
    *(uint16_t*)0x2000217c = 0x404;
    *(uint16_t*)0x2000217e = 2;
    *(uint32_t*)0x20002180 = 7;
    *(uint32_t*)0x20002184 = 1;
    *(uint32_t*)0x20002188 = 0x1000;
    *(uint32_t*)0x2000218c = 0xfc73;
    *(uint32_t*)0x20002190 = 3;
    *(uint32_t*)0x20002194 = 6;
    *(uint32_t*)0x20002198 = 6;
    *(uint32_t*)0x2000219c = 0x16;
    *(uint32_t*)0x200021a0 = 0x10000;
    *(uint32_t*)0x200021a4 = 5;
    *(uint32_t*)0x200021a8 = 1;
    *(uint32_t*)0x200021ac = 0x3f;
    *(uint32_t*)0x200021b0 = 8;
    *(uint32_t*)0x200021b4 = 0x5917;
    *(uint32_t*)0x200021b8 = 4;
    *(uint32_t*)0x200021bc = 7;
    *(uint32_t*)0x200021c0 = 0x400;
    *(uint32_t*)0x200021c4 = 3;
    *(uint32_t*)0x200021c8 = 6;
    *(uint32_t*)0x200021cc = 8;
    *(uint32_t*)0x200021d0 = 5;
    *(uint32_t*)0x200021d4 = 3;
    *(uint32_t*)0x200021d8 = 0xf3c;
    *(uint32_t*)0x200021dc = 0x3285;
    *(uint32_t*)0x200021e0 = 0x1ff;
    *(uint32_t*)0x200021e4 = 0x401;
    *(uint32_t*)0x200021e8 = 0x401;
    *(uint32_t*)0x200021ec = 9;
    *(uint32_t*)0x200021f0 = 8;
    *(uint32_t*)0x200021f4 = 7;
    *(uint32_t*)0x200021f8 = 1;
    *(uint32_t*)0x200021fc = 0x800;
    *(uint32_t*)0x20002200 = 0xfffffffb;
    *(uint32_t*)0x20002204 = 6;
    *(uint32_t*)0x20002208 = 0x80000000;
    *(uint32_t*)0x2000220c = 6;
    *(uint32_t*)0x20002210 = 6;
    *(uint32_t*)0x20002214 = 0;
    *(uint32_t*)0x20002218 = 0xa0000000;
    *(uint32_t*)0x2000221c = 0x80;
    *(uint32_t*)0x20002220 = 0x283e;
    *(uint32_t*)0x20002224 = 0x3ff;
    *(uint32_t*)0x20002228 = 0xc9ab;
    *(uint32_t*)0x2000222c = 0x40;
    *(uint32_t*)0x20002230 = 0x20;
    *(uint32_t*)0x20002234 = 4;
    *(uint32_t*)0x20002238 = 0x7a22;
    *(uint32_t*)0x2000223c = 1;
    *(uint32_t*)0x20002240 = 2;
    *(uint32_t*)0x20002244 = 6;
    *(uint32_t*)0x20002248 = 0x35;
    *(uint32_t*)0x2000224c = 0;
    *(uint32_t*)0x20002250 = 3;
    *(uint32_t*)0x20002254 = 0xfffffffb;
    *(uint32_t*)0x20002258 = 2;
    *(uint32_t*)0x2000225c = 8;
    *(uint32_t*)0x20002260 = 0xffffff80;
    *(uint32_t*)0x20002264 = 0x5680;
    *(uint32_t*)0x20002268 = 0xf7b5;
    *(uint32_t*)0x2000226c = 6;
    *(uint32_t*)0x20002270 = 2;
    *(uint32_t*)0x20002274 = 0x7b;
    *(uint32_t*)0x20002278 = 0x10001;
    *(uint32_t*)0x2000227c = 0x100;
    *(uint32_t*)0x20002280 = 0x5fbc;
    *(uint32_t*)0x20002284 = 0x85a;
    *(uint32_t*)0x20002288 = 6;
    *(uint32_t*)0x2000228c = 7;
    *(uint32_t*)0x20002290 = 8;
    *(uint32_t*)0x20002294 = 1;
    *(uint32_t*)0x20002298 = 1;
    *(uint32_t*)0x2000229c = 9;
    *(uint32_t*)0x200022a0 = 2;
    *(uint32_t*)0x200022a4 = 6;
    *(uint32_t*)0x200022a8 = 0xfffffec1;
    *(uint32_t*)0x200022ac = 6;
    *(uint32_t*)0x200022b0 = 9;
    *(uint32_t*)0x200022b4 = 1;
    *(uint32_t*)0x200022b8 = 2;
    *(uint32_t*)0x200022bc = 0x5000000;
    *(uint32_t*)0x200022c0 = 0x200;
    *(uint32_t*)0x200022c4 = 9;
    *(uint32_t*)0x200022c8 = 4;
    *(uint32_t*)0x200022cc = 0x100;
    *(uint32_t*)0x200022d0 = 7;
    *(uint32_t*)0x200022d4 = 0xa5;
    *(uint32_t*)0x200022d8 = 0x400;
    *(uint32_t*)0x200022dc = 0xffff;
    *(uint32_t*)0x200022e0 = 0;
    *(uint32_t*)0x200022e4 = 5;
    *(uint32_t*)0x200022e8 = 2;
    *(uint32_t*)0x200022ec = 0x4c2;
    *(uint32_t*)0x200022f0 = 5;
    *(uint32_t*)0x200022f4 = 7;
    *(uint32_t*)0x200022f8 = 7;
    *(uint32_t*)0x200022fc = 0x1ff;
    *(uint32_t*)0x20002300 = 0x1000;
    *(uint32_t*)0x20002304 = 0x10000;
    *(uint32_t*)0x20002308 = 0x58a;
    *(uint32_t*)0x2000230c = 6;
    *(uint32_t*)0x20002310 = 1;
    *(uint32_t*)0x20002314 = 1;
    *(uint32_t*)0x20002318 = 0xffff8000;
    *(uint32_t*)0x2000231c = 0xffff;
    *(uint32_t*)0x20002320 = 2;
    *(uint32_t*)0x20002324 = 0x9f01;
    *(uint32_t*)0x20002328 = 0x91;
    *(uint32_t*)0x2000232c = 4;
    *(uint32_t*)0x20002330 = 5;
    *(uint32_t*)0x20002334 = 0x200;
    *(uint32_t*)0x20002338 = 9;
    *(uint32_t*)0x2000233c = 0x10000000;
    *(uint32_t*)0x20002340 = 3;
    *(uint32_t*)0x20002344 = 7;
    *(uint32_t*)0x20002348 = 0x80;
    *(uint32_t*)0x2000234c = 6;
    *(uint32_t*)0x20002350 = 2;
    *(uint32_t*)0x20002354 = 1;
    *(uint32_t*)0x20002358 = 0x7fffffff;
    *(uint32_t*)0x2000235c = 7;
    *(uint32_t*)0x20002360 = 0;
    *(uint32_t*)0x20002364 = 0x9b5e;
    *(uint32_t*)0x20002368 = 0xfffffffd;
    *(uint32_t*)0x2000236c = 0xcc;
    *(uint32_t*)0x20002370 = 3;
    *(uint32_t*)0x20002374 = 0xa7;
    *(uint32_t*)0x20002378 = 0x4cda138f;
    *(uint32_t*)0x2000237c = 0x30000000;
    *(uint32_t*)0x20002380 = 0;
    *(uint32_t*)0x20002384 = 0xfcb9;
    *(uint32_t*)0x20002388 = 0x20;
    *(uint32_t*)0x2000238c = 0;
    *(uint32_t*)0x20002390 = 8;
    *(uint32_t*)0x20002394 = 9;
    *(uint32_t*)0x20002398 = 0x100;
    *(uint32_t*)0x2000239c = 5;
    *(uint32_t*)0x200023a0 = 0x840e;
    *(uint32_t*)0x200023a4 = 6;
    *(uint32_t*)0x200023a8 = 1;
    *(uint32_t*)0x200023ac = 0x7ff;
    *(uint32_t*)0x200023b0 = 1;
    *(uint32_t*)0x200023b4 = 0;
    *(uint32_t*)0x200023b8 = -1;
    *(uint32_t*)0x200023bc = 8;
    *(uint32_t*)0x200023c0 = 6;
    *(uint32_t*)0x200023c4 = 0x53f;
    *(uint32_t*)0x200023c8 = 0xea8;
    *(uint32_t*)0x200023cc = 7;
    *(uint32_t*)0x200023d0 = 0xc5d;
    *(uint32_t*)0x200023d4 = 9;
    *(uint32_t*)0x200023d8 = 2;
    *(uint32_t*)0x200023dc = 0x9ab;
    *(uint32_t*)0x200023e0 = 0xe49;
    *(uint32_t*)0x200023e4 = 4;
    *(uint32_t*)0x200023e8 = 2;
    *(uint32_t*)0x200023ec = 0xfffff1c4;
    *(uint32_t*)0x200023f0 = 0xffff6466;
    *(uint32_t*)0x200023f4 = 2;
    *(uint32_t*)0x200023f8 = 0x1000;
    *(uint32_t*)0x200023fc = 0xbf;
    *(uint32_t*)0x20002400 = 0x80000001;
    *(uint32_t*)0x20002404 = 0;
    *(uint32_t*)0x20002408 = 5;
    *(uint32_t*)0x2000240c = 0x7f0c;
    *(uint32_t*)0x20002410 = 0;
    *(uint32_t*)0x20002414 = 7;
    *(uint32_t*)0x20002418 = 0x10000;
    *(uint32_t*)0x2000241c = 0x621b;
    *(uint32_t*)0x20002420 = 3;
    *(uint32_t*)0x20002424 = 0x7fff;
    *(uint32_t*)0x20002428 = 4;
    *(uint32_t*)0x2000242c = 0x1a6da;
    *(uint32_t*)0x20002430 = 5;
    *(uint32_t*)0x20002434 = 7;
    *(uint32_t*)0x20002438 = 0x3f;
    *(uint32_t*)0x2000243c = 3;
    *(uint32_t*)0x20002440 = 0x40;
    *(uint32_t*)0x20002444 = 0x1f;
    *(uint32_t*)0x20002448 = 3;
    *(uint32_t*)0x2000244c = 0xb1;
    *(uint32_t*)0x20002450 = 7;
    *(uint32_t*)0x20002454 = 8;
    *(uint32_t*)0x20002458 = 6;
    *(uint32_t*)0x2000245c = 5;
    *(uint32_t*)0x20002460 = 0x9f;
    *(uint32_t*)0x20002464 = 0xcf25;
    *(uint32_t*)0x20002468 = 0x10001;
    *(uint32_t*)0x2000246c = 0x2c6a0000;
    *(uint32_t*)0x20002470 = 9;
    *(uint32_t*)0x20002474 = 0x743;
    *(uint32_t*)0x20002478 = 0x8000;
    *(uint32_t*)0x2000247c = 0xff15;
    *(uint32_t*)0x20002480 = 4;
    *(uint32_t*)0x20002484 = 1;
    *(uint32_t*)0x20002488 = 0xff;
    *(uint32_t*)0x2000248c = 2;
    *(uint32_t*)0x20002490 = 0x6c;
    *(uint32_t*)0x20002494 = 1;
    *(uint32_t*)0x20002498 = 0xfffffff9;
    *(uint32_t*)0x2000249c = 0xe79;
    *(uint32_t*)0x200024a0 = 0xffff3e4b;
    *(uint32_t*)0x200024a4 = 2;
    *(uint32_t*)0x200024a8 = 4;
    *(uint32_t*)0x200024ac = 2;
    *(uint32_t*)0x200024b0 = 0x5375c2ab;
    *(uint32_t*)0x200024b4 = 4;
    *(uint32_t*)0x200024b8 = 0xc1;
    *(uint32_t*)0x200024bc = 0xc61d;
    *(uint32_t*)0x200024c0 = 0x1f;
    *(uint32_t*)0x200024c4 = 1;
    *(uint32_t*)0x200024c8 = 0x800000;
    *(uint32_t*)0x200024cc = 0x6d2c;
    *(uint32_t*)0x200024d0 = 0x800;
    *(uint32_t*)0x200024d4 = 6;
    *(uint32_t*)0x200024d8 = 0x100;
    *(uint32_t*)0x200024dc = 0x400;
    *(uint32_t*)0x200024e0 = 0;
    *(uint32_t*)0x200024e4 = 7;
    *(uint32_t*)0x200024e8 = 4;
    *(uint32_t*)0x200024ec = -1;
    *(uint32_t*)0x200024f0 = 9;
    *(uint32_t*)0x200024f4 = 5;
    *(uint32_t*)0x200024f8 = 9;
    *(uint32_t*)0x200024fc = 1;
    *(uint32_t*)0x20002500 = 2;
    *(uint32_t*)0x20002504 = 3;
    *(uint32_t*)0x20002508 = 4;
    *(uint32_t*)0x2000250c = 0xfffffc00;
    *(uint32_t*)0x20002510 = 0x200;
    *(uint32_t*)0x20002514 = 4;
    *(uint32_t*)0x20002518 = 0x20;
    *(uint32_t*)0x2000251c = 8;
    *(uint32_t*)0x20002520 = 9;
    *(uint32_t*)0x20002524 = 0x20;
    *(uint32_t*)0x20002528 = 0x849;
    *(uint32_t*)0x2000252c = 8;
    *(uint32_t*)0x20002530 = 0xebfed57;
    *(uint32_t*)0x20002534 = 2;
    *(uint32_t*)0x20002538 = 6;
    *(uint32_t*)0x2000253c = 0x7ff;
    *(uint32_t*)0x20002540 = 0xff;
    *(uint32_t*)0x20002544 = 8;
    *(uint32_t*)0x20002548 = 0x1ed6;
    *(uint32_t*)0x2000254c = 0;
    *(uint32_t*)0x20002550 = 0x26781ace;
    *(uint32_t*)0x20002554 = 0x20;
    *(uint32_t*)0x20002558 = 3;
    *(uint32_t*)0x2000255c = 2;
    *(uint32_t*)0x20002560 = 0xfffffff7;
    *(uint32_t*)0x20002564 = 0x40;
    *(uint32_t*)0x20002568 = 6;
    *(uint32_t*)0x2000256c = 1;
    *(uint32_t*)0x20002570 = 1;
    *(uint32_t*)0x20002574 = 0;
    *(uint32_t*)0x20002578 = 0x200;
    *(uint32_t*)0x2000257c = 0;
    *(uint16_t*)0x20002580 = 0x404;
    *(uint16_t*)0x20002582 = 3;
    *(uint32_t*)0x20002584 = 0x8000;
    *(uint32_t*)0x20002588 = 0x7ff;
    *(uint32_t*)0x2000258c = 0x89;
    *(uint32_t*)0x20002590 = 0xdbc;
    *(uint32_t*)0x20002594 = 6;
    *(uint32_t*)0x20002598 = 2;
    *(uint32_t*)0x2000259c = 1;
    *(uint32_t*)0x200025a0 = 0x80;
    *(uint32_t*)0x200025a4 = 4;
    *(uint32_t*)0x200025a8 = 0;
    *(uint32_t*)0x200025ac = 1;
    *(uint32_t*)0x200025b0 = 0;
    *(uint32_t*)0x200025b4 = 0;
    *(uint32_t*)0x200025b8 = 0xfffffff7;
    *(uint32_t*)0x200025bc = 4;
    *(uint32_t*)0x200025c0 = 7;
    *(uint32_t*)0x200025c4 = 5;
    *(uint32_t*)0x200025c8 = 0xa975;
    *(uint32_t*)0x200025cc = 0xfff80000;
    *(uint32_t*)0x200025d0 = 1;
    *(uint32_t*)0x200025d4 = 0xffffff00;
    *(uint32_t*)0x200025d8 = 0xab;
    *(uint32_t*)0x200025dc = 0x3f;
    *(uint32_t*)0x200025e0 = 0x20;
    *(uint32_t*)0x200025e4 = 1;
    *(uint32_t*)0x200025e8 = 2;
    *(uint32_t*)0x200025ec = 2;
    *(uint32_t*)0x200025f0 = 0x8e2;
    *(uint32_t*)0x200025f4 = 5;
    *(uint32_t*)0x200025f8 = 8;
    *(uint32_t*)0x200025fc = 0xfffffff7;
    *(uint32_t*)0x20002600 = 0xfffffc00;
    *(uint32_t*)0x20002604 = 0xb5;
    *(uint32_t*)0x20002608 = 4;
    *(uint32_t*)0x2000260c = 5;
    *(uint32_t*)0x20002610 = 0x229b;
    *(uint32_t*)0x20002614 = 7;
    *(uint32_t*)0x20002618 = 4;
    *(uint32_t*)0x2000261c = 6;
    *(uint32_t*)0x20002620 = 0x80000000;
    *(uint32_t*)0x20002624 = 5;
    *(uint32_t*)0x20002628 = 0xad9;
    *(uint32_t*)0x2000262c = 0x1f;
    *(uint32_t*)0x20002630 = 2;
    *(uint32_t*)0x20002634 = 0xffffff81;
    *(uint32_t*)0x20002638 = 4;
    *(uint32_t*)0x2000263c = 1;
    *(uint32_t*)0x20002640 = -1;
    *(uint32_t*)0x20002644 = 9;
    *(uint32_t*)0x20002648 = 0x5bca9e6a;
    *(uint32_t*)0x2000264c = 0;
    *(uint32_t*)0x20002650 = 7;
    *(uint32_t*)0x20002654 = 4;
    *(uint32_t*)0x20002658 = 5;
    *(uint32_t*)0x2000265c = 5;
    *(uint32_t*)0x20002660 = 0xa84;
    *(uint32_t*)0x20002664 = 0xb366;
    *(uint32_t*)0x20002668 = 6;
    *(uint32_t*)0x2000266c = 9;
    *(uint32_t*)0x20002670 = 6;
    *(uint32_t*)0x20002674 = 8;
    *(uint32_t*)0x20002678 = 6;
    *(uint32_t*)0x2000267c = 0x833;
    *(uint32_t*)0x20002680 = 0x5b839c3c;
    *(uint32_t*)0x20002684 = 0xfff;
    *(uint32_t*)0x20002688 = 0x7fffffff;
    *(uint32_t*)0x2000268c = 0xffffe920;
    *(uint32_t*)0x20002690 = 5;
    *(uint32_t*)0x20002694 = 0x400;
    *(uint32_t*)0x20002698 = 0;
    *(uint32_t*)0x2000269c = 0x8001;
    *(uint32_t*)0x200026a0 = 7;
    *(uint32_t*)0x200026a4 = 9;
    *(uint32_t*)0x200026a8 = 8;
    *(uint32_t*)0x200026ac = 8;
    *(uint32_t*)0x200026b0 = 2;
    *(uint32_t*)0x200026b4 = 0xa2;
    *(uint32_t*)0x200026b8 = 4;
    *(uint32_t*)0x200026bc = 0;
    *(uint32_t*)0x200026c0 = 0x7ff;
    *(uint32_t*)0x200026c4 = 3;
    *(uint32_t*)0x200026c8 = 0x8000;
    *(uint32_t*)0x200026cc = 6;
    *(uint32_t*)0x200026d0 = -1;
    *(uint32_t*)0x200026d4 = 1;
    *(uint32_t*)0x200026d8 = 4;
    *(uint32_t*)0x200026dc = 0x75c9;
    *(uint32_t*)0x200026e0 = 1;
    *(uint32_t*)0x200026e4 = 0x40;
    *(uint32_t*)0x200026e8 = 0;
    *(uint32_t*)0x200026ec = 8;
    *(uint32_t*)0x200026f0 = 0;
    *(uint32_t*)0x200026f4 = 0xfffffffc;
    *(uint32_t*)0x200026f8 = 0;
    *(uint32_t*)0x200026fc = 0x8001;
    *(uint32_t*)0x20002700 = 1;
    *(uint32_t*)0x20002704 = 1;
    *(uint32_t*)0x20002708 = 0xfffff001;
    *(uint32_t*)0x2000270c = 0x1f;
    *(uint32_t*)0x20002710 = 2;
    *(uint32_t*)0x20002714 = 0x967;
    *(uint32_t*)0x20002718 = 5;
    *(uint32_t*)0x2000271c = 8;
    *(uint32_t*)0x20002720 = 0xc609;
    *(uint32_t*)0x20002724 = 0x55f27e0e;
    *(uint32_t*)0x20002728 = 1;
    *(uint32_t*)0x2000272c = 0xc849;
    *(uint32_t*)0x20002730 = 4;
    *(uint32_t*)0x20002734 = 6;
    *(uint32_t*)0x20002738 = 8;
    *(uint32_t*)0x2000273c = 0x1f;
    *(uint32_t*)0x20002740 = 9;
    *(uint32_t*)0x20002744 = 5;
    *(uint32_t*)0x20002748 = 0;
    *(uint32_t*)0x2000274c = 7;
    *(uint32_t*)0x20002750 = 8;
    *(uint32_t*)0x20002754 = 0x100;
    *(uint32_t*)0x20002758 = 5;
    *(uint32_t*)0x2000275c = 4;
    *(uint32_t*)0x20002760 = 0x7fff;
    *(uint32_t*)0x20002764 = 4;
    *(uint32_t*)0x20002768 = 0x80;
    *(uint32_t*)0x2000276c = 1;
    *(uint32_t*)0x20002770 = 3;
    *(uint32_t*)0x20002774 = 0x8f9;
    *(uint32_t*)0x20002778 = 5;
    *(uint32_t*)0x2000277c = 0x7fffffff;
    *(uint32_t*)0x20002780 = 2;
    *(uint32_t*)0x20002784 = 8;
    *(uint32_t*)0x20002788 = 6;
    *(uint32_t*)0x2000278c = 0x81;
    *(uint32_t*)0x20002790 = 1;
    *(uint32_t*)0x20002794 = 6;
    *(uint32_t*)0x20002798 = 5;
    *(uint32_t*)0x2000279c = 0xfffffffb;
    *(uint32_t*)0x200027a0 = 0x40000;
    *(uint32_t*)0x200027a4 = 0xffff;
    *(uint32_t*)0x200027a8 = 0x8001;
    *(uint32_t*)0x200027ac = 0x800;
    *(uint32_t*)0x200027b0 = 6;
    *(uint32_t*)0x200027b4 = -1;
    *(uint32_t*)0x200027b8 = 0x3a6;
    *(uint32_t*)0x200027bc = 3;
    *(uint32_t*)0x200027c0 = 2;
    *(uint32_t*)0x200027c4 = 0x1d;
    *(uint32_t*)0x200027c8 = 0x90be;
    *(uint32_t*)0x200027cc = 2;
    *(uint32_t*)0x200027d0 = 9;
    *(uint32_t*)0x200027d4 = 0x7fffffff;
    *(uint32_t*)0x200027d8 = 6;
    *(uint32_t*)0x200027dc = 0x15;
    *(uint32_t*)0x200027e0 = 0x80;
    *(uint32_t*)0x200027e4 = 4;
    *(uint32_t*)0x200027e8 = 9;
    *(uint32_t*)0x200027ec = 7;
    *(uint32_t*)0x200027f0 = 0x15;
    *(uint32_t*)0x200027f4 = 5;
    *(uint32_t*)0x200027f8 = 0x10001;
    *(uint32_t*)0x200027fc = 9;
    *(uint32_t*)0x20002800 = 9;
    *(uint32_t*)0x20002804 = 6;
    *(uint32_t*)0x20002808 = 8;
    *(uint32_t*)0x2000280c = 5;
    *(uint32_t*)0x20002810 = 2;
    *(uint32_t*)0x20002814 = -1;
    *(uint32_t*)0x20002818 = 9;
    *(uint32_t*)0x2000281c = 0xfffffff8;
    *(uint32_t*)0x20002820 = 0x9bb;
    *(uint32_t*)0x20002824 = 4;
    *(uint32_t*)0x20002828 = 0x3f;
    *(uint32_t*)0x2000282c = 0x800;
    *(uint32_t*)0x20002830 = 0;
    *(uint32_t*)0x20002834 = 2;
    *(uint32_t*)0x20002838 = 3;
    *(uint32_t*)0x2000283c = 1;
    *(uint32_t*)0x20002840 = 0x1800000;
    *(uint32_t*)0x20002844 = 0xd408;
    *(uint32_t*)0x20002848 = 0x7ff;
    *(uint32_t*)0x2000284c = 2;
    *(uint32_t*)0x20002850 = 3;
    *(uint32_t*)0x20002854 = 6;
    *(uint32_t*)0x20002858 = 0;
    *(uint32_t*)0x2000285c = 6;
    *(uint32_t*)0x20002860 = 0xfffff800;
    *(uint32_t*)0x20002864 = 0xfffffff9;
    *(uint32_t*)0x20002868 = 8;
    *(uint32_t*)0x2000286c = 1;
    *(uint32_t*)0x20002870 = 0xb09;
    *(uint32_t*)0x20002874 = 2;
    *(uint32_t*)0x20002878 = 0x10000;
    *(uint32_t*)0x2000287c = 1;
    *(uint32_t*)0x20002880 = 3;
    *(uint32_t*)0x20002884 = 0xfff;
    *(uint32_t*)0x20002888 = 1;
    *(uint32_t*)0x2000288c = 0x748;
    *(uint32_t*)0x20002890 = 5;
    *(uint32_t*)0x20002894 = 0x12000;
    *(uint32_t*)0x20002898 = 6;
    *(uint32_t*)0x2000289c = 0x7ff;
    *(uint32_t*)0x200028a0 = 4;
    *(uint32_t*)0x200028a4 = 6;
    *(uint32_t*)0x200028a8 = 6;
    *(uint32_t*)0x200028ac = 0xd8f0;
    *(uint32_t*)0x200028b0 = 0xe87;
    *(uint32_t*)0x200028b4 = 0x40;
    *(uint32_t*)0x200028b8 = 0xfffffff8;
    *(uint32_t*)0x200028bc = 0x40;
    *(uint32_t*)0x200028c0 = 0x20;
    *(uint32_t*)0x200028c4 = 0x20;
    *(uint32_t*)0x200028c8 = 0xa;
    *(uint32_t*)0x200028cc = 0;
    *(uint32_t*)0x200028d0 = 8;
    *(uint32_t*)0x200028d4 = 0;
    *(uint32_t*)0x200028d8 = 0xfffffffa;
    *(uint32_t*)0x200028dc = 8;
    *(uint32_t*)0x200028e0 = 6;
    *(uint32_t*)0x200028e4 = 4;
    *(uint32_t*)0x200028e8 = 4;
    *(uint32_t*)0x200028ec = 9;
    *(uint32_t*)0x200028f0 = 0xc928;
    *(uint32_t*)0x200028f4 = 0xe7;
    *(uint32_t*)0x200028f8 = 3;
    *(uint32_t*)0x200028fc = 2;
    *(uint32_t*)0x20002900 = 0x3c;
    *(uint32_t*)0x20002904 = 0xc7;
    *(uint32_t*)0x20002908 = 0x80000001;
    *(uint32_t*)0x2000290c = 0x80000000;
    *(uint32_t*)0x20002910 = 3;
    *(uint32_t*)0x20002914 = 9;
    *(uint32_t*)0x20002918 = 2;
    *(uint32_t*)0x2000291c = 2;
    *(uint32_t*)0x20002920 = 0xe6d;
    *(uint32_t*)0x20002924 = 0xfffffffc;
    *(uint32_t*)0x20002928 = 0xff;
    *(uint32_t*)0x2000292c = 0;
    *(uint32_t*)0x20002930 = 0xfffffffd;
    *(uint32_t*)0x20002934 = 0xdc7;
    *(uint32_t*)0x20002938 = 0x10000;
    *(uint32_t*)0x2000293c = 0x7ff;
    *(uint32_t*)0x20002940 = 4;
    *(uint32_t*)0x20002944 = 1;
    *(uint32_t*)0x20002948 = 0xfffeffff;
    *(uint32_t*)0x2000294c = 0x1000;
    *(uint32_t*)0x20002950 = 0xd4;
    *(uint32_t*)0x20002954 = 7;
    *(uint32_t*)0x20002958 = 0;
    *(uint32_t*)0x2000295c = 2;
    *(uint32_t*)0x20002960 = 9;
    *(uint32_t*)0x20002964 = 0x80000001;
    *(uint32_t*)0x20002968 = 0x10001;
    *(uint32_t*)0x2000296c = 0xa9;
    *(uint32_t*)0x20002970 = 0x21d;
    *(uint32_t*)0x20002974 = 6;
    *(uint32_t*)0x20002978 = 0x37d;
    *(uint32_t*)0x2000297c = 0;
    *(uint32_t*)0x20002980 = 6;
    *(uint16_t*)0x20002984 = 0x404;
    *(uint16_t*)0x20002986 = 3;
    *(uint32_t*)0x20002988 = 0x30;
    *(uint32_t*)0x2000298c = 6;
    *(uint32_t*)0x20002990 = 2;
    *(uint32_t*)0x20002994 = 0xfffffa20;
    *(uint32_t*)0x20002998 = 0x3ff;
    *(uint32_t*)0x2000299c = 4;
    *(uint32_t*)0x200029a0 = 0xfffffffb;
    *(uint32_t*)0x200029a4 = 3;
    *(uint32_t*)0x200029a8 = 0xffff;
    *(uint32_t*)0x200029ac = 0x400;
    *(uint32_t*)0x200029b0 = 9;
    *(uint32_t*)0x200029b4 = 5;
    *(uint32_t*)0x200029b8 = 0xf11;
    *(uint32_t*)0x200029bc = 0x7fff;
    *(uint32_t*)0x200029c0 = 0x1ff;
    *(uint32_t*)0x200029c4 = 0x7183;
    *(uint32_t*)0x200029c8 = 6;
    *(uint32_t*)0x200029cc = 0x3ff;
    *(uint32_t*)0x200029d0 = 0x8000;
    *(uint32_t*)0x200029d4 = 0x8001;
    *(uint32_t*)0x200029d8 = 0x10000;
    *(uint32_t*)0x200029dc = 0;
    *(uint32_t*)0x200029e0 = 2;
    *(uint32_t*)0x200029e4 = 8;
    *(uint32_t*)0x200029e8 = 0xd4;
    *(uint32_t*)0x200029ec = 0x400;
    *(uint32_t*)0x200029f0 = 0x7485;
    *(uint32_t*)0x200029f4 = 0;
    *(uint32_t*)0x200029f8 = 9;
    *(uint32_t*)0x200029fc = 0x800;
    *(uint32_t*)0x20002a00 = 6;
    *(uint32_t*)0x20002a04 = 0x80000000;
    *(uint32_t*)0x20002a08 = 0;
    *(uint32_t*)0x20002a0c = 4;
    *(uint32_t*)0x20002a10 = 4;
    *(uint32_t*)0x20002a14 = 0x3f;
    *(uint32_t*)0x20002a18 = 7;
    *(uint32_t*)0x20002a1c = 7;
    *(uint32_t*)0x20002a20 = 7;
    *(uint32_t*)0x20002a24 = 0x7fff;
    *(uint32_t*)0x20002a28 = 0x93b2;
    *(uint32_t*)0x20002a2c = 4;
    *(uint32_t*)0x20002a30 = 8;
    *(uint32_t*)0x20002a34 = 7;
    *(uint32_t*)0x20002a38 = 6;
    *(uint32_t*)0x20002a3c = 6;
    *(uint32_t*)0x20002a40 = 0;
    *(uint32_t*)0x20002a44 = 0x20000006;
    *(uint32_t*)0x20002a48 = 0xfe3;
    *(uint32_t*)0x20002a4c = 6;
    *(uint32_t*)0x20002a50 = 2;
    *(uint32_t*)0x20002a54 = 7;
    *(uint32_t*)0x20002a58 = 0xfffffbff;
    *(uint32_t*)0x20002a5c = 1;
    *(uint32_t*)0x20002a60 = 8;
    *(uint32_t*)0x20002a64 = 0x3f;
    *(uint32_t*)0x20002a68 = 3;
    *(uint32_t*)0x20002a6c = 0x3ff;
    *(uint32_t*)0x20002a70 = 0xc892;
    *(uint32_t*)0x20002a74 = 0xf24;
    *(uint32_t*)0x20002a78 = 0xbade;
    *(uint32_t*)0x20002a7c = 0;
    *(uint32_t*)0x20002a80 = 0x80000000;
    *(uint32_t*)0x20002a84 = 0;
    *(uint32_t*)0x20002a88 = 1;
    *(uint32_t*)0x20002a8c = 0xfff;
    *(uint32_t*)0x20002a90 = 4;
    *(uint32_t*)0x20002a94 = 3;
    *(uint32_t*)0x20002a98 = 2;
    *(uint32_t*)0x20002a9c = 0xcce;
    *(uint32_t*)0x20002aa0 = 0xd2f22c9;
    *(uint32_t*)0x20002aa4 = 3;
    *(uint32_t*)0x20002aa8 = 7;
    *(uint32_t*)0x20002aac = 0x34f8;
    *(uint32_t*)0x20002ab0 = 0xfffffffc;
    *(uint32_t*)0x20002ab4 = 0xcfe;
    *(uint32_t*)0x20002ab8 = 4;
    *(uint32_t*)0x20002abc = 8;
    *(uint32_t*)0x20002ac0 = 0x7ff;
    *(uint32_t*)0x20002ac4 = 4;
    *(uint32_t*)0x20002ac8 = 0x101;
    *(uint32_t*)0x20002acc = 4;
    *(uint32_t*)0x20002ad0 = 0x20;
    *(uint32_t*)0x20002ad4 = 0x7fffffff;
    *(uint32_t*)0x20002ad8 = 7;
    *(uint32_t*)0x20002adc = 0x242b;
    *(uint32_t*)0x20002ae0 = 0;
    *(uint32_t*)0x20002ae4 = 1;
    *(uint32_t*)0x20002ae8 = 5;
    *(uint32_t*)0x20002aec = 0x80000000;
    *(uint32_t*)0x20002af0 = 0xab3;
    *(uint32_t*)0x20002af4 = 0x8001;
    *(uint32_t*)0x20002af8 = 0xfffffff9;
    *(uint32_t*)0x20002afc = 0xfffffc01;
    *(uint32_t*)0x20002b00 = 1;
    *(uint32_t*)0x20002b04 = 0x99;
    *(uint32_t*)0x20002b08 = 0xeea8;
    *(uint32_t*)0x20002b0c = 0xfffffff8;
    *(uint32_t*)0x20002b10 = 4;
    *(uint32_t*)0x20002b14 = 0x101;
    *(uint32_t*)0x20002b18 = 8;
    *(uint32_t*)0x20002b1c = 2;
    *(uint32_t*)0x20002b20 = 5;
    *(uint32_t*)0x20002b24 = 0xffff;
    *(uint32_t*)0x20002b28 = 1;
    *(uint32_t*)0x20002b2c = 0;
    *(uint32_t*)0x20002b30 = 0x400;
    *(uint32_t*)0x20002b34 = 0x1c0;
    *(uint32_t*)0x20002b38 = 3;
    *(uint32_t*)0x20002b3c = 1;
    *(uint32_t*)0x20002b40 = 5;
    *(uint32_t*)0x20002b44 = -1;
    *(uint32_t*)0x20002b48 = 8;
    *(uint32_t*)0x20002b4c = 0x514;
    *(uint32_t*)0x20002b50 = 0;
    *(uint32_t*)0x20002b54 = 8;
    *(uint32_t*)0x20002b58 = 0x481f;
    *(uint32_t*)0x20002b5c = 4;
    *(uint32_t*)0x20002b60 = 0xffff;
    *(uint32_t*)0x20002b64 = 0x2a;
    *(uint32_t*)0x20002b68 = 6;
    *(uint32_t*)0x20002b6c = 1;
    *(uint32_t*)0x20002b70 = 3;
    *(uint32_t*)0x20002b74 = 0;
    *(uint32_t*)0x20002b78 = 4;
    *(uint32_t*)0x20002b7c = 4;
    *(uint32_t*)0x20002b80 = 0x7fff;
    *(uint32_t*)0x20002b84 = 8;
    *(uint32_t*)0x20002b88 = 0x401;
    *(uint32_t*)0x20002b8c = 0x20;
    *(uint32_t*)0x20002b90 = 1;
    *(uint32_t*)0x20002b94 = 0x80;
    *(uint32_t*)0x20002b98 = 0;
    *(uint32_t*)0x20002b9c = 3;
    *(uint32_t*)0x20002ba0 = 5;
    *(uint32_t*)0x20002ba4 = 0x45;
    *(uint32_t*)0x20002ba8 = 6;
    *(uint32_t*)0x20002bac = 0x80;
    *(uint32_t*)0x20002bb0 = 0x81;
    *(uint32_t*)0x20002bb4 = 9;
    *(uint32_t*)0x20002bb8 = 0x7ff;
    *(uint32_t*)0x20002bbc = 3;
    *(uint32_t*)0x20002bc0 = 0;
    *(uint32_t*)0x20002bc4 = 0xfffff001;
    *(uint32_t*)0x20002bc8 = 0x20;
    *(uint32_t*)0x20002bcc = 4;
    *(uint32_t*)0x20002bd0 = 7;
    *(uint32_t*)0x20002bd4 = 2;
    *(uint32_t*)0x20002bd8 = 0;
    *(uint32_t*)0x20002bdc = 0xffff7fff;
    *(uint32_t*)0x20002be0 = 0x3ff;
    *(uint32_t*)0x20002be4 = 0;
    *(uint32_t*)0x20002be8 = 0x800;
    *(uint32_t*)0x20002bec = 3;
    *(uint32_t*)0x20002bf0 = 0x10001;
    *(uint32_t*)0x20002bf4 = 3;
    *(uint32_t*)0x20002bf8 = 0x81;
    *(uint32_t*)0x20002bfc = 0;
    *(uint32_t*)0x20002c00 = 0x1000;
    *(uint32_t*)0x20002c04 = 5;
    *(uint32_t*)0x20002c08 = 7;
    *(uint32_t*)0x20002c0c = 6;
    *(uint32_t*)0x20002c10 = 9;
    *(uint32_t*)0x20002c14 = 0x20;
    *(uint32_t*)0x20002c18 = 4;
    *(uint32_t*)0x20002c1c = 0x1f;
    *(uint32_t*)0x20002c20 = 7;
    *(uint32_t*)0x20002c24 = 0;
    *(uint32_t*)0x20002c28 = 7;
    *(uint32_t*)0x20002c2c = 6;
    *(uint32_t*)0x20002c30 = 3;
    *(uint32_t*)0x20002c34 = 8;
    *(uint32_t*)0x20002c38 = 1;
    *(uint32_t*)0x20002c3c = 0;
    *(uint32_t*)0x20002c40 = 2;
    *(uint32_t*)0x20002c44 = 0xfffffffa;
    *(uint32_t*)0x20002c48 = 0x59c3314f;
    *(uint32_t*)0x20002c4c = 3;
    *(uint32_t*)0x20002c50 = 7;
    *(uint32_t*)0x20002c54 = 0xab0;
    *(uint32_t*)0x20002c58 = 9;
    *(uint32_t*)0x20002c5c = 0x10;
    *(uint32_t*)0x20002c60 = 5;
    *(uint32_t*)0x20002c64 = 6;
    *(uint32_t*)0x20002c68 = 0xe0d0eda7;
    *(uint32_t*)0x20002c6c = 4;
    *(uint32_t*)0x20002c70 = 2;
    *(uint32_t*)0x20002c74 = 0;
    *(uint32_t*)0x20002c78 = 2;
    *(uint32_t*)0x20002c7c = 0;
    *(uint32_t*)0x20002c80 = 2;
    *(uint32_t*)0x20002c84 = 0xfffffffc;
    *(uint32_t*)0x20002c88 = 0xe18;
    *(uint32_t*)0x20002c8c = 2;
    *(uint32_t*)0x20002c90 = 0x8a0102d;
    *(uint32_t*)0x20002c94 = 3;
    *(uint32_t*)0x20002c98 = 4;
    *(uint32_t*)0x20002c9c = 5;
    *(uint32_t*)0x20002ca0 = 1;
    *(uint32_t*)0x20002ca4 = 0x13;
    *(uint32_t*)0x20002ca8 = 9;
    *(uint32_t*)0x20002cac = 0x47934dea;
    *(uint32_t*)0x20002cb0 = 5;
    *(uint32_t*)0x20002cb4 = 7;
    *(uint32_t*)0x20002cb8 = 0x17;
    *(uint32_t*)0x20002cbc = 0x81;
    *(uint32_t*)0x20002cc0 = 0xfb;
    *(uint32_t*)0x20002cc4 = 0xa0000000;
    *(uint32_t*)0x20002cc8 = 9;
    *(uint32_t*)0x20002ccc = 8;
    *(uint32_t*)0x20002cd0 = 3;
    *(uint32_t*)0x20002cd4 = 0x7f;
    *(uint32_t*)0x20002cd8 = 0x56;
    *(uint32_t*)0x20002cdc = 0x7fff;
    *(uint32_t*)0x20002ce0 = 3;
    *(uint32_t*)0x20002ce4 = 0x7f;
    *(uint32_t*)0x20002ce8 = 7;
    *(uint32_t*)0x20002cec = 0x7e3;
    *(uint32_t*)0x20002cf0 = 0x100;
    *(uint32_t*)0x20002cf4 = 1;
    *(uint32_t*)0x20002cf8 = 5;
    *(uint32_t*)0x20002cfc = 2;
    *(uint32_t*)0x20002d00 = 0x6f0c;
    *(uint32_t*)0x20002d04 = 0xed1d;
    *(uint32_t*)0x20002d08 = 0x462;
    *(uint32_t*)0x20002d0c = 0x7e8f;
    *(uint32_t*)0x20002d10 = 0x80000000;
    *(uint32_t*)0x20002d14 = 0;
    *(uint32_t*)0x20002d18 = 0x54e5;
    *(uint32_t*)0x20002d1c = 0x9b96;
    *(uint32_t*)0x20002d20 = 0x2aa5;
    *(uint32_t*)0x20002d24 = 0x8c9;
    *(uint32_t*)0x20002d28 = 2;
    *(uint32_t*)0x20002d2c = 0xc6b5;
    *(uint32_t*)0x20002d30 = 9;
    *(uint32_t*)0x20002d34 = 0x10001;
    *(uint32_t*)0x20002d38 = 0x100;
    *(uint32_t*)0x20002d3c = 0;
    *(uint32_t*)0x20002d40 = 0x20;
    *(uint32_t*)0x20002d44 = 2;
    *(uint32_t*)0x20002d48 = 0xfffffff9;
    *(uint32_t*)0x20002d4c = 6;
    *(uint32_t*)0x20002d50 = 3;
    *(uint32_t*)0x20002d54 = 4;
    *(uint32_t*)0x20002d58 = 1;
    *(uint32_t*)0x20002d5c = 6;
    *(uint32_t*)0x20002d60 = 0x40;
    *(uint32_t*)0x20002d64 = 9;
    *(uint32_t*)0x20002d68 = 0;
    *(uint32_t*)0x20002d6c = 0x1f;
    *(uint32_t*)0x20002d70 = 5;
    *(uint32_t*)0x20002d74 = 3;
    *(uint32_t*)0x20002d78 = 0x40;
    *(uint32_t*)0x20002d7c = 0x8ec;
    *(uint32_t*)0x20002d80 = 0x20;
    *(uint32_t*)0x20002d84 = 0x4f0;
    *(uint16_t*)0x20002d88 = 0x404;
    *(uint16_t*)0x20002d8a = 2;
    *(uint32_t*)0x20002d8c = 0x16;
    *(uint32_t*)0x20002d90 = 0xf62;
    *(uint32_t*)0x20002d94 = 7;
    *(uint32_t*)0x20002d98 = 0x7f;
    *(uint32_t*)0x20002d9c = 0xfc;
    *(uint32_t*)0x20002da0 = 2;
    *(uint32_t*)0x20002da4 = 1;
    *(uint32_t*)0x20002da8 = 0;
    *(uint32_t*)0x20002dac = 6;
    *(uint32_t*)0x20002db0 = 1;
    *(uint32_t*)0x20002db4 = 2;
    *(uint32_t*)0x20002db8 = 9;
    *(uint32_t*)0x20002dbc = 3;
    *(uint32_t*)0x20002dc0 = 0x7fff;
    *(uint32_t*)0x20002dc4 = 7;
    *(uint32_t*)0x20002dc8 = 1;
    *(uint32_t*)0x20002dcc = 0x469a;
    *(uint32_t*)0x20002dd0 = 5;
    *(uint32_t*)0x20002dd4 = 9;
    *(uint32_t*)0x20002dd8 = 0;
    *(uint32_t*)0x20002ddc = 0x56c;
    *(uint32_t*)0x20002de0 = 1;
    *(uint32_t*)0x20002de4 = 0x7ff;
    *(uint32_t*)0x20002de8 = 0x120;
    *(uint32_t*)0x20002dec = 9;
    *(uint32_t*)0x20002df0 = 0x401;
    *(uint32_t*)0x20002df4 = 5;
    *(uint32_t*)0x20002df8 = 0x81;
    *(uint32_t*)0x20002dfc = 1;
    *(uint32_t*)0x20002e00 = 6;
    *(uint32_t*)0x20002e04 = 0x7fffffff;
    *(uint32_t*)0x20002e08 = 0;
    *(uint32_t*)0x20002e0c = 5;
    *(uint32_t*)0x20002e10 = 0xffffc97f;
    *(uint32_t*)0x20002e14 = 0x40d;
    *(uint32_t*)0x20002e18 = 7;
    *(uint32_t*)0x20002e1c = 0xffff7fff;
    *(uint32_t*)0x20002e20 = 6;
    *(uint32_t*)0x20002e24 = 2;
    *(uint32_t*)0x20002e28 = 0x3f;
    *(uint32_t*)0x20002e2c = 0x888;
    *(uint32_t*)0x20002e30 = 1;
    *(uint32_t*)0x20002e34 = 0xff;
    *(uint32_t*)0x20002e38 = 0x81;
    *(uint32_t*)0x20002e3c = 5;
    *(uint32_t*)0x20002e40 = 0x604a;
    *(uint32_t*)0x20002e44 = 0xffff;
    *(uint32_t*)0x20002e48 = 0x99;
    *(uint32_t*)0x20002e4c = 0xcd0d;
    *(uint32_t*)0x20002e50 = 0x8000;
    *(uint32_t*)0x20002e54 = 1;
    *(uint32_t*)0x20002e58 = 6;
    *(uint32_t*)0x20002e5c = 4;
    *(uint32_t*)0x20002e60 = 0x20;
    *(uint32_t*)0x20002e64 = 5;
    *(uint32_t*)0x20002e68 = 1;
    *(uint32_t*)0x20002e6c = 4;
    *(uint32_t*)0x20002e70 = 0x93a;
    *(uint32_t*)0x20002e74 = 0x7a4;
    *(uint32_t*)0x20002e78 = 0x8000;
    *(uint32_t*)0x20002e7c = 0xb4;
    *(uint32_t*)0x20002e80 = 0x101;
    *(uint32_t*)0x20002e84 = 4;
    *(uint32_t*)0x20002e88 = 4;
    *(uint32_t*)0x20002e8c = 5;
    *(uint32_t*)0x20002e90 = 0x80;
    *(uint32_t*)0x20002e94 = 0x5b;
    *(uint32_t*)0x20002e98 = 0x49b;
    *(uint32_t*)0x20002e9c = 0x7ff;
    *(uint32_t*)0x20002ea0 = 4;
    *(uint32_t*)0x20002ea4 = 5;
    *(uint32_t*)0x20002ea8 = 0;
    *(uint32_t*)0x20002eac = 6;
    *(uint32_t*)0x20002eb0 = 0x7fff;
    *(uint32_t*)0x20002eb4 = 9;
    *(uint32_t*)0x20002eb8 = 0xc176;
    *(uint32_t*)0x20002ebc = 8;
    *(uint32_t*)0x20002ec0 = 0x800;
    *(uint32_t*)0x20002ec4 = 6;
    *(uint32_t*)0x20002ec8 = 0x7ff;
    *(uint32_t*)0x20002ecc = 0xfffffffe;
    *(uint32_t*)0x20002ed0 = 1;
    *(uint32_t*)0x20002ed4 = 0x10000;
    *(uint32_t*)0x20002ed8 = 5;
    *(uint32_t*)0x20002edc = 0xb3;
    *(uint32_t*)0x20002ee0 = 3;
    *(uint32_t*)0x20002ee4 = 0x81;
    *(uint32_t*)0x20002ee8 = 0x1be;
    *(uint32_t*)0x20002eec = 0xd3c6;
    *(uint32_t*)0x20002ef0 = 0x7ff;
    *(uint32_t*)0x20002ef4 = 0xdb3a;
    *(uint32_t*)0x20002ef8 = 6;
    *(uint32_t*)0x20002efc = 5;
    *(uint32_t*)0x20002f00 = 0x400;
    *(uint32_t*)0x20002f04 = 0xcb;
    *(uint32_t*)0x20002f08 = 0x49c0649d;
    *(uint32_t*)0x20002f0c = 1;
    *(uint32_t*)0x20002f10 = 2;
    *(uint32_t*)0x20002f14 = 0;
    *(uint32_t*)0x20002f18 = 0x3ff;
    *(uint32_t*)0x20002f1c = 3;
    *(uint32_t*)0x20002f20 = 1;
    *(uint32_t*)0x20002f24 = -1;
    *(uint32_t*)0x20002f28 = 7;
    *(uint32_t*)0x20002f2c = 0;
    *(uint32_t*)0x20002f30 = 0xa2d;
    *(uint32_t*)0x20002f34 = 0xfffffff7;
    *(uint32_t*)0x20002f38 = 1;
    *(uint32_t*)0x20002f3c = 0xfffffffc;
    *(uint32_t*)0x20002f40 = 0x101;
    *(uint32_t*)0x20002f44 = 0xfffffff8;
    *(uint32_t*)0x20002f48 = -1;
    *(uint32_t*)0x20002f4c = 1;
    *(uint32_t*)0x20002f50 = 0xd3;
    *(uint32_t*)0x20002f54 = 0x9d8b;
    *(uint32_t*)0x20002f58 = 0x80000000;
    *(uint32_t*)0x20002f5c = 2;
    *(uint32_t*)0x20002f60 = 0x7f;
    *(uint32_t*)0x20002f64 = 0x7ff;
    *(uint32_t*)0x20002f68 = 0xb17;
    *(uint32_t*)0x20002f6c = 0x3f;
    *(uint32_t*)0x20002f70 = 0;
    *(uint32_t*)0x20002f74 = 0x1000;
    *(uint32_t*)0x20002f78 = 0x90f3;
    *(uint32_t*)0x20002f7c = 0x8001;
    *(uint32_t*)0x20002f80 = 3;
    *(uint32_t*)0x20002f84 = 3;
    *(uint32_t*)0x20002f88 = 9;
    *(uint32_t*)0x20002f8c = -1;
    *(uint32_t*)0x20002f90 = 8;
    *(uint32_t*)0x20002f94 = 9;
    *(uint32_t*)0x20002f98 = 0xfffffffc;
    *(uint32_t*)0x20002f9c = 0xfffffffd;
    *(uint32_t*)0x20002fa0 = 8;
    *(uint32_t*)0x20002fa4 = 0x48ed;
    *(uint32_t*)0x20002fa8 = 8;
    *(uint32_t*)0x20002fac = 0x81;
    *(uint32_t*)0x20002fb0 = 7;
    *(uint32_t*)0x20002fb4 = 0x7fffffff;
    *(uint32_t*)0x20002fb8 = 3;
    *(uint32_t*)0x20002fbc = 1;
    *(uint32_t*)0x20002fc0 = 0xe0a6;
    *(uint32_t*)0x20002fc4 = 0x7fff;
    *(uint32_t*)0x20002fc8 = 1;
    *(uint32_t*)0x20002fcc = 0x80;
    *(uint32_t*)0x20002fd0 = 3;
    *(uint32_t*)0x20002fd4 = 7;
    *(uint32_t*)0x20002fd8 = 0x40;
    *(uint32_t*)0x20002fdc = 2;
    *(uint32_t*)0x20002fe0 = 9;
    *(uint32_t*)0x20002fe4 = 2;
    *(uint32_t*)0x20002fe8 = 5;
    *(uint32_t*)0x20002fec = 2;
    *(uint32_t*)0x20002ff0 = 4;
    *(uint32_t*)0x20002ff4 = 1;
    *(uint32_t*)0x20002ff8 = 8;
    *(uint32_t*)0x20002ffc = 8;
    *(uint32_t*)0x20003000 = 0xdbac;
    *(uint32_t*)0x20003004 = 9;
    *(uint32_t*)0x20003008 = 0x3f;
    *(uint32_t*)0x2000300c = 0xfff;
    *(uint32_t*)0x20003010 = 5;
    *(uint32_t*)0x20003014 = -1;
    *(uint32_t*)0x20003018 = 6;
    *(uint32_t*)0x2000301c = 2;
    *(uint32_t*)0x20003020 = 5;
    *(uint32_t*)0x20003024 = 0xfff;
    *(uint32_t*)0x20003028 = 5;
    *(uint32_t*)0x2000302c = 1;
    *(uint32_t*)0x20003030 = 0x40;
    *(uint32_t*)0x20003034 = 0x2008000;
    *(uint32_t*)0x20003038 = 7;
    *(uint32_t*)0x2000303c = 0xff;
    *(uint32_t*)0x20003040 = 2;
    *(uint32_t*)0x20003044 = 0x7fff;
    *(uint32_t*)0x20003048 = 0x153;
    *(uint32_t*)0x2000304c = 0x57af;
    *(uint32_t*)0x20003050 = 0xffffff13;
    *(uint32_t*)0x20003054 = 8;
    *(uint32_t*)0x20003058 = 0x9a;
    *(uint32_t*)0x2000305c = 0x71;
    *(uint32_t*)0x20003060 = 2;
    *(uint32_t*)0x20003064 = 5;
    *(uint32_t*)0x20003068 = 5;
    *(uint32_t*)0x2000306c = 5;
    *(uint32_t*)0x20003070 = 6;
    *(uint32_t*)0x20003074 = 0x7fff;
    *(uint32_t*)0x20003078 = 0x3ff0000;
    *(uint32_t*)0x2000307c = 0x20;
    *(uint32_t*)0x20003080 = 3;
    *(uint32_t*)0x20003084 = 0xfffffff8;
    *(uint32_t*)0x20003088 = 0x7fff;
    *(uint32_t*)0x2000308c = 4;
    *(uint32_t*)0x20003090 = 3;
    *(uint32_t*)0x20003094 = 0;
    *(uint32_t*)0x20003098 = 0;
    *(uint32_t*)0x2000309c = 9;
    *(uint32_t*)0x200030a0 = 0;
    *(uint32_t*)0x200030a4 = 0x661;
    *(uint32_t*)0x200030a8 = 5;
    *(uint32_t*)0x200030ac = 0x7eb3;
    *(uint32_t*)0x200030b0 = 0xffff;
    *(uint32_t*)0x200030b4 = 0xa569;
    *(uint32_t*)0x200030b8 = 8;
    *(uint32_t*)0x200030bc = 3;
    *(uint32_t*)0x200030c0 = 2;
    *(uint32_t*)0x200030c4 = 3;
    *(uint32_t*)0x200030c8 = 0x8000;
    *(uint32_t*)0x200030cc = 9;
    *(uint32_t*)0x200030d0 = 6;
    *(uint32_t*)0x200030d4 = 0xfe7;
    *(uint32_t*)0x200030d8 = 0x7fff;
    *(uint32_t*)0x200030dc = 0xae39;
    *(uint32_t*)0x200030e0 = 7;
    *(uint32_t*)0x200030e4 = 0x20;
    *(uint32_t*)0x200030e8 = 0x81;
    *(uint32_t*)0x200030ec = 8;
    *(uint32_t*)0x200030f0 = 0xffffffc1;
    *(uint32_t*)0x200030f4 = 0xffff;
    *(uint32_t*)0x200030f8 = 4;
    *(uint32_t*)0x200030fc = 5;
    *(uint32_t*)0x20003100 = 2;
    *(uint32_t*)0x20003104 = 2;
    *(uint32_t*)0x20003108 = 0x80;
    *(uint32_t*)0x2000310c = 1;
    *(uint32_t*)0x20003110 = 0x400;
    *(uint32_t*)0x20003114 = 0x10001;
    *(uint32_t*)0x20003118 = 6;
    *(uint32_t*)0x2000311c = 7;
    *(uint32_t*)0x20003120 = 0x5ab3ff1e;
    *(uint32_t*)0x20003124 = 0x20;
    *(uint32_t*)0x20003128 = 7;
    *(uint32_t*)0x2000312c = 8;
    *(uint32_t*)0x20003130 = 1;
    *(uint32_t*)0x20003134 = 0x10000;
    *(uint32_t*)0x20003138 = 0x200;
    *(uint32_t*)0x2000313c = 0x80000000;
    *(uint32_t*)0x20003140 = 5;
    *(uint32_t*)0x20003144 = 6;
    *(uint32_t*)0x20003148 = 7;
    *(uint32_t*)0x2000314c = 7;
    *(uint32_t*)0x20003150 = 4;
    *(uint32_t*)0x20003154 = 5;
    *(uint32_t*)0x20003158 = 0x8f;
    *(uint32_t*)0x2000315c = 0x1199;
    *(uint32_t*)0x20003160 = 0;
    *(uint32_t*)0x20003164 = 0xb32;
    *(uint32_t*)0x20003168 = 0x1ff;
    *(uint32_t*)0x2000316c = 0xffffcbd2;
    *(uint32_t*)0x20003170 = 0x7fff;
    *(uint32_t*)0x20003174 = 9;
    *(uint32_t*)0x20003178 = 0x1983;
    *(uint32_t*)0x2000317c = 3;
    *(uint32_t*)0x20003180 = 0x8bc;
    *(uint32_t*)0x20003184 = 0;
    *(uint32_t*)0x20003188 = 0x8000;
    *(uint16_t*)0x2000318c = 0x3c;
    *(uint16_t*)0x2000318e = 1;
    *(uint32_t*)0x20003190 = 8;
    *(uint32_t*)0x20003194 = 6;
    *(uint32_t*)0x20003198 = 0x10001;
    *(uint32_t*)0x2000319c = 0;
    *(uint32_t*)0x200031a0 = 8;
    *(uint8_t*)0x200031a4 = 0x20;
    *(uint8_t*)0x200031a5 = 2;
    *(uint16_t*)0x200031a6 = 1;
    *(uint16_t*)0x200031a8 = 0x8486;
    *(uint16_t*)0x200031aa = 8;
    *(uint32_t*)0x200031ac = 0xfffffffa;
    *(uint8_t*)0x200031b0 = 5;
    *(uint8_t*)0x200031b1 = 1;
    *(uint16_t*)0x200031b2 = 1;
    *(uint16_t*)0x200031b4 = 9;
    *(uint16_t*)0x200031b6 = 0x3e;
    *(uint32_t*)0x200031b8 = 0x1000;
    *(uint32_t*)0x200031bc = 4;
    *(uint32_t*)0x200031c0 = 0xfffffbff;
    *(uint32_t*)0x200031c4 = 0x1ff;
    *(uint16_t*)0x200031c8 = 0x404;
    *(uint16_t*)0x200031ca = 3;
    *(uint32_t*)0x200031cc = 0x3365;
    *(uint32_t*)0x200031d0 = 3;
    *(uint32_t*)0x200031d4 = 1;
    *(uint32_t*)0x200031d8 = 9;
    *(uint32_t*)0x200031dc = 1;
    *(uint32_t*)0x200031e0 = 6;
    *(uint32_t*)0x200031e4 = 0x101;
    *(uint32_t*)0x200031e8 = 0x101;
    *(uint32_t*)0x200031ec = 6;
    *(uint32_t*)0x200031f0 = 0x4ab6;
    *(uint32_t*)0x200031f4 = 0x8001;
    *(uint32_t*)0x200031f8 = 0xd36d;
    *(uint32_t*)0x200031fc = 0;
    *(uint32_t*)0x20003200 = 2;
    *(uint32_t*)0x20003204 = 9;
    *(uint32_t*)0x20003208 = 8;
    *(uint32_t*)0x2000320c = 7;
    *(uint32_t*)0x20003210 = 8;
    *(uint32_t*)0x20003214 = 2;
    *(uint32_t*)0x20003218 = 2;
    *(uint32_t*)0x2000321c = 4;
    *(uint32_t*)0x20003220 = 7;
    *(uint32_t*)0x20003224 = 2;
    *(uint32_t*)0x20003228 = 0xd8;
    *(uint32_t*)0x2000322c = 0x83;
    *(uint32_t*)0x20003230 = 5;
    *(uint32_t*)0x20003234 = 7;
    *(uint32_t*)0x20003238 = 6;
    *(uint32_t*)0x2000323c = 0;
    *(uint32_t*)0x20003240 = 8;
    *(uint32_t*)0x20003244 = 0x71ec9e9c;
    *(uint32_t*)0x20003248 = 5;
    *(uint32_t*)0x2000324c = 0x78;
    *(uint32_t*)0x20003250 = 0xa707;
    *(uint32_t*)0x20003254 = 0x3f;
    *(uint32_t*)0x20003258 = 9;
    *(uint32_t*)0x2000325c = 8;
    *(uint32_t*)0x20003260 = 3;
    *(uint32_t*)0x20003264 = 8;
    *(uint32_t*)0x20003268 = 8;
    *(uint32_t*)0x2000326c = 9;
    *(uint32_t*)0x20003270 = 4;
    *(uint32_t*)0x20003274 = 5;
    *(uint32_t*)0x20003278 = 0xfffffff7;
    *(uint32_t*)0x2000327c = 0x7ff;
    *(uint32_t*)0x20003280 = 0;
    *(uint32_t*)0x20003284 = 6;
    *(uint32_t*)0x20003288 = 9;
    *(uint32_t*)0x2000328c = 0xffffffe0;
    *(uint32_t*)0x20003290 = 0x101;
    *(uint32_t*)0x20003294 = 0x1f;
    *(uint32_t*)0x20003298 = 7;
    *(uint32_t*)0x2000329c = 0xa33a;
    *(uint32_t*)0x200032a0 = 0x24a6;
    *(uint32_t*)0x200032a4 = 6;
    *(uint32_t*)0x200032a8 = 0xfffff801;
    *(uint32_t*)0x200032ac = 6;
    *(uint32_t*)0x200032b0 = 5;
    *(uint32_t*)0x200032b4 = 8;
    *(uint32_t*)0x200032b8 = 0;
    *(uint32_t*)0x200032bc = 2;
    *(uint32_t*)0x200032c0 = 0x80000001;
    *(uint32_t*)0x200032c4 = 0xd3a;
    *(uint32_t*)0x200032c8 = 6;
    *(uint32_t*)0x200032cc = 0x6e4f447e;
    *(uint32_t*)0x200032d0 = 0x100;
    *(uint32_t*)0x200032d4 = 0xfe3;
    *(uint32_t*)0x200032d8 = 0x20;
    *(uint32_t*)0x200032dc = 9;
    *(uint32_t*)0x200032e0 = 8;
    *(uint32_t*)0x200032e4 = 0xdf2;
    *(uint32_t*)0x200032e8 = -1;
    *(uint32_t*)0x200032ec = 0x800;
    *(uint32_t*)0x200032f0 = 0xb0;
    *(uint32_t*)0x200032f4 = 4;
    *(uint32_t*)0x200032f8 = 5;
    *(uint32_t*)0x200032fc = 0x1000;
    *(uint32_t*)0x20003300 = 0x447a0258;
    *(uint32_t*)0x20003304 = 5;
    *(uint32_t*)0x20003308 = 6;
    *(uint32_t*)0x2000330c = 3;
    *(uint32_t*)0x20003310 = 4;
    *(uint32_t*)0x20003314 = 0x7f;
    *(uint32_t*)0x20003318 = 0xd;
    *(uint32_t*)0x2000331c = 6;
    *(uint32_t*)0x20003320 = 0xffff;
    *(uint32_t*)0x20003324 = 1;
    *(uint32_t*)0x20003328 = 0x8000;
    *(uint32_t*)0x2000332c = 0xe1;
    *(uint32_t*)0x20003330 = 0xfffffd2a;
    *(uint32_t*)0x20003334 = 0x10000;
    *(uint32_t*)0x20003338 = 0xffff;
    *(uint32_t*)0x2000333c = 0x1ceaea0;
    *(uint32_t*)0x20003340 = 0x401;
    *(uint32_t*)0x20003344 = 0x8001;
    *(uint32_t*)0x20003348 = 0x7f;
    *(uint32_t*)0x2000334c = 3;
    *(uint32_t*)0x20003350 = 0;
    *(uint32_t*)0x20003354 = 0x100;
    *(uint32_t*)0x20003358 = 0;
    *(uint32_t*)0x2000335c = 3;
    *(uint32_t*)0x20003360 = 3;
    *(uint32_t*)0x20003364 = 1;
    *(uint32_t*)0x20003368 = 6;
    *(uint32_t*)0x2000336c = 8;
    *(uint32_t*)0x20003370 = 0x40;
    *(uint32_t*)0x20003374 = 0xf505;
    *(uint32_t*)0x20003378 = 0x1d;
    *(uint32_t*)0x2000337c = 9;
    *(uint32_t*)0x20003380 = 0;
    *(uint32_t*)0x20003384 = 8;
    *(uint32_t*)0x20003388 = 6;
    *(uint32_t*)0x2000338c = 0x80;
    *(uint32_t*)0x20003390 = 7;
    *(uint32_t*)0x20003394 = 0;
    *(uint32_t*)0x20003398 = 0x7ff;
    *(uint32_t*)0x2000339c = 8;
    *(uint32_t*)0x200033a0 = 1;
    *(uint32_t*)0x200033a4 = 9;
    *(uint32_t*)0x200033a8 = 0x20;
    *(uint32_t*)0x200033ac = -1;
    *(uint32_t*)0x200033b0 = 0x100;
    *(uint32_t*)0x200033b4 = 9;
    *(uint32_t*)0x200033b8 = 6;
    *(uint32_t*)0x200033bc = 6;
    *(uint32_t*)0x200033c0 = 0x33;
    *(uint32_t*)0x200033c4 = 0xb11d;
    *(uint32_t*)0x200033c8 = 9;
    *(uint32_t*)0x200033cc = 0xa9;
    *(uint32_t*)0x200033d0 = 0x7ff;
    *(uint32_t*)0x200033d4 = 0;
    *(uint32_t*)0x200033d8 = 3;
    *(uint32_t*)0x200033dc = 5;
    *(uint32_t*)0x200033e0 = 6;
    *(uint32_t*)0x200033e4 = 6;
    *(uint32_t*)0x200033e8 = 4;
    *(uint32_t*)0x200033ec = 8;
    *(uint32_t*)0x200033f0 = 0x40;
    *(uint32_t*)0x200033f4 = 0x80000001;
    *(uint32_t*)0x200033f8 = 9;
    *(uint32_t*)0x200033fc = 3;
    *(uint32_t*)0x20003400 = 1;
    *(uint32_t*)0x20003404 = 0x60be0000;
    *(uint32_t*)0x20003408 = 0xfffff003;
    *(uint32_t*)0x2000340c = 0x100;
    *(uint32_t*)0x20003410 = 1;
    *(uint32_t*)0x20003414 = 0x93f7;
    *(uint32_t*)0x20003418 = 0x3ff;
    *(uint32_t*)0x2000341c = 0x100;
    *(uint32_t*)0x20003420 = 0xdb;
    *(uint32_t*)0x20003424 = 6;
    *(uint32_t*)0x20003428 = 0x3392;
    *(uint32_t*)0x2000342c = 5;
    *(uint32_t*)0x20003430 = 1;
    *(uint32_t*)0x20003434 = 0x56000000;
    *(uint32_t*)0x20003438 = 0x2b;
    *(uint32_t*)0x2000343c = 5;
    *(uint32_t*)0x20003440 = 3;
    *(uint32_t*)0x20003444 = 0x10000;
    *(uint32_t*)0x20003448 = 0;
    *(uint32_t*)0x2000344c = 1;
    *(uint32_t*)0x20003450 = 9;
    *(uint32_t*)0x20003454 = 0x91ed;
    *(uint32_t*)0x20003458 = 3;
    *(uint32_t*)0x2000345c = 0xfff;
    *(uint32_t*)0x20003460 = 0x400;
    *(uint32_t*)0x20003464 = 0x7fff;
    *(uint32_t*)0x20003468 = 9;
    *(uint32_t*)0x2000346c = 0x1f;
    *(uint32_t*)0x20003470 = 0x8001;
    *(uint32_t*)0x20003474 = 7;
    *(uint32_t*)0x20003478 = 4;
    *(uint32_t*)0x2000347c = 2;
    *(uint32_t*)0x20003480 = 0x81;
    *(uint32_t*)0x20003484 = 5;
    *(uint32_t*)0x20003488 = 0xfffffffe;
    *(uint32_t*)0x2000348c = 3;
    *(uint32_t*)0x20003490 = 9;
    *(uint32_t*)0x20003494 = 4;
    *(uint32_t*)0x20003498 = 2;
    *(uint32_t*)0x2000349c = 0x3ff;
    *(uint32_t*)0x200034a0 = 8;
    *(uint32_t*)0x200034a4 = 0xfffffffb;
    *(uint32_t*)0x200034a8 = 0xfffffffa;
    *(uint32_t*)0x200034ac = 4;
    *(uint32_t*)0x200034b0 = 0;
    *(uint32_t*)0x200034b4 = 8;
    *(uint32_t*)0x200034b8 = 7;
    *(uint32_t*)0x200034bc = 2;
    *(uint32_t*)0x200034c0 = 0x80;
    *(uint32_t*)0x200034c4 = 0xfffff646;
    *(uint32_t*)0x200034c8 = 1;
    *(uint32_t*)0x200034cc = 8;
    *(uint32_t*)0x200034d0 = 2;
    *(uint32_t*)0x200034d4 = 0xfff;
    *(uint32_t*)0x200034d8 = 0xc415;
    *(uint32_t*)0x200034dc = 8;
    *(uint32_t*)0x200034e0 = 1;
    *(uint32_t*)0x200034e4 = 9;
    *(uint32_t*)0x200034e8 = 9;
    *(uint32_t*)0x200034ec = 6;
    *(uint32_t*)0x200034f0 = 0x1f;
    *(uint32_t*)0x200034f4 = 0x1f;
    *(uint32_t*)0x200034f8 = 1;
    *(uint32_t*)0x200034fc = 2;
    *(uint32_t*)0x20003500 = 0x327;
    *(uint32_t*)0x20003504 = 0x58;
    *(uint32_t*)0x20003508 = 1;
    *(uint32_t*)0x2000350c = 5;
    *(uint32_t*)0x20003510 = 8;
    *(uint32_t*)0x20003514 = 0;
    *(uint32_t*)0x20003518 = 0xfffffff7;
    *(uint32_t*)0x2000351c = 0xfffffff7;
    *(uint32_t*)0x20003520 = 5;
    *(uint32_t*)0x20003524 = 5;
    *(uint32_t*)0x20003528 = 0x684;
    *(uint32_t*)0x2000352c = 0xfffffff9;
    *(uint32_t*)0x20003530 = 8;
    *(uint32_t*)0x20003534 = 0;
    *(uint32_t*)0x20003538 = 8;
    *(uint32_t*)0x2000353c = 0xffffff10;
    *(uint32_t*)0x20003540 = 2;
    *(uint32_t*)0x20003544 = 0x1ff;
    *(uint32_t*)0x20003548 = 9;
    *(uint32_t*)0x2000354c = 0xff;
    *(uint32_t*)0x20003550 = 6;
    *(uint32_t*)0x20003554 = 0;
    *(uint32_t*)0x20003558 = 0;
    *(uint32_t*)0x2000355c = 5;
    *(uint32_t*)0x20003560 = 0;
    *(uint32_t*)0x20003564 = 0;
    *(uint32_t*)0x20003568 = 0x9d2;
    *(uint32_t*)0x2000356c = 0x7fff;
    *(uint32_t*)0x20003570 = 1;
    *(uint32_t*)0x20003574 = 0x13;
    *(uint32_t*)0x20003578 = 7;
    *(uint32_t*)0x2000357c = 4;
    *(uint32_t*)0x20003580 = 2;
    *(uint32_t*)0x20003584 = 0x8c;
    *(uint32_t*)0x20003588 = 0xff;
    *(uint32_t*)0x2000358c = 0x7fff;
    *(uint32_t*)0x20003590 = 0x10000;
    *(uint32_t*)0x20003594 = 7;
    *(uint32_t*)0x20003598 = 0xfffffff9;
    *(uint32_t*)0x2000359c = 0x401;
    *(uint32_t*)0x200035a0 = 0x800;
    *(uint32_t*)0x200035a4 = 0x508;
    *(uint32_t*)0x200035a8 = 0xfffff000;
    *(uint32_t*)0x200035ac = 1;
    *(uint32_t*)0x200035b0 = 9;
    *(uint32_t*)0x200035b4 = 0x800;
    *(uint32_t*)0x200035b8 = 0xadcb;
    *(uint32_t*)0x200035bc = 6;
    *(uint32_t*)0x200035c0 = 1;
    *(uint32_t*)0x200035c4 = 3;
    *(uint32_t*)0x200035c8 = 9;
    *(uint16_t*)0x200035cc = 0x3c;
    *(uint16_t*)0x200035ce = 1;
    *(uint32_t*)0x200035d0 = 0x800;
    *(uint32_t*)0x200035d4 = 5;
    *(uint32_t*)0x200035d8 = 0x80;
    *(uint32_t*)0x200035dc = 9;
    *(uint32_t*)0x200035e0 = 0xffff0001;
    *(uint8_t*)0x200035e4 = 1;
    *(uint8_t*)0x200035e5 = 2;
    *(uint16_t*)0x200035e6 = 0xff;
    *(uint16_t*)0x200035e8 = 0x1f;
    *(uint16_t*)0x200035ea = 0x7ff;
    *(uint32_t*)0x200035ec = 0xfffffffc;
    *(uint8_t*)0x200035f0 = 0x40;
    *(uint8_t*)0x200035f1 = 0;
    *(uint16_t*)0x200035f2 = 0x8000;
    *(uint16_t*)0x200035f4 = 0x3f;
    *(uint16_t*)0x200035f6 = 0x3ff;
    *(uint32_t*)0x200035f8 = 4;
    *(uint32_t*)0x200035fc = 0;
    *(uint32_t*)0x20003600 = 3;
    *(uint32_t*)0x20003604 = 0x3f;
    *(uint16_t*)0x20003608 = 0x3a0;
    STORE_BY_BITMASK(uint16_t, , 0x2000360a, 3, 0, 14);
    STORE_BY_BITMASK(uint16_t, , 0x2000360b, 0, 6, 1);
    STORE_BY_BITMASK(uint16_t, , 0x2000360b, 1, 7, 1);
    *(uint16_t*)0x2000360c = 8;
    *(uint16_t*)0x2000360e = 1;
    *(uint16_t*)0x20003610 = 0x101;
    *(uint16_t*)0x20003612 = 0;
    *(uint16_t*)0x20003614 = 0x360;
    STORE_BY_BITMASK(uint16_t, , 0x20003616, 2, 0, 14);
    STORE_BY_BITMASK(uint16_t, , 0x20003617, 0, 6, 1);
    STORE_BY_BITMASK(uint16_t, , 0x20003617, 1, 7, 1);
    *(uint16_t*)0x20003618 = 0x18;
    STORE_BY_BITMASK(uint16_t, , 0x2000361a, 3, 0, 14);
    STORE_BY_BITMASK(uint16_t, , 0x2000361b, 0, 6, 1);
    STORE_BY_BITMASK(uint16_t, , 0x2000361b, 0, 7, 1);
    *(uint16_t*)0x2000361c = 9;
    *(uint16_t*)0x2000361e = 1;
    *(uint16_t*)0x20003620 = 0;
    *(uint16_t*)0x20003622 = 0;
    *(uint32_t*)0x20003624 = 0x98f;
    *(uint32_t*)0x20003628 = 7;
    *(uint16_t*)0x2000362c = 2;
    STORE_BY_BITMASK(uint8_t, , 0x2000362e, 1, 0, 4);
    STORE_BY_BITMASK(uint8_t, , 0x2000362e, 9, 4, 4);
    STORE_BY_BITMASK(uint8_t, , 0x2000362f, 0, 0, 4);
    STORE_BY_BITMASK(uint8_t, , 0x2000362f, 2, 4, 4);
    *(uint16_t*)0x20003630 = 0x14;
    STORE_BY_BITMASK(uint16_t, , 0x20003632, 3, 0, 14);
    STORE_BY_BITMASK(uint16_t, , 0x20003633, 0, 6, 1);
    STORE_BY_BITMASK(uint16_t, , 0x20003633, 0, 7, 1);
    *(uint16_t*)0x20003634 = 0xe821;
    *(uint16_t*)0x20003636 = 7;
    *(uint16_t*)0x20003638 = 5;
    *(uint16_t*)0x2000363a = 0;
    STORE_BY_BITMASK(uint32_t, , 0x2000363c, 4, 0, 29);
    STORE_BY_BITMASK(uint32_t, , 0x2000363c, 1, 29, 1);
    STORE_BY_BITMASK(uint32_t, , 0x2000363c, 0, 30, 1);
    STORE_BY_BITMASK(uint32_t, , 0x2000363c, 1, 31, 1);
    STORE_BY_BITMASK(uint32_t, , 0x20003640, 3, 0, 29);
    STORE_BY_BITMASK(uint32_t, , 0x20003640, 1, 29, 1);
    STORE_BY_BITMASK(uint32_t, , 0x20003640, 1, 30, 1);
    STORE_BY_BITMASK(uint32_t, , 0x20003640, 0, 31, 1);
    *(uint16_t*)0x20003644 = 0x118;
    STORE_BY_BITMASK(uint16_t, , 0x20003646, 3, 0, 14);
    STORE_BY_BITMASK(uint16_t, , 0x20003647, 0, 6, 1);
    STORE_BY_BITMASK(uint16_t, , 0x20003647, 0, 7, 1);
    *(uint16_t*)0x20003648 = 0xfe36;
    *(uint16_t*)0x2000364a = 9;
    *(uint16_t*)0x2000364c = 0x40;
    *(uint16_t*)0x2000364e = 0;
    *(uint16_t*)0x20003650 = 5;
    *(uint16_t*)0x20003652 = 4;
    *(uint8_t*)0x20003654 = 0xd;
    *(uint16_t*)0x20003658 = 4;
    *(uint16_t*)0x2000365a = 5;
    *(uint16_t*)0x2000365c = 8;
    *(uint16_t*)0x2000365e = 1;
    *(uint32_t*)0x20003660 = 3;
    *(uint16_t*)0x20003664 = 0x8d;
    *(uint16_t*)0x20003666 = 5;
    memcpy((void*)0x20003668,
           "\xe3\xbb\x71\xf0\x8d\x0e\x51\xc8\xb1\xca\x00\xf0\x37\x1b\xff\x19"
           "\x3f\x81\xb5\x3e\x66\xcf\x51\xcd\xfe\x2f\xe5\x04\xec\x53\xaa\xfe"
           "\xa6\x59\x32\x7d\xa9\xcb\xcc\x98\x62\x38\xa7\x88\xbe\x9f\xab\x6c"
           "\xf3\xce\x47\xf6\xaf\xd9\xdb\x56\x5e\xe5\xd9\xb1\x6d\xdd\xbf\x9d"
           "\xdf\x85\xe3\xd6\x09\x43\x32\x1c\x4b\x40\x2e\xb1\x50\x75\x38\x3d"
           "\x6d\x2f\x52\x19\xec\x2e\x7b\x13\xd4\x24\x14\xa0\xf5\xbf\xcf\x8b"
           "\x4c\x6f\x63\x9a\x83\xdb\xc9\xfb\x4f\x95\xf8\x2b\x4b\x2c\x34\xe0"
           "\xf7\xaf\xb8\xe3\xa4\x6e\xfa\x57\x5c\x5a\xaa\x52\x2c\x33\xdd\x49"
           "\x25\x56\xd8\xcc\x44\xe6\x32\x5e\xe3",
           137);
    *(uint16_t*)0x200036f4 = 5;
    *(uint16_t*)0x200036f6 = 4;
    *(uint8_t*)0x200036f8 = 0xc;
    *(uint16_t*)0x200036fc = 5;
    *(uint16_t*)0x200036fe = 4;
    *(uint8_t*)0x20003700 = 3;
    *(uint16_t*)0x20003704 = 0x55;
    *(uint16_t*)0x20003706 = 5;
    memcpy((void*)0x20003708, "\x8d\x20\x11\x66\x87\x28\xf0\x68\x8d\x14\x39\x03"
                              "\x35\xb2\x6f\x32\x3f\xcb\x1a\x10\x34\x29\xda\x07"
                              "\x35\xb2\xdb\x8c\x9a\xcf\x06\xd6\x08\x0b\xf6\xcc"
                              "\x61\x33\x83\xb7\xf1\x53\x66\xd1\xa0\x35\x82\xaf"
                              "\xb4\xef\x5d\x0c\xb1\xb4\xbb\x86\x40\x4d\xfe\x66"
                              "\xf4\x94\xa2\x04\x4b\x04\x93\xbe\xc4\xea\xaf\x2a"
                              "\xd9\x11\x18\xed\x85\xa0\x42\x6a\xde",
           81);
    *(uint16_t*)0x2000375c = 0xc;
    STORE_BY_BITMASK(uint16_t, , 0x2000375e, 1, 0, 14);
    STORE_BY_BITMASK(uint16_t, , 0x2000375f, 0, 6, 1);
    STORE_BY_BITMASK(uint16_t, , 0x2000375f, 0, 7, 1);
    *(uint16_t*)0x20003760 = 0x81;
    *(uint16_t*)0x20003762 = 4;
    *(uint16_t*)0x20003764 = 0xe3a;
    *(uint16_t*)0x20003766 = 0;
    *(uint16_t*)0x20003768 = 0x14;
    STORE_BY_BITMASK(uint16_t, , 0x2000376a, 1, 0, 14);
    STORE_BY_BITMASK(uint16_t, , 0x2000376b, 0, 6, 1);
    STORE_BY_BITMASK(uint16_t, , 0x2000376b, 0, 7, 1);
    *(uint16_t*)0x2000376c = -1;
    *(uint16_t*)0x2000376e = 7;
    *(uint16_t*)0x20003770 = 0x20;
    *(uint16_t*)0x20003772 = 0;
    STORE_BY_BITMASK(uint32_t, , 0x20003774, 0, 0, 29);
    STORE_BY_BITMASK(uint32_t, , 0x20003774, 1, 29, 1);
    STORE_BY_BITMASK(uint32_t, , 0x20003774, 1, 30, 1);
    STORE_BY_BITMASK(uint32_t, , 0x20003774, 1, 31, 1);
    STORE_BY_BITMASK(uint32_t, , 0x20003778, 0, 0, 29);
    STORE_BY_BITMASK(uint32_t, , 0x20003778, 0, 29, 1);
    STORE_BY_BITMASK(uint32_t, , 0x20003778, 0, 30, 1);
    STORE_BY_BITMASK(uint32_t, , 0x20003778, 1, 31, 1);
    *(uint16_t*)0x2000377c = 0xfc;
    STORE_BY_BITMASK(uint16_t, , 0x2000377e, 3, 0, 14);
    STORE_BY_BITMASK(uint16_t, , 0x2000377f, 0, 6, 1);
    STORE_BY_BITMASK(uint16_t, , 0x2000377f, 0, 7, 1);
    *(uint16_t*)0x20003780 = 0x1000;
    *(uint16_t*)0x20003782 = 9;
    *(uint16_t*)0x20003784 = 0xca2;
    *(uint16_t*)0x20003786 = 0;
    *(uint16_t*)0x20003788 = 5;
    *(uint16_t*)0x2000378a = 3;
    *(uint8_t*)0x2000378c = 0x81;
    *(uint16_t*)0x20003790 = 5;
    *(uint16_t*)0x20003792 = 3;
    *(uint8_t*)0x20003794 = 3;
    *(uint16_t*)0x20003798 = 0xd4;
    *(uint16_t*)0x2000379a = 5;
    memcpy((void*)0x2000379c,
           "\x0b\xd2\x00\x24\xeb\x3f\x5c\xf4\x9f\x3c\x66\xfa\x96\x71\x08\x95"
           "\xfe\x51\x62\x40\x30\x5d\xcb\x59\xf7\x16\x2d\x16\x8a\x48\xc0\x2d"
           "\x49\x3b\x2e\xde\xee\x25\xab\x6b\x77\x92\x5b\x18\xb3\xb9\x8c\x2d"
           "\xa1\x3b\x6e\xf8\x0c\x90\x61\x5a\x62\xfb\x20\x98\xff\x0c\x6f\xcc"
           "\x28\xec\x15\x1b\xeb\x15\x98\xf8\x3d\xd7\x16\x4d\x79\xb5\x4f\x2f"
           "\xad\x4c\x90\x51\x54\x0a\x58\xe3\xed\x23\x9d\x8d\xc5\xdd\x4a\x55"
           "\x19\x26\x9d\x06\x48\xb5\x10\x05\xe5\xd4\x1f\x1f\x76\xb1\xe9\x0e"
           "\xc4\x7c\x2e\x95\x7b\x15\x30\x67\x3f\xcc\x0c\x92\x7a\xf7\x23\x4e"
           "\xe2\x2f\x17\xef\xf8\x39\xdb\x3e\x2c\x47\x24\xd6\xce\x45\x04\xe7"
           "\xed\x3e\x87\x16\x36\x87\x72\xb0\xbc\x5d\x30\xc2\xae\xc6\x79\x71"
           "\x7b\x61\x5f\x73\x7f\x90\x3f\xf0\xcc\xe6\x5e\x8b\xd0\xe2\xa4\xa1"
           "\xe3\xac\xa5\xf8\x00\xef\xec\x4a\xf6\xae\xbf\x49\x7e\x54\x58\xb0"
           "\x27\xed\x3d\x88\x18\x48\x2c\xa1\x32\x65\x1c\xcc\x4a\xcf\x91\xcb",
           208);
    *(uint16_t*)0x2000386c = 0xb;
    *(uint16_t*)0x2000386e = 2;
    memcpy((void*)0x20003870, "policy\000", 7);
    *(uint16_t*)0x20003878 = 0x68;
    STORE_BY_BITMASK(uint16_t, , 0x2000387a, 2, 0, 14);
    STORE_BY_BITMASK(uint16_t, , 0x2000387b, 0, 6, 1);
    STORE_BY_BITMASK(uint16_t, , 0x2000387b, 0, 7, 1);
    *(uint16_t*)0x2000387c = 0xfff9;
    *(uint16_t*)0x2000387e = 0;
    *(uint16_t*)0x20003880 = 0x3f;
    *(uint16_t*)0x20003882 = 0;
    memcpy((void*)0x20003884,
           "\x02\xeb\xc8\x49\xbc\xfb\x6e\x8c\x77\xb1\xc1\x3b\x78\xfe\x9c\x27"
           "\x8d\xc4\x9f\x25\x49\x91\x4c\x18\x36\x24\xaa\xf5\xeb\x96\xe4\x33"
           "\x44\x79\x88\xe2\x8a\xea\xc9\xe7\x6e\x84\x5d\xaa\x70\x4d\x5e\xf3"
           "\xe4\x2a\x14\xae\x0d\x1d\x68\x38\x7c\xfa\x04\x20\xce\x7a\xdc\x79"
           "\x8a\x6a\xe0\x2f\x64\x5d\xe9\xd9\xa6\xe4\x75\x05\xe1\x35\x9f\x02"
           "\xc6\x4f\x0e\xed\xcb\x5f\xec\xa6\xd1\x5f\xba\x1c",
           92);
    *(uint16_t*)0x200038e0 = 0x94;
    STORE_BY_BITMASK(uint16_t, , 0x200038e2, 1, 0, 14);
    STORE_BY_BITMASK(uint16_t, , 0x200038e3, 0, 6, 1);
    STORE_BY_BITMASK(uint16_t, , 0x200038e3, 0, 7, 1);
    *(uint16_t*)0x200038e4 = 6;
    *(uint16_t*)0x200038e6 = 4;
    *(uint16_t*)0x200038e8 = 7;
    *(uint16_t*)0x200038ea = 0;
    *(uint16_t*)0x200038ec = 0xc;
    *(uint16_t*)0x200038ee = 1;
    *(uint16_t*)0x200038f0 = 0x400;
    *(uint8_t*)0x200038f2 = 9;
    *(uint8_t*)0x200038f3 = 2;
    *(uint16_t*)0x200038f4 = 8;
    *(uint8_t*)0x200038f6 = 8;
    *(uint8_t*)0x200038f7 = 0;
    *(uint16_t*)0x200038f8 = 0x21;
    *(uint16_t*)0x200038fa = 2;
    *(uint32_t*)0x200038fc = 6;
    memcpy((void*)0x20003900, "\xff\xa8\x4c\x39\x9a\xc8\xcb\x21\xe5\x3c", 10);
    memcpy((void*)0x2000390a, "\x29\x91", 2);
    *(uint32_t*)0x2000390c = 0xa;
    *(uint32_t*)0x20003910 = 0xa;
    memcpy((void*)0x20003914, "\x69\xe4\xee\xe1\x12", 5);
    *(uint16_t*)0x2000391c = 0x17;
    *(uint16_t*)0x2000391e = 2;
    memcpy((void*)0x20003920, "\x34\x2d\x7f\x32\xc2\x3f\xdb", 7);
    memcpy((void*)0x20003927, "\v/", 2);
    memcpy((void*)0x20003929, "\x0e\x3b", 2);
    *(uint32_t*)0x2000392b = 8;
    *(uint32_t*)0x2000392f = 1;
    *(uint16_t*)0x20003934 = 0xc;
    *(uint16_t*)0x20003936 = 1;
    *(uint16_t*)0x20003938 = 4;
    *(uint8_t*)0x2000393a = 9;
    *(uint8_t*)0x2000393b = 1;
    *(uint16_t*)0x2000393c = 2;
    *(uint8_t*)0x2000393e = 9;
    *(uint8_t*)0x2000393f = 2;
    *(uint16_t*)0x20003940 = 0xc;
    *(uint16_t*)0x20003942 = 1;
    *(uint16_t*)0x20003944 = 0x81;
    *(uint8_t*)0x20003946 = -1;
    *(uint8_t*)0x20003947 = 3;
    *(uint16_t*)0x20003948 = 2;
    *(uint8_t*)0x2000394a = 0x3f;
    *(uint8_t*)0x2000394b = 0;
    *(uint16_t*)0x2000394c = 0xc;
    *(uint16_t*)0x2000394e = 1;
    *(uint16_t*)0x20003950 = 5;
    *(uint8_t*)0x20003952 = 0x37;
    *(uint8_t*)0x20003953 = 0;
    *(uint16_t*)0x20003954 = 9;
    *(uint8_t*)0x20003956 = 7;
    *(uint8_t*)0x20003957 = 1;
    *(uint16_t*)0x20003958 = 0x1b;
    *(uint16_t*)0x2000395a = 2;
    memcpy((void*)0x2000395c, "\x0b\xe9\xb5\x55\xe7\x27\x6c\xfa\x7e\xae", 10);
    memcpy((void*)0x20003966, "\x41\x49\xe1", 3);
    memcpy((void*)0x20003969, "\x2a\xfc\x9d\x72\xbb\xb9\xf2\x51\xce\x02", 10);
    *(uint16_t*)0x20003974 = 8;
    *(uint16_t*)0x20003976 = 1;
    *(uint16_t*)0x20003978 = 0x400;
    *(uint16_t*)0x2000397a = 0;
    *(uint16_t*)0x2000397c = 8;
    *(uint16_t*)0x2000397e = 1;
    *(uint16_t*)0x20003980 = -1;
    *(uint16_t*)0x20003982 = 0;
    *(uint16_t*)0x20003984 = 8;
    *(uint16_t*)0x20003986 = 1;
    *(uint16_t*)0x20003988 = 5;
    *(uint16_t*)0x2000398a = 0;
    *(uint16_t*)0x2000398c = 0x1c;
    STORE_BY_BITMASK(uint16_t, , 0x2000398e, 2, 0, 14);
    STORE_BY_BITMASK(uint16_t, , 0x2000398f, 0, 6, 1);
    STORE_BY_BITMASK(uint16_t, , 0x2000398f, 1, 7, 1);
    *(uint16_t*)0x20003990 = 0x18;
    STORE_BY_BITMASK(uint16_t, , 0x20003992, 2, 0, 14);
    STORE_BY_BITMASK(uint16_t, , 0x20003993, 0, 6, 1);
    STORE_BY_BITMASK(uint16_t, , 0x20003993, 0, 7, 1);
    *(uint16_t*)0x20003994 = 1;
    *(uint16_t*)0x20003996 = 1;
    *(uint16_t*)0x20003998 = 8;
    *(uint16_t*)0x2000399a = 0;
    *(uint32_t*)0x2000399c = 8;
    *(uint32_t*)0x200039a0 = 8;
    *(uint16_t*)0x200039a4 = 6;
    STORE_BY_BITMASK(uint8_t, , 0x200039a6, 4, 0, 4);
    STORE_BY_BITMASK(uint8_t, , 0x200039a6, 9, 4, 4);
    STORE_BY_BITMASK(uint8_t, , 0x200039a7, 0, 0, 4);
    STORE_BY_BITMASK(uint8_t, , 0x200039a7, 2, 4, 4);
    *(uint16_t*)0x200039a8 = 0xc;
    *(uint16_t*)0x200039aa = 1;
    memcpy((void*)0x200039ac, "tcindex\000", 8);
    *(uint16_t*)0x200039b4 = 0x1960;
    *(uint16_t*)0x200039b6 = 2;
    *(uint16_t*)0x200039b8 = 8;
    *(uint16_t*)0x200039ba = 3;
    *(uint32_t*)0x200039bc = 0;
    *(uint16_t*)0x200039c0 = 0x444;
    *(uint16_t*)0x200039c2 = 6;
    *(uint16_t*)0x200039c4 = 0x3c;
    *(uint16_t*)0x200039c6 = 1;
    *(uint32_t*)0x200039c8 = 0;
    *(uint32_t*)0x200039cc = 5;
    *(uint32_t*)0x200039d0 = 7;
    *(uint32_t*)0x200039d4 = 0x3f;
    *(uint32_t*)0x200039d8 = 0xfffe0000;
    *(uint8_t*)0x200039dc = 0xd;
    *(uint8_t*)0x200039dd = 0;
    *(uint16_t*)0x200039de = 7;
    *(uint16_t*)0x200039e0 = 3;
    *(uint16_t*)0x200039e2 = 4;
    *(uint32_t*)0x200039e4 = 0xffff;
    *(uint8_t*)0x200039e8 = 0;
    *(uint8_t*)0x200039e9 = 1;
    *(uint16_t*)0x200039ea = 0x8001;
    *(uint16_t*)0x200039ec = 7;
    *(uint16_t*)0x200039ee = 8;
    *(uint32_t*)0x200039f0 = 6;
    *(uint32_t*)0x200039f4 = 0x7fff;
    *(uint32_t*)0x200039f8 = 0xffff;
    *(uint32_t*)0x200039fc = 1;
    *(uint16_t*)0x20003a00 = 0x404;
    *(uint16_t*)0x20003a02 = 3;
    *(uint32_t*)0x20003a04 = 2;
    *(uint32_t*)0x20003a08 = 4;
    *(uint32_t*)0x20003a0c = 9;
    *(uint32_t*)0x20003a10 = 2;
    *(uint32_t*)0x20003a14 = 1;
    *(uint32_t*)0x20003a18 = 2;
    *(uint32_t*)0x20003a1c = 0;
    *(uint32_t*)0x20003a20 = 1;
    *(uint32_t*)0x20003a24 = 0x5f1;
    *(uint32_t*)0x20003a28 = 0x8000;
    *(uint32_t*)0x20003a2c = 0;
    *(uint32_t*)0x20003a30 = 0x6c2;
    *(uint32_t*)0x20003a34 = 0x80;
    *(uint32_t*)0x20003a38 = 0x1000;
    *(uint32_t*)0x20003a3c = 0x1ff;
    *(uint32_t*)0x20003a40 = 0xfffffff9;
    *(uint32_t*)0x20003a44 = 0xadd9;
    *(uint32_t*)0x20003a48 = 8;
    *(uint32_t*)0x20003a4c = 0x400;
    *(uint32_t*)0x20003a50 = 2;
    *(uint32_t*)0x20003a54 = 0xde;
    *(uint32_t*)0x20003a58 = 6;
    *(uint32_t*)0x20003a5c = 1;
    *(uint32_t*)0x20003a60 = 9;
    *(uint32_t*)0x20003a64 = 4;
    *(uint32_t*)0x20003a68 = 0x7fff;
    *(uint32_t*)0x20003a6c = 0xfffeffff;
    *(uint32_t*)0x20003a70 = 6;
    *(uint32_t*)0x20003a74 = 0x261c;
    *(uint32_t*)0x20003a78 = 5;
    *(uint32_t*)0x20003a7c = 0x101;
    *(uint32_t*)0x20003a80 = 0xcb;
    *(uint32_t*)0x20003a84 = 6;
    *(uint32_t*)0x20003a88 = 0;
    *(uint32_t*)0x20003a8c = 4;
    *(uint32_t*)0x20003a90 = 6;
    *(uint32_t*)0x20003a94 = 1;
    *(uint32_t*)0x20003a98 = 0xd5b6;
    *(uint32_t*)0x20003a9c = 0xfff;
    *(uint32_t*)0x20003aa0 = 1;
    *(uint32_t*)0x20003aa4 = 4;
    *(uint32_t*)0x20003aa8 = 0xdaf1;
    *(uint32_t*)0x20003aac = 5;
    *(uint32_t*)0x20003ab0 = 0x800;
    *(uint32_t*)0x20003ab4 = 8;
    *(uint32_t*)0x20003ab8 = 0;
    *(uint32_t*)0x20003abc = -1;
    *(uint32_t*)0x20003ac0 = -1;
    *(uint32_t*)0x20003ac4 = 7;
    *(uint32_t*)0x20003ac8 = 0x81;
    *(uint32_t*)0x20003acc = 8;
    *(uint32_t*)0x20003ad0 = 0x29;
    *(uint32_t*)0x20003ad4 = 0xfffff349;
    *(uint32_t*)0x20003ad8 = 3;
    *(uint32_t*)0x20003adc = 3;
    *(uint32_t*)0x20003ae0 = -1;
    *(uint32_t*)0x20003ae4 = 0x7fffffff;
    *(uint32_t*)0x20003ae8 = 4;
    *(uint32_t*)0x20003aec = 8;
    *(uint32_t*)0x20003af0 = 0x40;
    *(uint32_t*)0x20003af4 = 0xafaa;
    *(uint32_t*)0x20003af8 = 0x100;
    *(uint32_t*)0x20003afc = 0x1b;
    *(uint32_t*)0x20003b00 = 0xfffffffb;
    *(uint32_t*)0x20003b04 = 0xfffffffb;
    *(uint32_t*)0x20003b08 = 1;
    *(uint32_t*)0x20003b0c = 4;
    *(uint32_t*)0x20003b10 = 8;
    *(uint32_t*)0x20003b14 = 8;
    *(uint32_t*)0x20003b18 = 3;
    *(uint32_t*)0x20003b1c = 2;
    *(uint32_t*)0x20003b20 = 9;
    *(uint32_t*)0x20003b24 = 4;
    *(uint32_t*)0x20003b28 = 0;
    *(uint32_t*)0x20003b2c = 0x80000000;
    *(uint32_t*)0x20003b30 = 0x1c0000;
    *(uint32_t*)0x20003b34 = 6;
    *(uint32_t*)0x20003b38 = 0x80;
    *(uint32_t*)0x20003b3c = 9;
    *(uint32_t*)0x20003b40 = 4;
    *(uint32_t*)0x20003b44 = 2;
    *(uint32_t*)0x20003b48 = -1;
    *(uint32_t*)0x20003b4c = 6;
    *(uint32_t*)0x20003b50 = 0x3f;
    *(uint32_t*)0x20003b54 = 0x20;
    *(uint32_t*)0x20003b58 = 8;
    *(uint32_t*)0x20003b5c = 5;
    *(uint32_t*)0x20003b60 = 8;
    *(uint32_t*)0x20003b64 = 2;
    *(uint32_t*)0x20003b68 = 9;
    *(uint32_t*)0x20003b6c = 0xfff;
    *(uint32_t*)0x20003b70 = 0xfffffffb;
    *(uint32_t*)0x20003b74 = 0xc16;
    *(uint32_t*)0x20003b78 = 6;
    *(uint32_t*)0x20003b7c = 2;
    *(uint32_t*)0x20003b80 = 7;
    *(uint32_t*)0x20003b84 = 0x200;
    *(uint32_t*)0x20003b88 = 0x10001;
    *(uint32_t*)0x20003b8c = 2;
    *(uint32_t*)0x20003b90 = 2;
    *(uint32_t*)0x20003b94 = 0xfffffffa;
    *(uint32_t*)0x20003b98 = 0x400;
    *(uint32_t*)0x20003b9c = 3;
    *(uint32_t*)0x20003ba0 = 0x80000001;
    *(uint32_t*)0x20003ba4 = 0;
    *(uint32_t*)0x20003ba8 = 4;
    *(uint32_t*)0x20003bac = 8;
    *(uint32_t*)0x20003bb0 = 0xa4c8;
    *(uint32_t*)0x20003bb4 = 5;
    *(uint32_t*)0x20003bb8 = 8;
    *(uint32_t*)0x20003bbc = 0x39;
    *(uint32_t*)0x20003bc0 = 0x1ff;
    *(uint32_t*)0x20003bc4 = 0x20;
    *(uint32_t*)0x20003bc8 = 8;
    *(uint32_t*)0x20003bcc = 6;
    *(uint32_t*)0x20003bd0 = 0x80000001;
    *(uint32_t*)0x20003bd4 = 0x7fffffff;
    *(uint32_t*)0x20003bd8 = 9;
    *(uint32_t*)0x20003bdc = 0x3f;
    *(uint32_t*)0x20003be0 = 7;
    *(uint32_t*)0x20003be4 = 0;
    *(uint32_t*)0x20003be8 = 0x800;
    *(uint32_t*)0x20003bec = 0;
    *(uint32_t*)0x20003bf0 = 4;
    *(uint32_t*)0x20003bf4 = 0x200;
    *(uint32_t*)0x20003bf8 = 0x7fff;
    *(uint32_t*)0x20003bfc = 0;
    *(uint32_t*)0x20003c00 = 8;
    *(uint32_t*)0x20003c04 = 9;
    *(uint32_t*)0x20003c08 = 0x400;
    *(uint32_t*)0x20003c0c = 0x7fff;
    *(uint32_t*)0x20003c10 = 2;
    *(uint32_t*)0x20003c14 = 4;
    *(uint32_t*)0x20003c18 = 6;
    *(uint32_t*)0x20003c1c = 0x80;
    *(uint32_t*)0x20003c20 = 9;
    *(uint32_t*)0x20003c24 = 0x618;
    *(uint32_t*)0x20003c28 = 9;
    *(uint32_t*)0x20003c2c = 1;
    *(uint32_t*)0x20003c30 = 7;
    *(uint32_t*)0x20003c34 = 3;
    *(uint32_t*)0x20003c38 = 4;
    *(uint32_t*)0x20003c3c = 0x8a;
    *(uint32_t*)0x20003c40 = 1;
    *(uint32_t*)0x20003c44 = 6;
    *(uint32_t*)0x20003c48 = 4;
    *(uint32_t*)0x20003c4c = 8;
    *(uint32_t*)0x20003c50 = 0;
    *(uint32_t*)0x20003c54 = 5;
    *(uint32_t*)0x20003c58 = 5;
    *(uint32_t*)0x20003c5c = 5;
    *(uint32_t*)0x20003c60 = 4;
    *(uint32_t*)0x20003c64 = 0xfffffffb;
    *(uint32_t*)0x20003c68 = 9;
    *(uint32_t*)0x20003c6c = 0x1ff;
    *(uint32_t*)0x20003c70 = 5;
    *(uint32_t*)0x20003c74 = 0xccb9;
    *(uint32_t*)0x20003c78 = 0x80000000;
    *(uint32_t*)0x20003c7c = 0x9d9d;
    *(uint32_t*)0x20003c80 = 3;
    *(uint32_t*)0x20003c84 = 0x200;
    *(uint32_t*)0x20003c88 = 8;
    *(uint32_t*)0x20003c8c = 1;
    *(uint32_t*)0x20003c90 = 8;
    *(uint32_t*)0x20003c94 = 2;
    *(uint32_t*)0x20003c98 = 6;
    *(uint32_t*)0x20003c9c = 0x1ba500;
    *(uint32_t*)0x20003ca0 = 0x800;
    *(uint32_t*)0x20003ca4 = 0x3ff;
    *(uint32_t*)0x20003ca8 = 0x100;
    *(uint32_t*)0x20003cac = 1;
    *(uint32_t*)0x20003cb0 = 5;
    *(uint32_t*)0x20003cb4 = 0x7ff;
    *(uint32_t*)0x20003cb8 = 2;
    *(uint32_t*)0x20003cbc = 0;
    *(uint32_t*)0x20003cc0 = 2;
    *(uint32_t*)0x20003cc4 = 0x1ff;
    *(uint32_t*)0x20003cc8 = 0;
    *(uint32_t*)0x20003ccc = 5;
    *(uint32_t*)0x20003cd0 = 0xffff8001;
    *(uint32_t*)0x20003cd4 = 6;
    *(uint32_t*)0x20003cd8 = 0xffffffc0;
    *(uint32_t*)0x20003cdc = 2;
    *(uint32_t*)0x20003ce0 = 6;
    *(uint32_t*)0x20003ce4 = 0x80000001;
    *(uint32_t*)0x20003ce8 = 8;
    *(uint32_t*)0x20003cec = 6;
    *(uint32_t*)0x20003cf0 = 9;
    *(uint32_t*)0x20003cf4 = 0x55ff;
    *(uint32_t*)0x20003cf8 = 5;
    *(uint32_t*)0x20003cfc = 0xa32c;
    *(uint32_t*)0x20003d00 = 0x8001;
    *(uint32_t*)0x20003d04 = 0xfffffffb;
    *(uint32_t*)0x20003d08 = 8;
    *(uint32_t*)0x20003d0c = 0;
    *(uint32_t*)0x20003d10 = 1;
    *(uint32_t*)0x20003d14 = 0x8001;
    *(uint32_t*)0x20003d18 = 0x8001;
    *(uint32_t*)0x20003d1c = 7;
    *(uint32_t*)0x20003d20 = 0xffff;
    *(uint32_t*)0x20003d24 = 0;
    *(uint32_t*)0x20003d28 = 0x5c;
    *(uint32_t*)0x20003d2c = -1;
    *(uint32_t*)0x20003d30 = 1;
    *(uint32_t*)0x20003d34 = 0xff;
    *(uint32_t*)0x20003d38 = 7;
    *(uint32_t*)0x20003d3c = 3;
    *(uint32_t*)0x20003d40 = 2;
    *(uint32_t*)0x20003d44 = 7;
    *(uint32_t*)0x20003d48 = 0x868;
    *(uint32_t*)0x20003d4c = 8;
    *(uint32_t*)0x20003d50 = 5;
    *(uint32_t*)0x20003d54 = 0xffff;
    *(uint32_t*)0x20003d58 = 4;
    *(uint32_t*)0x20003d5c = 0x400;
    *(uint32_t*)0x20003d60 = 0x200;
    *(uint32_t*)0x20003d64 = -1;
    *(uint32_t*)0x20003d68 = 0x400;
    *(uint32_t*)0x20003d6c = 0xb3c2;
    *(uint32_t*)0x20003d70 = 6;
    *(uint32_t*)0x20003d74 = 0;
    *(uint32_t*)0x20003d78 = 3;
    *(uint32_t*)0x20003d7c = 2;
    *(uint32_t*)0x20003d80 = 6;
    *(uint32_t*)0x20003d84 = 9;
    *(uint32_t*)0x20003d88 = 3;
    *(uint32_t*)0x20003d8c = 0x5e;
    *(uint32_t*)0x20003d90 = 0xfffffff8;
    *(uint32_t*)0x20003d94 = 3;
    *(uint32_t*)0x20003d98 = 8;
    *(uint32_t*)0x20003d9c = 0x3ff;
    *(uint32_t*)0x20003da0 = 0x3a23;
    *(uint32_t*)0x20003da4 = 0x40;
    *(uint32_t*)0x20003da8 = 0x8001;
    *(uint32_t*)0x20003dac = 0x438d;
    *(uint32_t*)0x20003db0 = 8;
    *(uint32_t*)0x20003db4 = 6;
    *(uint32_t*)0x20003db8 = 1;
    *(uint32_t*)0x20003dbc = 0x1ff;
    *(uint32_t*)0x20003dc0 = 0x451;
    *(uint32_t*)0x20003dc4 = 0x7fff;
    *(uint32_t*)0x20003dc8 = 5;
    *(uint32_t*)0x20003dcc = 2;
    *(uint32_t*)0x20003dd0 = 4;
    *(uint32_t*)0x20003dd4 = 0x9ce;
    *(uint32_t*)0x20003dd8 = 0x3ff;
    *(uint32_t*)0x20003ddc = 0x7ff;
    *(uint32_t*)0x20003de0 = 9;
    *(uint32_t*)0x20003de4 = 7;
    *(uint32_t*)0x20003de8 = 5;
    *(uint32_t*)0x20003dec = 0;
    *(uint32_t*)0x20003df0 = 0x200;
    *(uint32_t*)0x20003df4 = 0x401;
    *(uint32_t*)0x20003df8 = 4;
    *(uint32_t*)0x20003dfc = 0x7f;
    *(uint32_t*)0x20003e00 = 8;
    *(uint16_t*)0x20003e04 = 6;
    *(uint16_t*)0x20003e06 = 2;
    *(uint16_t*)0x20003e08 = 0;
    *(uint16_t*)0x20003e0c = 0x434;
    *(uint16_t*)0x20003e0e = 7;
    *(uint16_t*)0x20003e10 = 0x1e4;
    STORE_BY_BITMASK(uint16_t, , 0x20003e12, 0xc, 0, 14);
    STORE_BY_BITMASK(uint16_t, , 0x20003e13, 0, 6, 1);
    STORE_BY_BITMASK(uint16_t, , 0x20003e13, 0, 7, 1);
    *(uint16_t*)0x20003e14 = 7;
    *(uint16_t*)0x20003e16 = 1;
    memcpy((void*)0x20003e18, "xt\000", 3);
    *(uint16_t*)0x20003e1c = 0x134;
    STORE_BY_BITMASK(uint16_t, , 0x20003e1e, 2, 0, 14);
    STORE_BY_BITMASK(uint16_t, , 0x20003e1f, 0, 6, 1);
    STORE_BY_BITMASK(uint16_t, , 0x20003e1f, 1, 7, 1);
    *(uint16_t*)0x20003e20 = 8;
    *(uint16_t*)0x20003e22 = 3;
    *(uint32_t*)0x20003e24 = 0xffffffc1;
    *(uint16_t*)0x20003e28 = 8;
    *(uint16_t*)0x20003e2a = 2;
    *(uint32_t*)0x20003e2c = 2;
    *(uint16_t*)0x20003e30 = 8;
    *(uint16_t*)0x20003e32 = 3;
    *(uint32_t*)0x20003e34 = 0xede;
    *(uint16_t*)0x20003e38 = 8;
    *(uint16_t*)0x20003e3a = 2;
    *(uint32_t*)0x20003e3c = 1;
    *(uint16_t*)0x20003e40 = 0x24;
    *(uint16_t*)0x20003e42 = 1;
    memcpy((void*)0x20003e44, "security\000\000\000\000\000\000\000\000\000\000"
                              "\000\000\000\000\000\000\000\000\000\000\000\000"
                              "\000\000",
           32);
    *(uint16_t*)0x20003e64 = 8;
    *(uint16_t*)0x20003e66 = 2;
    *(uint32_t*)0x20003e68 = 4;
    *(uint16_t*)0x20003e6c = 8;
    *(uint16_t*)0x20003e6e = 2;
    *(uint32_t*)0x20003e70 = 4;
    *(uint16_t*)0x20003e74 = 0x8c;
    *(uint16_t*)0x20003e76 = 6;
    *(uint16_t*)0x20003e78 = 1;
    memcpy((void*)0x20003e7a, "security\000\000\000\000\000\000\000\000\000\000"
                              "\000\000\000\000\000\000\000\000\000\000\000\000"
                              "\000\000",
           32);
    *(uint8_t*)0x20003e9a = 1;
    *(uint16_t*)0x20003e9c = 0x101;
    memcpy((void*)0x20003e9e,
           "\xe6\xb4\x5b\x2f\x2f\xb8\xd1\xee\x6e\x4d\x0a\x4a\x17\xfc\xf6\xc7"
           "\x0e\xde\xc1\x00\xda\x6a\x58\x8a\x41\xe3\x2e\x98\xa5\xb7\x1b\x94"
           "\xab\xe7\x81\x16\x93\xe9\x93\x4d\x45\x0a\x35\xb4\x92\x69\xf5\x58"
           "\xee\x4f\x25\xc3\x90\x99\xa1\xe1\x53\x4f\xef\x41\x26\x7a\xa8\xd6"
           "\xd7\xae\x5c\x3c\xc9\x11\x21\xab\x32\xf3\x1a\x72\x68\x23\xfe\x1b"
           "\x0f\xb5\x61\xa0\x68\x26\x37\xa6\x10\x1e\x97\x91\x03\x1c\xf4\xba"
           "\x2a\xa0",
           98);
    *(uint16_t*)0x20003f00 = 0x24;
    *(uint16_t*)0x20003f02 = 1;
    memcpy((void*)0x20003f04, "security\000\000\000\000\000\000\000\000\000\000"
                              "\000\000\000\000\000\000\000\000\000\000\000\000"
                              "\000\000",
           32);
    *(uint16_t*)0x20003f24 = 0x2a;
    *(uint16_t*)0x20003f26 = 6;
    *(uint16_t*)0x20003f28 = 0x200;
    memcpy((void*)0x20003f2a, "filter\000\000\000\000\000\000\000\000\000\000"
                              "\000\000\000\000\000\000\000\000\000\000\000\000"
                              "\000\000\000\000",
           32);
    *(uint8_t*)0x20003f4a = 4;
    *(uint16_t*)0x20003f4c = 4;
    *(uint16_t*)0x20003f50 = 0x8b;
    *(uint16_t*)0x20003f52 = 6;
    memcpy((void*)0x20003f54,
           "\xf2\x7c\xea\x80\x4d\x3e\x40\x88\xbb\xd9\x7b\x00\x52\x01\x0c\x08"
           "\x6a\x24\x95\xb6\x1e\x1b\x35\x58\xc9\x35\x07\x99\x60\x92\x33\xa7"
           "\x5b\xba\xe4\x89\xa5\x83\xb5\xaf\xc4\xda\x5b\x00\x5b\x47\x3f\xec"
           "\x2d\x0b\x3f\xf9\xf1\x3d\xaf\x4c\x16\x6d\x4f\x01\xb0\x96\xbc\x55"
           "\x1e\xfe\xa4\x1b\xc8\x2f\x4d\x88\xd6\x52\xde\x70\x78\x5d\xe4\x7a"
           "\x1d\xce\x58\xe2\x0b\x12\x2e\x68\xbb\xa5\xf4\x83\xf0\xda\xe9\x10"
           "\xd7\x8b\x79\xf3\xeb\xa4\x1e\x95\x1f\x91\x69\xbb\x82\x06\xc6\x76"
           "\xa1\xe9\x68\xa6\xde\x64\xc2\x2a\x84\x48\xab\xd8\x35\xc9\x3f\xdd"
           "\x55\xa5\x7a\x87\x32\x78\xd7",
           135);
    *(uint16_t*)0x20003fdc = 0xc;
    *(uint16_t*)0x20003fde = 7;
    *(uint32_t*)0x20003fe0 = 0;
    *(uint32_t*)0x20003fe4 = 0;
    *(uint16_t*)0x20003fe8 = 0xc;
    *(uint16_t*)0x20003fea = 8;
    *(uint32_t*)0x20003fec = 0;
    *(uint32_t*)0x20003ff0 = 1;
    *(uint16_t*)0x20003ff4 = 0x12c;
    STORE_BY_BITMASK(uint16_t, , 0x20003ff6, 0x1e, 0, 14);
    STORE_BY_BITMASK(uint16_t, , 0x20003ff7, 0, 6, 1);
    STORE_BY_BITMASK(uint16_t, , 0x20003ff7, 0, 7, 1);
    *(uint16_t*)0x20003ff8 = 8;
    *(uint16_t*)0x20003ffa = 1;
    memcpy((void*)0x20003ffc, "ipt\000", 4);
    *(uint16_t*)0x20004000 = 0x7c;
    STORE_BY_BITMASK(uint16_t, , 0x20004002, 2, 0, 14);
    STORE_BY_BITMASK(uint16_t, , 0x20004003, 0, 6, 1);
    STORE_BY_BITMASK(uint16_t, , 0x20004003, 1, 7, 1);
    *(uint16_t*)0x20004004 = 0x24;
    *(uint16_t*)0x20004006 = 1;
    memcpy((void*)0x20004008, "mangle\000\000\000\000\000\000\000\000\000\000"
                              "\000\000\000\000\000\000\000\000\000\000\000\000"
                              "\000\000\000\000",
           32);
    *(uint16_t*)0x20004028 = 0x2e;
    *(uint16_t*)0x2000402a = 6;
    *(uint16_t*)0x2000402c = 6;
    memcpy((void*)0x2000402e, "mangle\000\000\000\000\000\000\000\000\000\000"
                              "\000\000\000\000\000\000\000\000\000\000\000\000"
                              "\000\000\000\000",
           32);
    *(uint8_t*)0x2000404e = 5;
    *(uint16_t*)0x20004050 = 0x7f;
    memcpy((void*)0x20004052, "\xcd\x92\xaf\x1a", 4);
    *(uint16_t*)0x20004058 = 0x24;
    *(uint16_t*)0x2000405a = 1;
    memcpy((void*)0x2000405c, "filter\000\000\000\000\000\000\000\000\000\000"
                              "\000\000\000\000\000\000\000\000\000\000\000\000"
                              "\000\000\000\000",
           32);
    *(uint16_t*)0x2000407c = 0x89;
    *(uint16_t*)0x2000407e = 6;
    memcpy((void*)0x20004080,
           "\x22\x0c\xde\x9a\xf9\xd4\x75\xb4\x4c\xe4\x4c\x30\xd0\xc2\xb3\x1f"
           "\x10\x28\x77\xfc\xfe\x61\xdd\xd0\x1f\x02\x2f\x61\x73\x12\x60\x56"
           "\x84\xba\xa7\xc7\xa1\x47\xde\x47\x7c\x02\x23\x4c\xe4\x14\x7b\x07"
           "\xb0\x08\x2b\x0a\x39\x6e\xd1\xcc\x53\xe6\xd2\x0a\x78\xe0\x47\x5b"
           "\x1d\x02\x88\x95\x44\xd4\x8a\x93\xe5\x3b\xa1\x0f\xdc\xb0\x4a\xca"
           "\x03\xb6\x6e\x5d\x1f\x9a\xe7\xa5\x9c\x69\x5c\xee\x23\xd9\xe1\x94"
           "\xd2\xdb\x72\x55\x73\xfc\xe2\xae\x96\x2f\x2e\x53\x86\xe7\xd0\xc8"
           "\xeb\x0c\x88\xdf\x7e\x71\xad\xe2\x8a\xd7\xc7\x87\x22\xa2\x36\xd8"
           "\xe5\xaf\x29\x3e\x78",
           133);
    *(uint16_t*)0x20004108 = 0xc;
    *(uint16_t*)0x2000410a = 7;
    *(uint32_t*)0x2000410c = 1;
    *(uint32_t*)0x20004110 = 0;
    *(uint16_t*)0x20004114 = 0xc;
    *(uint16_t*)0x20004116 = 8;
    *(uint32_t*)0x20004118 = 2;
    *(uint32_t*)0x2000411c = 2;
    *(uint16_t*)0x20004120 = 0x120;
    STORE_BY_BITMASK(uint16_t, , 0x20004122, 0x1f, 0, 14);
    STORE_BY_BITMASK(uint16_t, , 0x20004123, 0, 6, 1);
    STORE_BY_BITMASK(uint16_t, , 0x20004123, 0, 7, 1);
    *(uint16_t*)0x20004124 = 0xb;
    *(uint16_t*)0x20004126 = 1;
    memcpy((void*)0x20004128, "mirred\000", 7);
    *(uint16_t*)0x20004130 = 0x84;
    STORE_BY_BITMASK(uint16_t, , 0x20004132, 2, 0, 14);
    STORE_BY_BITMASK(uint16_t, , 0x20004133, 0, 6, 1);
    STORE_BY_BITMASK(uint16_t, , 0x20004133, 1, 7, 1);
    *(uint16_t*)0x20004134 = 0x20;
    *(uint16_t*)0x20004136 = 2;
    *(uint32_t*)0x20004138 = 0xfffeffff;
    *(uint32_t*)0x2000413c = 8;
    *(uint32_t*)0x20004140 = -1;
    *(uint32_t*)0x20004144 = 7;
    *(uint32_t*)0x20004148 = 0x3ff;
    *(uint32_t*)0x2000414c = 3;
    *(uint32_t*)0x20004150 = 0;
    *(uint16_t*)0x20004154 = 0x20;
    *(uint16_t*)0x20004156 = 2;
    *(uint32_t*)0x20004158 = 9;
    *(uint32_t*)0x2000415c = 0x50;
    *(uint32_t*)0x20004160 = 4;
    *(uint32_t*)0x20004164 = 0xffffff7f;
    *(uint32_t*)0x20004168 = 8;
    *(uint32_t*)0x2000416c = 2;
    *(uint32_t*)0x20004170 = r[1];
    *(uint16_t*)0x20004174 = 0x20;
    *(uint16_t*)0x20004176 = 2;
    *(uint32_t*)0x20004178 = 0x1800000;
    *(uint32_t*)0x2000417c = 8;
    *(uint32_t*)0x20004180 = 1;
    *(uint32_t*)0x20004184 = 0x548b;
    *(uint32_t*)0x20004188 = 1;
    *(uint32_t*)0x2000418c = 2;
    *(uint32_t*)0x20004190 = 0;
    *(uint16_t*)0x20004194 = 0x20;
    *(uint16_t*)0x20004196 = 2;
    *(uint32_t*)0x20004198 = 7;
    *(uint32_t*)0x2000419c = 7;
    *(uint32_t*)0x200041a0 = 0x20000000;
    *(uint32_t*)0x200041a4 = 2;
    *(uint32_t*)0x200041a8 = 4;
    *(uint32_t*)0x200041ac = 2;
    *(uint32_t*)0x200041b0 = 0;
    *(uint16_t*)0x200041b4 = 0x74;
    *(uint16_t*)0x200041b6 = 6;
    memcpy((void*)0x200041b8,
           "\xa2\xd6\xce\x61\x32\xc5\xb9\xea\x83\x84\xc1\x0f\xe2\xe3\xe4\x0a"
           "\xc3\x0c\xad\x46\xa8\xe6\xd4\xab\xef\xb9\x88\x66\x4e\x3c\x9a\x81"
           "\x2e\x32\x39\x85\x6b\x15\xcb\x37\xf9\xce\x98\x5a\xcc\x30\x36\x35"
           "\x1f\xc8\xbb\xaa\xf7\x8e\xf7\x4d\x5a\xff\x97\x2a\x12\x83\xc3\x22"
           "\xc0\xaa\xca\xf9\x60\xc2\xc3\x84\x33\x31\x4b\xbd\xdd\xdc\xdc\xe8"
           "\x8f\xeb\xdd\x29\x9e\x2c\xcd\xf5\x41\x00\xed\x15\x5b\xd3\xcb\x7f"
           "\xd7\x98\xd2\x47\x02\xfa\xab\xdc\xf8\x2a\xfb\x4d\xab\x57\x11\x3c",
           112);
    *(uint16_t*)0x20004228 = 0xc;
    *(uint16_t*)0x2000422a = 7;
    *(uint32_t*)0x2000422c = 1;
    *(uint32_t*)0x20004230 = 0;
    *(uint16_t*)0x20004234 = 0xc;
    *(uint16_t*)0x20004236 = 8;
    *(uint32_t*)0x20004238 = 1;
    *(uint32_t*)0x2000423c = 0;
    *(uint16_t*)0x20004240 = 8;
    *(uint16_t*)0x20004242 = 1;
    *(uint32_t*)0x20004244 = 0xa4a0;
    *(uint16_t*)0x20004248 = 0x818;
    *(uint16_t*)0x2000424a = 6;
    *(uint16_t*)0x2000424c = 0x404;
    *(uint16_t*)0x2000424e = 3;
    *(uint32_t*)0x20004250 = 0xfffffffd;
    *(uint32_t*)0x20004254 = 3;
    *(uint32_t*)0x20004258 = 6;
    *(uint32_t*)0x2000425c = 8;
    *(uint32_t*)0x20004260 = 0x3f;
    *(uint32_t*)0x20004264 = 0x101;
    *(uint32_t*)0x20004268 = 7;
    *(uint32_t*)0x2000426c = 0;
    *(uint32_t*)0x20004270 = 0x8001;
    *(uint32_t*)0x20004274 = 0x80000000;
    *(uint32_t*)0x20004278 = 1;
    *(uint32_t*)0x2000427c = 0xa7;
    *(uint32_t*)0x20004280 = 7;
    *(uint32_t*)0x20004284 = 8;
    *(uint32_t*)0x20004288 = 2;
    *(uint32_t*)0x2000428c = 0x1a;
    *(uint32_t*)0x20004290 = 0x401;
    *(uint32_t*)0x20004294 = 7;
    *(uint32_t*)0x20004298 = 0x20;
    *(uint32_t*)0x2000429c = 0x20;
    *(uint32_t*)0x200042a0 = 6;
    *(uint32_t*)0x200042a4 = 0x10000;
    *(uint32_t*)0x200042a8 = 0x2463;
    *(uint32_t*)0x200042ac = 8;
    *(uint32_t*)0x200042b0 = 4;
    *(uint32_t*)0x200042b4 = 0x1fc;
    *(uint32_t*)0x200042b8 = 0xff;
    *(uint32_t*)0x200042bc = 0xbb;
    *(uint32_t*)0x200042c0 = 0;
    *(uint32_t*)0x200042c4 = 3;
    *(uint32_t*)0x200042c8 = 0xfffffff8;
    *(uint32_t*)0x200042cc = 0x7fffffff;
    *(uint32_t*)0x200042d0 = 0x5e;
    *(uint32_t*)0x200042d4 = 0xba0d;
    *(uint32_t*)0x200042d8 = 9;
    *(uint32_t*)0x200042dc = 8;
    *(uint32_t*)0x200042e0 = 7;
    *(uint32_t*)0x200042e4 = 4;
    *(uint32_t*)0x200042e8 = 0x1ff;
    *(uint32_t*)0x200042ec = 4;
    *(uint32_t*)0x200042f0 = 0xfffffffe;
    *(uint32_t*)0x200042f4 = 0;
    *(uint32_t*)0x200042f8 = 9;
    *(uint32_t*)0x200042fc = 0x7fffffff;
    *(uint32_t*)0x20004300 = 0xcdd5;
    *(uint32_t*)0x20004304 = 0x528a;
    *(uint32_t*)0x20004308 = 7;
    *(uint32_t*)0x2000430c = 0x280;
    *(uint32_t*)0x20004310 = 0x80;
    *(uint32_t*)0x20004314 = 0x7f;
    *(uint32_t*)0x20004318 = 0xc4;
    *(uint32_t*)0x2000431c = 0xfffeffff;
    *(uint32_t*)0x20004320 = 0;
    *(uint32_t*)0x20004324 = 8;
    *(uint32_t*)0x20004328 = 0x3ff;
    *(uint32_t*)0x2000432c = 6;
    *(uint32_t*)0x20004330 = 0;
    *(uint32_t*)0x20004334 = 0x3079;
    *(uint32_t*)0x20004338 = 0x30;
    *(uint32_t*)0x2000433c = 6;
    *(uint32_t*)0x20004340 = 0x7fffffff;
    *(uint32_t*)0x20004344 = 5;
    *(uint32_t*)0x20004348 = 1;
    *(uint32_t*)0x2000434c = 4;
    *(uint32_t*)0x20004350 = 0x7fff;
    *(uint32_t*)0x20004354 = 9;
    *(uint32_t*)0x20004358 = 8;
    *(uint32_t*)0x2000435c = 1;
    *(uint32_t*)0x20004360 = 0x1000;
    *(uint32_t*)0x20004364 = 9;
    *(uint32_t*)0x20004368 = 0x40;
    *(uint32_t*)0x2000436c = 0xffff;
    *(uint32_t*)0x20004370 = 0x24;
    *(uint32_t*)0x20004374 = 0xb8ce;
    *(uint32_t*)0x20004378 = 0;
    *(uint32_t*)0x2000437c = 0xe00;
    *(uint32_t*)0x20004380 = 3;
    *(uint32_t*)0x20004384 = 0;
    *(uint32_t*)0x20004388 = 0;
    *(uint32_t*)0x2000438c = 7;
    *(uint32_t*)0x20004390 = 1;
    *(uint32_t*)0x20004394 = 7;
    *(uint32_t*)0x20004398 = 7;
    *(uint32_t*)0x2000439c = 0xc3;
    *(uint32_t*)0x200043a0 = 0;
    *(uint32_t*)0x200043a4 = 0x9c14;
    *(uint32_t*)0x200043a8 = 0x10000;
    *(uint32_t*)0x200043ac = 0xa7;
    *(uint32_t*)0x200043b0 = 0x81;
    *(uint32_t*)0x200043b4 = 2;
    *(uint32_t*)0x200043b8 = 0x800;
    *(uint32_t*)0x200043bc = 4;
    *(uint32_t*)0x200043c0 = 0xd3;
    *(uint32_t*)0x200043c4 = 2;
    *(uint32_t*)0x200043c8 = 0x3f;
    *(uint32_t*)0x200043cc = 0x86b7;
    *(uint32_t*)0x200043d0 = 0xea;
    *(uint32_t*)0x200043d4 = 0x33;
    *(uint32_t*)0x200043d8 = 0xca36;
    *(uint32_t*)0x200043dc = 0x200;
    *(uint32_t*)0x200043e0 = 4;
    *(uint32_t*)0x200043e4 = 0x80000000;
    *(uint32_t*)0x200043e8 = 7;
    *(uint32_t*)0x200043ec = 7;
    *(uint32_t*)0x200043f0 = 9;
    *(uint32_t*)0x200043f4 = 2;
    *(uint32_t*)0x200043f8 = 0xfffffffc;
    *(uint32_t*)0x200043fc = 8;
    *(uint32_t*)0x20004400 = 8;
    *(uint32_t*)0x20004404 = 1;
    *(uint32_t*)0x20004408 = 0x7fffffff;
    *(uint32_t*)0x2000440c = 3;
    *(uint32_t*)0x20004410 = 0xd7;
    *(uint32_t*)0x20004414 = 7;
    *(uint32_t*)0x20004418 = 0x8000;
    *(uint32_t*)0x2000441c = 2;
    *(uint32_t*)0x20004420 = 0x8001;
    *(uint32_t*)0x20004424 = 9;
    *(uint32_t*)0x20004428 = 9;
    *(uint32_t*)0x2000442c = 0;
    *(uint32_t*)0x20004430 = 0xfffffffd;
    *(uint32_t*)0x20004434 = 0x80;
    *(uint32_t*)0x20004438 = 0x1ff;
    *(uint32_t*)0x2000443c = 0x3ff;
    *(uint32_t*)0x20004440 = 0x1f;
    *(uint32_t*)0x20004444 = 0x10001;
    *(uint32_t*)0x20004448 = 0x1000;
    *(uint32_t*)0x2000444c = 0x3f;
    *(uint32_t*)0x20004450 = 9;
    *(uint32_t*)0x20004454 = 0x7fff;
    *(uint32_t*)0x20004458 = 0xffffffc4;
    *(uint32_t*)0x2000445c = 7;
    *(uint32_t*)0x20004460 = 0x80000001;
    *(uint32_t*)0x20004464 = 6;
    *(uint32_t*)0x20004468 = 9;
    *(uint32_t*)0x2000446c = 6;
    *(uint32_t*)0x20004470 = 4;
    *(uint32_t*)0x20004474 = 8;
    *(uint32_t*)0x20004478 = 2;
    *(uint32_t*)0x2000447c = 9;
    *(uint32_t*)0x20004480 = 0;
    *(uint32_t*)0x20004484 = 6;
    *(uint32_t*)0x20004488 = 0x401;
    *(uint32_t*)0x2000448c = 8;
    *(uint32_t*)0x20004490 = 8;
    *(uint32_t*)0x20004494 = 1;
    *(uint32_t*)0x20004498 = 0x9f;
    *(uint32_t*)0x2000449c = 0x963;
    *(uint32_t*)0x200044a0 = 0;
    *(uint32_t*)0x200044a4 = 0x5bf;
    *(uint32_t*)0x200044a8 = 4;
    *(uint32_t*)0x200044ac = 2;
    *(uint32_t*)0x200044b0 = 0xfffffff9;
    *(uint32_t*)0x200044b4 = 4;
    *(uint32_t*)0x200044b8 = -1;
    *(uint32_t*)0x200044bc = 6;
    *(uint32_t*)0x200044c0 = 4;
    *(uint32_t*)0x200044c4 = 0xfc;
    *(uint32_t*)0x200044c8 = 9;
    *(uint32_t*)0x200044cc = 0x20;
    *(uint32_t*)0x200044d0 = 8;
    *(uint32_t*)0x200044d4 = 0;
    *(uint32_t*)0x200044d8 = 0;
    *(uint32_t*)0x200044dc = 0x80000000;
    *(uint32_t*)0x200044e0 = 8;
    *(uint32_t*)0x200044e4 = 0x401;
    *(uint32_t*)0x200044e8 = 0;
    *(uint32_t*)0x200044ec = 1;
    *(uint32_t*)0x200044f0 = 0x7fffffff;
    *(uint32_t*)0x200044f4 = 0x81;
    *(uint32_t*)0x200044f8 = 3;
    *(uint32_t*)0x200044fc = 0;
    *(uint32_t*)0x20004500 = 4;
    *(uint32_t*)0x20004504 = 8;
    *(uint32_t*)0x20004508 = 0x1ff;
    *(uint32_t*)0x2000450c = 0x200000;
    *(uint32_t*)0x20004510 = 6;
    *(uint32_t*)0x20004514 = 0x8001;
    *(uint32_t*)0x20004518 = 0x10000;
    *(uint32_t*)0x2000451c = 3;
    *(uint32_t*)0x20004520 = 0;
    *(uint32_t*)0x20004524 = 0;
    *(uint32_t*)0x20004528 = 0x80000000;
    *(uint32_t*)0x2000452c = 0xfffffffd;
    *(uint32_t*)0x20004530 = 6;
    *(uint32_t*)0x20004534 = 8;
    *(uint32_t*)0x20004538 = 0x532b;
    *(uint32_t*)0x2000453c = 0x400;
    *(uint32_t*)0x20004540 = 1;
    *(uint32_t*)0x20004544 = 5;
    *(uint32_t*)0x20004548 = 0;
    *(uint32_t*)0x2000454c = 1;
    *(uint32_t*)0x20004550 = 0x6c;
    *(uint32_t*)0x20004554 = 0x3f;
    *(uint32_t*)0x20004558 = 1;
    *(uint32_t*)0x2000455c = 5;
    *(uint32_t*)0x20004560 = 1;
    *(uint32_t*)0x20004564 = 4;
    *(uint32_t*)0x20004568 = 1;
    *(uint32_t*)0x2000456c = 1;
    *(uint32_t*)0x20004570 = 4;
    *(uint32_t*)0x20004574 = 0x1f;
    *(uint32_t*)0x20004578 = 7;
    *(uint32_t*)0x2000457c = 0xfffffffe;
    *(uint32_t*)0x20004580 = 2;
    *(uint32_t*)0x20004584 = 0x401;
    *(uint32_t*)0x20004588 = 1;
    *(uint32_t*)0x2000458c = 2;
    *(uint32_t*)0x20004590 = 9;
    *(uint32_t*)0x20004594 = 5;
    *(uint32_t*)0x20004598 = 0x1000;
    *(uint32_t*)0x2000459c = 2;
    *(uint32_t*)0x200045a0 = 0x2d70;
    *(uint32_t*)0x200045a4 = 0x7ff;
    *(uint32_t*)0x200045a8 = 0x800;
    *(uint32_t*)0x200045ac = 8;
    *(uint32_t*)0x200045b0 = 0xc95;
    *(uint32_t*)0x200045b4 = 5;
    *(uint32_t*)0x200045b8 = 7;
    *(uint32_t*)0x200045bc = 3;
    *(uint32_t*)0x200045c0 = 6;
    *(uint32_t*)0x200045c4 = 9;
    *(uint32_t*)0x200045c8 = 6;
    *(uint32_t*)0x200045cc = 9;
    *(uint32_t*)0x200045d0 = 0xffffe513;
    *(uint32_t*)0x200045d4 = 6;
    *(uint32_t*)0x200045d8 = 2;
    *(uint32_t*)0x200045dc = 0xfffffffd;
    *(uint32_t*)0x200045e0 = 0x1f;
    *(uint32_t*)0x200045e4 = 4;
    *(uint32_t*)0x200045e8 = 7;
    *(uint32_t*)0x200045ec = 0;
    *(uint32_t*)0x200045f0 = 4;
    *(uint32_t*)0x200045f4 = 1;
    *(uint32_t*)0x200045f8 = 6;
    *(uint32_t*)0x200045fc = 5;
    *(uint32_t*)0x20004600 = 8;
    *(uint32_t*)0x20004604 = 0;
    *(uint32_t*)0x20004608 = 0x140;
    *(uint32_t*)0x2000460c = 0xff;
    *(uint32_t*)0x20004610 = 0x394;
    *(uint32_t*)0x20004614 = 0xff;
    *(uint32_t*)0x20004618 = 6;
    *(uint32_t*)0x2000461c = 3;
    *(uint32_t*)0x20004620 = 0xc6f;
    *(uint32_t*)0x20004624 = 0x8000;
    *(uint32_t*)0x20004628 = 0xfffffe00;
    *(uint32_t*)0x2000462c = 7;
    *(uint32_t*)0x20004630 = 7;
    *(uint32_t*)0x20004634 = -1;
    *(uint32_t*)0x20004638 = 1;
    *(uint32_t*)0x2000463c = 0xfffffffa;
    *(uint32_t*)0x20004640 = 0x800;
    *(uint32_t*)0x20004644 = 1;
    *(uint32_t*)0x20004648 = 0;
    *(uint32_t*)0x2000464c = 0xffff;
    *(uint16_t*)0x20004650 = 0x404;
    *(uint16_t*)0x20004652 = 3;
    *(uint32_t*)0x20004654 = 6;
    *(uint32_t*)0x20004658 = 0x10001;
    *(uint32_t*)0x2000465c = 0x280;
    *(uint32_t*)0x20004660 = 6;
    *(uint32_t*)0x20004664 = 9;
    *(uint32_t*)0x20004668 = 0x10000000;
    *(uint32_t*)0x2000466c = 8;
    *(uint32_t*)0x20004670 = 3;
    *(uint32_t*)0x20004674 = -1;
    *(uint32_t*)0x20004678 = 7;
    *(uint32_t*)0x2000467c = 9;
    *(uint32_t*)0x20004680 = 1;
    *(uint32_t*)0x20004684 = 3;
    *(uint32_t*)0x20004688 = 0xa2b9;
    *(uint32_t*)0x2000468c = 0;
    *(uint32_t*)0x20004690 = 8;
    *(uint32_t*)0x20004694 = 7;
    *(uint32_t*)0x20004698 = 3;
    *(uint32_t*)0x2000469c = 0xda4c;
    *(uint32_t*)0x200046a0 = 0xcc89;
    *(uint32_t*)0x200046a4 = 3;
    *(uint32_t*)0x200046a8 = 0x42;
    *(uint32_t*)0x200046ac = 5;
    *(uint32_t*)0x200046b0 = 0xff;
    *(uint32_t*)0x200046b4 = 0x7ff;
    *(uint32_t*)0x200046b8 = 0x1000;
    *(uint32_t*)0x200046bc = 0xff;
    *(uint32_t*)0x200046c0 = 0;
    *(uint32_t*)0x200046c4 = 8;
    *(uint32_t*)0x200046c8 = 0x10000;
    *(uint32_t*)0x200046cc = 0xfffffffc;
    *(uint32_t*)0x200046d0 = 2;
    *(uint32_t*)0x200046d4 = 2;
    *(uint32_t*)0x200046d8 = 0x8157;
    *(uint32_t*)0x200046dc = 7;
    *(uint32_t*)0x200046e0 = 0x80;
    *(uint32_t*)0x200046e4 = 4;
    *(uint32_t*)0x200046e8 = 0xbd0;
    *(uint32_t*)0x200046ec = 0x2e4f;
    *(uint32_t*)0x200046f0 = 0x101;
    *(uint32_t*)0x200046f4 = 0x80;
    *(uint32_t*)0x200046f8 = 9;
    *(uint32_t*)0x200046fc = 0xf48b;
    *(uint32_t*)0x20004700 = 0x63;
    *(uint32_t*)0x20004704 = 2;
    *(uint32_t*)0x20004708 = 0xa0;
    *(uint32_t*)0x2000470c = 0x1489;
    *(uint32_t*)0x20004710 = 0xf0;
    *(uint32_t*)0x20004714 = 0x80;
    *(uint32_t*)0x20004718 = 0x1f;
    *(uint32_t*)0x2000471c = 0xa6;
    *(uint32_t*)0x20004720 = 0xfffffffd;
    *(uint32_t*)0x20004724 = 6;
    *(uint32_t*)0x20004728 = 0xfffffffe;
    *(uint32_t*)0x2000472c = 0x800;
    *(uint32_t*)0x20004730 = 5;
    *(uint32_t*)0x20004734 = 9;
    *(uint32_t*)0x20004738 = 4;
    *(uint32_t*)0x2000473c = 0x300000;
    *(uint32_t*)0x20004740 = 0x20;
    *(uint32_t*)0x20004744 = 8;
    *(uint32_t*)0x20004748 = 6;
    *(uint32_t*)0x2000474c = 0x8000;
    *(uint32_t*)0x20004750 = 7;
    *(uint32_t*)0x20004754 = 0x200;
    *(uint32_t*)0x20004758 = 0;
    *(uint32_t*)0x2000475c = 2;
    *(uint32_t*)0x20004760 = 0x763;
    *(uint32_t*)0x20004764 = 0x800;
    *(uint32_t*)0x20004768 = 9;
    *(uint32_t*)0x2000476c = 0xfffffffd;
    *(uint32_t*)0x20004770 = 0x75;
    *(uint32_t*)0x20004774 = 2;
    *(uint32_t*)0x20004778 = 0x400;
    *(uint32_t*)0x2000477c = 0xfffffffd;
    *(uint32_t*)0x20004780 = 0x10001;
    *(uint32_t*)0x20004784 = 0xa3d1;
    *(uint32_t*)0x20004788 = 0;
    *(uint32_t*)0x2000478c = 0x56b;
    *(uint32_t*)0x20004790 = 4;
    *(uint32_t*)0x20004794 = 1;
    *(uint32_t*)0x20004798 = 4;
    *(uint32_t*)0x2000479c = 5;
    *(uint32_t*)0x200047a0 = 0xffffffad;
    *(uint32_t*)0x200047a4 = 9;
    *(uint32_t*)0x200047a8 = 0;
    *(uint32_t*)0x200047ac = 0x2000;
    *(uint32_t*)0x200047b0 = 8;
    *(uint32_t*)0x200047b4 = 5;
    *(uint32_t*)0x200047b8 = 8;
    *(uint32_t*)0x200047bc = 0xf5;
    *(uint32_t*)0x200047c0 = 2;
    *(uint32_t*)0x200047c4 = 0x2ec;
    *(uint32_t*)0x200047c8 = 0;
    *(uint32_t*)0x200047cc = 0;
    *(uint32_t*)0x200047d0 = 3;
    *(uint32_t*)0x200047d4 = 2;
    *(uint32_t*)0x200047d8 = 0x100;
    *(uint32_t*)0x200047dc = 0xffff;
    *(uint32_t*)0x200047e0 = 3;
    *(uint32_t*)0x200047e4 = -1;
    *(uint32_t*)0x200047e8 = 0xa4f;
    *(uint32_t*)0x200047ec = 0x70;
    *(uint32_t*)0x200047f0 = 0x40;
    *(uint32_t*)0x200047f4 = 0x81;
    *(uint32_t*)0x200047f8 = 0;
    *(uint32_t*)0x200047fc = 3;
    *(uint32_t*)0x20004800 = 0x400;
    *(uint32_t*)0x20004804 = 1;
    *(uint32_t*)0x20004808 = 0x99b;
    *(uint32_t*)0x2000480c = 0x8c;
    *(uint32_t*)0x20004810 = 0x800;
    *(uint32_t*)0x20004814 = 0xa6;
    *(uint32_t*)0x20004818 = 6;
    *(uint32_t*)0x2000481c = 0x7ff;
    *(uint32_t*)0x20004820 = 7;
    *(uint32_t*)0x20004824 = 0x19;
    *(uint32_t*)0x20004828 = 0x1ff;
    *(uint32_t*)0x2000482c = 6;
    *(uint32_t*)0x20004830 = 4;
    *(uint32_t*)0x20004834 = 3;
    *(uint32_t*)0x20004838 = 0x80000000;
    *(uint32_t*)0x2000483c = 7;
    *(uint32_t*)0x20004840 = 0x38000;
    *(uint32_t*)0x20004844 = 0x1f;
    *(uint32_t*)0x20004848 = 0x400;
    *(uint32_t*)0x2000484c = 3;
    *(uint32_t*)0x20004850 = 0x35ec;
    *(uint32_t*)0x20004854 = 0xe38;
    *(uint32_t*)0x20004858 = 4;
    *(uint32_t*)0x2000485c = 5;
    *(uint32_t*)0x20004860 = 0xffff;
    *(uint32_t*)0x20004864 = -1;
    *(uint32_t*)0x20004868 = 9;
    *(uint32_t*)0x2000486c = 9;
    *(uint32_t*)0x20004870 = 0x593;
    *(uint32_t*)0x20004874 = 0xff;
    *(uint32_t*)0x20004878 = 1;
    *(uint32_t*)0x2000487c = 0x10000;
    *(uint32_t*)0x20004880 = 8;
    *(uint32_t*)0x20004884 = 1;
    *(uint32_t*)0x20004888 = 6;
    *(uint32_t*)0x2000488c = 9;
    *(uint32_t*)0x20004890 = 3;
    *(uint32_t*)0x20004894 = 0;
    *(uint32_t*)0x20004898 = 6;
    *(uint32_t*)0x2000489c = 0xffff0001;
    *(uint32_t*)0x200048a0 = 0x100;
    *(uint32_t*)0x200048a4 = 0x4c6c;
    *(uint32_t*)0x200048a8 = 1;
    *(uint32_t*)0x200048ac = 0x80000000;
    *(uint32_t*)0x200048b0 = 7;
    *(uint32_t*)0x200048b4 = 0x3f;
    *(uint32_t*)0x200048b8 = 0x10000;
    *(uint32_t*)0x200048bc = 0x2d0;
    *(uint32_t*)0x200048c0 = 8;
    *(uint32_t*)0x200048c4 = 2;
    *(uint32_t*)0x200048c8 = 0x7fff;
    *(uint32_t*)0x200048cc = 9;
    *(uint32_t*)0x200048d0 = 3;
    *(uint32_t*)0x200048d4 = 0x51;
    *(uint32_t*)0x200048d8 = 0x1000;
    *(uint32_t*)0x200048dc = 0x81;
    *(uint32_t*)0x200048e0 = 0x8001;
    *(uint32_t*)0x200048e4 = 0xd5;
    *(uint32_t*)0x200048e8 = 2;
    *(uint32_t*)0x200048ec = 1;
    *(uint32_t*)0x200048f0 = 0x76c253fc;
    *(uint32_t*)0x200048f4 = 0xc2;
    *(uint32_t*)0x200048f8 = 8;
    *(uint32_t*)0x200048fc = 4;
    *(uint32_t*)0x20004900 = 0x40000;
    *(uint32_t*)0x20004904 = 0x8cb7;
    *(uint32_t*)0x20004908 = 4;
    *(uint32_t*)0x2000490c = 0xff;
    *(uint32_t*)0x20004910 = 0x3ff;
    *(uint32_t*)0x20004914 = 3;
    *(uint32_t*)0x20004918 = 3;
    *(uint32_t*)0x2000491c = 0xb;
    *(uint32_t*)0x20004920 = 2;
    *(uint32_t*)0x20004924 = 3;
    *(uint32_t*)0x20004928 = 0x16;
    *(uint32_t*)0x2000492c = 0x180;
    *(uint32_t*)0x20004930 = 2;
    *(uint32_t*)0x20004934 = 6;
    *(uint32_t*)0x20004938 = 4;
    *(uint32_t*)0x2000493c = 0xec;
    *(uint32_t*)0x20004940 = 7;
    *(uint32_t*)0x20004944 = 0x800;
    *(uint32_t*)0x20004948 = 6;
    *(uint32_t*)0x2000494c = 0;
    *(uint32_t*)0x20004950 = 0;
    *(uint32_t*)0x20004954 = 6;
    *(uint32_t*)0x20004958 = 1;
    *(uint32_t*)0x2000495c = 0x87df;
    *(uint32_t*)0x20004960 = 3;
    *(uint32_t*)0x20004964 = 7;
    *(uint32_t*)0x20004968 = 5;
    *(uint32_t*)0x2000496c = 4;
    *(uint32_t*)0x20004970 = 0x7fff;
    *(uint32_t*)0x20004974 = 0;
    *(uint32_t*)0x20004978 = 1;
    *(uint32_t*)0x2000497c = 7;
    *(uint32_t*)0x20004980 = 0x1c000;
    *(uint32_t*)0x20004984 = 0x124;
    *(uint32_t*)0x20004988 = 0;
    *(uint32_t*)0x2000498c = 2;
    *(uint32_t*)0x20004990 = 4;
    *(uint32_t*)0x20004994 = 4;
    *(uint32_t*)0x20004998 = 5;
    *(uint32_t*)0x2000499c = 8;
    *(uint32_t*)0x200049a0 = 3;
    *(uint32_t*)0x200049a4 = 4;
    *(uint32_t*)0x200049a8 = 0x31;
    *(uint32_t*)0x200049ac = 8;
    *(uint32_t*)0x200049b0 = 0x8001;
    *(uint32_t*)0x200049b4 = 0x1f;
    *(uint32_t*)0x200049b8 = 0x7ff;
    *(uint32_t*)0x200049bc = 0x80000000;
    *(uint32_t*)0x200049c0 = 0xfffff5ce;
    *(uint32_t*)0x200049c4 = 1;
    *(uint32_t*)0x200049c8 = 0x81;
    *(uint32_t*)0x200049cc = 8;
    *(uint32_t*)0x200049d0 = 5;
    *(uint32_t*)0x200049d4 = 2;
    *(uint32_t*)0x200049d8 = 3;
    *(uint32_t*)0x200049dc = -1;
    *(uint32_t*)0x200049e0 = 0xffff;
    *(uint32_t*)0x200049e4 = 8;
    *(uint32_t*)0x200049e8 = 5;
    *(uint32_t*)0x200049ec = 2;
    *(uint32_t*)0x200049f0 = 5;
    *(uint32_t*)0x200049f4 = 9;
    *(uint32_t*)0x200049f8 = 6;
    *(uint32_t*)0x200049fc = 0xff;
    *(uint32_t*)0x20004a00 = 9;
    *(uint32_t*)0x20004a04 = 0;
    *(uint32_t*)0x20004a08 = 4;
    *(uint32_t*)0x20004a0c = 6;
    *(uint32_t*)0x20004a10 = 8;
    *(uint32_t*)0x20004a14 = 2;
    *(uint32_t*)0x20004a18 = 6;
    *(uint32_t*)0x20004a1c = 2;
    *(uint32_t*)0x20004a20 = 0x80000000;
    *(uint32_t*)0x20004a24 = 1;
    *(uint32_t*)0x20004a28 = 0;
    *(uint32_t*)0x20004a2c = 0xfffff543;
    *(uint32_t*)0x20004a30 = 1;
    *(uint32_t*)0x20004a34 = 0;
    *(uint32_t*)0x20004a38 = 0x100;
    *(uint32_t*)0x20004a3c = 6;
    *(uint32_t*)0x20004a40 = 0x100;
    *(uint32_t*)0x20004a44 = 0x66;
    *(uint32_t*)0x20004a48 = 3;
    *(uint32_t*)0x20004a4c = 4;
    *(uint32_t*)0x20004a50 = -1;
    *(uint16_t*)0x20004a54 = 0xc;
    *(uint16_t*)0x20004a56 = 9;
    *(uint64_t*)0x20004a58 = 0x8001;
    *(uint16_t*)0x20004a60 = 0x58;
    *(uint16_t*)0x20004a62 = 6;
    *(uint16_t*)0x20004a64 = 0x3c;
    *(uint16_t*)0x20004a66 = 1;
    *(uint32_t*)0x20004a68 = -1;
    *(uint32_t*)0x20004a6c = 5;
    *(uint32_t*)0x20004a70 = 9;
    *(uint32_t*)0x20004a74 = 0;
    *(uint32_t*)0x20004a78 = 0x71e75d9a;
    *(uint8_t*)0x20004a7c = 0x2b;
    *(uint8_t*)0x20004a7d = 2;
    *(uint16_t*)0x20004a7e = 9;
    *(uint16_t*)0x20004a80 = 0xe8;
    *(uint16_t*)0x20004a82 = 3;
    *(uint32_t*)0x20004a84 = 1;
    *(uint8_t*)0x20004a88 = 5;
    *(uint8_t*)0x20004a89 = 2;
    *(uint16_t*)0x20004a8a = 4;
    *(uint16_t*)0x20004a8c = 6;
    *(uint16_t*)0x20004a8e = 4;
    *(uint32_t*)0x20004a90 = 0x8000;
    *(uint32_t*)0x20004a94 = 0x80004;
    *(uint32_t*)0x20004a98 = 9;
    *(uint32_t*)0x20004a9c = 0xf99a;
    *(uint16_t*)0x20004aa0 = 0xc;
    *(uint16_t*)0x20004aa2 = 8;
    *(uint64_t*)0x20004aa4 = 7;
    *(uint16_t*)0x20004aac = 0xc;
    *(uint16_t*)0x20004aae = 8;
    *(uint64_t*)0x20004ab0 = 0;
    *(uint16_t*)0x20004ab8 = 6;
    *(uint16_t*)0x20004aba = 2;
    *(uint16_t*)0x20004abc = 0xf8c0;
    *(uint16_t*)0x20004ac0 = 0x854;
    *(uint16_t*)0x20004ac2 = 6;
    *(uint16_t*)0x20004ac4 = 0xc;
    *(uint16_t*)0x20004ac6 = 8;
    *(uint64_t*)0x20004ac8 = 0x401;
    *(uint16_t*)0x20004ad0 = 8;
    *(uint16_t*)0x20004ad2 = 5;
    *(uint32_t*)0x20004ad4 = 0x400;
    *(uint16_t*)0x20004ad8 = 0xc;
    *(uint16_t*)0x20004ada = 8;
    *(uint64_t*)0x20004adc = 4;
    *(uint16_t*)0x20004ae4 = 8;
    *(uint16_t*)0x20004ae6 = 4;
    *(uint32_t*)0x20004ae8 = 0x6f;
    *(uint16_t*)0x20004aec = 0xc;
    *(uint16_t*)0x20004aee = 8;
    *(uint64_t*)0x20004af0 = 0x1ff;
    *(uint16_t*)0x20004af8 = 0x404;
    *(uint16_t*)0x20004afa = 2;
    *(uint32_t*)0x20004afc = 0x5fc563cf;
    *(uint32_t*)0x20004b00 = 1;
    *(uint32_t*)0x20004b04 = 0x3ff;
    *(uint32_t*)0x20004b08 = 2;
    *(uint32_t*)0x20004b0c = 3;
    *(uint32_t*)0x20004b10 = 3;
    *(uint32_t*)0x20004b14 = 0x7fffffff;
    *(uint32_t*)0x20004b18 = 0x224c1a90;
    *(uint32_t*)0x20004b1c = 0x200;
    *(uint32_t*)0x20004b20 = 5;
    *(uint32_t*)0x20004b24 = -1;
    *(uint32_t*)0x20004b28 = 0xffffff76;
    *(uint32_t*)0x20004b2c = 0xfffffff8;
    *(uint32_t*)0x20004b30 = 0x4881;
    *(uint32_t*)0x20004b34 = 8;
    *(uint32_t*)0x20004b38 = 0x20;
    *(uint32_t*)0x20004b3c = 0x101;
    *(uint32_t*)0x20004b40 = 0xfff;
    *(uint32_t*)0x20004b44 = 7;
    *(uint32_t*)0x20004b48 = 0x23;
    *(uint32_t*)0x20004b4c = 0x23972431;
    *(uint32_t*)0x20004b50 = 0xff;
    *(uint32_t*)0x20004b54 = -1;
    *(uint32_t*)0x20004b58 = 0x20;
    *(uint32_t*)0x20004b5c = 0xeb18;
    *(uint32_t*)0x20004b60 = 0xfff;
    *(uint32_t*)0x20004b64 = 0xede5;
    *(uint32_t*)0x20004b68 = 1;
    *(uint32_t*)0x20004b6c = 5;
    *(uint32_t*)0x20004b70 = 1;
    *(uint32_t*)0x20004b74 = 8;
    *(uint32_t*)0x20004b78 = 1;
    *(uint32_t*)0x20004b7c = 0x7ff;
    *(uint32_t*)0x20004b80 = 0x81;
    *(uint32_t*)0x20004b84 = 5;
    *(uint32_t*)0x20004b88 = 0xb031;
    *(uint32_t*)0x20004b8c = 0x1f;
    *(uint32_t*)0x20004b90 = 0x80;
    *(uint32_t*)0x20004b94 = 0x10001;
    *(uint32_t*)0x20004b98 = 0xc1;
    *(uint32_t*)0x20004b9c = 3;
    *(uint32_t*)0x20004ba0 = 0x31ddab68;
    *(uint32_t*)0x20004ba4 = 0x60;
    *(uint32_t*)0x20004ba8 = 0xffff8000;
    *(uint32_t*)0x20004bac = 7;
    *(uint32_t*)0x20004bb0 = 0x256;
    *(uint32_t*)0x20004bb4 = 9;
    *(uint32_t*)0x20004bb8 = 0xd8;
    *(uint32_t*)0x20004bbc = 4;
    *(uint32_t*)0x20004bc0 = 0xfffffff8;
    *(uint32_t*)0x20004bc4 = 3;
    *(uint32_t*)0x20004bc8 = 0x100;
    *(uint32_t*)0x20004bcc = 0x80000001;
    *(uint32_t*)0x20004bd0 = 0x100;
    *(uint32_t*)0x20004bd4 = 8;
    *(uint32_t*)0x20004bd8 = 0x3fffc0;
    *(uint32_t*)0x20004bdc = 0x80000001;
    *(uint32_t*)0x20004be0 = 0x711;
    *(uint32_t*)0x20004be4 = 0xc2c9;
    *(uint32_t*)0x20004be8 = 8;
    *(uint32_t*)0x20004bec = 0x200;
    *(uint32_t*)0x20004bf0 = 8;
    *(uint32_t*)0x20004bf4 = -1;
    *(uint32_t*)0x20004bf8 = 7;
    *(uint32_t*)0x20004bfc = 0xfffffff8;
    *(uint32_t*)0x20004c00 = 0xc7;
    *(uint32_t*)0x20004c04 = 4;
    *(uint32_t*)0x20004c08 = 0xfffff006;
    *(uint32_t*)0x20004c0c = 0xfffffff8;
    *(uint32_t*)0x20004c10 = 3;
    *(uint32_t*)0x20004c14 = 0x8baa;
    *(uint32_t*)0x20004c18 = 0x51;
    *(uint32_t*)0x20004c1c = 0x5aff;
    *(uint32_t*)0x20004c20 = 0xec;
    *(uint32_t*)0x20004c24 = 0x7fff;
    *(uint32_t*)0x20004c28 = 0xab;
    *(uint32_t*)0x20004c2c = 0xffff;
    *(uint32_t*)0x20004c30 = 6;
    *(uint32_t*)0x20004c34 = 5;
    *(uint32_t*)0x20004c38 = 4;
    *(uint32_t*)0x20004c3c = 6;
    *(uint32_t*)0x20004c40 = 0x100;
    *(uint32_t*)0x20004c44 = 0xff;
    *(uint32_t*)0x20004c48 = 1;
    *(uint32_t*)0x20004c4c = 4;
    *(uint32_t*)0x20004c50 = -1;
    *(uint32_t*)0x20004c54 = 9;
    *(uint32_t*)0x20004c58 = 6;
    *(uint32_t*)0x20004c5c = 9;
    *(uint32_t*)0x20004c60 = 7;
    *(uint32_t*)0x20004c64 = 0x5c;
    *(uint32_t*)0x20004c68 = 6;
    *(uint32_t*)0x20004c6c = 0xffffb356;
    *(uint32_t*)0x20004c70 = 0;
    *(uint32_t*)0x20004c74 = 0x224000;
    *(uint32_t*)0x20004c78 = 0x7ff;
    *(uint32_t*)0x20004c7c = 8;
    *(uint32_t*)0x20004c80 = 0x13bd;
    *(uint32_t*)0x20004c84 = 8;
    *(uint32_t*)0x20004c88 = 0x5c;
    *(uint32_t*)0x20004c8c = 1;
    *(uint32_t*)0x20004c90 = 0xf45;
    *(uint32_t*)0x20004c94 = 1;
    *(uint32_t*)0x20004c98 = 4;
    *(uint32_t*)0x20004c9c = 0;
    *(uint32_t*)0x20004ca0 = 6;
    *(uint32_t*)0x20004ca4 = 0xfffffffe;
    *(uint32_t*)0x20004ca8 = 0x400;
    *(uint32_t*)0x20004cac = 7;
    *(uint32_t*)0x20004cb0 = 0x7ff;
    *(uint32_t*)0x20004cb4 = 0x1f;
    *(uint32_t*)0x20004cb8 = 3;
    *(uint32_t*)0x20004cbc = 0x3720590b;
    *(uint32_t*)0x20004cc0 = 0xa00;
    *(uint32_t*)0x20004cc4 = 1;
    *(uint32_t*)0x20004cc8 = 2;
    *(uint32_t*)0x20004ccc = 0xffff8000;
    *(uint32_t*)0x20004cd0 = 0x1f;
    *(uint32_t*)0x20004cd4 = 9;
    *(uint32_t*)0x20004cd8 = 6;
    *(uint32_t*)0x20004cdc = 0;
    *(uint32_t*)0x20004ce0 = 0x401;
    *(uint32_t*)0x20004ce4 = 0xff;
    *(uint32_t*)0x20004ce8 = 5;
    *(uint32_t*)0x20004cec = 3;
    *(uint32_t*)0x20004cf0 = 0xfffffffd;
    *(uint32_t*)0x20004cf4 = 0x3f;
    *(uint32_t*)0x20004cf8 = 4;
    *(uint32_t*)0x20004cfc = 0xfffff000;
    *(uint32_t*)0x20004d00 = 1;
    *(uint32_t*)0x20004d04 = 2;
    *(uint32_t*)0x20004d08 = 7;
    *(uint32_t*)0x20004d0c = 0xfffffffa;
    *(uint32_t*)0x20004d10 = 3;
    *(uint32_t*)0x20004d14 = 5;
    *(uint32_t*)0x20004d18 = 6;
    *(uint32_t*)0x20004d1c = 1;
    *(uint32_t*)0x20004d20 = 8;
    *(uint32_t*)0x20004d24 = 6;
    *(uint32_t*)0x20004d28 = 1;
    *(uint32_t*)0x20004d2c = 2;
    *(uint32_t*)0x20004d30 = 0x401;
    *(uint32_t*)0x20004d34 = 3;
    *(uint32_t*)0x20004d38 = 0x81;
    *(uint32_t*)0x20004d3c = 0x3741;
    *(uint32_t*)0x20004d40 = 1;
    *(uint32_t*)0x20004d44 = 7;
    *(uint32_t*)0x20004d48 = 1;
    *(uint32_t*)0x20004d4c = 0x9806;
    *(uint32_t*)0x20004d50 = 0x400;
    *(uint32_t*)0x20004d54 = 0x3f;
    *(uint32_t*)0x20004d58 = 0x401;
    *(uint32_t*)0x20004d5c = 0xffff4e56;
    *(uint32_t*)0x20004d60 = 3;
    *(uint32_t*)0x20004d64 = 2;
    *(uint32_t*)0x20004d68 = 9;
    *(uint32_t*)0x20004d6c = 3;
    *(uint32_t*)0x20004d70 = 1;
    *(uint32_t*)0x20004d74 = 0x100;
    *(uint32_t*)0x20004d78 = 6;
    *(uint32_t*)0x20004d7c = 1;
    *(uint32_t*)0x20004d80 = 0xfffffffd;
    *(uint32_t*)0x20004d84 = 0x6f6;
    *(uint32_t*)0x20004d88 = 6;
    *(uint32_t*)0x20004d8c = 1;
    *(uint32_t*)0x20004d90 = 1;
    *(uint32_t*)0x20004d94 = 0x98a;
    *(uint32_t*)0x20004d98 = 0x7fff;
    *(uint32_t*)0x20004d9c = 0xdf4;
    *(uint32_t*)0x20004da0 = 6;
    *(uint32_t*)0x20004da4 = 1;
    *(uint32_t*)0x20004da8 = 0x1000;
    *(uint32_t*)0x20004dac = 1;
    *(uint32_t*)0x20004db0 = 0xf0000000;
    *(uint32_t*)0x20004db4 = 0xffffffc1;
    *(uint32_t*)0x20004db8 = 8;
    *(uint32_t*)0x20004dbc = 0;
    *(uint32_t*)0x20004dc0 = 4;
    *(uint32_t*)0x20004dc4 = 0;
    *(uint32_t*)0x20004dc8 = 8;
    *(uint32_t*)0x20004dcc = 7;
    *(uint32_t*)0x20004dd0 = 0x7fff;
    *(uint32_t*)0x20004dd4 = 0x3ff;
    *(uint32_t*)0x20004dd8 = 0x80;
    *(uint32_t*)0x20004ddc = 0x80;
    *(uint32_t*)0x20004de0 = 7;
    *(uint32_t*)0x20004de4 = 7;
    *(uint32_t*)0x20004de8 = 1;
    *(uint32_t*)0x20004dec = 4;
    *(uint32_t*)0x20004df0 = 0x3f;
    *(uint32_t*)0x20004df4 = 2;
    *(uint32_t*)0x20004df8 = 2;
    *(uint32_t*)0x20004dfc = 4;
    *(uint32_t*)0x20004e00 = 0x40;
    *(uint32_t*)0x20004e04 = 0x56;
    *(uint32_t*)0x20004e08 = 7;
    *(uint32_t*)0x20004e0c = 0xc88;
    *(uint32_t*)0x20004e10 = 5;
    *(uint32_t*)0x20004e14 = 0x7ff;
    *(uint32_t*)0x20004e18 = 0x95;
    *(uint32_t*)0x20004e1c = 0xec;
    *(uint32_t*)0x20004e20 = 1;
    *(uint32_t*)0x20004e24 = 0x200;
    *(uint32_t*)0x20004e28 = 0x400;
    *(uint32_t*)0x20004e2c = 1;
    *(uint32_t*)0x20004e30 = 4;
    *(uint32_t*)0x20004e34 = 0x10001;
    *(uint32_t*)0x20004e38 = 8;
    *(uint32_t*)0x20004e3c = 0xf2c1;
    *(uint32_t*)0x20004e40 = 0x61ed;
    *(uint32_t*)0x20004e44 = 0x200;
    *(uint32_t*)0x20004e48 = 0x10001;
    *(uint32_t*)0x20004e4c = 0x101;
    *(uint32_t*)0x20004e50 = 7;
    *(uint32_t*)0x20004e54 = 0x400;
    *(uint32_t*)0x20004e58 = 0x7fffffff;
    *(uint32_t*)0x20004e5c = 5;
    *(uint32_t*)0x20004e60 = 6;
    *(uint32_t*)0x20004e64 = 0xb0c4;
    *(uint32_t*)0x20004e68 = 0x630;
    *(uint32_t*)0x20004e6c = 5;
    *(uint32_t*)0x20004e70 = 5;
    *(uint32_t*)0x20004e74 = 7;
    *(uint32_t*)0x20004e78 = 6;
    *(uint32_t*)0x20004e7c = 0x8df;
    *(uint32_t*)0x20004e80 = 9;
    *(uint32_t*)0x20004e84 = 3;
    *(uint32_t*)0x20004e88 = 0xff;
    *(uint32_t*)0x20004e8c = 4;
    *(uint32_t*)0x20004e90 = 0x324;
    *(uint32_t*)0x20004e94 = 4;
    *(uint32_t*)0x20004e98 = 0xfffffffe;
    *(uint32_t*)0x20004e9c = 0x8000;
    *(uint32_t*)0x20004ea0 = 1;
    *(uint32_t*)0x20004ea4 = 1;
    *(uint32_t*)0x20004ea8 = 0xd3;
    *(uint32_t*)0x20004eac = 1;
    *(uint32_t*)0x20004eb0 = 0x10000;
    *(uint32_t*)0x20004eb4 = 2;
    *(uint32_t*)0x20004eb8 = 0;
    *(uint32_t*)0x20004ebc = -1;
    *(uint32_t*)0x20004ec0 = -1;
    *(uint32_t*)0x20004ec4 = 8;
    *(uint32_t*)0x20004ec8 = 0x3d;
    *(uint32_t*)0x20004ecc = 0x3ff;
    *(uint32_t*)0x20004ed0 = 0x225;
    *(uint32_t*)0x20004ed4 = 5;
    *(uint32_t*)0x20004ed8 = 9;
    *(uint32_t*)0x20004edc = -1;
    *(uint32_t*)0x20004ee0 = 9;
    *(uint32_t*)0x20004ee4 = 0x101;
    *(uint32_t*)0x20004ee8 = 7;
    *(uint32_t*)0x20004eec = 2;
    *(uint32_t*)0x20004ef0 = 0x8000;
    *(uint32_t*)0x20004ef4 = 0x200;
    *(uint32_t*)0x20004ef8 = 0x4b3c;
    *(uint16_t*)0x20004efc = 0xc;
    *(uint16_t*)0x20004efe = 8;
    *(uint64_t*)0x20004f00 = 4;
    *(uint16_t*)0x20004f08 = 8;
    *(uint16_t*)0x20004f0a = 4;
    *(uint32_t*)0x20004f0c = 0x3f4f;
    *(uint16_t*)0x20004f10 = 0x404;
    *(uint16_t*)0x20004f12 = 2;
    *(uint32_t*)0x20004f14 = 4;
    *(uint32_t*)0x20004f18 = 0x91;
    *(uint32_t*)0x20004f1c = 2;
    *(uint32_t*)0x20004f20 = 9;
    *(uint32_t*)0x20004f24 = 1;
    *(uint32_t*)0x20004f28 = 0x94;
    *(uint32_t*)0x20004f2c = 0x75;
    *(uint32_t*)0x20004f30 = 2;
    *(uint32_t*)0x20004f34 = 4;
    *(uint32_t*)0x20004f38 = 0x778;
    *(uint32_t*)0x20004f3c = 7;
    *(uint32_t*)0x20004f40 = 0xff;
    *(uint32_t*)0x20004f44 = 0x20;
    *(uint32_t*)0x20004f48 = 0x8000;
    *(uint32_t*)0x20004f4c = 0xff;
    *(uint32_t*)0x20004f50 = 0x8001;
    *(uint32_t*)0x20004f54 = 0xc85;
    *(uint32_t*)0x20004f58 = 0x8e;
    *(uint32_t*)0x20004f5c = 0x81;
    *(uint32_t*)0x20004f60 = 0x3ff;
    *(uint32_t*)0x20004f64 = 0xfffffffb;
    *(uint32_t*)0x20004f68 = 0x1f;
    *(uint32_t*)0x20004f6c = 0;
    *(uint32_t*)0x20004f70 = 4;
    *(uint32_t*)0x20004f74 = 0x1ff;
    *(uint32_t*)0x20004f78 = 0xfff;
    *(uint32_t*)0x20004f7c = 4;
    *(uint32_t*)0x20004f80 = 0xffff7070;
    *(uint32_t*)0x20004f84 = 1;
    *(uint32_t*)0x20004f88 = 0xea;
    *(uint32_t*)0x20004f8c = 8;
    *(uint32_t*)0x20004f90 = 0x1ff;
    *(uint32_t*)0x20004f94 = 0xcd6;
    *(uint32_t*)0x20004f98 = 0x1ff;
    *(uint32_t*)0x20004f9c = 0x1ff;
    *(uint32_t*)0x20004fa0 = 0x81;
    *(uint32_t*)0x20004fa4 = 6;
    *(uint32_t*)0x20004fa8 = 0x3e3b;
    *(uint32_t*)0x20004fac = 0x1ff;
    *(uint32_t*)0x20004fb0 = 0x7ff;
    *(uint32_t*)0x20004fb4 = 0x7f;
    *(uint32_t*)0x20004fb8 = 9;
    *(uint32_t*)0x20004fbc = 0x1f;
    *(uint32_t*)0x20004fc0 = 9;
    *(uint32_t*)0x20004fc4 = 0x7ff;
    *(uint32_t*)0x20004fc8 = 0x80000001;
    *(uint32_t*)0x20004fcc = 6;
    *(uint32_t*)0x20004fd0 = 8;
    *(uint32_t*)0x20004fd4 = 0x18b5;
    *(uint32_t*)0x20004fd8 = 5;
    *(uint32_t*)0x20004fdc = 0x2a;
    *(uint32_t*)0x20004fe0 = 0xd3;
    *(uint32_t*)0x20004fe4 = 0x89;
    *(uint32_t*)0x20004fe8 = 1;
    *(uint32_t*)0x20004fec = 0x800;
    *(uint32_t*)0x20004ff0 = 0x8c86;
    *(uint32_t*)0x20004ff4 = 9;
    *(uint32_t*)0x20004ff8 = 0;
    *(uint32_t*)0x20004ffc = 1;
    *(uint32_t*)0x20005000 = 8;
    *(uint32_t*)0x20005004 = 6;
    *(uint32_t*)0x20005008 = 2;
    *(uint32_t*)0x2000500c = 3;
    *(uint32_t*)0x20005010 = 2;
    *(uint32_t*)0x20005014 = 6;
    *(uint32_t*)0x20005018 = 0x8b68a45;
    *(uint32_t*)0x2000501c = 4;
    *(uint32_t*)0x20005020 = 0x63b6;
    *(uint32_t*)0x20005024 = 6;
    *(uint32_t*)0x20005028 = 2;
    *(uint32_t*)0x2000502c = 0xcc;
    *(uint32_t*)0x20005030 = 3;
    *(uint32_t*)0x20005034 = 8;
    *(uint32_t*)0x20005038 = 1;
    *(uint32_t*)0x2000503c = 9;
    *(uint32_t*)0x20005040 = 0x3ff;
    *(uint32_t*)0x20005044 = 8;
    *(uint32_t*)0x20005048 = 0;
    *(uint32_t*)0x2000504c = 0x7fffffff;
    *(uint32_t*)0x20005050 = 0x10001;
    *(uint32_t*)0x20005054 = 0x40;
    *(uint32_t*)0x20005058 = 0x44;
    *(uint32_t*)0x2000505c = 5;
    *(uint32_t*)0x20005060 = 0xffff;
    *(uint32_t*)0x20005064 = 3;
    *(uint32_t*)0x20005068 = 0;
    *(uint32_t*)0x2000506c = 5;
    *(uint32_t*)0x20005070 = 0x80000001;
    *(uint32_t*)0x20005074 = 3;
    *(uint32_t*)0x20005078 = 0xe990;
    *(uint32_t*)0x2000507c = 0;
    *(uint32_t*)0x20005080 = 1;
    *(uint32_t*)0x20005084 = 0x7fffffff;
    *(uint32_t*)0x20005088 = 0x1ff;
    *(uint32_t*)0x2000508c = 0xf370;
    *(uint32_t*)0x20005090 = 0;
    *(uint32_t*)0x20005094 = 9;
    *(uint32_t*)0x20005098 = 1;
    *(uint32_t*)0x2000509c = 0x7d1;
    *(uint32_t*)0x200050a0 = 4;
    *(uint32_t*)0x200050a4 = 0xb9dc;
    *(uint32_t*)0x200050a8 = 7;
    *(uint32_t*)0x200050ac = 0xfffffff8;
    *(uint32_t*)0x200050b0 = 7;
    *(uint32_t*)0x200050b4 = 2;
    *(uint32_t*)0x200050b8 = 1;
    *(uint32_t*)0x200050bc = 0xffff;
    *(uint32_t*)0x200050c0 = 0xda;
    *(uint32_t*)0x200050c4 = 1;
    *(uint32_t*)0x200050c8 = 0x7ff;
    *(uint32_t*)0x200050cc = 6;
    *(uint32_t*)0x200050d0 = 0x400000;
    *(uint32_t*)0x200050d4 = 4;
    *(uint32_t*)0x200050d8 = 3;
    *(uint32_t*)0x200050dc = 0x81;
    *(uint32_t*)0x200050e0 = 0x10001;
    *(uint32_t*)0x200050e4 = 0;
    *(uint32_t*)0x200050e8 = 0x100;
    *(uint32_t*)0x200050ec = 0x70a;
    *(uint32_t*)0x200050f0 = 3;
    *(uint32_t*)0x200050f4 = 0x1000;
    *(uint32_t*)0x200050f8 = 4;
    *(uint32_t*)0x200050fc = 0x400;
    *(uint32_t*)0x20005100 = 9;
    *(uint32_t*)0x20005104 = 3;
    *(uint32_t*)0x20005108 = 0x200;
    *(uint32_t*)0x2000510c = 4;
    *(uint32_t*)0x20005110 = 0x89a8;
    *(uint32_t*)0x20005114 = 1;
    *(uint32_t*)0x20005118 = 3;
    *(uint32_t*)0x2000511c = 1;
    *(uint32_t*)0x20005120 = 4;
    *(uint32_t*)0x20005124 = 0;
    *(uint32_t*)0x20005128 = 9;
    *(uint32_t*)0x2000512c = 0x5a4;
    *(uint32_t*)0x20005130 = 4;
    *(uint32_t*)0x20005134 = 0xbc;
    *(uint32_t*)0x20005138 = 0x7fffffff;
    *(uint32_t*)0x2000513c = 9;
    *(uint32_t*)0x20005140 = 5;
    *(uint32_t*)0x20005144 = 2;
    *(uint32_t*)0x20005148 = 0x401;
    *(uint32_t*)0x2000514c = 6;
    *(uint32_t*)0x20005150 = 0x93d4;
    *(uint32_t*)0x20005154 = 2;
    *(uint32_t*)0x20005158 = 0xff;
    *(uint32_t*)0x2000515c = 0xa3;
    *(uint32_t*)0x20005160 = 6;
    *(uint32_t*)0x20005164 = 0x7ff;
    *(uint32_t*)0x20005168 = 5;
    *(uint32_t*)0x2000516c = 3;
    *(uint32_t*)0x20005170 = 0x7c15;
    *(uint32_t*)0x20005174 = 0x8001;
    *(uint32_t*)0x20005178 = 5;
    *(uint32_t*)0x2000517c = 0x400;
    *(uint32_t*)0x20005180 = 0;
    *(uint32_t*)0x20005184 = 0x53;
    *(uint32_t*)0x20005188 = 4;
    *(uint32_t*)0x2000518c = 0xfffffffd;
    *(uint32_t*)0x20005190 = 5;
    *(uint32_t*)0x20005194 = 0xfff;
    *(uint32_t*)0x20005198 = 8;
    *(uint32_t*)0x2000519c = -1;
    *(uint32_t*)0x200051a0 = 0x401;
    *(uint32_t*)0x200051a4 = 0x200;
    *(uint32_t*)0x200051a8 = 9;
    *(uint32_t*)0x200051ac = 0xa33;
    *(uint32_t*)0x200051b0 = 0;
    *(uint32_t*)0x200051b4 = 0x168;
    *(uint32_t*)0x200051b8 = 0x46;
    *(uint32_t*)0x200051bc = 0xff;
    *(uint32_t*)0x200051c0 = 0x400;
    *(uint32_t*)0x200051c4 = 0x926a;
    *(uint32_t*)0x200051c8 = 0xfff;
    *(uint32_t*)0x200051cc = 0xfffff660;
    *(uint32_t*)0x200051d0 = 0x200;
    *(uint32_t*)0x200051d4 = 0;
    *(uint32_t*)0x200051d8 = 7;
    *(uint32_t*)0x200051dc = 0;
    *(uint32_t*)0x200051e0 = 0x100;
    *(uint32_t*)0x200051e4 = 6;
    *(uint32_t*)0x200051e8 = 3;
    *(uint32_t*)0x200051ec = 0;
    *(uint32_t*)0x200051f0 = 0xd3;
    *(uint32_t*)0x200051f4 = 0x751;
    *(uint32_t*)0x200051f8 = 0xfffffffe;
    *(uint32_t*)0x200051fc = 6;
    *(uint32_t*)0x20005200 = 9;
    *(uint32_t*)0x20005204 = 4;
    *(uint32_t*)0x20005208 = 6;
    *(uint32_t*)0x2000520c = 3;
    *(uint32_t*)0x20005210 = 9;
    *(uint32_t*)0x20005214 = 0x81;
    *(uint32_t*)0x20005218 = 3;
    *(uint32_t*)0x2000521c = 0;
    *(uint32_t*)0x20005220 = 0xf16;
    *(uint32_t*)0x20005224 = 0;
    *(uint32_t*)0x20005228 = 5;
    *(uint32_t*)0x2000522c = 0xf6;
    *(uint32_t*)0x20005230 = 9;
    *(uint32_t*)0x20005234 = 0x7a800000;
    *(uint32_t*)0x20005238 = 0x7fff;
    *(uint32_t*)0x2000523c = 0x10000;
    *(uint32_t*)0x20005240 = 2;
    *(uint32_t*)0x20005244 = 6;
    *(uint32_t*)0x20005248 = 5;
    *(uint32_t*)0x2000524c = 0xfffffeff;
    *(uint32_t*)0x20005250 = 4;
    *(uint32_t*)0x20005254 = 0x776;
    *(uint32_t*)0x20005258 = 1;
    *(uint32_t*)0x2000525c = 0x20;
    *(uint32_t*)0x20005260 = 0x80;
    *(uint32_t*)0x20005264 = 0;
    *(uint32_t*)0x20005268 = 7;
    *(uint32_t*)0x2000526c = 0xed3d;
    *(uint32_t*)0x20005270 = 0x800000;
    *(uint32_t*)0x20005274 = 0x200;
    *(uint32_t*)0x20005278 = 0xfffffffc;
    *(uint32_t*)0x2000527c = 0xdf;
    *(uint32_t*)0x20005280 = 5;
    *(uint32_t*)0x20005284 = 6;
    *(uint32_t*)0x20005288 = 9;
    *(uint32_t*)0x2000528c = 6;
    *(uint32_t*)0x20005290 = 0x91d;
    *(uint32_t*)0x20005294 = 0xffff;
    *(uint32_t*)0x20005298 = 7;
    *(uint32_t*)0x2000529c = 0x8e4;
    *(uint32_t*)0x200052a0 = 1;
    *(uint32_t*)0x200052a4 = 0x5af9ea4f;
    *(uint32_t*)0x200052a8 = 0xff;
    *(uint32_t*)0x200052ac = 8;
    *(uint32_t*)0x200052b0 = 5;
    *(uint32_t*)0x200052b4 = 5;
    *(uint32_t*)0x200052b8 = 0;
    *(uint32_t*)0x200052bc = 2;
    *(uint32_t*)0x200052c0 = 1;
    *(uint32_t*)0x200052c4 = 3;
    *(uint32_t*)0x200052c8 = 3;
    *(uint32_t*)0x200052cc = 0x101;
    *(uint32_t*)0x200052d0 = 0;
    *(uint32_t*)0x200052d4 = 5;
    *(uint32_t*)0x200052d8 = 8;
    *(uint32_t*)0x200052dc = 7;
    *(uint32_t*)0x200052e0 = 6;
    *(uint32_t*)0x200052e4 = 0xfffffffa;
    *(uint32_t*)0x200052e8 = 8;
    *(uint32_t*)0x200052ec = 0x1000;
    *(uint32_t*)0x200052f0 = 7;
    *(uint32_t*)0x200052f4 = 0x81;
    *(uint32_t*)0x200052f8 = 0x64cb;
    *(uint32_t*)0x200052fc = 4;
    *(uint32_t*)0x20005300 = 6;
    *(uint32_t*)0x20005304 = 2;
    *(uint32_t*)0x20005308 = 5;
    *(uint32_t*)0x2000530c = 0x400;
    *(uint32_t*)0x20005310 = 4;
    *(uint64_t*)0x20005688 = 0x4f94;
    *(uint64_t*)0x200056d8 = 1;
    *(uint64_t*)0x200056e0 = 0;
    *(uint64_t*)0x200056e8 = 0;
    *(uint32_t*)0x200056f0 = 0x1000;
    syscall(__NR_sendmsg, -1, 0x200056c0ul, 0x20000000ul);
    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_sysctl();
  setup_binfmt_misc();
  setup_leak();
  for (procid = 0; procid < 8; procid++) {
    if (fork() == 0) {
      use_temporary_dir();
      do_sandbox_none();
    }
  }
  sleep(1000000);
  return 0;
}