// File: /workspace/github_cpp_makefile_star2_O1/ndsol[P]git-mine/hashapi.cpp
// Function: doGitCommit(unsigned long, Sha1Hash&, Blake2Hash&, CommitMessage&)
int doGitCommit(size_t thId, Sha1Hash& sha, Blake2Hash& b2h,
                CommitMessage& noodle) {
  if (printGitCommit(thId, sha, b2h, noodle)) {
    return 1;
  }

  // Create environment for subprocess.
  std::string author = noodle.author;
  size_t pos = author.find("<");
  if (pos == std::string::npos) {
    fprintf(stderr, "Failed to parse author <: %s\n", author.c_str());
    return 1;
  }
  std::string author_email = author.substr(pos + 1);
  if (author_email.find(">") == std::string::npos) {
    fprintf(stderr, "Failed to parse author >: %s\n", author.c_str());
    return 1;
  }
  author = author.substr(0, pos);
  author_email = author_email.substr(0, author_email.find(">"));
  if (author.substr(0, 7) != "author ") {
    fprintf(stderr, "Failed to parse author: %s\n", author.c_str());
    return 1;
  }
  author = author.substr(7);
  std::string author_date = noodle.author_time + noodle.author_tz;
  pos = author_date.find_last_not_of("\r\n ");
  if (pos == std::string::npos) {
    fprintf(stderr, "Failed to trim author_date: %s\n", author_date.c_str());
    return 1;
  }
  author_date = author_date.substr(0, pos + 1);

  std::string com = noodle.committer;
  pos = com.find("<");
  if (pos == std::string::npos) {
    fprintf(stderr, "Failed to parse committer <: %s\n", com.c_str());
    return 1;
  }
  std::string com_email = com.substr(pos + 1);
  if (com.find(">") == std::string::npos) {
    fprintf(stderr, "Failed to parse committer >: %s\n", com.c_str());
    return 1;
  }
  com = com.substr(0, pos);
  com_email = com_email.substr(0, com_email.find(">"));
  if (com.substr(0, 10) != "committer ") {
    fprintf(stderr, "Failed to parse committer: %s\n", com.c_str());
    return 1;
  }
  com = com.substr(10);
  std::string com_date = noodle.committer_time + noodle.committer_tz;
  pos = com_date.find_last_not_of("\r\n ");
  if (pos == std::string::npos) {
    fprintf(stderr, "Failed to trim com_date: %s\n", com_date.c_str());
    return 1;
  }
  com_date = com_date.substr(0, pos + 1);

  std::string parent = noodle.parent;
  if (!parent.empty()) {
    if (parent.substr(0, 7) != "parent ") {
      fprintf(stderr, "Failed to parse parent: %s\n", parent.c_str());
      return 1;
    }
    parent = parent.substr(7);
    pos = parent.find_last_not_of("\r\n ");
    if (pos == std::string::npos) {
      fprintf(stderr, "Failed to trim parent: %s\n", parent.c_str());
      return 1;
    }
    parent = parent.substr(0, pos + 1);
  }

  std::string tree;
  for (pos = 0; pos < noodle.header.size(); pos++) {
    if (noodle.header.at(pos) == 0) {
      pos++;
      if (pos >= noodle.header.size()) {
        fprintf(stderr, "Failed to find tree in header\n");
        return 1;
      }
      tree.assign(noodle.header.data() + pos,
                  noodle.header.size() - pos);
      if (tree.substr(0, 5) != "tree ") {
        fprintf(stderr, "Failed to parse tree: %s\n", tree.c_str());
        return 1;
      }
      tree = tree.substr(5);
      pos = tree.find_last_not_of("\r\n ");
      if (pos == std::string::npos) {
        fprintf(stderr, "Failed to trim tree: %s\n", tree.c_str());
        return 1;
      }
      tree = tree.substr(0, pos + 1);
      break;
    }
  }
  if (pos >= noodle.header.size()) {
    fprintf(stderr, "Failed to parse header\n");
    return 1;
  }

  std::vector<char *> git_env;
  author = "GIT_AUTHOR_NAME=" + author;
  git_env.push_back((char*)author.c_str());
  author_email = "GIT_AUTHOR_EMAIL=" + author_email;
  git_env.push_back((char*)author_email.c_str());
  author_date = "GIT_AUTHOR_DATE=" + author_date;
  git_env.push_back((char*)author_date.c_str());

  com = "GIT_COMMITTER_NAME=" + com;
  git_env.push_back((char*)com.c_str());
  com_email = "GIT_COMMITTER_EMAIL=" + com_email;
  git_env.push_back((char*)com_email.c_str());
  com_date = "GIT_COMMITTER_DATE=" + com_date;
  git_env.push_back((char*)com_date.c_str());

  if (0) {
    fprintf(stderr, "tree \"%s\"\n", tree.c_str());
    if (!parent.empty()) fprintf(stderr, "parent \"%s\"\n", parent.c_str());
    fprintf(stderr, "\"%s\" \"%s\" \"%s\"\n",
            author.c_str(), author_email.c_str(), author_date.c_str());
    fprintf(stderr, "\"%s\" \"%s\" \"%s\"\n",
            com.c_str(), com_email.c_str(), com_date.c_str());
  }

  char ** p = environ;
  while (*p) {
    git_env.push_back(*p);
    p++;
  }
  git_env.push_back(NULL);  // Terminate the environment linked list.

  int pipe1[2];
  if (pipe(pipe1) < 0) {
    fprintf(stderr, "pipe(pipe1): %d %s\n", errno, strerror(errno));
    return 1;
  }
  int pipe2[2];
  if (pipe(pipe2) < 0) {
    fprintf(stderr, "pipe(pipe2): %d %s\n", errno, strerror(errno));
    return 1;
  }

  signal(SIGPIPE, handle_SIGPIPE);
  char* git_argv[] = {
    (char*)"git", (char*)"commit-tree", (char*)tree.c_str(),
    NULL,  // Terminate git_argv with a NULL.
    NULL,
    NULL,
  };
  if (!parent.empty()) {
    git_argv[3] = (char*)"-p";
    git_argv[4] = (char*)parent.c_str();
  }

  int pid = fork();
  if (pid < 0) {
    fprintf(stderr, "fork(git commit-tree) failed: %d %s\n", errno,
            strerror(errno));
    return 1;
  }
  if (!pid) {
    // In child process: exec(git commit-tree).
    close(pipe1[0]);  // Close "read end"
    dup2(pipe1[1], 1);  // Redirect stdout to pipe1[1] ("write end")
    dup2(pipe1[1], 2);  // Redirect stderr to pipe1[1] ("write end")
    close(pipe1[1]);  // Close "write end" since it is now stdout/stderr.
    close(pipe2[1]);  // Close "write end"
    dup2(pipe2[0], 0);  // Redirect pipe2[0] ("read end") to stdin
    close(pipe2[0]);  // Close "read end"
    execvpe("git", git_argv, git_env.data());
    fprintf(stderr, "execvpe(git commit-tree) failed: %d %s\n", errno,
            strerror(errno));
    fflush(stderr);
    _exit(1);
  }
  close(pipe1[1]);  // Close "write end" that will not be used in parent
  close(pipe2[0]);  // Close "read end" that will not be used in parent

  // Wait for child (and read in what it says).
  std::string output;
  int epollfd = epoll_create1(0 /*flags*/);
  if (epollfd < 0) {
    fprintf(stderr, "epoll_create1 failed: %d %s\n", errno, strerror(errno));
    return 1;
  }

  std::vector<epoll_event> events;
  events.emplace_back();
  events.back().events = EPOLLIN;
  events.back().data.fd = pipe1[0];
  if (epoll_ctl(epollfd, EPOLL_CTL_ADD, pipe1[0], &events.back())) {
    fprintf(stderr, "EPOLL_CTL_ADD pipe1 failed: %d %s\n", errno,
            strerror(errno));
    return 1;
  }
  events.emplace_back();
  events.back().events = EPOLLOUT;
  events.back().data.fd = pipe2[1];
  if (epoll_ctl(epollfd, EPOLL_CTL_ADD, pipe2[1], &events.back())) {
    fprintf(stderr, "EPOLL_CTL_ADD pipe2 failed: %d %s\n", errno,
            strerror(errno));
    return 1;
  }

  int go = 1;
  size_t wrote_count = 0;
  while (go) {
    int r = epoll_wait(epollfd, events.data(), events.size(),
                        1000 /*milliseconds*/);
    if (r < 0) {
      fprintf(stderr, "epoll_wait failed: %d %s\n", errno, strerror(errno));
      return 1;
    } else if ((size_t)r > events.size()) {
      fprintf(stderr, "epoll_wait referred to %d, only %zu exist\n", r,
              events.size());
      return 1;
    } else if (!r) {
      fprintf(stderr, "Waiting for pid %d: git commit-tree...\n", pid);
      continue;
    }
    for (size_t i = 0; i < (size_t)r; i++) {
      if (events.at(i).data.fd == pipe1[0]) {
        if (events.at(i).events & EPOLLHUP) {
          go = 0;
          continue;
        }
        char buf[256];
        ssize_t nr = read(pipe1[0], buf, sizeof(buf));
        if (nr < 0) {
          fprintf(stderr, "read(pipe1[0]) failed: %d %s\n", errno,
                  strerror(errno));
          return 1;
        }
        if (nr == 0) {
          // 0 bytes indicates pipe1[0] was closed.
          close(pipe1[0]);
          go = 0;
          continue;
        }
        std::string s(buf, nr);
        output += s;
      } else if (events.at(i).data.fd == pipe2[1]) {
        // Stream commit message to child process.
        ssize_t wrlen = write(pipe2[1], noodle.log.c_str() + wrote_count,
                              noodle.log.size() - wrote_count);
        if (wrlen != ssize_t(noodle.log.size() - wrote_count)) {
          fprintf(stderr, "Write failed: %d %s (wrote %lld, want %lld)\n",
                  errno, strerror(errno), (long long) wrlen,
                  (long long) noodle.log.size() - wrote_count);
          close(pipe2[1]);
          return 1;
        }
        wrote_count += wrlen;
        if (wrote_count >= noodle.log.size()) {
          // All of noodle.log was sent. Close pipe2[1] so child knows.
          if (epoll_ctl(epollfd, EPOLL_CTL_DEL, pipe2[1], &events.at(i))) {
            fprintf(stderr, "EPOLL_CTL_DEL pipe2 failed: %d %s\n", errno,
                    strerror(errno));
            return 1;
          }
          close(pipe2[1]);
        }
      }
    }
  }
  int code;
  int waitres = waitpid(pid, &code, 0);
  if (waitres != pid) {
    fprintf(stderr, "waitpid failed: got %d, want pid %d. %d %s\n",
            waitres, pid, errno, strerror(errno));
    return 1;
  }
  // wantOutput has the hexdump of sha1 from the top of the function.
  char buf[1024];
  if (sha.dump(buf, sizeof(buf))) {
    fprintf(stderr, "sha.dump failed\n");
    return 1;
  }
  snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "\n");
  if (code || output != buf) {
    fprintf(stderr, "git commit-tree exited with code %d:\n", code);
    fprintf(stderr, "%s", output.c_str());
    return 1;
  }
  fprintf(stderr, "repo updated.\n# hint: %s %s",
          "git checkout master; git reset --hard", buf);
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x608, %rsp            # imm = 0x608
movq %rcx, %r15
movq %rsi, %rbx
callq 0x3751
testl %eax, %eax
je 0x39c0
pushq $0x1
popq %rbx
jmp 0x4f7c
movq %rbx, 0x1c8(%rsp)
leaq 0x50(%rsp), %r14
movq %r14, -0x10(%r14)
movq 0x40(%r15), %rsi
movq 0x48(%r15), %rdx
addq %rsi, %rdx
leaq 0x40(%rsp), %rbx
movq %rbx, %rdi
callq 0x6d32
leaq 0x88b2(%rip), %rsi      # 0xc2a2
pushq $0x1
popq %rcx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x3470
cmpq $-0x1, %rax
je 0x49c1
movq %rax, %rbx
leaq 0x1(%rax), %rdx
leaq 0x188(%rsp), %rdi
leaq 0x40(%rsp), %rsi
pushq $-0x1
popq %rcx
callq 0x3250
leaq 0x887a(%rip), %rsi      # 0xc2a4
leaq 0x188(%rsp), %rdi
pushq $0x1
popq %rcx
xorl %edx, %edx
callq 0x3470
cmpq $-0x1, %rax
je 0x49e6
leaq 0x200(%rsp), %rdi
leaq 0x40(%rsp), %rsi
xorl %edx, %edx
movq %rbx, %rcx
callq 0x3250
leaq 0x40(%rsp), %rdi
leaq 0x200(%rsp), %rbx
movq %rbx, %rsi
callq 0x32d0
movq (%rbx), %rdi
leaq 0x210(%rsp), %r12
cmpq %r12, %rdi
je 0x3a92
movq 0x210(%rsp), %rsi
incq %rsi
callq 0x3240
leaq 0x880b(%rip), %rsi      # 0xc2a4
leaq 0x188(%rsp), %rbx
pushq $0x1
popq %rcx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x3470
leaq 0x200(%rsp), %rdi
movq %rbx, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x3250
leaq 0x188(%rsp), %rdi
leaq 0x200(%rsp), %rbx
movq %rbx, %rsi
callq 0x32d0
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x3af3
movq 0x210(%rsp), %rsi
incq %rsi
callq 0x3240
movq %r15, %r13
leaq 0x200(%rsp), %rdi
leaq 0x40(%rsp), %rsi
pushq $0x7
popq %rcx
xorl %edx, %edx
callq 0x3250
leaq 0x873e(%rip), %rsi      # 0xc252
leaq 0x200(%rsp), %r15
movq %r15, %rdi
callq 0x3090
movl %eax, %ebx
movq (%r15), %rdi
cmpq %r12, %rdi
je 0x3b3e
movq 0x210(%rsp), %rsi
incq %rsi
callq 0x3240
testl %ebx, %ebx
jne 0x49fe
movq %r13, %r15
leaq 0x200(%rsp), %rdi
leaq 0x40(%rsp), %rsi
pushq $0x7
popq %rdx
pushq $-0x1
popq %rcx
callq 0x3250
leaq 0x40(%rsp), %rdi
leaq 0x200(%rsp), %rbx
movq %rbx, %rsi
callq 0x32d0
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x3b8e
movq 0x210(%rsp), %rsi
incq %rsi
callq 0x3240
leaq 0x60(%r15), %rsi
leaq 0x80(%r15), %rdx
leaq 0x168(%rsp), %rdi
callq 0x6cd8
leaq 0x8d56(%rip), %rsi      # 0xc903
leaq 0x168(%rsp), %rdi
pushq $-0x1
popq %rdx
pushq $0x3
popq %rcx
callq 0x33f0
cmpq $-0x1, %rax
je 0x4a23
incq %rax
leaq 0x200(%rsp), %rdi
leaq 0x168(%rsp), %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x3250
leaq 0x168(%rsp), %rdi
leaq 0x200(%rsp), %rbx
movq %rbx, %rsi
callq 0x32d0
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x3c17
movq 0x210(%rsp), %rsi
incq %rsi
callq 0x3240
leaq 0x98(%rsp), %rax
movq %rax, -0x10(%rax)
movq 0xa0(%r15), %rsi
movq 0xa8(%r15), %rdx
addq %rsi, %rdx
leaq 0x88(%rsp), %rdi
callq 0x6d32
leaq 0x865a(%rip), %rsi      # 0xc2a2
leaq 0x88(%rsp), %rdi
pushq $0x1
popq %rcx
xorl %edx, %edx
callq 0x3470
cmpq $-0x1, %rax
je 0x4a4b
movq %rax, %rbx
leaq 0x1(%rax), %rdx
leaq 0x1a8(%rsp), %rdi
leaq 0x88(%rsp), %rsi
pushq $-0x1
popq %rcx
callq 0x3250
leaq 0x861a(%rip), %rsi      # 0xc2a4
leaq 0x88(%rsp), %rdi
pushq $0x1
popq %rcx
xorl %edx, %edx
callq 0x3470
cmpq $-0x1, %rax
je 0x4a73
leaq 0x200(%rsp), %rdi
leaq 0x88(%rsp), %rsi
xorl %edx, %edx
movq %rbx, %rcx
callq 0x3250
leaq 0x88(%rsp), %rdi
leaq 0x200(%rsp), %rbx
movq %rbx, %rsi
callq 0x32d0
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x3cf0
movq 0x210(%rsp), %rsi
incq %rsi
callq 0x3240
leaq 0x85ad(%rip), %rsi      # 0xc2a4
leaq 0x1a8(%rsp), %r15
pushq $0x1
popq %rbx
movq %r15, %rdi
xorl %edx, %edx
movq %rbx, %rcx
callq 0x3470
leaq 0x200(%rsp), %rdi
movq %r15, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x3250
leaq 0x1a8(%rsp), %rdi
leaq 0x200(%rsp), %r15
movq %r15, %rsi
callq 0x32d0
movq (%r15), %rdi
cmpq %r12, %rdi
je 0x3d54
movq 0x210(%rsp), %rsi
incq %rsi
callq 0x3240
leaq 0x200(%rsp), %rdi
leaq 0x88(%rsp), %rsi
pushq $0xa
popq %rcx
xorl %edx, %edx
callq 0x3250
leaq 0x84e5(%rip), %rsi      # 0xc25a
leaq 0x200(%rsp), %r15
movq %r15, %rdi
callq 0x3090
movl %eax, %ebp
movq (%r15), %rdi
cmpq %r12, %rdi
je 0x3d9f
movq 0x210(%rsp), %rsi
incq %rsi
callq 0x3240
testl %ebp, %ebp
jne 0x4a8e
leaq 0x200(%rsp), %rdi
leaq 0x88(%rsp), %rsi
pushq $0xa
popq %rdx
pushq $-0x1
popq %rcx
callq 0x3250
leaq 0x88(%rsp), %rdi
leaq 0x200(%rsp), %r15
movq %r15, %rsi
callq 0x32d0
movq (%r15), %rdi
cmpq %r12, %rdi
je 0x3df2
movq 0x210(%rsp), %rsi
incq %rsi
callq 0x3240
leaq 0xc0(%r13), %rsi
leaq 0xe0(%r13), %rdx
leaq 0x148(%rsp), %rdi
callq 0x6cd8
leaq 0x8aef(%rip), %rsi      # 0xc903
leaq 0x148(%rsp), %rdi
pushq $-0x1
popq %rdx
pushq $0x3
popq %rcx
callq 0x33f0
cmpq $-0x1, %rax
je 0x4ab6
incq %rax
leaq 0x200(%rsp), %rdi
leaq 0x148(%rsp), %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x3250
leaq 0x148(%rsp), %rdi
leaq 0x200(%rsp), %r15
movq %r15, %rsi
callq 0x32d0
movq (%r15), %rdi
cmpq %r12, %rdi
je 0x3e7e
movq 0x210(%rsp), %rsi
incq %rsi
callq 0x3240
leaq 0xb8(%rsp), %rax
movq %rax, -0x10(%rax)
movq %r13, %r15
movq 0x20(%r13), %rsi
movq 0x28(%r13), %rdx
addq %rsi, %rdx
leaq 0xa8(%rsp), %rdi
callq 0x6d32
cmpq $0x0, 0xb0(%rsp)
je 0x3fc6
leaq 0x200(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
pushq $0x7
popq %rcx
xorl %edx, %edx
callq 0x3250
leaq 0x8375(%rip), %rsi      # 0xc24a
leaq 0x200(%rsp), %r15
movq %r15, %rdi
callq 0x3090
movl %eax, %ebp
movq (%r15), %rdi
cmpq %r12, %rdi
je 0x3eff
movq 0x210(%rsp), %rsi
incq %rsi
callq 0x3240
testl %ebp, %ebp
jne 0x4d2c
leaq 0x200(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
pushq $0x7
popq %rdx
pushq $-0x1
popq %rcx
callq 0x3250
leaq 0xa8(%rsp), %rdi
leaq 0x200(%rsp), %r15
movq %r15, %rsi
callq 0x32d0
movq (%r15), %rdi
cmpq %r12, %rdi
je 0x3f52
movq 0x210(%rsp), %rsi
incq %rsi
callq 0x3240
leaq 0x89aa(%rip), %rsi      # 0xc903
leaq 0xa8(%rsp), %rdi
pushq $-0x1
popq %rdx
pushq $0x3
popq %rcx
callq 0x33f0
cmpq $-0x1, %rax
je 0x4d83
incq %rax
leaq 0x200(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x3250
leaq 0xa8(%rsp), %rdi
leaq 0x200(%rsp), %r15
movq %r15, %rsi
callq 0x32d0
movq (%r15), %rdi
cmpq %r12, %rdi
je 0x3fc3
movq 0x210(%rsp), %rsi
incq %rsi
callq 0x3240
movq %r13, %r15
leaq 0xf8(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0x8(%r15), %r8
movq 0x10(%r15), %rax
movq %rax, %r15
subq %r8, %r15
je 0x400b
leaq 0x1(%r8), %rcx
notq %r8
addq %rax, %r8
cmpb $0x0, -0x1(%rcx)
je 0x4013
incq %rcx
incq %rbx
addq $-0x1, %r8
jb 0x3ff4
jmp 0x413d
xorl %r15d, %r15d
jmp 0x413d
cmpq %r15, %rbx
jae 0x4f90
leaq 0xe8(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x33a0
leaq 0x200(%rsp), %rdi
leaq 0xe8(%rsp), %rsi
pushq $0x5
popq %rcx
xorl %edx, %edx
callq 0x3250
leaq 0x8132(%rip), %rsi      # 0xc180
leaq 0x200(%rsp), %r15
movq %r15, %rdi
callq 0x3090
movl %eax, %ebx
movq (%r15), %rdi
cmpq %r12, %rdi
je 0x4078
movq 0x210(%rsp), %rsi
incq %rsi
callq 0x3240
testl %ebx, %ebx
jne 0x4fae
leaq 0x200(%rsp), %rdi
leaq 0xe8(%rsp), %rsi
pushq $0x5
popq %rdx
pushq $-0x1
popq %rcx
callq 0x3250
leaq 0xe8(%rsp), %rdi
leaq 0x200(%rsp), %rbx
movq %rbx, %rsi
callq 0x32d0
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x40cb
movq 0x210(%rsp), %rsi
incq %rsi
callq 0x3240
leaq 0x8831(%rip), %rsi      # 0xc903
leaq 0xe8(%rsp), %rdi
pushq $-0x1
popq %rdx
pushq $0x3
popq %rcx
callq 0x33f0
cmpq $-0x1, %rax
je 0x4fc9
movq %rax, %r15
leaq 0x1(%rax), %rcx
leaq 0x200(%rsp), %rdi
leaq 0xe8(%rsp), %rsi
xorl %edx, %edx
callq 0x3250
leaq 0xe8(%rsp), %rdi
leaq 0x200(%rsp), %rbx
movq %rbx, %rsi
callq 0x32d0
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x413d
movq 0x210(%rsp), %rsi
incq %rsi
callq 0x3240
movq 0x10(%r13), %rax
subq 0x8(%r13), %rax
cmpq %rax, %r15
jae 0x4bbf
xorps %xmm0, %xmm0
movaps %xmm0, 0x60(%rsp)
andq $0x0, 0x70(%rsp)
leaq 0x88e3(%rip), %rsi      # 0xca46
leaq 0x200(%rsp), %rdi
leaq 0x40(%rsp), %rdx
callq 0xafe5
leaq 0x40(%rsp), %rdi
leaq 0x200(%rsp), %rbx
movq %rbx, %rsi
callq 0x32d0
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x41a2
movq 0x210(%rsp), %rsi
incq %rsi
callq 0x3240
movq 0x40(%rsp), %rax
leaq 0x200(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x60(%rsp), %rdi
callq 0xb0fe
leaq 0x8894(%rip), %rsi      # 0xca57
leaq 0x200(%rsp), %rdi
leaq 0x188(%rsp), %rdx
callq 0xafe5
leaq 0x188(%rsp), %rdi
leaq 0x200(%rsp), %rbx
movq %rbx, %rsi
callq 0x32d0
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x4208
movq 0x210(%rsp), %rsi
incq %rsi
callq 0x3240
movq 0x188(%rsp), %rax
leaq 0x200(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x60(%rsp), %rdi
callq 0xb0fe
leaq 0x883d(%rip), %rsi      # 0xca69
leaq 0x200(%rsp), %rdi
leaq 0x168(%rsp), %rdx
callq 0xafe5
leaq 0x168(%rsp), %rdi
leaq 0x200(%rsp), %rbx
movq %rbx, %rsi
callq 0x32d0
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x4271
movq 0x210(%rsp), %rsi
incq %rsi
callq 0x3240
movq 0x168(%rsp), %rax
leaq 0x200(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x60(%rsp), %rdi
callq 0xb0fe
leaq 0x87e5(%rip), %rsi      # 0xca7a
leaq 0x200(%rsp), %rdi
leaq 0x88(%rsp), %rdx
callq 0xafe5
leaq 0x88(%rsp), %rdi
leaq 0x200(%rsp), %rbx
movq %rbx, %rsi
callq 0x32d0
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x42da
movq 0x210(%rsp), %rsi
incq %rsi
callq 0x3240
movq 0x88(%rsp), %rax
leaq 0x200(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x60(%rsp), %rdi
callq 0xb0fe
leaq 0x8790(%rip), %rsi      # 0xca8e
leaq 0x200(%rsp), %rdi
leaq 0x1a8(%rsp), %rdx
callq 0xafe5
leaq 0x1a8(%rsp), %rdi
leaq 0x200(%rsp), %rbx
movq %rbx, %rsi
callq 0x32d0
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x4343
movq 0x210(%rsp), %rsi
incq %rsi
callq 0x3240
movq 0x1a8(%rsp), %rax
leaq 0x200(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x60(%rsp), %rdi
callq 0xb0fe
leaq 0x873c(%rip), %rsi      # 0xcaa3
leaq 0x200(%rsp), %rdi
leaq 0x148(%rsp), %rdx
callq 0xafe5
leaq 0x148(%rsp), %rdi
leaq 0x200(%rsp), %rbx
movq %rbx, %rsi
callq 0x32d0
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x43ac
movq 0x210(%rsp), %rsi
incq %rsi
callq 0x3240
movq 0x148(%rsp), %rax
leaq 0x200(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x60(%rsp), %rdi
callq 0xb0fe
movq 0xbc08(%rip), %rax      # 0xffd8
movq (%rax), %rbx
movq (%rbx), %rax
testq %rax, %rax
je 0x440f
leaq 0x60(%rsp), %r15
movq 0x68(%rsp), %rsi
cmpq 0x70(%rsp), %rsi
je 0x43f7
movq %rax, (%rsi)
addq $0x8, 0x68(%rsp)
jmp 0x4402
movq %r15, %rdi
movq %rbx, %rdx
callq 0xb26a
movq 0x8(%rbx), %rax
addq $0x8, %rbx
testq %rax, %rax
jne 0x43e0
leaq 0x200(%rsp), %rsi
andq $0x0, (%rsi)
leaq 0x60(%rsp), %rdi
callq 0xb0fe
leaq 0x18(%rsp), %rdi
callq 0x3310
testl %eax, %eax
js 0x4bd7
movq %r13, %r15
leaq 0xc(%rsp), %rdi
callq 0x3310
testl %eax, %eax
js 0x4bf8
leaq 0xe6c(%rip), %rsi       # 0x52bf
pushq $0xd
popq %rdi
callq 0x32c0
leaq 0x867d(%rip), %rax      # 0xcadf
movq %rax, 0x1d0(%rsp)
leaq 0x8672(%rip), %rax      # 0xcae3
movq %rax, 0x1d8(%rsp)
movq 0xe8(%rsp), %rax
movq %rax, 0x1e0(%rsp)
andq $0x0, 0x1f8(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x1e8(%rsp)
cmpq $0x0, 0xb0(%rsp)
je 0x44c7
leaq 0x8640(%rip), %rax      # 0xcaef
movq %rax, 0x1e8(%rsp)
movq 0xa8(%rsp), %rax
movq %rax, 0x1f0(%rsp)
callq 0x3060
movl %eax, 0x84(%rsp)
testl %eax, %eax
js 0x4c19
je 0x4c4f
movl 0x1c(%rsp), %edi
callq 0x34d0
movl 0xc(%rsp), %edi
callq 0x34d0
leaq 0xd8(%rsp), %r12
movq %r12, -0x10(%r12)
andq $0x0, -0x8(%r12)
movb $0x0, (%r12)
xorl %edi, %edi
callq 0x32e0
movl %eax, 0x14(%rsp)
testl %eax, %eax
js 0x4cf3
andq $0x0, 0x30(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movq 0x28(%rsp), %rsi
testq %rsi, %rsi
je 0x4546
andl $0x0, 0x8(%rsi)
andq $0x0, (%rsi)
addq $0xc, 0x28(%rsp)
jmp 0x4550
leaq 0x20(%rsp), %rdi
callq 0xb346
movq 0x28(%rsp), %rax
movl $0x1, -0xc(%rax)
movl 0x18(%rsp), %ecx
movl %ecx, -0x8(%rax)
movl 0x18(%rsp), %edx
movq 0x28(%rsp), %rcx
addq $-0xc, %rcx
pushq $0x1
popq %rbx
movl 0x14(%rsp), %edi
movl %ebx, %esi
callq 0x3320
testl %eax, %eax
jne 0x4d47
movq 0x28(%rsp), %rsi
cmpq 0x30(%rsp), %rsi
je 0x45a2
andl $0x0, 0x8(%rsi)
andq $0x0, (%rsi)
addq $0xc, 0x28(%rsp)
jmp 0x45ac
leaq 0x20(%rsp), %rdi
callq 0xb346
movq 0x28(%rsp), %rax
movl $0x4, -0xc(%rax)
movl 0x10(%rsp), %ecx
movl %ecx, -0x8(%rax)
movl 0x10(%rsp), %edx
movq 0x28(%rsp), %rcx
addq $-0xc, %rcx
pushq $0x1
popq %rbx
movl 0x14(%rsp), %edi
movl %ebx, %esi
callq 0x3320
testl %eax, %eax
jne 0x4dab
pushq $0xc
popq %r14
xorl %ebx, %ebx
movq %r15, 0x140(%rsp)
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rax
subq %rsi, %rax
cqto
idivq %r14
movl 0x14(%rsp), %edi
movl %eax, %edx
movl $0x3e8, %ecx            # imm = 0x3E8
callq 0x3140
movl %eax, %ecx
testl %eax, %eax
js 0x4944
movl %ecx, %r13d
movq 0x28(%rsp), %rax
subq 0x20(%rsp), %rax
cqto
idivq %r14
cmpq %r13, %rax
jb 0x4975
testl %ecx, %ecx
je 0x4998
xorl %ebp, %ebp
xorl %r12d, %r12d
pushq $0x1
popq %rax
movl %eax, 0x3c(%rsp)
movq %r13, 0x138(%rsp)
movq 0x20(%rsp), %rcx
movq 0x28(%rsp), %rax
subq %rcx, %rax
cqto
idivq %r14
cmpq %r12, %rax
jbe 0x5046
movl 0x4(%rcx,%rbp), %eax
movl 0x18(%rsp), %edi
cmpl %edi, %eax
jne 0x4722
testb $0x10, (%rcx,%rbp)
jne 0x477e
movl $0x100, %edx            # imm = 0x100
leaq 0x200(%rsp), %rsi
callq 0x3350
testq %rax, %rax
js 0x4827
je 0x47f1
leaq 0x128(%rsp), %rcx
movq %rcx, 0x118(%rsp)
leaq (%rsp,%rax), %rdx
addq $0x200, %rdx            # imm = 0x200
leaq 0x118(%rsp), %rdi
leaq 0x200(%rsp), %rsi
callq 0xb06e
movq 0x118(%rsp), %rsi
movq 0x120(%rsp), %rdx
leaq 0xc8(%rsp), %rdi
callq 0x30a0
movq 0x118(%rsp), %rdi
leaq 0x128(%rsp), %rax
cmpq %rax, %rdi
je 0x471b
movq 0x128(%rsp), %rsi
incq %rsi
callq 0x3240
xorl %eax, %eax
jmp 0x4805
movl 0x10(%rsp), %edi
cmpl %edi, %eax
jne 0x4812
movq 0x100(%r15), %rsi
addq %rbx, %rsi
movq 0x108(%r15), %rdx
movq %rbx, %r13
subq %rbx, %rdx
callq 0x30c0
movq %rax, %rbx
movq 0x140(%rsp), %r15
movq 0x108(%r15), %rax
movq %rax, %rcx
movq %r13, %r14
subq %r13, %rcx
cmpq %rcx, %rbx
jne 0x4875
addq %rbx, %r14
movb $0x1, %r15b
cmpq %rax, %r14
jae 0x478b
movq %r14, %r13
jmp 0x47d0
movl $0x0, 0x3c(%rsp)
jmp 0x4812
movq 0x20(%rsp), %rcx
movq 0x28(%rsp), %rax
subq %rcx, %rax
cqto
pushq $0xc
popq %rsi
idivq %rsi
cmpq %r12, %rax
jbe 0x505a
movq %r14, %r13
movl 0x10(%rsp), %edx
addq %rbp, %rcx
movl 0x14(%rsp), %edi
pushq $0x2
popq %rsi
callq 0x3320
testl %eax, %eax
jne 0x48d8
movl 0x10(%rsp), %edi
callq 0x34d0
testb %r15b, %r15b
movq 0x140(%rsp), %r15
pushq $0xc
popq %r14
movq %r13, %rbx
movq 0x138(%rsp), %r13
jne 0x4812
jmp 0x4912
movl $0x0, 0x3c(%rsp)
movl 0x18(%rsp), %edi
callq 0x34d0
pushq $0xb
popq %rax
testl %eax, %eax
je 0x4812
cmpl $0xb, %eax
jne 0x4915
incq %r12
addq $0xc, %rbp
cmpq %r12, %r13
jne 0x4653
jmp 0x490e
movq 0xb7a2(%rip), %rax      # 0xffd0
movq (%rax), %rax
movq %rax, 0x108(%rsp)
callq 0x3030
movq %rbx, %r13
movl (%rax), %ebx
movl %ebx, %edi
callq 0x30b0
movq 0x108(%rsp), %rdi
leaq 0x83b6(%rip), %rsi      # 0xcc0f
movl %ebx, %edx
movq %r13, %rbx
movq 0x138(%rsp), %r13
movq %rax, %rcx
xorl %eax, %eax
callq 0x3340
pushq $0x1
popq %rax
jmp 0x4805
movq 0xb754(%rip), %rax      # 0xffd0
movq (%rax), %rax
movq %rax, 0x108(%rsp)
callq 0x3030
movl (%rax), %edi
movl %edi, 0x114(%rsp)
callq 0x30b0
movq 0x108(%r15), %r9
subq %r14, %r9
xorl %r15d, %r15d
movq 0x108(%rsp), %rdi
leaq 0x8377(%rip), %rsi      # 0xcc2d
movl 0x114(%rsp), %edx
movq %rax, %rcx
movq %rbx, %r8
xorl %eax, %eax
callq 0x3340
movl 0x10(%rsp), %edi
callq 0x34d0
jmp 0x47d0
movq 0xb6f1(%rip), %rax      # 0xffd0
movq (%rax), %r14
callq 0x3030
movl (%rax), %ebx
movl %ebx, %edi
callq 0x30b0
xorl %r15d, %r15d
movq %r14, %rdi
leaq 0x835d(%rip), %rsi      # 0xcc5a
movl %ebx, %edx
movq %rax, %rcx
xorl %eax, %eax
callq 0x3340
jmp 0x47d0
pushq $0x9
jmp 0x4914
pushq $0x1
popq %rax
cmpl $0x9, %eax
movl $0x0, %ecx
cmovel %ecx, %eax
cmpl $0x0, 0x3c(%rsp)
sete %bpl
cmpl $0x7, %eax
je 0x4936
testl %eax, %eax
jne 0x4e17
testb %bpl, %bpl
je 0x45f0
jmp 0x4ade
movq 0xb685(%rip), %rax      # 0xffd0
movq %rbx, %r13
movq (%rax), %rbx
callq 0x3030
movl (%rax), %r12d
movl %r12d, %edi
callq 0x30b0
xorl %ebp, %ebp
movq %rbx, %rdi
movq %r13, %rbx
leaq 0x8232(%rip), %rsi      # 0xcba2
movl %r12d, %edx
jmp 0x498a
movq 0xb654(%rip), %rdx      # 0xffd0
movq (%rdx), %rdi
xorl %ebp, %ebp
leaq 0x8234(%rip), %rsi      # 0xcbbc
movl %ecx, %edx
movq %rax, %rcx
xorl %eax, %eax
callq 0x3340
pushq $0x1
jmp 0x49bb
movq 0xb631(%rip), %rax      # 0xffd0
movq (%rax), %rdi
xorl %ebp, %ebp
leaq 0x823c(%rip), %rsi      # 0xcbe7
movl 0x84(%rsp), %edx
xorl %eax, %eax
callq 0x3340
pushq $0x7
popq %rax
jmp 0x4929
movq 0xb608(%rip), %rax      # 0xffd0
movq (%rax), %rdi
movq 0x40(%rsp), %rdx
leaq 0x7ed4(%rip), %rsi      # 0xc8ab
xorl %eax, %eax
callq 0x3340
pushq $0x1
popq %rbx
jmp 0x4f65
movq 0xb5e3(%rip), %rax      # 0xffd0
movq (%rax), %rdi
movq 0x40(%rsp), %rdx
leaq 0x7ecd(%rip), %rsi      # 0xc8c9
jmp 0x4a14
movq 0xb5cb(%rip), %rax      # 0xffd0
movq (%rax), %rdi
movq 0x40(%rsp), %rdx
leaq 0x7ed3(%rip), %rsi      # 0xc8e7
xorl %eax, %eax
callq 0x3340
pushq $0x1
popq %rbx
jmp 0x4f44
movq 0xb5a6(%rip), %rax      # 0xffd0
movq (%rax), %rdi
movq 0x168(%rsp), %rdx
leaq 0x7ecb(%rip), %rsi      # 0xc907
xorl %eax, %eax
callq 0x3340
pushq $0x1
popq %rbx
jmp 0x4f23
movq 0xb57e(%rip), %rax      # 0xffd0
movq (%rax), %rdi
movq 0x88(%rsp), %rdx
leaq 0x7ec3(%rip), %rsi      # 0xc927
xorl %eax, %eax
callq 0x3340
pushq $0x1
popq %rbx
jmp 0x4efe
movq 0xb556(%rip), %rax      # 0xffd0
movq (%rax), %rdi
movq 0x88(%rsp), %rdx
leaq 0x7ebc(%rip), %rsi      # 0xc948
jmp 0x4aa7
movq 0xb53b(%rip), %rax      # 0xffd0
movq (%rax), %rdi
movq 0x88(%rsp), %rdx
leaq 0x7ec2(%rip), %rsi      # 0xc969
xorl %eax, %eax
callq 0x3340
pushq $0x1
popq %rbx
jmp 0x4edd
movq 0xb513(%rip), %rax      # 0xffd0
movq (%rax), %rdi
movq 0x148(%rsp), %rdx
leaq 0x7eb9(%rip), %rsi      # 0xc988
xorl %eax, %eax
callq 0x3340
pushq $0x1
popq %rbx
jmp 0x4ebc
leaq 0x118(%rsp), %rsi
movl 0x84(%rsp), %r15d
movl %r15d, %edi
xorl %edx, %edx
callq 0x31c0
movl %eax, %ebx
cmpl %r15d, %eax
jne 0x4de3
leaq 0x200(%rsp), %rdi
movl $0x400, %ebx            # imm = 0x400
pushq $0x14
popq %rcx
movl $0x400, %esi            # imm = 0x400
movq 0x1c8(%rsp), %rdx
callq 0xaf20
testl %eax, %eax
leaq 0x50(%rsp), %r14
leaq 0xd8(%rsp), %r15
jne 0x4ff1
leaq 0x200(%rsp), %rdi
callq 0x3100
leaq (%rsp,%rax), %rdi
addq $0x200, %rdi            # imm = 0x200
subq %rax, %rbx
leaq 0x76cc(%rip), %rdx      # 0xc228
movq %rbx, %rsi
xorl %eax, %eax
callq 0x33e0
cmpl $0x0, 0x118(%rsp)
jne 0x500f
leaq 0xc8(%rsp), %rdi
leaq 0x200(%rsp), %rsi
callq 0x3090
testl %eax, %eax
jne 0x500f
movq 0xb438(%rip), %rax      # 0xffd0
movq (%rax), %rdi
leaq 0x812d(%rip), %rsi      # 0xcccf
leaq 0x8142(%rip), %rdx      # 0xcceb
xorl %ebx, %ebx
leaq 0x200(%rsp), %rcx
xorl %eax, %eax
callq 0x3340
jmp 0x4e27
movq 0xb40a(%rip), %rax      # 0xffd0
movq (%rax), %rcx
leaq 0x7e5e(%rip), %rdi      # 0xca2e
pushq $0x17
jmp 0x4fa3
movq 0xb3f2(%rip), %rax      # 0xffd0
movq (%rax), %rbx
callq 0x3030
movl (%rax), %ebp
movl %ebp, %edi
callq 0x30b0
leaq 0x7ec1(%rip), %rsi      # 0xcab7
jmp 0x4c38
movq 0xb3d1(%rip), %rax      # 0xffd0
movq (%rax), %rbx
callq 0x3030
movl (%rax), %ebp
movl %ebp, %edi
callq 0x30b0
leaq 0x7eb4(%rip), %rsi      # 0xcacb
jmp 0x4c38
movq 0xb3b0(%rip), %rax      # 0xffd0
movq (%rax), %rbx
callq 0x3030
movl (%rax), %ebp
movl %ebp, %edi
callq 0x30b0
leaq 0x7eba(%rip), %rsi      # 0xcaf2
movq %rbx, %rdi
movl %ebp, %edx
movq %rax, %rcx
xorl %eax, %eax
callq 0x3340
pushq $0x1
popq %rbx
jmp 0x4e5b
movl 0x18(%rsp), %edi
callq 0x34d0
movl 0x1c(%rsp), %edi
pushq $0x1
popq %rsi
callq 0x3200
movl 0x1c(%rsp), %edi
pushq $0x2
popq %rsi
callq 0x3200
movl 0x1c(%rsp), %edi
callq 0x34d0
movl 0x10(%rsp), %edi
callq 0x34d0
movl 0xc(%rsp), %edi
xorl %esi, %esi
callq 0x3200
movl 0xc(%rsp), %edi
callq 0x34d0
movq 0x60(%rsp), %rdx
leaq 0x7e3d(%rip), %rdi      # 0xcadf
leaq 0x1d0(%rsp), %rsi
callq 0x34b0
movq %r14, %r15
movq 0xb317(%rip), %r14      # 0xffd0
movq (%r14), %rbx
callq 0x3030
movl (%rax), %ebp
movl %ebp, %edi
callq 0x30b0
leaq 0x7e46(%rip), %rsi      # 0xcb17
movq %rbx, %rdi
movl %ebp, %edx
movq %rax, %rcx
xorl %eax, %eax
callq 0x3340
movq (%r14), %rdi
movq %r15, %r14
callq 0x32a0
pushq $0x1
popq %rdi
callq 0x3410
movq 0xb2d6(%rip), %rax      # 0xffd0
movq (%rax), %rbx
callq 0x3030
movl (%rax), %ebp
movl %ebp, %edi
callq 0x30b0
leaq 0x7e2d(%rip), %rsi      # 0xcb3f
movq %rbx, %rdi
movl %ebp, %edx
movq %r12, %r15
movq %rax, %rcx
xorl %eax, %eax
callq 0x3340
pushq $0x1
popq %rbx
jmp 0x4e3e
movq 0xb29d(%rip), %rax      # 0xffd0
movq (%rax), %rdi
movq 0xa8(%rsp), %rdx
leaq 0x7c60(%rip), %rsi      # 0xc9a5
jmp 0x4d9c
movq 0xb282(%rip), %rax      # 0xffd0
movq %r14, %r15
movq (%rax), %r14
callq 0x3030
movl (%rax), %ebp
movl %ebp, %edi
callq 0x30b0
leaq 0x7df3(%rip), %rsi      # 0xcb5c
movq %r14, %rdi
movq %r15, %r14
movl %ebp, %edx
movq %r12, %r15
movq %rax, %rcx
xorl %eax, %eax
callq 0x3340
jmp 0x4e27
movq 0xb246(%rip), %rax      # 0xffd0
movq (%rax), %rdi
movq 0xa8(%rsp), %rdx
leaq 0x7c25(%rip), %rsi      # 0xc9c1
xorl %eax, %eax
callq 0x3340
pushq $0x1
popq %rbx
jmp 0x4e97
movq 0xb21e(%rip), %rax      # 0xffd0
movq (%rax), %r14
callq 0x3030
movl (%rax), %ebp
movl %ebp, %edi
callq 0x30b0
leaq 0x7db5(%rip), %rsi      # 0xcb7f
movq %r14, %rdi
movl %ebp, %edx
movq %r12, %r15
movq %rax, %rcx
xorl %eax, %eax
callq 0x3340
leaq 0x50(%rsp), %r14
jmp 0x4e27
movq 0xb1e6(%rip), %rax      # 0xffd0
movq (%rax), %r14
callq 0x3030
movl (%rax), %ebp
movl %ebp, %edi
callq 0x30b0
leaq 0x7e7b(%rip), %rsi      # 0xcc7d
movq %r14, %rdi
movl %ebx, %edx
movl %r15d, %ecx
movl %ebp, %r8d
movq %rax, %r9
xorl %eax, %eax
callq 0x3340
pushq $0x1
popq %rbx
leaq 0x50(%rsp), %r14
leaq 0xd8(%rsp), %r15
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x4e3e
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x3240
movq 0xc8(%rsp), %rdi
cmpq %r15, %rdi
je 0x4e5b
movq 0xd8(%rsp), %rsi
incq %rsi
callq 0x3240
movq 0x60(%rsp), %rdi
testq %rdi, %rdi
je 0x4e72
movq 0x70(%rsp), %rsi
subq %rdi, %rsi
callq 0x3240
movq 0xe8(%rsp), %rdi
leaq 0xf8(%rsp), %rax
cmpq %rax, %rdi
je 0x4e97
movq 0xf8(%rsp), %rsi
incq %rsi
callq 0x3240
movq 0xa8(%rsp), %rdi
leaq 0xb8(%rsp), %rax
cmpq %rax, %rdi
je 0x4ebc
movq 0xb8(%rsp), %rsi
incq %rsi
callq 0x3240
leaq 0x158(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4edd
movq 0x158(%rsp), %rsi
incq %rsi
callq 0x3240
leaq 0x1b8(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4efe
movq 0x1b8(%rsp), %rsi
incq %rsi
callq 0x3240
movq 0x88(%rsp), %rdi
leaq 0x98(%rsp), %rax
cmpq %rax, %rdi
je 0x4f23
movq 0x98(%rsp), %rsi
incq %rsi
callq 0x3240
leaq 0x178(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4f44
movq 0x178(%rsp), %rsi
incq %rsi
callq 0x3240
leaq 0x198(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4f65
movq 0x198(%rsp), %rsi
incq %rsi
callq 0x3240
movq 0x40(%rsp), %rdi
cmpq %r14, %rdi
je 0x4f7c
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x3240
movl %ebx, %eax
addq $0x608, %rsp            # imm = 0x608
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xb039(%rip), %rax      # 0xffd0
movq (%rax), %rcx
leaq 0x7a3b(%rip), %rdi      # 0xc9dc
pushq $0x1e
popq %rsi
pushq $0x1
popq %rdx
callq 0x34c0
jmp 0x4fe9
movq 0xb01b(%rip), %rax      # 0xffd0
movq (%rax), %rdi
movq 0xe8(%rsp), %rdx
leaq 0x7a34(%rip), %rsi      # 0xc9fb
jmp 0x4fe2
movq 0xb000(%rip), %rax      # 0xffd0
movq (%rax), %rdi
movq 0xe8(%rsp), %rdx
leaq 0x7a33(%rip), %rsi      # 0xca15
xorl %eax, %eax
callq 0x3340
pushq $0x1
popq %rbx
jmp 0x4e72
movq 0xafd8(%rip), %rax      # 0xffd0
movq (%rax), %rcx
leaq 0x749d(%rip), %rdi      # 0xc49f
pushq $0x10
popq %rsi
pushq $0x1
popq %rdx
callq 0x34c0
jmp 0x503e
movq 0xafba(%rip), %rbx      # 0xffd0
movq (%rbx), %rdi
movl 0x118(%rsp), %edx
leaq 0x7c82(%rip), %rsi      # 0xcca9
xorl %eax, %eax
callq 0x3340
movq (%rbx), %rsi
movq 0xc8(%rsp), %rdi
callq 0x3270
pushq $0x1
popq %rbx
jmp 0x4e27
leaq 0x73f6(%rip), %rdi      # 0xc443
movq %r12, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x3390
leaq 0x73e2(%rip), %rdi      # 0xc443
movq %r12, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x3390
jmp 0x5074
jmp 0x5074
jmp 0x5074
movq %rax, %rbx
jmp 0x51ad
movq %rax, %rbx
jmp 0x515d
jmp 0x5088
jmp 0x5088
movq %rax, %rbx
jmp 0x51d2
jmp 0x5193
jmp 0x5193
jmp 0x5193
jmp 0x5193
jmp 0x5193
jmp 0x5193
jmp 0x5193
jmp 0x5193
jmp 0x5193
jmp 0x5193
jmp 0x5193
jmp 0x5193
jmp 0x5193
jmp 0x514d
jmp 0x50d5
movq %rax, %rbx
jmp 0x51f7
jmp 0x50e5
jmp 0x50e5
jmp 0x50e5
jmp 0x50e5
movq %rax, %rbx
jmp 0x5218
movq %rax, %rbx
jmp 0x5239
jmp 0x50f7
movq %rax, %rbx
jmp 0x525e
jmp 0x5107
jmp 0x5107
jmp 0x5107
jmp 0x5107
movq %rax, %rbx
jmp 0x527f
movq %rax, %rbx
jmp 0x52a0
jmp 0x5193
jmp 0x514d
jmp 0x514d
movq %rax, %rbx
movq 0x118(%rsp), %rdi
leaq 0x128(%rsp), %rax
cmpq %rax, %rdi
je 0x5150
movq 0x128(%rsp), %rsi
incq %rsi
callq 0x3240
jmp 0x5150
jmp 0x514d
jmp 0x514d
jmp 0x514d
movq %rax, %rbx
leaq 0x50(%rsp), %r14
leaq 0xd8(%rsp), %r12
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x5174
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x3240
movq 0xc8(%rsp), %rdi
cmpq %r12, %rdi
je 0x5196
movq 0xd8(%rsp), %rsi
incq %rsi
callq 0x3240
jmp 0x5196
movq %rax, %rbx
movq 0x60(%rsp), %rdi
testq %rdi, %rdi
je 0x51ad
movq 0x70(%rsp), %rsi
subq %rdi, %rsi
callq 0x3240
movq 0xe8(%rsp), %rdi
leaq 0xf8(%rsp), %rax
cmpq %rax, %rdi
je 0x51d2
movq 0xf8(%rsp), %rsi
incq %rsi
callq 0x3240
movq 0xa8(%rsp), %rdi
leaq 0xb8(%rsp), %rax
cmpq %rax, %rdi
je 0x51f7
movq 0xb8(%rsp), %rsi
incq %rsi
callq 0x3240
leaq 0x158(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5218
movq 0x158(%rsp), %rsi
incq %rsi
callq 0x3240
leaq 0x1b8(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5239
movq 0x1b8(%rsp), %rsi
incq %rsi
callq 0x3240
movq 0x88(%rsp), %rdi
leaq 0x98(%rsp), %rax
cmpq %rax, %rdi
je 0x525e
movq 0x98(%rsp), %rsi
incq %rsi
callq 0x3240
leaq 0x178(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x527f
movq 0x178(%rsp), %rsi
incq %rsi
callq 0x3240
leaq 0x198(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x52a0
movq 0x198(%rsp), %rsi
incq %rsi
callq 0x3240
movq 0x40(%rsp), %rdi
cmpq %r14, %rdi
je 0x52b7
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x3240
movq %rbx, %rdi
callq 0x3480