// File: /workspace/github_cpp_makefile_star2_O3/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 $0x5e8, %rsp            # imm = 0x5E8
movq %rcx, %r14
movq %rsi, %rbx
callq 0x3714
testl %eax, %eax
je 0x3994
pushq $0x1
popq %r12
movl %r12d, %eax
addq $0x5e8, %rsp            # imm = 0x5E8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x30(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq 0x40(%r14), %rsi
movq 0x48(%r14), %rdx
addq %rsi, %rdx
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0x6bb6
leaq 0x78e6(%rip), %rsi      # 0xb2a2
pushq $0x1
popq %rcx
movq %r15, %rdi
xorl %edx, %edx
callq 0x3470
cmpq $-0x1, %rax
jne 0x39f5
movq 0xb602(%rip), %rax      # 0xefd8
movq (%rax), %rdi
movq 0x20(%rsp), %rdx
leaq 0x7ec6(%rip), %rsi      # 0xb8ab
xorl %eax, %eax
callq 0x3340
pushq $0x1
popq %r12
jmp 0x47e2
movq %rax, %r15
leaq 0x1(%rax), %rdx
leaq 0x150(%rsp), %rdi
leaq 0x20(%rsp), %rsi
pushq $-0x1
popq %rcx
callq 0x3250
leaq 0x788c(%rip), %rsi      # 0xb2a4
leaq 0x150(%rsp), %rdi
pushq $0x1
popq %rcx
xorl %edx, %edx
callq 0x3470
cmpq $-0x1, %rax
jne 0x3a56
movq 0xb5a1(%rip), %rax      # 0xefd8
movq (%rax), %rdi
movq 0x20(%rsp), %rdx
leaq 0x7e83(%rip), %rsi      # 0xb8c9
xorl %eax, %eax
callq 0x3340
pushq $0x1
popq %r12
jmp 0x47c1
leaq 0x1e0(%rsp), %rdi
leaq 0x20(%rsp), %rsi
xorl %edx, %edx
movq %r15, %rcx
callq 0x3250
leaq 0x20(%rsp), %rdi
leaq 0x1e0(%rsp), %r15
movq %r15, %rsi
callq 0x32d0
movq (%r15), %rdi
leaq 0x1f0(%rsp), %r13
cmpq %r13, %rdi
je 0x3aa2
movq 0x1f0(%rsp), %rsi
incq %rsi
callq 0x3240
leaq 0x77fb(%rip), %rsi      # 0xb2a4
leaq 0x150(%rsp), %r15
pushq $0x1
popq %rcx
movq %r15, %rdi
xorl %edx, %edx
callq 0x3470
leaq 0x1e0(%rsp), %rdi
movq %r15, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x3250
leaq 0x150(%rsp), %rdi
leaq 0x1e0(%rsp), %r15
movq %r15, %rsi
callq 0x32d0
movq (%r15), %rdi
cmpq %r13, %rdi
je 0x3b03
movq 0x1f0(%rsp), %rsi
incq %rsi
callq 0x3240
leaq 0x1e0(%rsp), %rdi
leaq 0x20(%rsp), %rsi
pushq $0x7
popq %rcx
xorl %edx, %edx
callq 0x3250
leaq 0x7731(%rip), %rsi      # 0xb252
leaq 0x1e0(%rsp), %r15
movq %r15, %rdi
callq 0x3090
movl %eax, %ebp
movq (%r15), %rdi
cmpq %r13, %rdi
je 0x3b4b
movq 0x1f0(%rsp), %rsi
incq %rsi
callq 0x3240
testl %ebp, %ebp
jne 0x3bfe
leaq 0x1e0(%rsp), %rdi
leaq 0x20(%rsp), %rsi
pushq $0x7
popq %rdx
pushq $-0x1
popq %rcx
leaq 0x30(%rsp), %rbp
callq 0x3250
leaq 0x20(%rsp), %rdi
leaq 0x1e0(%rsp), %r15
movq %r15, %rsi
callq 0x32d0
movq (%r15), %rdi
cmpq %r13, %rdi
je 0x3b9d
movq 0x1f0(%rsp), %rsi
incq %rsi
callq 0x3240
leaq 0x60(%r14), %rsi
leaq 0x80(%r14), %rdx
leaq 0x130(%rsp), %rdi
callq 0x6b5c
leaq 0x7d47(%rip), %rsi      # 0xb903
leaq 0x130(%rsp), %rdi
pushq $-0x1
popq %rdx
pushq $0x3
popq %rcx
callq 0x33f0
cmpq $-0x1, %rax
jne 0x3c29
movq 0xb3fc(%rip), %rax      # 0xefd8
movq (%rax), %rdi
movq 0x130(%rsp), %rdx
leaq 0x7d19(%rip), %rsi      # 0xb907
xorl %eax, %eax
callq 0x3340
pushq $0x1
popq %r12
jmp 0x47a0
movq 0xb3d3(%rip), %rax      # 0xefd8
movq (%rax), %rdi
movq 0x20(%rsp), %rdx
leaq 0x7cd3(%rip), %rsi      # 0xb8e7
xorl %eax, %eax
callq 0x3340
pushq $0x1
popq %r12
leaq 0x30(%rsp), %rbp
jmp 0x47c1
incq %rax
leaq 0x1e0(%rsp), %rdi
leaq 0x130(%rsp), %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x3250
leaq 0x130(%rsp), %rdi
leaq 0x1e0(%rsp), %r15
movq %r15, %rsi
callq 0x32d0
movq (%r15), %rdi
cmpq %r13, %rdi
je 0x3c76
movq 0x1f0(%rsp), %rsi
incq %rsi
callq 0x3240
leaq 0xb0(%rsp), %rax
movq %rax, -0x10(%rax)
movq 0xa0(%r14), %rsi
movq 0xa8(%r14), %rdx
addq %rsi, %rdx
leaq 0xa0(%rsp), %rdi
callq 0x6bb6
leaq 0x75fb(%rip), %rsi      # 0xb2a2
leaq 0xa0(%rsp), %rdi
pushq $0x1
popq %rcx
xorl %edx, %edx
callq 0x3470
cmpq $-0x1, %rax
jne 0x3ce8
movq 0xb312(%rip), %rax      # 0xefd8
movq (%rax), %rdi
movq 0xa0(%rsp), %rdx
leaq 0x7c4f(%rip), %rsi      # 0xb927
xorl %eax, %eax
callq 0x3340
pushq $0x1
popq %r12
jmp 0x477b
movq %rax, %r15
leaq 0x1(%rax), %rdx
leaq 0x190(%rsp), %rdi
leaq 0xa0(%rsp), %rsi
pushq $-0x1
popq %rcx
callq 0x3250
leaq 0x7596(%rip), %rsi      # 0xb2a4
leaq 0xa0(%rsp), %rdi
pushq $0x1
popq %rcx
xorl %edx, %edx
callq 0x3470
cmpq $-0x1, %rax
jne 0x3d4f
movq 0xb2ab(%rip), %rax      # 0xefd8
movq (%rax), %rdi
movq 0xa0(%rsp), %rdx
leaq 0x7c09(%rip), %rsi      # 0xb948
xorl %eax, %eax
callq 0x3340
pushq $0x1
popq %r12
jmp 0x475a
leaq 0x1e0(%rsp), %rdi
leaq 0xa0(%rsp), %rsi
xorl %edx, %edx
movq %r15, %rcx
callq 0x3250
leaq 0xa0(%rsp), %rdi
leaq 0x1e0(%rsp), %r15
movq %r15, %rsi
callq 0x32d0
movq (%r15), %rdi
cmpq %r13, %rdi
je 0x3d99
movq 0x1f0(%rsp), %rsi
incq %rsi
callq 0x3240
leaq 0x7504(%rip), %rsi      # 0xb2a4
leaq 0x190(%rsp), %r12
pushq $0x1
popq %r15
movq %r12, %rdi
xorl %edx, %edx
movq %r15, %rcx
callq 0x3470
leaq 0x1e0(%rsp), %rdi
movq %r12, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x3250
leaq 0x190(%rsp), %rdi
leaq 0x1e0(%rsp), %r12
movq %r12, %rsi
callq 0x32d0
movq (%r12), %rdi
cmpq %r13, %rdi
je 0x3dff
movq 0x1f0(%rsp), %rsi
incq %rsi
callq 0x3240
leaq 0x1e0(%rsp), %rdi
leaq 0xa0(%rsp), %rsi
pushq $0xa
popq %rcx
xorl %edx, %edx
callq 0x3250
leaq 0x743a(%rip), %rsi      # 0xb25a
leaq 0x1e0(%rsp), %r12
movq %r12, %rdi
callq 0x3090
movl %eax, %ebp
movq (%r12), %rdi
cmpq %r13, %rdi
je 0x3e4b
movq 0x1f0(%rsp), %rsi
incq %rsi
callq 0x3240
testl %ebp, %ebp
jne 0x3f08
leaq 0x1e0(%rsp), %rdi
leaq 0xa0(%rsp), %rsi
pushq $0xa
popq %rdx
pushq $-0x1
popq %rcx
leaq 0x30(%rsp), %rbp
callq 0x3250
leaq 0xa0(%rsp), %rdi
leaq 0x1e0(%rsp), %r12
movq %r12, %rsi
callq 0x32d0
movq (%r12), %rdi
cmpq %r13, %rdi
je 0x3ea4
movq 0x1f0(%rsp), %rsi
incq %rsi
callq 0x3240
leaq 0xc0(%r14), %rsi
leaq 0xe0(%r14), %rdx
leaq 0x110(%rsp), %rdi
callq 0x6b5c
leaq 0x7a3d(%rip), %rsi      # 0xb903
leaq 0x110(%rsp), %rdi
pushq $-0x1
popq %rdx
pushq $0x3
popq %rcx
callq 0x33f0
cmpq $-0x1, %rax
jne 0x3f36
movq 0xb0f2(%rip), %rax      # 0xefd8
movq (%rax), %rdi
movq 0x110(%rsp), %rdx
leaq 0x7a90(%rip), %rsi      # 0xb988
xorl %eax, %eax
callq 0x3340
pushq $0x1
popq %r12
jmp 0x4739
movq 0xb0c9(%rip), %rax      # 0xefd8
movq (%rax), %rdi
movq 0xa0(%rsp), %rdx
leaq 0x7a48(%rip), %rsi      # 0xb969
xorl %eax, %eax
callq 0x3340
pushq $0x1
popq %r12
leaq 0x30(%rsp), %rbp
jmp 0x475a
incq %rax
leaq 0x1e0(%rsp), %rdi
leaq 0x110(%rsp), %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x3250
leaq 0x110(%rsp), %rdi
leaq 0x1e0(%rsp), %r12
movq %r12, %rsi
callq 0x32d0
movq (%r12), %rdi
cmpq %r13, %rdi
je 0x3f84
movq 0x1f0(%rsp), %rsi
incq %rsi
callq 0x3240
leaq 0x70(%rsp), %rax
movq %rax, -0x10(%rax)
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
addq %rsi, %rdx
leaq 0x60(%rsp), %rdi
callq 0x6bb6
cmpq $0x0, 0x68(%rsp)
jne 0x4318
leaq 0xd0(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0x8(%r14), %r8
movq 0x10(%r14), %rdx
movq %rdx, %rax
subq %r8, %rax
jne 0x43e8
xorl %eax, %eax
xorl %r15d, %r15d
cmpq %rax, %r15
jae 0x4404
xorps %xmm0, %xmm0
movaps %xmm0, 0x80(%rsp)
andq $0x0, 0x90(%rsp)
leaq 0x7a47(%rip), %rsi      # 0xba46
leaq 0x1e0(%rsp), %rdi
leaq 0x20(%rsp), %rdx
callq 0x9c47
leaq 0x20(%rsp), %rdi
leaq 0x1e0(%rsp), %r15
movq %r15, %rsi
callq 0x32d0
movq (%r15), %rdi
cmpq %r13, %rdi
je 0x403e
movq 0x1f0(%rsp), %rsi
incq %rsi
callq 0x3240
movq 0x20(%rsp), %rax
leaq 0x1e0(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x80(%rsp), %rdi
callq 0x9d66
leaq 0x79f5(%rip), %rsi      # 0xba57
leaq 0x1e0(%rsp), %rdi
leaq 0x150(%rsp), %rdx
callq 0x9c47
leaq 0x150(%rsp), %rdi
leaq 0x1e0(%rsp), %r15
movq %r15, %rsi
callq 0x32d0
movq (%r15), %rdi
cmpq %r13, %rdi
je 0x40a7
movq 0x1f0(%rsp), %rsi
incq %rsi
callq 0x3240
movq 0x150(%rsp), %rax
leaq 0x1e0(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x80(%rsp), %rdi
callq 0x9d66
leaq 0x799b(%rip), %rsi      # 0xba69
leaq 0x1e0(%rsp), %rdi
leaq 0x130(%rsp), %rdx
callq 0x9c47
leaq 0x130(%rsp), %rdi
leaq 0x1e0(%rsp), %r15
movq %r15, %rsi
callq 0x32d0
movq (%r15), %rdi
cmpq %r13, %rdi
je 0x4113
movq 0x1f0(%rsp), %rsi
incq %rsi
callq 0x3240
movq 0x130(%rsp), %rax
leaq 0x1e0(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x80(%rsp), %rdi
callq 0x9d66
leaq 0x7940(%rip), %rsi      # 0xba7a
leaq 0x1e0(%rsp), %rdi
leaq 0xa0(%rsp), %rdx
callq 0x9c47
leaq 0xa0(%rsp), %rdi
leaq 0x1e0(%rsp), %r15
movq %r15, %rsi
callq 0x32d0
movq (%r15), %rdi
cmpq %r13, %rdi
je 0x417f
movq 0x1f0(%rsp), %rsi
incq %rsi
callq 0x3240
movq 0xa0(%rsp), %rax
leaq 0x1e0(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x80(%rsp), %rdi
callq 0x9d66
leaq 0x78e8(%rip), %rsi      # 0xba8e
leaq 0x1e0(%rsp), %rdi
leaq 0x190(%rsp), %rdx
callq 0x9c47
leaq 0x190(%rsp), %rdi
leaq 0x1e0(%rsp), %r15
movq %r15, %rsi
callq 0x32d0
movq (%r15), %rdi
cmpq %r13, %rdi
je 0x41eb
movq 0x1f0(%rsp), %rsi
incq %rsi
callq 0x3240
movq 0x190(%rsp), %rax
leaq 0x1e0(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x80(%rsp), %rdi
callq 0x9d66
leaq 0x7891(%rip), %rsi      # 0xbaa3
leaq 0x1e0(%rsp), %rdi
leaq 0x110(%rsp), %rdx
callq 0x9c47
leaq 0x110(%rsp), %rdi
leaq 0x1e0(%rsp), %r15
movq %r15, %rsi
callq 0x32d0
movq (%r15), %rdi
cmpq %r13, %rdi
je 0x4257
movq 0x1f0(%rsp), %rsi
incq %rsi
callq 0x3240
movq 0x110(%rsp), %rax
leaq 0x1e0(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x80(%rsp), %rdi
callq 0x9d66
movq 0xad62(%rip), %rax      # 0xefe0
movq (%rax), %r15
movq (%r15), %rax
testq %rax, %rax
je 0x42c9
leaq 0x80(%rsp), %r12
movq 0x88(%rsp), %rsi
cmpq 0x90(%rsp), %rsi
je 0x42b1
movq %rax, (%rsi)
addq $0x8, 0x88(%rsp)
jmp 0x42bc
movq %r12, %rdi
movq %r15, %rdx
callq 0x9eda
movq 0x8(%r15), %rax
addq $0x8, %r15
testq %rax, %rax
jne 0x4291
leaq 0x1e0(%rsp), %rsi
andq $0x0, (%rsi)
leaq 0x80(%rsp), %rdi
callq 0x9d66
leaq 0x18(%rsp), %rdi
callq 0x3310
testl %eax, %eax
jns 0x45a5
movq 0xacdd(%rip), %rax      # 0xefd8
movq (%rax), %rbx
callq 0x3030
movl (%rax), %ebp
movl %ebp, %edi
callq 0x30b0
leaq 0x77a4(%rip), %rsi      # 0xbab7
jmp 0x469d
leaq 0x1e0(%rsp), %rdi
leaq 0x60(%rsp), %rsi
pushq $0x7
popq %rcx
xorl %edx, %edx
callq 0x3250
leaq 0x6f14(%rip), %rsi      # 0xb24a
leaq 0x1e0(%rsp), %r12
movq %r12, %rdi
callq 0x3090
movl %eax, %ebp
movq (%r12), %rdi
cmpq %r13, %rdi
je 0x4361
movq 0x1f0(%rsp), %rsi
incq %rsi
callq 0x3240
testl %ebp, %ebp
jne 0x4429
leaq 0x1e0(%rsp), %rdi
leaq 0x60(%rsp), %rsi
pushq $0x7
popq %rdx
pushq $-0x1
popq %rcx
callq 0x3250
leaq 0x60(%rsp), %rdi
leaq 0x1e0(%rsp), %r12
movq %r12, %rsi
callq 0x32d0
movq (%r12), %rdi
cmpq %r13, %rdi
je 0x43af
movq 0x1f0(%rsp), %rsi
incq %rsi
callq 0x3240
leaq 0x754d(%rip), %rsi      # 0xb903
leaq 0x60(%rsp), %rdi
pushq $-0x1
popq %rdx
pushq $0x3
popq %rcx
callq 0x33f0
cmpq $-0x1, %rax
jne 0x4553
movq 0xac01(%rip), %rax      # 0xefd8
movq (%rax), %rdi
movq 0x60(%rsp), %rdx
leaq 0x75db(%rip), %rsi      # 0xb9c1
jmp 0x443f
leaq 0x1(%r8), %rcx
notq %r8
addq %rdx, %r8
cmpb $0x0, -0x1(%rcx)
je 0x4459
incq %rcx
incq %r15
addq $-0x1, %r8
jb 0x43f2
movq 0xabcd(%rip), %rax      # 0xefd8
movq (%rax), %rcx
leaq 0x7619(%rip), %rdi      # 0xba2e
pushq $0x17
popq %rsi
pushq $0x1
popq %rdx
callq 0x34c0
pushq $0x1
popq %r12
jmp 0x46f8
movq 0xaba8(%rip), %rax      # 0xefd8
movq (%rax), %rdi
movq 0x60(%rsp), %rdx
leaq 0x7566(%rip), %rsi      # 0xb9a5
xorl %eax, %eax
callq 0x3340
pushq $0x1
popq %r12
leaq 0x30(%rsp), %rbp
leaq 0x70(%rsp), %rbx
jmp 0x4722
cmpq %rax, %r15
jae 0x45d7
leaq 0xc0(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x33a0
leaq 0x1e0(%rsp), %rdi
leaq 0xc0(%rsp), %rsi
pushq $0x5
popq %rcx
xorl %edx, %edx
callq 0x3250
leaq 0x6cec(%rip), %rsi      # 0xb180
leaq 0x1e0(%rsp), %r15
movq %r15, %rdi
callq 0x3090
movl %eax, %ebp
movq (%r15), %rdi
cmpq %r13, %rdi
je 0x44be
movq 0x1f0(%rsp), %rsi
incq %rsi
callq 0x3240
testl %ebp, %ebp
jne 0x46cf
leaq 0x1e0(%rsp), %rdi
leaq 0xc0(%rsp), %rsi
pushq $0x5
popq %rdx
pushq $-0x1
popq %rcx
callq 0x3250
leaq 0xc0(%rsp), %rdi
leaq 0x1e0(%rsp), %r15
movq %r15, %rsi
callq 0x32d0
movq (%r15), %rdi
cmpq %r13, %rdi
je 0x4511
movq 0x1f0(%rsp), %rsi
incq %rsi
callq 0x3240
leaq 0x73eb(%rip), %rsi      # 0xb903
leaq 0xc0(%rsp), %rdi
pushq $-0x1
popq %rdx
pushq $0x3
popq %rcx
callq 0x33f0
cmpq $-0x1, %rax
jne 0x48a9
movq 0xaa9c(%rip), %rax      # 0xefd8
movq (%rax), %rdi
movq 0xc0(%rsp), %rdx
leaq 0x74c7(%rip), %rsi      # 0xba15
jmp 0x46e8
incq %rax
leaq 0x1e0(%rsp), %rdi
leaq 0x60(%rsp), %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x3250
leaq 0x60(%rsp), %rdi
leaq 0x1e0(%rsp), %r12
movq %r12, %rsi
callq 0x32d0
movq (%r12), %rdi
cmpq %r13, %rdi
je 0x459b
movq 0x1f0(%rsp), %rsi
incq %rsi
callq 0x3240
leaq 0x30(%rsp), %rbp
jmp 0x3fae
leaq 0x8(%rsp), %rdi
callq 0x3310
testl %eax, %eax
jns 0x45f8
movq 0xaa1e(%rip), %rax      # 0xefd8
movq (%rax), %rbx
callq 0x3030
movl (%rax), %ebp
movl %ebp, %edi
callq 0x30b0
leaq 0x74f9(%rip), %rsi      # 0xbacb
jmp 0x469d
movq 0xa9fa(%rip), %rax      # 0xefd8
movq (%rax), %rcx
leaq 0x73f4(%rip), %rdi      # 0xb9dc
pushq $0x1e
popq %rsi
pushq $0x1
popq %rdx
callq 0x34c0
jmp 0x46ef
leaq 0xbb2(%rip), %rsi       # 0x51b1
pushq $0xd
popq %rdi
callq 0x32c0
leaq 0x74d1(%rip), %rax      # 0xbadf
movq %rax, 0x1b0(%rsp)
leaq 0x74c6(%rip), %rax      # 0xbae3
movq %rax, 0x1b8(%rsp)
movq 0xc0(%rsp), %rax
movq %rax, 0x1c0(%rsp)
andq $0x0, 0x1d8(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x1c8(%rsp)
cmpq $0x0, 0x68(%rsp)
je 0x466d
leaq 0x7497(%rip), %rax      # 0xbaef
movq %rax, 0x1c8(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x1d0(%rsp)
callq 0x3060
movl %eax, 0x14(%rsp)
testl %eax, %eax
jns 0x4802
movq 0xa953(%rip), %rax      # 0xefd8
movq (%rax), %rbx
callq 0x3030
movl (%rax), %ebp
movl %ebp, %edi
callq 0x30b0
leaq 0x7455(%rip), %rsi      # 0xbaf2
movq %rbx, %rdi
movl %ebp, %edx
movq %rax, %rcx
xorl %eax, %eax
callq 0x3340
pushq $0x1
popq %r12
movq 0x80(%rsp), %rdi
testq %rdi, %rdi
je 0x46f3
movq 0x90(%rsp), %rsi
subq %rdi, %rsi
callq 0x3240
jmp 0x46f3
movq 0xa902(%rip), %rax      # 0xefd8
movq (%rax), %rdi
movq 0xc0(%rsp), %rdx
leaq 0x7313(%rip), %rsi      # 0xb9fb
xorl %eax, %eax
callq 0x3340
pushq $0x1
popq %r12
leaq 0x30(%rsp), %rbp
leaq 0x70(%rsp), %rbx
leaq 0xd0(%rsp), %rax
movq 0xc0(%rsp), %rdi
cmpq %rax, %rdi
je 0x4722
movq 0xd0(%rsp), %rsi
incq %rsi
callq 0x3240
movq 0x60(%rsp), %rdi
cmpq %rbx, %rdi
je 0x4739
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x3240
leaq 0x120(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x475a
movq 0x120(%rsp), %rsi
incq %rsi
callq 0x3240
leaq 0x1a0(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x477b
movq 0x1a0(%rsp), %rsi
incq %rsi
callq 0x3240
movq 0xa0(%rsp), %rdi
leaq 0xb0(%rsp), %rax
cmpq %rax, %rdi
je 0x47a0
movq 0xb0(%rsp), %rsi
incq %rsi
callq 0x3240
leaq 0x140(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x47c1
movq 0x140(%rsp), %rsi
incq %rsi
callq 0x3240
leaq 0x160(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x47e2
movq 0x160(%rsp), %rsi
incq %rsi
callq 0x3240
movq 0x20(%rsp), %rdi
cmpq %rbp, %rdi
je 0x397f
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x3240
jmp 0x397f
jne 0x490a
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 0xc(%rsp), %edi
callq 0x34d0
movl 0x8(%rsp), %edi
xorl %esi, %esi
callq 0x3200
movl 0x8(%rsp), %edi
callq 0x34d0
movq 0x80(%rsp), %rdx
leaq 0x7281(%rip), %rdi      # 0xbadf
leaq 0x1b0(%rsp), %rsi
callq 0x34b0
movq 0xa766(%rip), %r14      # 0xefd8
movq (%r14), %rbx
callq 0x3030
movl (%rax), %ebp
movl %ebp, %edi
callq 0x30b0
leaq 0x728d(%rip), %rsi      # 0xbb17
movq %rbx, %rdi
movl %ebp, %edx
movq %rax, %rcx
xorl %eax, %eax
callq 0x3340
movq (%r14), %rdi
callq 0x32a0
pushq $0x1
popq %rdi
callq 0x3410
movq %rax, %r15
leaq 0x1(%rax), %rcx
leaq 0x1e0(%rsp), %rdi
leaq 0xc0(%rsp), %rsi
xorl %edx, %edx
callq 0x3250
leaq 0xc0(%rsp), %rdi
leaq 0x1e0(%rsp), %r12
movq %r12, %rsi
callq 0x32d0
movq (%r12), %rdi
cmpq %r13, %rdi
je 0x48f8
movq 0x1f0(%rsp), %rsi
incq %rsi
callq 0x3240
movq 0x10(%r14), %rax
subq 0x8(%r14), %rax
leaq 0x30(%rsp), %rbp
jmp 0x3fdb
movl 0x1c(%rsp), %edi
callq 0x34d0
movl 0x8(%rsp), %edi
callq 0x34d0
leaq 0x180(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
xorl %edi, %edi
callq 0x32e0
movl %eax, 0x10(%rsp)
testl %eax, %eax
jns 0x4976
movq 0xa692(%rip), %rax      # 0xefd8
movq (%rax), %rbx
callq 0x3030
movl (%rax), %ebp
movl %ebp, %edi
callq 0x30b0
leaq 0x71e1(%rip), %rsi      # 0xbb3f
movq %rbx, %rdi
movl %ebp, %edx
movq %rax, %rcx
xorl %eax, %eax
callq 0x3340
pushq $0x1
popq %r12
jmp 0x4f36
xorps %xmm0, %xmm0
leaq 0x40(%rsp), %rdi
movaps %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
xorl %esi, %esi
callq 0x9fb6
movq 0x48(%rsp), %rax
movl $0x1, -0xc(%rax)
movl 0x18(%rsp), %ecx
movl %ecx, -0x8(%rax)
movl 0x18(%rsp), %edx
movq 0x48(%rsp), %rcx
addq $-0xc, %rcx
pushq $0x1
popq %r12
movl 0x10(%rsp), %edi
movl %r12d, %esi
callq 0x3320
testl %eax, %eax
jne 0x49de
movq 0x48(%rsp), %rsi
cmpq 0x50(%rsp), %rsi
jne 0x4a02
leaq 0x40(%rsp), %rdi
callq 0x9fb6
movq 0x48(%rsp), %rax
jmp 0x4a18
movq 0xa5f3(%rip), %rax      # 0xefd8
movq (%rax), %rbx
callq 0x3030
movl (%rax), %ebp
movl %ebp, %edi
callq 0x30b0
leaq 0x715f(%rip), %rsi      # 0xbb5c
jmp 0x4d9d
andl $0x0, 0x8(%rsi)
andq $0x0, (%rsi)
movq 0x48(%rsp), %rax
addq $0xc, %rax
movq %rax, 0x48(%rsp)
movl $0x4, -0xc(%rax)
movl 0xc(%rsp), %ecx
movl %ecx, -0x8(%rax)
movl 0xc(%rsp), %edx
movq 0x48(%rsp), %rcx
addq $-0xc, %rcx
pushq $0x1
popq %r12
movl 0x10(%rsp), %edi
movl %r12d, %esi
callq 0x3320
testl %eax, %eax
jne 0x4d7e
movq $0x0, 0x98(%rsp)
movq 0x40(%rsp), %rsi
movq 0x48(%rsp), %rax
subq %rsi, %rax
cqto
pushq $0xc
popq %rcx
idivq %rcx
movl 0x10(%rsp), %edi
movl %eax, %edx
movl $0x3e8, %ecx            # imm = 0x3E8
callq 0x3140
movl %eax, %ecx
testl %eax, %eax
js 0x4eb7
movl %ecx, %edi
movq 0x48(%rsp), %rax
subq 0x40(%rsp), %rax
cqto
pushq $0xc
popq %rsi
idivq %rsi
movq %rdi, 0xe8(%rsp)
cmpq %rdi, %rax
jb 0x4ed8
testl %ecx, %ecx
jne 0x4acd
movq 0xa522(%rip), %rax      # 0xefd8
movq (%rax), %rdi
leaq 0x7127(%rip), %rsi      # 0xbbe7
movl 0x14(%rsp), %edx
xorl %eax, %eax
callq 0x3340
jmp 0x4a57
negq 0xe8(%rsp)
xorl %ebp, %ebp
pushq $0x1
popq %r15
movq 0x40(%rsp), %rcx
movq 0x48(%rsp), %rax
subq %rcx, %rax
cqto
pushq $0xc
popq %rsi
idivq %rsi
movl 0x18(%rsp), %edx
imulq $0xc, %rbp, %r13
incq %rbp
leaq -0x1(%rbp), %r12
cmpq %r12, %rax
jbe 0x4f64
movl 0x4(%rcx,%r13), %edi
cmpl %edx, %edi
jne 0x4b3f
testb $0x10, (%rcx,%r13)
je 0x4bfa
addq $0xc, %r13
movq 0xe8(%rsp), %rsi
addq %rbp, %rsi
incq %rsi
incq %rbp
xorl %r15d, %r15d
cmpq $0x1, %rsi
jne 0x4afb
jmp 0x4cb1
cmpl 0xc(%rsp), %edi
jne 0x4c97
movq 0x100(%r14), %rsi
movq 0x98(%rsp), %rax
addq %rax, %rsi
movq 0x108(%r14), %rdx
subq %rax, %rdx
callq 0x30c0
movq %rax, 0xe0(%rsp)
movq 0x108(%r14), %rax
movq %rax, %rcx
subq 0x98(%rsp), %rcx
cmpq %rcx, 0xe0(%rsp)
jne 0x4e67
movq 0x98(%rsp), %rdx
addq 0xe0(%rsp), %rdx
movq %rdx, 0x98(%rsp)
cmpq %rax, %rdx
jb 0x4c97
movq 0x40(%rsp), %rcx
movq 0x48(%rsp), %rax
subq %rcx, %rax
cqto
pushq $0xc
popq %rsi
idivq %rsi
cmpq %r12, %rax
jbe 0x4f78
movl 0xc(%rsp), %edx
addq %r13, %rcx
movl 0x10(%rsp), %edi
pushq $0x2
popq %rsi
callq 0x3320
testl %eax, %eax
jne 0x4eed
movl 0xc(%rsp), %edi
callq 0x34d0
jmp 0x4c97
movl $0x100, %edx            # imm = 0x100
leaq 0x1e0(%rsp), %rsi
callq 0x3350
testq %rax, %rax
js 0x4e43
je 0x4c8b
leaq 0x100(%rsp), %rcx
movq %rcx, 0xf0(%rsp)
leaq (%rsp,%rax), %rdx
addq $0x1e0, %rdx            # imm = 0x1E0
leaq 0xf0(%rsp), %rdi
leaq 0x1e0(%rsp), %rsi
callq 0x9cd0
movq 0xf0(%rsp), %rsi
movq 0xf8(%rsp), %rdx
leaq 0x170(%rsp), %rdi
callq 0x30a0
movq 0xf0(%rsp), %rdi
leaq 0x100(%rsp), %rax
cmpq %rax, %rdi
je 0x4c97
movq 0x100(%rsp), %rsi
incq %rsi
callq 0x3240
jmp 0x4c97
xorl %r15d, %r15d
movl 0x18(%rsp), %edi
callq 0x34d0
movq 0xe8(%rsp), %rax
addq %rbp, %rax
jne 0x4adb
testl %r15d, %r15d
jne 0x4a57
leaq 0xf0(%rsp), %rsi
movl 0x14(%rsp), %edi
xorl %edx, %edx
callq 0x31c0
movl %eax, %r14d
cmpl 0x14(%rsp), %eax
jne 0x4db1
leaq 0x1e0(%rsp), %rdi
movl $0x400, %r14d           # imm = 0x400
pushq $0x14
popq %rcx
movl $0x400, %esi            # imm = 0x400
movq %rbx, %rdx
callq 0x9bb4
testl %eax, %eax
jne 0x4dee
leaq 0x1e0(%rsp), %rdi
callq 0x3100
leaq (%rsp,%rax), %rdi
addq $0x1e0, %rdi            # imm = 0x1E0
subq %rax, %r14
leaq 0x650f(%rip), %rdx      # 0xb228
movq %r14, %rsi
xorl %eax, %eax
callq 0x33e0
movl 0xf0(%rsp), %edx
testl %edx, %edx
jne 0x4e16
leaq 0x170(%rsp), %rdi
leaq 0x1e0(%rsp), %rsi
callq 0x3090
testl %eax, %eax
jne 0x4e0f
movq 0xa282(%rip), %rax      # 0xefd8
movq (%rax), %rdi
leaq 0x6f6f(%rip), %rsi      # 0xbccf
leaq 0x6f84(%rip), %rdx      # 0xbceb
xorl %r12d, %r12d
leaq 0x1e0(%rsp), %rcx
xorl %eax, %eax
callq 0x3340
jmp 0x4f1f
movq 0xa253(%rip), %rax      # 0xefd8
movq (%rax), %rbx
callq 0x3030
movl (%rax), %ebp
movl %ebp, %edi
callq 0x30b0
leaq 0x6de2(%rip), %rsi      # 0xbb7f
movq %rbx, %rdi
movl %ebp, %edx
movq %rax, %rcx
xorl %eax, %eax
callq 0x3340
jmp 0x4f1f
movq 0xa220(%rip), %rax      # 0xefd8
movq (%rax), %rbx
callq 0x3030
movl (%rax), %r15d
movl %r15d, %edi
callq 0x30b0
leaq 0x6eab(%rip), %rsi      # 0xbc7d
movq %rbx, %rdi
movl %r14d, %edx
movl 0x14(%rsp), %ecx
movl %r15d, %r8d
movq %rax, %r9
xorl %eax, %eax
callq 0x3340
jmp 0x4f1b
movq 0xa1e3(%rip), %rax      # 0xefd8
movq (%rax), %rcx
leaq 0x66a0(%rip), %rdi      # 0xb49f
pushq $0x10
popq %rsi
pushq $0x1
popq %rdx
callq 0x34c0
jmp 0x4f1b
movl 0xf0(%rsp), %edx
movq 0xa1bb(%rip), %rbx      # 0xefd8
movq (%rbx), %rdi
leaq 0x6e82(%rip), %rsi      # 0xbca9
xorl %eax, %eax
callq 0x3340
movq (%rbx), %rsi
movq 0x170(%rsp), %rdi
callq 0x3270
jmp 0x4f1b
movq 0xa18e(%rip), %rax      # 0xefd8
movq (%rax), %rbx
callq 0x3030
movl (%rax), %ebp
movl %ebp, %edi
callq 0x30b0
leaq 0x6dad(%rip), %rsi      # 0xbc0f
jmp 0x4f0c
movq 0xa16a(%rip), %rax      # 0xefd8
movq (%rax), %rbx
callq 0x3030
movl (%rax), %ebp
movl %ebp, %edi
callq 0x30b0
movq 0x108(%r14), %r9
subq 0x98(%rsp), %r9
leaq 0x6d98(%rip), %rsi      # 0xbc2d
movq %rbx, %rdi
movl %ebp, %edx
movq %rax, %rcx
movq 0xe0(%rsp), %r8
xorl %eax, %eax
callq 0x3340
movl 0xc(%rsp), %edi
callq 0x34d0
jmp 0x4f1b
movq 0xa11a(%rip), %rax      # 0xefd8
movq (%rax), %rbx
callq 0x3030
movl (%rax), %ebp
movl %ebp, %edi
callq 0x30b0
leaq 0x6ccc(%rip), %rsi      # 0xbba2
jmp 0x4f0c
movq 0xa0f9(%rip), %rdx      # 0xefd8
movq (%rdx), %rdi
leaq 0x6cd3(%rip), %rsi      # 0xbbbc
movl %ecx, %edx
jmp 0x4f11
movq 0xa0e4(%rip), %rax      # 0xefd8
movq (%rax), %rbx
callq 0x3030
movl (%rax), %ebp
movl %ebp, %edi
callq 0x30b0
leaq 0x6d4e(%rip), %rsi      # 0xbc5a
movq %rbx, %rdi
movl %ebp, %edx
movq %rax, %rcx
xorl %eax, %eax
callq 0x3340
pushq $0x1
popq %r12
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x4f36
movq 0x50(%rsp), %rsi
subq %rdi, %rsi
callq 0x3240
movq 0x170(%rsp), %rdi
leaq 0x180(%rsp), %rax
cmpq %rax, %rdi
je 0x46b0
movq 0x180(%rsp), %rsi
incq %rsi
callq 0x3240
jmp 0x46b0
leaq 0x64d8(%rip), %rdi      # 0xb443
movq %r12, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x3390
leaq 0x64c4(%rip), %rdi      # 0xb443
movq %r12, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x3390
jmp 0x4fc8
jmp 0x4fc8
jmp 0x4fc8
movq %rax, %rbx
movq 0xf0(%rsp), %rdi
leaq 0x100(%rsp), %rax
cmpq %rax, %rdi
je 0x4fcb
movq 0x100(%rsp), %rsi
incq %rsi
callq 0x3240
jmp 0x4fcb
jmp 0x4fc8
jmp 0x4fc8
jmp 0x4fc8
jmp 0x4fc8
jmp 0x500f
jmp 0x500f
movq %rax, %rbx
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x4fe2
movq 0x50(%rsp), %rsi
subq %rdi, %rsi
callq 0x3240
movq 0x170(%rsp), %rdi
leaq 0x180(%rsp), %rax
cmpq %rax, %rdi
je 0x5086
movq 0x180(%rsp), %rsi
incq %rsi
callq 0x3240
jmp 0x5086
jmp 0x500f
movq %rax, %rbx
jmp 0x50a3
jmp 0x5035
jmp 0x5083
jmp 0x5083
jmp 0x5083
jmp 0x5083
jmp 0x5083
jmp 0x5083
jmp 0x5083
jmp 0x5083
jmp 0x5083
jmp 0x5083
jmp 0x5083
jmp 0x5083
jmp 0x5083
jmp 0x5035
movq %rax, %rbx
jmp 0x50c8
jmp 0x5083
jmp 0x5041
movq %rax, %rbx
jmp 0x50e4
jmp 0x5051
jmp 0x5051
jmp 0x5051
jmp 0x5051
movq %rax, %rbx
jmp 0x5105
movq %rax, %rbx
jmp 0x5126
jmp 0x5063
movq %rax, %rbx
jmp 0x514b
jmp 0x5073
jmp 0x5073
jmp 0x5073
jmp 0x5073
movq %rax, %rbx
jmp 0x516c
movq %rax, %rbx
jmp 0x518d
movq %rax, %rbx
movq 0x80(%rsp), %rdi
testq %rdi, %rdi
je 0x50a3
movq 0x90(%rsp), %rsi
subq %rdi, %rsi
callq 0x3240
movq 0xc0(%rsp), %rdi
leaq 0xd0(%rsp), %rax
cmpq %rax, %rdi
je 0x50c8
movq 0xd0(%rsp), %rsi
incq %rsi
callq 0x3240
movq 0x60(%rsp), %rdi
leaq 0x70(%rsp), %rax
cmpq %rax, %rdi
je 0x50e4
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x3240
leaq 0x120(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5105
movq 0x120(%rsp), %rsi
incq %rsi
callq 0x3240
leaq 0x1a0(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5126
movq 0x1a0(%rsp), %rsi
incq %rsi
callq 0x3240
movq 0xa0(%rsp), %rdi
leaq 0xb0(%rsp), %rax
cmpq %rax, %rdi
je 0x514b
movq 0xb0(%rsp), %rsi
incq %rsi
callq 0x3240
leaq 0x140(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x516c
movq 0x140(%rsp), %rsi
incq %rsi
callq 0x3240
leaq 0x160(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x518d
movq 0x160(%rsp), %rsi
incq %rsi
callq 0x3240
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x51a9
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x3240
movq %rbx, %rdi
callq 0x3480