// https://syzkaller.appspot.com/bug?id=c1c126bc2802148d1dabae59b8c8b30373eead1b
// 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 <netinet/in.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/ioctl.h>
#include <sys/mount.h>
#include <sys/prctl.h>
#include <sys/resource.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <sys/syscall.h>
#include <sys/time.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <time.h>
#include <unistd.h>

#include <linux/capability.h>
#include <linux/genetlink.h>
#include <linux/if_addr.h>
#include <linux/if_link.h>
#include <linux/in6.h>
#include <linux/neighbour.h>
#include <linux/net.h>
#include <linux/netlink.h>
#include <linux/rtnetlink.h>
#include <linux/veth.h>

#ifndef __NR_io_uring_enter
#define __NR_io_uring_enter 426
#endif
#ifndef __NR_io_uring_setup
#define __NR_io_uring_setup 425
#endif

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

#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))))

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, bool dofail)
{
  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;
  ssize_t n = sendto(sock, nlmsg->buf, hdr->nlmsg_len, 0,
                     (struct sockaddr*)&addr, sizeof(addr));
  if (n != (ssize_t)hdr->nlmsg_len) {
    if (dofail)
      exit(1);
    return -1;
  }
  n = recv(sock, nlmsg->buf, sizeof(nlmsg->buf), 0);
  if (reply_len)
    *reply_len = 0;
  if (n < 0) {
    if (dofail)
      exit(1);
    return -1;
  }
  if (n < (ssize_t)sizeof(struct nlmsghdr)) {
    errno = EINVAL;
    if (dofail)
      exit(1);
    return -1;
  }
  if (hdr->nlmsg_type == NLMSG_DONE)
    return 0;
  if (reply_len && hdr->nlmsg_type == reply_type) {
    *reply_len = n;
    return 0;
  }
  if (n < (ssize_t)(sizeof(struct nlmsghdr) + sizeof(struct nlmsgerr))) {
    errno = EINVAL;
    if (dofail)
      exit(1);
    return -1;
  }
  if (hdr->nlmsg_type != NLMSG_ERROR) {
    errno = EINVAL;
    if (dofail)
      exit(1);
    return -1;
  }
  errno = -((struct nlmsgerr*)(hdr + 1))->error;
  return -errno;
}

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

static int netlink_query_family_id(struct nlmsg* nlmsg, int sock,
                                   const char* family_name, bool dofail)
{
  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, dofail);
  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) {
    errno = EINVAL;
    return -1;
  }
  recv(sock, nlmsg->buf, sizeof(nlmsg->buf), 0);
  return id;
}

static unsigned int queue_count = 2;

static void netlink_add_device_impl(struct nlmsg* nlmsg, const char* type,
                                    const char* name, bool up)
{
  struct ifinfomsg hdr;
  memset(&hdr, 0, sizeof(hdr));
  if (up)
    hdr.ifi_flags = hdr.ifi_change = IFF_UP;
  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_attr(nlmsg, IFLA_NUM_TX_QUEUES, &queue_count, sizeof(queue_count));
  netlink_attr(nlmsg, IFLA_NUM_RX_QUEUES, &queue_count, sizeof(queue_count));
  netlink_nest(nlmsg, IFLA_LINKINFO);
  netlink_attr(nlmsg, IFLA_INFO_KIND, type, strlen(type));
}

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);
  if (err < 0) {
  }
}

static struct nlmsg nlmsg;

#define MAX_FDS 30

static void mount_cgroups(const char* dir, const char** controllers, int count)
{
  if (mkdir(dir, 0777)) {
    return;
  }
  char enabled[128] = {0};
  int i = 0;
  for (; i < count; i++) {
    if (mount("none", dir, "cgroup", 0, controllers[i])) {
      continue;
    }
    umount(dir);
    strcat(enabled, ",");
    strcat(enabled, controllers[i]);
  }
  if (enabled[0] == 0) {
    if (rmdir(dir) && errno != EBUSY)
      exit(1);
    return;
  }
  if (mount("none", dir, "cgroup", 0, enabled + 1)) {
    if (rmdir(dir) && errno != EBUSY)
      exit(1);
  }
  if (chmod(dir, 0777)) {
  }
}

static void mount_cgroups2(const char** controllers, int count)
{
  if (mkdir("/syzcgroup/unified", 0777)) {
    return;
  }
  if (mount("none", "/syzcgroup/unified", "cgroup2", 0, NULL)) {
    if (rmdir("/syzcgroup/unified") && errno != EBUSY)
      exit(1);
    return;
  }
  if (chmod("/syzcgroup/unified", 0777)) {
  }
  int control = open("/syzcgroup/unified/cgroup.subtree_control", O_WRONLY);
  if (control == -1)
    return;
  int i;
  for (i = 0; i < count; i++)
    if (write(control, controllers[i], strlen(controllers[i])) < 0) {
    }
  close(control);
}

static void setup_cgroups()
{
  const char* unified_controllers[] = {"+cpu", "+io", "+pids"};
  const char* net_controllers[] = {"net", "net_prio", "devices", "blkio",
                                   "freezer"};
  const char* cpu_controllers[] = {"cpuset", "cpuacct", "hugetlb", "rlimit",
                                   "memory"};
  if (mkdir("/syzcgroup", 0777)) {
    return;
  }
  mount_cgroups2(unified_controllers,
                 sizeof(unified_controllers) / sizeof(unified_controllers[0]));
  mount_cgroups("/syzcgroup/net", net_controllers,
                sizeof(net_controllers) / sizeof(net_controllers[0]));
  mount_cgroups("/syzcgroup/cpu", cpu_controllers,
                sizeof(cpu_controllers) / sizeof(cpu_controllers[0]));
  write_file("/syzcgroup/cpu/cgroup.clone_children", "1");
  write_file("/syzcgroup/cpu/cpuset.memory_pressure_enabled", "1");
}

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/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(file, sizeof(file), "%s/memory.soft_limit_in_bytes", cgroupdir);
  write_file(file, "%d", 299 << 20);
  snprintf(file, sizeof(file), "%s/memory.limit_in_bytes", cgroupdir);
  write_file(file, "%d", 300 << 20);
  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 initialize_cgroups()
{
  if (mkdir("./syz-tmp/newroot/syzcgroup", 0700))
    exit(1);
  if (mkdir("./syz-tmp/newroot/syzcgroup/unified", 0700))
    exit(1);
  if (mkdir("./syz-tmp/newroot/syzcgroup/cpu", 0700))
    exit(1);
  if (mkdir("./syz-tmp/newroot/syzcgroup/net", 0700))
    exit(1);
  unsigned bind_mount_flags = MS_BIND | MS_REC | MS_PRIVATE;
  if (mount("/syzcgroup/unified", "./syz-tmp/newroot/syzcgroup/unified", NULL,
            bind_mount_flags, NULL)) {
  }
  if (mount("/syzcgroup/cpu", "./syz-tmp/newroot/syzcgroup/cpu", NULL,
            bind_mount_flags, NULL)) {
  }
  if (mount("/syzcgroup/net", "./syz-tmp/newroot/syzcgroup/net", NULL,
            bind_mount_flags, NULL)) {
  }
}

static void setup_gadgetfs();
static void setup_binderfs();
static void setup_fusectl();
static void sandbox_common_mount_tmpfs(void)
{
  write_file("/proc/sys/fs/mount-max", "100000");
  if (mkdir("./syz-tmp", 0777))
    exit(1);
  if (mount("", "./syz-tmp", "tmpfs", 0, NULL))
    exit(1);
  if (mkdir("./syz-tmp/newroot", 0777))
    exit(1);
  if (mkdir("./syz-tmp/newroot/dev", 0700))
    exit(1);
  unsigned bind_mount_flags = MS_BIND | MS_REC | MS_PRIVATE;
  if (mount("/dev", "./syz-tmp/newroot/dev", NULL, bind_mount_flags, NULL))
    exit(1);
  if (mkdir("./syz-tmp/newroot/proc", 0700))
    exit(1);
  if (mount("syz-proc", "./syz-tmp/newroot/proc", "proc", 0, NULL))
    exit(1);
  if (mkdir("./syz-tmp/newroot/selinux", 0700))
    exit(1);
  const char* selinux_path = "./syz-tmp/newroot/selinux";
  if (mount("/selinux", selinux_path, NULL, bind_mount_flags, NULL)) {
    if (errno != ENOENT)
      exit(1);
    if (mount("/sys/fs/selinux", selinux_path, NULL, bind_mount_flags, NULL) &&
        errno != ENOENT)
      exit(1);
  }
  if (mkdir("./syz-tmp/newroot/sys", 0700))
    exit(1);
  if (mount("/sys", "./syz-tmp/newroot/sys", 0, bind_mount_flags, NULL))
    exit(1);
  if (mount("/sys/kernel/debug", "./syz-tmp/newroot/sys/kernel/debug", NULL,
            bind_mount_flags, NULL) &&
      errno != ENOENT)
    exit(1);
  if (mount("/sys/fs/smackfs", "./syz-tmp/newroot/sys/fs/smackfs", NULL,
            bind_mount_flags, NULL) &&
      errno != ENOENT)
    exit(1);
  if (mount("/proc/sys/fs/binfmt_misc",
            "./syz-tmp/newroot/proc/sys/fs/binfmt_misc", NULL, bind_mount_flags,
            NULL) &&
      errno != ENOENT)
    exit(1);
  if (mkdir("./syz-tmp/newroot/syz-inputs", 0700))
    exit(1);
  if (mount("/syz-inputs", "./syz-tmp/newroot/syz-inputs", NULL,
            bind_mount_flags | MS_RDONLY, NULL) &&
      errno != ENOENT)
    exit(1);
  initialize_cgroups();
  if (mkdir("./syz-tmp/pivot", 0777))
    exit(1);
  if (syscall(SYS_pivot_root, "./syz-tmp", "./syz-tmp/pivot")) {
    if (chdir("./syz-tmp"))
      exit(1);
  } else {
    if (chdir("/"))
      exit(1);
    if (umount2("./pivot", MNT_DETACH))
      exit(1);
  }
  if (chroot("./newroot"))
    exit(1);
  if (chdir("/"))
    exit(1);
  setup_gadgetfs();
  setup_binderfs();
  setup_fusectl();
}

static void setup_gadgetfs()
{
  if (mkdir("/dev/gadgetfs", 0777)) {
  }
  if (mount("gadgetfs", "/dev/gadgetfs", "gadgetfs", 0, NULL)) {
  }
}

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

static void setup_binderfs()
{
  if (mkdir("/dev/binderfs", 0777)) {
  }
  if (mount("binder", "/dev/binderfs", "binder", 0, NULL)) {
  }
}

static void loop();

static void sandbox_common()
{
  prctl(PR_SET_PDEATHSIG, SIGKILL, 0, 0, 0);
  if (getppid() == 1)
    exit(1);
  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 = 128 << 20;
  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);
  sandbox_common();
  drop_caps();
  if (unshare(CLONE_NEWNET)) {
  }
  write_file("/proc/sys/net/ipv4/ping_group_range", "0 65535");
  sandbox_common_mount_tmpfs();
  loop();
  exit(1);
}

#define FS_IOC_SETFLAGS _IOW('f', 2, long)
static void remove_dir(const char* dir)
{
  int iter = 0;
  DIR* dp = 0;
  const int umount_flags = MNT_FORCE | UMOUNT_NOFOLLOW;

retry:
  while (umount2(dir, umount_flags) == 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, umount_flags) == 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, umount_flags))
        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, umount_flags))
          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");
  if (symlink("/dev/binderfs", "./binderfs")) {
  }
}

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

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

static const char* setup_leak()
{
  if (!write_file(KMEMLEAK_FILE, "scan=off")) {
    if (errno == EBUSY)
      return "KMEMLEAK disabled: increase CONFIG_DEBUG_KMEMLEAK_EARLY_LOG_SIZE"
             " or unset CONFIG_DEBUG_KMEMLEAK_DEFAULT_OFF";
    return "failed to write(kmemleak, \"scan=off\")";
  }
  if (!write_file(KMEMLEAK_FILE, "scan"))
    return "failed to write(kmemleak, \"scan\")";
  sleep(5);
  if (!write_file(KMEMLEAK_FILE, "scan"))
    return "failed to write(kmemleak, \"scan\")";
  if (!write_file(KMEMLEAK_FILE, "clear"))
    return "failed to write(kmemleak, \"clear\")";
  return NULL;
}

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 const char* setup_usb()
{
  if (chmod("/dev/raw-gadget", 0666))
    return "failed to chmod /dev/raw-gadget";
  return NULL;
}

#define NL802154_CMD_SET_SHORT_ADDR 11
#define NL802154_ATTR_IFINDEX 3
#define NL802154_ATTR_SHORT_ADDR 10

static const char* setup_802154()
{
  const char* error = NULL;
  int sock_generic = -1;
  int sock_route = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
  if (sock_route == -1) {
    error = "socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE) failed";
    goto fail;
  }
  sock_generic = socket(AF_NETLINK, SOCK_RAW, NETLINK_GENERIC);
  if (sock_generic == -1) {
    error = "socket(AF_NETLINK, SOCK_RAW, NETLINK_GENERIC) failed";
    goto fail;
  }
  {
    int nl802154_family_id =
        netlink_query_family_id(&nlmsg, sock_generic, "nl802154", true);
    if (nl802154_family_id < 0) {
      error = "netlink_query_family_id failed";
      goto fail;
    }
    for (int i = 0; i < 2; i++) {
      char devname[] = "wpan0";
      devname[strlen(devname) - 1] += i;
      uint64_t hwaddr = 0xaaaaaaaaaaaa0002 + (i << 8);
      uint16_t shortaddr = 0xaaa0 + i;
      int ifindex = if_nametoindex(devname);
      struct genlmsghdr genlhdr;
      memset(&genlhdr, 0, sizeof(genlhdr));
      genlhdr.cmd = NL802154_CMD_SET_SHORT_ADDR;
      netlink_init(&nlmsg, nl802154_family_id, 0, &genlhdr, sizeof(genlhdr));
      netlink_attr(&nlmsg, NL802154_ATTR_IFINDEX, &ifindex, sizeof(ifindex));
      netlink_attr(&nlmsg, NL802154_ATTR_SHORT_ADDR, &shortaddr,
                   sizeof(shortaddr));
      if (netlink_send(&nlmsg, sock_generic) < 0) {
        error = "NL802154_CMD_SET_SHORT_ADDR failed";
        goto fail;
      }
      netlink_device_change(&nlmsg, sock_route, devname, true, 0, &hwaddr,
                            sizeof(hwaddr), 0);
      if (i == 0) {
        netlink_add_device_impl(&nlmsg, "lowpan", "lowpan0", false);
        netlink_done(&nlmsg);
        netlink_attr(&nlmsg, IFLA_LINK, &ifindex, sizeof(ifindex));
        if (netlink_send(&nlmsg, sock_route) < 0) {
          error = "netlink: adding device lowpan0 type lowpan link wpan0";
          goto fail;
        }
      }
    }
  }
fail:
  close(sock_route);
  close(sock_generic);
  return error;
}

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();
      close_fds();
      exit(0);
    }
    int status = 0;
    uint64_t start = current_time_ms();
    for (;;) {
      sleep_ms(10);
      if (waitpid(-1, &status, WNOHANG | WAIT_FLAGS) == pid)
        break;
      if (current_time_ms() - start < 5000)
        continue;
      kill_and_wait(pid, &status);
      break;
    }
    remove_dir(cwdbuf);
    check_leaks();
  }
}

uint64_t r[1] = {0xffffffffffffffff};

