LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: travisdowns[P]sort-bench/bench.cpp
// Function: bench_one(sort_algo const&, unsigned long const*, unsigned long*, unsigned long)
void bench_one(const sort_algo& algo, const uint64_t* input, uint64_t* buffer, size_t size) {
    // assert(!is_sorted(input, size));

    // clock_t before, after;
    int64_t elapsed;
    for (int i = 0; i < repeats; i++) {
      std::copy(input, input + size, buffer);
      
      // before = clock();
      SimpleTimer timer;
      algo.fn(buffer, size);
      elapsed = timer.elapsedNanos();
      // after  = clock();
    }

    assert(is_sorted(buffer, size));

    // printf(",%*.1f", (int)strlen(algo.name), (after - before) * 1000000000. / size / CLOCKS_PER_SEC);
    printf(",%*.1f", (int)strlen(algo.name), (double)elapsed / size);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x0, -0x2c(%rbp)
cmpl $0x2, -0x2c(%rbp)
jge 0x2619
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rsi
movq -0x18(%rbp), %rdx
callq 0x2d20
leaq -0x48(%rbp), %rdi
movl $0x1, %esi
callq 0x2d60
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq *%rax
leaq -0x48(%rbp), %rdi
callq 0x2da0
movq %rax, -0x28(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x25bf
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x2430
testb $0x1, %al
jne 0x262c
jmp 0x262e
jmp 0x264d
leaq 0x89fb(%rip), %rdi      # 0xb030
leaq 0x8a0c(%rip), %rsi      # 0xb048
movl $0x4d, %edx
leaq 0x8a0a(%rip), %rcx      # 0xb052
callq 0x2110
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x20c0
movl %eax, %esi
cvtsi2sdq -0x28(%rbp), %xmm0
movaps 0x89a8(%rip), %xmm2     # 0xb010
movq -0x20(%rbp), %xmm1
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0x89a7(%rip), %xmm2     # 0xb020
subpd %xmm2, %xmm1
movaps %xmm1, %xmm2
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
leaq 0x8a07(%rip), %rdi      # 0xb09a
movb $0x1, %al
callq 0x2040
addq $0x50, %rsp
popq %rbp
retq
// File: travisdowns[P]sort-bench/./wyhash.h
// Function: wyhash64_stateless(unsigned long*)
static inline uint64_t wyhash64_stateless(uint64_t *seed) {
  *seed += UINT64_C(0x60bee2bee120fc15);
  __uint128_t tmp;
  tmp = (__uint128_t)*seed * UINT64_C(0xa3b195354a39b70d);
  uint64_t m1 = (tmp >> 64) ^ tmp;
  tmp = (__uint128_t)m1 * UINT64_C(0x1b03738712fad5c9);
  uint64_t m2 = (tmp >> 64) ^ tmp;
  return m2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movabsq $0x60bee2bee120fc15, %rdx # imm = 0x60BEE2BEE120FC15
addq %rdx, %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movabsq $-0x5c4e6acab5c648f3, %rcx # imm = 0xA3B195354A39B70D
mulq %rcx
movq %rdx, -0x18(%rbp)
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
xorq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movabsq $0x1b03738712fad5c9, %rcx # imm = 0x1B03738712FAD5C9
mulq %rcx
movq %rdx, -0x18(%rbp)
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
xorq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: travisdowns[P]sort-bench/./simple-timer.hpp
// Function: SimpleTimerT<std::chrono::_V2::system_clock>::checkState(SimpleTimerT<std::chrono::_V2::system_clock>::State, char const*)
void checkState(State expected, const char *msg) {
        if (mode_ != expected) {
            if (mode_ != STARTED && mode_ != STOPPED) {
                throw std::logic_error("bad state (maybe uninit?)");
            } else {
                throw std::logic_error(msg);
            }
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl 0x10(%rax), %eax
cmpl -0xc(%rbp), %eax
je 0x3978
movq -0x30(%rbp), %rax
cmpl $0x0, 0x10(%rax)
je 0x392b
movq -0x30(%rbp), %rax
cmpl $0x1, 0x10(%rax)
je 0x392b
movl $0x10, %edi
callq 0x20d0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
leaq 0x786b(%rip), %rsi      # 0xb161
callq 0x2270
jmp 0x38fd
movq -0x38(%rbp), %rdi
movq 0xd6e0(%rip), %rsi      # 0x10fe8
movq 0xd6c1(%rip), %rdx      # 0x10fd0
callq 0x22b0
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x2150
jmp 0x397e
movl $0x10, %edi
callq 0x20d0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rsi
callq 0x2270
jmp 0x394a
movq -0x40(%rbp), %rdi
movq 0xd693(%rip), %rsi      # 0x10fe8
movq 0xd674(%rip), %rdx      # 0x10fd0
callq 0x22b0
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x2150
jmp 0x397e
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x22c0
nopw (%rax,%rax)
// File: travisdowns[P]sort-bench/msort-copy.cpp
// Function: void __qsort_r_copy<int (*)(void const*, void const*)>(void*, unsigned long, unsigned long, int (*)(void const*, void const*))
static inline void __qsort_r_copy (void *b, size_t n, size_t s, C cmp)
{
  size_t size = n * s;
  char *tmp = NULL;
  struct msort_param p;

  
    /* It's somewhat large, so malloc it.  */
  tmp = (char *)malloc(size);
  if (tmp == NULL)
  {
      /* Couldn't get space, so use the slower algorithm
          that doesn't need a temporary array.  */
      assert(0);
  }
  assert(s == sizeof(uint64_t));
  p.t = tmp;
  p.var = 1;
  p.s = s;  
  
  msort_with_tmp (&p, b, n, cmp);
    
  free (tmp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
imulq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x2250
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x5730
leaq 0x5daa(%rip), %rdi      # 0xb4c2
leaq 0x5b9a(%rip), %rsi      # 0xb2b9
movl $0x60, %edx
leaq 0x5b9d(%rip), %rcx      # 0xb2c8
callq 0x2110
cmpq $0x8, -0x18(%rbp)
jne 0x5739
jmp 0x5758
leaq 0x5be1(%rip), %rdi      # 0xb321
leaq 0x5b72(%rip), %rsi      # 0xb2b9
movl $0x62, %edx
leaq 0x5b75(%rip), %rcx      # 0xb2c8
callq 0x2110
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq $0x1, -0x40(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x20(%rbp), %rcx
leaq -0x48(%rbp), %rdi
callq 0x5890
movq -0x30(%rbp), %rdi
callq 0x2210
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: travisdowns[P]sort-bench/msort-copy.cpp
// Function: void msort_with_tmp<int (*)(void const*, void const*)>(msort_param const*, void*, unsigned long, int (*)(void const*, void const*))
void msort_with_tmp (const struct msort_param *p, void *b, size_t n, C cmp)
{
  char *b1, *b2;
  size_t n1, n2;

  if (n <= 1)
    return;

  n1 = n / 2;
  n2 = n - n1;
  b1 = (char *)b;
  b2 = (char *) b + (n1 * p->s);

  msort_with_tmp (p, b1, n1, cmp);
  msort_with_tmp (p, b2, n2, cmp);

  char *tmp = p->t;
  const size_t s = p->s;
  assert(p->var == 1);
  while (n1 > 0 && n2 > 0)
  {
    if (cmp(b1, b2) <= 0)
    {
      *(uint64_t *) tmp = *(uint64_t *) b1;
      b1 += sizeof (uint64_t);
      --n1;
    }
    else
    {
      *(uint64_t *) tmp = *(uint64_t *) b2;
      b2 += sizeof (uint64_t);
      --n2;
    }
    tmp += sizeof (uint64_t);
  }

  if (n1 > 0)
    memcpy (tmp, b1, n1 * s);
  memcpy (b, p->t, (n - n2) * s);
}

// 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)
cmpq $0x1, -0x18(%rbp)
ja 0x58b4
jmp 0x5a26
movq -0x18(%rbp), %rax
shrq %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
subq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq -0x38(%rbp), %rcx
movq -0x8(%rbp), %rdx
imulq (%rdx), %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x5890
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x5890
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x1, 0x8(%rax)
jne 0x5938
jmp 0x5957
leaq 0x59f8(%rip), %rdi      # 0xb337
leaq 0x5973(%rip), %rsi      # 0xb2b9
movl $0x3a, %edx
leaq 0x59f1(%rip), %rcx      # 0xb343
callq 0x2110
jmp 0x5959
xorl %eax, %eax
cmpq $0x0, -0x38(%rbp)
movb %al, -0x51(%rbp)
jbe 0x5970
cmpq $0x0, -0x40(%rbp)
seta %al
movb %al, -0x51(%rbp)
movb -0x51(%rbp), %al
testb $0x1, %al
jne 0x5979
jmp 0x59eb
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq *%rax
cmpl $0x0, %eax
jg 0x59b4
movq -0x28(%rbp), %rax
movq (%rax), %rcx
movq -0x48(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x28(%rbp)
movq -0x38(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x59da
movq -0x30(%rbp), %rax
movq (%rax), %rcx
movq -0x48(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x30(%rbp)
movq -0x40(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x40(%rbp)
movq -0x48(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x48(%rbp)
jmp 0x5959
cmpq $0x0, -0x38(%rbp)
jbe 0x5a08
movq -0x48(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x38(%rbp), %rdx
imulq -0x50(%rbp), %rdx
callq 0x2180
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x18(%rbp), %rdx
subq -0x40(%rbp), %rdx
imulq -0x50(%rbp), %rdx
callq 0x2180
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: travisdowns[P]sort-bench/radix1.cpp
// Function: radix_sort1(unsigned long*, unsigned long)
void radix_sort1(uint64_t *a, size_t count)
{
    using queuetype = std::vector<uint64_t>;

    for (size_t pass = 0; pass < RADIX_LEVELS; pass++) {
        uint64_t shift = pass * RADIX_BITS;
        std::array<queuetype, RADIX_SIZE> queues;

        // copy each element into the appropriate queue based on the current RADIX_BITS sized
        // "digit" within it
        for (size_t i = 0; i < count; i++) {
            size_t value = a[i];
            size_t index = (value >> shift) & RADIX_MASK;
            queues[index].push_back(value);
        }

        // copy all the queues back over top of the original array in order
        uint64_t* aptr = a;
        for (auto& queue : queues) {
            aptr = std::copy(queue.begin(), queue.end(), aptr);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1890, %rsp           # imm = 0x1890
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x8, -0x18(%rbp)
jae 0x5dec
movq -0x18(%rbp), %rax
shlq $0x3, %rax
movq %rax, -0x20(%rbp)
leaq -0x1820(%rbp), %rdi
callq 0x5e10
movq $0x0, -0x1828(%rbp)
movq -0x1828(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x5d04
movq -0x8(%rbp), %rax
movq -0x1828(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x1830(%rbp)
movq -0x1830(%rbp), %rax
movb -0x20(%rbp), %cl
shrq %cl, %rax
movzbl %al, %eax
movq %rax, -0x1838(%rbp)
movq -0x1838(%rbp), %rsi
leaq -0x1820(%rbp), %rdi
callq 0x5e60
movq %rax, %rdi
leaq -0x1830(%rbp), %rsi
callq 0x5e90
jmp 0x5ccb
jmp 0x5ccd
movq -0x1828(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x1828(%rbp)
jmp 0x5c69
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1840(%rbp)
movl %eax, -0x1844(%rbp)
leaq -0x1820(%rbp), %rdi
callq 0x6010
jmp 0x5df5
movq -0x8(%rbp), %rax
movq %rax, -0x1850(%rbp)
leaq -0x1820(%rbp), %rax
movq %rax, -0x1858(%rbp)
movq -0x1858(%rbp), %rdi
callq 0x5f00
movq %rax, -0x1860(%rbp)
movq -0x1858(%rbp), %rdi
callq 0x5f20
movq %rax, -0x1868(%rbp)
movq -0x1860(%rbp), %rax
cmpq -0x1868(%rbp), %rax
je 0x5dcf
movq -0x1860(%rbp), %rax
movq %rax, -0x1870(%rbp)
movq -0x1870(%rbp), %rdi
callq 0x5fb0
movq %rax, -0x1878(%rbp)
movq -0x1870(%rbp), %rdi
callq 0x5fe0
movq %rax, -0x1880(%rbp)
movq -0x1850(%rbp), %rdx
movq -0x1878(%rbp), %rdi
movq -0x1880(%rbp), %rsi
callq 0x5f50
movq %rax, -0x1888(%rbp)
jmp 0x5daa
movq -0x1888(%rbp), %rax
movq %rax, -0x1850(%rbp)
movq -0x1860(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x1860(%rbp)
jmp 0x5d43
leaq -0x1820(%rbp), %rdi
callq 0x6010
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x5c3b
addq $0x1890, %rsp           # imm = 0x1890
popq %rbp
retq
movq -0x1840(%rbp), %rdi
callq 0x22c0
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: travisdowns[P]sort-bench/radix4.cpp
// Function: count_frequency(unsigned long*, unsigned long, unsigned long (*) [256])
HEDLEY_NEVER_INLINE
static void count_frequency(uint64_t *a, size_t count, freq_array_type freqs) {
  for (size_t i = 0; i < count; i++) {
      uint64_t value = a[i];
      for (size_t pass = 0; pass < RADIX_LEVELS; pass++) {
          freqs[pass][value & RADIX_MASK]++;
          value >>= RADIX_BITS;
      }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x7531
movq -0x8(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
cmpq $0x8, -0x30(%rbp)
jae 0x7521
movq -0x18(%rbp), %rax
movq -0x30(%rbp), %rcx
shlq $0xb, %rcx
addq %rcx, %rax
movq -0x28(%rbp), %rcx
andq $0xff, %rcx
movq (%rax,%rcx,8), %rdx
addq $0x1, %rdx
movq %rdx, (%rax,%rcx,8)
movq -0x28(%rbp), %rax
shrq $0x8, %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x74da
jmp 0x7523
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x74b8
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: travisdowns[P]sort-bench/radix6.cpp
// Function: is_trivial(unsigned long*, unsigned long)
static bool is_trivial(size_t freqs[RADIX_SIZE], size_t count) {
    for (size_t i = 0; i < RADIX_SIZE; i++) {
        auto freq = freqs[i];
        if (freq != 0) {
            return freq == count;
        }
    }
    assert(count == 0); // we only get here if count was zero
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
cmpq $0x100, -0x20(%rbp)     # imm = 0x100
jae 0x7c8b
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x7c7b
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x7cb7
jmp 0x7c7d
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x7c48
cmpq $0x0, -0x18(%rbp)
jne 0x7c94
jmp 0x7cb3
leaq 0x381e(%rip), %rdi      # 0xb4b9
leaq 0x3822(%rip), %rsi      # 0xb4c4
movl $0x2d, %edx
leaq 0x3821(%rip), %rcx      # 0xb4cf
callq 0x2110
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: travisdowns[P]sort-bench/std-sorts.cpp
// Function: compare_uint64_t(void const*, void const*)
int compare_uint64_t(const void *l_, const void *r_) { 
    uint64_t l = *(const uint64_t *)l_;
    uint64_t r = *(const uint64_t *)r_;
    if (l < r) return -1;
    if (l > r) return  1;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x80f5
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x810f
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jbe 0x8108
movl $0x1, -0x4(%rbp)
jmp 0x810f
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: pollo[P]graph-partitioning/graph.cpp
// Function: Graph::add_neighbor(int, int)
void Graph::add_neighbor(int node_index, int neighbor_index)
{
  if (node_index != neighbor_index)
  {
    if (node_index>=counted_nodes_number ||
        neighbor_index>=counted_nodes_number)
    {
      counted_nodes_number = max(node_index, neighbor_index) + 1;
      neighbors.resize(max(counted_nodes_number, (int) neighbors.size()));
    }

    if (find(neighbors[node_index].begin(),
             neighbors[node_index].end(),
             neighbor_index) == neighbors[node_index].end())
    {
      neighbors[node_index].push_back(neighbor_index);
      neighbors[neighbor_index].push_back(node_index);
      counted_edges_number += 1;
    }
  }
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movl %esi, 0x4c(%rsp)
movl %edx, 0x48(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x18(%rsp)
movl 0x4c(%rsp), %eax
cmpl 0x48(%rsp), %eax
je 0x3131
movq 0x18(%rsp), %rcx
movl 0x4c(%rsp), %eax
cmpl 0x8(%rcx), %eax
jge 0x2ff5
movq 0x18(%rsp), %rcx
movl 0x48(%rsp), %eax
cmpl 0x8(%rcx), %eax
jl 0x3052
leaq 0x4c(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x3cc0
movq 0x18(%rsp), %rdi
movl (%rax), %eax
addl $0x1, %eax
movl %eax, 0x8(%rdi)
movq %rdi, %rax
addq $0x10, %rax
movq %rax, 0x10(%rsp)
movq %rdi, %rax
addq $0x8, %rax
movq %rax, 0x8(%rsp)
addq $0x10, %rdi
callq 0x3da0
movq 0x8(%rsp), %rdi
movl %eax, 0x44(%rsp)
leaq 0x44(%rsp), %rsi
callq 0x3cc0
movq 0x10(%rsp), %rdi
movslq (%rax), %rsi
callq 0x3d00
movq 0x18(%rsp), %rdi
addq $0x10, %rdi
movslq 0x4c(%rsp), %rsi
callq 0x3e60
movq %rax, %rdi
callq 0x3e80
movq 0x18(%rsp), %rdi
movq %rax, 0x30(%rsp)
addq $0x10, %rdi
movslq 0x4c(%rsp), %rsi
callq 0x3e60
movq %rax, %rdi
callq 0x3eb0
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
leaq 0x48(%rsp), %rdx
callq 0x3e00
movq 0x18(%rsp), %rdi
movq %rax, 0x38(%rsp)
addq $0x10, %rdi
movslq 0x4c(%rsp), %rsi
callq 0x3e60
movq %rax, %rdi
callq 0x3eb0
movq %rax, 0x20(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x3dc0
testb $0x1, %al
jne 0x30e0
jmp 0x312f
movq 0x18(%rsp), %rdi
addq $0x10, %rdi
movslq 0x4c(%rsp), %rsi
callq 0x3e60
movq %rax, %rdi
leaq 0x48(%rsp), %rsi
callq 0x3ee0
movq 0x18(%rsp), %rdi
addq $0x10, %rdi
movslq 0x48(%rsp), %rsi
callq 0x3e60
movq %rax, %rdi
leaq 0x4c(%rsp), %rsi
callq 0x3ee0
movq 0x18(%rsp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x3131
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: pollo[P]graph-partitioning/graph.cpp
// Function: Graph::print_graph() const
void Graph::print_graph() const
{
/*  for (int i=0; i<nodes_number; i++)
  {
    printf("Node %d has neighbors: ",i);
    const vector<int>& neighbors = get_neighbors(i);
    for (vector<int>::const_iterator it = neighbors.begin();
         it != neighbors.end();
         it++)
    {
      printf("%d ",*it);
    }
    printf("\n");
    }*/
  printf("%d %lld\n",counted_nodes_number, counted_edges_number);
  for (int i=0; i<counted_nodes_number; i++)
  {
    const vector<int>& neighbors = get_neighbors(i);
    bool no = true;
    for (vector<int>::const_iterator it = neighbors.begin();
         it != neighbors.end();
         it++)
    {
      no = false;
      printf("%d ",*it+1);
    }
    if (no)
      printf("%d ",i+1);
    printf("\n");
  }
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x8(%rax), %esi
movq (%rax), %rdx
leaq 0x90b6(%rip), %rdi      # 0xc256
movb $0x0, %al
callq 0x2030
movl $0x0, 0x3c(%rsp)
movq 0x8(%rsp), %rcx
movl 0x3c(%rsp), %eax
cmpl 0x8(%rcx), %eax
jge 0x327b
movq 0x8(%rsp), %rdi
movl 0x3c(%rsp), %esi
callq 0x3280
movq %rax, 0x30(%rsp)
movb $0x1, 0x2f(%rsp)
movq 0x30(%rsp), %rdi
callq 0x3f50
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rdi
callq 0x3fc0
movq %rax, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x3f80
testb $0x1, %al
jne 0x320c
jmp 0x3241
movb $0x0, 0x2f(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x3ff0
movl (%rax), %esi
addl $0x1, %esi
leaq 0x9038(%rip), %rdi      # 0xc25f
movb $0x0, %al
callq 0x2030
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
callq 0x4000
movq %rax, 0x10(%rsp)
jmp 0x31e8
testb $0x1, 0x2f(%rsp)
je 0x325d
movl 0x3c(%rsp), %esi
addl $0x1, %esi
leaq 0x9009(%rip), %rdi      # 0xc25f
movb $0x0, %al
callq 0x2030
leaq 0x8e6b(%rip), %rdi      # 0xc0cf
movb $0x0, %al
callq 0x2030
movl 0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
jmp 0x31af
addq $0x48, %rsp
retq
// File: pollo[P]graph-partitioning/graph.cpp
// Function: Graph::get_nodes_randomly(std::vector<int, std::allocator<int>>*) const
void Graph::get_nodes_randomly(vector<int>* nodes) const {
  srand ( unsigned ( std::time(0) ) );
  nodes->resize(counted_nodes_number);
  for (int i=0; i<counted_nodes_number; i++)
    (*nodes)[i] = i;
  random_shuffle(nodes->begin(), nodes->end(), myrandom);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
xorl %eax, %eax
movl %eax, %edi
callq 0x2150
movl %eax, %edi
callq 0x2170
movq 0x8(%rsp), %rax
movq 0x28(%rsp), %rdi
movslq 0x8(%rax), %rsi
callq 0x4060
movl $0x0, 0x24(%rsp)
movq 0x8(%rsp), %rcx
movl 0x24(%rsp), %eax
cmpl 0x8(%rcx), %eax
jge 0x334b
movl 0x24(%rsp), %eax
movl %eax, 0x4(%rsp)
movq 0x28(%rsp), %rdi
movslq 0x24(%rsp), %rsi
callq 0x4100
movl 0x4(%rsp), %ecx
movl %ecx, (%rax)
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x3313
movq 0x28(%rsp), %rdi
callq 0x3e80
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rdi
callq 0x3eb0
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
leaq -0xca(%rip), %rdx       # 0x32b0
callq 0x4120
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: pollo[P]graph-partitioning/graph.cpp
// Function: Graph::get_fraction_edges_cut(Partition const&) const
double Graph::get_fraction_edges_cut(const Partition& partition) const {
  long long int edges_cut = 0;

  for (int node = 0; node < counted_nodes_number; node++)
  {
    int node_partition = partition.get_node_partition(node);
    for (vector<int>::const_iterator neighbor = neighbors[node].begin();
         neighbor != neighbors[node].end();
         ++neighbor)
    {
      if (node_partition != partition.get_node_partition(*neighbor))
        edges_cut++;
    }
  }

  edges_cut /= 2;

  return ((double) edges_cut)/counted_edges_number;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movq $0x0, 0x30(%rsp)
movl $0x0, 0x2c(%rsp)
movq 0x10(%rsp), %rcx
movl 0x2c(%rsp), %eax
cmpl 0x8(%rcx), %eax
jge 0x38a3
movq 0x38(%rsp), %rdi
movl 0x2c(%rsp), %esi
callq 0x81a0
movq 0x10(%rsp), %rdi
movl %eax, 0x28(%rsp)
addq $0x10, %rdi
movslq 0x2c(%rsp), %rsi
callq 0x4040
movq %rax, %rdi
callq 0x3f50
movq %rax, 0x20(%rsp)
movq 0x10(%rsp), %rdi
addq $0x10, %rdi
movslq 0x2c(%rsp), %rsi
callq 0x4040
movq %rax, %rdi
callq 0x3fc0
movq %rax, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x3f80
testb $0x1, %al
jne 0x3842
jmp 0x3891
movl 0x28(%rsp), %eax
movl %eax, 0xc(%rsp)
movq 0x38(%rsp), %rax
movq %rax, (%rsp)
leaq 0x20(%rsp), %rdi
callq 0x3ff0
movq (%rsp), %rdi
movl (%rax), %esi
callq 0x81a0
movl %eax, %ecx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
je 0x3880
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
jmp 0x3882
leaq 0x20(%rsp), %rdi
callq 0x4540
jmp 0x380d
jmp 0x3893
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x37c9
movq 0x30(%rsp), %rax
movl $0x2, %ecx
cqto
idivq %rcx
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x30(%rsp)
cvtsi2sdq 0x30(%rsp), %xmm0
cvtsi2sdq (%rax), %xmm1
divsd %xmm1, %xmm0
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: pollo[P]graph-partitioning/graph.cpp
// Function: Graph::get_normalized_maximum_load(Partition const&) const
double Graph::get_normalized_maximum_load(const Partition& partition) const {
  int maximum_load = 0;

  for (int i=0; i<partition.get_partitions_number(); i++)
  {
    int partition_size = partition.get_partition_size(i);
    if (partition_size > maximum_load)
      maximum_load = partition_size;
  }

  return maximum_load / \
    ((double) counted_nodes_number / partition.get_partitions_number());
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x20(%rsp)
movl $0x0, 0x34(%rsp)
movl $0x0, 0x30(%rsp)
movl 0x30(%rsp), %eax
movl %eax, 0x1c(%rsp)
movq 0x38(%rsp), %rdi
callq 0x8200
movl %eax, %ecx
movl 0x1c(%rsp), %eax
cmpl %ecx, %eax
jge 0x3c77
movq 0x38(%rsp), %rdi
movl 0x30(%rsp), %esi
callq 0x81d0
movl %eax, 0x2c(%rsp)
movl 0x2c(%rsp), %eax
cmpl 0x34(%rsp), %eax
jle 0x3c68
movl 0x2c(%rsp), %eax
movl %eax, 0x34(%rsp)
jmp 0x3c6a
movl 0x30(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x30(%rsp)
jmp 0x3c28
movq 0x20(%rsp), %rax
cvtsi2sdl 0x34(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
cvtsi2sdl 0x8(%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x38(%rsp), %rdi
callq 0x8200
movsd 0x8(%rsp), %xmm1
movsd 0x10(%rsp), %xmm0
cvtsi2sd %eax, %xmm2
divsd %xmm2, %xmm1
divsd %xmm1, %xmm0
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: pollo[P]graph-partitioning/loaders.cpp
// Function: snap_loader(Graph*, char const*)
void snap_loader(Graph* graph, const char* file_name) {
  int n,m;
  int from, to;
  char buffer[1000];
  FILE *fp = fopen(file_name, "r");

  if (fp == NULL)
  {
    printf("File %s not found\n",file_name);
    exit(1);
  }

  fgets(buffer, sizeof buffer, fp);
  fgets(buffer, sizeof buffer, fp);
  fgets(buffer, sizeof buffer, fp);
  sscanf(buffer, "# Nodes: %d Edges: %d",&n,&m);

  //read edges
  while (fgets(buffer, sizeof buffer, fp) != NULL)
  {
    if (buffer[0] != '#')
    {
      sscanf(buffer, "%d\t%d", &from,&to);
      graph->add_neighbor(from,to);
    }
  }

  //graph->print_graph_size();

  fclose(fp);
}

// Assembly:
subq $0x418, %rsp            # imm = 0x418
movq %rdi, 0x410(%rsp)
movq %rsi, 0x408(%rsp)
movq 0x408(%rsp), %rdi
leaq 0x4611(%rip), %rsi      # 0xc1c7
callq 0x21c0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x7be8
movq 0x408(%rsp), %rsi
leaq 0x4707(%rip), %rdi      # 0xc2de
movb $0x0, %al
callq 0x2030
movl $0x1, %edi
callq 0x21d0
leaq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rdx
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x2220
leaq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rdx
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x2220
leaq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rdx
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x2220
leaq 0x10(%rsp), %rdi
leaq 0x46c1(%rip), %rsi      # 0xc2f1
leaq 0x404(%rsp), %rdx
leaq 0x400(%rsp), %rcx
movb $0x0, %al
callq 0x2180
leaq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rdx
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x2220
cmpq $0x0, %rax
je 0x7cab
movsbl 0x10(%rsp), %eax
cmpl $0x23, %eax
je 0x7ca9
leaq 0x10(%rsp), %rdi
leaq 0x4690(%rip), %rsi      # 0xc307
leaq 0x3fc(%rsp), %rdx
leaq 0x3f8(%rsp), %rcx
movb $0x0, %al
callq 0x2180
movq 0x410(%rsp), %rdi
movl 0x3fc(%rsp), %esi
movl 0x3f8(%rsp), %edx
callq 0x2fb0
jmp 0x7c47
movq 0x8(%rsp), %rdi
callq 0x2190
addq $0x418, %rsp            # imm = 0x418
retq
nopl (%rax)
// File: pollo[P]graph-partitioning/loaders.cpp
// Function: preprocessed_loader(Graph*, char const*)
void preprocessed_loader(Graph* graph, const char* file_name) {
  int n,m;
  int from, to;
  char buffer[1000];
  char pre_file_name[1000];
  strcpy(pre_file_name, file_name);
  strcat(pre_file_name, ".preprocessed");

  printf("%s\n",pre_file_name);

  FILE *fp = fopen(pre_file_name, "r");

  fgets(buffer, sizeof buffer, fp);
  sscanf(buffer, "%d %d\n",&n,&m);

  //read edges
  while (fgets(buffer, sizeof buffer, fp) != NULL)
  {
    sscanf(buffer, "%d %d", &from,&to);
    graph->add_neighbor(from,to);
  }

  graph->print_graph_size();

  fclose(fp);
}

// Assembly:
subq $0x808, %rsp            # imm = 0x808
movq %rdi, 0x800(%rsp)
movq %rsi, 0x7f8(%rsp)
leaq 0x10(%rsp), %rdi
movq 0x7f8(%rsp), %rsi
callq 0x2160
leaq 0x10(%rsp), %rdi
leaq 0x4618(%rip), %rsi      # 0xc30d
callq 0x2280
leaq 0x10(%rsp), %rsi
leaq 0x432b(%rip), %rdi      # 0xc031
movb $0x0, %al
callq 0x2030
leaq 0x10(%rsp), %rdi
leaq 0x44ae(%rip), %rsi      # 0xc1c7
callq 0x21c0
movq %rax, 0x8(%rsp)
leaq 0x400(%rsp), %rdi
movq 0x8(%rsp), %rdx
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x2220
leaq 0x400(%rsp), %rdi
leaq 0x451a(%rip), %rsi      # 0xc263
leaq 0x7f4(%rsp), %rdx
leaq 0x7f0(%rsp), %rcx
movb $0x0, %al
callq 0x2180
leaq 0x400(%rsp), %rdi
movq 0x8(%rsp), %rdx
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x2220
cmpq $0x0, %rax
je 0x7dc0
leaq 0x400(%rsp), %rdi
leaq 0x458f(%rip), %rsi      # 0xc31b
leaq 0x7ec(%rsp), %rdx
leaq 0x7e8(%rsp), %rcx
movb $0x0, %al
callq 0x2180
movq 0x800(%rsp), %rdi
movl 0x7ec(%rsp), %esi
movl 0x7e8(%rsp), %edx
callq 0x2fb0
jmp 0x7d60
movq 0x800(%rsp), %rdi
callq 0x3140
movq 0x8(%rsp), %rdi
callq 0x2190
addq $0x808, %rsp            # imm = 0x808
retq
nop
// File: pollo[P]graph-partitioning/loaders.cpp
// Function: elt_loader(Graph*)
void elt_loader(Graph* graph) {
  int n,m;
  int neighbor;
  string line;
  ifstream elt_file(ELT_FILE);

  elt_file >> n;
  elt_file >> m;

  //read edges
  getline(elt_file, line);
  for (int i=0 ; i<n; i++)
  {
    getline(elt_file, line);
    stringstream linestream(line);

    while (linestream >> neighbor)
    {
      neighbor--;
      graph->add_neighbor(i, neighbor);
    }
  }

  graph->print_graph_size();

  elt_file.close();
}

// Assembly:
subq $0x3f8, %rsp            # imm = 0x3F8
movq %rdi, 0x3f0(%rsp)
leaq 0x3c0(%rsp), %rdi
callq 0x21f0
leaq 0x451e(%rip), %rsi      # 0xc321
leaq 0x1b8(%rsp), %rdi
movl $0x8, %edx
callq 0x2290
jmp 0x7e17
leaq 0x1b8(%rsp), %rdi
leaq 0x3ec(%rsp), %rsi
callq 0x2100
jmp 0x7e2e
leaq 0x1b8(%rsp), %rdi
leaq 0x3e8(%rsp), %rsi
callq 0x2100
jmp 0x7e45
leaq 0x1b8(%rsp), %rdi
leaq 0x3c0(%rsp), %rsi
callq 0x2040
jmp 0x7e5c
movl $0x0, 0x1a8(%rsp)
movl 0x1a8(%rsp), %eax
cmpl 0x3ec(%rsp), %eax
jge 0x7fa2
leaq 0x1b8(%rsp), %rdi
leaq 0x3c0(%rsp), %rsi
callq 0x2040
jmp 0x7e92
movl $0x10, %edi
movl $0x8, %esi
callq 0x80b0
movl %eax, 0x1c(%rsp)
jmp 0x7ea7
movl 0x1c(%rsp), %edx
leaq 0x20(%rsp), %rdi
leaq 0x3c0(%rsp), %rsi
callq 0x2230
jmp 0x7ebf
jmp 0x7ec1
leaq 0x20(%rsp), %rdi
leaq 0x3e4(%rsp), %rsi
callq 0x2100
movq %rax, 0x10(%rsp)
jmp 0x7eda
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x21e0
movb %al, 0xf(%rsp)
jmp 0x7ef4
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x7f01
jmp 0x7f82
movl 0x3e4(%rsp), %eax
decl %eax
movl %eax, 0x3e4(%rsp)
movq 0x3f0(%rsp), %rdi
movl 0x1a8(%rsp), %esi
movl 0x3e4(%rsp), %edx
callq 0x2fb0
jmp 0x7f2e
jmp 0x7ec1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1b0(%rsp)
movl %eax, 0x1ac(%rsp)
jmp 0x7fef
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1b0(%rsp)
movl %eax, 0x1ac(%rsp)
jmp 0x7fe2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1b0(%rsp)
movl %eax, 0x1ac(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x2120
jmp 0x7fe2
leaq 0x20(%rsp), %rdi
callq 0x2120
movl 0x1a8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1a8(%rsp)
jmp 0x7e67
movq 0x3f0(%rsp), %rdi
callq 0x3140
jmp 0x7fb1
leaq 0x1b8(%rsp), %rdi
callq 0x2050
jmp 0x7fc0
leaq 0x1b8(%rsp), %rdi
callq 0x2070
leaq 0x3c0(%rsp), %rdi
callq 0x2110
addq $0x3f8, %rsp            # imm = 0x3F8
retq
leaq 0x1b8(%rsp), %rdi
callq 0x2070
leaq 0x3c0(%rsp), %rdi
callq 0x2110
movq 0x1b0(%rsp), %rdi
callq 0x2270
nopl (%rax)
// File: pollo[P]graph-partitioning/loaders.cpp
// Function: twitter_loader(Graph*)
void twitter_loader(Graph* graph) {
  int from, to;
  char buffer[1000];
  FILE *fp = fopen(TWITTER_FILE, "r");

  //read edges
  while (fgets(buffer, sizeof buffer, fp) != NULL)
  {
      sscanf(buffer, "%d\t%d", &from,&to);
      graph->add_neighbor(from,to);
  }

  graph->print_graph_size();

  fclose(fp);
}

// Assembly:
subq $0x408, %rsp            # imm = 0x408
movq %rdi, 0x400(%rsp)
leaq 0x4312(%rip), %rdi      # 0xc338
leaq 0x419a(%rip), %rsi      # 0xc1c7
callq 0x21c0
movq %rax, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rdx
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x2220
cmpq $0x0, %rax
je 0x8091
leaq 0x10(%rsp), %rdi
leaq 0x42aa(%rip), %rsi      # 0xc307
leaq 0x3fc(%rsp), %rdx
leaq 0x3f8(%rsp), %rcx
movb $0x0, %al
callq 0x2180
movq 0x400(%rsp), %rdi
movl 0x3fc(%rsp), %esi
movl 0x3f8(%rsp), %edx
callq 0x2fb0
jmp 0x8037
movq 0x400(%rsp), %rdi
callq 0x3140
movq 0x8(%rsp), %rdi
callq 0x2190
addq $0x408, %rsp            # imm = 0x408
retq
// File: pollo[P]graph-partitioning/partition.cpp
// Function: Partition::set_size(int, int)
void Partition::set_size(int nodes_number, int partitions_number)
{
  this->nodes_number = nodes_number;
  this->partitions_number = partitions_number;
  //-1 means not yet assigned
  partitions.resize(nodes_number, -1);
  partition_sizes.resize(partitions_number, 0);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movl 0x1c(%rsp), %eax
movl %eax, (%rdi)
movl 0x18(%rsp), %eax
movl %eax, 0x4(%rdi)
addq $0x8, %rdi
movslq 0x1c(%rsp), %rsi
movl $0xffffffff, 0x14(%rsp) # imm = 0xFFFFFFFF
leaq 0x14(%rsp), %rdx
callq 0x8210
movq 0x8(%rsp), %rdi
addq $0x20, %rdi
movslq 0x18(%rsp), %rsi
movl $0x0, 0x10(%rsp)
leaq 0x10(%rsp), %rdx
callq 0x8210
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: iZhangHui[P]CppPrimer/CH16_TemplatesAndGenericProgramming/examples/./Blob.h
// Function: BlobPtr<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::operator++()
BlobPtr<T>& BlobPtr<T>::operator++()
{
	// if curr already points past the end of the container, can't increment it
	check(curr, "increment past end of BlobPtr");
	++curr;       // advance the current state
	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0x60(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x21f0
movq -0x58(%rbp), %rdx
leaq 0x347c(%rip), %rsi      # 0x6060
leaq -0x38(%rbp), %rdi
callq 0x2170
jmp 0x2bef
movq -0x60(%rbp), %rdx
movq -0x68(%rbp), %rsi
leaq -0x18(%rbp), %rdi
leaq -0x38(%rbp), %rcx
callq 0x5360
jmp 0x2c06
leaq -0x18(%rbp), %rdi
callq 0x2f30
leaq -0x38(%rbp), %rdi
callq 0x20d0
leaq -0x39(%rbp), %rdi
callq 0x2160
movq -0x68(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x2c5a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x20d0
leaq -0x39(%rbp), %rdi
callq 0x2160
movq -0x48(%rbp), %rdi
callq 0x21e0
nopl (%rax)
// File: iZhangHui[P]CppPrimer/CH16_TemplatesAndGenericProgramming/examples/./Blob.h
// Function: BlobPtr<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::check(unsigned long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
std::shared_ptr<std::vector<T>> BlobPtr<T>::check(std::size_t i, const std::string& msg) const
{
	auto ret = wptr.lock();   // is the vector still around?
	if (!ret)
		throw std::runtime_error("unbound BlobPtr");
	if (i >= ret->size())
		throw std::out_of_range(msg);
	return ret; // otherwise, return a shared_ptr to the vector
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rsi
movb $0x0, -0x21(%rbp)
callq 0x5160
movq -0x40(%rbp), %rdi
callq 0x54b0
testb $0x1, %al
jne 0x5406
movl $0x10, %edi
callq 0x2090
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x50(%rbp)
leaq 0xcc6(%rip), %rsi       # 0x607e
callq 0x2060
jmp 0x53bf
movq -0x50(%rbp), %rdi
movq 0x4c26(%rip), %rsi      # 0x9ff0
movq 0x4bdf(%rip), %rdx      # 0x9fb0
callq 0x21d0
jmp 0x54a9
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x20e0
jmp 0x5497
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x5497
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
callq 0x3e20
movq %rax, %rdi
callq 0x3e40
movq %rax, %rcx
movq -0x58(%rbp), %rax
cmpq %rcx, %rax
jb 0x547a
movl $0x10, %edi
callq 0x2090
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq -0x20(%rbp), %rsi
callq 0x21a0
jmp 0x544a
movq -0x60(%rbp), %rdi
movq 0x4b7b(%rip), %rsi      # 0x9fd0
movq 0x4b6c(%rip), %rdx      # 0x9fc8
callq 0x21d0
jmp 0x54a9
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x20e0
jmp 0x5497
movb $0x1, -0x21(%rbp)
testb $0x1, -0x21(%rbp)
jne 0x548d
movq -0x40(%rbp), %rdi
callq 0x2f30
movq -0x48(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x2f30
movq -0x30(%rbp), %rdi
callq 0x21e0
nopl (%rax)
// File: CDISC2020[P]Projet_satellite_agile/src/FDIR/main_FDIR.cpp
// Function: gestion_wd_arduino(void*)
void* gestion_wd_arduino(void* args)
{
	while(1)
	{
		if(set_wd_ard==true)
		{
			myFDIR.set_arduino();//on demande a mettre la pin a 1
			usleep(5000);
			myFDIR.reset_arduino();//on demande a mettre la pin a 0
			usleep(20000);
			set_wd_ard=false;
		}

		usleep(100);
	}

	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movb 0x52c6(%rip), %al       # 0x8238
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x2faf
leaq 0x5291(%rip), %rdi      # 0x8214
callq 0x3fd0
movl $0x1388, %edi           # imm = 0x1388
callq 0x2260
leaq 0x527b(%rip), %rdi      # 0x8214
callq 0x3ff0
movl $0x4e20, %edi           # imm = 0x4E20
callq 0x2260
movb $0x0, 0x5289(%rip)      # 0x8238
movl $0x64, %edi
callq 0x2260
jmp 0x2f6c
nopl (%rax,%rax)
// File: CDISC2020[P]Projet_satellite_agile/src/FDIR/main_FDIR.cpp
// Function: ARINC_PID(int)
void ARINC_PID(int signal)
{
	ifstream fichier;
	fichier.open("pid_ARINC");
	string line;
	if(!fichier)
	{
		cout << "Failed to open pid_ARINC" << endl;
		exit(1);
	}
	getline(fichier,line);
	arinc_pid=atoi(line.c_str());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x260, %rsp            # imm = 0x260
movl %edi, -0x4(%rbp)
leaq -0x210(%rbp), %rdi
movq %rdi, -0x248(%rbp)
callq 0x21d0
movq -0x248(%rbp), %rdi
leaq 0x1e32(%rip), %rsi      # 0x5241
movl $0x8, %edx
callq 0x2110
jmp 0x341b
leaq -0x240(%rbp), %rdi
callq 0x2250
movq -0x210(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x210(%rbp,%rax), %rdi
callq 0x20f0
movb %al, -0x249(%rbp)
jmp 0x3447
movb -0x249(%rbp), %al
testb $0x1, %al
jne 0x3453
jmp 0x34c2
movq 0x4b76(%rip), %rdi      # 0x7fd0
leaq 0x1dd1(%rip), %rsi      # 0x5232
callq 0x21b0
movq %rax, -0x258(%rbp)
jmp 0x346f
movq -0x258(%rbp), %rdi
movq 0x4b43(%rip), %rsi      # 0x7fc0
callq 0x21c0
jmp 0x3484
movl $0x1, %edi
callq 0x2210
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x218(%rbp)
movl %eax, -0x21c(%rbp)
jmp 0x3512
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x218(%rbp)
movl %eax, -0x21c(%rbp)
leaq -0x240(%rbp), %rdi
callq 0x2100
jmp 0x3512
leaq -0x210(%rbp), %rdi
leaq -0x240(%rbp), %rsi
callq 0x2080
jmp 0x34d7
leaq -0x240(%rbp), %rdi
callq 0x20d0
movq %rax, %rdi
callq 0x22f0
movl %eax, 0x4cff(%rip)      # 0x81f0
leaq -0x240(%rbp), %rdi
callq 0x2100
leaq -0x210(%rbp), %rdi
callq 0x20b0
addq $0x260, %rsp            # imm = 0x260
popq %rbp
retq
leaq -0x210(%rbp), %rdi
callq 0x20b0
movq -0x218(%rbp), %rdi
callq 0x2360
nopw (%rax,%rax)
// File: CDISC2020[P]Projet_satellite_agile/src/FDIR/main_FDIR.cpp
// Function: reboot_PM(void*)
void* reboot_PM(void* args)
{
	// reboot PM
	system("xterm -e ./main_PM &");
	sleep(1);

	// maj du listpid
	maj_listpid();

	// previent ARINC qu'il faut prendre en compte la modif de listpid
	if(arinc_pid!=-1)
		kill(arinc_pid,SIGUSR1);

	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x1d08(%rip), %rdi      # 0x524b
callq 0x2160
movl $0x1, %edi
callq 0x2130
callq 0x2fc0
cmpl $-0x1, 0x4c92(%rip)     # 0x81f0
je 0x3570
movl 0x4c8a(%rip), %edi      # 0x81f0
movl $0xa, %esi
callq 0x2270
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: CDISC2020[P]Projet_satellite_agile/src/FDIR/main_FDIR.cpp
// Function: reboot_COM(void*)
void* reboot_COM(void* args)
{
	// reboot COM
	system("xterm -e ./main_Com_ST &");
	sleep(1);

	// maj du listpid
	maj_listpid();

	// previent ARINC qu'il faut prendre en compte la modif de listpid
	if(arinc_pid!=-1)
		kill(arinc_pid,SIGUSR1);

	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x1ccd(%rip), %rdi      # 0x5260
callq 0x2160
movl $0x1, %edi
callq 0x2130
callq 0x2fc0
cmpl $-0x1, 0x4c42(%rip)     # 0x81f0
je 0x35c0
movl 0x4c3a(%rip), %edi      # 0x81f0
movl $0xa, %esi
callq 0x2270
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: CDISC2020[P]Projet_satellite_agile/src/FDIR/main_FDIR.cpp
// Function: recouvrement_COM()
void recouvrement_COM()
{
	// tolere faute par crash pas par freeze, sinon faut tuer process avant et donc recup les pid de tout le monde

	if(rec_COM)
	{
		// autre time out
		cout << "faut changer de raspy my boi" << endl;
	}
	else
	{
		rec_COM=true;

		pthread_attr_t *thread_attributes;
	        pthread_t *thread;

	        thread_attributes=(pthread_attr_t *)malloc(sizeof(pthread_attr_t));
	        thread=(pthread_t *)malloc(sizeof(pthread_t));

	        pthread_attr_init(thread_attributes);
	        if (pthread_create(thread, thread_attributes, reboot_COM,(void *) NULL) != 0)
	                perror ("Thread FDIR COM!");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
testb $0x1, 0x4cc5(%rip)      # 0x82a4
je 0x3605
movq 0x49e8(%rip), %rdi      # 0x7fd0
leaq 0x1c8a(%rip), %rsi      # 0x5279
callq 0x21b0
movq %rax, %rdi
movq 0x49c2(%rip), %rsi      # 0x7fc0
callq 0x21c0
jmp 0x365c
movb $0x1, 0x4c98(%rip)      # 0x82a4
movl $0x38, %edi
callq 0x2230
movq %rax, -0x8(%rbp)
movl $0x8, %edi
callq 0x2230
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2220
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
leaq -0xc0(%rip), %rdx       # 0x3580
xorl %eax, %eax
movl %eax, %ecx
callq 0x2370
cmpl $0x0, %eax
je 0x365a
leaq 0x1c41(%rip), %rdi      # 0x5296
callq 0x2150
jmp 0x365c
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: CDISC2020[P]Projet_satellite_agile/src/FDIR/main_FDIR.cpp
// Function: recouvrement_PM()
void recouvrement_PM()
{
	// tolere faute par crash pas par freeze, sinon faut tuer process avant et donc recup les pid de tout le monde

	if(rec_PM)
	{
		cout << "faut changer de raspy my boi" << endl;
	}
	else
	{
		rec_PM=true;

		pthread_attr_t *thread_attributes;
	        pthread_t *thread;

	        thread_attributes=(pthread_attr_t *)malloc(sizeof(pthread_attr_t));
	        thread=(pthread_t *)malloc(sizeof(pthread_t));

	        pthread_attr_init(thread_attributes);
	        if (pthread_create(thread, thread_attributes, reboot_PM,(void *) NULL) != 0)
	                perror ("Thread FDIR PM!");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
testb $0x1, 0x4c26(%rip)      # 0x82a5
je 0x36a5
movq 0x4948(%rip), %rdi      # 0x7fd0
leaq 0x1bea(%rip), %rsi      # 0x5279
callq 0x21b0
movq %rax, %rdi
movq 0x4922(%rip), %rsi      # 0x7fc0
callq 0x21c0
jmp 0x36fc
movb $0x1, 0x4bf9(%rip)      # 0x82a5
movl $0x38, %edi
callq 0x2230
movq %rax, -0x8(%rbp)
movl $0x8, %edi
callq 0x2230
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2220
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
leaq -0x1b0(%rip), %rdx      # 0x3530
xorl %eax, %eax
movl %eax, %ecx
callq 0x2370
cmpl $0x0, %eax
je 0x36fa
leaq 0x1bb2(%rip), %rdi      # 0x52a7
callq 0x2150
jmp 0x36fc
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: CDISC2020[P]Projet_satellite_agile/src/FDIR/watchdog_arduino.cpp
// Function: Watchdog_arduino::Watchdog_arduino()
Watchdog_arduino::Watchdog_arduino() 
{
	// activation des GPIO
	GPIOExport(3);
	GPIOExport(2);

	// choix du mode (in/out) des GPIO
	GPIODirection(3,OUT);
	GPIODirection(2,IN);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x3, %edi
callq 0x41b0
movl $0x2, %edi
callq 0x41b0
movl $0x3, %edi
movl $0x1, %esi
callq 0x42f0
movl $0x2, %edi
xorl %esi, %esi
callq 0x42f0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: yoavweiss[P]cache-digests-cuckoo/cuckoo.cpp
// Function: Cuckoo::bigEndianWrite(unsigned char*, unsigned int, unsigned long, unsigned long)
void Cuckoo::bigEndianWrite(unsigned char* digest, unsigned startPosition, size_t length, unsigned long number) {
    const unsigned long digit = 0xff;
    for (int i = length - 1; i >= 0; --i) {
        unsigned long temp = number & digit;
        digest[startPosition + i] = (unsigned char)temp;
        number >>= 8;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq $0xff, -0x28(%rbp)
movq -0x18(%rbp), %rax
subq $0x1, %rax
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jl 0x2666
movq -0x20(%rbp), %rax
andq $0xff, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movb %al, %dl
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
addl -0x2c(%rbp), %ecx
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
movq -0x20(%rbp), %rax
shrq $0x8, %rax
movq %rax, -0x20(%rbp)
movl -0x2c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x2626
popq %rbp
retq
nopl (%rax,%rax)
// File: yoavweiss[P]cache-digests-cuckoo/cuckoo.cpp
// Function: Cuckoo::bigEndianRead(unsigned char const*, unsigned int, unsigned long)
unsigned long Cuckoo::bigEndianRead(const unsigned char* digest, unsigned startPosition, size_t length) {
    unsigned long readNumber = 0;
    for (unsigned i = 0; i < length; ++i) {
        readNumber <<= 8;
        readNumber += digest[startPosition + i];
    }
    return readNumber;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpq -0x18(%rbp), %rax
jae 0x2ba6
movq -0x20(%rbp), %rax
shlq $0x8, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
addl -0x24(%rbp), %ecx
movl %ecx, %ecx
movzbl (%rax,%rcx), %eax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x2b6e
movq -0x20(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: yoavweiss[P]cache-digests-cuckoo/cuckoo.cpp
// Function: Cuckoo::key(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::string Cuckoo::key(std::string URL, std::string ETag) {
    // Given the following inputs:
    //
    // * `URL`, an array of characters
    // * `ETag`, an array of characters
    // 1. Let `key` be `URL` converted to an ASCII string by percent-encoding as appropriate {{RFC3986}}.
    // TODO(yoav): Convert to ascii.
    std::string keyString = URL;
    // 2. If `ETag` is not null:
    if (!ETag.empty()) {
        // 1. Append `ETag` to `key` as an ASCII string, including both the `weak` indicator (if present) and double quotes, as per {{RFC7232}}, Section 2.3.
        // TODO(yoav): Only add the double quotes if they are not already there.
        keyString += "\"" + ETag + "\"";
    }
    return keyString;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdx, -0x78(%rbp)
movq %rdi, -0x88(%rbp)
movq %rdi, %rax
movq %rax, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x2110
movq -0x78(%rbp), %rdi
callq 0x22e0
testb $0x1, %al
jne 0x2c81
movq -0x78(%rbp), %rdx
leaq 0x358d(%rip), %rsi      # 0x618b
leaq -0x60(%rbp), %rdi
callq 0x4250
jmp 0x2c09
leaq 0x357b(%rip), %rdx      # 0x618b
leaq -0x40(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x4200
jmp 0x2c1f
movq -0x88(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x2250
jmp 0x2c31
leaq -0x40(%rbp), %rdi
callq 0x2190
leaq -0x60(%rbp), %rdi
callq 0x2190
jmp 0x2c81
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x2ca4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x2c76
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x2190
leaq -0x60(%rbp), %rdi
callq 0x2190
jmp 0x2ca4
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x2c97
movq -0x88(%rbp), %rdi
callq 0x2190
movq -0x80(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x88(%rbp), %rdi
callq 0x2190
movq -0x68(%rbp), %rdi
callq 0x2330
nopl (%rax)