// File: /workspace/github_c_makefile_star2_O2/stfwi[P]duktape-cc/build/duktape/mod/ext/app_attachment/././app_attachment.hh
// Function: int sw::util::detail::basic_executable_attachment<void>::patch_application<void>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
static inline int patch_application(std::string path, bool verbose=false, std::string attachment_contents="")
    {
      using namespace std;

      // hexdump
      auto hexdump = [](const vector<char>& data, std::ostream& os) {
        size_t n = 0;
        for(auto e:data) {
          if(!(n & 63)) os << "\n" << hex << setw(8) << setfill('0') << n << ": ";
          os << hex << setw(2) << setfill('0') << ((int)(e&0xff));
          ++n;
        }
        os << dec << "\n";
      };

      // file size using stat to double check later read
      size_t filesize = 0;
      {
        struct ::stat st;
        if(::stat(path.c_str(), &st) != 0) {
          cerr << "stat failed for " << path << "\n";
          return 1;
        } else {
          filesize = st.st_size;
          if(verbose) {
            cerr << "File size: " << dec << ((long)filesize) << " (0x" << hex << ((long)filesize) << ")\n";
          }
        }
      }

      // same placeholder as in the application
      vector<char> reverse_boundary_key(256);
      std::copy_n(
        basic_executable_attachment<void>::boundary_marker,
        sizeof(basic_executable_attachment<void>::boundary_marker),
        reverse_boundary_key.begin()
      );

      if(verbose) {
        cerr << "----------------------\n";
        cerr << "reverse_boundary_key:\n";
        hexdump(reverse_boundary_key, cerr);
        cerr << "----------------------\n";
      }

      // Read whole application
      vector<char> contents;
      {
        std::ifstream fis(path.c_str(), std::ios::in|std::ios::binary);
        contents.assign((std::istreambuf_iterator<char>(fis)), std::istreambuf_iterator<char>());
        if(contents.size() != filesize) {
          cerr << "file size mismatch\n"
              << "- file size : " << filesize << "\n"
              << "- file size read: " << contents.size() << "\n";
          return 1;
        }
      }

      if(verbose) {
        std::ofstream fos((path+".unpatched.tmp").c_str(), std::ios::out|std::ios::binary);
        hexdump(contents, fos);
        fos.close();
      }

      // Fill up the file until it has 4k size (app checks the start of each read 4k block to save time).
      while((contents.size() & (4095u)) != 0) contents.push_back(0);
      if(verbose) cerr << "File size after alignment fill: " << dec << ((long)contents.size()) << " (0x" << hex << ((long)contents.size()) << ")\n";

      // Find placeholder
      auto key_patch_position_it = std::search(contents.begin(), contents.end(), reverse_boundary_key.begin(), reverse_boundary_key.end());
      {
        if(key_patch_position_it == contents.end()) {
          cerr << "reverse boundary placeholder not found\n";
          return 1;
        }
        if(verbose) {
          size_t pos = static_cast<size_t>(key_patch_position_it - contents.begin()) / sizeof(decltype(contents)::iterator::difference_type);
          cerr << "Boundary placeholder at: " << pos << "\n";
        }
      }

      // Make random boundary key, check that it is unique in the whole file.
      vector<char> patch_key;
      {
        int retries = 10;
        const std::string ofs = std::string("[<") + std::to_string(long(contents.size())) + ">]";
        while(--retries) {
          patch_key.clear();
          patch_key.reserve(reverse_boundary_key.size());
          default_random_engine rd(std::chrono::high_resolution_clock::now().time_since_epoch().count());
          mt19937 mt(rd());
          uniform_int_distribution<char> db(33, 124);
          while(patch_key.size() < reverse_boundary_key.size()) patch_key.push_back(char(db(mt)));
          reverse(patch_key.begin(), patch_key.end());
          std::copy(ofs.begin(), ofs.end(), patch_key.begin());
          auto check_it = std::search(contents.begin(), contents.end(), patch_key.begin(), patch_key.end());
          auto check_sym = patch_key;
          reverse(check_sym.begin(), check_sym.end());
          if((check_it == contents.end()) && (check_sym != patch_key)) break;
        }
        if(!retries) {
          cerr << "failed to generate collisionless boundary\n";
          return 1;
        }
        if(verbose) {
          cerr << "----------------------\n";
          cerr << "patch key:'" << ofs << "'\n";
          hexdump(patch_key, cerr);
          cerr << "----------------------\n";
        }
      }
      // Patch the placeholder position with the generated key.
      std::copy_n(patch_key.begin(), patch_key.size(), key_patch_position_it);
      // Reverse the key and write it at the end.
      reverse(patch_key.begin(), patch_key.end());
      for(auto e:patch_key) contents.push_back(e);
      if(verbose) cerr << "File size after adding the boundary: " << dec << ((long)contents.size()) << " (0x" << hex << ((long)contents.size()) << ")\n";
      std::ofstream fos(path.c_str(), ofstream::out|ofstream::binary);
      if(!fos.write(contents.data(), contents.size())) { cerr << "failed to write file\n" ; return 1; }
      if(verbose) {
        std::ofstream dump_fos((path+".patched.tmp").c_str(), std::ios::out|std::ios::binary);
        hexdump(contents, dump_fos);
        dump_fos.close();
      }
      if(!attachment_contents.empty()) {
        if(verbose) cerr << "[verb] Attaching " << long(attachment_contents.size()>>10) << "kb data ...\n";
        reverse(patch_key.begin(), patch_key.end());
        const auto wdata = basic_executable_attachment<void>::serialize<vector<char>, string>(attachment_contents, patch_key.data());
        copy(wdata.begin(), wdata.end(), ostreambuf_iterator<char>(fos));
      }
      return 0;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1648, %rsp           # imm = 0x1648
movq %rdx, %rbx
movl %esi, %r14d
movq %rdi, %r15
movq (%rdi), %rdi
leaq -0x1670(%rbp), %rsi
callq 0x2140
testl %eax, %eax
je 0x2915
pushq $0x1
popq %rbx
movq 0x5706(%rip), %rdi      # 0x7ff0
leaq 0x27ba(%rip), %rsi      # 0x50ab
callq 0x2160
movq %rax, %rdi
movq %r15, %rsi
callq 0x2130
leaq 0x275a(%rip), %rsi      # 0x5062
movq %rax, %rdi
callq 0x2160
jmp 0x31cc
movq -0x1640(%rbp), %r12
testb %r14b, %r14b
movq %rbx, -0xc8(%rbp)
movl %r14d, -0x54(%rbp)
je 0x2a25
movq 0x56b9(%rip), %rbx      # 0x7ff0
leaq 0x277e(%rip), %rsi      # 0x50bc
movq %rbx, %rdi
callq 0x2160
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movl 0x18(%rax,%rcx), %edx
andl $-0x4b, %edx
orl $0x2, %edx
movl %edx, 0x18(%rax,%rcx)
movq %rax, %rdi
movq %r12, %rsi
callq 0x2150
leaq 0x275b(%rip), %rsi      # 0x50c8
movq %rax, %rdi
callq 0x2160
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movl 0x18(%rax,%rcx), %edx
andl $-0x4b, %edx
orl $0x8, %edx
movl %edx, 0x18(%rax,%rcx)
movq %rax, %rdi
movq %r12, %rsi
callq 0x2150
leaq 0x2731(%rip), %rsi      # 0x50cd
movq %rax, %rdi
callq 0x2160
leaq -0x90(%rbp), %r14
leaq -0x1670(%rbp), %rdx
movl $0x100, %esi            # imm = 0x100
movq %r14, %rdi
callq 0x3c88
movq (%r14), %rdi
movl -0x54(%rbp), %r14d
leaq 0x28f3(%rip), %rsi      # 0x52c0
movl $0x100, %edx            # imm = 0x100
callq 0x2110
leaq 0x26f2(%rip), %rsi      # 0x50d0
movq %rbx, %rdi
callq 0x2160
movq 0x5603(%rip), %rdi      # 0x7ff0
leaq 0x26f4(%rip), %rsi      # 0x50e8
callq 0x2160
movq 0x55f0(%rip), %rdx      # 0x7ff0
leaq -0x29(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x3cda
movq 0x55d9(%rip), %rdi      # 0x7ff0
leaq 0x26b2(%rip), %rsi      # 0x50d0
callq 0x2160
jmp 0x2a54
leaq -0x90(%rbp), %rbx
leaq -0x1670(%rbp), %rdx
movl $0x100, %esi            # imm = 0x100
movq %rbx, %rdi
callq 0x3c88
movq (%rbx), %rdi
leaq 0x2876(%rip), %rsi      # 0x52c0
movl $0x100, %edx            # imm = 0x100
callq 0x2110
xorps %xmm0, %xmm0
movaps %xmm0, -0x50(%rbp)
andq $0x0, -0x40(%rbp)
movq (%r15), %rsi
leaq -0x1670(%rbp), %rdi
pushq $0xc
popq %rdx
callq 0x22d0
movq -0x1670(%rbp), %rax
movq -0x18(%rax), %rax
movq -0x1588(%rbp,%rax), %rsi
leaq -0x50(%rbp), %rdi
pushq $-0x1
popq %rdx
xorl %ecx, %ecx
movl %edx, %r8d
callq 0x4188
movq -0x48(%rbp), %rax
subq -0x50(%rbp), %rax
cmpq %r12, %rax
jne 0x2b47
leaq -0x1670(%rbp), %rdi
callq 0x2050
testb %r14b, %r14b
je 0x2b1c
leaq 0x2676(%rip), %rdx      # 0x5135
leaq -0x2e8(%rbp), %rdi
movq %r15, %rsi
callq 0x3dd4
movq -0x2e8(%rbp), %rsi
leaq -0x1670(%rbp), %rdi
pushq $0x14
popq %rdx
callq 0x21a0
leaq -0x2e8(%rbp), %rdi
callq 0x20b0
leaq -0x29(%rbp), %rdi
leaq -0x50(%rbp), %rsi
leaq -0x1670(%rbp), %rdx
callq 0x3cda
leaq -0x1670(%rbp), %rdi
callq 0x2200
leaq -0x1670(%rbp), %rdi
callq 0x2220
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
movl %esi, %eax
subl %edi, %eax
testw $0xfff, %ax             # imm = 0xFFF
je 0x2bc2
leaq -0x1670(%rbp), %rsi
movb $0x0, (%rsi)
leaq -0x50(%rbp), %rdi
callq 0x4598
jmp 0x2b1c
movq 0x54a2(%rip), %rdi      # 0x7ff0
leaq 0x25aa(%rip), %rsi      # 0x50ff
callq 0x2160
leaq 0x25b2(%rip), %rsi      # 0x5113
movq %rax, %rdi
callq 0x2160
movq %rax, %rdi
movq %r12, %rsi
callq 0x20f0
leaq 0x24e7(%rip), %rsi      # 0x5062
movq %rax, %rdi
callq 0x2160
leaq 0x2598(%rip), %rsi      # 0x5122
movq %rax, %rdi
callq 0x2160
movq -0x48(%rbp), %rsi
subq -0x50(%rbp), %rsi
movq %rax, %rdi
callq 0x20f0
leaq 0x24b9(%rip), %rsi      # 0x5062
movq %rax, %rdi
callq 0x2160
leaq -0x1670(%rbp), %rdi
callq 0x2050
jmp 0x3009
testb %r14b, %r14b
je 0x2c4e
movq 0x541e(%rip), %rdi      # 0x7ff0
leaq 0x256b(%rip), %rsi      # 0x5144
callq 0x2160
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movl 0x18(%rax,%rcx), %edx
andl $-0x4b, %edx
orl $0x2, %edx
movl %edx, 0x18(%rax,%rcx)
movq -0x48(%rbp), %rsi
subq -0x50(%rbp), %rsi
movq %rax, %rdi
callq 0x2150
leaq 0x24be(%rip), %rsi      # 0x50c8
movq %rax, %rdi
callq 0x2160
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movl 0x18(%rax,%rcx), %edx
andl $-0x4b, %edx
orl $0x8, %edx
movl %edx, 0x18(%rax,%rcx)
movq -0x48(%rbp), %rsi
subq -0x50(%rbp), %rsi
movq %rax, %rdi
callq 0x2150
leaq 0x248f(%rip), %rsi      # 0x50cd
movq %rax, %rdi
callq 0x2160
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x90(%rbp), %rdx
movq -0x88(%rbp), %rcx
callq 0x4761
cmpq -0x48(%rbp), %rax
je 0x2ff6
movq %rax, -0xb8(%rbp)
testb %r14b, %r14b
je 0x2cb3
movq -0x50(%rbp), %rbx
movq 0x536e(%rip), %rdi      # 0x7ff0
leaq 0x2504(%rip), %rsi      # 0x518d
callq 0x2160
movq -0xb8(%rbp), %rsi
subq %rbx, %rsi
shrq $0x3, %rsi
movq %rax, %rdi
callq 0x20f0
leaq 0x23b7(%rip), %rsi      # 0x5062
movq %rax, %rdi
callq 0x2160
xorps %xmm0, %xmm0
movaps %xmm0, -0x70(%rbp)
andq $0x0, -0x60(%rbp)
leaq 0x24e1(%rip), %rsi      # 0x51a7
leaq -0xb0(%rbp), %rdi
leaq -0x55(%rbp), %rdx
callq 0x2090
movq -0x48(%rbp), %rsi
subq -0x50(%rbp), %rsi
leaq -0xe8(%rbp), %rdi
callq 0x3ea6
leaq -0x1670(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
leaq -0xe8(%rbp), %rdx
callq 0x3e35
movq %r15, -0xc0(%rbp)
leaq 0x2498(%rip), %rdx      # 0x51aa
leaq -0x2e8(%rbp), %rdi
leaq -0x1670(%rbp), %rsi
callq 0x3e0c
leaq -0x1670(%rbp), %r13
movq %r13, %rdi
callq 0x20b0
leaq -0xe8(%rbp), %rbx
movq %rbx, %rdi
callq 0x20b0
leaq -0xb0(%rbp), %r12
movq %r12, %rdi
callq 0x20b0
pushq $0xa
popq %r14
leaq -0x70(%rbp), %r15
decl %r14d
je 0x2e86
movq -0x70(%rbp), %rax
cmpq %rax, -0x68(%rbp)
je 0x2d71
movq %rax, -0x68(%rbp)
movq -0x88(%rbp), %rsi
subq -0x90(%rbp), %rsi
movq %r15, %rdi
callq 0x3f06
callq 0x2030
xorl %edx, %edx
movl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
divq %rcx
cmpq $0x1, %rdx
adcq $0x0, %rdx
imulq $0x41a7, %rdx, %rax     # imm = 0x41A7
xorl %edx, %edx
divq %rcx
movq %r13, %rdi
movq %rdx, %rsi
callq 0x4932
movw $0x7c21, -0xe8(%rbp)    # imm = 0x7C21
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rsi
movq %rsi, %rax
subq %rdi, %rax
movq -0x88(%rbp), %rcx
subq -0x90(%rbp), %rcx
cmpq %rcx, %rax
jae 0x2dfd
movq %rbx, %rdi
movq %r13, %rsi
callq 0x3f90
movb %al, -0xb0(%rbp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x4598
jmp 0x2dbe
callq 0x4bbc
movl %r14d, -0x74(%rbp)
movq -0x2e0(%rbp), %rdx
testq %rdx, %rdx
je 0x2e22
movq -0x2e8(%rbp), %rsi
movq -0x70(%rbp), %rdi
callq 0x2280
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x70(%rbp), %rdx
movq -0x68(%rbp), %rcx
callq 0x4761
movq %rax, %r14
movq %r12, %rdi
movq %r15, %rsi
callq 0x3f9e
movq -0xb0(%rbp), %rdi
movq -0xa8(%rbp), %rsi
callq 0x4bbc
cmpq -0x48(%rbp), %r14
movl -0x54(%rbp), %r14d
jne 0x2e75
movq %r12, %rdi
movq %r15, %rsi
callq 0x3ff1
testb %al, %al
jne 0x3019
movq %r12, %rdi
callq 0x40f6
movl -0x74(%rbp), %r14d
jmp 0x2d5a
leaq 0x2320(%rip), %rbx      # 0x51ad
movq 0x515c(%rip), %rdi      # 0x7ff0
movq %rbx, %rsi
callq 0x2160
leaq -0x2e8(%rbp), %rdi
callq 0x20b0
testl %r14d, %r14d
je 0x3011
movq -0x70(%rbp), %rax
movq -0x68(%rbp), %rsi
movq %rsi, %rdx
subq %rax, %rdx
je 0x2ed8
movq -0xb8(%rbp), %rdi
movq %rax, %rsi
callq 0x2280
movq -0x70(%rbp), %rax
movq -0x68(%rbp), %rsi
movq %rax, %rdi
callq 0x4bbc
movq -0x70(%rbp), %r15
movq -0x68(%rbp), %r12
leaq -0x50(%rbp), %rbx
leaq -0x1670(%rbp), %r14
cmpq %r12, %r15
je 0x2f11
movb (%r15), %al
movb %al, -0x1670(%rbp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3ffe
incq %r15
jmp 0x2ef3
cmpb $0x0, -0x54(%rbp)
je 0x2f92
movq 0x50d2(%rip), %rdi      # 0x7ff0
leaq 0x22bf(%rip), %rsi      # 0x51e4
callq 0x2160
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movl 0x18(%rax,%rcx), %edx
andl $-0x4b, %edx
orl $0x2, %edx
movl %edx, 0x18(%rax,%rcx)
movq -0x48(%rbp), %rsi
subq -0x50(%rbp), %rsi
movq %rax, %rdi
callq 0x2150
leaq 0x2172(%rip), %rsi      # 0x50c8
movq %rax, %rdi
callq 0x2160
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movl 0x18(%rax,%rcx), %edx
andl $-0x4b, %edx
orl $0x8, %edx
movl %edx, 0x18(%rax,%rcx)
movq -0x48(%rbp), %rsi
subq -0x50(%rbp), %rsi
movq %rax, %rdi
callq 0x2150
leaq 0x2143(%rip), %rsi      # 0x50cd
movq %rax, %rdi
callq 0x2160
movq -0xc0(%rbp), %r14
movq (%r14), %rsi
leaq -0x1670(%rbp), %rdi
pushq $0x14
popq %rdx
callq 0x21a0
movq -0xc8(%rbp), %rbx
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
subq %rsi, %rdx
leaq -0x1670(%rbp), %rdi
callq 0x21e0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
je 0x3092
movq 0x500e(%rip), %rdi      # 0x7ff0
leaq 0x2221(%rip), %rsi      # 0x520a
callq 0x2160
pushq $0x1
popq %rbx
jmp 0x31a2
movq 0x4ff3(%rip), %rdi      # 0x7ff0
leaq 0x2161(%rip), %rsi      # 0x5165
callq 0x2160
pushq $0x1
popq %rbx
jmp 0x31b7
pushq $0x1
popq %rbx
jmp 0x31ae
leaq -0xb0(%rbp), %rdi
callq 0x40f6
testb %r14b, %r14b
movl -0x74(%rbp), %r14d
je 0x2e9c
movq 0x4fb7(%rip), %rdi      # 0x7ff0
leaq 0x2090(%rip), %rbx      # 0x50d0
movq %rbx, %rsi
callq 0x2160
movq 0x4fa1(%rip), %rdi      # 0x7ff0
leaq 0x2182(%rip), %rsi      # 0x51d8
callq 0x2160
leaq -0x2e8(%rbp), %rsi
movq %rax, %rdi
callq 0x2130
leaq 0x1ff0(%rip), %rsi      # 0x5061
movq %rax, %rdi
callq 0x2160
movq 0x4f70(%rip), %rdx      # 0x7ff0
leaq -0x29(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x3cda
jmp 0x2e8d
cmpb $0x0, -0x54(%rbp)
je 0x313f
leaq 0x217d(%rip), %rdx      # 0x5220
leaq -0xb0(%rbp), %rdi
movq %r14, %rsi
callq 0x3dd4
movq -0xb0(%rbp), %rsi
leaq -0x2e8(%rbp), %rdi
pushq $0x14
popq %rdx
callq 0x21a0
leaq -0xb0(%rbp), %rdi
callq 0x20b0
leaq -0x29(%rbp), %rdi
leaq -0x50(%rbp), %rsi
leaq -0x2e8(%rbp), %rdx
callq 0x3cda
leaq -0x2e8(%rbp), %rdi
callq 0x2200
leaq -0x2e8(%rbp), %rdi
callq 0x2220
cmpq $0x0, 0x8(%rbx)
je 0x31a0
movq 0x4ede(%rip), %rdi      # 0x7ff0
leaq 0x2114(%rip), %rsi      # 0x522d
callq 0x2160
movq 0x8(%rbx), %rsi
shrq $0xa, %rsi
movq %rax, %rdi
callq 0x2150
leaq 0x210a(%rip), %rsi      # 0x523f
movq %rax, %rdi
callq 0x2160
jmp 0x3146
cmpq $0x0, 0x8(%rbx)
je 0x31a0
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0x4bbc
movq -0x70(%rbp), %rdx
leaq -0x2e8(%rbp), %rdi
movq %rbx, %rsi
callq 0x4020
movq -0x2e8(%rbp), %rdi
movq -0x2e0(%rbp), %rsi
movq -0x1670(%rbp), %rax
movq -0x18(%rax), %rax
movq -0x1588(%rbp,%rax), %rdx
xorl %ecx, %ecx
testq %rdx, %rdx
sete %cl
callq 0x4cf0
leaq -0x2e8(%rbp), %rdi
callq 0x40f6
xorl %ebx, %ebx
leaq -0x1670(%rbp), %rdi
callq 0x2220
leaq -0x70(%rbp), %rdi
callq 0x40f6
leaq -0x50(%rbp), %rdi
callq 0x40f6
leaq -0x90(%rbp), %rdi
callq 0x40f6
movl %ebx, %eax
addq $0x1648, %rsp           # imm = 0x1648
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0xb0(%rbp), %rdi
callq 0x20b0
jmp 0x3268
jmp 0x3265
movq %rax, %rbx
leaq -0x2e8(%rbp), %rdi
callq 0x40f6
jmp 0x3268
jmp 0x3265
movq %rax, %rbx
leaq -0x2e8(%rbp), %rdi
callq 0x2220
jmp 0x3268
jmp 0x32ab
movq %rax, %rbx
leaq -0x2e8(%rbp), %rdi
callq 0x20b0
jmp 0x32e8
jmp 0x32cb
movq %rax, %rbx
leaq -0x1670(%rbp), %rdi
callq 0x20b0
jmp 0x3249
movq %rax, %rbx
leaq -0xe8(%rbp), %rdi
callq 0x20b0
jmp 0x325a
movq %rax, %rbx
leaq -0xb0(%rbp), %rdi
jmp 0x32da
jmp 0x32ab
movq %rax, %rbx
leaq -0x1670(%rbp), %rdi
callq 0x2220
jmp 0x32df
jmp 0x32cb
jmp 0x32d0
movq %rax, %rbx
leaq -0x1670(%rbp), %rdi
callq 0x2220
jmp 0x32e8
jmp 0x32ab
jmp 0x32cb
jmp 0x32cb
jmp 0x32cb
movq %rax, %rbx
jmp 0x32f1
jmp 0x32b0
movq %rax, %rbx
leaq -0x1670(%rbp), %rdi
callq 0x2050
jmp 0x32e8
movq %rax, %rbx
jmp 0x32df
movq %rax, %rbx
leaq -0xb0(%rbp), %rdi
callq 0x40f6
jmp 0x32d3
jmp 0x32d0
jmp 0x32d0
jmp 0x32d0
jmp 0x32d0
jmp 0x32d0
movq %rax, %rbx
jmp 0x32e8
movq %rax, %rbx
leaq -0x2e8(%rbp), %rdi
callq 0x20b0
leaq -0x70(%rbp), %rdi
callq 0x40f6
leaq -0x50(%rbp), %rdi
callq 0x40f6
leaq -0x90(%rbp), %rdi
callq 0x40f6
movq %rbx, %rdi
callq 0x22b0
nop