void execute_one(void)
{
  intptr_t res = 0;
  if (write(1, "executing program\n", sizeof("executing program\n") - 1)) {
  }
  //  socket$nl_generic arguments: [
  //    domain: const = 0x10 (8 bytes)
  //    type: const = 0x3 (8 bytes)
  //    proto: const = 0x10 (4 bytes)
  //  ]
  //  returns sock_nl_generic
  syscall(__NR_socket, /*domain=*/0x10ul, /*type=*/3ul, /*proto=*/0x10);
  //  socket$nl_route arguments: [
  //    domain: const = 0x10 (8 bytes)
  //    type: const = 0x3 (8 bytes)
  //    proto: const = 0x0 (4 bytes)
  //  ]
  //  returns sock_nl_route
  syscall(__NR_socket, /*domain=*/0x10ul, /*type=*/3ul, /*proto=*/0);
  //  openat arguments: [
  //    fd: fd_dir (resource)
  //    file: ptr[in, buffer] {
  //      buffer: {2e 2f 63 67 72 6f 75 70 2f 63 67 72 6f 75 70 2e 70 72 6f 63
  //      73 00} (length 0x16)
  //    }
  //    flags: open_flags = 0x2 (4 bytes)
  //    mode: open_mode = 0x0 (2 bytes)
  //  ]
  //  returns fd
  memcpy((void*)0x200000000040, "./cgroup/cgroup.procs\000", 22);
  syscall(__NR_openat, /*fd=*/0xffffff9c, /*file=*/0x200000000040ul,
          /*flags=O_RDWR*/ 2, /*mode=*/0);
  //  socket$nl_route arguments: [
  //    domain: const = 0x10 (8 bytes)
  //    type: const = 0x3 (8 bytes)
  //    proto: const = 0x0 (4 bytes)
  //  ]
  //  returns sock_nl_route
  syscall(__NR_socket, /*domain=*/0x10ul, /*type=*/3ul, /*proto=*/0);
  //  sendmsg$nl_route_sched arguments: [
  //    fd: sock_nl_route (resource)
  //    msg: ptr[in, msghdr_netlink[netlink_msg_route_sched]] {
  //      msghdr_netlink[netlink_msg_route_sched] {
  //        addr: nil
  //        addrlen: len = 0x0 (4 bytes)
  //        pad = 0x0 (4 bytes)
  //        vec: ptr[in, iovec[in, netlink_msg_route_sched]] {
  //          iovec[in, netlink_msg_route_sched] {
  //            addr: ptr[in, netlink_msg_route_sched] {
  //              union netlink_msg_route_sched {
  //                deltfilter: netlink_msg_t[const[RTM_DELTFILTER, int16],
  //                tcmsg[AF_UNSPEC], filter_policy] {
  //                  len: len = 0x1ddc (4 bytes)
  //                  type: const = 0x2d (2 bytes)
  //                  flags: netlink_msg_flags = 0x400 (2 bytes)
  //                  seq: int32 = 0x70bd2c (4 bytes)
  //                  pid: int32 = 0x25dfdbfe (4 bytes)
  //                  payload: tcmsg[AF_UNSPEC] {
  //                    family: const = 0x0 (1 bytes)
  //                    tcm__pad1: const = 0x0 (1 bytes)
  //                    tcm__pad2: const = 0x0 (2 bytes)
  //                    ifindex: ifindex (resource)
  //                    tcm_handle: tcm_handle {
  //                      minor: tcm_handle_offsets = 0x5 (2 bytes)
  //                      major: tcm_handle_offsets = 0xffe0 (2 bytes)
  //                    }
  //                    tcm_parent: tcm_handle {
  //                      minor: tcm_handle_offsets = 0xa (2 bytes)
  //                      major: tcm_handle_offsets = 0x3 (2 bytes)
  //                    }
  //                    tcm_info: tcm_handle {
  //                      minor: tcm_handle_offsets = 0x6 (2 bytes)
  //                      major: tcm_handle_offsets = 0x5 (2 bytes)
  //                    }
  //                  }
  //                  attrs: array[filter_policy] {
  //                    union filter_policy {
  //                      TCA_CHAIN: nlattr_t[const[TCA_CHAIN, int16], int32] {
  //                        nla_len: offsetof = 0x8 (2 bytes)
  //                        nla_type: const = 0xb (2 bytes)
  //                        payload: int32 = 0x6 (4 bytes)
  //                        size: buffer: {} (length 0x0)
  //                      }
  //                    }
  //                    union filter_policy {
  //                      filter_kind_options: union filter_kind_options {
  //                        f_cgroup: tca_kind_options_t["cgroup",
  //                        array[cgroup_policy]] {
  //                          TCA_KIND: nlattr_t[const[TCA_KIND, int16],
  //                          string["cgroup"]] {
  //                            nla_len: offsetof = 0xb (2 bytes)
  //                            nla_type: const = 0x1 (2 bytes)
  //                            payload: buffer: {63 67 72 6f 75 70 00} (length
  //                            0x7) size: buffer: {} (length 0x0) pad = 0x0 (1
  //                            bytes)
  //                          }
  //                          TCA_OPTIONS: nlattr_t[const[TCA_OPTIONS, int16],
  //                          array[cgroup_policy]] {
  //                            nla_len: offsetof = 0x1da4 (2 bytes)
  //                            nla_type: const = 0x2 (2 bytes)
  //                            payload: array[cgroup_policy] {
  //                              union cgroup_policy {
  //                                TCA_CGROUP_ACT:
  //                                nlattr_t[const[TCA_CGROUP_ACT, int16],
  //                                array[tca_actions]] {
  //                                  nla_len: offsetof = 0x1da0 (2 bytes)
  //                                  nla_type: const = 0x1 (2 bytes)
  //                                  payload: array[tca_actions] {
  //                                    union tca_actions {
  //                                      m_connmark:
  //                                      nlattr_tt[int16:14[0:TCA_ACT_MAX_PRIO],
  //                                      0, 0, tcf_action_policy["connmark",
  //                                      connmark_policy]] {
  //                                        nla_len: offsetof = 0x94 (2 bytes)
  //                                        nla_type: int16 = 0x0 (1 bytes)
  //                                        NLA_F_NET_BYTEORDER: const = 0x0 (0
  //                                        bytes) NLA_F_NESTED: const = 0x0 (1
  //                                        bytes) payload:
  //                                        tcf_action_policy["connmark",
  //                                        connmark_policy] {
  //                                          TCA_ACT_KIND:
  //                                          nlattr_t[const[TCA_ACT_KIND,
  //                                          int16], string["connmark"]] {
  //                                            nla_len: offsetof = 0xd (2
  //                                            bytes) nla_type: const = 0x1 (2
  //                                            bytes) payload: buffer: {63 6f
  //                                            6e 6e 6d 61 72 6b 00} (length
  //                                            0x9) size: buffer: {} (length
  //                                            0x0) pad = 0x0 (3 bytes)
  //                                          }
  //                                          TCA_ACT_OPTIONS:
  //                                          nlattr_tt[const[TCA_ACT_OPTIONS,
  //                                          int16:14], 0, 1,
  //                                          array[connmark_policy]] {
  //                                            nla_len: offsetof = 0x3c (2
  //                                            bytes) nla_type: const = 0x2 (1
  //                                            bytes) NLA_F_NET_BYTEORDER:
  //                                            const = 0x0 (0 bytes)
  //                                            NLA_F_NESTED: const = 0x1 (1
  //                                            bytes) payload:
  //                                            array[connmark_policy] {
  //                                              union connmark_policy {
  //                                                TCA_CONNMARK_PARMS:
  //                                                nlattr_t[const[TCA_CONNMARK_PARMS,
  //                                                int16], tc_connmark] {
  //                                                  nla_len: offsetof = 0x1c
  //                                                  (2 bytes) nla_type: const
  //                                                  = 0x1 (2 bytes) payload:
  //                                                  tc_connmark {
  //                                                    tc_gen: tc_gen {
  //                                                      index: int32 = 0x9 (4
  //                                                      bytes) capab: int32 =
  //                                                      0x671 (4 bytes)
  //                                                      action: tc_actions =
  //                                                      0x7 (4 bytes) refcnt:
  //                                                      int32 = 0x7 (4 bytes)
  //                                                      bindcnt: int32 = 0x3
  //                                                      (4 bytes)
  //                                                    }
  //                                                    zone: int16 = 0xe57 (2
  //                                                    bytes) pad = 0x0 (2
  //                                                    bytes)
  //                                                  }
  //                                                  size: buffer: {} (length
  //                                                  0x0)
  //                                                }
  //                                              }
  //                                              union connmark_policy {
  //                                                TCA_CONNMARK_PARMS:
  //                                                nlattr_t[const[TCA_CONNMARK_PARMS,
  //                                                int16], tc_connmark] {
  //                                                  nla_len: offsetof = 0x1c
  //                                                  (2 bytes) nla_type: const
  //                                                  = 0x1 (2 bytes) payload:
  //                                                  tc_connmark {
  //                                                    tc_gen: tc_gen {
  //                                                      index: int32 = 0x8 (4
  //                                                      bytes) capab: int32 =
  //                                                      0x3 (4 bytes) action:
  //                                                      tc_actions =
  //                                                      0xffffffffffffffff (4
  //                                                      bytes) refcnt: int32 =
  //                                                      0x5 (4 bytes) bindcnt:
  //                                                      int32 = 0x5854 (4
  //                                                      bytes)
  //                                                    }
  //                                                    zone: int16 = 0xfffc (2
  //                                                    bytes) pad = 0x0 (2
  //                                                    bytes)
  //                                                  }
  //                                                  size: buffer: {} (length
  //                                                  0x0)
  //                                                }
  //                                              }
  //                                            }
  //                                            size: buffer: {} (length 0x0)
  //                                          }
  //                                          TCA_ACT_COOKIE:
  //                                          nlattr_t[const[TCA_ACT_COOKIE,
  //                                          int16], array[int8]] {
  //                                            nla_len: offsetof = 0x29 (2
  //                                            bytes) nla_type: const = 0x6 (2
  //                                            bytes) payload: buffer: {86 03
  //                                            f5 39 b6 a7 af 82 4d 26 2b f6 54
  //                                            e2 99 8b 1e f3 d2 c0 c3 dc ff 53
  //                                            29 f4 0e 2a 66 13 62 2a 8e 0c 66
  //                                            06 97} (length 0x25) size:
  //                                            buffer: {} (length 0x0)
  //                                          }
  //                                          TCA_ACT_FLAGS:
  //                                          nlattr_t[const[TCA_ACT_FLAGS,
  //                                          int16],
  //                                          nla_bitfield32[tcf_action_policy_flags]]
  //                                          {
  //                                            nla_len: offsetof = 0xc (2
  //                                            bytes) nla_type: const = 0x7 (2
  //                                            bytes) payload:
  //                                            nla_bitfield32[tcf_action_policy_flags]
  //                                            {
  //                                              value: tcf_action_policy_flags
  //                                              = 0x1 (4 bytes) selector:
  //                                              tcf_action_policy_flags = 0x1
  //                                              (4 bytes)
  //                                            }
  //                                            size: buffer: {} (length 0x0)
  //                                          }
  //                                          TCA_ACT_HW_STATS:
  //                                          nlattr_t[const[TCA_ACT_HW_STATS,
  //                                          int16],
  //                                          nla_bitfield32[tcf_action_policy_hw_stats]]
  //                                          {
  //                                            nla_len: offsetof = 0xc (2
  //                                            bytes) nla_type: const = 0x8 (2
  //                                            bytes) payload:
  //                                            nla_bitfield32[tcf_action_policy_hw_stats]
  //                                            {
  //                                              value:
  //                                              tcf_action_policy_hw_stats =
  //                                              0x1 (4 bytes) selector:
  //                                              tcf_action_policy_hw_stats =
  //                                              0x3 (4 bytes)
  //                                            }
  //                                            size: buffer: {} (length 0x0)
  //                                          }
  //                                        }
  //                                        size: buffer: {} (length 0x0)
  //                                      }
  //                                    }
  //                                    union tca_actions {
  //                                      m_connmark:
  //                                      nlattr_tt[int16:14[0:TCA_ACT_MAX_PRIO],
  //                                      0, 0, tcf_action_policy["connmark",
  //                                      connmark_policy]] {
  //                                        nla_len: offsetof = 0x50 (2 bytes)
  //                                        nla_type: int16 = 0x14 (1 bytes)
  //                                        NLA_F_NET_BYTEORDER: const = 0x0 (0
  //                                        bytes) NLA_F_NESTED: const = 0x0 (1
  //                                        bytes) payload:
  //                                        tcf_action_policy["connmark",
  //                                        connmark_policy] {
  //                                          TCA_ACT_KIND:
  //                                          nlattr_t[const[TCA_ACT_KIND,
  //                                          int16], string["connmark"]] {
  //                                            nla_len: offsetof = 0xd (2
  //                                            bytes) nla_type: const = 0x1 (2
  //                                            bytes) payload: buffer: {63 6f
  //                                            6e 6e 6d 61 72 6b 00} (length
  //                                            0x9) size: buffer: {} (length
  //                                            0x0) pad = 0x0 (3 bytes)
  //                                          }
  //                                          TCA_ACT_OPTIONS:
  //                                          nlattr_tt[const[TCA_ACT_OPTIONS,
  //                                          int16:14], 0, 1,
  //                                          array[connmark_policy]] {
  //                                            nla_len: offsetof = 0x20 (2
  //                                            bytes) nla_type: const = 0x2 (1
  //                                            bytes) NLA_F_NET_BYTEORDER:
  //                                            const = 0x0 (0 bytes)
  //                                            NLA_F_NESTED: const = 0x1 (1
  //                                            bytes) payload:
  //                                            array[connmark_policy] {
  //                                              union connmark_policy {
  //                                                TCA_CONNMARK_PARMS:
  //                                                nlattr_t[const[TCA_CONNMARK_PARMS,
  //                                                int16], tc_connmark] {
  //                                                  nla_len: offsetof = 0x1c
  //                                                  (2 bytes) nla_type: const
  //                                                  = 0x1 (2 bytes) payload:
  //                                                  tc_connmark {
  //                                                    tc_gen: tc_gen {
  //                                                      index: int32 = 0x8001
  //                                                      (4 bytes) capab: int32
  //                                                      = 0x10001 (4 bytes)
  //                                                      action: tc_actions =
  //                                                      0x3 (4 bytes) refcnt:
  //                                                      int32 = 0x4 (4 bytes)
  //                                                      bindcnt: int32 = 0x800
  //                                                      (4 bytes)
  //                                                    }
  //                                                    zone: int16 = 0x2 (2
  //                                                    bytes) pad = 0x0 (2
  //                                                    bytes)
  //                                                  }
  //                                                  size: buffer: {} (length
  //                                                  0x0)
  //                                                }
  //                                              }
  //                                            }
  //                                            size: buffer: {} (length 0x0)
  //                                          }
  //                                          TCA_ACT_COOKIE:
  //                                          nlattr_t[const[TCA_ACT_COOKIE,
  //                                          int16], array[int8]] {
  //                                            nla_len: offsetof = 0x4 (2
  //                                            bytes) nla_type: const = 0x6 (2
  //                                            bytes) payload: buffer: {}
  //                                            (length 0x0) size: buffer: {}
  //                                            (length 0x0)
  //                                          }
  //                                          TCA_ACT_FLAGS:
  //                                          nlattr_t[const[TCA_ACT_FLAGS,
  //                                          int16],
  //                                          nla_bitfield32[tcf_action_policy_flags]]
  //                                          {
  //                                            nla_len: offsetof = 0xc (2
  //                                            bytes) nla_type: const = 0x7 (2
  //                                            bytes) payload:
  //                                            nla_bitfield32[tcf_action_policy_flags]
  //                                            {
  //                                              value: tcf_action_policy_flags
  //                                              = 0x0 (4 bytes) selector:
  //                                              tcf_action_policy_flags = 0x1
  //                                              (4 bytes)
  //                                            }
  //                                            size: buffer: {} (length 0x0)
  //                                          }
  //                                          TCA_ACT_HW_STATS:
  //                                          nlattr_t[const[TCA_ACT_HW_STATS,
  //                                          int16],
  //                                          nla_bitfield32[tcf_action_policy_hw_stats]]
  //                                          {
  //                                            nla_len: offsetof = 0xc (2
  //                                            bytes) nla_type: const = 0x8 (2
  //                                            bytes) payload:
  //                                            nla_bitfield32[tcf_action_policy_hw_stats]
  //                                            {
  //                                              value:
  //                                              tcf_action_policy_hw_stats =
  //                                              0x3 (4 bytes) selector:
  //                                              tcf_action_policy_hw_stats =
  //                                              0x1 (4 bytes)
  //                                            }
  //                                            size: buffer: {} (length 0x0)
  //                                          }
  //                                        }
  //                                        size: buffer: {} (length 0x0)
  //                                      }
  //                                    }
  //                                    union tca_actions {
  //                                      m_pedit:
  //                                      nlattr_tt[int16:14[0:TCA_ACT_MAX_PRIO],
  //                                      0, 0, tcf_action_policy["pedit",
  //                                      pedit_policy]] {
  //                                        nla_len: offsetof = 0xe68 (2 bytes)
  //                                        nla_type: int16 = 0x5 (1 bytes)
  //                                        NLA_F_NET_BYTEORDER: const = 0x0 (0
  //                                        bytes) NLA_F_NESTED: const = 0x0 (1
  //                                        bytes) payload:
  //                                        tcf_action_policy["pedit",
  //                                        pedit_policy] {
  //                                          TCA_ACT_KIND:
  //                                          nlattr_t[const[TCA_ACT_KIND,
  //                                          int16], string["pedit"]] {
  //                                            nla_len: offsetof = 0xa (2
  //                                            bytes) nla_type: const = 0x1 (2
  //                                            bytes) payload: buffer: {70 65
  //                                            64 69 74 00} (length 0x6) size:
  //                                            buffer: {} (length 0x0) pad =
  //                                            0x0 (2 bytes)
  //                                          }
  //                                          TCA_ACT_OPTIONS:
  //                                          nlattr_tt[const[TCA_ACT_OPTIONS,
  //                                          int16:14], 0, 1,
  //                                          array[pedit_policy]] {
  //                                            nla_len: offsetof = 0xe3c (2
  //                                            bytes) nla_type: const = 0x2 (1
  //                                            bytes) NLA_F_NET_BYTEORDER:
  //                                            const = 0x0 (0 bytes)
  //                                            NLA_F_NESTED: const = 0x1 (1
  //                                            bytes) payload:
  //                                            array[pedit_policy] {
  //                                              union pedit_policy {
  //                                                TCA_PEDIT_PARMS:
  //                                                nlattr_t[const[TCA_PEDIT_PARMS,
  //                                                int16], m_pedit_sel] {
  //                                                  nla_len: offsetof = 0xe38
  //                                                  (2 bytes) nla_type: const
  //                                                  = 0x2 (2 bytes) payload:
  //                                                  m_pedit_sel {
  //                                                    sel: tc_pedit_sel {
  //                                                      tc_gen: tc_gen {
  //                                                        index: int32 =
  //                                                        0x1c000000 (4 bytes)
  //                                                        capab: int32 = 0x40
  //                                                        (4 bytes) action:
  //                                                        tc_actions = 0x4 (4
  //                                                        bytes) refcnt: int32
  //                                                        = 0x7 (4 bytes)
  //                                                        bindcnt: int32 =
  //                                                        0x3fe (4 bytes)
  //                                                      }
  //                                                      nkeys: int8 = 0xb1 (1
  //                                                      bytes) flags: int8 =
  //                                                      0x3 (1 bytes) pad =
  //                                                      0x0 (2 bytes) keys:
  //                                                      array[tc_pedit_key] {
  //                                                        tc_pedit_key {
  //                                                          mask: int32 =
  //                                                          0xf7b7 (4 bytes)
  //                                                          val: int32 = 0x5
  //                                                          (4 bytes) off:
  //                                                          int32 = 0x9 (4
  //                                                          bytes) at: int32 =
  //                                                          0xd (4 bytes)
  //                                                          offmask: int32 =
  //                                                          0xdd (4 bytes)
  //                                                          shift: int32 = 0x5
  //                                                          (4 bytes)
  //                                                        }
  //                                                      }
  //                                                    }
  //                                                    keys:
  //                                                    array[tc_pedit_key] {
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x3 (4
  //                                                        bytes) val: int32 =
  //                                                        0x2 (4 bytes) off:
  //                                                        int32 = 0xffffffff
  //                                                        (4 bytes) at: int32
  //                                                        = 0x3 (4 bytes)
  //                                                        offmask: int32 =
  //                                                        0xd8aa (4 bytes)
  //                                                        shift: int32 = 0x7
  //                                                        (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0xaa2
  //                                                        (4 bytes) val: int32
  //                                                        = 0x6 (4 bytes) off:
  //                                                        int32 = 0x101 (4
  //                                                        bytes) at: int32 =
  //                                                        0x6 (4 bytes)
  //                                                        offmask: int32 = 0x2
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0x3 (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 =
  //                                                        0x200000 (4 bytes)
  //                                                        val: int32 = 0x100
  //                                                        (4 bytes) off: int32
  //                                                        = 0x0 (4 bytes) at:
  //                                                        int32 = 0x5c6 (4
  //                                                        bytes) offmask:
  //                                                        int32 = 0x6830 (4
  //                                                        bytes) shift: int32
  //                                                        = 0x8 (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x2 (4
  //                                                        bytes) val: int32 =
  //                                                        0x311 (4 bytes) off:
  //                                                        int32 = 0x8 (4
  //                                                        bytes) at: int32 =
  //                                                        0x4b (4 bytes)
  //                                                        offmask: int32 =
  //                                                        0x82 (4 bytes)
  //                                                        shift: int32 = 0x8
  //                                                        (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x7 (4
  //                                                        bytes) val: int32 =
  //                                                        0x5 (4 bytes) off:
  //                                                        int32 = 0x2 (4
  //                                                        bytes) at: int32 =
  //                                                        0x212 (4 bytes)
  //                                                        offmask: int32 = 0x7
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0xe1 (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x7 (4
  //                                                        bytes) val: int32 =
  //                                                        0x4 (4 bytes) off:
  //                                                        int32 = 0x8d (4
  //                                                        bytes) at: int32 =
  //                                                        0x1ff (4 bytes)
  //                                                        offmask: int32 =
  //                                                        0x1ff (4 bytes)
  //                                                        shift: int32 =
  //                                                        0x1000 (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x200
  //                                                        (4 bytes) val: int32
  //                                                        = 0x7 (4 bytes) off:
  //                                                        int32 = 0xffffffff
  //                                                        (4 bytes) at: int32
  //                                                        = 0x9 (4 bytes)
  //                                                        offmask: int32 = 0x9
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0x0 (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x7 (4
  //                                                        bytes) val: int32 =
  //                                                        0xfe4 (4 bytes) off:
  //                                                        int32 = 0x1 (4
  //                                                        bytes) at: int32 =
  //                                                        0x0 (4 bytes)
  //                                                        offmask: int32 =
  //                                                        0x624 (4 bytes)
  //                                                        shift: int32 =
  //                                                        0xb513 (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x8 (4
  //                                                        bytes) val: int32 =
  //                                                        0x3 (4 bytes) off:
  //                                                        int32 = 0x7ff (4
  //                                                        bytes) at: int32 =
  //                                                        0x70 (4 bytes)
  //                                                        offmask: int32 = 0x6
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0x8000 (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 =
  //                                                        0xfffffffe (4 bytes)
  //                                                        val: int32 = 0x0 (4
  //                                                        bytes) off: int32 =
  //                                                        0x3ff (4 bytes) at:
  //                                                        int32 = 0xb06 (4
  //                                                        bytes) offmask:
  //                                                        int32 = 0x1 (4
  //                                                        bytes) shift: int32
  //                                                        = 0x6 (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x5 (4
  //                                                        bytes) val: int32 =
  //                                                        0x1 (4 bytes) off:
  //                                                        int32 = 0xdb (4
  //                                                        bytes) at: int32 =
  //                                                        0x6 (4 bytes)
  //                                                        offmask: int32 = 0x2
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0x4 (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x9 (4
  //                                                        bytes) val: int32 =
  //                                                        0x4 (4 bytes) off:
  //                                                        int32 = 0x519f (4
  //                                                        bytes) at: int32 =
  //                                                        0x5 (4 bytes)
  //                                                        offmask: int32 = 0x6
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0x31c4 (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x7 (4
  //                                                        bytes) val: int32 =
  //                                                        0x7 (4 bytes) off:
  //                                                        int32 = 0x3ff (4
  //                                                        bytes) at: int32 =
  //                                                        0x1 (4 bytes)
  //                                                        offmask: int32 =
  //                                                        0x8000 (4 bytes)
  //                                                        shift: int32 = 0x5
  //                                                        (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 =
  //                                                        0x7fffffff (4 bytes)
  //                                                        val: int32 = 0x1 (4
  //                                                        bytes) off: int32 =
  //                                                        0x5 (4 bytes) at:
  //                                                        int32 = 0xfe45 (4
  //                                                        bytes) offmask:
  //                                                        int32 = 0x5 (4
  //                                                        bytes) shift: int32
  //                                                        = 0xb (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0xbd
  //                                                        (4 bytes) val: int32
  //                                                        = 0x5f05 (4 bytes)
  //                                                        off: int32 = 0x8 (4
  //                                                        bytes) at: int32 =
  //                                                        0xf (4 bytes)
  //                                                        offmask: int32 = 0x1
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0xa (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x0 (4
  //                                                        bytes) val: int32 =
  //                                                        0x8000 (4 bytes)
  //                                                        off: int32 = 0x3 (4
  //                                                        bytes) at: int32 =
  //                                                        0x7 (4 bytes)
  //                                                        offmask: int32 =
  //                                                        0xd17 (4 bytes)
  //                                                        shift: int32 = 0x7
  //                                                        (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0xae
  //                                                        (4 bytes) val: int32
  //                                                        = 0x7 (4 bytes) off:
  //                                                        int32 = 0x2 (4
  //                                                        bytes) at: int32 =
  //                                                        0x2 (4 bytes)
  //                                                        offmask: int32 = 0x9
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0x0 (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x6 (4
  //                                                        bytes) val: int32 =
  //                                                        0x4 (4 bytes) off:
  //                                                        int32 = 0xa (4
  //                                                        bytes) at: int32 =
  //                                                        0x3 (4 bytes)
  //                                                        offmask: int32 = 0x1
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0x3 (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x2 (4
  //                                                        bytes) val: int32 =
  //                                                        0xa502 (4 bytes)
  //                                                        off: int32 = 0x3 (4
  //                                                        bytes) at: int32 =
  //                                                        0xfffffff7 (4 bytes)
  //                                                        offmask: int32 =
  //                                                        0x81 (4 bytes)
  //                                                        shift: int32 = 0x1
  //                                                        (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x80
  //                                                        (4 bytes) val: int32
  //                                                        = 0x8 (4 bytes) off:
  //                                                        int32 = 0x9 (4
  //                                                        bytes) at: int32 =
  //                                                        0x0 (4 bytes)
  //                                                        offmask: int32 = 0x0
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0x7 (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x9 (4
  //                                                        bytes) val: int32 =
  //                                                        0x4 (4 bytes) off:
  //                                                        int32 = 0x1400000 (4
  //                                                        bytes) at: int32 =
  //                                                        0x9 (4 bytes)
  //                                                        offmask: int32 =
  //                                                        0xad (4 bytes)
  //                                                        shift: int32 = 0x6
  //                                                        (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0xc (4
  //                                                        bytes) val: int32 =
  //                                                        0xffffff00 (4 bytes)
  //                                                        off: int32 = 0x5 (4
  //                                                        bytes) at: int32 =
  //                                                        0x3 (4 bytes)
  //                                                        offmask: int32 = 0x3
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0x3 (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x7 (4
  //                                                        bytes) val: int32 =
  //                                                        0x32da135 (4 bytes)
  //                                                        off: int32 = 0xb (4
  //                                                        bytes) at: int32 =
  //                                                        0x8 (4 bytes)
  //                                                        offmask: int32 =
  //                                                        0xa93c (4 bytes)
  //                                                        shift: int32 = 0x6
  //                                                        (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x3e
  //                                                        (4 bytes) val: int32
  //                                                        = 0x5bce (4 bytes)
  //                                                        off: int32 = 0x4 (4
  //                                                        bytes) at: int32 =
  //                                                        0x7ff (4 bytes)
  //                                                        offmask: int32 =
  //                                                        0x80000001 (4 bytes)
  //                                                        shift: int32 = 0x32b
  //                                                        (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 =
  //                                                        0xffffffff (4 bytes)
  //                                                        val: int32 = 0x9 (4
  //                                                        bytes) off: int32 =
  //                                                        0x100 (4 bytes) at:
  //                                                        int32 = 0x1 (4
  //                                                        bytes) offmask:
  //                                                        int32 = 0xfffffffb
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0x9 (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 =
  //                                                        0x10001 (4 bytes)
  //                                                        val: int32 = 0x1 (4
  //                                                        bytes) off: int32 =
  //                                                        0xe0cc (4 bytes) at:
  //                                                        int32 = 0x8 (4
  //                                                        bytes) offmask:
  //                                                        int32 = 0x9 (4
  //                                                        bytes) shift: int32
  //                                                        = 0x2 (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0xf7
  //                                                        (4 bytes) val: int32
  //                                                        = 0x5 (4 bytes) off:
  //                                                        int32 = 0x800 (4
  //                                                        bytes) at: int32 =
  //                                                        0x8 (4 bytes)
  //                                                        offmask: int32 =
  //                                                        0x7f (4 bytes)
  //                                                        shift: int32 = 0x0
  //                                                        (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0xdbeb
  //                                                        (4 bytes) val: int32
  //                                                        = 0x8 (4 bytes) off:
  //                                                        int32 = 0x1 (4
  //                                                        bytes) at: int32 =
  //                                                        0x1 (4 bytes)
  //                                                        offmask: int32 = 0x1
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0x80000 (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x5 (4
  //                                                        bytes) val: int32 =
  //                                                        0x0 (4 bytes) off:
  //                                                        int32 = 0xbaf9 (4
  //                                                        bytes) at: int32 =
  //                                                        0x4 (4 bytes)
  //                                                        offmask: int32 =
  //                                                        0x28000000 (4 bytes)
  //                                                        shift: int32 = 0x9
  //                                                        (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x0 (4
  //                                                        bytes) val: int32 =
  //                                                        0x8 (4 bytes) off:
  //                                                        int32 = 0x6 (4
  //                                                        bytes) at: int32 =
  //                                                        0x9 (4 bytes)
  //                                                        offmask: int32 = 0x5
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0xfffffff4
  //                                                        (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0xadfe
  //                                                        (4 bytes) val: int32
  //                                                        = 0x9 (4 bytes) off:
  //                                                        int32 = 0x1 (4
  //                                                        bytes) at: int32 =
  //                                                        0x4 (4 bytes)
  //                                                        offmask: int32 =
  //                                                        0xfaf (4 bytes)
  //                                                        shift: int32 = 0x81
  //                                                        (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x800
  //                                                        (4 bytes) val: int32
  //                                                        = 0x5 (4 bytes) off:
  //                                                        int32 = 0x3 (4
  //                                                        bytes) at: int32 =
  //                                                        0x5 (4 bytes)
  //                                                        offmask: int32 = 0x5
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0x1e4 (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x6 (4
  //                                                        bytes) val: int32 =
  //                                                        0x7 (4 bytes) off:
  //                                                        int32 = 0x8 (4
  //                                                        bytes) at: int32 =
  //                                                        0x8 (4 bytes)
  //                                                        offmask: int32 =
  //                                                        0xad38 (4 bytes)
  //                                                        shift: int32 = 0x6
  //                                                        (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0xa (4
  //                                                        bytes) val: int32 =
  //                                                        0x4467 (4 bytes)
  //                                                        off: int32 = 0x9 (4
  //                                                        bytes) at: int32 =
  //                                                        0x5 (4 bytes)
  //                                                        offmask: int32 =
  //                                                        0x401 (4 bytes)
  //                                                        shift: int32 = 0x1
  //                                                        (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x1ff
  //                                                        (4 bytes) val: int32
  //                                                        = 0x400 (4 bytes)
  //                                                        off: int32 = 0x9 (4
  //                                                        bytes) at: int32 =
  //                                                        0x80000001 (4 bytes)
  //                                                        offmask: int32 =
  //                                                        0x7ff (4 bytes)
  //                                                        shift: int32 = 0xb6
  //                                                        (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x1000
  //                                                        (4 bytes) val: int32
  //                                                        = 0xffff8001 (4
  //                                                        bytes) off: int32 =
  //                                                        0x40 (4 bytes) at:
  //                                                        int32 = 0x2 (4
  //                                                        bytes) offmask:
  //                                                        int32 = 0x800 (4
  //                                                        bytes) shift: int32
  //                                                        = 0x3 (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x9 (4
  //                                                        bytes) val: int32 =
  //                                                        0xb (4 bytes) off:
  //                                                        int32 = 0x5 (4
  //                                                        bytes) at: int32 =
  //                                                        0x9 (4 bytes)
  //                                                        offmask: int32 = 0x4
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0x9 (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x0 (4
  //                                                        bytes) val: int32 =
  //                                                        0xe (4 bytes) off:
  //                                                        int32 = 0x4 (4
  //                                                        bytes) at: int32 =
  //                                                        0x4 (4 bytes)
  //                                                        offmask: int32 = 0x9
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0x6 (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x5 (4
  //                                                        bytes) val: int32 =
  //                                                        0x4 (4 bytes) off:
  //                                                        int32 = 0x6 (4
  //                                                        bytes) at: int32 =
  //                                                        0xfffffffe (4 bytes)
  //                                                        offmask: int32 = 0x4
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0xfff (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x5 (4
  //                                                        bytes) val: int32 =
  //                                                        0x0 (4 bytes) off:
  //                                                        int32 = 0x1 (4
  //                                                        bytes) at: int32 =
  //                                                        0x5a48 (4 bytes)
  //                                                        offmask: int32 = 0x6
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0xfffffff9
  //                                                        (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 =
  //                                                        0xffffffff (4 bytes)
  //                                                        val: int32 =
  //                                                        0x80000000 (4 bytes)
  //                                                        off: int32 = 0x6d (4
  //                                                        bytes) at: int32 =
  //                                                        0x0 (4 bytes)
  //                                                        offmask: int32 = 0x8
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0xe (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x9 (4
  //                                                        bytes) val: int32 =
  //                                                        0xfffffffa (4 bytes)
  //                                                        off: int32 = 0x5 (4
  //                                                        bytes) at: int32 =
  //                                                        0x6 (4 bytes)
  //                                                        offmask: int32 = 0x8
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0x9 (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x7fff
  //                                                        (4 bytes) val: int32
  //                                                        = 0x3 (4 bytes) off:
  //                                                        int32 = 0x5 (4
  //                                                        bytes) at: int32 =
  //                                                        0x3ff (4 bytes)
  //                                                        offmask: int32 = 0x8
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0x7 (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 =
  //                                                        0x10001 (4 bytes)
  //                                                        val: int32 = 0x7 (4
  //                                                        bytes) off: int32 =
  //                                                        0x2 (4 bytes) at:
  //                                                        int32 = 0x7ff (4
  //                                                        bytes) offmask:
  //                                                        int32 = 0x9 (4
  //                                                        bytes) shift: int32
  //                                                        = 0x6 (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x3 (4
  //                                                        bytes) val: int32 =
  //                                                        0x9de (4 bytes) off:
  //                                                        int32 = 0x4 (4
  //                                                        bytes) at: int32 =
  //                                                        0x11 (4 bytes)
  //                                                        offmask: int32 = 0x7
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0x9 (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x3 (4
  //                                                        bytes) val: int32 =
  //                                                        0x9 (4 bytes) off:
  //                                                        int32 = 0x8f (4
  //                                                        bytes) at: int32 =
  //                                                        0xffffdd1a (4 bytes)
  //                                                        offmask: int32 =
  //                                                        0x10 (4 bytes)
  //                                                        shift: int32 = 0x2
  //                                                        (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x1 (4
  //                                                        bytes) val: int32 =
  //                                                        0xa8a9 (4 bytes)
  //                                                        off: int32 = 0x1 (4
  //                                                        bytes) at: int32 =
  //                                                        0x5 (4 bytes)
  //                                                        offmask: int32 = 0x7
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0x401 (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x4 (4
  //                                                        bytes) val: int32 =
  //                                                        0xffff (4 bytes)
  //                                                        off: int32 = 0x1000
  //                                                        (4 bytes) at: int32
  //                                                        = 0x1 (4 bytes)
  //                                                        offmask: int32 = 0x6
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0x1 (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x2a
  //                                                        (4 bytes) val: int32
  //                                                        = 0x0 (4 bytes) off:
  //                                                        int32 = 0x80000000
  //                                                        (4 bytes) at: int32
  //                                                        = 0x0 (4 bytes)
  //                                                        offmask: int32 =
  //                                                        0xfc (4 bytes)
  //                                                        shift: int32 = 0x3
  //                                                        (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0xc55b
  //                                                        (4 bytes) val: int32
  //                                                        = 0x5 (4 bytes) off:
  //                                                        int32 = 0xb (4
  //                                                        bytes) at: int32 =
  //                                                        0x8001 (4 bytes)
  //                                                        offmask: int32 = 0x4
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0x1ff (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x7 (4
  //                                                        bytes) val: int32 =
  //                                                        0x6 (4 bytes) off:
  //                                                        int32 = 0x0 (4
  //                                                        bytes) at: int32 =
  //                                                        0x1d (4 bytes)
  //                                                        offmask: int32 =
  //                                                        0x42f (4 bytes)
  //                                                        shift: int32 = 0x7
  //                                                        (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 =
  //                                                        0xfffffff8 (4 bytes)
  //                                                        val: int32 = 0x6 (4
  //                                                        bytes) off: int32 =
  //                                                        0x3 (4 bytes) at:
  //                                                        int32 = 0x2 (4
  //                                                        bytes) offmask:
  //                                                        int32 = 0x7 (4
  //                                                        bytes) shift: int32
  //                                                        = 0x7 (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x1 (4
  //                                                        bytes) val: int32 =
  //                                                        0x2 (4 bytes) off:
  //                                                        int32 = 0x5 (4
  //                                                        bytes) at: int32 =
  //                                                        0x30 (4 bytes)
  //                                                        offmask: int32 =
  //                                                        0xfe68 (4 bytes)
  //                                                        shift: int32 = 0x800
  //                                                        (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 =
  //                                                        0x80000000 (4 bytes)
  //                                                        val: int32 = 0x2 (4
  //                                                        bytes) off: int32 =
  //                                                        0x1 (4 bytes) at:
  //                                                        int32 = 0x8 (4
  //                                                        bytes) offmask:
  //                                                        int32 = 0x0 (4
  //                                                        bytes) shift: int32
  //                                                        = 0xffffffff (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x3 (4
  //                                                        bytes) val: int32 =
  //                                                        0x6021db75 (4 bytes)
  //                                                        off: int32 = 0x7fff
  //                                                        (4 bytes) at: int32
  //                                                        = 0x1000 (4 bytes)
  //                                                        offmask: int32 =
  //                                                        0xc1 (4 bytes)
  //                                                        shift: int32 =
  //                                                        0x1add65aa (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x2 (4
  //                                                        bytes) val: int32 =
  //                                                        0x7 (4 bytes) off:
  //                                                        int32 = 0x4 (4
  //                                                        bytes) at: int32 =
  //                                                        0x2 (4 bytes)
  //                                                        offmask: int32 =
  //                                                        0xe9 (4 bytes)
  //                                                        shift: int32 = 0x986
  //                                                        (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0xba
  //                                                        (4 bytes) val: int32
  //                                                        = 0x8 (4 bytes) off:
  //                                                        int32 = 0x6 (4
  //                                                        bytes) at: int32 =
  //                                                        0x401 (4 bytes)
  //                                                        offmask: int32 = 0x4
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0x10 (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x9 (4
  //                                                        bytes) val: int32 =
  //                                                        0x7fffffff (4 bytes)
  //                                                        off: int32 = 0xb70f
  //                                                        (4 bytes) at: int32
  //                                                        = 0x40 (4 bytes)
  //                                                        offmask: int32 = 0x3
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0xfffffffe
  //                                                        (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x4 (4
  //                                                        bytes) val: int32 =
  //                                                        0x3 (4 bytes) off:
  //                                                        int32 = 0x4 (4
  //                                                        bytes) at: int32 =
  //                                                        0xd (4 bytes)
  //                                                        offmask: int32 =
  //                                                        0xb24 (4 bytes)
  //                                                        shift: int32 = 0x6
  //                                                        (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0xbf
  //                                                        (4 bytes) val: int32
  //                                                        = 0x3 (4 bytes) off:
  //                                                        int32 = 0xbf6 (4
  //                                                        bytes) at: int32 =
  //                                                        0xfffeffff (4 bytes)
  //                                                        offmask: int32 = 0x2
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0x3 (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x3 (4
  //                                                        bytes) val: int32 =
  //                                                        0x6 (4 bytes) off:
  //                                                        int32 = 0x4 (4
  //                                                        bytes) at: int32 =
  //                                                        0x7c6 (4 bytes)
  //                                                        offmask: int32 =
  //                                                        0x80000001 (4 bytes)
  //                                                        shift: int32 = 0x1
  //                                                        (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x58e2
  //                                                        (4 bytes) val: int32
  //                                                        = 0x1 (4 bytes) off:
  //                                                        int32 = 0x4 (4
  //                                                        bytes) at: int32 =
  //                                                        0x7 (4 bytes)
  //                                                        offmask: int32 =
  //                                                        0x3ff (4 bytes)
  //                                                        shift: int32 = 0x4
  //                                                        (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x6 (4
  //                                                        bytes) val: int32 =
  //                                                        0xb4 (4 bytes) off:
  //                                                        int32 = 0xeb (4
  //                                                        bytes) at: int32 =
  //                                                        0x3 (4 bytes)
  //                                                        offmask: int32 = 0x6
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0xe (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0xc (4
  //                                                        bytes) val: int32 =
  //                                                        0x1 (4 bytes) off:
  //                                                        int32 = 0x3 (4
  //                                                        bytes) at: int32 =
  //                                                        0xf (4 bytes)
  //                                                        offmask: int32 = 0x7
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0xdb10ee8a
  //                                                        (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x3 (4
  //                                                        bytes) val: int32 =
  //                                                        0xf (4 bytes) off:
  //                                                        int32 = 0x81 (4
  //                                                        bytes) at: int32 =
  //                                                        0x420d (4 bytes)
  //                                                        offmask: int32 = 0xa
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0xad78 (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x2 (4
  //                                                        bytes) val: int32 =
  //                                                        0x4 (4 bytes) off:
  //                                                        int32 = 0xfffffffc
  //                                                        (4 bytes) at: int32
  //                                                        = 0x401 (4 bytes)
  //                                                        offmask: int32 = 0x4
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0x2 (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x4 (4
  //                                                        bytes) val: int32 =
  //                                                        0x4 (4 bytes) off:
  //                                                        int32 = 0x3 (4
  //                                                        bytes) at: int32 =
  //                                                        0xf908 (4 bytes)
  //                                                        offmask: int32 = 0x2
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0x400 (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x800
  //                                                        (4 bytes) val: int32
  //                                                        = 0x6 (4 bytes) off:
  //                                                        int32 = 0x2 (4
  //                                                        bytes) at: int32 =
  //                                                        0x4 (4 bytes)
  //                                                        offmask: int32 =
  //                                                        0x8e20 (4 bytes)
  //                                                        shift: int32 = 0x4
  //                                                        (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 =
  //                                                        0x7ae4fc5e (4 bytes)
  //                                                        val: int32 = 0x3 (4
  //                                                        bytes) off: int32 =
  //                                                        0xf (4 bytes) at:
  //                                                        int32 = 0xf87 (4
  //                                                        bytes) offmask:
  //                                                        int32 = 0x2 (4
  //                                                        bytes) shift: int32
  //                                                        = 0x1 (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x2 (4
  //                                                        bytes) val: int32 =
  //                                                        0x7 (4 bytes) off:
  //                                                        int32 = 0xed7e (4
  //                                                        bytes) at: int32 =
  //                                                        0x4 (4 bytes)
  //                                                        offmask: int32 = 0x5
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0xdc (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x4 (4
  //                                                        bytes) val: int32 =
  //                                                        0x154 (4 bytes) off:
  //                                                        int32 = 0xfffffe00
  //                                                        (4 bytes) at: int32
  //                                                        = 0x3ff80000 (4
  //                                                        bytes) offmask:
  //                                                        int32 = 0x2 (4
  //                                                        bytes) shift: int32
  //                                                        = 0xa (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x6 (4
  //                                                        bytes) val: int32 =
  //                                                        0x5 (4 bytes) off:
  //                                                        int32 = 0x3 (4
  //                                                        bytes) at: int32 =
  //                                                        0x3a84 (4 bytes)
  //                                                        offmask: int32 = 0x0
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0x1 (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0xeea1
  //                                                        (4 bytes) val: int32
  //                                                        = 0x9 (4 bytes) off:
  //                                                        int32 = 0x55de2144
  //                                                        (4 bytes) at: int32
  //                                                        = 0x9 (4 bytes)
  //                                                        offmask: int32 =
  //                                                        0x80 (4 bytes)
  //                                                        shift: int32 = 0x7cf
  //                                                        (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x2 (4
  //                                                        bytes) val: int32 =
  //                                                        0x6 (4 bytes) off:
  //                                                        int32 = 0x8 (4
  //                                                        bytes) at: int32 =
  //                                                        0x3 (4 bytes)
  //                                                        offmask: int32 = 0x0
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0x7fffffff
  //                                                        (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x1000
  //                                                        (4 bytes) val: int32
  //                                                        = 0x7f (4 bytes)
  //                                                        off: int32 = 0x8000
  //                                                        (4 bytes) at: int32
  //                                                        = 0xfffffffe (4
  //                                                        bytes) offmask:
  //                                                        int32 = 0x8 (4
  //                                                        bytes) shift: int32
  //                                                        = 0xd1e (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x6 (4
  //                                                        bytes) val: int32 =
  //                                                        0x2 (4 bytes) off:
  //                                                        int32 = 0x6c5 (4
  //                                                        bytes) at: int32 =
  //                                                        0xd (4 bytes)
  //                                                        offmask: int32 = 0x4
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0x8 (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x1 (4
  //                                                        bytes) val: int32 =
  //                                                        0x5 (4 bytes) off:
  //                                                        int32 = 0x10000 (4
  //                                                        bytes) at: int32 =
  //                                                        0xc (4 bytes)
  //                                                        offmask: int32 =
  //                                                        0x7ff (4 bytes)
  //                                                        shift: int32 = 0x5
  //                                                        (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x4 (4
  //                                                        bytes) val: int32 =
  //                                                        0x7 (4 bytes) off:
  //                                                        int32 = 0x264564e6
  //                                                        (4 bytes) at: int32
  //                                                        = 0xea (4 bytes)
  //                                                        offmask: int32 =
  //                                                        0x7fff (4 bytes)
  //                                                        shift: int32 = 0x1
  //                                                        (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0xa (4
  //                                                        bytes) val: int32 =
  //                                                        0x4 (4 bytes) off:
  //                                                        int32 = 0x2 (4
  //                                                        bytes) at: int32 =
  //                                                        0x3 (4 bytes)
  //                                                        offmask: int32 = 0x0
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0x7 (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 =
  //                                                        0x84000000 (4 bytes)
  //                                                        val: int32 = 0x9 (4
  //                                                        bytes) off: int32 =
  //                                                        0x2 (4 bytes) at:
  //                                                        int32 = 0x8000 (4
  //                                                        bytes) offmask:
  //                                                        int32 = 0x5 (4
  //                                                        bytes) shift: int32
  //                                                        = 0x4 (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x0 (4
  //                                                        bytes) val: int32 =
  //                                                        0x2 (4 bytes) off:
  //                                                        int32 = 0xa483 (4
  //                                                        bytes) at: int32 =
  //                                                        0x9 (4 bytes)
  //                                                        offmask: int32 = 0x2
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0x6 (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x22
  //                                                        (4 bytes) val: int32
  //                                                        = 0x2 (4 bytes) off:
  //                                                        int32 = 0x9 (4
  //                                                        bytes) at: int32 =
  //                                                        0x1 (4 bytes)
  //                                                        offmask: int32 = 0x3
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0x4 (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x3 (4
  //                                                        bytes) val: int32 =
  //                                                        0x3 (4 bytes) off:
  //                                                        int32 = 0x7fff (4
  //                                                        bytes) at: int32 =
  //                                                        0x0 (4 bytes)
  //                                                        offmask: int32 =
  //                                                        0x46 (4 bytes)
  //                                                        shift: int32 =
  //                                                        0x7fffffff (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x6 (4
  //                                                        bytes) val: int32 =
  //                                                        0x8 (4 bytes) off:
  //                                                        int32 = 0xffffc000
  //                                                        (4 bytes) at: int32
  //                                                        = 0x1ff (4 bytes)
  //                                                        offmask: int32 = 0x8
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0x0 (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0xe (4
  //                                                        bytes) val: int32 =
  //                                                        0x1 (4 bytes) off:
  //                                                        int32 = 0x0 (4
  //                                                        bytes) at: int32 =
  //                                                        0x9 (4 bytes)
  //                                                        offmask: int32 = 0x9
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0x8 (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x1000
  //                                                        (4 bytes) val: int32
  //                                                        = 0x9 (4 bytes) off:
  //                                                        int32 = 0xffffffff
  //                                                        (4 bytes) at: int32
  //                                                        = 0x100 (4 bytes)
  //                                                        offmask: int32 =
  //                                                        0x3ff (4 bytes)
  //                                                        shift: int32 = 0x0
  //                                                        (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x80
  //                                                        (4 bytes) val: int32
  //                                                        = 0x1 (4 bytes) off:
  //                                                        int32 = 0x9 (4
  //                                                        bytes) at: int32 =
  //                                                        0x6a59 (4 bytes)
  //                                                        offmask: int32 = 0x4
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0x3 (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x8000
  //                                                        (4 bytes) val: int32
  //                                                        = 0x0 (4 bytes) off:
  //                                                        int32 = 0x100 (4
  //                                                        bytes) at: int32 =
  //                                                        0x1 (4 bytes)
  //                                                        offmask: int32 = 0x0
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0x4 (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x0 (4
  //                                                        bytes) val: int32 =
  //                                                        0x401 (4 bytes) off:
  //                                                        int32 = 0xbe5e (4
  //                                                        bytes) at: int32 =
  //                                                        0x0 (4 bytes)
  //                                                        offmask: int32 =
  //                                                        0x81 (4 bytes)
  //                                                        shift: int32 = 0xd0
  //                                                        (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x6 (4
  //                                                        bytes) val: int32 =
  //                                                        0xa (4 bytes) off:
  //                                                        int32 = 0x146e (4
  //                                                        bytes) at: int32 =
  //                                                        0x8 (4 bytes)
  //                                                        offmask: int32 = 0xe
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0xb08 (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x7ff
  //                                                        (4 bytes) val: int32
  //                                                        = 0x0 (4 bytes) off:
  //                                                        int32 = 0x4 (4
  //                                                        bytes) at: int32 =
  //                                                        0x0 (4 bytes)
  //                                                        offmask: int32 =
  //                                                        0x7f (4 bytes)
  //                                                        shift: int32 = 0x1
  //                                                        (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 =
  //                                                        0xfffffff6 (4 bytes)
  //                                                        val: int32 = 0x5 (4
  //                                                        bytes) off: int32 =
  //                                                        0xe (4 bytes) at:
  //                                                        int32 = 0xff (4
  //                                                        bytes) offmask:
  //                                                        int32 = 0x7 (4
  //                                                        bytes) shift: int32
  //                                                        = 0x6 (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x0 (4
  //                                                        bytes) val: int32 =
  //                                                        0x4c (4 bytes) off:
  //                                                        int32 = 0x8 (4
  //                                                        bytes) at: int32 =
  //                                                        0xfffffffc (4 bytes)
  //                                                        offmask: int32 = 0x2
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0xd42 (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0xff
  //                                                        (4 bytes) val: int32
  //                                                        = 0xfffffffc (4
  //                                                        bytes) off: int32 =
  //                                                        0x2 (4 bytes) at:
  //                                                        int32 = 0x0 (4
  //                                                        bytes) offmask:
  //                                                        int32 = 0xb881 (4
  //                                                        bytes) shift: int32
  //                                                        = 0x6 (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x3 (4
  //                                                        bytes) val: int32 =
  //                                                        0x8 (4 bytes) off:
  //                                                        int32 = 0xffffffff
  //                                                        (4 bytes) at: int32
  //                                                        = 0xfffffbff (4
  //                                                        bytes) offmask:
  //                                                        int32 = 0x1 (4
  //                                                        bytes) shift: int32
  //                                                        = 0x96e (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x5 (4
  //                                                        bytes) val: int32 =
  //                                                        0x6 (4 bytes) off:
  //                                                        int32 = 0x380000 (4
  //                                                        bytes) at: int32 =
  //                                                        0x3 (4 bytes)
  //                                                        offmask: int32 = 0x7
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0x2 (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x0 (4
  //                                                        bytes) val: int32 =
  //                                                        0x81 (4 bytes) off:
  //                                                        int32 = 0x3 (4
  //                                                        bytes) at: int32 =
  //                                                        0x1 (4 bytes)
  //                                                        offmask: int32 = 0x4
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0x4 (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x0 (4
  //                                                        bytes) val: int32 =
  //                                                        0x7 (4 bytes) off:
  //                                                        int32 = 0x8 (4
  //                                                        bytes) at: int32 =
  //                                                        0x5 (4 bytes)
  //                                                        offmask: int32 = 0x3
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0x10 (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x4 (4
  //                                                        bytes) val: int32 =
  //                                                        0x6 (4 bytes) off:
  //                                                        int32 = 0x3 (4
  //                                                        bytes) at: int32 =
  //                                                        0xf (4 bytes)
  //                                                        offmask: int32 = 0xf
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0x9 (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 =
  //                                                        0x7fffffff (4 bytes)
  //                                                        val: int32 = 0x8000
  //                                                        (4 bytes) off: int32
  //                                                        = 0x3ff (4 bytes)
  //                                                        at: int32 = 0x8 (4
  //                                                        bytes) offmask:
  //                                                        int32 = 0x505 (4
  //                                                        bytes) shift: int32
  //                                                        = 0xe3e (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x9 (4
  //                                                        bytes) val: int32 =
  //                                                        0x1 (4 bytes) off:
  //                                                        int32 = 0x7 (4
  //                                                        bytes) at: int32 =
  //                                                        0xd1 (4 bytes)
  //                                                        offmask: int32 = 0x8
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0x1 (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x4 (4
  //                                                        bytes) val: int32 =
  //                                                        0x9da (4 bytes) off:
  //                                                        int32 = 0x2 (4
  //                                                        bytes) at: int32 =
  //                                                        0x7 (4 bytes)
  //                                                        offmask: int32 =
  //                                                        0x9d94bae (4 bytes)
  //                                                        shift: int32 = 0x101
  //                                                        (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x6 (4
  //                                                        bytes) val: int32 =
  //                                                        0x2 (4 bytes) off:
  //                                                        int32 = 0x7f (4
  //                                                        bytes) at: int32 =
  //                                                        0x13760 (4 bytes)
  //                                                        offmask: int32 =
  //                                                        0x10001 (4 bytes)
  //                                                        shift: int32 = 0x9
  //                                                        (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x3c
  //                                                        (4 bytes) val: int32
  //                                                        = 0x0 (4 bytes) off:
  //                                                        int32 = 0x409 (4
  //                                                        bytes) at: int32 =
  //                                                        0x3 (4 bytes)
  //                                                        offmask: int32 =
  //                                                        0xfffeffff (4 bytes)
  //                                                        shift: int32 = 0x0
  //                                                        (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x9 (4
  //                                                        bytes) val: int32 =
  //                                                        0x7 (4 bytes) off:
  //                                                        int32 = 0x0 (4
  //                                                        bytes) at: int32 =
  //                                                        0xf5 (4 bytes)
  //                                                        offmask: int32 =
  //                                                        0xffffffff (4 bytes)
  //                                                        shift: int32 =
  //                                                        0x7c94 (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x5 (4
  //                                                        bytes) val: int32 =
  //                                                        0x3 (4 bytes) off:
  //                                                        int32 = 0xfff (4
  //                                                        bytes) at: int32 =
  //                                                        0x5 (4 bytes)
  //                                                        offmask: int32 =
  //                                                        0x99 (4 bytes)
  //                                                        shift: int32 = 0x4e
  //                                                        (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x10
  //                                                        (4 bytes) val: int32
  //                                                        = 0x3 (4 bytes) off:
  //                                                        int32 = 0x8 (4
  //                                                        bytes) at: int32 =
  //                                                        0x4516 (4 bytes)
  //                                                        offmask: int32 = 0x1
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0xe89c (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x21b
  //                                                        (4 bytes) val: int32
  //                                                        = 0x9 (4 bytes) off:
  //                                                        int32 = 0xa (4
  //                                                        bytes) at: int32 =
  //                                                        0x5 (4 bytes)
  //                                                        offmask: int32 =
  //                                                        0x7fff (4 bytes)
  //                                                        shift: int32 = 0x0
  //                                                        (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x7f
  //                                                        (4 bytes) val: int32
  //                                                        = 0x0 (4 bytes) off:
  //                                                        int32 = 0x489 (4
  //                                                        bytes) at: int32 =
  //                                                        0x1 (4 bytes)
  //                                                        offmask: int32 =
  //                                                        0x80000001 (4 bytes)
  //                                                        shift: int32 = 0xe
  //                                                        (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x5 (4
  //                                                        bytes) val: int32 =
  //                                                        0xfffff1f4 (4 bytes)
  //                                                        off: int32 = 0x7 (4
  //                                                        bytes) at: int32 =
  //                                                        0x5 (4 bytes)
  //                                                        offmask: int32 = 0x7
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0x9 (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x4 (4
  //                                                        bytes) val: int32 =
  //                                                        0x6 (4 bytes) off:
  //                                                        int32 = 0x3 (4
  //                                                        bytes) at: int32 =
  //                                                        0x5 (4 bytes)
  //                                                        offmask: int32 = 0x6
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0x1 (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0xe3e
  //                                                        (4 bytes) val: int32
  //                                                        = 0xfffffffd (4
  //                                                        bytes) off: int32 =
  //                                                        0x3 (4 bytes) at:
  //                                                        int32 = 0x5 (4
  //                                                        bytes) offmask:
  //                                                        int32 = 0x8000 (4
  //                                                        bytes) shift: int32
  //                                                        = 0x2 (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x101
  //                                                        (4 bytes) val: int32
  //                                                        = 0xa2 (4 bytes)
  //                                                        off: int32 = 0xff (4
  //                                                        bytes) at: int32 =
  //                                                        0xfffffff7 (4 bytes)
  //                                                        offmask: int32 =
  //                                                        0x10001 (4 bytes)
  //                                                        shift: int32 =
  //                                                        0x80000000 (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x14a9
  //                                                        (4 bytes) val: int32
  //                                                        = 0x1ff (4 bytes)
  //                                                        off: int32 = 0x3 (4
  //                                                        bytes) at: int32 =
  //                                                        0x2 (4 bytes)
  //                                                        offmask: int32 = 0x7
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0x1 (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0xa82c
  //                                                        (4 bytes) val: int32
  //                                                        = 0x570b (4 bytes)
  //                                                        off: int32 = 0x9 (4
  //                                                        bytes) at: int32 =
  //                                                        0x0 (4 bytes)
  //                                                        offmask: int32 = 0x1
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0x5 (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x2 (4
  //                                                        bytes) val: int32 =
  //                                                        0x3 (4 bytes) off:
  //                                                        int32 = 0x2 (4
  //                                                        bytes) at: int32 =
  //                                                        0xffff0000 (4 bytes)
  //                                                        offmask: int32 = 0x8
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0x7 (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x2 (4
  //                                                        bytes) val: int32 =
  //                                                        0xd2 (4 bytes) off:
  //                                                        int32 = 0x1 (4
  //                                                        bytes) at: int32 =
  //                                                        0x9 (4 bytes)
  //                                                        offmask: int32 =
  //                                                        0x10 (4 bytes)
  //                                                        shift: int32 =
  //                                                        0xfffff000 (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x5 (4
  //                                                        bytes) val: int32 =
  //                                                        0x8 (4 bytes) off:
  //                                                        int32 = 0x1 (4
  //                                                        bytes) at: int32 =
  //                                                        0x0 (4 bytes)
  //                                                        offmask: int32 = 0x4
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0x1c5b (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x2 (4
  //                                                        bytes) val: int32 =
  //                                                        0xffff5a2f (4 bytes)
  //                                                        off: int32 = 0x2 (4
  //                                                        bytes) at: int32 =
  //                                                        0x5 (4 bytes)
  //                                                        offmask: int32 = 0x1
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0x200 (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 =
  //                                                        0x193cfceb (4 bytes)
  //                                                        val: int32 = 0x800
  //                                                        (4 bytes) off: int32
  //                                                        = 0x3 (4 bytes) at:
  //                                                        int32 = 0xd (4
  //                                                        bytes) offmask:
  //                                                        int32 = 0x4 (4
  //                                                        bytes) shift: int32
  //                                                        = 0x5 (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x8 (4
  //                                                        bytes) val: int32 =
  //                                                        0x1fffe (4 bytes)
  //                                                        off: int32 = 0x2 (4
  //                                                        bytes) at: int32 =
  //                                                        0x9 (4 bytes)
  //                                                        offmask: int32 = 0x0
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0xc38c (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x9 (4
  //                                                        bytes) val: int32 =
  //                                                        0x0 (4 bytes) off:
  //                                                        int32 = 0x5 (4
  //                                                        bytes) at: int32 =
  //                                                        0x4 (4 bytes)
  //                                                        offmask: int32 =
  //                                                        0xfffffffd (4 bytes)
  //                                                        shift: int32 =
  //                                                        0xe0000 (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 =
  //                                                        0xffffffff (4 bytes)
  //                                                        val: int32 = 0xec (4
  //                                                        bytes) off: int32 =
  //                                                        0x5 (4 bytes) at:
  //                                                        int32 = 0x4 (4
  //                                                        bytes) offmask:
  //                                                        int32 = 0xc1e7 (4
  //                                                        bytes) shift: int32
  //                                                        = 0xb64d (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x8000
  //                                                        (4 bytes) val: int32
  //                                                        = 0x87 (4 bytes)
  //                                                        off: int32 = 0x7ce
  //                                                        (4 bytes) at: int32
  //                                                        = 0x400 (4 bytes)
  //                                                        offmask: int32 = 0x0
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0x2d (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x9 (4
  //                                                        bytes) val: int32 =
  //                                                        0x9 (4 bytes) off:
  //                                                        int32 = 0x2 (4
  //                                                        bytes) at: int32 =
  //                                                        0x18f (4 bytes)
  //                                                        offmask: int32 =
  //                                                        0x3ff (4 bytes)
  //                                                        shift: int32 = 0x3
  //                                                        (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x2 (4
  //                                                        bytes) val: int32 =
  //                                                        0x5 (4 bytes) off:
  //                                                        int32 = 0x6 (4
  //                                                        bytes) at: int32 =
  //                                                        0xb (4 bytes)
  //                                                        offmask: int32 = 0x7
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0x0 (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x81
  //                                                        (4 bytes) val: int32
  //                                                        = 0x2 (4 bytes) off:
  //                                                        int32 = 0x4 (4
  //                                                        bytes) at: int32 =
  //                                                        0x0 (4 bytes)
  //                                                        offmask: int32 = 0x3
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0x7 (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x9f8
  //                                                        (4 bytes) val: int32
  //                                                        = 0x2 (4 bytes) off:
  //                                                        int32 = 0x4 (4
  //                                                        bytes) at: int32 =
  //                                                        0xe (4 bytes)
  //                                                        offmask: int32 =
  //                                                        0x400 (4 bytes)
  //                                                        shift: int32 = 0x6
  //                                                        (4 bytes)
  //                                                      }
  //                                                    }
  //                                                    keys_ex:
  //                                                    array[m_pedit_key_ex] {
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x2 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x706c4c185c430530
  //                                                        (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x1 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x4 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x5 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x2 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x0 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x1 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x4 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x2 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x1 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x4 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x5 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x7 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x3 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x4 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x5 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x1 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x4 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x1 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x1 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x1 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x4 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x0 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x3 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x5 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x2 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x1 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x0 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x1 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x3 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x1 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x3 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x0 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x4 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x3 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x5 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x1 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x5 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x3 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x2 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x1 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x0 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x1 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x5 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x0 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x5 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x5 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x4 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x0 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x5 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x3 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x0 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x5 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x5 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x2 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x2 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x0 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x5 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x0 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x1 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x2 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x2 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x5 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x1 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x3 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x5 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x4 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x3 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x4 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x2 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x3 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x0 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x2 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x3 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x0 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x5 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x5 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x4 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x2 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x0 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x0 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x3 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x1 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x3 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x7 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x2 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x3 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x2 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x4 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x5 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x1 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x4 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x1 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x3 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x4 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x0 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x5 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x4 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x5 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x5 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x0 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x5 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x2 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x5 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x3 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x3 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x2 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x3 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x4 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x0 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x3 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x2 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x4 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0xec1752f8e3477738
  //                                                        (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x3 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x2 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x0 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x3 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x3 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x5 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x0 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x0 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x3 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x4 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x2 (2 bytes) cmd:
  //                                                        pedit_cmd =
  //                                                        0x433dd36a35789fc3
  //                                                        (2 bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x0 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x3 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x4 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                    }
  //                                                    extended: int8 = 0x1 (1
  //                                                    bytes)
  //                                                  }
  //                                                  size: buffer: {} (length
  //                                                  0x0)
  //                                                }
  //                                              }
  //                                            }
  //                                            size: buffer: {} (length 0x0)
  //                                          }
  //                                          TCA_ACT_COOKIE:
  //                                          nlattr_t[const[TCA_ACT_COOKIE,
  //                                          int16], array[int8]] {
  //                                            nla_len: offsetof = 0x4 (2
  //                                            bytes) nla_type: const = 0x6 (2
  //                                            bytes) payload: buffer: {}
  //                                            (length 0x0) size: buffer: {}
  //                                            (length 0x0)
  //                                          }
  //                                          TCA_ACT_FLAGS:
  //                                          nlattr_t[const[TCA_ACT_FLAGS,
  //                                          int16],
  //                                          nla_bitfield32[tcf_action_policy_flags]]
  //                                          {
  //                                            nla_len: offsetof = 0xc (2
  //                                            bytes) nla_type: const = 0x7 (2
  //                                            bytes) payload:
  //                                            nla_bitfield32[tcf_action_policy_flags]
  //                                            {
  //                                              value: tcf_action_policy_flags
  //                                              = 0x1 (4 bytes) selector:
  //                                              tcf_action_policy_flags = 0x0
  //                                              (4 bytes)
  //                                            }
  //                                            size: buffer: {} (length 0x0)
  //                                          }
  //                                          TCA_ACT_HW_STATS:
  //                                          nlattr_t[const[TCA_ACT_HW_STATS,
  //                                          int16],
  //                                          nla_bitfield32[tcf_action_policy_hw_stats]]
  //                                          {
  //                                            nla_len: offsetof = 0xc (2
  //                                            bytes) nla_type: const = 0x8 (2
  //                                            bytes) payload:
  //                                            nla_bitfield32[tcf_action_policy_hw_stats]
  //                                            {
  //                                              value:
  //                                              tcf_action_policy_hw_stats =
  //                                              0x0 (4 bytes) selector:
  //                                              tcf_action_policy_hw_stats =
  //                                              0x1 (4 bytes)
  //                                            }
  //                                            size: buffer: {} (length 0x0)
  //                                          }
  //                                        }
  //                                        size: buffer: {} (length 0x0)
  //                                      }
  //                                    }
  //                                    union tca_actions {
  //                                      m_pedit:
  //                                      nlattr_tt[int16:14[0:TCA_ACT_MAX_PRIO],
  //                                      0, 0, tcf_action_policy["pedit",
  //                                      pedit_policy]] {
  //                                        nla_len: offsetof = 0xe50 (2 bytes)
  //                                        nla_type: int16 = 0xb (1 bytes)
  //                                        NLA_F_NET_BYTEORDER: const = 0x0 (0
  //                                        bytes) NLA_F_NESTED: const = 0x0 (1
  //                                        bytes) payload:
  //                                        tcf_action_policy["pedit",
  //                                        pedit_policy] {
  //                                          TCA_ACT_KIND:
  //                                          nlattr_t[const[TCA_ACT_KIND,
  //                                          int16], string["pedit"]] {
  //                                            nla_len: offsetof = 0xa (2
  //                                            bytes) nla_type: const = 0x1 (2
  //                                            bytes) payload: buffer: {70 65
  //                                            64 69 74 00} (length 0x6) size:
  //                                            buffer: {} (length 0x0) pad =
  //                                            0x0 (2 bytes)
  //                                          }
  //                                          TCA_ACT_OPTIONS:
  //                                          nlattr_tt[const[TCA_ACT_OPTIONS,
  //                                          int16:14], 0, 1,
  //                                          array[pedit_policy]] {
  //                                            nla_len: offsetof = 0xe24 (2
  //                                            bytes) nla_type: const = 0x2 (1
  //                                            bytes) NLA_F_NET_BYTEORDER:
  //                                            const = 0x0 (0 bytes)
  //                                            NLA_F_NESTED: const = 0x1 (1
  //                                            bytes) payload:
  //                                            array[pedit_policy] {
  //                                              union pedit_policy {
  //                                                TCA_PEDIT_PARMS:
  //                                                nlattr_t[const[TCA_PEDIT_PARMS,
  //                                                int16], m_pedit_sel] {
  //                                                  nla_len: offsetof = 0xe20
  //                                                  (2 bytes) nla_type: const
  //                                                  = 0x2 (2 bytes) payload:
  //                                                  m_pedit_sel {
  //                                                    sel: tc_pedit_sel {
  //                                                      tc_gen: tc_gen {
  //                                                        index: int32 = 0x7
  //                                                        (4 bytes) capab:
  //                                                        int32 = 0x456 (4
  //                                                        bytes) action:
  //                                                        tc_actions = 0x4 (4
  //                                                        bytes) refcnt: int32
  //                                                        = 0x6 (4 bytes)
  //                                                        bindcnt: int32 = 0x1
  //                                                        (4 bytes)
  //                                                      }
  //                                                      nkeys: int8 = 0xb9 (1
  //                                                      bytes) flags: int8 =
  //                                                      0xf3 (1 bytes) pad =
  //                                                      0x0 (2 bytes) keys:
  //                                                      array[tc_pedit_key] {
  //                                                      }
  //                                                    }
  //                                                    keys:
  //                                                    array[tc_pedit_key] {
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x8bc
  //                                                        (4 bytes) val: int32
  //                                                        = 0x1 (4 bytes) off:
  //                                                        int32 = 0x6 (4
  //                                                        bytes) at: int32 =
  //                                                        0x4 (4 bytes)
  //                                                        offmask: int32 =
  //                                                        0x100 (4 bytes)
  //                                                        shift: int32 =
  //                                                        0xfffffffd (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x0 (4
  //                                                        bytes) val: int32 =
  //                                                        0x68 (4 bytes) off:
  //                                                        int32 = 0xfffffff8
  //                                                        (4 bytes) at: int32
  //                                                        = 0x6 (4 bytes)
  //                                                        offmask: int32 = 0x5
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0x4 (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0xbb05
  //                                                        (4 bytes) val: int32
  //                                                        = 0x97af (4 bytes)
  //                                                        off: int32 = 0x3 (4
  //                                                        bytes) at: int32 =
  //                                                        0x2 (4 bytes)
  //                                                        offmask: int32 = 0x4
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0x6 (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x6 (4
  //                                                        bytes) val: int32 =
  //                                                        0x1 (4 bytes) off:
  //                                                        int32 = 0x3 (4
  //                                                        bytes) at: int32 =
  //                                                        0x2c27f2d1 (4 bytes)
  //                                                        offmask: int32 = 0x0
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0x559a (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x0 (4
  //                                                        bytes) val: int32 =
  //                                                        0x8 (4 bytes) off:
  //                                                        int32 = 0x2 (4
  //                                                        bytes) at: int32 =
  //                                                        0x1 (4 bytes)
  //                                                        offmask: int32 = 0x2
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0x5 (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 =
  //                                                        0x10000 (4 bytes)
  //                                                        val: int32 = 0x1000
  //                                                        (4 bytes) off: int32
  //                                                        = 0x7f (4 bytes) at:
  //                                                        int32 = 0x8 (4
  //                                                        bytes) offmask:
  //                                                        int32 = 0x3 (4
  //                                                        bytes) shift: int32
  //                                                        = 0x6 (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x4 (4
  //                                                        bytes) val: int32 =
  //                                                        0x2c4 (4 bytes) off:
  //                                                        int32 = 0x7ab (4
  //                                                        bytes) at: int32 =
  //                                                        0x4 (4 bytes)
  //                                                        offmask: int32 = 0x7
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0x0 (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0xa92
  //                                                        (4 bytes) val: int32
  //                                                        = 0x3 (4 bytes) off:
  //                                                        int32 = 0xb (4
  //                                                        bytes) at: int32 =
  //                                                        0x0 (4 bytes)
  //                                                        offmask: int32 = 0x1
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0x5 (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x7fff
  //                                                        (4 bytes) val: int32
  //                                                        = 0xe (4 bytes) off:
  //                                                        int32 = 0xa524 (4
  //                                                        bytes) at: int32 =
  //                                                        0x40 (4 bytes)
  //                                                        offmask: int32 = 0x5
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0x101 (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0xb (4
  //                                                        bytes) val: int32 =
  //                                                        0x8 (4 bytes) off:
  //                                                        int32 = 0xfffffff8
  //                                                        (4 bytes) at: int32
  //                                                        = 0x1000 (4 bytes)
  //                                                        offmask: int32 =
  //                                                        0xd72 (4 bytes)
  //                                                        shift: int32 = 0x4
  //                                                        (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x9 (4
  //                                                        bytes) val: int32 =
  //                                                        0x8000000 (4 bytes)
  //                                                        off: int32 = 0x0 (4
  //                                                        bytes) at: int32 =
  //                                                        0x2 (4 bytes)
  //                                                        offmask: int32 = 0x2
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0x3ff (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x7 (4
  //                                                        bytes) val: int32 =
  //                                                        0x3 (4 bytes) off:
  //                                                        int32 = 0x6 (4
  //                                                        bytes) at: int32 =
  //                                                        0xcea (4 bytes)
  //                                                        offmask: int32 =
  //                                                        0xff (4 bytes)
  //                                                        shift: int32 =
  //                                                        0x80000001 (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 =
  //                                                        0x1800000 (4 bytes)
  //                                                        val: int32 = 0x9 (4
  //                                                        bytes) off: int32 =
  //                                                        0x3 (4 bytes) at:
  //                                                        int32 = 0x7ff (4
  //                                                        bytes) offmask:
  //                                                        int32 = 0x1 (4
  //                                                        bytes) shift: int32
  //                                                        = 0x4 (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 =
  //                                                        0xfffffffd (4 bytes)
  //                                                        val: int32 =
  //                                                        0xfffffffd (4 bytes)
  //                                                        off: int32 = 0x9 (4
  //                                                        bytes) at: int32 =
  //                                                        0x0 (4 bytes)
  //                                                        offmask: int32 =
  //                                                        0xd1 (4 bytes)
  //                                                        shift: int32 = 0x61b
  //                                                        (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 =
  //                                                        0xfffffff1 (4 bytes)
  //                                                        val: int32 = 0x80 (4
  //                                                        bytes) off: int32 =
  //                                                        0x7 (4 bytes) at:
  //                                                        int32 = 0x1 (4
  //                                                        bytes) offmask:
  //                                                        int32 = 0x4 (4
  //                                                        bytes) shift: int32
  //                                                        = 0x1000 (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0xdab4
  //                                                        (4 bytes) val: int32
  //                                                        = 0x3b6 (4 bytes)
  //                                                        off: int32 = 0x8000
  //                                                        (4 bytes) at: int32
  //                                                        = 0x9 (4 bytes)
  //                                                        offmask: int32 = 0x1
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0x0 (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x2 (4
  //                                                        bytes) val: int32 =
  //                                                        0x400 (4 bytes) off:
  //                                                        int32 = 0x0 (4
  //                                                        bytes) at: int32 =
  //                                                        0x9 (4 bytes)
  //                                                        offmask: int32 = 0x7
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0x2 (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 =
  //                                                        0xffffffff (4 bytes)
  //                                                        val: int32 = 0x245
  //                                                        (4 bytes) off: int32
  //                                                        = 0x63 (4 bytes) at:
  //                                                        int32 = 0x80000001
  //                                                        (4 bytes) offmask:
  //                                                        int32 = 0xc00000 (4
  //                                                        bytes) shift: int32
  //                                                        = 0xa (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 =
  //                                                        0xfffffffc (4 bytes)
  //                                                        val: int32 = 0x10000
  //                                                        (4 bytes) off: int32
  //                                                        = 0x80000001 (4
  //                                                        bytes) at: int32 =
  //                                                        0x8 (4 bytes)
  //                                                        offmask: int32 = 0x8
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0x5 (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 =
  //                                                        0x80000001 (4 bytes)
  //                                                        val: int32 = 0x1 (4
  //                                                        bytes) off: int32 =
  //                                                        0x5e67 (4 bytes) at:
  //                                                        int32 = 0x0 (4
  //                                                        bytes) offmask:
  //                                                        int32 = 0xff (4
  //                                                        bytes) shift: int32
  //                                                        = 0x9 (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x6 (4
  //                                                        bytes) val: int32 =
  //                                                        0x5 (4 bytes) off:
  //                                                        int32 = 0x1a (4
  //                                                        bytes) at: int32 =
  //                                                        0x618 (4 bytes)
  //                                                        offmask: int32 = 0x2
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0x1 (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x9 (4
  //                                                        bytes) val: int32 =
  //                                                        0x9 (4 bytes) off:
  //                                                        int32 = 0x5 (4
  //                                                        bytes) at: int32 =
  //                                                        0x6 (4 bytes)
  //                                                        offmask: int32 = 0x4
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0x8 (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x1 (4
  //                                                        bytes) val: int32 =
  //                                                        0x7 (4 bytes) off:
  //                                                        int32 = 0xf (4
  //                                                        bytes) at: int32 =
  //                                                        0x1 (4 bytes)
  //                                                        offmask: int32 = 0x2
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0x1 (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x9 (4
  //                                                        bytes) val: int32 =
  //                                                        0xa (4 bytes) off:
  //                                                        int32 = 0x3 (4
  //                                                        bytes) at: int32 =
  //                                                        0x2 (4 bytes)
  //                                                        offmask: int32 = 0x6
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0x9 (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x495f
  //                                                        (4 bytes) val: int32
  //                                                        = 0xfe (4 bytes)
  //                                                        off: int32 = 0x9bb3
  //                                                        (4 bytes) at: int32
  //                                                        = 0x2 (4 bytes)
  //                                                        offmask: int32 =
  //                                                        0xfffffffa (4 bytes)
  //                                                        shift: int32 = 0x7
  //                                                        (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x9 (4
  //                                                        bytes) val: int32 =
  //                                                        0x10001 (4 bytes)
  //                                                        off: int32 = 0xc (4
  //                                                        bytes) at: int32 =
  //                                                        0x76 (4 bytes)
  //                                                        offmask: int32 = 0x6
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0x4 (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x8c
  //                                                        (4 bytes) val: int32
  //                                                        = 0x4 (4 bytes) off:
  //                                                        int32 = 0x8f29 (4
  //                                                        bytes) at: int32 =
  //                                                        0x0 (4 bytes)
  //                                                        offmask: int32 =
  //                                                        0xffff8001 (4 bytes)
  //                                                        shift: int32 = 0x7
  //                                                        (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0xfff
  //                                                        (4 bytes) val: int32
  //                                                        = 0xffff (4 bytes)
  //                                                        off: int32 = 0xc (4
  //                                                        bytes) at: int32 =
  //                                                        0xe4 (4 bytes)
  //                                                        offmask: int32 = 0x6
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0x7 (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x7 (4
  //                                                        bytes) val: int32 =
  //                                                        0x8 (4 bytes) off:
  //                                                        int32 = 0xffff8001
  //                                                        (4 bytes) at: int32
  //                                                        = 0x100 (4 bytes)
  //                                                        offmask: int32 = 0x7
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0x0 (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x4 (4
  //                                                        bytes) val: int32 =
  //                                                        0xbe8b (4 bytes)
  //                                                        off: int32 = 0x4 (4
  //                                                        bytes) at: int32 =
  //                                                        0x6 (4 bytes)
  //                                                        offmask: int32 = 0x1
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0x3 (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x5 (4
  //                                                        bytes) val: int32 =
  //                                                        0xad4 (4 bytes) off:
  //                                                        int32 = 0x2 (4
  //                                                        bytes) at: int32 =
  //                                                        0x9 (4 bytes)
  //                                                        offmask: int32 =
  //                                                        0xb1a8 (4 bytes)
  //                                                        shift: int32 = 0x5
  //                                                        (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x9 (4
  //                                                        bytes) val: int32 =
  //                                                        0x3 (4 bytes) off:
  //                                                        int32 = 0xb6e (4
  //                                                        bytes) at: int32 =
  //                                                        0xfff (4 bytes)
  //                                                        offmask: int32 =
  //                                                        0x200 (4 bytes)
  //                                                        shift: int32 = 0x9
  //                                                        (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x4 (4
  //                                                        bytes) val: int32 =
  //                                                        0x8000 (4 bytes)
  //                                                        off: int32 = 0x8 (4
  //                                                        bytes) at: int32 =
  //                                                        0x5 (4 bytes)
  //                                                        offmask: int32 = 0x6
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0x0 (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x4 (4
  //                                                        bytes) val: int32 =
  //                                                        0x2 (4 bytes) off:
  //                                                        int32 = 0x6 (4
  //                                                        bytes) at: int32 =
  //                                                        0x3 (4 bytes)
  //                                                        offmask: int32 = 0x3
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0x1 (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x7 (4
  //                                                        bytes) val: int32 =
  //                                                        0x3e (4 bytes) off:
  //                                                        int32 = 0x6 (4
  //                                                        bytes) at: int32 =
  //                                                        0x8 (4 bytes)
  //                                                        offmask: int32 = 0x7
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0x7 (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x6 (4
  //                                                        bytes) val: int32 =
  //                                                        0x401 (4 bytes) off:
  //                                                        int32 = 0x4 (4
  //                                                        bytes) at: int32 =
  //                                                        0x9 (4 bytes)
  //                                                        offmask: int32 = 0x3
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0x0 (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0xa (4
  //                                                        bytes) val: int32 =
  //                                                        0x40 (4 bytes) off:
  //                                                        int32 = 0x9 (4
  //                                                        bytes) at: int32 =
  //                                                        0xf (4 bytes)
  //                                                        offmask: int32 = 0x5
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0xf (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 =
  //                                                        0x12b8c98e (4 bytes)
  //                                                        val: int32 = 0xfff
  //                                                        (4 bytes) off: int32
  //                                                        = 0x7fffffff (4
  //                                                        bytes) at: int32 =
  //                                                        0x3 (4 bytes)
  //                                                        offmask: int32 = 0xe
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0x7fff (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x6 (4
  //                                                        bytes) val: int32 =
  //                                                        0x8 (4 bytes) off:
  //                                                        int32 = 0x118 (4
  //                                                        bytes) at: int32 =
  //                                                        0xe6c6 (4 bytes)
  //                                                        offmask: int32 = 0x6
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0x9738 (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x3 (4
  //                                                        bytes) val: int32 =
  //                                                        0x9 (4 bytes) off:
  //                                                        int32 = 0x7ff (4
  //                                                        bytes) at: int32 =
  //                                                        0x3 (4 bytes)
  //                                                        offmask: int32 =
  //                                                        0xffffffff (4 bytes)
  //                                                        shift: int32 = 0x9
  //                                                        (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x8 (4
  //                                                        bytes) val: int32 =
  //                                                        0x6 (4 bytes) off:
  //                                                        int32 = 0x7 (4
  //                                                        bytes) at: int32 =
  //                                                        0x7 (4 bytes)
  //                                                        offmask: int32 = 0x2
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0x8 (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 =
  //                                                        0x80000000 (4 bytes)
  //                                                        val: int32 =
  //                                                        0x5ce23415 (4 bytes)
  //                                                        off: int32 = 0x24 (4
  //                                                        bytes) at: int32 =
  //                                                        0xfff (4 bytes)
  //                                                        offmask: int32 =
  //                                                        0xff (4 bytes)
  //                                                        shift: int32 = 0x2
  //                                                        (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x100
  //                                                        (4 bytes) val: int32
  //                                                        = 0x1000 (4 bytes)
  //                                                        off: int32 = 0xca6
  //                                                        (4 bytes) at: int32
  //                                                        = 0x0 (4 bytes)
  //                                                        offmask: int32 =
  //                                                        0xfffffff7 (4 bytes)
  //                                                        shift: int32 = 0xa1
  //                                                        (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x1 (4
  //                                                        bytes) val: int32 =
  //                                                        0x8 (4 bytes) off:
  //                                                        int32 = 0x7 (4
  //                                                        bytes) at: int32 =
  //                                                        0x5 (4 bytes)
  //                                                        offmask: int32 =
  //                                                        0xfffffff7 (4 bytes)
  //                                                        shift: int32 = 0x3a
  //                                                        (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x84c
  //                                                        (4 bytes) val: int32
  //                                                        = 0x81 (4 bytes)
  //                                                        off: int32 = 0x7 (4
  //                                                        bytes) at: int32 =
  //                                                        0x1 (4 bytes)
  //                                                        offmask: int32 = 0x1
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0x7f (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x9 (4
  //                                                        bytes) val: int32 =
  //                                                        0x200 (4 bytes) off:
  //                                                        int32 = 0x700000 (4
  //                                                        bytes) at: int32 =
  //                                                        0x1 (4 bytes)
  //                                                        offmask: int32 = 0x3
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0x5 (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x6 (4
  //                                                        bytes) val: int32 =
  //                                                        0x2 (4 bytes) off:
  //                                                        int32 = 0x7 (4
  //                                                        bytes) at: int32 =
  //                                                        0x6 (4 bytes)
  //                                                        offmask: int32 =
  //                                                        0xfffffffb (4 bytes)
  //                                                        shift: int32 = 0x7
  //                                                        (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x0 (4
  //                                                        bytes) val: int32 =
  //                                                        0x6 (4 bytes) off:
  //                                                        int32 = 0xf (4
  //                                                        bytes) at: int32 =
  //                                                        0x9 (4 bytes)
  //                                                        offmask: int32 = 0x5
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0xd5a (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 =
  //                                                        0xfffffff7 (4 bytes)
  //                                                        val: int32 = 0x7 (4
  //                                                        bytes) off: int32 =
  //                                                        0xffffff7f (4 bytes)
  //                                                        at: int32 = 0x5 (4
  //                                                        bytes) offmask:
  //                                                        int32 = 0x8 (4
  //                                                        bytes) shift: int32
  //                                                        = 0x2 (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x5 (4
  //                                                        bytes) val: int32 =
  //                                                        0x8 (4 bytes) off:
  //                                                        int32 = 0x3 (4
  //                                                        bytes) at: int32 =
  //                                                        0x26 (4 bytes)
  //                                                        offmask: int32 = 0x3
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0x400 (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x0 (4
  //                                                        bytes) val: int32 =
  //                                                        0x6 (4 bytes) off:
  //                                                        int32 = 0x6 (4
  //                                                        bytes) at: int32 =
  //                                                        0x7 (4 bytes)
  //                                                        offmask: int32 =
  //                                                        0x101 (4 bytes)
  //                                                        shift: int32 = 0x222
  //                                                        (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x1f
  //                                                        (4 bytes) val: int32
  //                                                        = 0x800 (4 bytes)
  //                                                        off: int32 = 0x3 (4
  //                                                        bytes) at: int32 =
  //                                                        0xe6b (4 bytes)
  //                                                        offmask: int32 = 0x0
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0xfffffff7
  //                                                        (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x8 (4
  //                                                        bytes) val: int32 =
  //                                                        0x4 (4 bytes) off:
  //                                                        int32 = 0x6 (4
  //                                                        bytes) at: int32 =
  //                                                        0x0 (4 bytes)
  //                                                        offmask: int32 = 0x2
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0x5 (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x0 (4
  //                                                        bytes) val: int32 =
  //                                                        0x2 (4 bytes) off:
  //                                                        int32 = 0x2 (4
  //                                                        bytes) at: int32 =
  //                                                        0x7 (4 bytes)
  //                                                        offmask: int32 =
  //                                                        0x400 (4 bytes)
  //                                                        shift: int32 = 0x7
  //                                                        (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x200
  //                                                        (4 bytes) val: int32
  //                                                        = 0x3 (4 bytes) off:
  //                                                        int32 = 0x8000 (4
  //                                                        bytes) at: int32 =
  //                                                        0x65 (4 bytes)
  //                                                        offmask: int32 =
  //                                                        0x1000 (4 bytes)
  //                                                        shift: int32 = 0x40
  //                                                        (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x10
  //                                                        (4 bytes) val: int32
  //                                                        = 0xa (4 bytes) off:
  //                                                        int32 = 0x4 (4
  //                                                        bytes) at: int32 =
  //                                                        0x10 (4 bytes)
  //                                                        offmask: int32 = 0x1
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0x5 (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x9 (4
  //                                                        bytes) val: int32 =
  //                                                        0x9 (4 bytes) off:
  //                                                        int32 = 0xe95 (4
  //                                                        bytes) at: int32 =
  //                                                        0x4 (4 bytes)
  //                                                        offmask: int32 = 0xd
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0x0 (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0xe0
  //                                                        (4 bytes) val: int32
  //                                                        = 0x2 (4 bytes) off:
  //                                                        int32 = 0x80000001
  //                                                        (4 bytes) at: int32
  //                                                        = 0x4 (4 bytes)
  //                                                        offmask: int32 =
  //                                                        0x1a49 (4 bytes)
  //                                                        shift: int32 = 0x6
  //                                                        (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x2 (4
  //                                                        bytes) val: int32 =
  //                                                        0x4 (4 bytes) off:
  //                                                        int32 = 0x4 (4
  //                                                        bytes) at: int32 =
  //                                                        0x10 (4 bytes)
  //                                                        offmask: int32 =
  //                                                        0xfffff0ac (4 bytes)
  //                                                        shift: int32 = 0x3
  //                                                        (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0xbb
  //                                                        (4 bytes) val: int32
  //                                                        = 0x4 (4 bytes) off:
  //                                                        int32 = 0x4 (4
  //                                                        bytes) at: int32 =
  //                                                        0x1 (4 bytes)
  //                                                        offmask: int32 =
  //                                                        0x7fffffff (4 bytes)
  //                                                        shift: int32 = 0x6
  //                                                        (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 =
  //                                                        0xffffffff (4 bytes)
  //                                                        val: int32 = 0xffff
  //                                                        (4 bytes) off: int32
  //                                                        = 0x6 (4 bytes) at:
  //                                                        int32 = 0xe4 (4
  //                                                        bytes) offmask:
  //                                                        int32 = 0x0 (4
  //                                                        bytes) shift: int32
  //                                                        = 0x6 (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 =
  //                                                        0xfffffff9 (4 bytes)
  //                                                        val: int32 = 0x2 (4
  //                                                        bytes) off: int32 =
  //                                                        0x1 (4 bytes) at:
  //                                                        int32 = 0xc (4
  //                                                        bytes) offmask:
  //                                                        int32 = 0x8 (4
  //                                                        bytes) shift: int32
  //                                                        = 0x800 (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x6 (4
  //                                                        bytes) val: int32 =
  //                                                        0x4 (4 bytes) off:
  //                                                        int32 = 0x5 (4
  //                                                        bytes) at: int32 =
  //                                                        0x1 (4 bytes)
  //                                                        offmask: int32 = 0x1
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0x4 (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0xe (4
  //                                                        bytes) val: int32 =
  //                                                        0x6 (4 bytes) off:
  //                                                        int32 = 0x1 (4
  //                                                        bytes) at: int32 =
  //                                                        0x8 (4 bytes)
  //                                                        offmask: int32 = 0x9
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0x9 (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x7 (4
  //                                                        bytes) val: int32 =
  //                                                        0xc6 (4 bytes) off:
  //                                                        int32 = 0x3ff (4
  //                                                        bytes) at: int32 =
  //                                                        0xe7e3 (4 bytes)
  //                                                        offmask: int32 = 0x5
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0x9 (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0xea48
  //                                                        (4 bytes) val: int32
  //                                                        = 0xfffffffd (4
  //                                                        bytes) off: int32 =
  //                                                        0x10000 (4 bytes)
  //                                                        at: int32 = 0x6 (4
  //                                                        bytes) offmask:
  //                                                        int32 = 0x3 (4
  //                                                        bytes) shift: int32
  //                                                        = 0x5 (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x4 (4
  //                                                        bytes) val: int32 =
  //                                                        0xffff (4 bytes)
  //                                                        off: int32 = 0x1ff
  //                                                        (4 bytes) at: int32
  //                                                        = 0x8 (4 bytes)
  //                                                        offmask: int32 = 0x4
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0xfffffff0
  //                                                        (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0xb (4
  //                                                        bytes) val: int32 =
  //                                                        0x3b3 (4 bytes) off:
  //                                                        int32 = 0x1 (4
  //                                                        bytes) at: int32 =
  //                                                        0x101 (4 bytes)
  //                                                        offmask: int32 =
  //                                                        0xe11 (4 bytes)
  //                                                        shift: int32 = 0x5
  //                                                        (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x3 (4
  //                                                        bytes) val: int32 =
  //                                                        0x4 (4 bytes) off:
  //                                                        int32 = 0x6 (4
  //                                                        bytes) at: int32 =
  //                                                        0xff (4 bytes)
  //                                                        offmask: int32 =
  //                                                        0xff (4 bytes)
  //                                                        shift: int32 = 0x7
  //                                                        (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x0 (4
  //                                                        bytes) val: int32 =
  //                                                        0x2 (4 bytes) off:
  //                                                        int32 = 0x8 (4
  //                                                        bytes) at: int32 =
  //                                                        0x4 (4 bytes)
  //                                                        offmask: int32 = 0x7
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0x4 (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x7 (4
  //                                                        bytes) val: int32 =
  //                                                        0xb (4 bytes) off:
  //                                                        int32 = 0x44df (4
  //                                                        bytes) at: int32 =
  //                                                        0x9 (4 bytes)
  //                                                        offmask: int32 = 0x6
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0x5d5ab339
  //                                                        (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x6 (4
  //                                                        bytes) val: int32 =
  //                                                        0x6 (4 bytes) off:
  //                                                        int32 = 0x40 (4
  //                                                        bytes) at: int32 =
  //                                                        0x2 (4 bytes)
  //                                                        offmask: int32 = 0x9
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0x1ff (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x7 (4
  //                                                        bytes) val: int32 =
  //                                                        0xffffffff (4 bytes)
  //                                                        off: int32 = 0x4 (4
  //                                                        bytes) at: int32 =
  //                                                        0x10001 (4 bytes)
  //                                                        offmask: int32 =
  //                                                        0xffffffff (4 bytes)
  //                                                        shift: int32 = 0x7
  //                                                        (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x81
  //                                                        (4 bytes) val: int32
  //                                                        = 0xa (4 bytes) off:
  //                                                        int32 = 0x3 (4
  //                                                        bytes) at: int32 =
  //                                                        0x8 (4 bytes)
  //                                                        offmask: int32 =
  //                                                        0xd33 (4 bytes)
  //                                                        shift: int32 = 0x6
  //                                                        (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x2 (4
  //                                                        bytes) val: int32 =
  //                                                        0x4 (4 bytes) off:
  //                                                        int32 = 0x9ab (4
  //                                                        bytes) at: int32 =
  //                                                        0xb4 (4 bytes)
  //                                                        offmask: int32 = 0x5
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0xb577 (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x0 (4
  //                                                        bytes) val: int32 =
  //                                                        0xffff (4 bytes)
  //                                                        off: int32 = 0x6 (4
  //                                                        bytes) at: int32 =
  //                                                        0x7fff (4 bytes)
  //                                                        offmask: int32 = 0x0
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0x5 (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0xd (4
  //                                                        bytes) val: int32 =
  //                                                        0x6 (4 bytes) off:
  //                                                        int32 = 0xaa10 (4
  //                                                        bytes) at: int32 =
  //                                                        0xfffff477 (4 bytes)
  //                                                        offmask: int32 = 0x0
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0xff (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x2 (4
  //                                                        bytes) val: int32 =
  //                                                        0xfffffffa (4 bytes)
  //                                                        off: int32 = 0x4 (4
  //                                                        bytes) at: int32 =
  //                                                        0x90 (4 bytes)
  //                                                        offmask: int32 = 0x9
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0x3e (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x2 (4
  //                                                        bytes) val: int32 =
  //                                                        0x80000000 (4 bytes)
  //                                                        off: int32 = 0x4 (4
  //                                                        bytes) at: int32 =
  //                                                        0x4 (4 bytes)
  //                                                        offmask: int32 =
  //                                                        0x90 (4 bytes)
  //                                                        shift: int32 = 0x2
  //                                                        (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x4 (4
  //                                                        bytes) val: int32 =
  //                                                        0x1 (4 bytes) off:
  //                                                        int32 = 0x6 (4
  //                                                        bytes) at: int32 =
  //                                                        0x4 (4 bytes)
  //                                                        offmask: int32 = 0x4
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0x7 (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x5 (4
  //                                                        bytes) val: int32 =
  //                                                        0x6 (4 bytes) off:
  //                                                        int32 = 0x4 (4
  //                                                        bytes) at: int32 =
  //                                                        0xb80c (4 bytes)
  //                                                        offmask: int32 = 0x5
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0x4cf1 (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x8001
  //                                                        (4 bytes) val: int32
  //                                                        = 0x4 (4 bytes) off:
  //                                                        int32 = 0x8 (4
  //                                                        bytes) at: int32 =
  //                                                        0x9 (4 bytes)
  //                                                        offmask: int32 = 0x0
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0x6 (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x40
  //                                                        (4 bytes) val: int32
  //                                                        = 0x9 (4 bytes) off:
  //                                                        int32 = 0x18c (4
  //                                                        bytes) at: int32 =
  //                                                        0x100 (4 bytes)
  //                                                        offmask: int32 = 0x2
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0x9 (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x3 (4
  //                                                        bytes) val: int32 =
  //                                                        0x4 (4 bytes) off:
  //                                                        int32 = 0x9 (4
  //                                                        bytes) at: int32 =
  //                                                        0x7f (4 bytes)
  //                                                        offmask: int32 = 0x7
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0x179 (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x0 (4
  //                                                        bytes) val: int32 =
  //                                                        0x7 (4 bytes) off:
  //                                                        int32 = 0x2 (4
  //                                                        bytes) at: int32 =
  //                                                        0x80 (4 bytes)
  //                                                        offmask: int32 =
  //                                                        0x401 (4 bytes)
  //                                                        shift: int32 = 0x8
  //                                                        (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x7 (4
  //                                                        bytes) val: int32 =
  //                                                        0x0 (4 bytes) off:
  //                                                        int32 = 0x10001 (4
  //                                                        bytes) at: int32 =
  //                                                        0xf6 (4 bytes)
  //                                                        offmask: int32 =
  //                                                        0x64f57d4f (4 bytes)
  //                                                        shift: int32 =
  //                                                        0x10f00000 (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x7 (4
  //                                                        bytes) val: int32 =
  //                                                        0x200 (4 bytes) off:
  //                                                        int32 = 0x200 (4
  //                                                        bytes) at: int32 =
  //                                                        0x9 (4 bytes)
  //                                                        offmask: int32 = 0x5
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0x4512 (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0xd3
  //                                                        (4 bytes) val: int32
  //                                                        = 0x0 (4 bytes) off:
  //                                                        int32 = 0x8 (4
  //                                                        bytes) at: int32 =
  //                                                        0x2 (4 bytes)
  //                                                        offmask: int32 = 0x8
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0x101 (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x6b0c
  //                                                        (4 bytes) val: int32
  //                                                        = 0x9 (4 bytes) off:
  //                                                        int32 = 0x7 (4
  //                                                        bytes) at: int32 =
  //                                                        0x3ff (4 bytes)
  //                                                        offmask: int32 = 0x4
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0x0 (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x5f
  //                                                        (4 bytes) val: int32
  //                                                        = 0x4 (4 bytes) off:
  //                                                        int32 = 0xffffffff
  //                                                        (4 bytes) at: int32
  //                                                        = 0x0 (4 bytes)
  //                                                        offmask: int32 = 0x0
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0x7 (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x4 (4
  //                                                        bytes) val: int32 =
  //                                                        0x4 (4 bytes) off:
  //                                                        int32 = 0x1200000 (4
  //                                                        bytes) at: int32 =
  //                                                        0x7 (4 bytes)
  //                                                        offmask: int32 =
  //                                                        0x800 (4 bytes)
  //                                                        shift: int32 = 0x6
  //                                                        (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x1 (4
  //                                                        bytes) val: int32 =
  //                                                        0x6 (4 bytes) off:
  //                                                        int32 = 0x80 (4
  //                                                        bytes) at: int32 =
  //                                                        0xef8 (4 bytes)
  //                                                        offmask: int32 = 0x0
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0x5 (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 =
  //                                                        0x40000 (4 bytes)
  //                                                        val: int32 = 0x6 (4
  //                                                        bytes) off: int32 =
  //                                                        0x1 (4 bytes) at:
  //                                                        int32 = 0x1 (4
  //                                                        bytes) offmask:
  //                                                        int32 = 0x2 (4
  //                                                        bytes) shift: int32
  //                                                        = 0xd09 (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x8000
  //                                                        (4 bytes) val: int32
  //                                                        = 0x9 (4 bytes) off:
  //                                                        int32 = 0xfffffffd
  //                                                        (4 bytes) at: int32
  //                                                        = 0x100 (4 bytes)
  //                                                        offmask: int32 = 0x6
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0xfffffff7
  //                                                        (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x9 (4
  //                                                        bytes) val: int32 =
  //                                                        0x2 (4 bytes) off:
  //                                                        int32 = 0x9 (4
  //                                                        bytes) at: int32 =
  //                                                        0x1 (4 bytes)
  //                                                        offmask: int32 = 0x3
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0xbe2 (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x4 (4
  //                                                        bytes) val: int32 =
  //                                                        0xa (4 bytes) off:
  //                                                        int32 = 0x0 (4
  //                                                        bytes) at: int32 =
  //                                                        0x0 (4 bytes)
  //                                                        offmask: int32 = 0x6
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0x6 (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x3ff
  //                                                        (4 bytes) val: int32
  //                                                        = 0x5 (4 bytes) off:
  //                                                        int32 = 0x1 (4
  //                                                        bytes) at: int32 =
  //                                                        0x7000 (4 bytes)
  //                                                        offmask: int32 =
  //                                                        0x4e (4 bytes)
  //                                                        shift: int32 = 0x8
  //                                                        (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0xd6
  //                                                        (4 bytes) val: int32
  //                                                        = 0x9 (4 bytes) off:
  //                                                        int32 = 0x10000 (4
  //                                                        bytes) at: int32 =
  //                                                        0x8 (4 bytes)
  //                                                        offmask: int32 =
  //                                                        0xff (4 bytes)
  //                                                        shift: int32 = 0x2
  //                                                        (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0xb (4
  //                                                        bytes) val: int32 =
  //                                                        0x1 (4 bytes) off:
  //                                                        int32 = 0x1f36 (4
  //                                                        bytes) at: int32 =
  //                                                        0x8ff4 (4 bytes)
  //                                                        offmask: int32 =
  //                                                        0xfff (4 bytes)
  //                                                        shift: int32 = 0x6
  //                                                        (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x0 (4
  //                                                        bytes) val: int32 =
  //                                                        0x516607 (4 bytes)
  //                                                        off: int32 = 0x2 (4
  //                                                        bytes) at: int32 =
  //                                                        0x3 (4 bytes)
  //                                                        offmask: int32 = 0x3
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0xffffffff
  //                                                        (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 =
  //                                                        0xffff4b03 (4 bytes)
  //                                                        val: int32 = 0x5 (4
  //                                                        bytes) off: int32 =
  //                                                        0x10 (4 bytes) at:
  //                                                        int32 = 0x1 (4
  //                                                        bytes) offmask:
  //                                                        int32 = 0x3 (4
  //                                                        bytes) shift: int32
  //                                                        = 0x6 (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x7 (4
  //                                                        bytes) val: int32 =
  //                                                        0x0 (4 bytes) off:
  //                                                        int32 = 0x6 (4
  //                                                        bytes) at: int32 =
  //                                                        0x8000 (4 bytes)
  //                                                        offmask: int32 =
  //                                                        0x10 (4 bytes)
  //                                                        shift: int32 = 0xa
  //                                                        (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x2 (4
  //                                                        bytes) val: int32 =
  //                                                        0x6c (4 bytes) off:
  //                                                        int32 = 0xffffffff
  //                                                        (4 bytes) at: int32
  //                                                        = 0x2 (4 bytes)
  //                                                        offmask: int32 =
  //                                                        0x94 (4 bytes)
  //                                                        shift: int32 = 0x9
  //                                                        (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x3 (4
  //                                                        bytes) val: int32 =
  //                                                        0x40 (4 bytes) off:
  //                                                        int32 = 0xfffffffa
  //                                                        (4 bytes) at: int32
  //                                                        = 0x6 (4 bytes)
  //                                                        offmask: int32 = 0x0
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0xef0 (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x8 (4
  //                                                        bytes) val: int32 =
  //                                                        0x8 (4 bytes) off:
  //                                                        int32 = 0x64 (4
  //                                                        bytes) at: int32 =
  //                                                        0x10 (4 bytes)
  //                                                        offmask: int32 =
  //                                                        0x49 (4 bytes)
  //                                                        shift: int32 = 0x80
  //                                                        (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x9 (4
  //                                                        bytes) val: int32 =
  //                                                        0xc (4 bytes) off:
  //                                                        int32 = 0x8000 (4
  //                                                        bytes) at: int32 =
  //                                                        0x7 (4 bytes)
  //                                                        offmask: int32 = 0x3
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0x140 (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x7 (4
  //                                                        bytes) val: int32 =
  //                                                        0x7 (4 bytes) off:
  //                                                        int32 = 0xf16 (4
  //                                                        bytes) at: int32 =
  //                                                        0x7ff (4 bytes)
  //                                                        offmask: int32 = 0x3
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0x7 (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x1ff
  //                                                        (4 bytes) val: int32
  //                                                        = 0x9 (4 bytes) off:
  //                                                        int32 = 0x1 (4
  //                                                        bytes) at: int32 =
  //                                                        0x9 (4 bytes)
  //                                                        offmask: int32 =
  //                                                        0x4e (4 bytes)
  //                                                        shift: int32 =
  //                                                        0xffffffff (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x4 (4
  //                                                        bytes) val: int32 =
  //                                                        0x2 (4 bytes) off:
  //                                                        int32 = 0xffffffff
  //                                                        (4 bytes) at: int32
  //                                                        = 0xe559 (4 bytes)
  //                                                        offmask: int32 =
  //                                                        0xc16 (4 bytes)
  //                                                        shift: int32 = 0x4
  //                                                        (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 =
  //                                                        0xfffff802 (4 bytes)
  //                                                        val: int32 = 0x1 (4
  //                                                        bytes) off: int32 =
  //                                                        0x4 (4 bytes) at:
  //                                                        int32 = 0x1 (4
  //                                                        bytes) offmask:
  //                                                        int32 = 0x6 (4
  //                                                        bytes) shift: int32
  //                                                        = 0x0 (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x2 (4
  //                                                        bytes) val: int32 =
  //                                                        0xf (4 bytes) off:
  //                                                        int32 = 0x10 (4
  //                                                        bytes) at: int32 =
  //                                                        0x3 (4 bytes)
  //                                                        offmask: int32 =
  //                                                        0xafae (4 bytes)
  //                                                        shift: int32 = 0x3
  //                                                        (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 =
  //                                                        0x10000 (4 bytes)
  //                                                        val: int32 = 0x4 (4
  //                                                        bytes) off: int32 =
  //                                                        0x6 (4 bytes) at:
  //                                                        int32 = 0x2 (4
  //                                                        bytes) offmask:
  //                                                        int32 = 0x6 (4
  //                                                        bytes) shift: int32
  //                                                        = 0xa4 (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x0 (4
  //                                                        bytes) val: int32 =
  //                                                        0x4 (4 bytes) off:
  //                                                        int32 = 0x0 (4
  //                                                        bytes) at: int32 =
  //                                                        0x4 (4 bytes)
  //                                                        offmask: int32 =
  //                                                        0x1000 (4 bytes)
  //                                                        shift: int32 =
  //                                                        0x6f17 (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x2 (4
  //                                                        bytes) val: int32 =
  //                                                        0x4 (4 bytes) off:
  //                                                        int32 = 0xd9 (4
  //                                                        bytes) at: int32 =
  //                                                        0x7fffffff (4 bytes)
  //                                                        offmask: int32 = 0x3
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0x805 (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0xf17
  //                                                        (4 bytes) val: int32
  //                                                        = 0x4 (4 bytes) off:
  //                                                        int32 = 0x40 (4
  //                                                        bytes) at: int32 =
  //                                                        0x5 (4 bytes)
  //                                                        offmask: int32 = 0x1
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0xff (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x0 (4
  //                                                        bytes) val: int32 =
  //                                                        0x80000001 (4 bytes)
  //                                                        off: int32 = 0xb44f
  //                                                        (4 bytes) at: int32
  //                                                        = 0xfffffffa (4
  //                                                        bytes) offmask:
  //                                                        int32 = 0x0 (4
  //                                                        bytes) shift: int32
  //                                                        = 0x8a5 (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x8000
  //                                                        (4 bytes) val: int32
  //                                                        = 0x7ff (4 bytes)
  //                                                        off: int32 = 0x5 (4
  //                                                        bytes) at: int32 =
  //                                                        0x3 (4 bytes)
  //                                                        offmask: int32 = 0x4
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0x600 (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x4b
  //                                                        (4 bytes) val: int32
  //                                                        = 0xad (4 bytes)
  //                                                        off: int32 = 0x8 (4
  //                                                        bytes) at: int32 =
  //                                                        0x669 (4 bytes)
  //                                                        offmask: int32 =
  //                                                        0x1ff (4 bytes)
  //                                                        shift: int32 = 0x3
  //                                                        (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x2 (4
  //                                                        bytes) val: int32 =
  //                                                        0xa45 (4 bytes) off:
  //                                                        int32 = 0x1000 (4
  //                                                        bytes) at: int32 =
  //                                                        0x0 (4 bytes)
  //                                                        offmask: int32 = 0xa
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0x1 (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x4 (4
  //                                                        bytes) val: int32 =
  //                                                        0x1 (4 bytes) off:
  //                                                        int32 = 0x8 (4
  //                                                        bytes) at: int32 =
  //                                                        0x2 (4 bytes)
  //                                                        offmask: int32 =
  //                                                        0xe0 (4 bytes)
  //                                                        shift: int32 = 0x4
  //                                                        (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x4 (4
  //                                                        bytes) val: int32 =
  //                                                        0xffd (4 bytes) off:
  //                                                        int32 = 0x5 (4
  //                                                        bytes) at: int32 =
  //                                                        0x3 (4 bytes)
  //                                                        offmask: int32 =
  //                                                        0x7fffffff (4 bytes)
  //                                                        shift: int32 =
  //                                                        0xfffffffb (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x8 (4
  //                                                        bytes) val: int32 =
  //                                                        0x4 (4 bytes) off:
  //                                                        int32 = 0x4 (4
  //                                                        bytes) at: int32 =
  //                                                        0x6 (4 bytes)
  //                                                        offmask: int32 = 0x1
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0x5 (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x6 (4
  //                                                        bytes) val: int32 =
  //                                                        0x0 (4 bytes) off:
  //                                                        int32 = 0xffffdbdc
  //                                                        (4 bytes) at: int32
  //                                                        = 0x2 (4 bytes)
  //                                                        offmask: int32 = 0x9
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0x140000 (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x2 (4
  //                                                        bytes) val: int32 =
  //                                                        0x1 (4 bytes) off:
  //                                                        int32 = 0xdc (4
  //                                                        bytes) at: int32 =
  //                                                        0x8 (4 bytes)
  //                                                        offmask: int32 =
  //                                                        0x80000000 (4 bytes)
  //                                                        shift: int32 = 0x569
  //                                                        (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x0 (4
  //                                                        bytes) val: int32 =
  //                                                        0x8 (4 bytes) off:
  //                                                        int32 = 0xffffffff
  //                                                        (4 bytes) at: int32
  //                                                        = 0xa (4 bytes)
  //                                                        offmask: int32 =
  //                                                        0x80000001 (4 bytes)
  //                                                        shift: int32 = 0xa
  //                                                        (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 =
  //                                                        0xfffffbff (4 bytes)
  //                                                        val: int32 = 0x10 (4
  //                                                        bytes) off: int32 =
  //                                                        0x8 (4 bytes) at:
  //                                                        int32 = 0x101 (4
  //                                                        bytes) offmask:
  //                                                        int32 = 0xfffffffa
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0x8000 (4
  //                                                        bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0xa9c
  //                                                        (4 bytes) val: int32
  //                                                        = 0x6 (4 bytes) off:
  //                                                        int32 = 0x1ff (4
  //                                                        bytes) at: int32 =
  //                                                        0x8 (4 bytes)
  //                                                        offmask: int32 =
  //                                                        0x1d (4 bytes)
  //                                                        shift: int32 = 0x3
  //                                                        (4 bytes)
  //                                                      }
  //                                                      tc_pedit_key {
  //                                                        mask: int32 = 0x2 (4
  //                                                        bytes) val: int32 =
  //                                                        0xfffff16c (4 bytes)
  //                                                        off: int32 = 0x5 (4
  //                                                        bytes) at: int32 =
  //                                                        0x3 (4 bytes)
  //                                                        offmask: int32 = 0x5
  //                                                        (4 bytes) shift:
  //                                                        int32 = 0x7ff (4
  //                                                        bytes)
  //                                                      }
  //                                                    }
  //                                                    keys_ex:
  //                                                    array[m_pedit_key_ex] {
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x1 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x2 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x4 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x0 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x4 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x3 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x2d451479be6868cc
  //                                                        (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x3 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x0 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x1 (2 bytes) cmd:
  //                                                        pedit_cmd =
  //                                                        0xa02f5fe57b5d7768
  //                                                        (2 bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x3 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x2 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x0 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x0 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x4 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x2 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x1 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x5 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x2 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x0 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x1 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x5 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x5 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x4 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x4 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x4 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x2 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x1 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x2 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x1 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x2 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x4 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x3 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x4 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x2 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x5 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x1 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x3 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x1 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x5 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x2 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x3 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x4 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x3 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x3 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x1 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x1 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x4 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x3 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x2 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x2 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x5 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x3 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x0 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x5 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x5 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x5 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x5 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x0 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x4 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x3 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x2 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x2 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x3 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x2 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x4 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x2 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x0 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x4 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x5 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x3 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x5 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x4 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x1 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x2 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x3 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x6 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x4 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x7 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x1 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x3 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x2 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x0 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x2 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x0 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x5 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x5 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x5 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x2 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x3 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x2 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x0 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x2 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x5 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x4 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x1 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x0 (2 bytes) cmd:
  //                                                        pedit_cmd =
  //                                                        0x2220886d9e210a2 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x3 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x1 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x3 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x4 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x0 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x5 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x4 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x2 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x4 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x0 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x2 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x2 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x3 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x1 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x4 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x3 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x2 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x3 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x1 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x4 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x3 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x2 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x3 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x5 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x2 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x1 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x1 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x5 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x3 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x0 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x0 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x0 (2
  //                                                        bytes)
  //                                                      }
  //                                                      m_pedit_key_ex {
  //                                                        htype:
  //                                                        pedit_header_type =
  //                                                        0x4 (2 bytes) cmd:
  //                                                        pedit_cmd = 0x1 (2
  //                                                        bytes)
  //                                                      }
  //                                                    }
  //                                                    extended: int8 = 0x1 (1
  //                                                    bytes)
  //                                                  }
  //                                                  size: buffer: {} (length
  //                                                  0x0)
  //                                                }
  //                                              }
  //                                            }
  //                                            size: buffer: {} (length 0x0)
  //                                          }
  //                                          TCA_ACT_COOKIE:
  //                                          nlattr_t[const[TCA_ACT_COOKIE,
  //                                          int16], array[int8]] {
  //                                            nla_len: offsetof = 0x4 (2
  //                                            bytes) nla_type: const = 0x6 (2
  //                                            bytes) payload: buffer: {}
  //                                            (length 0x0) size: buffer: {}
  //                                            (length 0x0)
  //                                          }
  //                                          TCA_ACT_FLAGS:
  //                                          nlattr_t[const[TCA_ACT_FLAGS,
  //                                          int16],
  //                                          nla_bitfield32[tcf_action_policy_flags]]
  //                                          {
  //                                            nla_len: offsetof = 0xc (2
  //                                            bytes) nla_type: const = 0x7 (2
  //                                            bytes) payload:
  //                                            nla_bitfield32[tcf_action_policy_flags]
  //                                            {
  //                                              value: tcf_action_policy_flags
  //                                              = 0x0 (4 bytes) selector:
  //                                              tcf_action_policy_flags = 0x1
  //                                              (4 bytes)
  //                                            }
  //                                            size: buffer: {} (length 0x0)
  //                                          }
  //                                          TCA_ACT_HW_STATS:
  //                                          nlattr_t[const[TCA_ACT_HW_STATS,
  //                                          int16],
  //                                          nla_bitfield32[tcf_action_policy_hw_stats]]
  //                                          {
  //                                            nla_len: offsetof = 0xc (2
  //                                            bytes) nla_type: const = 0x8 (2
  //                                            bytes) payload:
  //                                            nla_bitfield32[tcf_action_policy_hw_stats]
  //                                            {
  //                                              value:
  //                                              tcf_action_policy_hw_stats =
  //                                              0x5 (4 bytes) selector:
  //                                              tcf_action_policy_hw_stats =
  //                                              0x0 (4 bytes)
  //                                            }
  //                                            size: buffer: {} (length 0x0)
  //                                          }
  //                                        }
  //                                        size: buffer: {} (length 0x0)
  //                                      }
  //                                    }
  //                                  }
  //                                  size: buffer: {} (length 0x0)
  //                                }
  //                              }
  //                            }
  //                            size: buffer: {} (length 0x0)
  //                          }
  //                        }
  //                      }
  //                    }
  //                  }
  //                }
  //              }
  //            }
  //            len: len = 0x1ddc (8 bytes)
  //          }
  //        }
  //        vlen: const = 0x1 (8 bytes)
  //        ctrl: const = 0x0 (8 bytes)
  //        ctrllen: const = 0x0 (8 bytes)
  //        f: send_flags = 0x4040000 (4 bytes)
  //        pad = 0x0 (4 bytes)
  //      }
  //    }
  //    f: send_flags = 0x8800 (8 bytes)
  //  ]
  *(uint64_t*)0x200000000400 = 0;
  *(uint32_t*)0x200000000408 = 0;
  *(uint64_t*)0x200000000410 = 0x200000000340;
  *(uint64_t*)0x200000000340 = 0x2000000026c0;
  *(uint32_t*)0x2000000026c0 = 0x1ddc;
  *(uint16_t*)0x2000000026c4 = 0x2d;
  *(uint16_t*)0x2000000026c6 = 0x400;
  *(uint32_t*)0x2000000026c8 = 0x70bd2c;
  *(uint32_t*)0x2000000026cc = 0x25dfdbfe;
  *(uint8_t*)0x2000000026d0 = 0;
  *(uint8_t*)0x2000000026d1 = 0;
  *(uint16_t*)0x2000000026d2 = 0;
  *(uint32_t*)0x2000000026d4 = 0;
  *(uint16_t*)0x2000000026d8 = 5;
  *(uint16_t*)0x2000000026da = 0xffe0;
  *(uint16_t*)0x2000000026dc = 0xa;
  *(uint16_t*)0x2000000026de = 3;
  *(uint16_t*)0x2000000026e0 = 6;
  *(uint16_t*)0x2000000026e2 = 5;
  *(uint16_t*)0x2000000026e4 = 8;
  *(uint16_t*)0x2000000026e6 = 0xb;
  *(uint32_t*)0x2000000026e8 = 6;
  *(uint16_t*)0x2000000026ec = 0xb;
  *(uint16_t*)0x2000000026ee = 1;
  memcpy((void*)0x2000000026f0, "cgroup\000", 7);
  *(uint16_t*)0x2000000026f8 = 0x1da4;
  *(uint16_t*)0x2000000026fa = 2;
  *(uint16_t*)0x2000000026fc = 0x1da0;
  *(uint16_t*)0x2000000026fe = 1;
  *(uint16_t*)0x200000002700 = 0x94;
  STORE_BY_BITMASK(uint16_t, , 0x200000002702, 0, 0, 14);
  STORE_BY_BITMASK(uint16_t, , 0x200000002703, 0, 6, 1);
  STORE_BY_BITMASK(uint16_t, , 0x200000002703, 0, 7, 1);
  *(uint16_t*)0x200000002704 = 0xd;
  *(uint16_t*)0x200000002706 = 1;
  memcpy((void*)0x200000002708, "connmark\000", 9);
  *(uint16_t*)0x200000002714 = 0x3c;
  STORE_BY_BITMASK(uint16_t, , 0x200000002716, 2, 0, 14);
  STORE_BY_BITMASK(uint16_t, , 0x200000002717, 0, 6, 1);
  STORE_BY_BITMASK(uint16_t, , 0x200000002717, 1, 7, 1);
  *(uint16_t*)0x200000002718 = 0x1c;
  *(uint16_t*)0x20000000271a = 1;
  *(uint32_t*)0x20000000271c = 9;
  *(uint32_t*)0x200000002720 = 0x671;
  *(uint32_t*)0x200000002724 = 7;
  *(uint32_t*)0x200000002728 = 7;
  *(uint32_t*)0x20000000272c = 3;
  *(uint16_t*)0x200000002730 = 0xe57;
  *(uint16_t*)0x200000002734 = 0x1c;
  *(uint16_t*)0x200000002736 = 1;
  *(uint32_t*)0x200000002738 = 8;
  *(uint32_t*)0x20000000273c = 3;
  *(uint32_t*)0x200000002740 = -1;
  *(uint32_t*)0x200000002744 = 5;
  *(uint32_t*)0x200000002748 = 0x5854;
  *(uint16_t*)0x20000000274c = 0xfffc;
  *(uint16_t*)0x200000002750 = 0x29;
  *(uint16_t*)0x200000002752 = 6;
  memcpy((void*)0x200000002754,
         "\x86\x03\xf5\x39\xb6\xa7\xaf\x82\x4d\x26\x2b\xf6\x54\xe2\x99\x8b\x1e"
         "\xf3\xd2\xc0\xc3\xdc\xff\x53\x29\xf4\x0e\x2a\x66\x13\x62\x2a\x8e\x0c"
         "\x66\x06\x97",
         37);
  *(uint16_t*)0x20000000277c = 0xc;
  *(uint16_t*)0x20000000277e = 7;
  *(uint32_t*)0x200000002780 = 1;
  *(uint32_t*)0x200000002784 = 1;
  *(uint16_t*)0x200000002788 = 0xc;
  *(uint16_t*)0x20000000278a = 8;
  *(uint32_t*)0x20000000278c = 1;
  *(uint32_t*)0x200000002790 = 3;
  *(uint16_t*)0x200000002794 = 0x50;
  STORE_BY_BITMASK(uint16_t, , 0x200000002796, 0x14, 0, 14);
  STORE_BY_BITMASK(uint16_t, , 0x200000002797, 0, 6, 1);
  STORE_BY_BITMASK(uint16_t, , 0x200000002797, 0, 7, 1);
  *(uint16_t*)0x200000002798 = 0xd;
  *(uint16_t*)0x20000000279a = 1;
  memcpy((void*)0x20000000279c, "connmark\000", 9);
  *(uint16_t*)0x2000000027a8 = 0x20;
  STORE_BY_BITMASK(uint16_t, , 0x2000000027aa, 2, 0, 14);
  STORE_BY_BITMASK(uint16_t, , 0x2000000027ab, 0, 6, 1);
  STORE_BY_BITMASK(uint16_t, , 0x2000000027ab, 1, 7, 1);
  *(uint16_t*)0x2000000027ac = 0x1c;
  *(uint16_t*)0x2000000027ae = 1;
  *(uint32_t*)0x2000000027b0 = 0x8001;
  *(uint32_t*)0x2000000027b4 = 0x10001;
  *(uint32_t*)0x2000000027b8 = 3;
  *(uint32_t*)0x2000000027bc = 4;
  *(uint32_t*)0x2000000027c0 = 0x800;
  *(uint16_t*)0x2000000027c4 = 2;
  *(uint16_t*)0x2000000027c8 = 4;
  *(uint16_t*)0x2000000027ca = 6;
  *(uint16_t*)0x2000000027cc = 0xc;
  *(uint16_t*)0x2000000027ce = 7;
  *(uint32_t*)0x2000000027d0 = 0;
  *(uint32_t*)0x2000000027d4 = 1;
  *(uint16_t*)0x2000000027d8 = 0xc;
  *(uint16_t*)0x2000000027da = 8;
  *(uint32_t*)0x2000000027dc = 3;
  *(uint32_t*)0x2000000027e0 = 1;
  *(uint16_t*)0x2000000027e4 = 0xe68;
  STORE_BY_BITMASK(uint16_t, , 0x2000000027e6, 5, 0, 14);
  STORE_BY_BITMASK(uint16_t, , 0x2000000027e7, 0, 6, 1);
  STORE_BY_BITMASK(uint16_t, , 0x2000000027e7, 0, 7, 1);
  *(uint16_t*)0x2000000027e8 = 0xa;
  *(uint16_t*)0x2000000027ea = 1;
  memcpy((void*)0x2000000027ec, "pedit\000", 6);
  *(uint16_t*)0x2000000027f4 = 0xe3c;
  STORE_BY_BITMASK(uint16_t, , 0x2000000027f6, 2, 0, 14);
  STORE_BY_BITMASK(uint16_t, , 0x2000000027f7, 0, 6, 1);
  STORE_BY_BITMASK(uint16_t, , 0x2000000027f7, 1, 7, 1);
  *(uint16_t*)0x2000000027f8 = 0xe38;
  *(uint16_t*)0x2000000027fa = 2;
  *(uint32_t*)0x2000000027fc = 0x1c000000;
  *(uint32_t*)0x200000002800 = 0x40;
  *(uint32_t*)0x200000002804 = 4;
  *(uint32_t*)0x200000002808 = 7;
  *(uint32_t*)0x20000000280c = 0x3fe;
  *(uint8_t*)0x200000002810 = 0xb1;
  *(uint8_t*)0x200000002811 = 3;
  *(uint32_t*)0x200000002814 = 0xf7b7;
  *(uint32_t*)0x200000002818 = 5;
  *(uint32_t*)0x20000000281c = 9;
  *(uint32_t*)0x200000002820 = 0xd;
  *(uint32_t*)0x200000002824 = 0xdd;
  *(uint32_t*)0x200000002828 = 5;
  *(uint32_t*)0x20000000282c = 3;
  *(uint32_t*)0x200000002830 = 2;
  *(uint32_t*)0x200000002834 = -1;
  *(uint32_t*)0x200000002838 = 3;
  *(uint32_t*)0x20000000283c = 0xd8aa;
  *(uint32_t*)0x200000002840 = 7;
  *(uint32_t*)0x200000002844 = 0xaa2;
  *(uint32_t*)0x200000002848 = 6;
  *(uint32_t*)0x20000000284c = 0x101;
  *(uint32_t*)0x200000002850 = 6;
  *(uint32_t*)0x200000002854 = 2;
  *(uint32_t*)0x200000002858 = 3;
  *(uint32_t*)0x20000000285c = 0x200000;
  *(uint32_t*)0x200000002860 = 0x100;
  *(uint32_t*)0x200000002864 = 0;
  *(uint32_t*)0x200000002868 = 0x5c6;
  *(uint32_t*)0x20000000286c = 0x6830;
  *(uint32_t*)0x200000002870 = 8;
  *(uint32_t*)0x200000002874 = 2;
  *(uint32_t*)0x200000002878 = 0x311;
  *(uint32_t*)0x20000000287c = 8;
  *(uint32_t*)0x200000002880 = 0x4b;
  *(uint32_t*)0x200000002884 = 0x82;
  *(uint32_t*)0x200000002888 = 8;
  *(uint32_t*)0x20000000288c = 7;
  *(uint32_t*)0x200000002890 = 5;
  *(uint32_t*)0x200000002894 = 2;
  *(uint32_t*)0x200000002898 = 0x212;
  *(uint32_t*)0x20000000289c = 7;
  *(uint32_t*)0x2000000028a0 = 0xe1;
  *(uint32_t*)0x2000000028a4 = 7;
  *(uint32_t*)0x2000000028a8 = 4;
  *(uint32_t*)0x2000000028ac = 0x8d;
  *(uint32_t*)0x2000000028b0 = 0x1ff;
  *(uint32_t*)0x2000000028b4 = 0x1ff;
  *(uint32_t*)0x2000000028b8 = 0x1000;
  *(uint32_t*)0x2000000028bc = 0x200;
  *(uint32_t*)0x2000000028c0 = 7;
  *(uint32_t*)0x2000000028c4 = -1;
  *(uint32_t*)0x2000000028c8 = 9;
  *(uint32_t*)0x2000000028cc = 9;
  *(uint32_t*)0x2000000028d0 = 0;
  *(uint32_t*)0x2000000028d4 = 7;
  *(uint32_t*)0x2000000028d8 = 0xfe4;
  *(uint32_t*)0x2000000028dc = 1;
  *(uint32_t*)0x2000000028e0 = 0;
  *(uint32_t*)0x2000000028e4 = 0x624;
  *(uint32_t*)0x2000000028e8 = 0xb513;
  *(uint32_t*)0x2000000028ec = 8;
  *(uint32_t*)0x2000000028f0 = 3;
  *(uint32_t*)0x2000000028f4 = 0x7ff;
  *(uint32_t*)0x2000000028f8 = 0x70;
  *(uint32_t*)0x2000000028fc = 6;
  *(uint32_t*)0x200000002900 = 0x8000;
  *(uint32_t*)0x200000002904 = 0xfffffffe;
  *(uint32_t*)0x200000002908 = 0;
  *(uint32_t*)0x20000000290c = 0x3ff;
  *(uint32_t*)0x200000002910 = 0xb06;
  *(uint32_t*)0x200000002914 = 1;
  *(uint32_t*)0x200000002918 = 6;
  *(uint32_t*)0x20000000291c = 5;
  *(uint32_t*)0x200000002920 = 1;
  *(uint32_t*)0x200000002924 = 0xdb;
  *(uint32_t*)0x200000002928 = 6;
  *(uint32_t*)0x20000000292c = 2;
  *(uint32_t*)0x200000002930 = 4;
  *(uint32_t*)0x200000002934 = 9;
  *(uint32_t*)0x200000002938 = 4;
  *(uint32_t*)0x20000000293c = 0x519f;
  *(uint32_t*)0x200000002940 = 5;
  *(uint32_t*)0x200000002944 = 6;
  *(uint32_t*)0x200000002948 = 0x31c4;
  *(uint32_t*)0x20000000294c = 7;
  *(uint32_t*)0x200000002950 = 7;
  *(uint32_t*)0x200000002954 = 0x3ff;
  *(uint32_t*)0x200000002958 = 1;
  *(uint32_t*)0x20000000295c = 0x8000;
  *(uint32_t*)0x200000002960 = 5;
  *(uint32_t*)0x200000002964 = 0x7fffffff;
  *(uint32_t*)0x200000002968 = 1;
  *(uint32_t*)0x20000000296c = 5;
  *(uint32_t*)0x200000002970 = 0xfe45;
  *(uint32_t*)0x200000002974 = 5;
  *(uint32_t*)0x200000002978 = 0xb;
  *(uint32_t*)0x20000000297c = 0xbd;
  *(uint32_t*)0x200000002980 = 0x5f05;
  *(uint32_t*)0x200000002984 = 8;
  *(uint32_t*)0x200000002988 = 0xf;
  *(uint32_t*)0x20000000298c = 1;
  *(uint32_t*)0x200000002990 = 0xa;
  *(uint32_t*)0x200000002994 = 0;
  *(uint32_t*)0x200000002998 = 0x8000;
  *(uint32_t*)0x20000000299c = 3;
  *(uint32_t*)0x2000000029a0 = 7;
  *(uint32_t*)0x2000000029a4 = 0xd17;
  *(uint32_t*)0x2000000029a8 = 7;
  *(uint32_t*)0x2000000029ac = 0xae;
  *(uint32_t*)0x2000000029b0 = 7;
  *(uint32_t*)0x2000000029b4 = 2;
  *(uint32_t*)0x2000000029b8 = 2;
  *(uint32_t*)0x2000000029bc = 9;
  *(uint32_t*)0x2000000029c0 = 0;
  *(uint32_t*)0x2000000029c4 = 6;
  *(uint32_t*)0x2000000029c8 = 4;
  *(uint32_t*)0x2000000029cc = 0xa;
  *(uint32_t*)0x2000000029d0 = 3;
  *(uint32_t*)0x2000000029d4 = 1;
  *(uint32_t*)0x2000000029d8 = 3;
  *(uint32_t*)0x2000000029dc = 2;
  *(uint32_t*)0x2000000029e0 = 0xa502;
  *(uint32_t*)0x2000000029e4 = 3;
  *(uint32_t*)0x2000000029e8 = 0xfffffff7;
  *(uint32_t*)0x2000000029ec = 0x81;
  *(uint32_t*)0x2000000029f0 = 1;
  *(uint32_t*)0x2000000029f4 = 0x80;
  *(uint32_t*)0x2000000029f8 = 8;
  *(uint32_t*)0x2000000029fc = 9;
  *(uint32_t*)0x200000002a00 = 0;
  *(uint32_t*)0x200000002a04 = 0;
  *(uint32_t*)0x200000002a08 = 7;
  *(uint32_t*)0x200000002a0c = 9;
  *(uint32_t*)0x200000002a10 = 4;
  *(uint32_t*)0x200000002a14 = 0x1400000;
  *(uint32_t*)0x200000002a18 = 9;
  *(uint32_t*)0x200000002a1c = 0xad;
  *(uint32_t*)0x200000002a20 = 6;
  *(uint32_t*)0x200000002a24 = 0xc;
  *(uint32_t*)0x200000002a28 = 0xffffff00;
  *(uint32_t*)0x200000002a2c = 5;
  *(uint32_t*)0x200000002a30 = 3;
  *(uint32_t*)0x200000002a34 = 3;
  *(uint32_t*)0x200000002a38 = 3;
  *(uint32_t*)0x200000002a3c = 7;
  *(uint32_t*)0x200000002a40 = 0x32da135;
  *(uint32_t*)0x200000002a44 = 0xb;
  *(uint32_t*)0x200000002a48 = 8;
  *(uint32_t*)0x200000002a4c = 0xa93c;
  *(uint32_t*)0x200000002a50 = 6;
  *(uint32_t*)0x200000002a54 = 0x3e;
  *(uint32_t*)0x200000002a58 = 0x5bce;
  *(uint32_t*)0x200000002a5c = 4;
  *(uint32_t*)0x200000002a60 = 0x7ff;
  *(uint32_t*)0x200000002a64 = 0x80000001;
  *(uint32_t*)0x200000002a68 = 0x32b;
  *(uint32_t*)0x200000002a6c = -1;
  *(uint32_t*)0x200000002a70 = 9;
  *(uint32_t*)0x200000002a74 = 0x100;
  *(uint32_t*)0x200000002a78 = 1;
  *(uint32_t*)0x200000002a7c = 0xfffffffb;
  *(uint32_t*)0x200000002a80 = 9;
  *(uint32_t*)0x200000002a84 = 0x10001;
  *(uint32_t*)0x200000002a88 = 1;
  *(uint32_t*)0x200000002a8c = 0xe0cc;
  *(uint32_t*)0x200000002a90 = 8;
  *(uint32_t*)0x200000002a94 = 9;
  *(uint32_t*)0x200000002a98 = 2;
  *(uint32_t*)0x200000002a9c = 0xf7;
  *(uint32_t*)0x200000002aa0 = 5;
  *(uint32_t*)0x200000002aa4 = 0x800;
  *(uint32_t*)0x200000002aa8 = 8;
  *(uint32_t*)0x200000002aac = 0x7f;
  *(uint32_t*)0x200000002ab0 = 0;
  *(uint32_t*)0x200000002ab4 = 0xdbeb;
  *(uint32_t*)0x200000002ab8 = 8;
  *(uint32_t*)0x200000002abc = 1;
  *(uint32_t*)0x200000002ac0 = 1;
  *(uint32_t*)0x200000002ac4 = 1;
  *(uint32_t*)0x200000002ac8 = 0x80000;
  *(uint32_t*)0x200000002acc = 5;
  *(uint32_t*)0x200000002ad0 = 0;
  *(uint32_t*)0x200000002ad4 = 0xbaf9;
  *(uint32_t*)0x200000002ad8 = 4;
  *(uint32_t*)0x200000002adc = 0x28000000;
  *(uint32_t*)0x200000002ae0 = 9;
  *(uint32_t*)0x200000002ae4 = 0;
  *(uint32_t*)0x200000002ae8 = 8;
  *(uint32_t*)0x200000002aec = 6;
  *(uint32_t*)0x200000002af0 = 9;
  *(uint32_t*)0x200000002af4 = 5;
  *(uint32_t*)0x200000002af8 = 0xfffffff4;
  *(uint32_t*)0x200000002afc = 0xadfe;
  *(uint32_t*)0x200000002b00 = 9;
  *(uint32_t*)0x200000002b04 = 1;
  *(uint32_t*)0x200000002b08 = 4;
  *(uint32_t*)0x200000002b0c = 0xfaf;
  *(uint32_t*)0x200000002b10 = 0x81;
  *(uint32_t*)0x200000002b14 = 0x800;
  *(uint32_t*)0x200000002b18 = 5;
  *(uint32_t*)0x200000002b1c = 3;
  *(uint32_t*)0x200000002b20 = 5;
  *(uint32_t*)0x200000002b24 = 5;
  *(uint32_t*)0x200000002b28 = 0x1e4;
  *(uint32_t*)0x200000002b2c = 6;
  *(uint32_t*)0x200000002b30 = 7;
  *(uint32_t*)0x200000002b34 = 8;
  *(uint32_t*)0x200000002b38 = 8;
  *(uint32_t*)0x200000002b3c = 0xad38;
  *(uint32_t*)0x200000002b40 = 6;
  *(uint32_t*)0x200000002b44 = 0xa;
  *(uint32_t*)0x200000002b48 = 0x4467;
  *(uint32_t*)0x200000002b4c = 9;
  *(uint32_t*)0x200000002b50 = 5;
  *(uint32_t*)0x200000002b54 = 0x401;
  *(uint32_t*)0x200000002b58 = 1;
  *(uint32_t*)0x200000002b5c = 0x1ff;
  *(uint32_t*)0x200000002b60 = 0x400;
  *(uint32_t*)0x200000002b64 = 9;
  *(uint32_t*)0x200000002b68 = 0x80000001;
  *(uint32_t*)0x200000002b6c = 0x7ff;
  *(uint32_t*)0x200000002b70 = 0xb6;
  *(uint32_t*)0x200000002b74 = 0x1000;
  *(uint32_t*)0x200000002b78 = 0xffff8001;
  *(uint32_t*)0x200000002b7c = 0x40;
  *(uint32_t*)0x200000002b80 = 2;
  *(uint32_t*)0x200000002b84 = 0x800;
  *(uint32_t*)0x200000002b88 = 3;
  *(uint32_t*)0x200000002b8c = 9;
  *(uint32_t*)0x200000002b90 = 0xb;
  *(uint32_t*)0x200000002b94 = 5;
  *(uint32_t*)0x200000002b98 = 9;
  *(uint32_t*)0x200000002b9c = 4;
  *(uint32_t*)0x200000002ba0 = 9;
  *(uint32_t*)0x200000002ba4 = 0;
  *(uint32_t*)0x200000002ba8 = 0xe;
  *(uint32_t*)0x200000002bac = 4;
  *(uint32_t*)0x200000002bb0 = 4;
  *(uint32_t*)0x200000002bb4 = 9;
  *(uint32_t*)0x200000002bb8 = 6;
  *(uint32_t*)0x200000002bbc = 5;
  *(uint32_t*)0x200000002bc0 = 4;
  *(uint32_t*)0x200000002bc4 = 6;
  *(uint32_t*)0x200000002bc8 = 0xfffffffe;
  *(uint32_t*)0x200000002bcc = 4;
  *(uint32_t*)0x200000002bd0 = 0xfff;
  *(uint32_t*)0x200000002bd4 = 5;
  *(uint32_t*)0x200000002bd8 = 0;
  *(uint32_t*)0x200000002bdc = 1;
  *(uint32_t*)0x200000002be0 = 0x5a48;
  *(uint32_t*)0x200000002be4 = 6;
  *(uint32_t*)0x200000002be8 = 0xfffffff9;
  *(uint32_t*)0x200000002bec = -1;
  *(uint32_t*)0x200000002bf0 = 0x80000000;
  *(uint32_t*)0x200000002bf4 = 0x6d;
  *(uint32_t*)0x200000002bf8 = 0;
  *(uint32_t*)0x200000002bfc = 8;
  *(uint32_t*)0x200000002c00 = 0xe;
  *(uint32_t*)0x200000002c04 = 9;
  *(uint32_t*)0x200000002c08 = 0xfffffffa;
  *(uint32_t*)0x200000002c0c = 5;
  *(uint32_t*)0x200000002c10 = 6;
  *(uint32_t*)0x200000002c14 = 8;
  *(uint32_t*)0x200000002c18 = 9;
  *(uint32_t*)0x200000002c1c = 0x7fff;
  *(uint32_t*)0x200000002c20 = 3;
  *(uint32_t*)0x200000002c24 = 5;
  *(uint32_t*)0x200000002c28 = 0x3ff;
  *(uint32_t*)0x200000002c2c = 8;
  *(uint32_t*)0x200000002c30 = 7;
  *(uint32_t*)0x200000002c34 = 0x10001;
  *(uint32_t*)0x200000002c38 = 7;
  *(uint32_t*)0x200000002c3c = 2;
  *(uint32_t*)0x200000002c40 = 0x7ff;
  *(uint32_t*)0x200000002c44 = 9;
  *(uint32_t*)0x200000002c48 = 6;
  *(uint32_t*)0x200000002c4c = 3;
  *(uint32_t*)0x200000002c50 = 0x9de;
  *(uint32_t*)0x200000002c54 = 4;
  *(uint32_t*)0x200000002c58 = 0x11;
  *(uint32_t*)0x200000002c5c = 7;
  *(uint32_t*)0x200000002c60 = 9;
  *(uint32_t*)0x200000002c64 = 3;
  *(uint32_t*)0x200000002c68 = 9;
  *(uint32_t*)0x200000002c6c = 0x8f;
  *(uint32_t*)0x200000002c70 = 0xffffdd1a;
  *(uint32_t*)0x200000002c74 = 0x10;
  *(uint32_t*)0x200000002c78 = 2;
  *(uint32_t*)0x200000002c7c = 1;
  *(uint32_t*)0x200000002c80 = 0xa8a9;
  *(uint32_t*)0x200000002c84 = 1;
  *(uint32_t*)0x200000002c88 = 5;
  *(uint32_t*)0x200000002c8c = 7;
  *(uint32_t*)0x200000002c90 = 0x401;
  *(uint32_t*)0x200000002c94 = 4;
  *(uint32_t*)0x200000002c98 = 0xffff;
  *(uint32_t*)0x200000002c9c = 0x1000;
  *(uint32_t*)0x200000002ca0 = 1;
  *(uint32_t*)0x200000002ca4 = 6;
  *(uint32_t*)0x200000002ca8 = 1;
  *(uint32_t*)0x200000002cac = 0x2a;
  *(uint32_t*)0x200000002cb0 = 0;
  *(uint32_t*)0x200000002cb4 = 0x80000000;
  *(uint32_t*)0x200000002cb8 = 0;
  *(uint32_t*)0x200000002cbc = 0xfc;
  *(uint32_t*)0x200000002cc0 = 3;
  *(uint32_t*)0x200000002cc4 = 0xc55b;
  *(uint32_t*)0x200000002cc8 = 5;
  *(uint32_t*)0x200000002ccc = 0xb;
  *(uint32_t*)0x200000002cd0 = 0x8001;
  *(uint32_t*)0x200000002cd4 = 4;
  *(uint32_t*)0x200000002cd8 = 0x1ff;
  *(uint32_t*)0x200000002cdc = 7;
  *(uint32_t*)0x200000002ce0 = 6;
  *(uint32_t*)0x200000002ce4 = 0;
  *(uint32_t*)0x200000002ce8 = 0x1d;
  *(uint32_t*)0x200000002cec = 0x42f;
  *(uint32_t*)0x200000002cf0 = 7;
  *(uint32_t*)0x200000002cf4 = 0xfffffff8;
  *(uint32_t*)0x200000002cf8 = 6;
  *(uint32_t*)0x200000002cfc = 3;
  *(uint32_t*)0x200000002d00 = 2;
  *(uint32_t*)0x200000002d04 = 7;
  *(uint32_t*)0x200000002d08 = 7;
  *(uint32_t*)0x200000002d0c = 1;
  *(uint32_t*)0x200000002d10 = 2;
  *(uint32_t*)0x200000002d14 = 5;
  *(uint32_t*)0x200000002d18 = 0x30;
  *(uint32_t*)0x200000002d1c = 0xfe68;
  *(uint32_t*)0x200000002d20 = 0x800;
  *(uint32_t*)0x200000002d24 = 0x80000000;
  *(uint32_t*)0x200000002d28 = 2;
  *(uint32_t*)0x200000002d2c = 1;
  *(uint32_t*)0x200000002d30 = 8;
  *(uint32_t*)0x200000002d34 = 0;
  *(uint32_t*)0x200000002d38 = -1;
  *(uint32_t*)0x200000002d3c = 3;
  *(uint32_t*)0x200000002d40 = 0x6021db75;
  *(uint32_t*)0x200000002d44 = 0x7fff;
  *(uint32_t*)0x200000002d48 = 0x1000;
  *(uint32_t*)0x200000002d4c = 0xc1;
  *(uint32_t*)0x200000002d50 = 0x1add65aa;
  *(uint32_t*)0x200000002d54 = 2;
  *(uint32_t*)0x200000002d58 = 7;
  *(uint32_t*)0x200000002d5c = 4;
  *(uint32_t*)0x200000002d60 = 2;
  *(uint32_t*)0x200000002d64 = 0xe9;
  *(uint32_t*)0x200000002d68 = 0x986;
  *(uint32_t*)0x200000002d6c = 0xba;
  *(uint32_t*)0x200000002d70 = 8;
  *(uint32_t*)0x200000002d74 = 6;
  *(uint32_t*)0x200000002d78 = 0x401;
  *(uint32_t*)0x200000002d7c = 4;
  *(uint32_t*)0x200000002d80 = 0x10;
  *(uint32_t*)0x200000002d84 = 9;
  *(uint32_t*)0x200000002d88 = 0x7fffffff;
  *(uint32_t*)0x200000002d8c = 0xb70f;
  *(uint32_t*)0x200000002d90 = 0x40;
  *(uint32_t*)0x200000002d94 = 3;
  *(uint32_t*)0x200000002d98 = 0xfffffffe;
  *(uint32_t*)0x200000002d9c = 4;
  *(uint32_t*)0x200000002da0 = 3;
  *(uint32_t*)0x200000002da4 = 4;
  *(uint32_t*)0x200000002da8 = 0xd;
  *(uint32_t*)0x200000002dac = 0xb24;
  *(uint32_t*)0x200000002db0 = 6;
  *(uint32_t*)0x200000002db4 = 0xbf;
  *(uint32_t*)0x200000002db8 = 3;
  *(uint32_t*)0x200000002dbc = 0xbf6;
  *(uint32_t*)0x200000002dc0 = 0xfffeffff;
  *(uint32_t*)0x200000002dc4 = 2;
  *(uint32_t*)0x200000002dc8 = 3;
  *(uint32_t*)0x200000002dcc = 3;
  *(uint32_t*)0x200000002dd0 = 6;
  *(uint32_t*)0x200000002dd4 = 4;
  *(uint32_t*)0x200000002dd8 = 0x7c6;
  *(uint32_t*)0x200000002ddc = 0x80000001;
  *(uint32_t*)0x200000002de0 = 1;
  *(uint32_t*)0x200000002de4 = 0x58e2;
  *(uint32_t*)0x200000002de8 = 1;
  *(uint32_t*)0x200000002dec = 4;
  *(uint32_t*)0x200000002df0 = 7;
  *(uint32_t*)0x200000002df4 = 0x3ff;
  *(uint32_t*)0x200000002df8 = 4;
  *(uint32_t*)0x200000002dfc = 6;
  *(uint32_t*)0x200000002e00 = 0xb4;
  *(uint32_t*)0x200000002e04 = 0xeb;
  *(uint32_t*)0x200000002e08 = 3;
  *(uint32_t*)0x200000002e0c = 6;
  *(uint32_t*)0x200000002e10 = 0xe;
  *(uint32_t*)0x200000002e14 = 0xc;
  *(uint32_t*)0x200000002e18 = 1;
  *(uint32_t*)0x200000002e1c = 3;
  *(uint32_t*)0x200000002e20 = 0xf;
  *(uint32_t*)0x200000002e24 = 7;
  *(uint32_t*)0x200000002e28 = 0xdb10ee8a;
  *(uint32_t*)0x200000002e2c = 3;
  *(uint32_t*)0x200000002e30 = 0xf;
  *(uint32_t*)0x200000002e34 = 0x81;
  *(uint32_t*)0x200000002e38 = 0x420d;
  *(uint32_t*)0x200000002e3c = 0xa;
  *(uint32_t*)0x200000002e40 = 0xad78;
  *(uint32_t*)0x200000002e44 = 2;
  *(uint32_t*)0x200000002e48 = 4;
  *(uint32_t*)0x200000002e4c = 0xfffffffc;
  *(uint32_t*)0x200000002e50 = 0x401;
  *(uint32_t*)0x200000002e54 = 4;
  *(uint32_t*)0x200000002e58 = 2;
  *(uint32_t*)0x200000002e5c = 4;
  *(uint32_t*)0x200000002e60 = 4;
  *(uint32_t*)0x200000002e64 = 3;
  *(uint32_t*)0x200000002e68 = 0xf908;
  *(uint32_t*)0x200000002e6c = 2;
  *(uint32_t*)0x200000002e70 = 0x400;
  *(uint32_t*)0x200000002e74 = 0x800;
  *(uint32_t*)0x200000002e78 = 6;
  *(uint32_t*)0x200000002e7c = 2;
  *(uint32_t*)0x200000002e80 = 4;
  *(uint32_t*)0x200000002e84 = 0x8e20;
  *(uint32_t*)0x200000002e88 = 4;
  *(uint32_t*)0x200000002e8c = 0x7ae4fc5e;
  *(uint32_t*)0x200000002e90 = 3;
  *(uint32_t*)0x200000002e94 = 0xf;
  *(uint32_t*)0x200000002e98 = 0xf87;
  *(uint32_t*)0x200000002e9c = 2;
  *(uint32_t*)0x200000002ea0 = 1;
  *(uint32_t*)0x200000002ea4 = 2;
  *(uint32_t*)0x200000002ea8 = 7;
  *(uint32_t*)0x200000002eac = 0xed7e;
  *(uint32_t*)0x200000002eb0 = 4;
  *(uint32_t*)0x200000002eb4 = 5;
  *(uint32_t*)0x200000002eb8 = 0xdc;
  *(uint32_t*)0x200000002ebc = 4;
  *(uint32_t*)0x200000002ec0 = 0x154;
  *(uint32_t*)0x200000002ec4 = 0xfffffe00;
  *(uint32_t*)0x200000002ec8 = 0x3ff80000;
  *(uint32_t*)0x200000002ecc = 2;
  *(uint32_t*)0x200000002ed0 = 0xa;
  *(uint32_t*)0x200000002ed4 = 6;
  *(uint32_t*)0x200000002ed8 = 5;
  *(uint32_t*)0x200000002edc = 3;
  *(uint32_t*)0x200000002ee0 = 0x3a84;
  *(uint32_t*)0x200000002ee4 = 0;
  *(uint32_t*)0x200000002ee8 = 1;
  *(uint32_t*)0x200000002eec = 0xeea1;
  *(uint32_t*)0x200000002ef0 = 9;
  *(uint32_t*)0x200000002ef4 = 0x55de2144;
  *(uint32_t*)0x200000002ef8 = 9;
  *(uint32_t*)0x200000002efc = 0x80;
  *(uint32_t*)0x200000002f00 = 0x7cf;
  *(uint32_t*)0x200000002f04 = 2;
  *(uint32_t*)0x200000002f08 = 6;
  *(uint32_t*)0x200000002f0c = 8;
  *(uint32_t*)0x200000002f10 = 3;
  *(uint32_t*)0x200000002f14 = 0;
  *(uint32_t*)0x200000002f18 = 0x7fffffff;
  *(uint32_t*)0x200000002f1c = 0x1000;
  *(uint32_t*)0x200000002f20 = 0x7f;
  *(uint32_t*)0x200000002f24 = 0x8000;
  *(uint32_t*)0x200000002f28 = 0xfffffffe;
  *(uint32_t*)0x200000002f2c = 8;
  *(uint32_t*)0x200000002f30 = 0xd1e;
  *(uint32_t*)0x200000002f34 = 6;
  *(uint32_t*)0x200000002f38 = 2;
  *(uint32_t*)0x200000002f3c = 0x6c5;
  *(uint32_t*)0x200000002f40 = 0xd;
  *(uint32_t*)0x200000002f44 = 4;
  *(uint32_t*)0x200000002f48 = 8;
  *(uint32_t*)0x200000002f4c = 1;
  *(uint32_t*)0x200000002f50 = 5;
  *(uint32_t*)0x200000002f54 = 0x10000;
  *(uint32_t*)0x200000002f58 = 0xc;
  *(uint32_t*)0x200000002f5c = 0x7ff;
  *(uint32_t*)0x200000002f60 = 5;
  *(uint32_t*)0x200000002f64 = 4;
  *(uint32_t*)0x200000002f68 = 7;
  *(uint32_t*)0x200000002f6c = 0x264564e6;
  *(uint32_t*)0x200000002f70 = 0xea;
  *(uint32_t*)0x200000002f74 = 0x7fff;
  *(uint32_t*)0x200000002f78 = 1;
  *(uint32_t*)0x200000002f7c = 0xa;
  *(uint32_t*)0x200000002f80 = 4;
  *(uint32_t*)0x200000002f84 = 2;
  *(uint32_t*)0x200000002f88 = 3;
  *(uint32_t*)0x200000002f8c = 0;
  *(uint32_t*)0x200000002f90 = 7;
  *(uint32_t*)0x200000002f94 = 0x84000000;
  *(uint32_t*)0x200000002f98 = 9;
  *(uint32_t*)0x200000002f9c = 2;
  *(uint32_t*)0x200000002fa0 = 0x8000;
  *(uint32_t*)0x200000002fa4 = 5;
  *(uint32_t*)0x200000002fa8 = 4;
  *(uint32_t*)0x200000002fac = 0;
  *(uint32_t*)0x200000002fb0 = 2;
  *(uint32_t*)0x200000002fb4 = 0xa483;
  *(uint32_t*)0x200000002fb8 = 9;
  *(uint32_t*)0x200000002fbc = 2;
  *(uint32_t*)0x200000002fc0 = 6;
  *(uint32_t*)0x200000002fc4 = 0x22;
  *(uint32_t*)0x200000002fc8 = 2;
  *(uint32_t*)0x200000002fcc = 9;
  *(uint32_t*)0x200000002fd0 = 1;
  *(uint32_t*)0x200000002fd4 = 3;
  *(uint32_t*)0x200000002fd8 = 4;
  *(uint32_t*)0x200000002fdc = 3;
  *(uint32_t*)0x200000002fe0 = 3;
  *(uint32_t*)0x200000002fe4 = 0x7fff;
  *(uint32_t*)0x200000002fe8 = 0;
  *(uint32_t*)0x200000002fec = 0x46;
  *(uint32_t*)0x200000002ff0 = 0x7fffffff;
  *(uint32_t*)0x200000002ff4 = 6;
  *(uint32_t*)0x200000002ff8 = 8;
  *(uint32_t*)0x200000002ffc = 0xffffc000;
  *(uint32_t*)0x200000003000 = 0x1ff;
  *(uint32_t*)0x200000003004 = 8;
  *(uint32_t*)0x200000003008 = 0;
  *(uint32_t*)0x20000000300c = 0xe;
  *(uint32_t*)0x200000003010 = 1;
  *(uint32_t*)0x200000003014 = 0;
  *(uint32_t*)0x200000003018 = 9;
  *(uint32_t*)0x20000000301c = 9;
  *(uint32_t*)0x200000003020 = 8;
  *(uint32_t*)0x200000003024 = 0x1000;
  *(uint32_t*)0x200000003028 = 9;
  *(uint32_t*)0x20000000302c = -1;
  *(uint32_t*)0x200000003030 = 0x100;
  *(uint32_t*)0x200000003034 = 0x3ff;
  *(uint32_t*)0x200000003038 = 0;
  *(uint32_t*)0x20000000303c = 0x80;
  *(uint32_t*)0x200000003040 = 1;
  *(uint32_t*)0x200000003044 = 9;
  *(uint32_t*)0x200000003048 = 0x6a59;
  *(uint32_t*)0x20000000304c = 4;
  *(uint32_t*)0x200000003050 = 3;
  *(uint32_t*)0x200000003054 = 0x8000;
  *(uint32_t*)0x200000003058 = 0;
  *(uint32_t*)0x20000000305c = 0x100;
  *(uint32_t*)0x200000003060 = 1;
  *(uint32_t*)0x200000003064 = 0;
  *(uint32_t*)0x200000003068 = 4;
  *(uint32_t*)0x20000000306c = 0;
  *(uint32_t*)0x200000003070 = 0x401;
  *(uint32_t*)0x200000003074 = 0xbe5e;
  *(uint32_t*)0x200000003078 = 0;
  *(uint32_t*)0x20000000307c = 0x81;
  *(uint32_t*)0x200000003080 = 0xd0;
  *(uint32_t*)0x200000003084 = 6;
  *(uint32_t*)0x200000003088 = 0xa;
  *(uint32_t*)0x20000000308c = 0x146e;
  *(uint32_t*)0x200000003090 = 8;
  *(uint32_t*)0x200000003094 = 0xe;
  *(uint32_t*)0x200000003098 = 0xb08;
  *(uint32_t*)0x20000000309c = 0x7ff;
  *(uint32_t*)0x2000000030a0 = 0;
  *(uint32_t*)0x2000000030a4 = 4;
  *(uint32_t*)0x2000000030a8 = 0;
  *(uint32_t*)0x2000000030ac = 0x7f;
  *(uint32_t*)0x2000000030b0 = 1;
  *(uint32_t*)0x2000000030b4 = 0xfffffff6;
  *(uint32_t*)0x2000000030b8 = 5;
  *(uint32_t*)0x2000000030bc = 0xe;
  *(uint32_t*)0x2000000030c0 = 0xff;
  *(uint32_t*)0x2000000030c4 = 7;
  *(uint32_t*)0x2000000030c8 = 6;
  *(uint32_t*)0x2000000030cc = 0;
  *(uint32_t*)0x2000000030d0 = 0x4c;
  *(uint32_t*)0x2000000030d4 = 8;
  *(uint32_t*)0x2000000030d8 = 0xfffffffc;
  *(uint32_t*)0x2000000030dc = 2;
  *(uint32_t*)0x2000000030e0 = 0xd42;
  *(uint32_t*)0x2000000030e4 = 0xff;
  *(uint32_t*)0x2000000030e8 = 0xfffffffc;
  *(uint32_t*)0x2000000030ec = 2;
  *(uint32_t*)0x2000000030f0 = 0;
  *(uint32_t*)0x2000000030f4 = 0xb881;
  *(uint32_t*)0x2000000030f8 = 6;
  *(uint32_t*)0x2000000030fc = 3;
  *(uint32_t*)0x200000003100 = 8;
  *(uint32_t*)0x200000003104 = -1;
  *(uint32_t*)0x200000003108 = 0xfffffbff;
  *(uint32_t*)0x20000000310c = 1;
  *(uint32_t*)0x200000003110 = 0x96e;
  *(uint32_t*)0x200000003114 = 5;
  *(uint32_t*)0x200000003118 = 6;
  *(uint32_t*)0x20000000311c = 0x380000;
  *(uint32_t*)0x200000003120 = 3;
  *(uint32_t*)0x200000003124 = 7;
  *(uint32_t*)0x200000003128 = 2;
  *(uint32_t*)0x20000000312c = 0;
  *(uint32_t*)0x200000003130 = 0x81;
  *(uint32_t*)0x200000003134 = 3;
  *(uint32_t*)0x200000003138 = 1;
  *(uint32_t*)0x20000000313c = 4;
  *(uint32_t*)0x200000003140 = 4;
  *(uint32_t*)0x200000003144 = 0;
  *(uint32_t*)0x200000003148 = 7;
  *(uint32_t*)0x20000000314c = 8;
  *(uint32_t*)0x200000003150 = 5;
  *(uint32_t*)0x200000003154 = 3;
  *(uint32_t*)0x200000003158 = 0x10;
  *(uint32_t*)0x20000000315c = 4;
  *(uint32_t*)0x200000003160 = 6;
  *(uint32_t*)0x200000003164 = 3;
  *(uint32_t*)0x200000003168 = 0xf;
  *(uint32_t*)0x20000000316c = 0xf;
  *(uint32_t*)0x200000003170 = 9;
  *(uint32_t*)0x200000003174 = 0x7fffffff;
  *(uint32_t*)0x200000003178 = 0x8000;
  *(uint32_t*)0x20000000317c = 0x3ff;
  *(uint32_t*)0x200000003180 = 8;
  *(uint32_t*)0x200000003184 = 0x505;
  *(uint32_t*)0x200000003188 = 0xe3e;
  *(uint32_t*)0x20000000318c = 9;
  *(uint32_t*)0x200000003190 = 1;
  *(uint32_t*)0x200000003194 = 7;
  *(uint32_t*)0x200000003198 = 0xd1;
  *(uint32_t*)0x20000000319c = 8;
  *(uint32_t*)0x2000000031a0 = 1;
  *(uint32_t*)0x2000000031a4 = 4;
  *(uint32_t*)0x2000000031a8 = 0x9da;
  *(uint32_t*)0x2000000031ac = 2;
  *(uint32_t*)0x2000000031b0 = 7;
  *(uint32_t*)0x2000000031b4 = 0x9d94bae;
  *(uint32_t*)0x2000000031b8 = 0x101;
  *(uint32_t*)0x2000000031bc = 6;
  *(uint32_t*)0x2000000031c0 = 2;
  *(uint32_t*)0x2000000031c4 = 0x7f;
  *(uint32_t*)0x2000000031c8 = 0x13760;
  *(uint32_t*)0x2000000031cc = 0x10001;
  *(uint32_t*)0x2000000031d0 = 9;
  *(uint32_t*)0x2000000031d4 = 0x3c;
  *(uint32_t*)0x2000000031d8 = 0;
  *(uint32_t*)0x2000000031dc = 0x409;
  *(uint32_t*)0x2000000031e0 = 3;
  *(uint32_t*)0x2000000031e4 = 0xfffeffff;
  *(uint32_t*)0x2000000031e8 = 0;
  *(uint32_t*)0x2000000031ec = 9;
  *(uint32_t*)0x2000000031f0 = 7;
  *(uint32_t*)0x2000000031f4 = 0;
  *(uint32_t*)0x2000000031f8 = 0xf5;
  *(uint32_t*)0x2000000031fc = -1;
  *(uint32_t*)0x200000003200 = 0x7c94;
  *(uint32_t*)0x200000003204 = 5;
  *(uint32_t*)0x200000003208 = 3;
  *(uint32_t*)0x20000000320c = 0xfff;
  *(uint32_t*)0x200000003210 = 5;
  *(uint32_t*)0x200000003214 = 0x99;
  *(uint32_t*)0x200000003218 = 0x4e;
  *(uint32_t*)0x20000000321c = 0x10;
  *(uint32_t*)0x200000003220 = 3;
  *(uint32_t*)0x200000003224 = 8;
  *(uint32_t*)0x200000003228 = 0x4516;
  *(uint32_t*)0x20000000322c = 1;
  *(uint32_t*)0x200000003230 = 0xe89c;
  *(uint32_t*)0x200000003234 = 0x21b;
  *(uint32_t*)0x200000003238 = 9;
  *(uint32_t*)0x20000000323c = 0xa;
  *(uint32_t*)0x200000003240 = 5;
  *(uint32_t*)0x200000003244 = 0x7fff;
  *(uint32_t*)0x200000003248 = 0;
  *(uint32_t*)0x20000000324c = 0x7f;
  *(uint32_t*)0x200000003250 = 0;
  *(uint32_t*)0x200000003254 = 0x489;
  *(uint32_t*)0x200000003258 = 1;
  *(uint32_t*)0x20000000325c = 0x80000001;
  *(uint32_t*)0x200000003260 = 0xe;
  *(uint32_t*)0x200000003264 = 5;
  *(uint32_t*)0x200000003268 = 0xfffff1f4;
  *(uint32_t*)0x20000000326c = 7;
  *(uint32_t*)0x200000003270 = 5;
  *(uint32_t*)0x200000003274 = 7;
  *(uint32_t*)0x200000003278 = 9;
  *(uint32_t*)0x20000000327c = 4;
  *(uint32_t*)0x200000003280 = 6;
  *(uint32_t*)0x200000003284 = 3;
  *(uint32_t*)0x200000003288 = 5;
  *(uint32_t*)0x20000000328c = 6;
  *(uint32_t*)0x200000003290 = 1;
  *(uint32_t*)0x200000003294 = 0xe3e;
  *(uint32_t*)0x200000003298 = 0xfffffffd;
  *(uint32_t*)0x20000000329c = 3;
  *(uint32_t*)0x2000000032a0 = 5;
  *(uint32_t*)0x2000000032a4 = 0x8000;
  *(uint32_t*)0x2000000032a8 = 2;
  *(uint32_t*)0x2000000032ac = 0x101;
  *(uint32_t*)0x2000000032b0 = 0xa2;
  *(uint32_t*)0x2000000032b4 = 0xff;
  *(uint32_t*)0x2000000032b8 = 0xfffffff7;
  *(uint32_t*)0x2000000032bc = 0x10001;
  *(uint32_t*)0x2000000032c0 = 0x80000000;
  *(uint32_t*)0x2000000032c4 = 0x14a9;
  *(uint32_t*)0x2000000032c8 = 0x1ff;
  *(uint32_t*)0x2000000032cc = 3;
  *(uint32_t*)0x2000000032d0 = 2;
  *(uint32_t*)0x2000000032d4 = 7;
  *(uint32_t*)0x2000000032d8 = 1;
  *(uint32_t*)0x2000000032dc = 0xa82c;
  *(uint32_t*)0x2000000032e0 = 0x570b;
  *(uint32_t*)0x2000000032e4 = 9;
  *(uint32_t*)0x2000000032e8 = 0;
  *(uint32_t*)0x2000000032ec = 1;
  *(uint32_t*)0x2000000032f0 = 5;
  *(uint32_t*)0x2000000032f4 = 2;
  *(uint32_t*)0x2000000032f8 = 3;
  *(uint32_t*)0x2000000032fc = 2;
  *(uint32_t*)0x200000003300 = 0xffff0000;
  *(uint32_t*)0x200000003304 = 8;
  *(uint32_t*)0x200000003308 = 7;
  *(uint32_t*)0x20000000330c = 2;
  *(uint32_t*)0x200000003310 = 0xd2;
  *(uint32_t*)0x200000003314 = 1;
  *(uint32_t*)0x200000003318 = 9;
  *(uint32_t*)0x20000000331c = 0x10;
  *(uint32_t*)0x200000003320 = 0xfffff000;
  *(uint32_t*)0x200000003324 = 5;
  *(uint32_t*)0x200000003328 = 8;
  *(uint32_t*)0x20000000332c = 1;
  *(uint32_t*)0x200000003330 = 0;
  *(uint32_t*)0x200000003334 = 4;
  *(uint32_t*)0x200000003338 = 0x1c5b;
  *(uint32_t*)0x20000000333c = 2;
  *(uint32_t*)0x200000003340 = 0xffff5a2f;
  *(uint32_t*)0x200000003344 = 2;
  *(uint32_t*)0x200000003348 = 5;
  *(uint32_t*)0x20000000334c = 1;
  *(uint32_t*)0x200000003350 = 0x200;
  *(uint32_t*)0x200000003354 = 0x193cfceb;
  *(uint32_t*)0x200000003358 = 0x800;
  *(uint32_t*)0x20000000335c = 3;
  *(uint32_t*)0x200000003360 = 0xd;
  *(uint32_t*)0x200000003364 = 4;
  *(uint32_t*)0x200000003368 = 5;
  *(uint32_t*)0x20000000336c = 8;
  *(uint32_t*)0x200000003370 = 0x1fffe;
  *(uint32_t*)0x200000003374 = 2;
  *(uint32_t*)0x200000003378 = 9;
  *(uint32_t*)0x20000000337c = 0;
  *(uint32_t*)0x200000003380 = 0xc38c;
  *(uint32_t*)0x200000003384 = 9;
  *(uint32_t*)0x200000003388 = 0;
  *(uint32_t*)0x20000000338c = 5;
  *(uint32_t*)0x200000003390 = 4;
  *(uint32_t*)0x200000003394 = 0xfffffffd;
  *(uint32_t*)0x200000003398 = 0xe0000;
  *(uint32_t*)0x20000000339c = -1;
  *(uint32_t*)0x2000000033a0 = 0xec;
  *(uint32_t*)0x2000000033a4 = 5;
  *(uint32_t*)0x2000000033a8 = 4;
  *(uint32_t*)0x2000000033ac = 0xc1e7;
  *(uint32_t*)0x2000000033b0 = 0xb64d;
  *(uint32_t*)0x2000000033b4 = 0x8000;
  *(uint32_t*)0x2000000033b8 = 0x87;
  *(uint32_t*)0x2000000033bc = 0x7ce;
  *(uint32_t*)0x2000000033c0 = 0x400;
  *(uint32_t*)0x2000000033c4 = 0;
  *(uint32_t*)0x2000000033c8 = 0x2d;
  *(uint32_t*)0x2000000033cc = 9;
  *(uint32_t*)0x2000000033d0 = 9;
  *(uint32_t*)0x2000000033d4 = 2;
  *(uint32_t*)0x2000000033d8 = 0x18f;
  *(uint32_t*)0x2000000033dc = 0x3ff;
  *(uint32_t*)0x2000000033e0 = 3;
  *(uint32_t*)0x2000000033e4 = 2;
  *(uint32_t*)0x2000000033e8 = 5;
  *(uint32_t*)0x2000000033ec = 6;
  *(uint32_t*)0x2000000033f0 = 0xb;
  *(uint32_t*)0x2000000033f4 = 7;
  *(uint32_t*)0x2000000033f8 = 0;
  *(uint32_t*)0x2000000033fc = 0x81;
  *(uint32_t*)0x200000003400 = 2;
  *(uint32_t*)0x200000003404 = 4;
  *(uint32_t*)0x200000003408 = 0;
  *(uint32_t*)0x20000000340c = 3;
  *(uint32_t*)0x200000003410 = 7;
  *(uint32_t*)0x200000003414 = 0x9f8;
  *(uint32_t*)0x200000003418 = 2;
  *(uint32_t*)0x20000000341c = 4;
  *(uint32_t*)0x200000003420 = 0xe;
  *(uint32_t*)0x200000003424 = 0x400;
  *(uint32_t*)0x200000003428 = 6;
  *(uint16_t*)0x20000000342c = 2;
  *(uint16_t*)0x20000000342e = 0;
  *(uint16_t*)0x200000003430 = 0x530;
  *(uint16_t*)0x200000003432 = 0;
  *(uint16_t*)0x200000003434 = 1;
  *(uint16_t*)0x200000003436 = 1;
  *(uint16_t*)0x200000003438 = 4;
  *(uint16_t*)0x20000000343a = 0;
  *(uint16_t*)0x20000000343c = 5;
  *(uint16_t*)0x20000000343e = 1;
  *(uint16_t*)0x200000003440 = 2;
  *(uint16_t*)0x200000003442 = 1;
  *(uint16_t*)0x200000003444 = 0;
  *(uint16_t*)0x200000003446 = 1;
  *(uint16_t*)0x200000003448 = 1;
  *(uint16_t*)0x20000000344a = 1;
  *(uint16_t*)0x20000000344c = 4;
  *(uint16_t*)0x20000000344e = 0;
  *(uint16_t*)0x200000003450 = 2;
  *(uint16_t*)0x200000003452 = 1;
  *(uint16_t*)0x200000003454 = 1;
  *(uint16_t*)0x200000003456 = 1;
  *(uint16_t*)0x200000003458 = 4;
  *(uint16_t*)0x20000000345a = 0;
  *(uint16_t*)0x20000000345c = 5;
  *(uint16_t*)0x20000000345e = 0;
  *(uint16_t*)0x200000003460 = 7;
  *(uint16_t*)0x200000003462 = 1;
  *(uint16_t*)0x200000003464 = 3;
  *(uint16_t*)0x200000003466 = 0;
  *(uint16_t*)0x200000003468 = 4;
  *(uint16_t*)0x20000000346a = 1;
  *(uint16_t*)0x20000000346c = 5;
  *(uint16_t*)0x20000000346e = 1;
  *(uint16_t*)0x200000003470 = 1;
  *(uint16_t*)0x200000003472 = 0;
  *(uint16_t*)0x200000003474 = 4;
  *(uint16_t*)0x200000003476 = 1;
  *(uint16_t*)0x200000003478 = 1;
  *(uint16_t*)0x20000000347a = 0;
  *(uint16_t*)0x20000000347c = 1;
  *(uint16_t*)0x20000000347e = 0;
  *(uint16_t*)0x200000003480 = 1;
  *(uint16_t*)0x200000003482 = 0;
  *(uint16_t*)0x200000003484 = 4;
  *(uint16_t*)0x200000003486 = 0;
  *(uint16_t*)0x200000003488 = 0;
  *(uint16_t*)0x20000000348a = 1;
  *(uint16_t*)0x20000000348c = 3;
  *(uint16_t*)0x20000000348e = 1;
  *(uint16_t*)0x200000003490 = 5;
  *(uint16_t*)0x200000003492 = 1;
  *(uint16_t*)0x200000003494 = 2;
  *(uint16_t*)0x200000003496 = 1;
  *(uint16_t*)0x200000003498 = 1;
  *(uint16_t*)0x20000000349a = 0;
  *(uint16_t*)0x20000000349c = 0;
  *(uint16_t*)0x20000000349e = 0;
  *(uint16_t*)0x2000000034a0 = 1;
  *(uint16_t*)0x2000000034a2 = 1;
  *(uint16_t*)0x2000000034a4 = 3;
  *(uint16_t*)0x2000000034a6 = 0;
  *(uint16_t*)0x2000000034a8 = 1;
  *(uint16_t*)0x2000000034aa = 1;
  *(uint16_t*)0x2000000034ac = 3;
  *(uint16_t*)0x2000000034ae = 1;
  *(uint16_t*)0x2000000034b0 = 0;
  *(uint16_t*)0x2000000034b2 = 1;
  *(uint16_t*)0x2000000034b4 = 4;
  *(uint16_t*)0x2000000034b6 = 1;
  *(uint16_t*)0x2000000034b8 = 3;
  *(uint16_t*)0x2000000034ba = 1;
  *(uint16_t*)0x2000000034bc = 5;
  *(uint16_t*)0x2000000034be = 0;
  *(uint16_t*)0x2000000034c0 = 1;
  *(uint16_t*)0x2000000034c2 = 1;
  *(uint16_t*)0x2000000034c4 = 5;
  *(uint16_t*)0x2000000034c6 = 1;
  *(uint16_t*)0x2000000034c8 = 3;
  *(uint16_t*)0x2000000034ca = 1;
  *(uint16_t*)0x2000000034cc = 2;
  *(uint16_t*)0x2000000034ce = 0;
  *(uint16_t*)0x2000000034d0 = 1;
  *(uint16_t*)0x2000000034d2 = 0;
  *(uint16_t*)0x2000000034d4 = 0;
  *(uint16_t*)0x2000000034d6 = 0;
  *(uint16_t*)0x2000000034d8 = 1;
  *(uint16_t*)0x2000000034da = 0;
  *(uint16_t*)0x2000000034dc = 5;
  *(uint16_t*)0x2000000034de = 0;
  *(uint16_t*)0x2000000034e0 = 0;
  *(uint16_t*)0x2000000034e2 = 1;
  *(uint16_t*)0x2000000034e4 = 5;
  *(uint16_t*)0x2000000034e6 = 0;
  *(uint16_t*)0x2000000034e8 = 5;
  *(uint16_t*)0x2000000034ea = 0;
  *(uint16_t*)0x2000000034ec = 4;
  *(uint16_t*)0x2000000034ee = 0;
  *(uint16_t*)0x2000000034f0 = 0;
  *(uint16_t*)0x2000000034f2 = 0;
  *(uint16_t*)0x2000000034f4 = 5;
  *(uint16_t*)0x2000000034f6 = 1;
  *(uint16_t*)0x2000000034f8 = 3;
  *(uint16_t*)0x2000000034fa = 0;
  *(uint16_t*)0x2000000034fc = 0;
  *(uint16_t*)0x2000000034fe = 0;
  *(uint16_t*)0x200000003500 = 5;
  *(uint16_t*)0x200000003502 = 1;
  *(uint16_t*)0x200000003504 = 5;
  *(uint16_t*)0x200000003506 = 1;
  *(uint16_t*)0x200000003508 = 2;
  *(uint16_t*)0x20000000350a = 1;
  *(uint16_t*)0x20000000350c = 2;
  *(uint16_t*)0x20000000350e = 0;
  *(uint16_t*)0x200000003510 = 0;
  *(uint16_t*)0x200000003512 = 1;
  *(uint16_t*)0x200000003514 = 5;
  *(uint16_t*)0x200000003516 = 0;
  *(uint16_t*)0x200000003518 = 0;
  *(uint16_t*)0x20000000351a = 1;
  *(uint16_t*)0x20000000351c = 1;
  *(uint16_t*)0x20000000351e = 0;
  *(uint16_t*)0x200000003520 = 2;
  *(uint16_t*)0x200000003522 = 0;
  *(uint16_t*)0x200000003524 = 2;
  *(uint16_t*)0x200000003526 = 0;
  *(uint16_t*)0x200000003528 = 5;
  *(uint16_t*)0x20000000352a = 0;
  *(uint16_t*)0x20000000352c = 1;
  *(uint16_t*)0x20000000352e = 1;
  *(uint16_t*)0x200000003530 = 3;
  *(uint16_t*)0x200000003532 = 0;
  *(uint16_t*)0x200000003534 = 5;
  *(uint16_t*)0x200000003536 = 1;
  *(uint16_t*)0x200000003538 = 4;
  *(uint16_t*)0x20000000353a = 1;
  *(uint16_t*)0x20000000353c = 3;
  *(uint16_t*)0x20000000353e = 0;
  *(uint16_t*)0x200000003540 = 4;
  *(uint16_t*)0x200000003542 = 1;
  *(uint16_t*)0x200000003544 = 2;
  *(uint16_t*)0x200000003546 = 0;
  *(uint16_t*)0x200000003548 = 3;
  *(uint16_t*)0x20000000354a = 0;
  *(uint16_t*)0x20000000354c = 0;
  *(uint16_t*)0x20000000354e = 1;
  *(uint16_t*)0x200000003550 = 2;
  *(uint16_t*)0x200000003552 = 1;
  *(uint16_t*)0x200000003554 = 3;
  *(uint16_t*)0x200000003556 = 1;
  *(uint16_t*)0x200000003558 = 0;
  *(uint16_t*)0x20000000355a = 0;
  *(uint16_t*)0x20000000355c = 5;
  *(uint16_t*)0x20000000355e = 1;
  *(uint16_t*)0x200000003560 = 5;
  *(uint16_t*)0x200000003562 = 0;
  *(uint16_t*)0x200000003564 = 4;
  *(uint16_t*)0x200000003566 = 1;
  *(uint16_t*)0x200000003568 = 2;
  *(uint16_t*)0x20000000356a = 0;
  *(uint16_t*)0x20000000356c = 0;
  *(uint16_t*)0x20000000356e = 0;
  *(uint16_t*)0x200000003570 = 0;
  *(uint16_t*)0x200000003572 = 1;
  *(uint16_t*)0x200000003574 = 3;
  *(uint16_t*)0x200000003576 = 0;
  *(uint16_t*)0x200000003578 = 1;
  *(uint16_t*)0x20000000357a = 1;
  *(uint16_t*)0x20000000357c = 3;
  *(uint16_t*)0x20000000357e = 0;
  *(uint16_t*)0x200000003580 = 7;
  *(uint16_t*)0x200000003582 = 1;
  *(uint16_t*)0x200000003584 = 2;
  *(uint16_t*)0x200000003586 = 1;
  *(uint16_t*)0x200000003588 = 3;
  *(uint16_t*)0x20000000358a = 2;
  *(uint16_t*)0x20000000358c = 4;
  *(uint16_t*)0x20000000358e = 0;
  *(uint16_t*)0x200000003590 = 5;
  *(uint16_t*)0x200000003592 = 0;
  *(uint16_t*)0x200000003594 = 1;
  *(uint16_t*)0x200000003596 = 0;
  *(uint16_t*)0x200000003598 = 4;
  *(uint16_t*)0x20000000359a = 1;
  *(uint16_t*)0x20000000359c = 1;
  *(uint16_t*)0x20000000359e = 1;
  *(uint16_t*)0x2000000035a0 = 3;
  *(uint16_t*)0x2000000035a2 = 0;
  *(uint16_t*)0x2000000035a4 = 4;
  *(uint16_t*)0x2000000035a6 = 1;
  *(uint16_t*)0x2000000035a8 = 0;
  *(uint16_t*)0x2000000035aa = 0;
  *(uint16_t*)0x2000000035ac = 5;
  *(uint16_t*)0x2000000035ae = 1;
  *(uint16_t*)0x2000000035b0 = 4;
  *(uint16_t*)0x2000000035b2 = 0;
  *(uint16_t*)0x2000000035b4 = 5;
  *(uint16_t*)0x2000000035b6 = 0;
  *(uint16_t*)0x2000000035b8 = 5;
  *(uint16_t*)0x2000000035ba = 1;
  *(uint16_t*)0x2000000035bc = 0;
  *(uint16_t*)0x2000000035be = 1;
  *(uint16_t*)0x2000000035c0 = 5;
  *(uint16_t*)0x2000000035c2 = 0;
  *(uint16_t*)0x2000000035c4 = 2;
  *(uint16_t*)0x2000000035c6 = 1;
  *(uint16_t*)0x2000000035c8 = 5;
  *(uint16_t*)0x2000000035ca = 0;
  *(uint16_t*)0x2000000035cc = 3;
  *(uint16_t*)0x2000000035ce = 1;
  *(uint16_t*)0x2000000035d0 = 3;
  *(uint16_t*)0x2000000035d2 = 1;
  *(uint16_t*)0x2000000035d4 = 2;
  *(uint16_t*)0x2000000035d6 = 0;
  *(uint16_t*)0x2000000035d8 = 3;
  *(uint16_t*)0x2000000035da = 0;
  *(uint16_t*)0x2000000035dc = 4;
  *(uint16_t*)0x2000000035de = 1;
  *(uint16_t*)0x2000000035e0 = 0;
  *(uint16_t*)0x2000000035e2 = 1;
  *(uint16_t*)0x2000000035e4 = 3;
  *(uint16_t*)0x2000000035e6 = 0;
  *(uint16_t*)0x2000000035e8 = 2;
  *(uint16_t*)0x2000000035ea = 1;
  *(uint16_t*)0x2000000035ec = 4;
  *(uint16_t*)0x2000000035ee = 0;
  *(uint16_t*)0x2000000035f0 = 0x7738;
  *(uint16_t*)0x2000000035f2 = 1;
  *(uint16_t*)0x2000000035f4 = 3;
  *(uint16_t*)0x2000000035f6 = 1;
  *(uint16_t*)0x2000000035f8 = 2;
  *(uint16_t*)0x2000000035fa = 0;
  *(uint16_t*)0x2000000035fc = 0;
  *(uint16_t*)0x2000000035fe = 1;
  *(uint16_t*)0x200000003600 = 3;
  *(uint16_t*)0x200000003602 = 0;
  *(uint16_t*)0x200000003604 = 3;
  *(uint16_t*)0x200000003606 = 1;
  *(uint16_t*)0x200000003608 = 5;
  *(uint16_t*)0x20000000360a = 1;
  *(uint16_t*)0x20000000360c = 0;
  *(uint16_t*)0x20000000360e = 1;
  *(uint16_t*)0x200000003610 = 0;
  *(uint16_t*)0x200000003612 = 0;
  *(uint16_t*)0x200000003614 = 3;
  *(uint16_t*)0x200000003616 = 1;
  *(uint16_t*)0x200000003618 = 4;
  *(uint16_t*)0x20000000361a = 1;
  *(uint16_t*)0x20000000361c = 2;
  *(uint16_t*)0x20000000361e = 0x9fc3;
  *(uint16_t*)0x200000003620 = 0;
  *(uint16_t*)0x200000003622 = 0;
  *(uint16_t*)0x200000003624 = 3;
  *(uint16_t*)0x200000003626 = 0;
  *(uint16_t*)0x200000003628 = 4;
  *(uint16_t*)0x20000000362a = 1;
  *(uint8_t*)0x20000000362c = 1;
  *(uint16_t*)0x200000003630 = 4;
  *(uint16_t*)0x200000003632 = 6;
  *(uint16_t*)0x200000003634 = 0xc;
  *(uint16_t*)0x200000003636 = 7;
  *(uint32_t*)0x200000003638 = 1;
  *(uint32_t*)0x20000000363c = 0;
  *(uint16_t*)0x200000003640 = 0xc;
  *(uint16_t*)0x200000003642 = 8;
  *(uint32_t*)0x200000003644 = 0;
  *(uint32_t*)0x200000003648 = 1;
  *(uint16_t*)0x20000000364c = 0xe50;
  STORE_BY_BITMASK(uint16_t, , 0x20000000364e, 0xb, 0, 14);
  STORE_BY_BITMASK(uint16_t, , 0x20000000364f, 0, 6, 1);
  STORE_BY_BITMASK(uint16_t, , 0x20000000364f, 0, 7, 1);
  *(uint16_t*)0x200000003650 = 0xa;
  *(uint16_t*)0x200000003652 = 1;
  memcpy((void*)0x200000003654, "pedit\000", 6);
  *(uint16_t*)0x20000000365c = 0xe24;
  STORE_BY_BITMASK(uint16_t, , 0x20000000365e, 2, 0, 14);
  STORE_BY_BITMASK(uint16_t, , 0x20000000365f, 0, 6, 1);
  STORE_BY_BITMASK(uint16_t, , 0x20000000365f, 1, 7, 1);
  *(uint16_t*)0x200000003660 = 0xe20;
  *(uint16_t*)0x200000003662 = 2;
  *(uint32_t*)0x200000003664 = 7;
  *(uint32_t*)0x200000003668 = 0x456;
  *(uint32_t*)0x20000000366c = 4;
  *(uint32_t*)0x200000003670 = 6;
  *(uint32_t*)0x200000003674 = 1;
  *(uint8_t*)0x200000003678 = 0xb9;
  *(uint8_t*)0x200000003679 = 0xf3;
  *(uint32_t*)0x20000000367c = 0x8bc;
  *(uint32_t*)0x200000003680 = 1;
  *(uint32_t*)0x200000003684 = 6;
  *(uint32_t*)0x200000003688 = 4;
  *(uint32_t*)0x20000000368c = 0x100;
  *(uint32_t*)0x200000003690 = 0xfffffffd;
  *(uint32_t*)0x200000003694 = 0;
  *(uint32_t*)0x200000003698 = 0x68;
  *(uint32_t*)0x20000000369c = 0xfffffff8;
  *(uint32_t*)0x2000000036a0 = 6;
  *(uint32_t*)0x2000000036a4 = 5;
  *(uint32_t*)0x2000000036a8 = 4;
  *(uint32_t*)0x2000000036ac = 0xbb05;
  *(uint32_t*)0x2000000036b0 = 0x97af;
  *(uint32_t*)0x2000000036b4 = 3;
  *(uint32_t*)0x2000000036b8 = 2;
  *(uint32_t*)0x2000000036bc = 4;
  *(uint32_t*)0x2000000036c0 = 6;
  *(uint32_t*)0x2000000036c4 = 6;
  *(uint32_t*)0x2000000036c8 = 1;
  *(uint32_t*)0x2000000036cc = 3;
  *(uint32_t*)0x2000000036d0 = 0x2c27f2d1;
  *(uint32_t*)0x2000000036d4 = 0;
  *(uint32_t*)0x2000000036d8 = 0x559a;
  *(uint32_t*)0x2000000036dc = 0;
  *(uint32_t*)0x2000000036e0 = 8;
  *(uint32_t*)0x2000000036e4 = 2;
  *(uint32_t*)0x2000000036e8 = 1;
  *(uint32_t*)0x2000000036ec = 2;
  *(uint32_t*)0x2000000036f0 = 5;
  *(uint32_t*)0x2000000036f4 = 0x10000;
  *(uint32_t*)0x2000000036f8 = 0x1000;
  *(uint32_t*)0x2000000036fc = 0x7f;
  *(uint32_t*)0x200000003700 = 8;
  *(uint32_t*)0x200000003704 = 3;
  *(uint32_t*)0x200000003708 = 6;
  *(uint32_t*)0x20000000370c = 4;
  *(uint32_t*)0x200000003710 = 0x2c4;
  *(uint32_t*)0x200000003714 = 0x7ab;
  *(uint32_t*)0x200000003718 = 4;
  *(uint32_t*)0x20000000371c = 7;
  *(uint32_t*)0x200000003720 = 0;
  *(uint32_t*)0x200000003724 = 0xa92;
  *(uint32_t*)0x200000003728 = 3;
  *(uint32_t*)0x20000000372c = 0xb;
  *(uint32_t*)0x200000003730 = 0;
  *(uint32_t*)0x200000003734 = 1;
  *(uint32_t*)0x200000003738 = 5;
  *(uint32_t*)0x20000000373c = 0x7fff;
  *(uint32_t*)0x200000003740 = 0xe;
  *(uint32_t*)0x200000003744 = 0xa524;
  *(uint32_t*)0x200000003748 = 0x40;
  *(uint32_t*)0x20000000374c = 5;
  *(uint32_t*)0x200000003750 = 0x101;
  *(uint32_t*)0x200000003754 = 0xb;
  *(uint32_t*)0x200000003758 = 8;
  *(uint32_t*)0x20000000375c = 0xfffffff8;
  *(uint32_t*)0x200000003760 = 0x1000;
  *(uint32_t*)0x200000003764 = 0xd72;
  *(uint32_t*)0x200000003768 = 4;
  *(uint32_t*)0x20000000376c = 9;
  *(uint32_t*)0x200000003770 = 0x8000000;
  *(uint32_t*)0x200000003774 = 0;
  *(uint32_t*)0x200000003778 = 2;
  *(uint32_t*)0x20000000377c = 2;
  *(uint32_t*)0x200000003780 = 0x3ff;
  *(uint32_t*)0x200000003784 = 7;
  *(uint32_t*)0x200000003788 = 3;
  *(uint32_t*)0x20000000378c = 6;
  *(uint32_t*)0x200000003790 = 0xcea;
  *(uint32_t*)0x200000003794 = 0xff;
  *(uint32_t*)0x200000003798 = 0x80000001;
  *(uint32_t*)0x20000000379c = 0x1800000;
  *(uint32_t*)0x2000000037a0 = 9;
  *(uint32_t*)0x2000000037a4 = 3;
  *(uint32_t*)0x2000000037a8 = 0x7ff;
  *(uint32_t*)0x2000000037ac = 1;
  *(uint32_t*)0x2000000037b0 = 4;
  *(uint32_t*)0x2000000037b4 = 0xfffffffd;
  *(uint32_t*)0x2000000037b8 = 0xfffffffd;
  *(uint32_t*)0x2000000037bc = 9;
  *(uint32_t*)0x2000000037c0 = 0;
  *(uint32_t*)0x2000000037c4 = 0xd1;
  *(uint32_t*)0x2000000037c8 = 0x61b;
  *(uint32_t*)0x2000000037cc = 0xfffffff1;
  *(uint32_t*)0x2000000037d0 = 0x80;
  *(uint32_t*)0x2000000037d4 = 7;
  *(uint32_t*)0x2000000037d8 = 1;
  *(uint32_t*)0x2000000037dc = 4;
  *(uint32_t*)0x2000000037e0 = 0x1000;
  *(uint32_t*)0x2000000037e4 = 0xdab4;
  *(uint32_t*)0x2000000037e8 = 0x3b6;
  *(uint32_t*)0x2000000037ec = 0x8000;
  *(uint32_t*)0x2000000037f0 = 9;
  *(uint32_t*)0x2000000037f4 = 1;
  *(uint32_t*)0x2000000037f8 = 0;
  *(uint32_t*)0x2000000037fc = 2;
  *(uint32_t*)0x200000003800 = 0x400;
  *(uint32_t*)0x200000003804 = 0;
  *(uint32_t*)0x200000003808 = 9;
  *(uint32_t*)0x20000000380c = 7;
  *(uint32_t*)0x200000003810 = 2;
  *(uint32_t*)0x200000003814 = -1;
  *(uint32_t*)0x200000003818 = 0x245;
  *(uint32_t*)0x20000000381c = 0x63;
  *(uint32_t*)0x200000003820 = 0x80000001;
  *(uint32_t*)0x200000003824 = 0xc00000;
  *(uint32_t*)0x200000003828 = 0xa;
  *(uint32_t*)0x20000000382c = 0xfffffffc;
  *(uint32_t*)0x200000003830 = 0x10000;
  *(uint32_t*)0x200000003834 = 0x80000001;
  *(uint32_t*)0x200000003838 = 8;
  *(uint32_t*)0x20000000383c = 8;
  *(uint32_t*)0x200000003840 = 5;
  *(uint32_t*)0x200000003844 = 0x80000001;
  *(uint32_t*)0x200000003848 = 1;
  *(uint32_t*)0x20000000384c = 0x5e67;
  *(uint32_t*)0x200000003850 = 0;
  *(uint32_t*)0x200000003854 = 0xff;
  *(uint32_t*)0x200000003858 = 9;
  *(uint32_t*)0x20000000385c = 6;
  *(uint32_t*)0x200000003860 = 5;
  *(uint32_t*)0x200000003864 = 0x1a;
  *(uint32_t*)0x200000003868 = 0x618;
  *(uint32_t*)0x20000000386c = 2;
  *(uint32_t*)0x200000003870 = 1;
  *(uint32_t*)0x200000003874 = 9;
  *(uint32_t*)0x200000003878 = 9;
  *(uint32_t*)0x20000000387c = 5;
  *(uint32_t*)0x200000003880 = 6;
  *(uint32_t*)0x200000003884 = 4;
  *(uint32_t*)0x200000003888 = 8;
  *(uint32_t*)0x20000000388c = 1;
  *(uint32_t*)0x200000003890 = 7;
  *(uint32_t*)0x200000003894 = 0xf;
  *(uint32_t*)0x200000003898 = 1;
  *(uint32_t*)0x20000000389c = 2;
  *(uint32_t*)0x2000000038a0 = 1;
  *(uint32_t*)0x2000000038a4 = 9;
  *(uint32_t*)0x2000000038a8 = 0xa;
  *(uint32_t*)0x2000000038ac = 3;
  *(uint32_t*)0x2000000038b0 = 2;
  *(uint32_t*)0x2000000038b4 = 6;
  *(uint32_t*)0x2000000038b8 = 9;
  *(uint32_t*)0x2000000038bc = 0x495f;
  *(uint32_t*)0x2000000038c0 = 0xfe;
  *(uint32_t*)0x2000000038c4 = 0x9bb3;
  *(uint32_t*)0x2000000038c8 = 2;
  *(uint32_t*)0x2000000038cc = 0xfffffffa;
  *(uint32_t*)0x2000000038d0 = 7;
  *(uint32_t*)0x2000000038d4 = 9;
  *(uint32_t*)0x2000000038d8 = 0x10001;
  *(uint32_t*)0x2000000038dc = 0xc;
  *(uint32_t*)0x2000000038e0 = 0x76;
  *(uint32_t*)0x2000000038e4 = 6;
  *(uint32_t*)0x2000000038e8 = 4;
  *(uint32_t*)0x2000000038ec = 0x8c;
  *(uint32_t*)0x2000000038f0 = 4;
  *(uint32_t*)0x2000000038f4 = 0x8f29;
  *(uint32_t*)0x2000000038f8 = 0;
  *(uint32_t*)0x2000000038fc = 0xffff8001;
  *(uint32_t*)0x200000003900 = 7;
  *(uint32_t*)0x200000003904 = 0xfff;
  *(uint32_t*)0x200000003908 = 0xffff;
  *(uint32_t*)0x20000000390c = 0xc;
  *(uint32_t*)0x200000003910 = 0xe4;
  *(uint32_t*)0x200000003914 = 6;
  *(uint32_t*)0x200000003918 = 7;
  *(uint32_t*)0x20000000391c = 7;
  *(uint32_t*)0x200000003920 = 8;
  *(uint32_t*)0x200000003924 = 0xffff8001;
  *(uint32_t*)0x200000003928 = 0x100;
  *(uint32_t*)0x20000000392c = 7;
  *(uint32_t*)0x200000003930 = 0;
  *(uint32_t*)0x200000003934 = 4;
  *(uint32_t*)0x200000003938 = 0xbe8b;
  *(uint32_t*)0x20000000393c = 4;
  *(uint32_t*)0x200000003940 = 6;
  *(uint32_t*)0x200000003944 = 1;
  *(uint32_t*)0x200000003948 = 3;
  *(uint32_t*)0x20000000394c = 5;
  *(uint32_t*)0x200000003950 = 0xad4;
  *(uint32_t*)0x200000003954 = 2;
  *(uint32_t*)0x200000003958 = 9;
  *(uint32_t*)0x20000000395c = 0xb1a8;
  *(uint32_t*)0x200000003960 = 5;
  *(uint32_t*)0x200000003964 = 9;
  *(uint32_t*)0x200000003968 = 3;
  *(uint32_t*)0x20000000396c = 0xb6e;
  *(uint32_t*)0x200000003970 = 0xfff;
  *(uint32_t*)0x200000003974 = 0x200;
  *(uint32_t*)0x200000003978 = 9;
  *(uint32_t*)0x20000000397c = 4;
  *(uint32_t*)0x200000003980 = 0x8000;
  *(uint32_t*)0x200000003984 = 8;
  *(uint32_t*)0x200000003988 = 5;
  *(uint32_t*)0x20000000398c = 6;
  *(uint32_t*)0x200000003990 = 0;
  *(uint32_t*)0x200000003994 = 4;
  *(uint32_t*)0x200000003998 = 2;
  *(uint32_t*)0x20000000399c = 6;
  *(uint32_t*)0x2000000039a0 = 3;
  *(uint32_t*)0x2000000039a4 = 3;
  *(uint32_t*)0x2000000039a8 = 1;
  *(uint32_t*)0x2000000039ac = 7;
  *(uint32_t*)0x2000000039b0 = 0x3e;
  *(uint32_t*)0x2000000039b4 = 6;
  *(uint32_t*)0x2000000039b8 = 8;
  *(uint32_t*)0x2000000039bc = 7;
  *(uint32_t*)0x2000000039c0 = 7;
  *(uint32_t*)0x2000000039c4 = 6;
  *(uint32_t*)0x2000000039c8 = 0x401;
  *(uint32_t*)0x2000000039cc = 4;
  *(uint32_t*)0x2000000039d0 = 9;
  *(uint32_t*)0x2000000039d4 = 3;
  *(uint32_t*)0x2000000039d8 = 0;
  *(uint32_t*)0x2000000039dc = 0xa;
  *(uint32_t*)0x2000000039e0 = 0x40;
  *(uint32_t*)0x2000000039e4 = 9;
  *(uint32_t*)0x2000000039e8 = 0xf;
  *(uint32_t*)0x2000000039ec = 5;
  *(uint32_t*)0x2000000039f0 = 0xf;
  *(uint32_t*)0x2000000039f4 = 0x12b8c98e;
  *(uint32_t*)0x2000000039f8 = 0xfff;
  *(uint32_t*)0x2000000039fc = 0x7fffffff;
  *(uint32_t*)0x200000003a00 = 3;
  *(uint32_t*)0x200000003a04 = 0xe;
  *(uint32_t*)0x200000003a08 = 0x7fff;
  *(uint32_t*)0x200000003a0c = 6;
  *(uint32_t*)0x200000003a10 = 8;
  *(uint32_t*)0x200000003a14 = 0x118;
  *(uint32_t*)0x200000003a18 = 0xe6c6;
  *(uint32_t*)0x200000003a1c = 6;
  *(uint32_t*)0x200000003a20 = 0x9738;
  *(uint32_t*)0x200000003a24 = 3;
  *(uint32_t*)0x200000003a28 = 9;
  *(uint32_t*)0x200000003a2c = 0x7ff;
  *(uint32_t*)0x200000003a30 = 3;
  *(uint32_t*)0x200000003a34 = -1;
  *(uint32_t*)0x200000003a38 = 9;
  *(uint32_t*)0x200000003a3c = 8;
  *(uint32_t*)0x200000003a40 = 6;
  *(uint32_t*)0x200000003a44 = 7;
  *(uint32_t*)0x200000003a48 = 7;
  *(uint32_t*)0x200000003a4c = 2;
  *(uint32_t*)0x200000003a50 = 8;
  *(uint32_t*)0x200000003a54 = 0x80000000;
  *(uint32_t*)0x200000003a58 = 0x5ce23415;
  *(uint32_t*)0x200000003a5c = 0x24;
  *(uint32_t*)0x200000003a60 = 0xfff;
  *(uint32_t*)0x200000003a64 = 0xff;
  *(uint32_t*)0x200000003a68 = 2;
  *(uint32_t*)0x200000003a6c = 0x100;
  *(uint32_t*)0x200000003a70 = 0x1000;
  *(uint32_t*)0x200000003a74 = 0xca6;
  *(uint32_t*)0x200000003a78 = 0;
  *(uint32_t*)0x200000003a7c = 0xfffffff7;
  *(uint32_t*)0x200000003a80 = 0xa1;
  *(uint32_t*)0x200000003a84 = 1;
  *(uint32_t*)0x200000003a88 = 8;
  *(uint32_t*)0x200000003a8c = 7;
  *(uint32_t*)0x200000003a90 = 5;
  *(uint32_t*)0x200000003a94 = 0xfffffff7;
  *(uint32_t*)0x200000003a98 = 0x3a;
  *(uint32_t*)0x200000003a9c = 0x84c;
  *(uint32_t*)0x200000003aa0 = 0x81;
  *(uint32_t*)0x200000003aa4 = 7;
  *(uint32_t*)0x200000003aa8 = 1;
  *(uint32_t*)0x200000003aac = 1;
  *(uint32_t*)0x200000003ab0 = 0x7f;
  *(uint32_t*)0x200000003ab4 = 9;
  *(uint32_t*)0x200000003ab8 = 0x200;
  *(uint32_t*)0x200000003abc = 0x700000;
  *(uint32_t*)0x200000003ac0 = 1;
  *(uint32_t*)0x200000003ac4 = 3;
  *(uint32_t*)0x200000003ac8 = 5;
  *(uint32_t*)0x200000003acc = 6;
  *(uint32_t*)0x200000003ad0 = 2;
  *(uint32_t*)0x200000003ad4 = 7;
  *(uint32_t*)0x200000003ad8 = 6;
  *(uint32_t*)0x200000003adc = 0xfffffffb;
  *(uint32_t*)0x200000003ae0 = 7;
  *(uint32_t*)0x200000003ae4 = 0;
  *(uint32_t*)0x200000003ae8 = 6;
  *(uint32_t*)0x200000003aec = 0xf;
  *(uint32_t*)0x200000003af0 = 9;
  *(uint32_t*)0x200000003af4 = 5;
  *(uint32_t*)0x200000003af8 = 0xd5a;
  *(uint32_t*)0x200000003afc = 0xfffffff7;
  *(uint32_t*)0x200000003b00 = 7;
  *(uint32_t*)0x200000003b04 = 0xffffff7f;
  *(uint32_t*)0x200000003b08 = 5;
  *(uint32_t*)0x200000003b0c = 8;
  *(uint32_t*)0x200000003b10 = 2;
  *(uint32_t*)0x200000003b14 = 5;
  *(uint32_t*)0x200000003b18 = 8;
  *(uint32_t*)0x200000003b1c = 3;
  *(uint32_t*)0x200000003b20 = 0x26;
  *(uint32_t*)0x200000003b24 = 3;
  *(uint32_t*)0x200000003b28 = 0x400;
  *(uint32_t*)0x200000003b2c = 0;
  *(uint32_t*)0x200000003b30 = 6;
  *(uint32_t*)0x200000003b34 = 6;
  *(uint32_t*)0x200000003b38 = 7;
  *(uint32_t*)0x200000003b3c = 0x101;
  *(uint32_t*)0x200000003b40 = 0x222;
  *(uint32_t*)0x200000003b44 = 0x1f;
  *(uint32_t*)0x200000003b48 = 0x800;
  *(uint32_t*)0x200000003b4c = 3;
  *(uint32_t*)0x200000003b50 = 0xe6b;
  *(uint32_t*)0x200000003b54 = 0;
  *(uint32_t*)0x200000003b58 = 0xfffffff7;
  *(uint32_t*)0x200000003b5c = 8;
  *(uint32_t*)0x200000003b60 = 4;
  *(uint32_t*)0x200000003b64 = 6;
  *(uint32_t*)0x200000003b68 = 0;
  *(uint32_t*)0x200000003b6c = 2;
  *(uint32_t*)0x200000003b70 = 5;
  *(uint32_t*)0x200000003b74 = 0;
  *(uint32_t*)0x200000003b78 = 2;
  *(uint32_t*)0x200000003b7c = 2;
  *(uint32_t*)0x200000003b80 = 7;
  *(uint32_t*)0x200000003b84 = 0x400;
  *(uint32_t*)0x200000003b88 = 7;
  *(uint32_t*)0x200000003b8c = 0x200;
  *(uint32_t*)0x200000003b90 = 3;
  *(uint32_t*)0x200000003b94 = 0x8000;
  *(uint32_t*)0x200000003b98 = 0x65;
  *(uint32_t*)0x200000003b9c = 0x1000;
  *(uint32_t*)0x200000003ba0 = 0x40;
  *(uint32_t*)0x200000003ba4 = 0x10;
  *(uint32_t*)0x200000003ba8 = 0xa;
  *(uint32_t*)0x200000003bac = 4;
  *(uint32_t*)0x200000003bb0 = 0x10;
  *(uint32_t*)0x200000003bb4 = 1;
  *(uint32_t*)0x200000003bb8 = 5;
  *(uint32_t*)0x200000003bbc = 9;
  *(uint32_t*)0x200000003bc0 = 9;
  *(uint32_t*)0x200000003bc4 = 0xe95;
  *(uint32_t*)0x200000003bc8 = 4;
  *(uint32_t*)0x200000003bcc = 0xd;
  *(uint32_t*)0x200000003bd0 = 0;
  *(uint32_t*)0x200000003bd4 = 0xe0;
  *(uint32_t*)0x200000003bd8 = 2;
  *(uint32_t*)0x200000003bdc = 0x80000001;
  *(uint32_t*)0x200000003be0 = 4;
  *(uint32_t*)0x200000003be4 = 0x1a49;
  *(uint32_t*)0x200000003be8 = 6;
  *(uint32_t*)0x200000003bec = 2;
  *(uint32_t*)0x200000003bf0 = 4;
  *(uint32_t*)0x200000003bf4 = 4;
  *(uint32_t*)0x200000003bf8 = 0x10;
  *(uint32_t*)0x200000003bfc = 0xfffff0ac;
  *(uint32_t*)0x200000003c00 = 3;
  *(uint32_t*)0x200000003c04 = 0xbb;
  *(uint32_t*)0x200000003c08 = 4;
  *(uint32_t*)0x200000003c0c = 4;
  *(uint32_t*)0x200000003c10 = 1;
  *(uint32_t*)0x200000003c14 = 0x7fffffff;
  *(uint32_t*)0x200000003c18 = 6;
  *(uint32_t*)0x200000003c1c = -1;
  *(uint32_t*)0x200000003c20 = 0xffff;
  *(uint32_t*)0x200000003c24 = 6;
  *(uint32_t*)0x200000003c28 = 0xe4;
  *(uint32_t*)0x200000003c2c = 0;
  *(uint32_t*)0x200000003c30 = 6;
  *(uint32_t*)0x200000003c34 = 0xfffffff9;
  *(uint32_t*)0x200000003c38 = 2;
  *(uint32_t*)0x200000003c3c = 1;
  *(uint32_t*)0x200000003c40 = 0xc;
  *(uint32_t*)0x200000003c44 = 8;
  *(uint32_t*)0x200000003c48 = 0x800;
  *(uint32_t*)0x200000003c4c = 6;
  *(uint32_t*)0x200000003c50 = 4;
  *(uint32_t*)0x200000003c54 = 5;
  *(uint32_t*)0x200000003c58 = 1;
  *(uint32_t*)0x200000003c5c = 1;
  *(uint32_t*)0x200000003c60 = 4;
  *(uint32_t*)0x200000003c64 = 0xe;
  *(uint32_t*)0x200000003c68 = 6;
  *(uint32_t*)0x200000003c6c = 1;
  *(uint32_t*)0x200000003c70 = 8;
  *(uint32_t*)0x200000003c74 = 9;
  *(uint32_t*)0x200000003c78 = 9;
  *(uint32_t*)0x200000003c7c = 7;
  *(uint32_t*)0x200000003c80 = 0xc6;
  *(uint32_t*)0x200000003c84 = 0x3ff;
  *(uint32_t*)0x200000003c88 = 0xe7e3;
  *(uint32_t*)0x200000003c8c = 5;
  *(uint32_t*)0x200000003c90 = 9;
  *(uint32_t*)0x200000003c94 = 0xea48;
  *(uint32_t*)0x200000003c98 = 0xfffffffd;
  *(uint32_t*)0x200000003c9c = 0x10000;
  *(uint32_t*)0x200000003ca0 = 6;
  *(uint32_t*)0x200000003ca4 = 3;
  *(uint32_t*)0x200000003ca8 = 5;
  *(uint32_t*)0x200000003cac = 4;
  *(uint32_t*)0x200000003cb0 = 0xffff;
  *(uint32_t*)0x200000003cb4 = 0x1ff;
  *(uint32_t*)0x200000003cb8 = 8;
  *(uint32_t*)0x200000003cbc = 4;
  *(uint32_t*)0x200000003cc0 = 0xfffffff0;
  *(uint32_t*)0x200000003cc4 = 0xb;
  *(uint32_t*)0x200000003cc8 = 0x3b3;
  *(uint32_t*)0x200000003ccc = 1;
  *(uint32_t*)0x200000003cd0 = 0x101;
  *(uint32_t*)0x200000003cd4 = 0xe11;
  *(uint32_t*)0x200000003cd8 = 5;
  *(uint32_t*)0x200000003cdc = 3;
  *(uint32_t*)0x200000003ce0 = 4;
  *(uint32_t*)0x200000003ce4 = 6;
  *(uint32_t*)0x200000003ce8 = 0xff;
  *(uint32_t*)0x200000003cec = 0xff;
  *(uint32_t*)0x200000003cf0 = 7;
  *(uint32_t*)0x200000003cf4 = 0;
  *(uint32_t*)0x200000003cf8 = 2;
  *(uint32_t*)0x200000003cfc = 8;
  *(uint32_t*)0x200000003d00 = 4;
  *(uint32_t*)0x200000003d04 = 7;
  *(uint32_t*)0x200000003d08 = 4;
  *(uint32_t*)0x200000003d0c = 7;
  *(uint32_t*)0x200000003d10 = 0xb;
  *(uint32_t*)0x200000003d14 = 0x44df;
  *(uint32_t*)0x200000003d18 = 9;
  *(uint32_t*)0x200000003d1c = 6;
  *(uint32_t*)0x200000003d20 = 0x5d5ab339;
  *(uint32_t*)0x200000003d24 = 6;
  *(uint32_t*)0x200000003d28 = 6;
  *(uint32_t*)0x200000003d2c = 0x40;
  *(uint32_t*)0x200000003d30 = 2;
  *(uint32_t*)0x200000003d34 = 9;
  *(uint32_t*)0x200000003d38 = 0x1ff;
  *(uint32_t*)0x200000003d3c = 7;
  *(uint32_t*)0x200000003d40 = -1;
  *(uint32_t*)0x200000003d44 = 4;
  *(uint32_t*)0x200000003d48 = 0x10001;
  *(uint32_t*)0x200000003d4c = -1;
  *(uint32_t*)0x200000003d50 = 7;
  *(uint32_t*)0x200000003d54 = 0x81;
  *(uint32_t*)0x200000003d58 = 0xa;
  *(uint32_t*)0x200000003d5c = 3;
  *(uint32_t*)0x200000003d60 = 8;
  *(uint32_t*)0x200000003d64 = 0xd33;
  *(uint32_t*)0x200000003d68 = 6;
  *(uint32_t*)0x200000003d6c = 2;
  *(uint32_t*)0x200000003d70 = 4;
  *(uint32_t*)0x200000003d74 = 0x9ab;
  *(uint32_t*)0x200000003d78 = 0xb4;
  *(uint32_t*)0x200000003d7c = 5;
  *(uint32_t*)0x200000003d80 = 0xb577;
  *(uint32_t*)0x200000003d84 = 0;
  *(uint32_t*)0x200000003d88 = 0xffff;
  *(uint32_t*)0x200000003d8c = 6;
  *(uint32_t*)0x200000003d90 = 0x7fff;
  *(uint32_t*)0x200000003d94 = 0;
  *(uint32_t*)0x200000003d98 = 5;
  *(uint32_t*)0x200000003d9c = 0xd;
  *(uint32_t*)0x200000003da0 = 6;
  *(uint32_t*)0x200000003da4 = 0xaa10;
  *(uint32_t*)0x200000003da8 = 0xfffff477;
  *(uint32_t*)0x200000003dac = 0;
  *(uint32_t*)0x200000003db0 = 0xff;
  *(uint32_t*)0x200000003db4 = 2;
  *(uint32_t*)0x200000003db8 = 0xfffffffa;
  *(uint32_t*)0x200000003dbc = 4;
  *(uint32_t*)0x200000003dc0 = 0x90;
  *(uint32_t*)0x200000003dc4 = 9;
  *(uint32_t*)0x200000003dc8 = 0x3e;
  *(uint32_t*)0x200000003dcc = 2;
  *(uint32_t*)0x200000003dd0 = 0x80000000;
  *(uint32_t*)0x200000003dd4 = 4;
  *(uint32_t*)0x200000003dd8 = 4;
  *(uint32_t*)0x200000003ddc = 0x90;
  *(uint32_t*)0x200000003de0 = 2;
  *(uint32_t*)0x200000003de4 = 4;
  *(uint32_t*)0x200000003de8 = 1;
  *(uint32_t*)0x200000003dec = 6;
  *(uint32_t*)0x200000003df0 = 4;
  *(uint32_t*)0x200000003df4 = 4;
  *(uint32_t*)0x200000003df8 = 7;
  *(uint32_t*)0x200000003dfc = 5;
  *(uint32_t*)0x200000003e00 = 6;
  *(uint32_t*)0x200000003e04 = 4;
  *(uint32_t*)0x200000003e08 = 0xb80c;
  *(uint32_t*)0x200000003e0c = 5;
  *(uint32_t*)0x200000003e10 = 0x4cf1;
  *(uint32_t*)0x200000003e14 = 0x8001;
  *(uint32_t*)0x200000003e18 = 4;
  *(uint32_t*)0x200000003e1c = 8;
  *(uint32_t*)0x200000003e20 = 9;
  *(uint32_t*)0x200000003e24 = 0;
  *(uint32_t*)0x200000003e28 = 6;
  *(uint32_t*)0x200000003e2c = 0x40;
  *(uint32_t*)0x200000003e30 = 9;
  *(uint32_t*)0x200000003e34 = 0x18c;
  *(uint32_t*)0x200000003e38 = 0x100;
  *(uint32_t*)0x200000003e3c = 2;
  *(uint32_t*)0x200000003e40 = 9;
  *(uint32_t*)0x200000003e44 = 3;
  *(uint32_t*)0x200000003e48 = 4;
  *(uint32_t*)0x200000003e4c = 9;
  *(uint32_t*)0x200000003e50 = 0x7f;
  *(uint32_t*)0x200000003e54 = 7;
  *(uint32_t*)0x200000003e58 = 0x179;
  *(uint32_t*)0x200000003e5c = 0;
  *(uint32_t*)0x200000003e60 = 7;
  *(uint32_t*)0x200000003e64 = 2;
  *(uint32_t*)0x200000003e68 = 0x80;
  *(uint32_t*)0x200000003e6c = 0x401;
  *(uint32_t*)0x200000003e70 = 8;
  *(uint32_t*)0x200000003e74 = 7;
  *(uint32_t*)0x200000003e78 = 0;
  *(uint32_t*)0x200000003e7c = 0x10001;
  *(uint32_t*)0x200000003e80 = 0xf6;
  *(uint32_t*)0x200000003e84 = 0x64f57d4f;
  *(uint32_t*)0x200000003e88 = 0x10f00000;
  *(uint32_t*)0x200000003e8c = 7;
  *(uint32_t*)0x200000003e90 = 0x200;
  *(uint32_t*)0x200000003e94 = 0x200;
  *(uint32_t*)0x200000003e98 = 9;
  *(uint32_t*)0x200000003e9c = 5;
  *(uint32_t*)0x200000003ea0 = 0x4512;
  *(uint32_t*)0x200000003ea4 = 0xd3;
  *(uint32_t*)0x200000003ea8 = 0;
  *(uint32_t*)0x200000003eac = 8;
  *(uint32_t*)0x200000003eb0 = 2;
  *(uint32_t*)0x200000003eb4 = 8;
  *(uint32_t*)0x200000003eb8 = 0x101;
  *(uint32_t*)0x200000003ebc = 0x6b0c;
  *(uint32_t*)0x200000003ec0 = 9;
  *(uint32_t*)0x200000003ec4 = 7;
  *(uint32_t*)0x200000003ec8 = 0x3ff;
  *(uint32_t*)0x200000003ecc = 4;
  *(uint32_t*)0x200000003ed0 = 0;
  *(uint32_t*)0x200000003ed4 = 0x5f;
  *(uint32_t*)0x200000003ed8 = 4;
  *(uint32_t*)0x200000003edc = -1;
  *(uint32_t*)0x200000003ee0 = 0;
  *(uint32_t*)0x200000003ee4 = 0;
  *(uint32_t*)0x200000003ee8 = 7;
  *(uint32_t*)0x200000003eec = 4;
  *(uint32_t*)0x200000003ef0 = 4;
  *(uint32_t*)0x200000003ef4 = 0x1200000;
  *(uint32_t*)0x200000003ef8 = 7;
  *(uint32_t*)0x200000003efc = 0x800;
  *(uint32_t*)0x200000003f00 = 6;
  *(uint32_t*)0x200000003f04 = 1;
  *(uint32_t*)0x200000003f08 = 6;
  *(uint32_t*)0x200000003f0c = 0x80;
  *(uint32_t*)0x200000003f10 = 0xef8;
  *(uint32_t*)0x200000003f14 = 0;
  *(uint32_t*)0x200000003f18 = 5;
  *(uint32_t*)0x200000003f1c = 0x40000;
  *(uint32_t*)0x200000003f20 = 6;
  *(uint32_t*)0x200000003f24 = 1;
  *(uint32_t*)0x200000003f28 = 1;
  *(uint32_t*)0x200000003f2c = 2;
  *(uint32_t*)0x200000003f30 = 0xd09;
  *(uint32_t*)0x200000003f34 = 0x8000;
  *(uint32_t*)0x200000003f38 = 9;
  *(uint32_t*)0x200000003f3c = 0xfffffffd;
  *(uint32_t*)0x200000003f40 = 0x100;
  *(uint32_t*)0x200000003f44 = 6;
  *(uint32_t*)0x200000003f48 = 0xfffffff7;
  *(uint32_t*)0x200000003f4c = 9;
  *(uint32_t*)0x200000003f50 = 2;
  *(uint32_t*)0x200000003f54 = 9;
  *(uint32_t*)0x200000003f58 = 1;
  *(uint32_t*)0x200000003f5c = 3;
  *(uint32_t*)0x200000003f60 = 0xbe2;
  *(uint32_t*)0x200000003f64 = 4;
  *(uint32_t*)0x200000003f68 = 0xa;
  *(uint32_t*)0x200000003f6c = 0;
  *(uint32_t*)0x200000003f70 = 0;
  *(uint32_t*)0x200000003f74 = 6;
  *(uint32_t*)0x200000003f78 = 6;
  *(uint32_t*)0x200000003f7c = 0x3ff;
  *(uint32_t*)0x200000003f80 = 5;
  *(uint32_t*)0x200000003f84 = 1;
  *(uint32_t*)0x200000003f88 = 0x7000;
  *(uint32_t*)0x200000003f8c = 0x4e;
  *(uint32_t*)0x200000003f90 = 8;
  *(uint32_t*)0x200000003f94 = 0xd6;
  *(uint32_t*)0x200000003f98 = 9;
  *(uint32_t*)0x200000003f9c = 0x10000;
  *(uint32_t*)0x200000003fa0 = 8;
  *(uint32_t*)0x200000003fa4 = 0xff;
  *(uint32_t*)0x200000003fa8 = 2;
  *(uint32_t*)0x200000003fac = 0xb;
  *(uint32_t*)0x200000003fb0 = 1;
  *(uint32_t*)0x200000003fb4 = 0x1f36;
  *(uint32_t*)0x200000003fb8 = 0x8ff4;
  *(uint32_t*)0x200000003fbc = 0xfff;
  *(uint32_t*)0x200000003fc0 = 6;
  *(uint32_t*)0x200000003fc4 = 0;
  *(uint32_t*)0x200000003fc8 = 0x516607;
  *(uint32_t*)0x200000003fcc = 2;
  *(uint32_t*)0x200000003fd0 = 3;
  *(uint32_t*)0x200000003fd4 = 3;
  *(uint32_t*)0x200000003fd8 = -1;
  *(uint32_t*)0x200000003fdc = 0xffff4b03;
  *(uint32_t*)0x200000003fe0 = 5;
  *(uint32_t*)0x200000003fe4 = 0x10;
  *(uint32_t*)0x200000003fe8 = 1;
  *(uint32_t*)0x200000003fec = 3;
  *(uint32_t*)0x200000003ff0 = 6;
  *(uint32_t*)0x200000003ff4 = 7;
  *(uint32_t*)0x200000003ff8 = 0;
  *(uint32_t*)0x200000003ffc = 6;
  *(uint32_t*)0x200000004000 = 0x8000;
  *(uint32_t*)0x200000004004 = 0x10;
  *(uint32_t*)0x200000004008 = 0xa;
  *(uint32_t*)0x20000000400c = 2;
  *(uint32_t*)0x200000004010 = 0x6c;
  *(uint32_t*)0x200000004014 = -1;
  *(uint32_t*)0x200000004018 = 2;
  *(uint32_t*)0x20000000401c = 0x94;
  *(uint32_t*)0x200000004020 = 9;
  *(uint32_t*)0x200000004024 = 3;
  *(uint32_t*)0x200000004028 = 0x40;
  *(uint32_t*)0x20000000402c = 0xfffffffa;
  *(uint32_t*)0x200000004030 = 6;
  *(uint32_t*)0x200000004034 = 0;
  *(uint32_t*)0x200000004038 = 0xef0;
  *(uint32_t*)0x20000000403c = 8;
  *(uint32_t*)0x200000004040 = 8;
  *(uint32_t*)0x200000004044 = 0x64;
  *(uint32_t*)0x200000004048 = 0x10;
  *(uint32_t*)0x20000000404c = 0x49;
  *(uint32_t*)0x200000004050 = 0x80;
  *(uint32_t*)0x200000004054 = 9;
  *(uint32_t*)0x200000004058 = 0xc;
  *(uint32_t*)0x20000000405c = 0x8000;
  *(uint32_t*)0x200000004060 = 7;
  *(uint32_t*)0x200000004064 = 3;
  *(uint32_t*)0x200000004068 = 0x140;
  *(uint32_t*)0x20000000406c = 7;
  *(uint32_t*)0x200000004070 = 7;
  *(uint32_t*)0x200000004074 = 0xf16;
  *(uint32_t*)0x200000004078 = 0x7ff;
  *(uint32_t*)0x20000000407c = 3;
  *(uint32_t*)0x200000004080 = 7;
  *(uint32_t*)0x200000004084 = 0x1ff;
  *(uint32_t*)0x200000004088 = 9;
  *(uint32_t*)0x20000000408c = 1;
  *(uint32_t*)0x200000004090 = 9;
  *(uint32_t*)0x200000004094 = 0x4e;
  *(uint32_t*)0x200000004098 = -1;
  *(uint32_t*)0x20000000409c = 4;
  *(uint32_t*)0x2000000040a0 = 2;
  *(uint32_t*)0x2000000040a4 = -1;
  *(uint32_t*)0x2000000040a8 = 0xe559;
  *(uint32_t*)0x2000000040ac = 0xc16;
  *(uint32_t*)0x2000000040b0 = 4;
  *(uint32_t*)0x2000000040b4 = 0xfffff802;
  *(uint32_t*)0x2000000040b8 = 1;
  *(uint32_t*)0x2000000040bc = 4;
  *(uint32_t*)0x2000000040c0 = 1;
  *(uint32_t*)0x2000000040c4 = 6;
  *(uint32_t*)0x2000000040c8 = 0;
  *(uint32_t*)0x2000000040cc = 2;
  *(uint32_t*)0x2000000040d0 = 0xf;
  *(uint32_t*)0x2000000040d4 = 0x10;
  *(uint32_t*)0x2000000040d8 = 3;
  *(uint32_t*)0x2000000040dc = 0xafae;
  *(uint32_t*)0x2000000040e0 = 3;
  *(uint32_t*)0x2000000040e4 = 0x10000;
  *(uint32_t*)0x2000000040e8 = 4;
  *(uint32_t*)0x2000000040ec = 6;
  *(uint32_t*)0x2000000040f0 = 2;
  *(uint32_t*)0x2000000040f4 = 6;
  *(uint32_t*)0x2000000040f8 = 0xa4;
  *(uint32_t*)0x2000000040fc = 0;
  *(uint32_t*)0x200000004100 = 4;
  *(uint32_t*)0x200000004104 = 0;
  *(uint32_t*)0x200000004108 = 4;
  *(uint32_t*)0x20000000410c = 0x1000;
  *(uint32_t*)0x200000004110 = 0x6f17;
  *(uint32_t*)0x200000004114 = 2;
  *(uint32_t*)0x200000004118 = 4;
  *(uint32_t*)0x20000000411c = 0xd9;
  *(uint32_t*)0x200000004120 = 0x7fffffff;
  *(uint32_t*)0x200000004124 = 3;
  *(uint32_t*)0x200000004128 = 0x805;
  *(uint32_t*)0x20000000412c = 0xf17;
  *(uint32_t*)0x200000004130 = 4;
  *(uint32_t*)0x200000004134 = 0x40;
  *(uint32_t*)0x200000004138 = 5;
  *(uint32_t*)0x20000000413c = 1;
  *(uint32_t*)0x200000004140 = 0xff;
  *(uint32_t*)0x200000004144 = 0;
  *(uint32_t*)0x200000004148 = 0x80000001;
  *(uint32_t*)0x20000000414c = 0xb44f;
  *(uint32_t*)0x200000004150 = 0xfffffffa;
  *(uint32_t*)0x200000004154 = 0;
  *(uint32_t*)0x200000004158 = 0x8a5;
  *(uint32_t*)0x20000000415c = 0x8000;
  *(uint32_t*)0x200000004160 = 0x7ff;
  *(uint32_t*)0x200000004164 = 5;
  *(uint32_t*)0x200000004168 = 3;
  *(uint32_t*)0x20000000416c = 4;
  *(uint32_t*)0x200000004170 = 0x600;
  *(uint32_t*)0x200000004174 = 0x4b;
  *(uint32_t*)0x200000004178 = 0xad;
  *(uint32_t*)0x20000000417c = 8;
  *(uint32_t*)0x200000004180 = 0x669;
  *(uint32_t*)0x200000004184 = 0x1ff;
  *(uint32_t*)0x200000004188 = 3;
  *(uint32_t*)0x20000000418c = 2;
  *(uint32_t*)0x200000004190 = 0xa45;
  *(uint32_t*)0x200000004194 = 0x1000;
  *(uint32_t*)0x200000004198 = 0;
  *(uint32_t*)0x20000000419c = 0xa;
  *(uint32_t*)0x2000000041a0 = 1;
  *(uint32_t*)0x2000000041a4 = 4;
  *(uint32_t*)0x2000000041a8 = 1;
  *(uint32_t*)0x2000000041ac = 8;
  *(uint32_t*)0x2000000041b0 = 2;
  *(uint32_t*)0x2000000041b4 = 0xe0;
  *(uint32_t*)0x2000000041b8 = 4;
  *(uint32_t*)0x2000000041bc = 4;
  *(uint32_t*)0x2000000041c0 = 0xffd;
  *(uint32_t*)0x2000000041c4 = 5;
  *(uint32_t*)0x2000000041c8 = 3;
  *(uint32_t*)0x2000000041cc = 0x7fffffff;
  *(uint32_t*)0x2000000041d0 = 0xfffffffb;
  *(uint32_t*)0x2000000041d4 = 8;
  *(uint32_t*)0x2000000041d8 = 4;
  *(uint32_t*)0x2000000041dc = 4;
  *(uint32_t*)0x2000000041e0 = 6;
  *(uint32_t*)0x2000000041e4 = 1;
  *(uint32_t*)0x2000000041e8 = 5;
  *(uint32_t*)0x2000000041ec = 6;
  *(uint32_t*)0x2000000041f0 = 0;
  *(uint32_t*)0x2000000041f4 = 0xffffdbdc;
  *(uint32_t*)0x2000000041f8 = 2;
  *(uint32_t*)0x2000000041fc = 9;
  *(uint32_t*)0x200000004200 = 0x140000;
  *(uint32_t*)0x200000004204 = 2;
  *(uint32_t*)0x200000004208 = 1;
  *(uint32_t*)0x20000000420c = 0xdc;
  *(uint32_t*)0x200000004210 = 8;
  *(uint32_t*)0x200000004214 = 0x80000000;
  *(uint32_t*)0x200000004218 = 0x569;
  *(uint32_t*)0x20000000421c = 0;
  *(uint32_t*)0x200000004220 = 8;
  *(uint32_t*)0x200000004224 = -1;
  *(uint32_t*)0x200000004228 = 0xa;
  *(uint32_t*)0x20000000422c = 0x80000001;
  *(uint32_t*)0x200000004230 = 0xa;
  *(uint32_t*)0x200000004234 = 0xfffffbff;
  *(uint32_t*)0x200000004238 = 0x10;
  *(uint32_t*)0x20000000423c = 8;
  *(uint32_t*)0x200000004240 = 0x101;
  *(uint32_t*)0x200000004244 = 0xfffffffa;
  *(uint32_t*)0x200000004248 = 0x8000;
  *(uint32_t*)0x20000000424c = 0xa9c;
  *(uint32_t*)0x200000004250 = 6;
  *(uint32_t*)0x200000004254 = 0x1ff;
  *(uint32_t*)0x200000004258 = 8;
  *(uint32_t*)0x20000000425c = 0x1d;
  *(uint32_t*)0x200000004260 = 3;
  *(uint32_t*)0x200000004264 = 2;
  *(uint32_t*)0x200000004268 = 0xfffff16c;
  *(uint32_t*)0x20000000426c = 5;
  *(uint32_t*)0x200000004270 = 3;
  *(uint32_t*)0x200000004274 = 5;
  *(uint32_t*)0x200000004278 = 0x7ff;
  *(uint16_t*)0x20000000427c = 1;
  *(uint16_t*)0x20000000427e = 1;
  *(uint16_t*)0x200000004280 = 2;
  *(uint16_t*)0x200000004282 = 0;
  *(uint16_t*)0x200000004284 = 4;
  *(uint16_t*)0x200000004286 = 1;
  *(uint16_t*)0x200000004288 = 0;
  *(uint16_t*)0x20000000428a = 1;
  *(uint16_t*)0x20000000428c = 4;
  *(uint16_t*)0x20000000428e = 1;
  *(uint16_t*)0x200000004290 = 3;
  *(uint16_t*)0x200000004292 = 1;
  *(uint16_t*)0x200000004294 = 0x68cc;
  *(uint16_t*)0x200000004296 = 1;
  *(uint16_t*)0x200000004298 = 3;
  *(uint16_t*)0x20000000429a = 1;
  *(uint16_t*)0x20000000429c = 0;
  *(uint16_t*)0x20000000429e = 1;
  *(uint16_t*)0x2000000042a0 = 1;
  *(uint16_t*)0x2000000042a2 = 0x7768;
  *(uint16_t*)0x2000000042a4 = 3;
  *(uint16_t*)0x2000000042a6 = 0;
  *(uint16_t*)0x2000000042a8 = 2;
  *(uint16_t*)0x2000000042aa = 0;
  *(uint16_t*)0x2000000042ac = 0;
  *(uint16_t*)0x2000000042ae = 1;
  *(uint16_t*)0x2000000042b0 = 0;
  *(uint16_t*)0x2000000042b2 = 0;
  *(uint16_t*)0x2000000042b4 = 4;
  *(uint16_t*)0x2000000042b6 = 0;
  *(uint16_t*)0x2000000042b8 = 2;
  *(uint16_t*)0x2000000042ba = 0;
  *(uint16_t*)0x2000000042bc = 1;
  *(uint16_t*)0x2000000042be = 0;
  *(uint16_t*)0x2000000042c0 = 5;
  *(uint16_t*)0x2000000042c2 = 0;
  *(uint16_t*)0x2000000042c4 = 2;
  *(uint16_t*)0x2000000042c6 = 1;
  *(uint16_t*)0x2000000042c8 = 0;
  *(uint16_t*)0x2000000042ca = 1;
  *(uint16_t*)0x2000000042cc = 1;
  *(uint16_t*)0x2000000042ce = 0;
  *(uint16_t*)0x2000000042d0 = 5;
  *(uint16_t*)0x2000000042d2 = 1;
  *(uint16_t*)0x2000000042d4 = 5;
  *(uint16_t*)0x2000000042d6 = 0;
  *(uint16_t*)0x2000000042d8 = 4;
  *(uint16_t*)0x2000000042da = 0;
  *(uint16_t*)0x2000000042dc = 4;
  *(uint16_t*)0x2000000042de = 1;
  *(uint16_t*)0x2000000042e0 = 4;
  *(uint16_t*)0x2000000042e2 = 1;
  *(uint16_t*)0x2000000042e4 = 2;
  *(uint16_t*)0x2000000042e6 = 0;
  *(uint16_t*)0x2000000042e8 = 1;
  *(uint16_t*)0x2000000042ea = 1;
  *(uint16_t*)0x2000000042ec = 2;
  *(uint16_t*)0x2000000042ee = 0;
  *(uint16_t*)0x2000000042f0 = 1;
  *(uint16_t*)0x2000000042f2 = 1;
  *(uint16_t*)0x2000000042f4 = 2;
  *(uint16_t*)0x2000000042f6 = 0;
  *(uint16_t*)0x2000000042f8 = 4;
  *(uint16_t*)0x2000000042fa = 1;
  *(uint16_t*)0x2000000042fc = 3;
  *(uint16_t*)0x2000000042fe = 1;
  *(uint16_t*)0x200000004300 = 4;
  *(uint16_t*)0x200000004302 = 1;
  *(uint16_t*)0x200000004304 = 2;
  *(uint16_t*)0x200000004306 = 1;
  *(uint16_t*)0x200000004308 = 5;
  *(uint16_t*)0x20000000430a = 0;
  *(uint16_t*)0x20000000430c = 1;
  *(uint16_t*)0x20000000430e = 0;
  *(uint16_t*)0x200000004310 = 3;
  *(uint16_t*)0x200000004312 = 1;
  *(uint16_t*)0x200000004314 = 1;
  *(uint16_t*)0x200000004316 = 0;
  *(uint16_t*)0x200000004318 = 5;
  *(uint16_t*)0x20000000431a = 1;
  *(uint16_t*)0x20000000431c = 2;
  *(uint16_t*)0x20000000431e = 0;
  *(uint16_t*)0x200000004320 = 3;
  *(uint16_t*)0x200000004322 = 1;
  *(uint16_t*)0x200000004324 = 4;
  *(uint16_t*)0x200000004326 = 1;
  *(uint16_t*)0x200000004328 = 3;
  *(uint16_t*)0x20000000432a = 1;
  *(uint16_t*)0x20000000432c = 3;
  *(uint16_t*)0x20000000432e = 0;
  *(uint16_t*)0x200000004330 = 1;
  *(uint16_t*)0x200000004332 = 0;
  *(uint16_t*)0x200000004334 = 1;
  *(uint16_t*)0x200000004336 = 1;
  *(uint16_t*)0x200000004338 = 4;
  *(uint16_t*)0x20000000433a = 1;
  *(uint16_t*)0x20000000433c = 3;
  *(uint16_t*)0x20000000433e = 1;
  *(uint16_t*)0x200000004340 = 2;
  *(uint16_t*)0x200000004342 = 1;
  *(uint16_t*)0x200000004344 = 2;
  *(uint16_t*)0x200000004346 = 1;
  *(uint16_t*)0x200000004348 = 5;
  *(uint16_t*)0x20000000434a = 0;
  *(uint16_t*)0x20000000434c = 3;
  *(uint16_t*)0x20000000434e = 1;
  *(uint16_t*)0x200000004350 = 0;
  *(uint16_t*)0x200000004352 = 1;
  *(uint16_t*)0x200000004354 = 5;
  *(uint16_t*)0x200000004356 = 0;
  *(uint16_t*)0x200000004358 = 5;
  *(uint16_t*)0x20000000435a = 1;
  *(uint16_t*)0x20000000435c = 5;
  *(uint16_t*)0x20000000435e = 1;
  *(uint16_t*)0x200000004360 = 5;
  *(uint16_t*)0x200000004362 = 1;
  *(uint16_t*)0x200000004364 = 0;
  *(uint16_t*)0x200000004366 = 1;
  *(uint16_t*)0x200000004368 = 4;
  *(uint16_t*)0x20000000436a = 0;
  *(uint16_t*)0x20000000436c = 3;
  *(uint16_t*)0x20000000436e = 0;
  *(uint16_t*)0x200000004370 = 2;
  *(uint16_t*)0x200000004372 = 1;
  *(uint16_t*)0x200000004374 = 2;
  *(uint16_t*)0x200000004376 = 1;
  *(uint16_t*)0x200000004378 = 3;
  *(uint16_t*)0x20000000437a = 0;
  *(uint16_t*)0x20000000437c = 2;
  *(uint16_t*)0x20000000437e = 1;
  *(uint16_t*)0x200000004380 = 4;
  *(uint16_t*)0x200000004382 = 1;
  *(uint16_t*)0x200000004384 = 2;
  *(uint16_t*)0x200000004386 = 0;
  *(uint16_t*)0x200000004388 = 0;
  *(uint16_t*)0x20000000438a = 0;
  *(uint16_t*)0x20000000438c = 4;
  *(uint16_t*)0x20000000438e = 0;
  *(uint16_t*)0x200000004390 = 5;
  *(uint16_t*)0x200000004392 = 1;
  *(uint16_t*)0x200000004394 = 3;
  *(uint16_t*)0x200000004396 = 1;
  *(uint16_t*)0x200000004398 = 5;
  *(uint16_t*)0x20000000439a = 1;
  *(uint16_t*)0x20000000439c = 4;
  *(uint16_t*)0x20000000439e = 0;
  *(uint16_t*)0x2000000043a0 = 1;
  *(uint16_t*)0x2000000043a2 = 1;
  *(uint16_t*)0x2000000043a4 = 2;
  *(uint16_t*)0x2000000043a6 = 0;
  *(uint16_t*)0x2000000043a8 = 3;
  *(uint16_t*)0x2000000043aa = 1;
  *(uint16_t*)0x2000000043ac = 6;
  *(uint16_t*)0x2000000043ae = 1;
  *(uint16_t*)0x2000000043b0 = 4;
  *(uint16_t*)0x2000000043b2 = 0;
  *(uint16_t*)0x2000000043b4 = 7;
  *(uint16_t*)0x2000000043b6 = 0;
  *(uint16_t*)0x2000000043b8 = 1;
  *(uint16_t*)0x2000000043ba = 0;
  *(uint16_t*)0x2000000043bc = 3;
  *(uint16_t*)0x2000000043be = 0;
  *(uint16_t*)0x2000000043c0 = 2;
  *(uint16_t*)0x2000000043c2 = 0;
  *(uint16_t*)0x2000000043c4 = 0;
  *(uint16_t*)0x2000000043c6 = 0;
  *(uint16_t*)0x2000000043c8 = 2;
  *(uint16_t*)0x2000000043ca = 0;
  *(uint16_t*)0x2000000043cc = 0;
  *(uint16_t*)0x2000000043ce = 0;
  *(uint16_t*)0x2000000043d0 = 5;
  *(uint16_t*)0x2000000043d2 = 0;
  *(uint16_t*)0x2000000043d4 = 5;
  *(uint16_t*)0x2000000043d6 = 1;
  *(uint16_t*)0x2000000043d8 = 5;
  *(uint16_t*)0x2000000043da = 1;
  *(uint16_t*)0x2000000043dc = 2;
  *(uint16_t*)0x2000000043de = 0;
  *(uint16_t*)0x2000000043e0 = 3;
  *(uint16_t*)0x2000000043e2 = 0;
  *(uint16_t*)0x2000000043e4 = 2;
  *(uint16_t*)0x2000000043e6 = 1;
  *(uint16_t*)0x2000000043e8 = 0;
  *(uint16_t*)0x2000000043ea = 1;
  *(uint16_t*)0x2000000043ec = 2;
  *(uint16_t*)0x2000000043ee = 1;
  *(uint16_t*)0x2000000043f0 = 5;
  *(uint16_t*)0x2000000043f2 = 1;
  *(uint16_t*)0x2000000043f4 = 4;
  *(uint16_t*)0x2000000043f6 = 1;
  *(uint16_t*)0x2000000043f8 = 1;
  *(uint16_t*)0x2000000043fa = 0;
  *(uint16_t*)0x2000000043fc = 0;
  *(uint16_t*)0x2000000043fe = 0x10a2;
  *(uint16_t*)0x200000004400 = 3;
  *(uint16_t*)0x200000004402 = 0;
  *(uint16_t*)0x200000004404 = 1;
  *(uint16_t*)0x200000004406 = 1;
  *(uint16_t*)0x200000004408 = 3;
  *(uint16_t*)0x20000000440a = 1;
  *(uint16_t*)0x20000000440c = 4;
  *(uint16_t*)0x20000000440e = 0;
  *(uint16_t*)0x200000004410 = 0;
  *(uint16_t*)0x200000004412 = 1;
  *(uint16_t*)0x200000004414 = 5;
  *(uint16_t*)0x200000004416 = 1;
  *(uint16_t*)0x200000004418 = 4;
  *(uint16_t*)0x20000000441a = 1;
  *(uint16_t*)0x20000000441c = 2;
  *(uint16_t*)0x20000000441e = 0;
  *(uint16_t*)0x200000004420 = 4;
  *(uint16_t*)0x200000004422 = 1;
  *(uint16_t*)0x200000004424 = 0;
  *(uint16_t*)0x200000004426 = 1;
  *(uint16_t*)0x200000004428 = 2;
  *(uint16_t*)0x20000000442a = 0;
  *(uint16_t*)0x20000000442c = 2;
  *(uint16_t*)0x20000000442e = 1;
  *(uint16_t*)0x200000004430 = 3;
  *(uint16_t*)0x200000004432 = 0;
  *(uint16_t*)0x200000004434 = 1;
  *(uint16_t*)0x200000004436 = 1;
  *(uint16_t*)0x200000004438 = 4;
  *(uint16_t*)0x20000000443a = 1;
  *(uint16_t*)0x20000000443c = 3;
  *(uint16_t*)0x20000000443e = 2;
  *(uint16_t*)0x200000004440 = 3;
  *(uint16_t*)0x200000004442 = 1;
  *(uint16_t*)0x200000004444 = 1;
  *(uint16_t*)0x200000004446 = 1;
  *(uint16_t*)0x200000004448 = 4;
  *(uint16_t*)0x20000000444a = 0;
  *(uint16_t*)0x20000000444c = 3;
  *(uint16_t*)0x20000000444e = 1;
  *(uint16_t*)0x200000004450 = 2;
  *(uint16_t*)0x200000004452 = 0;
  *(uint16_t*)0x200000004454 = 3;
  *(uint16_t*)0x200000004456 = 0;
  *(uint16_t*)0x200000004458 = 5;
  *(uint16_t*)0x20000000445a = 0;
  *(uint16_t*)0x20000000445c = 2;
  *(uint16_t*)0x20000000445e = 0;
  *(uint16_t*)0x200000004460 = 1;
  *(uint16_t*)0x200000004462 = 1;
  *(uint16_t*)0x200000004464 = 1;
  *(uint16_t*)0x200000004466 = 1;
  *(uint16_t*)0x200000004468 = 5;
  *(uint16_t*)0x20000000446a = 1;
  *(uint16_t*)0x20000000446c = 3;
  *(uint16_t*)0x20000000446e = 1;
  *(uint16_t*)0x200000004470 = 0;
  *(uint16_t*)0x200000004472 = 0;
  *(uint16_t*)0x200000004474 = 0;
  *(uint16_t*)0x200000004476 = 0;
  *(uint16_t*)0x200000004478 = 4;
  *(uint16_t*)0x20000000447a = 1;
  *(uint8_t*)0x20000000447c = 1;
  *(uint16_t*)0x200000004480 = 4;
  *(uint16_t*)0x200000004482 = 6;
  *(uint16_t*)0x200000004484 = 0xc;
  *(uint16_t*)0x200000004486 = 7;
  *(uint32_t*)0x200000004488 = 0;
  *(uint32_t*)0x20000000448c = 1;
  *(uint16_t*)0x200000004490 = 0xc;
  *(uint16_t*)0x200000004492 = 8;
  *(uint32_t*)0x200000004494 = 5;
  *(uint32_t*)0x200000004498 = 0;
  *(uint64_t*)0x200000000348 = 0x1ddc;
  *(uint64_t*)0x200000000418 = 1;
  *(uint64_t*)0x200000000420 = 0;
  *(uint64_t*)0x200000000428 = 0;
  *(uint32_t*)0x200000000430 = 0x4040000;
  syscall(__NR_sendmsg, /*fd=*/(intptr_t)-1, /*msg=*/0x200000000400ul,
          /*f=MSG_MORE|MSG_CONFIRM*/ 0x8800ul);
  //  prctl$PR_SET_MM_MAP arguments: [
  //    option: const = 0x23 (8 bytes)
  //    opt: const = 0xe (8 bytes)
  //    arg: ptr[in, prctl_mm_map] {
  //      prctl_mm_map {
  //        start_code: VMA[0x1000]
  //        end_code: VMA[0xf000]
  //        start_data: VMA[0x2000]
  //        end_data: VMA[0x3000]
  //        start_brk: VMA[0x4000]
  //        brk: VMA[0x3000]
  //        start_stack: VMA[0x3000]
  //        arg_start: VMA[0x3000]
  //        arg_end: VMA[0x1000]
  //        env_start: VMA[0x1000]
  //        env_end: VMA[0x2000]
  //        auxv: nil
  //        auxv_size: bytesize = 0x0 (4 bytes)
  //        exe_fd: fd (resource)
  //      }
  //    }
  //    len: bytesize = 0x68 (8 bytes)
  //  ]
  *(uint64_t*)0x200000000080 = 0x200000ff7000;
  *(uint64_t*)0x200000000088 = 0x200000ff1000;
  *(uint64_t*)0x200000000090 = 0x200000ff1000;
  *(uint64_t*)0x200000000098 = 0x200000ff5000;
  *(uint64_t*)0x2000000000a0 = 0x200000ff8000;
  *(uint64_t*)0x2000000000a8 = 0x200000ff8000;
  *(uint64_t*)0x2000000000b0 = 0x200000ffd000;
  *(uint64_t*)0x2000000000b8 = 0x200000ffb000;
  *(uint64_t*)0x2000000000c0 = 0x200000ff5000;
  *(uint64_t*)0x2000000000c8 = 0x200000ffa000;
  *(uint64_t*)0x2000000000d0 = 0x200000ffa000;
  *(uint64_t*)0x2000000000d8 = 0;
  *(uint32_t*)0x2000000000e0 = 0;
  *(uint32_t*)0x2000000000e4 = -1;
  syscall(__NR_prctl, /*option=*/0x23ul, /*opt=*/0xeul,
          /*arg=*/0x200000000080ul, /*len=*/0x68ul, 0);
  //  sendmsg$NFT_BATCH arguments: [
  //    fd: sock_nl_netfilter (resource)
  //    msg: ptr[in, msghdr_netlink[nft_batch_msg]] {
  //      msghdr_netlink[nft_batch_msg] {
  //        addr: nil
  //        addrlen: len = 0x0 (4 bytes)
  //        pad = 0x0 (4 bytes)
  //        vec: nil
  //        vlen: const = 0x1 (8 bytes)
  //        ctrl: const = 0x0 (8 bytes)
  //        ctrllen: const = 0x0 (8 bytes)
  //        f: send_flags = 0x0 (4 bytes)
  //        pad = 0x0 (4 bytes)
  //      }
  //    }
  //    f: send_flags = 0x24004045 (8 bytes)
  //  ]
  *(uint64_t*)0x200000000080 = 0;
  *(uint32_t*)0x200000000088 = 0;
  *(uint64_t*)0x200000000090 = 0;
  *(uint64_t*)0x200000000098 = 1;
  *(uint64_t*)0x2000000000a0 = 0;
  *(uint64_t*)0x2000000000a8 = 0;
  *(uint32_t*)0x2000000000b0 = 0;
  syscall(
      __NR_sendmsg, /*fd=*/(intptr_t)-1, /*msg=*/0x200000000080ul,
      /*f=MSG_ZEROCOPY|MSG_FASTOPEN|MSG_OOB|MSG_NOSIGNAL|MSG_DONTWAIT|MSG_DONTROUTE*/
      0x24004045ul);
  //  io_uring_setup arguments: [
  //    entries: int32 = 0x524 (4 bytes)
  //    params: ptr[inout, io_uring_params] {
  //      io_uring_params {
  //        sq_entries: int32 = 0x0 (4 bytes)
  //        cq_entries: int32 = 0x3cb1 (4 bytes)
  //        flags: io_uring_setup_flags = 0x1c080 (4 bytes)
  //        sq_thread_cpu: int32 = 0xa (4 bytes)
  //        sq_thread_idle: int32 = 0x20002f7 (4 bytes)
  //        features: int32 = 0x0 (4 bytes)
  //        wq_fd: fd_io_uring (resource)
  //        resv: buffer: {00 00 00 00 00 00 00 00 00 00 00 00} (length 0xc)
  //        sq_off: io_sqring_offsets {
  //          head: int32 = 0x0 (4 bytes)
  //          tail: int32 = 0x0 (4 bytes)
  //          ring_mask: int32 = 0x0 (4 bytes)
  //          ring_entries: int32 = 0x0 (4 bytes)
  //          flags: int32 = 0x0 (4 bytes)
  //          dropped: int32 = 0x0 (4 bytes)
  //          array: int32 = 0x0 (4 bytes)
  //          resv1: int32 = 0x0 (4 bytes)
  //          user_addr: int64 = 0x0 (8 bytes)
  //        }
  //        cq_off: io_cqring_offsets {
  //          head: int32 = 0x0 (4 bytes)
  //          tail: int32 = 0x0 (4 bytes)
  //          ring_mask: int32 = 0x0 (4 bytes)
  //          ring_entries: int32 = 0x0 (4 bytes)
  //          overflow: int32 = 0x0 (4 bytes)
  //          cqes: int32 = 0x0 (4 bytes)
  //          flags: int32 = 0x0 (4 bytes)
  //          resv1: int32 = 0x0 (4 bytes)
  //          user_addr: int64 = 0x0 (8 bytes)
  //        }
  //      }
  //    }
  //  ]
  //  returns fd_io_uring
  *(uint32_t*)0x200000000044 = 0x3cb1;
  *(uint32_t*)0x200000000048 = 0x1c080;
  *(uint32_t*)0x20000000004c = 0xa;
  *(uint32_t*)0x200000000050 = 0x20002f7;
  *(uint32_t*)0x200000000058 = -1;
  memset((void*)0x20000000005c, 0, 12);
  res = syscall(__NR_io_uring_setup, /*entries=*/0x524,
                /*params=*/0x200000000040ul);
  if (res != -1)
    r[0] = res;
  //  setsockopt$inet_sctp_SCTP_SOCKOPT_BINDX_ADD arguments: [
  //    fd: sock_sctp (resource)
  //    level: const = 0x84 (4 bytes)
  //    opt: const = 0x64 (4 bytes)
  //    val: ptr[in, array[sockaddr_sctp]] {
  //      array[sockaddr_sctp] {
  //        union sockaddr_sctp {
  //          in6: sockaddr_in6 {
  //            family: const = 0xa (2 bytes)
  //            port: int16be = 0x4e23 (2 bytes)
  //            flow: int32be = 0x401 (4 bytes)
  //            addr: union ipv6_addr {
  //              loopback: ipv6_addr_loopback {
  //                a0: const = 0x0 (8 bytes)
  //                a1: const = 0x1 (8 bytes)
  //              }
  //            }
  //            scope: int32 = 0x0 (4 bytes)
  //          }
  //        }
  //      }
  //    }
  //    len: bytesize = 0x1c (8 bytes)
  //  ]
  *(uint16_t*)0x200000000000 = 0xa;
  *(uint16_t*)0x200000000002 = htobe16(0x4e23);
  *(uint32_t*)0x200000000004 = htobe32(0x401);
  *(uint64_t*)0x200000000008 = htobe64(0);
  *(uint64_t*)0x200000000010 = htobe64(1);
  *(uint32_t*)0x200000000018 = 0;
  syscall(__NR_setsockopt, /*fd=*/(intptr_t)-1, /*level=*/0x84, /*opt=*/0x64,
          /*val=*/0x200000000000ul, /*len=*/0x1cul);
  //  io_uring_enter arguments: [
  //    fd: fd_io_uring (resource)
  //    to_submit: int32 = 0x2219 (4 bytes)
  //    min_complete: int32 = 0x7721 (4 bytes)
  //    flags: io_uring_enter_flags = 0x16 (8 bytes)
  //    sigmask: nil
  //    size: len = 0x0 (8 bytes)
  //  ]
  syscall(
      __NR_io_uring_enter, /*fd=*/r[0], /*to_submit=*/0x2219,
      /*min_complete=*/0x7721,
      /*flags=IORING_ENTER_REGISTERED_RING|IORING_ENTER_SQ_WAIT|IORING_ENTER_SQ_WAKEUP*/
      0x16ul, /*sigmask=*/0ul, /*size=*/0ul);
}
int main(void)
{
  syscall(__NR_mmap, /*addr=*/0x1ffffffff000ul, /*len=*/0x1000ul, /*prot=*/0ul,
          /*flags=MAP_FIXED|MAP_ANONYMOUS|MAP_PRIVATE*/ 0x32ul,
          /*fd=*/(intptr_t)-1, /*offset=*/0ul);
  syscall(__NR_mmap, /*addr=*/0x200000000000ul, /*len=*/0x1000000ul,
          /*prot=PROT_WRITE|PROT_READ|PROT_EXEC*/ 7ul,
          /*flags=MAP_FIXED|MAP_ANONYMOUS|MAP_PRIVATE*/ 0x32ul,
          /*fd=*/(intptr_t)-1, /*offset=*/0ul);
  syscall(__NR_mmap, /*addr=*/0x200001000000ul, /*len=*/0x1000ul, /*prot=*/0ul,
          /*flags=MAP_FIXED|MAP_ANONYMOUS|MAP_PRIVATE*/ 0x32ul,
          /*fd=*/(intptr_t)-1, /*offset=*/0ul);
  setup_cgroups();
  const char* reason;
  (void)reason;
  if ((reason = setup_leak()))
    printf("the reproducer may not work as expected: leak checking setup "
           "failed: %s\n",
           reason);
  if ((reason = setup_usb()))
    printf("the reproducer may not work as expected: USB injection setup "
           "failed: %s\n",
           reason);
  if ((reason = setup_802154()))
    printf("the reproducer may not work as expected: 802154 injection setup "
           "failed: %s\n",
           reason);
  for (procid = 0; procid < 7; procid++) {
    if (fork() == 0) {
      use_temporary_dir();
      do_sandbox_none();
    }
  }
  sleep(1000000);
  return 0;
}