LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: czinn[P]homeworlds/game.cc
// Function: Game::create_system(std::vector<Pyramid, std::allocator<Pyramid>> const&, int)
int Game::create_system(const std::vector<Pyramid>& stars, int player) {
  for (const Pyramid& star : stars) {
    stash_[star]--;
  }
  if (player != 0) {
    homeworlds_built_++;
  }
  return add_system(System{0, player, stars});
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x90e0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x9110
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x9140
testb $0x1, %al
jne 0x61f6
jmp 0x6229
leaq -0x28(%rbp), %rdi
callq 0x9180
movq -0x88(%rbp), %rdi
movq %rax, -0x38(%rbp)
addq $0x38, %rdi
movq -0x38(%rbp), %rsi
callq 0x8980
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
leaq -0x28(%rbp), %rdi
callq 0x91a0
jmp 0x61e3
cmpl $0x0, -0x14(%rbp)
je 0x623f
movq -0x88(%rbp), %rax
movl 0xc(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xc(%rax)
movl $0x0, -0x70(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x6c(%rbp)
leaq -0x68(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x9510
leaq -0x50(%rbp), %rdi
xorps %xmm0, %xmm0
movups %xmm0, -0x50(%rbp)
movq $0x0, -0x40(%rbp)
callq 0x9600
movq -0x88(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x6750
movl %eax, -0x8c(%rbp)
jmp 0x6289
leaq -0x70(%rbp), %rdi
callq 0x9620
movl -0x8c(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x9620
movq -0x78(%rbp), %rdi
callq 0x33c0
nop
// File: czinn[P]homeworlds/game.cc
// Function: Game::destroy_system(int)
void Game::destroy_system(int system_id) {
  const auto& it = find_if(systems_.begin(), systems_.end(),
      [system_id](const System& s) {
        return s.id == system_id;
      });
  for (const Pyramid& star : it->stars) {
    stash_[star]++;
  }
  for (const Ship& ship : it->ships) {
    stash_[ship.pyramid]++;
  }
  systems_.erase(it);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x90(%rbp)
addq $0x20, %rdi
callq 0x96c0
movq -0x90(%rbp), %rdi
movq %rax, -0x28(%rbp)
addq $0x20, %rdi
callq 0x96f0
movq %rax, -0x30(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
movl -0x34(%rbp), %edx
callq 0x6790
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x9720
addq $0x8, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0x9740
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rdi
callq 0x9770
movq %rax, -0x50(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x97a0
testb $0x1, %al
jne 0x635e
jmp 0x6391
leaq -0x48(%rbp), %rdi
callq 0x97e0
movq -0x90(%rbp), %rdi
movq %rax, -0x58(%rbp)
addq $0x38, %rdi
movq -0x58(%rbp), %rsi
callq 0x8980
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
leaq -0x48(%rbp), %rdi
callq 0x9800
jmp 0x634b
movq -0x18(%rbp), %rdi
callq 0x9720
addq $0x20, %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rdi
callq 0x9820
movq %rax, -0x68(%rbp)
movq -0x60(%rbp), %rdi
callq 0x9850
movq %rax, -0x70(%rbp)
leaq -0x68(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x9880
testb $0x1, %al
jne 0x63cf
jmp 0x6406
leaq -0x68(%rbp), %rdi
callq 0x98c0
movq -0x90(%rbp), %rdi
movq %rax, -0x78(%rbp)
addq $0x38, %rdi
movq -0x78(%rbp), %rsi
addq $0x4, %rsi
callq 0x8980
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
leaq -0x68(%rbp), %rdi
callq 0x98e0
jmp 0x63bc
movq -0x90(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x98(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x80(%rbp), %rdi
callq 0x9970
movq -0x98(%rbp), %rdi
movq -0x80(%rbp), %rsi
callq 0x9900
movq %rax, -0x88(%rbp)
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: czinn[P]homeworlds/negamax.cc
// Function: Negamax::half_heuristic(Game const*, int)
int Negamax::half_heuristic(const Game *game, int player) {
  if (game->winner() == player) {
    return 1000000;
  } else if (game->winner() != 0) {
    return 0;
  }

  int total = 0;
  for (const System& system : game->systems()) {
    for (const Ship& ship : system.ships) {
      if (ship.player == player) {
        total += 100 * ship.pyramid.size * ship.pyramid.size;
      }
    }
  }

  return total;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3c80
cmpl -0x1c(%rbp), %eax
jne 0x1455d
movl $0xf4240, -0x4(%rbp)    # imm = 0xF4240
jmp 0x14654
movq -0x18(%rbp), %rdi
callq 0x3c80
cmpl $0x0, %eax
je 0x14577
movl $0x0, -0x4(%rbp)
jmp 0x14654
jmp 0x14579
movl $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3b80
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x8ae0
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x8b10
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x8b40
testb $0x1, %al
jne 0x145bd
jmp 0x1464e
leaq -0x30(%rbp), %rdi
callq 0x8b80
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
callq 0x8be0
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rdi
callq 0x8c10
movq %rax, -0x58(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x8ba0
testb $0x1, %al
jne 0x14603
jmp 0x1463e
leaq -0x50(%rbp), %rdi
callq 0x8fb0
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
movl (%rax), %eax
cmpl -0x1c(%rbp), %eax
jne 0x14631
movq -0x60(%rbp), %rax
imull $0x64, 0x4(%rax), %eax
movq -0x60(%rbp), %rcx
imull 0x4(%rcx), %eax
addl -0x20(%rbp), %eax
movl %eax, -0x20(%rbp)
jmp 0x14633
leaq -0x50(%rbp), %rdi
callq 0x8fd0
jmp 0x145f0
jmp 0x14640
leaq -0x30(%rbp), %rdi
callq 0x8c40
jmp 0x145a7
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: czinn[P]homeworlds/game_io.cc
// Function: operator<<(std::ostream&, System const&)
std::ostream& operator<<(std::ostream &os, const System& system) {
  os << "(";
  if (system.player != 0) {
    os << system.player << ", ";
  }
  for (const Pyramid& pyramid : system.stars) {
    os << pyramid;
  }
  os << ")";
  for (const Ship& ship : system.ships) {
    os << " " << ship;
  }
  return os;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x6586(%rip), %rsi      # 0x24251
callq 0x3220
movq -0x10(%rbp), %rax
cmpl $0x0, 0x4(%rax)
je 0x1dcf9
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x4(%rax), %esi
callq 0x33b0
movq %rax, %rdi
leaq 0x655f(%rip), %rsi      # 0x24253
callq 0x3220
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x90e0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x9110
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x9140
testb $0x1, %al
jne 0x1dd32
jmp 0x1dd57
leaq -0x20(%rbp), %rdi
callq 0x9180
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x1dc20
leaq -0x20(%rbp), %rdi
callq 0x91a0
jmp 0x1dd1f
movq -0x8(%rbp), %rdi
leaq 0x64a8(%rip), %rsi      # 0x2420a
callq 0x3220
movq -0x10(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x8be0
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
callq 0x8c10
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x8ba0
testb $0x1, %al
jne 0x1dda0
jmp 0x1ddd4
leaq -0x40(%rbp), %rdi
callq 0x8fb0
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x649c(%rip), %rsi      # 0x24254
callq 0x3220
movq %rax, %rdi
movq -0x50(%rbp), %rsi
callq 0x1dc70
leaq -0x40(%rbp), %rdi
callq 0x8fd0
jmp 0x1dd8d
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: czinn[P]homeworlds/game_io.cc
// Function: print_game(std::ostream&, Game const&, std::map<int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<int>, std::allocator<std::pair<int const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>> const&)
void print_game(std::ostream& os, const Game& game,
                const std::map<int, std::string>& system_names) {
  os << game.num_players() << " ";
  os << game.homeworlds_built() << " ";
  os << game.cur_player() << std::endl;
  for (const System& system : game.systems()) {
    os << system_names.at(system.id) << " " << system << std::endl;
  }
  os << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3ab0
movq -0x50(%rbp), %rdi
movl %eax, %esi
callq 0x33b0
movq %rax, %rdi
leaq 0x5e2a(%rip), %rsi      # 0x24254
callq 0x3220
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3b00
movq -0x48(%rbp), %rdi
movl %eax, %esi
callq 0x33b0
movq %rax, %rdi
leaq 0x5dff(%rip), %rsi      # 0x24254
callq 0x3220
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3ac0
movq -0x40(%rbp), %rdi
movl %eax, %esi
callq 0x33b0
movq %rax, %rdi
movq 0x17b30(%rip), %rsi     # 0x35fb0
callq 0x3260
movq -0x10(%rbp), %rdi
callq 0x3b80
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x8ae0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x8b10
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x8b40
testb $0x1, %al
jne 0x1e4bf
jmp 0x1e522
leaq -0x28(%rbp), %rdi
callq 0x8b80
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x1f240
movq -0x58(%rbp), %rdi
movq %rax, %rsi
callq 0x3200
movq %rax, %rdi
leaq 0x5d5d(%rip), %rsi      # 0x24254
callq 0x3220
movq %rax, %rdi
movq -0x38(%rbp), %rsi
callq 0x1dcb0
movq %rax, %rdi
movq 0x17a9e(%rip), %rsi     # 0x35fb0
callq 0x3260
leaq -0x28(%rbp), %rdi
callq 0x8c40
jmp 0x1e4ac
movq -0x8(%rbp), %rdi
movq 0x17a83(%rip), %rsi     # 0x35fb0
callq 0x3260
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: czinn[P]homeworlds/game_io.cc
// Function: operator>>(std::istream&, Pyramid&)
std::istream& operator>>(std::istream& is, Pyramid& pyramid) {
  is >> std::ws;
  char c;
  is.get(c);
  pyramid.colour =
    c == 'r' || c == 'R' ? RED :
    c == 'y' || c == 'Y' ? YELLOW :
    c == 'g' || c == 'G' ? GREEN : BLUE;
  int size;
  is >> size;
  pyramid.size = (Size)size;
  return is;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq 0x17a6d(%rip), %rsi     # 0x35fc8
callq 0x3090
movq -0x8(%rbp), %rdi
leaq -0x11(%rbp), %rsi
callq 0x3310
movsbl -0x11(%rbp), %eax
cmpl $0x72, %eax
je 0x1e57f
movsbl -0x11(%rbp), %eax
cmpl $0x52, %eax
jne 0x1e586
xorl %eax, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1e5d9
movsbl -0x11(%rbp), %eax
cmpl $0x79, %eax
je 0x1e598
movsbl -0x11(%rbp), %eax
cmpl $0x59, %eax
jne 0x1e5a2
movl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x1e5d3
movsbl -0x11(%rbp), %ecx
movb $0x1, %al
cmpl $0x67, %ecx
movb %al, -0x21(%rbp)
je 0x1e5bd
movsbl -0x11(%rbp), %eax
cmpl $0x47, %eax
sete %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %dl
movl $0x3, %eax
movl $0x2, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x8(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x3150
movl -0x18(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: czinn[P]homeworlds/game_io.cc
// Function: operator>>(std::istream&, Ship&)
std::istream& operator>>(std::istream& is, Ship& ship) {
  is >> std::ws;
  char c;
  is.get(c);
  ship.player = (int)(c - '0');
  is >> ship.pyramid;
  return is;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq 0x1799d(%rip), %rsi     # 0x35fc8
callq 0x3090
movq -0x8(%rbp), %rdi
leaq -0x11(%rbp), %rsi
callq 0x3310
movsbl -0x11(%rbp), %ecx
subl $0x30, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x4, %rsi
callq 0x1e540
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: czinn[P]homeworlds/game_io.cc
// Function: operator>>(std::istream&, System&)
std::istream& operator>>(std::istream& is, System& system) {
  system.player = 0;
  system.id = 0;
  is >> std::ws;
  is.ignore(); // (
  if (std::isdigit(is.peek())) {
    is >> system.player;
    is.ignore(256, ' ');
  }
  while (is.peek() != ')') {
    Pyramid star;
    is >> star;
    system.stars.push_back(star);
  }
  is.ignore(); // )
  while (!is.eof()) {
    Ship ship;
    is >> ship;
    system.ships.push_back(ship);
  }
  return is;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
movq -0x8(%rbp), %rdi
movq 0x17928(%rip), %rsi     # 0x35fc8
callq 0x3090
movq -0x8(%rbp), %rdi
callq 0x33f0
movq -0x8(%rbp), %rdi
callq 0x30b0
movl %eax, %edi
callq 0x3210
cmpl $0x0, %eax
je 0x1e6e7
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x4, %rsi
callq 0x3150
movq -0x8(%rbp), %rdi
movl $0x100, %esi            # imm = 0x100
movl $0x20, %edx
callq 0x3180
jmp 0x1e6e9
movq -0x8(%rbp), %rdi
callq 0x30b0
cmpl $0x29, %eax
je 0x1e717
movq -0x8(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x1e540
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
leaq -0x18(%rbp), %rsi
callq 0x1f340
jmp 0x1e6e9
movq -0x8(%rbp), %rdi
callq 0x33f0
movq -0x8(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x3400
xorb $-0x1, %al
testb $0x1, %al
jne 0x1e738
jmp 0x1e758
movq -0x8(%rbp), %rdi
leaq -0x24(%rbp), %rsi
callq 0x1e610
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
leaq -0x24(%rbp), %rsi
callq 0x99b0
jmp 0x1e720
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ehw-fit[P]py-paretoarchive/src/paretoarchive/core.cpp
// Function: _pyx_CyFunction_init()
static int __pyx_CyFunction_init(void) {
    __pyx_CyFunctionType = __Pyx_FetchCommonType(&__pyx_CyFunctionType_type);
    if (unlikely(__pyx_CyFunctionType == NULL)) {
        return -1;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x7c931(%rip), %rdi     # 0xa74b0
callq 0x2c710
movq %rax, 0x819b5(%rip)     # 0xac540
cmpq $0x0, 0x819ad(%rip)     # 0xac540
sete %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x2aba0
jmp 0x2aba9
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2abb0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: ehw-fit[P]py-paretoarchive/src/paretoarchive/core.cpp
// Function: _Pyx_InitCachedBuiltins()
static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(void) {
  __pyx_builtin_range = __Pyx_GetBuiltinName(__pyx_n_s_range); if (!__pyx_builtin_range) __PYX_ERR(0, 99, __pyx_L1_error)
  __pyx_builtin_enumerate = __Pyx_GetBuiltinName(__pyx_n_s_enumerate); if (!__pyx_builtin_enumerate) __PYX_ERR(0, 1295, __pyx_L1_error)
  __pyx_builtin_sorted = __Pyx_GetBuiltinName(__pyx_n_s_sorted); if (!__pyx_builtin_sorted) __PYX_ERR(0, 1300, __pyx_L1_error)
  return 0;
  __pyx_L1_error:;
  return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x81589(%rip), %rdi     # 0xac6e8
callq 0x2df40
movq %rax, 0x815bd(%rip)     # 0xac728
cmpq $0x0, 0x815b5(%rip)     # 0xac728
jne 0x2b19c
movq 0x7c2e4(%rip), %rax     # 0xa7460
movq %rax, 0x813c5(%rip)     # 0xac548
movl $0x63, 0x813c3(%rip)    # 0xac550
movl $0x62bb, 0x813bd(%rip)  # imm = 0x62BB
jmp 0x2b227
movq 0x814ad(%rip), %rdi     # 0xac650
callq 0x2df40
movq %rax, 0x81581(%rip)     # 0xac730
cmpq $0x0, 0x81579(%rip)     # 0xac730
jne 0x2b1dd
movq 0x7c2a0(%rip), %rax     # 0xa7460
movq %rax, 0x81381(%rip)     # 0xac548
movl $0x50f, 0x8137f(%rip)   # imm = 0x50F
movl $0x62bc, 0x81379(%rip)  # imm = 0x62BC
jmp 0x2b227
movq 0x81534(%rip), %rdi     # 0xac718
callq 0x2df40
movq %rax, 0x81548(%rip)     # 0xac738
cmpq $0x0, 0x81540(%rip)     # 0xac738
jne 0x2b21e
movq 0x7c25f(%rip), %rax     # 0xa7460
movq %rax, 0x81340(%rip)     # 0xac548
movl $0x514, 0x8133e(%rip)   # imm = 0x514
movl $0x62bd, 0x81338(%rip)  # imm = 0x62BD
jmp 0x2b227
movl $0x0, -0x4(%rbp)
jmp 0x2b22e
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: ehw-fit[P]py-paretoarchive/src/paretoarchive/core.cpp
// Function: _Pyx_CyFunction_New(PyMethodDef*, int, _object*, _object*, _object*, _object*, _object*)
static PyObject *__Pyx_CyFunction_New(PyMethodDef *ml, int flags, PyObject* qualname,
                                      PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) {
    PyObject *op = __Pyx_CyFunction_Init(
        PyObject_GC_New(__pyx_CyFunctionObject, __pyx_CyFunctionType),
        ml, flags, qualname, closure, module, globals, code
    );
    if (likely(op)) {
        PyObject_GC_Track(op);
    }
    return op;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq 0x801d6(%rip), %rdi     # 0xac540
callq 0x295b0
movq %rax, %rdi
movq -0x8(%rbp), %rsi
movl -0xc(%rbp), %edx
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
movq -0x28(%rbp), %r9
movq -0x30(%rbp), %r10
movq 0x10(%rbp), %rax
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x63220
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x2c3b1
jmp 0x2c3ba
movq -0x38(%rbp), %rdi
callq 0x296b0
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ehw-fit[P]py-paretoarchive/src/paretoarchive/core.cpp
// Function: _Pyx_Py3ClassCreate(_object*, _object*, _object*, _object*, _object*, int, int)
static PyObject *__Pyx_Py3ClassCreate(PyObject *metaclass, PyObject *name, PyObject *bases,
                                      PyObject *dict, PyObject *mkw,
                                      int calculate_metaclass, int allow_py2_metaclass) {
    PyObject *result, *margs;
    PyObject *owned_metaclass = NULL;
    if (allow_py2_metaclass) {
        owned_metaclass = PyObject_GetItem(dict, __pyx_n_s_metaclass);
        if (owned_metaclass) {
            metaclass = owned_metaclass;
        } else if (likely(PyErr_ExceptionMatches(PyExc_KeyError))) {
            PyErr_Clear();
        } else {
            return NULL;
        }
    }
    if (calculate_metaclass && (!metaclass || PyType_Check(metaclass))) {
        metaclass = __Pyx_CalculateMetaclass((PyTypeObject*) metaclass, bases);
        Py_XDECREF(owned_metaclass);
        if (unlikely(!metaclass))
            return NULL;
        owned_metaclass = metaclass;
    }
    margs = PyTuple_Pack(3, name, bases, dict);
    if (unlikely(!margs)) {
        result = NULL;
    } else {
        result = PyObject_Call(metaclass, margs, mkw);
        Py_DECREF(margs);
    }
    Py_XDECREF(owned_metaclass);
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl 0x10(%rbp), %eax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movl %r9d, -0x34(%rbp)
movq $0x0, -0x50(%rbp)
cmpl $0x0, 0x10(%rbp)
je 0x2c4cd
movq -0x28(%rbp), %rdi
movq 0x801fc(%rip), %rsi     # 0xac678
callq 0x294f0
movq %rax, -0x50(%rbp)
cmpq $0x0, -0x50(%rbp)
je 0x2c496
movq -0x50(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x2c4cb
movq 0x7a8eb(%rip), %rax     # 0xa6d88
movq (%rax), %rdi
callq 0x29350
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x2c4b5
jmp 0x2c4bc
callq 0x293e0
jmp 0x2c4c9
movq $0x0, -0x8(%rbp)
jmp 0x2c591
jmp 0x2c4cb
jmp 0x2c4cd
cmpl $0x0, -0x34(%rbp)
je 0x2c528
cmpq $0x0, -0x10(%rbp)
je 0x2c4e8
movq -0x10(%rbp), %rdi
callq 0x2c860
cmpl $0x0, %eax
je 0x2c528
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x67a70
movq %rax, -0x10(%rbp)
movq -0x50(%rbp), %rdi
callq 0x2a8d0
cmpq $0x0, -0x10(%rbp)
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x2c516
jmp 0x2c520
movq $0x0, -0x8(%rbp)
jmp 0x2c591
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movl $0x3, %edi
movb $0x0, %al
callq 0x290d0
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x2c558
jmp 0x2c562
movq $0x0, -0x40(%rbp)
jmp 0x2c580
movq -0x10(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x290c0
movq %rax, -0x40(%rbp)
movq -0x48(%rbp), %rdi
callq 0x2a7e0
movq -0x50(%rbp), %rdi
callq 0x2a8d0
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: ehw-fit[P]py-paretoarchive/src/paretoarchive/core.cpp
// Function: _Pyx_FetchCommonType(_typeobject*)
static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type) {
    PyObject* fake_module;
    PyTypeObject* cached_type = NULL;
    fake_module = PyImport_AddModule((char*) "_cython_" CYTHON_ABI);
    if (!fake_module) return NULL;
    Py_INCREF(fake_module);
    cached_type = (PyTypeObject*) PyObject_GetAttrString(fake_module, type->tp_name);
    if (cached_type) {
        if (!PyType_Check((PyObject*)cached_type)) {
            PyErr_Format(PyExc_TypeError,
                "Shared Cython type %.200s is not a type object",
                type->tp_name);
            goto bad;
        }
        if (cached_type->tp_basicsize != type->tp_basicsize) {
            PyErr_Format(PyExc_TypeError,
                "Shared Cython type %.200s has the wrong size, try recompiling",
                type->tp_name);
            goto bad;
        }
    } else {
        if (!PyErr_ExceptionMatches(PyExc_AttributeError)) goto bad;
        PyErr_Clear();
        if (PyType_Ready(type) < 0) goto bad;
        if (PyObject_SetAttrString(fake_module, type->tp_name, (PyObject*) type) < 0)
            goto bad;
        Py_INCREF(type);
        cached_type = type;
    }
done:
    Py_DECREF(fake_module);
    return cached_type;
bad:
    Py_XDECREF(cached_type);
    cached_type = NULL;
    goto done;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x20(%rbp)
leaq 0x62159(%rip), %rdi     # 0x8e884
callq 0x290b0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x2c748
movq $0x0, -0x8(%rbp)
jmp 0x2c856
movq -0x18(%rbp), %rdi
callq 0x2a7c0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x29110
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x2c7d6
movq -0x20(%rbp), %rdi
callq 0x2c860
cmpl $0x0, %eax
jne 0x2c7a0
movq 0x7a79e(%rip), %rax     # 0xa6f20
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdx
leaq 0x62100(%rip), %rsi     # 0x8e894
movb $0x0, %al
callq 0x292e0
jmp 0x2c843
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x20(%rcx), %rax
je 0x2c7d4
movq 0x7a767(%rip), %rax     # 0xa6f20
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdx
leaq 0x620f8(%rip), %rsi     # 0x8e8c3
movb $0x0, %al
callq 0x292e0
jmp 0x2c843
jmp 0x2c82e
movq 0x7a613(%rip), %rax     # 0xa6df0
movq (%rax), %rdi
callq 0x29350
cmpl $0x0, %eax
jne 0x2c7ec
jmp 0x2c843
callq 0x293e0
movq -0x10(%rbp), %rdi
callq 0x29510
cmpl $0x0, %eax
jge 0x2c801
jmp 0x2c843
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x10(%rbp), %rdx
callq 0x294a0
cmpl $0x0, %eax
jge 0x2c81d
jmp 0x2c843
movq -0x10(%rbp), %rdi
callq 0x2a7c0
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x2c830
movq -0x18(%rbp), %rdi
callq 0x2a7e0
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2c856
movq -0x20(%rbp), %rdi
callq 0x2a8d0
movq $0x0, -0x20(%rbp)
jmp 0x2c830
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: ehw-fit[P]py-paretoarchive/src/paretoarchive/core.cpp
// Function: _Pyx_CyFunction_CallAsMethod(_object*, _object*, _object*)
static PyObject *__Pyx_CyFunction_CallAsMethod(PyObject *func, PyObject *args, PyObject *kw) {
    PyObject *result;
    __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *) func;
    if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !(cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD)) {
        Py_ssize_t argc;
        PyObject *new_args;
        PyObject *self;
        argc = PyTuple_GET_SIZE(args);
        new_args = PyTuple_GetSlice(args, 1, argc);
        if (unlikely(!new_args))
            return NULL;
        self = PyTuple_GetItem(args, 0);
        if (unlikely(!self)) {
            Py_DECREF(new_args);
#if PY_MAJOR_VERSION > 2
            PyErr_Format(PyExc_TypeError,
                         "unbound method %.200S() needs an argument",
                         cyfunc->func_qualname);
#else
            PyErr_SetString(PyExc_TypeError,
                            "unbound method needs an argument");
#endif
            return NULL;
        }
        result = __Pyx_CyFunction_CallMethod(func, self, new_args, kw);
        Py_DECREF(new_args);
    } else {
        result = __Pyx_CyFunction_Call(func, args, kw);
    }
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl 0x90(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x2ca37
movq -0x30(%rbp), %rax
movl 0x90(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x2ca37
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
movq -0x38(%rbp), %rdx
movl $0x1, %esi
callq 0x29070
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x2c9ae
jmp 0x2c9bb
movq $0x0, -0x8(%rbp)
jmp 0x2ca54
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x296c0
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x2c9e0
jmp 0x2ca13
movq -0x40(%rbp), %rdi
callq 0x2a7e0
movq 0x7a530(%rip), %rax     # 0xa6f20
movq (%rax), %rdi
movq -0x30(%rbp), %rax
movq 0x48(%rax), %rdx
leaq 0x61f2f(%rip), %rsi     # 0x8e931
movb $0x0, %al
callq 0x292e0
movq $0x0, -0x8(%rbp)
jmp 0x2ca54
movq -0x10(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x2d0a0
movq %rax, -0x28(%rbp)
movq -0x40(%rbp), %rdi
callq 0x2a7e0
jmp 0x2ca4c
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x2d300
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: ehw-fit[P]py-paretoarchive/src/paretoarchive/core.cpp
// Function: _Pyx__CyFunction_dealloc(__pyx_CyFunctionObject*)
static void __Pyx__CyFunction_dealloc(__pyx_CyFunctionObject *m)
{
    if (__Pyx_CyFunction_weakreflist(m) != NULL)
        PyObject_ClearWeakRefs((PyObject *) m);
    __Pyx_CyFunction_clear(m);
    PyObject_GC_Del(m);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x2d080
movq -0x8(%rbp), %rdi
callq 0x29540
movq -0x8(%rbp), %rdi
callq 0x2cd70
movq -0x8(%rbp), %rdi
callq 0x294c0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: ehw-fit[P]py-paretoarchive/src/paretoarchive/core.cpp
// Function: _Pyx_CyFunction_get_doc(__pyx_CyFunctionObject*, void*)
static PyObject *
__Pyx_CyFunction_get_doc(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *closure)
{
    if (unlikely(op->func_doc == NULL)) {
        if (op->func.m_ml->ml_doc) {
#if PY_MAJOR_VERSION >= 3
            op->func_doc = PyUnicode_FromString(op->func.m_ml->ml_doc);
#else
            op->func_doc = PyString_FromString(op->func.m_ml->ml_doc);
#endif
            if (unlikely(op->func_doc == NULL))
                return NULL;
        } else {
            Py_INCREF(Py_None);
            return Py_None;
        }
    }
    Py_INCREF(op->func_doc);
    return op->func_doc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x50(%rax)
sete %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x2d396
jmp 0x2d3fe
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
cmpq $0x0, 0x18(%rax)
je 0x2d3e3
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x18(%rax), %rdi
callq 0x293a0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x50(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x50(%rax)
sete %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x2d3d7
jmp 0x2d3e1
movq $0x0, -0x8(%rbp)
jmp 0x2d417
jmp 0x2d3fc
movq 0x799fe(%rip), %rdi     # 0xa6de8
callq 0x2a7c0
movq 0x799f2(%rip), %rax     # 0xa6de8
movq %rax, -0x8(%rbp)
jmp 0x2d417
jmp 0x2d3fe
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rdi
callq 0x2a7c0
movq -0x10(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ehw-fit[P]py-paretoarchive/src/paretoarchive/core.cpp
// Function: _Pyx_CyFunction_set_doc(__pyx_CyFunctionObject*, _object*, void*)
static int
__Pyx_CyFunction_set_doc(__pyx_CyFunctionObject *op, PyObject *value, CYTHON_UNUSED void *context)
{
    PyObject *tmp = op->func_doc;
    if (value == NULL) {
        value = Py_None;
    }
    Py_INCREF(value);
    op->func_doc = value;
    Py_XDECREF(tmp);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x2d462
movq 0x7998a(%rip), %rax     # 0xa6de8
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2a7c0
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x50(%rax)
movq -0x20(%rbp), %rdi
callq 0x2a8d0
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: ehw-fit[P]py-paretoarchive/src/paretoarchive/core.cpp
// Function: _Pyx_CyFunction_get_name(__pyx_CyFunctionObject*, void*)
static PyObject *
__Pyx_CyFunction_get_name(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *context)
{
    if (unlikely(op->func_name == NULL)) {
#if PY_MAJOR_VERSION >= 3
        op->func_name = PyUnicode_InternFromString(op->func.m_ml->ml_name);
#else
        op->func_name = PyString_InternFromString(op->func.m_ml->ml_name);
#endif
        if (unlikely(op->func_name == NULL))
            return NULL;
    }
    Py_INCREF(op->func_name);
    return op->func_name;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x40(%rax)
sete %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x2d4b6
jmp 0x2d4f3
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rdi
callq 0x291f0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x40(%rax)
sete %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x2d4e7
jmp 0x2d4f1
movq $0x0, -0x8(%rbp)
jmp 0x2d50c
jmp 0x2d4f3
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x2a7c0
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ehw-fit[P]py-paretoarchive/src/paretoarchive/core.cpp
// Function: _Pyx_CyFunction_set_name(__pyx_CyFunctionObject*, _object*, void*)
static int
__Pyx_CyFunction_set_name(__pyx_CyFunctionObject *op, PyObject *value, CYTHON_UNUSED void *context)
{
    PyObject *tmp;
#if PY_MAJOR_VERSION >= 3
    if (unlikely(value == NULL || !PyUnicode_Check(value)))
#else
    if (unlikely(value == NULL || !PyString_Check(value)))
#endif
    {
        PyErr_SetString(PyExc_TypeError,
                        "__name__ must be set to a string object");
        return -1;
    }
    tmp = op->func_name;
    Py_INCREF(value);
    op->func_name = value;
    Py_XDECREF(tmp);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movb $0x1, %al
cmpq $0x0, -0x18(%rbp)
movb %al, -0x29(%rbp)
je 0x2d55d
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movl $0x10000000, %esi       # imm = 0x10000000
callq 0x2c890
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x2d56a
jmp 0x2d589
movq 0x799af(%rip), %rax     # 0xa6f20
movq (%rax), %rdi
leaq 0x61581(%rip), %rsi     # 0x8eafc
callq 0x29450
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2d5ba
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2a7c0
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x28(%rbp), %rdi
callq 0x2a8d0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ehw-fit[P]py-paretoarchive/src/paretoarchive/core.cpp
// Function: _Pyx_CyFunction_set_qualname(__pyx_CyFunctionObject*, _object*, void*)
static int
__Pyx_CyFunction_set_qualname(__pyx_CyFunctionObject *op, PyObject *value, CYTHON_UNUSED void *context)
{
    PyObject *tmp;
#if PY_MAJOR_VERSION >= 3
    if (unlikely(value == NULL || !PyUnicode_Check(value)))
#else
    if (unlikely(value == NULL || !PyString_Check(value)))
#endif
    {
        PyErr_SetString(PyExc_TypeError,
                        "__qualname__ must be set to a string object");
        return -1;
    }
    tmp = op->func_qualname;
    Py_INCREF(value);
    op->func_qualname = value;
    Py_XDECREF(tmp);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movb $0x1, %al
cmpq $0x0, -0x18(%rbp)
movb %al, -0x29(%rbp)
je 0x2d63d
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movl $0x10000000, %esi       # imm = 0x10000000
callq 0x2c890
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x2d64a
jmp 0x2d669
movq 0x798cf(%rip), %rax     # 0xa6f20
movq (%rax), %rdi
leaq 0x614c9(%rip), %rsi     # 0x8eb24
callq 0x29450
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2d69a
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2a7c0
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x48(%rax)
movq -0x28(%rbp), %rdi
callq 0x2a8d0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ehw-fit[P]py-paretoarchive/src/paretoarchive/core.cpp
// Function: _Pyx_CyFunction_get_self(__pyx_CyFunctionObject*, void*)
static PyObject *
__Pyx_CyFunction_get_self(__pyx_CyFunctionObject *m, CYTHON_UNUSED void *closure)
{
    PyObject *self;
    self = m->func_closure;
    if (self == NULL)
        self = Py_None;
    Py_INCREF(self);
    return self;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x2d6de
movq 0x7970e(%rip), %rax     # 0xa6de8
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2a7c0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ehw-fit[P]py-paretoarchive/src/paretoarchive/core.cpp
// Function: _Pyx_CyFunction_get_dict(__pyx_CyFunctionObject*, void*)
static PyObject *
__Pyx_CyFunction_get_dict(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *context)
{
    if (unlikely(op->func_dict == NULL)) {
        op->func_dict = PyDict_New();
        if (unlikely(op->func_dict == NULL))
            return NULL;
    }
    Py_INCREF(op->func_dict);
    return op->func_dict;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x38(%rax)
sete %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x2d726
jmp 0x2d758
callq 0x29440
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x38(%rax)
sete %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x2d74c
jmp 0x2d756
movq $0x0, -0x8(%rbp)
jmp 0x2d771
jmp 0x2d758
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x2a7c0
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: ehw-fit[P]py-paretoarchive/src/paretoarchive/core.cpp
// Function: _Pyx_CyFunction_set_dict(__pyx_CyFunctionObject*, _object*, void*)
static int
__Pyx_CyFunction_set_dict(__pyx_CyFunctionObject *op, PyObject *value, CYTHON_UNUSED void *context)
{
    PyObject *tmp;
    if (unlikely(value == NULL)) {
        PyErr_SetString(PyExc_TypeError,
               "function's dictionary may not be deleted");
        return -1;
    }
    if (unlikely(!PyDict_Check(value))) {
        PyErr_SetString(PyExc_TypeError,
               "setting function's dictionary to a non-dict");
        return -1;
    }
    tmp = op->func_dict;
    Py_INCREF(value);
    op->func_dict = value;
    Py_XDECREF(tmp);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
sete %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x2d7a6
jmp 0x2d7c5
movq 0x79773(%rip), %rax     # 0xa6f20
movq (%rax), %rdi
leaq 0x61399(%rip), %rsi     # 0x8eb50
callq 0x29450
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2d839
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movl $0x20000000, %esi       # imm = 0x20000000
callq 0x2c890
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x2d7e9
jmp 0x2d808
movq 0x79730(%rip), %rax     # 0xa6f20
movq (%rax), %rdi
leaq 0x6137f(%rip), %rsi     # 0x8eb79
callq 0x29450
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2d839
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2a7c0
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x28(%rbp), %rdi
callq 0x2a8d0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ehw-fit[P]py-paretoarchive/src/paretoarchive/core.cpp
// Function: _Pyx_CyFunction_get_defaults(__pyx_CyFunctionObject*, void*)
static PyObject *
__Pyx_CyFunction_get_defaults(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *context) {
    PyObject* result = op->defaults_tuple;
    if (unlikely(!result)) {
        if (op->defaults_getter) {
            if (__Pyx_CyFunction_init_defaults(op) < 0) return NULL;
            result = op->defaults_tuple;
        } else {
            result = Py_None;
        }
    }
    Py_INCREF(result);
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x2d943
jmp 0x2d987
movq -0x10(%rbp), %rax
cmpq $0x0, 0xa8(%rax)
je 0x2d97a
movq -0x10(%rbp), %rdi
callq 0x2dcf0
cmpl $0x0, %eax
jge 0x2d969
movq $0x0, -0x8(%rbp)
jmp 0x2d998
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x2d985
movq 0x79467(%rip), %rax     # 0xa6de8
movq %rax, -0x20(%rbp)
jmp 0x2d987
movq -0x20(%rbp), %rdi
callq 0x2a7c0
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ehw-fit[P]py-paretoarchive/src/paretoarchive/core.cpp
// Function: _Pyx_CyFunction_set_defaults(__pyx_CyFunctionObject*, _object*, void*)
static int
__Pyx_CyFunction_set_defaults(__pyx_CyFunctionObject *op, PyObject* value, CYTHON_UNUSED void *context) {
    PyObject* tmp;
    if (!value) {
        value = Py_None;
    } else if (value != Py_None && !PyTuple_Check(value)) {
        PyErr_SetString(PyExc_TypeError,
                        "__defaults__ must be set to a tuple object");
        return -1;
    }
    Py_INCREF(value);
    tmp = op->defaults_tuple;
    op->defaults_tuple = value;
    Py_XDECREF(tmp);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x2d9d8
movq 0x79416(%rip), %rax     # 0xa6de8
movq %rax, -0x18(%rbp)
jmp 0x2da1d
movq 0x79409(%rip), %rax     # 0xa6de8
cmpq %rax, -0x18(%rbp)
je 0x2da1b
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movl $0x4000000, %esi        # imm = 0x4000000
callq 0x2c890
cmpl $0x0, %eax
jne 0x2da1b
movq 0x7951d(%rip), %rax     # 0xa6f20
movq (%rax), %rdi
leaq 0x61198(%rip), %rsi     # 0x8eba5
callq 0x29450
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2da54
jmp 0x2da1d
movq -0x18(%rbp), %rdi
callq 0x2a7c0
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x98(%rax)
movq -0x28(%rbp), %rdi
callq 0x2a8d0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: ehw-fit[P]py-paretoarchive/src/paretoarchive/core.cpp
// Function: _Pyx_CyFunction_get_kwdefaults(__pyx_CyFunctionObject*, void*)
static PyObject *
__Pyx_CyFunction_get_kwdefaults(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *context) {
    PyObject* result = op->defaults_kwdict;
    if (unlikely(!result)) {
        if (op->defaults_getter) {
            if (__Pyx_CyFunction_init_defaults(op) < 0) return NULL;
            result = op->defaults_kwdict;
        } else {
            result = Py_None;
        }
    }
    Py_INCREF(result);
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0xa0(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x2da93
jmp 0x2dad7
movq -0x10(%rbp), %rax
cmpq $0x0, 0xa8(%rax)
je 0x2daca
movq -0x10(%rbp), %rdi
callq 0x2dcf0
cmpl $0x0, %eax
jge 0x2dab9
movq $0x0, -0x8(%rbp)
jmp 0x2dae8
movq -0x10(%rbp), %rax
movq 0xa0(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x2dad5
movq 0x79317(%rip), %rax     # 0xa6de8
movq %rax, -0x20(%rbp)
jmp 0x2dad7
movq -0x20(%rbp), %rdi
callq 0x2a7c0
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ehw-fit[P]py-paretoarchive/src/paretoarchive/core.cpp
// Function: _Pyx_CyFunction_set_kwdefaults(__pyx_CyFunctionObject*, _object*, void*)
static int
__Pyx_CyFunction_set_kwdefaults(__pyx_CyFunctionObject *op, PyObject* value, CYTHON_UNUSED void *context) {
    PyObject* tmp;
    if (!value) {
        value = Py_None;
    } else if (value != Py_None && !PyDict_Check(value)) {
        PyErr_SetString(PyExc_TypeError,
                        "__kwdefaults__ must be set to a dict object");
        return -1;
    }
    Py_INCREF(value);
    tmp = op->defaults_kwdict;
    op->defaults_kwdict = value;
    Py_XDECREF(tmp);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x2db28
movq 0x792c6(%rip), %rax     # 0xa6de8
movq %rax, -0x18(%rbp)
jmp 0x2db6d
movq 0x792b9(%rip), %rax     # 0xa6de8
cmpq %rax, -0x18(%rbp)
je 0x2db6b
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movl $0x20000000, %esi       # imm = 0x20000000
callq 0x2c890
cmpl $0x0, %eax
jne 0x2db6b
movq 0x793cd(%rip), %rax     # 0xa6f20
movq (%rax), %rdi
leaq 0x61073(%rip), %rsi     # 0x8ebd0
callq 0x29450
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2dba4
jmp 0x2db6d
movq -0x18(%rbp), %rdi
callq 0x2a7c0
movq -0x10(%rbp), %rax
movq 0xa0(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0xa0(%rax)
movq -0x28(%rbp), %rdi
callq 0x2a8d0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: ehw-fit[P]py-paretoarchive/src/paretoarchive/core.cpp
// Function: _Pyx_CyFunction_get_annotations(__pyx_CyFunctionObject*, void*)
static PyObject *
__Pyx_CyFunction_get_annotations(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *context) {
    PyObject* result = op->func_annotations;
    if (unlikely(!result)) {
        result = PyDict_New();
        if (unlikely(!result)) return NULL;
        op->func_annotations = result;
    }
    Py_INCREF(result);
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0xb0(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x2dbe3
jmp 0x2dc19
callq 0x29440
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x2dc00
jmp 0x2dc0a
movq $0x0, -0x8(%rbp)
jmp 0x2dc2a
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0xb0(%rax)
movq -0x20(%rbp), %rdi
callq 0x2a7c0
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ehw-fit[P]py-paretoarchive/src/paretoarchive/core.cpp
// Function: _Pyx_CyFunction_set_annotations(__pyx_CyFunctionObject*, _object*, void*)
static int
__Pyx_CyFunction_set_annotations(__pyx_CyFunctionObject *op, PyObject* value, CYTHON_UNUSED void *context) {
    PyObject* tmp;
    if (!value || value == Py_None) {
        value = NULL;
    } else if (!PyDict_Check(value)) {
        PyErr_SetString(PyExc_TypeError,
                        "__annotations__ must be set to a dict object");
        return -1;
    }
    Py_XINCREF(value);
    tmp = op->func_annotations;
    op->func_annotations = value;
    Py_XDECREF(tmp);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x2dc68
movq 0x79186(%rip), %rax     # 0xa6de8
cmpq %rax, -0x18(%rbp)
jne 0x2dc72
movq $0x0, -0x18(%rbp)
jmp 0x2dcaa
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movl $0x20000000, %esi       # imm = 0x20000000
callq 0x2c890
cmpl $0x0, %eax
jne 0x2dca8
movq 0x79290(%rip), %rax     # 0xa6f20
movq (%rax), %rdi
leaq 0x60f62(%rip), %rsi     # 0x8ebfc
callq 0x29450
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2dce1
jmp 0x2dcaa
movq -0x18(%rbp), %rdi
callq 0x2dda0
movq -0x10(%rbp), %rax
movq 0xb0(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0xb0(%rax)
movq -0x28(%rbp), %rdi
callq 0x2a8d0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: ehw-fit[P]py-paretoarchive/src/paretoarchive/core.cpp
// Function: _Pyx_CyFunction_init_defaults(__pyx_CyFunctionObject*)
static int
__Pyx_CyFunction_init_defaults(__pyx_CyFunctionObject *op) {
    int result = 0;
    PyObject *res = op->defaults_getter((PyObject *) op);
    if (unlikely(!res))
        return -1;
    #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
    op->defaults_tuple = PyTuple_GET_ITEM(res, 0);
    Py_INCREF(op->defaults_tuple);
    op->defaults_kwdict = PyTuple_GET_ITEM(res, 1);
    Py_INCREF(op->defaults_kwdict);
    #else
    op->defaults_tuple = PySequence_ITEM(res, 0);
    if (unlikely(!op->defaults_tuple)) result = -1;
    else {
        op->defaults_kwdict = PySequence_ITEM(res, 1);
        if (unlikely(!op->defaults_kwdict)) result = -1;
    }
    #endif
    Py_DECREF(res);
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0xa8(%rax), %rax
movq -0x10(%rbp), %rdi
callq *%rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x2dd2c
jmp 0x2dd35
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2dd8a
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x98(%rax)
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rdi
callq 0x2a7c0
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0xa0(%rax)
movq -0x10(%rbp), %rax
movq 0xa0(%rax), %rdi
callq 0x2a7c0
movq -0x20(%rbp), %rdi
callq 0x2a7e0
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)