LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: bonetblai[P]mdp-engine/ctp3/./ctp3.h
// Function: state_t::operator<(state_t const&) const
bool operator<(const state_t &s) const {
        return (current_ < s.current_) ||
               ((current_ == s.current_) && (info_ < s.info_)) ||
               ((current_ == s.current_) && (info_ == s.info_) &&
                (memcmp(visited_, s.visited_, words_for_nodes_ * sizeof(unsigned)) < 0));
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movl (%rax), %ecx
movq 0x18(%rsp), %rdx
movb $0x1, %al
cmpl (%rdx), %ecx
movb %al, 0x17(%rsp)
jl 0x5a3a1
movq 0x8(%rsp), %rax
movl (%rax), %eax
movq 0x18(%rsp), %rcx
cmpl (%rcx), %eax
jne 0x5a331
movq 0x8(%rsp), %rdi
addq $0x4, %rdi
movq 0x18(%rsp), %rsi
addq $0x4, %rsi
callq 0x5a3b0
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, 0x17(%rsp)
jne 0x5a3a1
movq 0x8(%rsp), %rax
movl (%rax), %ecx
movq 0x18(%rsp), %rdx
xorl %eax, %eax
cmpl (%rdx), %ecx
movb %al, 0x7(%rsp)
jne 0x5a399
movq 0x8(%rsp), %rdi
addq $0x4, %rdi
movq 0x18(%rsp), %rsi
addq $0x4, %rsi
callq 0x151e0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0x7(%rsp)
jne 0x5a36d
jmp 0x5a399
movq 0x8(%rsp), %rdi
addq $0x4c, %rdi
movq 0x18(%rsp), %rsi
addq $0x4c, %rsi
movslq 0x28f9a(%rip), %rdx     # 0x83320
shlq $0x2, %rdx
callq 0x6180
cmpl $0x0, %eax
setl %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
movb %al, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopl (%rax)
// File: iZhangHui[P]CppPrimer/CH03_StringsVectorsAndArrays/examples/add_using.cc
// Function: main
int main()
{
	cout << "Enter two numbers:" << endl;

	int v1, v2;
	cin >> v1 >> v2;

	cout << "The sum of " << v1 << " and " << v2
	     << " is " << v1 + v2 << endl;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movq 0x2dea(%rip), %rdi      # 0x3fd0
leaq 0xe17(%rip), %rsi       # 0x2004
callq 0x1050
movq %rax, %rdi
movq 0x2dc4(%rip), %rsi      # 0x3fc0
callq 0x1060
movq 0x2dd8(%rip), %rdi      # 0x3fe0
leaq -0x8(%rbp), %rsi
callq 0x1030
movq %rax, %rdi
leaq -0xc(%rbp), %rsi
callq 0x1030
movq 0x2dac(%rip), %rdi      # 0x3fd0
leaq 0xdec(%rip), %rsi       # 0x2017
callq 0x1050
movq %rax, %rdi
movl -0x8(%rbp), %esi
callq 0x1080
movq %rax, %rdi
leaq 0xdde(%rip), %rsi       # 0x2023
callq 0x1050
movq %rax, %rdi
movl -0xc(%rbp), %esi
callq 0x1080
movq %rax, %rdi
leaq 0xdca(%rip), %rsi       # 0x2029
callq 0x1050
movq %rax, %rdi
movl -0x8(%rbp), %esi
addl -0xc(%rbp), %esi
callq 0x1080
movq %rax, %rdi
movq 0x2d44(%rip), %rsi      # 0x3fc0
callq 0x1060
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
// File: cjsmeele[P]stipje/./stipje.hh
// Function: stipje::pixel_format::rgba::unformat(unsigned int)
static constexpr pixel_t unformat(uint32_t x) {
            return (((x << 24))            |
                    ((x <<  8) & 0xff0000) |
                    ((x >>  8) & 0x00ff00) |
                    ((x >> 24) & 0x0000ff));
        }

// Assembly:
movl %edi, -0x4(%rsp)
movl -0x4(%rsp), %eax
shll $0x18, %eax
movl -0x4(%rsp), %ecx
shll $0x8, %ecx
andl $0xff0000, %ecx         # imm = 0xFF0000
orl %ecx, %eax
movl -0x4(%rsp), %ecx
shrl $0x8, %ecx
andl $0xff00, %ecx           # imm = 0xFF00
orl %ecx, %eax
movl -0x4(%rsp), %ecx
shrl $0x18, %ecx
andl $0xff, %ecx
orl %ecx, %eax
retq
nopl (%rax)
// File: xukmin[P]rase/sensor-placers.cc
// Function: RandomizedSensorPlacer::GeneratePositions(std::vector<Position, std::allocator<Position>>*)
void RandomizedSensorPlacer::GeneratePositions(std::vector<Position>* positions) {
  assert(positions != NULL);
  positions->clear();

  // Put the base station at the origin.
  positions->push_back(Position(0.0, 0.0));

  for (int i = 1; i < num_sensors_; i++) {
    positions->push_back(Position(DoubleRand(region_.min_x, region_.max_x),
                                  DoubleRand(region_.min_y, region_.max_y)));
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x5eb1
jmp 0x5ed0
leaq 0xe1ff(%rip), %rdi      # 0x140b7
leaq 0xe20a(%rip), %rsi      # 0x140c9
movl $0x16, %edx
leaq 0xe210(%rip), %rcx      # 0x140db
callq 0x3130
movq -0x10(%rbp), %rdi
callq 0x6130
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x20(%rbp), %rdi
xorps %xmm1, %xmm1
movaps %xmm1, %xmm0
callq 0x6180
movq -0x48(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x6150
movl $0x1, -0x24(%rbp)
movq -0x40(%rbp), %rcx
movl -0x24(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x5f6c
movq -0x40(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, -0x50(%rbp)
movsd 0x10(%rax), %xmm0
movsd 0x20(%rax), %xmm1
callq 0x133a0
movq -0x40(%rbp), %rax
movsd %xmm0, -0x58(%rbp)
movsd 0x18(%rax), %xmm0
movsd 0x28(%rax), %xmm1
callq 0x133a0
movaps %xmm0, %xmm1
movsd -0x58(%rbp), %xmm0
leaq -0x38(%rbp), %rdi
callq 0x6180
movq -0x50(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x6150
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x5f04
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: xukmin[P]rase/sensor-placers.cc
// Function: RegularSensorPlacer::GeneratePositions(std::vector<Position, std::allocator<Position>>*)
void RegularSensorPlacer::GeneratePositions(std::vector<Position>* positions) {
  assert(positions != NULL);
  positions->clear();

  double gap_x = (region_.max_x - region_.min_x) / num_cols_;
  double gap_y = (region_.max_y - region_.min_y) / num_rows_;

  for (int i = 0; i < num_cols_; i++) {
    for (int j = 0; j < num_rows_; j++) {
      positions->push_back(Position(region_.min_x + i * gap_x,
                                    region_.min_y + j * gap_y));
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x5fa1
jmp 0x5fc0
leaq 0xe10f(%rip), %rdi      # 0x140b7
leaq 0xe11a(%rip), %rsi      # 0x140c9
movl $0x23, %edx
leaq 0xe170(%rip), %rcx      # 0x1412b
callq 0x3130
movq -0x10(%rbp), %rdi
callq 0x6130
movq -0x40(%rbp), %rax
movsd 0x20(%rax), %xmm0
subsd 0x10(%rax), %xmm0
cvtsi2sdl 0x8(%rax), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movsd 0x28(%rax), %xmm0
subsd 0x18(%rax), %xmm0
cvtsi2sdl 0xc(%rax), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x40(%rbp), %rcx
movl -0x24(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x608e
movl $0x0, -0x28(%rbp)
movq -0x40(%rbp), %rcx
movl -0x28(%rbp), %eax
cmpl 0xc(%rcx), %eax
jge 0x607e
movq -0x40(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, -0x48(%rbp)
movsd 0x10(%rax), %xmm1
cvtsi2sdl -0x24(%rbp), %xmm0
movsd -0x18(%rbp), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd 0x18(%rax), %xmm2
cvtsi2sdl -0x28(%rbp), %xmm1
movsd -0x20(%rbp), %xmm3
mulsd %xmm3, %xmm1
addsd %xmm2, %xmm1
leaq -0x38(%rbp), %rdi
callq 0x6180
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x6150
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x6017
jmp 0x6080
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x6004
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: xukmin[P]rase/sensor-placers.cc
// Function: GeneratePositionsThatCanBeConnected(double, SensorPlacer*, std::vector<Position, std::allocator<Position>>*)
void GeneratePositionsThatCanBeConnected(double communication_range,
                                         SensorPlacer* placer,
                                         std::vector<Position>* positions) {
  double min_communication_range;
  int retries = 10;
  while (retries-- > 0) {
    placer->GeneratePositions(positions);
    if (communication_range >= CalculateMinimumCommunicationRange(*positions)) {
      return;
    }
  }
  fprintf(stderr, "Failed to generate sensors with given communication range!\n");
  exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movsd %xmm0, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0xa, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x24(%rbp)
cmpl $0x0, %eax
jle 0x6103
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq (%rdi), %rax
callq *0x10(%rax)
movsd -0x8(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x7d40
movaps %xmm0, %xmm1
movsd -0x30(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jb 0x6101
addq $0x30, %rsp
popq %rbp
retq
jmp 0x60bc
movq 0x19ece(%rip), %rax     # 0x1ffd8
movq (%rax), %rdi
leaq 0xe064(%rip), %rsi      # 0x14178
movb $0x0, %al
callq 0x32d0
movl $0x1, %edi
callq 0x3290
nopw %cs:(%rax,%rax)
nop
// File: xukmin[P]rase/sensor-network.cc
// Function: SensorNetwork::FindSensorsWithinRange(Position const&, double, std::vector<int, std::allocator<int>>*) const
bool SensorNetwork::FindSensorsWithinRange(const Position& position,
                                           double range,
                                           std::vector<int>* neighbors) const {
  assert(neighbors != NULL);
  neighbors->clear();

  std::vector<int> candidates;
  FindNeighborCandidates(position, range, &candidates);

  for (int i = 0; i < candidates.size(); i++) {
    int c = candidates[i];
    if (Distance(position, sensors_[c].position()) <= range) {
      neighbors->push_back(c);
    }
  }

  return !neighbors->empty();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x706d
jmp 0x708c
leaq 0xd200(%rip), %rdi      # 0x14274
leaq 0xd188(%rip), %rsi      # 0x14203
movl $0x57, %edx
leaq 0xd1ff(%rip), %rcx      # 0x14286
callq 0x3130
movq -0x20(%rbp), %rdi
callq 0x82a0
leaq -0x38(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x8510
movq -0x58(%rbp), %rdi
movq -0x60(%rbp), %rdx
movq -0x10(%rbp), %rsi
movsd -0x18(%rbp), %xmm0
callq 0x6cc0
jmp 0x70ba
movl $0x0, -0x48(%rbp)
movslq -0x48(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x8530
movq %rax, %rcx
movq -0x68(%rbp), %rax
cmpq %rcx, %rax
jae 0x7173
movslq -0x48(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x8550
movq -0x58(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x4c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
movslq -0x4c(%rbp), %rsi
callq 0x8570
movq %rax, %rdi
callq 0x8590
movq %rax, -0x70(%rbp)
jmp 0x7117
movq -0x70(%rbp), %rsi
movq -0x78(%rbp), %rdi
callq 0xf020
movsd %xmm0, -0x80(%rbp)
jmp 0x712b
movsd -0x80(%rbp), %xmm1
movsd -0x18(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jb 0x7163
movq -0x20(%rbp), %rdi
leaq -0x4c(%rbp), %rsi
callq 0x85a0
jmp 0x714a
jmp 0x7163
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x8650
jmp 0x719e
jmp 0x7165
movl -0x48(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x48(%rbp)
jmp 0x70c1
movq -0x20(%rbp), %rdi
callq 0x8610
xorb $-0x1, %al
movb %al, -0x81(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x8650
movb -0x81(%rbp), %al
andb $0x1, %al
addq $0x90, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x3340
nopw (%rax,%rax)
// File: xukmin[P]rase/sensor-network.cc
// Function: SensorNetwork::FindSensorsWithinRange(int, double, std::vector<int, std::allocator<int>>*) const
bool SensorNetwork::FindSensorsWithinRange(int sensor,
                                           double range,
                                           std::vector<int>* neighbors) const {
  assert(neighbors != NULL);
  neighbors->clear();

  std::vector<int> candidates;
  FindNeighborCandidates(sensors_[sensor].position(), range, &candidates);

  for (int i = 0; i < candidates.size(); i++) {
    int c = candidates[i];
    if (distances_[sensor][c] <= range) {
      neighbors->push_back(c);
    }
  }

  return !neighbors->empty();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movsd %xmm0, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x71d9
jmp 0x71f8
leaq 0xd094(%rip), %rdi      # 0x14274
leaq 0xd01c(%rip), %rsi      # 0x14203
movl $0x6a, %edx
leaq 0xd0f2(%rip), %rcx      # 0x142e5
callq 0x3130
movq -0x20(%rbp), %rdi
callq 0x82a0
leaq -0x38(%rbp), %rdi
callq 0x8510
movq -0x58(%rbp), %rdi
movslq -0xc(%rbp), %rsi
callq 0x8570
movq %rax, %rdi
callq 0x8590
movq %rax, -0x60(%rbp)
jmp 0x7225
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdi
movsd -0x18(%rbp), %xmm0
leaq -0x38(%rbp), %rdx
callq 0x6cc0
jmp 0x723d
movl $0x0, -0x48(%rbp)
movslq -0x48(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x8530
movq %rax, %rcx
movq -0x68(%rbp), %rax
cmpq %rcx, %rax
jae 0x72d7
movslq -0x48(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x8550
movq -0x58(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x4c(%rbp)
addq $0x78, %rdi
movslq -0xc(%rbp), %rsi
callq 0x86b0
movq %rax, %rdi
movslq -0x4c(%rbp), %rsi
callq 0x86d0
movsd (%rax), %xmm1
movsd -0x18(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jb 0x72c7
movq -0x20(%rbp), %rdi
leaq -0x4c(%rbp), %rsi
callq 0x85a0
jmp 0x72ae
jmp 0x72c7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x8650
jmp 0x72f9
jmp 0x72c9
movl -0x48(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x48(%rbp)
jmp 0x7244
movq -0x20(%rbp), %rdi
callq 0x8610
xorb $-0x1, %al
movb %al, -0x69(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x8650
movb -0x69(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x3340
nopw %cs:(%rax,%rax)
// File: xukmin[P]rase/sensor-network.cc
// Function: SensorNetwork::CreateChannels(double)
void SensorNetwork::CreateChannels(double communication_range) {
  RemoveChannels();

  communication_range_ = communication_range;
  for (int i = 0; i < sensors_.size(); i++) {
    Sensor& sensor = sensors_[i];
    const Position& p = sensor.position();

    std::vector<int> neighbors;
    FindSensorsWithinRange(i, communication_range, &neighbors);
    for (int j = 0; j < neighbors.size(); j++) {
      if (neighbors[j] != i) {
        sensor.AddNeighbor(neighbors[j]);
      }
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x6c60
movq -0x58(%rbp), %rax
movsd -0x10(%rbp), %xmm0
movsd %xmm0, 0x90(%rax)
movl $0x0, -0x14(%rbp)
movq -0x58(%rbp), %rdi
movslq -0x14(%rbp), %rax
movq %rax, -0x60(%rbp)
callq 0x8180
movq %rax, %rcx
movq -0x60(%rbp), %rax
cmpq %rcx, %rax
jae 0x7443
movq -0x58(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x8260
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x8590
movq %rax, -0x28(%rbp)
leaq -0x40(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x8510
movq -0x58(%rbp), %rdi
movq -0x68(%rbp), %rdx
movl -0x14(%rbp), %esi
movsd -0x10(%rbp), %xmm0
callq 0x71b0
jmp 0x73ac
movl $0x0, -0x50(%rbp)
movslq -0x50(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x8530
movq %rax, %rcx
movq -0x70(%rbp), %rax
cmpq %rcx, %rax
jae 0x742c
movslq -0x50(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x8550
movl (%rax), %eax
cmpl -0x14(%rbp), %eax
je 0x741f
movq -0x20(%rbp), %rax
movq %rax, -0x78(%rbp)
movslq -0x50(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x8550
movq -0x78(%rbp), %rdi
movl (%rax), %esi
callq 0x86f0
jmp 0x7406
jmp 0x741f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x8650
jmp 0x744c
jmp 0x7421
movl -0x50(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x50(%rbp)
jmp 0x73b3
leaq -0x40(%rbp), %rdi
callq 0x8650
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x7349
addq $0x80, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x3340
nopw %cs:(%rax,%rax)
// File: xukmin[P]rase/sensor-network.cc
// Function: SensorNetwork::AddSensors(std::vector<Position, std::allocator<Position>> const&)
void SensorNetwork::AddSensors(const std::vector<Position>& positions) {
  RemoveSensors();
  for (int i = 0; i < positions.size(); i++) {
    AddSensor(positions[i]);
  }

  CalculateDistances(positions, &distances_);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x74e0
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x67a0
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x74c5
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x8720
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x6b20
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x7484
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x78, %rsi
callq 0x7520
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: xukmin[P]rase/sensor-network.cc
// Function: (anonymous namespace)::CalculateDistances(std::vector<Position, std::allocator<Position>> const&, std::vector<std::vector<double, std::allocator<double>>, std::allocator<std::vector<double, std::allocator<double>>>>*)
void CalculateDistances(const std::vector<Position>& positions,
                        std::vector<std::vector<double> >* distances) {
  distances->clear();
  distances->resize(positions.size());
  for (int i = 0; i < distances->size(); i++) {
    (*distances)[i].resize(positions.size());
  }

  for (int i = 0; i < positions.size(); i++) {
    for (int j = i + 1; j < positions.size(); j++) {
      (*distances)[i][j] = (*distances)[j][i] =
          Distance(positions[i], positions[j]);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8df0
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x67a0
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x8e10
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8ea0
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x75ab
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x8b80
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
callq 0x67a0
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x8ed0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x755d
movl $0x0, -0x18(%rbp)
movslq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
callq 0x67a0
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jae 0x768e
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movslq -0x1c(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rdi
callq 0x67a0
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
jae 0x767e
movq -0x8(%rbp), %rdi
movslq -0x18(%rbp), %rsi
callq 0x8720
movq %rax, -0x58(%rbp)
movq -0x8(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x8720
movq -0x58(%rbp), %rdi
movq %rax, %rsi
callq 0xf020
movsd %xmm0, -0x50(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x8b80
movq %rax, %rdi
movslq -0x18(%rbp), %rsi
callq 0x8ba0
movsd -0x50(%rbp), %xmm0
movsd %xmm0, (%rax)
movq -0x10(%rbp), %rdi
movslq -0x18(%rbp), %rsi
callq 0x8b80
movq %rax, %rdi
movslq -0x1c(%rbp), %rsi
callq 0x8ba0
movsd -0x50(%rbp), %xmm0
movsd %xmm0, (%rax)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x75dc
jmp 0x7680
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x75b2
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: xukmin[P]rase/position.cc
// Function: operator<(Position const&, Position const&)
bool operator<(const Position& lhs, const Position& rhs) {
  if (lhs.y != rhs.y) {
    return lhs.y < rhs.y;
  } else {
    return lhs.x < rhs.x;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movsd 0x8(%rax), %xmm0
movq -0x18(%rbp), %rax
ucomisd 0x8(%rax), %xmm0
jne 0xefd4
jp 0xefd4
jmp 0xeff4
movq -0x10(%rbp), %rax
movsd 0x8(%rax), %xmm1
movq -0x18(%rbp), %rax
movsd 0x8(%rax), %xmm0
ucomisd %xmm1, %xmm0
seta %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0xf010
movq -0x10(%rbp), %rax
movsd (%rax), %xmm1
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
ucomisd %xmm1, %xmm0
seta %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw (%rax,%rax)
// File: xukmin[P]rase/routing-builders.cc
// Function: RoutingBuilder::BuildRouting(SensorNetwork*)
void RoutingBuilder::BuildRouting(SensorNetwork* network) {
  network->RemoveParents();
  std::vector<std::vector<int> > candidates;
  bool succeeded = GenerateParentCandidates(network, &candidates);
  assert(succeeded);

  // Base station does not need to and cannot select parent.
  for (int i = 1; i < network->num_sensors(); i++) {
    network->SetParent(i, selector_->SelectParent(i, candidates[i], *network));
  }
  // Make sure the routing generator works as expected.
  assert(network->IsConnectedWithRoutings());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
callq 0x7a20
leaq -0x28(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x10bb0
movq -0x50(%rbp), %rsi
movq -0x10(%rbp), %rdi
callq 0xf090
movb %al, -0x41(%rbp)
jmp 0xf663
movb -0x41(%rbp), %al
andb $0x1, %al
movb %al, -0x29(%rbp)
testb $0x1, -0x29(%rbp)
je 0xf673
jmp 0xf6ac
leaq 0x4ecd(%rip), %rdi      # 0x14547
leaq 0x4e03(%rip), %rsi      # 0x14484
movl $0x57, %edx
leaq 0x4ec4(%rip), %rcx      # 0x14551
callq 0x3130
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x10c00
jmp 0xf77b
movl $0x1, -0x40(%rbp)
movl -0x40(%rbp), %eax
movl %eax, -0x60(%rbp)
movq -0x10(%rbp), %rdi
callq 0x87a0
movl %eax, -0x5c(%rbp)
jmp 0xf6c7
movl -0x60(%rbp), %eax
movl -0x5c(%rbp), %ecx
cmpl %ecx, %eax
jge 0xf731
movq -0x58(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
movl -0x40(%rbp), %eax
movl %eax, -0x68(%rbp)
movq 0x48(%rcx), %rcx
movq %rcx, -0x70(%rbp)
movslq %eax, %rsi
leaq -0x28(%rbp), %rdi
callq 0x10b00
movq -0x70(%rbp), %rdi
movl -0x68(%rbp), %esi
movq %rax, %rdx
movq -0x10(%rbp), %rcx
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movl %eax, -0x64(%rbp)
jmp 0xf713
movl -0x64(%rbp), %edx
movl -0x68(%rbp), %esi
movq -0x78(%rbp), %rdi
callq 0x10bd0
jmp 0xf724
jmp 0xf726
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x40(%rbp)
jmp 0xf6b3
movq -0x10(%rbp), %rdi
callq 0x7a80
movb %al, -0x79(%rbp)
jmp 0xf73f
movb -0x79(%rbp), %al
testb $0x1, %al
jne 0xf748
jmp 0xf74a
jmp 0xf769
leaq 0x4e33(%rip), %rdi      # 0x14584
leaq 0x4d2c(%rip), %rsi      # 0x14484
movl $0x5e, %edx
leaq 0x4ded(%rip), %rcx      # 0x14551
callq 0x3130
leaq -0x28(%rbp), %rdi
callq 0x10c00
addq $0x80, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x3340
nopw %cs:(%rax,%rax)
// File: xukmin[P]rase/routing-builders.cc
// Function: SecondEarliestFirstParentSelector::SelectParent(int, std::vector<int, std::allocator<int>> const&, SensorNetwork const&)
int SecondEarliestFirstParentSelector::SelectParent(
    int sensor,
    const std::vector<int>& candidates,
    const SensorNetwork& network) {
  assert(!candidates.empty());
  if (candidates.size() == 1) {
    return candidates.front();
  } else {
    return candidates[1];
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x8610
xorb $-0x1, %al
testb $0x1, %al
jne 0xf958
jmp 0xf95a
jmp 0xf979
leaq 0x4c46(%rip), %rdi      # 0x145a7
leaq 0x4b1c(%rip), %rsi      # 0x14484
movl $0x80, %edx
leaq 0x4cb3(%rip), %rcx      # 0x14627
callq 0x3130
movq -0x20(%rbp), %rdi
callq 0x8530
cmpq $0x1, %rax
jne 0xf998
movq -0x20(%rbp), %rdi
callq 0x10c60
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0xf9ab
movq -0x20(%rbp), %rdi
movl $0x1, %esi
callq 0x10e00
movl (%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: xukmin[P]rase/routing-builders.cc
// Function: NearestFirstParentSelector::SelectParent(int, std::vector<int, std::allocator<int>> const&, SensorNetwork const&)
int NearestFirstParentSelector::SelectParent(int sensor,
                                             const std::vector<int>& candidates,
                                             const SensorNetwork& network) {
  assert(!candidates.empty());
  int parent = candidates[0];
  double min_distance = network.GetDistance(sensor, parent);
  for (int i = 1; i < candidates.size(); i++) {
    double distance = network.GetDistance(sensor, candidates[i]);
    if (distance < min_distance) {
      parent = candidates[i];
      min_distance = distance;
    }
  }

  return parent;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x8610
xorb $-0x1, %al
testb $0x1, %al
jne 0xfe98
jmp 0xfe9a
jmp 0xfeb9
leaq 0x4706(%rip), %rdi      # 0x145a7
leaq 0x45dc(%rip), %rsi      # 0x14484
movl $0xc0, %edx
leaq 0x490e(%rip), %rcx      # 0x147c2
callq 0x3130
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x10e00
movl (%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x24(%rbp), %edx
callq 0x10f20
movsd %xmm0, -0x30(%rbp)
movl $0x1, -0x34(%rbp)
movslq -0x34(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
callq 0x8530
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
jae 0xff6d
movq -0x20(%rbp), %rax
movq %rax, -0x58(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x4c(%rbp)
movq -0x18(%rbp), %rdi
movslq -0x34(%rbp), %rsi
callq 0x10e00
movq -0x58(%rbp), %rdi
movl -0x4c(%rbp), %esi
movl (%rax), %edx
callq 0x10f20
movsd %xmm0, -0x40(%rbp)
movsd -0x40(%rbp), %xmm1
movsd -0x30(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0xff5d
movq -0x18(%rbp), %rdi
movslq -0x34(%rbp), %rsi
callq 0x10e00
movl (%rax), %eax
movl %eax, -0x24(%rbp)
movsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
jmp 0xff5f
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0xfee6
movl -0x24(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: xukmin[P]rase/routing-builders.cc
// Function: FarthestFirstParentSelector::SelectParent(int, std::vector<int, std::allocator<int>> const&, SensorNetwork const&)
int FarthestFirstParentSelector::SelectParent(int sensor,
                                              const std::vector<int>& candidates,
                                              const SensorNetwork& network) {
  assert(!candidates.empty());
  int parent = candidates[0];
  double max_distance = network.GetDistance(sensor, parent);
  for (int i = 1; i < candidates.size(); i++) {
    double distance = network.GetDistance(sensor, candidates[i]);
    if (distance > max_distance) {
      parent = candidates[i];
      max_distance = distance;
    }
  }

  return parent;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x8610
xorb $-0x1, %al
testb $0x1, %al
jne 0x103f8
jmp 0x103fa
jmp 0x10419
leaq 0x41a6(%rip), %rdi      # 0x145a7
leaq 0x407c(%rip), %rsi      # 0x14484
movl $0x10c, %edx            # imm = 0x10C
leaq 0x44bc(%rip), %rcx      # 0x148d0
callq 0x3130
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x10e00
movl (%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x24(%rbp), %edx
callq 0x10f20
movsd %xmm0, -0x30(%rbp)
movl $0x1, -0x34(%rbp)
movslq -0x34(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
callq 0x8530
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
jae 0x104c6
movq -0x20(%rbp), %rax
movq %rax, -0x58(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x4c(%rbp)
movq -0x18(%rbp), %rdi
movslq -0x34(%rbp), %rsi
callq 0x10e00
movq -0x58(%rbp), %rdi
movl -0x4c(%rbp), %esi
movl (%rax), %edx
callq 0x10f20
movsd %xmm0, -0x40(%rbp)
movsd -0x40(%rbp), %xmm0
ucomisd -0x30(%rbp), %xmm0
jbe 0x104b9
movq -0x18(%rbp), %rdi
movslq -0x34(%rbp), %rsi
callq 0x10e00
movl (%rax), %eax
movl %eax, -0x24(%rbp)
movsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
jmp 0x104bb
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x10446
movl -0x24(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nop
// File: xukmin[P]rase/svg-printer.cc
// Function: SvgPrinter::SvgPrinter(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Region const&, double)
SvgPrinter::SvgPrinter(const std::string& filename,
                       const std::string& title,
                       const Region& region,
                       double scale)
    : filename_(filename), title_(title), region_(region), scale_(scale) {
  file_ = std::fopen(filename_.c_str(), "w");
  if (!file_) {
    fprintf(stderr, "Failed to open file %s!\n", filename_.c_str());
    exit(1);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movsd %xmm0, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rsi
callq 0x30c0
movq -0x48(%rbp), %rdi
addq $0x20, %rdi
movq %rdi, -0x40(%rbp)
movq -0x18(%rbp), %rsi
callq 0x30c0
jmp 0x12c3c
movq -0x50(%rbp), %rdi
movq -0x20(%rbp), %rax
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups %xmm1, 0x50(%rdi)
movups %xmm0, 0x40(%rdi)
movsd -0x28(%rbp), %xmm0
movsd %xmm0, 0x60(%rdi)
callq 0x30b0
movq %rax, %rdi
leaq 0x2034(%rip), %rsi      # 0x14ca0
callq 0x3280
movq %rax, -0x58(%rbp)
jmp 0x12c77
movq -0x50(%rbp), %rax
movq -0x58(%rbp), %rcx
movq %rcx, 0x68(%rax)
cmpq $0x0, 0x68(%rax)
jne 0x12ce5
movq -0x50(%rbp), %rdi
movq 0xd343(%rip), %rax      # 0x1ffd8
movq (%rax), %rax
movq %rax, -0x60(%rbp)
callq 0x30b0
movq -0x60(%rbp), %rdi
movq %rax, %rdx
leaq 0x1ff3(%rip), %rsi      # 0x14ca2
movb $0x0, %al
callq 0x32d0
movl $0x1, %edi
callq 0x3290
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x12ceb
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x3120
jmp 0x12ceb
addq $0x60, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x3120
movq -0x30(%rbp), %rdi
callq 0x3340
nopl (%rax)
// File: Slexis-Works[P]texture-packing/PPMImage.cpp
// Function: PPMImage::PPMImage(unsigned int, unsigned int, RGBColor)
PPMImage::PPMImage(coord width, coord height, RGBColor bgc)
: width(width)
, height(height)
, length(width*height)
, map(NULL)
{
	map = new RGBColor[length];
	assert(map);
	for (size_t i=0 ; i<length ; ++i)
		map[i] = bgc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movw %cx, %ax
movw %ax, -0x3(%rbp)
shrl $0x10, %ecx
movb %cl, %al
movb %al, -0x1(%rbp)
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x14(%rbp), %ecx
movl %ecx, (%rax)
movl -0x18(%rbp), %ecx
movl %ecx, 0x4(%rax)
movl -0x14(%rbp), %ecx
imull -0x18(%rbp), %ecx
movl %ecx, %ecx
movq %rcx, 0x8(%rax)
movq $0x0, 0x10(%rax)
movq 0x8(%rax), %rax
movl $0x3, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x2030
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
cmpq $0x0, 0x10(%rax)
je 0x3202
jmp 0x3221
leaq 0x6e67(%rip), %rdi      # 0xa070
leaq 0x6e64(%rip), %rsi      # 0xa074
movl $0xa, %edx
leaq 0x6e65(%rip), %rcx      # 0xa081
callq 0x20b0
movq $0x0, -0x20(%rbp)
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
cmpq 0x8(%rcx), %rax
jae 0x3262
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
imulq $0x3, -0x20(%rbp), %rcx
addq %rcx, %rax
movw -0x3(%rbp), %cx
movw %cx, (%rax)
movb -0x1(%rbp), %cl
movb %cl, 0x2(%rax)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x3229
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Slexis-Works[P]texture-packing/PPMImage.cpp
// Function: PPMImage::drawPix(unsigned int, unsigned int, RGBColor)
void PPMImage::drawPix(coord x, coord y, RGBColor col) {
	if (/*x < 0 || */x >= width
		|| /*y < 0 ||*/ y >= height)
		return;
	map[y*width + x] = col;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movw %cx, %ax
movw %ax, -0x3(%rbp)
shrl $0x10, %ecx
movb %cl, %al
movb %al, -0x1(%rbp)
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movl -0x14(%rbp), %eax
cmpl (%rcx), %eax
jae 0x32e8
movq -0x20(%rbp), %rcx
movl -0x18(%rbp), %eax
cmpl 0x4(%rcx), %eax
jb 0x32ea
jmp 0x3311
movq -0x20(%rbp), %rdx
movq 0x10(%rdx), %rax
movl -0x18(%rbp), %ecx
imull (%rdx), %ecx
addl -0x14(%rbp), %ecx
movl %ecx, %ecx
imulq $0x3, %rcx, %rcx
addq %rcx, %rax
movw -0x3(%rbp), %cx
movw %cx, (%rax)
movb -0x1(%rbp), %cl
movb %cl, 0x2(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Slexis-Works[P]texture-packing/PPMImage.cpp
// Function: PPMImage::saveImage(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void PPMImage::saveImage(std::string path) {
	std::ofstream file(path);

	file << "P6" << std::endl
		<< width << ' ' << height << std::endl
		<< "255" << std::endl;

	for (coord y=0 ; y<height ; ++y) {
		for (coord x=0 ; x<width ; ++x) {
			RGBColor curp = map[y*width + x];
			file << curp.r << curp.g << curp.b;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x280, %rsp            # imm = 0x280
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x240(%rbp)
leaq -0x210(%rbp), %rdi
movq %rdi, -0x238(%rbp)
movl $0x10, %edx
callq 0x22c0
movq -0x238(%rbp), %rdi
leaq 0x6c88(%rip), %rsi      # 0xa0ac
callq 0x2160
movq %rax, -0x230(%rbp)
jmp 0x3432
movq -0x230(%rbp), %rdi
movq 0xbb88(%rip), %rsi      # 0xefc8
callq 0x2190
movq %rax, -0x248(%rbp)
jmp 0x344e
movq -0x248(%rbp), %rdi
movq -0x240(%rbp), %rax
movl (%rax), %esi
callq 0x2200
movq %rax, -0x250(%rbp)
jmp 0x346c
movq -0x250(%rbp), %rdi
movl $0x20, %esi
callq 0x21e0
movq %rax, -0x258(%rbp)
jmp 0x3486
movq -0x258(%rbp), %rdi
movq -0x240(%rbp), %rax
movl 0x4(%rax), %esi
callq 0x2200
movq %rax, -0x260(%rbp)
jmp 0x34a5
movq -0x260(%rbp), %rdi
movq 0xbb15(%rip), %rsi      # 0xefc8
callq 0x2190
movq %rax, -0x268(%rbp)
jmp 0x34c1
movq -0x268(%rbp), %rdi
leaq 0x6be0(%rip), %rsi      # 0xa0af
callq 0x2160
movq %rax, -0x270(%rbp)
jmp 0x34dd
movq -0x270(%rbp), %rdi
movq 0xbadd(%rip), %rsi      # 0xefc8
callq 0x2190
jmp 0x34f2
movl $0x0, -0x220(%rbp)
movq -0x240(%rbp), %rcx
movl -0x220(%rbp), %eax
cmpl 0x4(%rcx), %eax
jae 0x3601
movl $0x0, -0x224(%rbp)
movq -0x240(%rbp), %rcx
movl -0x224(%rbp), %eax
cmpl (%rcx), %eax
jae 0x35eb
movq -0x240(%rbp), %rdx
movq 0x10(%rdx), %rax
movl -0x220(%rbp), %ecx
movl (%rdx), %edx
imull %edx, %ecx
movl -0x224(%rbp), %edx
addl %edx, %ecx
leaq (%rcx,%rcx,2), %rcx
movb 0x2(%rax,%rcx), %dl
movb %dl, -0x226(%rbp)
movw (%rax,%rcx), %ax
movw %ax, -0x228(%rbp)
movzbl -0x228(%rbp), %esi
leaq -0x210(%rbp), %rdi
callq 0x2240
movq %rax, -0x278(%rbp)
jmp 0x3584
movq -0x278(%rbp), %rdi
movzbl -0x227(%rbp), %esi
callq 0x2240
movq %rax, -0x280(%rbp)
jmp 0x35a0
movq -0x280(%rbp), %rdi
movzbl -0x226(%rbp), %esi
callq 0x2240
jmp 0x35b5
jmp 0x35b7
movl -0x224(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x224(%rbp)
jmp 0x351c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x218(%rbp)
movl %eax, -0x21c(%rbp)
leaq -0x210(%rbp), %rdi
callq 0x2220
jmp 0x3616
jmp 0x35ed
movl -0x220(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x220(%rbp)
jmp 0x34fc
leaq -0x210(%rbp), %rdi
callq 0x2220
addq $0x280, %rsp            # imm = 0x280
popq %rbp
retq
movq -0x218(%rbp), %rdi
callq 0x2290
nopw %cs:(%rax,%rax)
// File: Slexis-Works[P]texture-packing/PPMImage.cpp
// Function: PPMImage::saveImageASCII(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void PPMImage::saveImageASCII(std::string path) {
	std::ofstream file(path);

	file << "P3" << std::endl
		<< width << ' ' << height << std::endl
		<< "255" << std::endl;

	for (coord y=0 ; y<height ; ++y) {
		for (coord x=0 ; x<width ; ++x) {
			RGBColor curp = map[y*width + x];
			file << (int)curp.r << ' ' << (int)curp.g << ' ' << (int)curp.b << ' ';
		}
		file << std::endl;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2a0, %rsp            # imm = 0x2A0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x240(%rbp)
leaq -0x210(%rbp), %rdi
movq %rdi, -0x238(%rbp)
movl $0x10, %edx
callq 0x22c0
movq -0x238(%rbp), %rdi
leaq 0x6a3f(%rip), %rsi      # 0xa0b3
callq 0x2160
movq %rax, -0x230(%rbp)
jmp 0x3682
movq -0x230(%rbp), %rdi
movq 0xb938(%rip), %rsi      # 0xefc8
callq 0x2190
movq %rax, -0x248(%rbp)
jmp 0x369e
movq -0x248(%rbp), %rdi
movq -0x240(%rbp), %rax
movl (%rax), %esi
callq 0x2200
movq %rax, -0x250(%rbp)
jmp 0x36bc
movq -0x250(%rbp), %rdi
movl $0x20, %esi
callq 0x21e0
movq %rax, -0x258(%rbp)
jmp 0x36d6
movq -0x258(%rbp), %rdi
movq -0x240(%rbp), %rax
movl 0x4(%rax), %esi
callq 0x2200
movq %rax, -0x260(%rbp)
jmp 0x36f5
movq -0x260(%rbp), %rdi
movq 0xb8c5(%rip), %rsi      # 0xefc8
callq 0x2190
movq %rax, -0x268(%rbp)
jmp 0x3711
movq -0x268(%rbp), %rdi
leaq 0x6990(%rip), %rsi      # 0xa0af
callq 0x2160
movq %rax, -0x270(%rbp)
jmp 0x372d
movq -0x270(%rbp), %rdi
movq 0xb88d(%rip), %rsi      # 0xefc8
callq 0x2190
jmp 0x3742
movl $0x0, -0x220(%rbp)
movq -0x240(%rbp), %rcx
movl -0x220(%rbp), %eax
cmpl 0x4(%rcx), %eax
jae 0x38b4
movl $0x0, -0x224(%rbp)
movq -0x240(%rbp), %rcx
movl -0x224(%rbp), %eax
cmpl (%rcx), %eax
jae 0x3889
movq -0x240(%rbp), %rdx
movq 0x10(%rdx), %rax
movl -0x220(%rbp), %ecx
movl (%rdx), %edx
imull %edx, %ecx
movl -0x224(%rbp), %edx
addl %edx, %ecx
leaq (%rcx,%rcx,2), %rcx
movb 0x2(%rax,%rcx), %dl
movb %dl, -0x226(%rbp)
movw (%rax,%rcx), %ax
movw %ax, -0x228(%rbp)
movzbl -0x228(%rbp), %esi
leaq -0x210(%rbp), %rdi
callq 0x2280
movq %rax, -0x278(%rbp)
jmp 0x37d4
movq -0x278(%rbp), %rdi
movl $0x20, %esi
callq 0x21e0
movq %rax, -0x280(%rbp)
jmp 0x37ee
movq -0x280(%rbp), %rdi
movzbl -0x227(%rbp), %esi
callq 0x2280
movq %rax, -0x288(%rbp)
jmp 0x380a
movq -0x288(%rbp), %rdi
movl $0x20, %esi
callq 0x21e0
movq %rax, -0x290(%rbp)
jmp 0x3824
movq -0x290(%rbp), %rdi
movzbl -0x226(%rbp), %esi
callq 0x2280
movq %rax, -0x298(%rbp)
jmp 0x3840
movq -0x298(%rbp), %rdi
movl $0x20, %esi
callq 0x21e0
jmp 0x3853
jmp 0x3855
movl -0x224(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x224(%rbp)
jmp 0x376c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x218(%rbp)
movl %eax, -0x21c(%rbp)
leaq -0x210(%rbp), %rdi
callq 0x2220
jmp 0x38c9
movq 0xb738(%rip), %rsi      # 0xefc8
leaq -0x210(%rbp), %rdi
callq 0x2190
jmp 0x389e
jmp 0x38a0
movl -0x220(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x220(%rbp)
jmp 0x374c
leaq -0x210(%rbp), %rdi
callq 0x2220
addq $0x2a0, %rsp            # imm = 0x2A0
popq %rbp
retq
movq -0x218(%rbp), %rdi
callq 0x2290
nopw %cs:(%rax,%rax)
// File: Slexis-Works[P]texture-packing/Rectangle.cpp
// Function: Rectangle::collides(Rectangle) const
bool Rectangle::collides(const Rectangle o) const {
	return x + w >= o.x
		&& x < o.x + o.w
		&& y + h >= o.y
		&& y < o.y + o.h;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x10(%rbp), %rdx
movq %rdx, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl (%rax), %ecx
addl 0x8(%rax), %ecx
xorl %eax, %eax
cmpl (%rdx), %ecx
movb %al, -0x9(%rbp)
jb 0x3eff
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movl (%rcx), %ecx
movl (%rax), %edx
addl 0x8(%rax), %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x9(%rbp)
jae 0x3eff
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rax
movl 0x4(%rax), %ecx
addl 0xc(%rax), %ecx
xorl %eax, %eax
cmpl 0x4(%rdx), %ecx
movb %al, -0x9(%rbp)
jb 0x3eff
movq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
movl 0x4(%rdx), %ecx
addl 0xc(%rdx), %ecx
cmpl %ecx, %eax
setb %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Slexis-Works[P]texture-packing/Shelf.cpp
// Function: Shelf::putRect(Rectangle const&)
bool Shelf::putRect(const Rectangle &rect) {
	coord rw = rect.getW();
	//if (rect.getH() > rects.back().getH()
	if (rect.getH() > height
		|| rw > maxWidth - curWidth) {
		return false;
	}

	// Ajout effectif
	rects.push_back(Rectangle(rect, curWidth, y));
	curWidth += rw;
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4240
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4220
movq -0x38(%rbp), %rcx
cmpl (%rcx), %eax
ja 0x4006
movq -0x38(%rbp), %rdx
movl -0x1c(%rbp), %eax
movl 0xc(%rdx), %ecx
subl 0x8(%rdx), %ecx
cmpl %ecx, %eax
jbe 0x400c
movb $0x0, -0x1(%rbp)
jmp 0x404c
movq -0x38(%rbp), %rax
movq %rax, %rcx
addq $0x10, %rcx
movq %rcx, -0x40(%rbp)
movq -0x18(%rbp), %rsi
movl 0x8(%rax), %edx
movl 0x4(%rax), %ecx
leaq -0x30(%rbp), %rdi
callq 0x3d40
movq -0x40(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x4280
movq -0x38(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl 0x8(%rax), %ecx
movl %ecx, 0x8(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Slexis-Works[P]texture-packing/Shelf.cpp
// Function: Shelf::putRotatableRect(Rectangle const&)
int Shelf::putRotatableRect(const Rectangle &rect) {
	Rectangle recTest(rect, 0, 0);
	if (putRect(recTest)) {
		return 1;
	}
	recTest.flip();
	if (putRect(recTest)) {
		return 2;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x2c(%rbp), %rdi
xorl %ecx, %ecx
movl %ecx, %edx
callq 0x3d40
movq -0x38(%rbp), %rdi
leaq -0x2c(%rbp), %rsi
callq 0x3fc0
testb $0x1, %al
jne 0x409c
jmp 0x40a5
movl $0x1, -0x4(%rbp)
jmp 0x40d1
leaq -0x2c(%rbp), %rdi
callq 0x3db0
movq -0x38(%rbp), %rdi
leaq -0x2c(%rbp), %rsi
callq 0x3fc0
testb $0x1, %al
jne 0x40c1
jmp 0x40ca
movl $0x2, -0x4(%rbp)
jmp 0x40d1
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Slexis-Works[P]texture-packing/Shelf.cpp
// Function: Shelf::setY(unsigned int)
void Shelf::setY(coord ny) {
	y = ny;
	std::vector<Rectangle>::iterator it, end;
	it = rects.begin();
	end = rects.end();
	while (it != end) {
		(*it).setY(ny);
		++it;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl -0xc(%rbp), %ecx
movl %ecx, 0x4(%rax)
leaq -0x18(%rbp), %rdi
callq 0x42b0
leaq -0x20(%rbp), %rdi
callq 0x42b0
movq -0x38(%rbp), %rdi
addq $0x10, %rdi
callq 0x42d0
movq -0x38(%rbp), %rdi
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
addq $0x10, %rdi
callq 0x4300
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x4330
testb $0x1, %al
jne 0x4154
jmp 0x4173
leaq -0x18(%rbp), %rdi
callq 0x4370
movq %rax, %rdi
movl -0xc(%rbp), %esi
callq 0x4390
leaq -0x18(%rbp), %rdi
callq 0x43b0
jmp 0x4141
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: Slexis-Works[P]texture-packing/Shelf.cpp
// Function: Shelf::drawOn(PPMImage&) const
void Shelf::drawOn(PPMImage &img) const {
	std::vector<Rectangle>::const_iterator it, end;
	it = rects.begin();
	end = rects.end();
	while (it != end) {
		(*it).drawOn(img);
		++it;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x43d0
leaq -0x20(%rbp), %rdi
callq 0x43d0
movq -0x38(%rbp), %rdi
addq $0x10, %rdi
callq 0x43f0
movq -0x38(%rbp), %rdi
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
addq $0x10, %rdi
callq 0x4420
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x4450
testb $0x1, %al
jne 0x41ef
jmp 0x420f
leaq -0x18(%rbp), %rdi
callq 0x4490
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x3e30
leaq -0x18(%rbp), %rdi
callq 0x44b0
jmp 0x41dc
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: Slexis-Works[P]texture-packing/Bin.cpp
// Function: Bin::importShelf(Shelf const&)
void Bin::importShelf(const Shelf &shelf) {
	std::vector<Rectangle>::const_iterator it = shelf.getRects().begin(), end = shelf.getRects().end();
	while (it != end) {
		addRect(*it, it->getX(), it->getY());
		++it;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5000
movq %rax, %rdi
callq 0x43f0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5000
movq %rax, %rdi
callq 0x4420
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x4450
testb $0x1, %al
jne 0x4f15
jmp 0x4f64
leaq -0x18(%rbp), %rdi
callq 0x4490
movq %rax, -0x38(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x5020
movq %rax, %rdi
callq 0x5040
movl %eax, -0x2c(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x5020
movq %rax, %rdi
callq 0x5050
movq -0x28(%rbp), %rdi
movq -0x38(%rbp), %rsi
movl -0x2c(%rbp), %edx
movl %eax, %ecx
callq 0x4e70
leaq -0x18(%rbp), %rdi
callq 0x44b0
jmp 0x4f02
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: eecs280staff[P]unit_test_framework/test/test_special_asserts.cpp
// Function: main
int main() {
    test_assert_equal();
    test_assert_not_equal();
    test_assert_true();
    test_assert_false();
    test_assert_almost_equal();

    cout << "All tests passed" << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x25c0
callq 0x3120
callq 0x3c80
callq 0x3dd0
callq 0x3f20
movq 0x9a44(%rip), %rdi      # 0xbfd8
leaq 0x5ad1(%rip), %rsi      # 0x806c
callq 0x2180
movq %rax, %rdi
movq 0x9a1e(%rip), %rsi      # 0xbfc8
callq 0x21c0
xorl %eax, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: eecs280staff[P]unit_test_framework/test/test_special_asserts.cpp
// Function: test_assert_almost_equal()
void test_assert_almost_equal() {
    cout << "test_assert_almost_equal" << endl;

    ASSERT_ALMOST_EQUAL(42.1, 42.2, 0.2);
    ASSERT_ALMOST_EQUAL(0.2 + 0.1, 0.3, 0.01);

    ASSERT_TEST_FAILURE_RAISED(ASSERT_ALMOST_EQUAL(42.1, 42.3, 0.1));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq 0x80a9(%rip), %rdi      # 0xbfd8
leaq 0x4592(%rip), %rsi      # 0x84c8
callq 0x2180
movq %rax, %rdi
movq 0x8083(%rip), %rsi      # 0xbfc8
callq 0x21c0
leaq 0x4590(%rip), %rsi      # 0x84e1
movsd 0x40af(%rip), %xmm0     # 0x8008
movsd %xmm0, -0x40(%rbp)
movsd 0x40aa(%rip), %xmm1     # 0x8010
movsd 0x40aa(%rip), %xmm2     # 0x8018
movl $0x83, %edi
callq 0x5a10
leaq 0x4587(%rip), %rsi      # 0x8506
movsd 0x4099(%rip), %xmm0     # 0x8020
movsd 0x4099(%rip), %xmm1     # 0x8028
movsd 0x4099(%rip), %xmm2     # 0x8030
movl $0x84, %edi
callq 0x5a10
movsd -0x40(%rbp), %xmm0
leaq 0x4583(%rip), %rsi      # 0x8530
movsd 0x4083(%rip), %xmm1     # 0x8038
movsd 0x4083(%rip), %xmm2     # 0x8040
movl $0x86, %edi
callq 0x5a10
jmp 0x3fc9
movq 0x8008(%rip), %rdi      # 0xbfd8
leaq 0x415a(%rip), %rsi      # 0x8131
callq 0x2180
movq %rax, -0x48(%rbp)
jmp 0x3fe2
movq -0x48(%rbp), %rdi
movq 0x7fdb(%rip), %rsi      # 0xbfc8
callq 0x21c0
jmp 0x3ff4
leaq 0x45c0(%rip), %rdi      # 0x85bb
leaq 0x4146(%rip), %rsi      # 0x8148
movl $0x86, %edx
leaq 0x4547(%rip), %rcx      # 0x8555
callq 0x20d0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x8(%rbp)
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x40b3
movq -0x8(%rbp), %rdi
callq 0x2060
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x4960
jmp 0x404b
movq 0x7f86(%rip), %rdi      # 0xbfd8
leaq -0x38(%rbp), %rsi
callq 0x2170
movq %rax, -0x50(%rbp)
jmp 0x4061
movq -0x50(%rbp), %rdi
movq 0x7f5c(%rip), %rsi      # 0xbfc8
callq 0x21c0
jmp 0x4073
leaq -0x38(%rbp), %rdi
callq 0x20c0
callq 0x2290
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x8(%rbp)
movl %eax, -0xc(%rbp)
jmp 0x40aa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x8(%rbp)
movl %eax, -0xc(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x20c0
callq 0x2290
jmp 0x40b1
jmp 0x40b3
movq -0x8(%rbp), %rdi
callq 0x22c0
movq %rax, %rdi
callq 0x4a20
nopw %cs:(%rax,%rax)
nop