LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: redpony[P]cpyp/./cpyp/crp_table_manager.h
// Function: std::pair<unsigned int, int> cpyp::crp_table_manager<1u>::remove_customer<cpyp::MT19937>(cpyp::MT19937&, unsigned int*)
inline std::pair<unsigned,int> remove_customer(Engine& eng, unsigned* selected_table_postcount) {
    int r = sample_uniform01<double>(eng) * num_customers();
    const auto floor_count = [&]()->std::pair<unsigned,int> {
      for (unsigned floor = 0; floor < NumFloors; ++floor) {
        const auto end = h[floor].end();
        auto i = h[floor].begin();
        for (; i != end; ++i) {
          // sample randomly, i.e. *don't* discount
          const int thresh = i->first * i->second;
          if (thresh > r) return std::make_pair(floor, i->first);
          r -= thresh;
        }
      }
      std::cerr << "Serious error while decrementing: Floors=" << NumFloors
                << " r=" << r << std::endl;
      std::abort();
    }();
    --customers;
    const unsigned tc = floor_count.second;
    if (selected_table_postcount) *selected_table_postcount = tc - 1;
    if (tc == 1) { // remove customer from table containing a single customer
      h[floor_count.first].decrement(1);
      --tables;
      return std::make_pair(floor_count.first, -1);
    } else {
      h[floor_count.first].move(tc, tc - 1);
      return std::make_pair(0u, 0);
    }
  }

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq %rdx, 0x48(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x50(%rsp), %rdi
callq 0x6510
movq 0x10(%rsp), %rdi
movsd %xmm0, 0x8(%rsp)
callq 0xc9f0
movsd 0x8(%rsp), %xmm0
movl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, %ecx
cvtsi2sd %rcx, %xmm1
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %ecx
movl %ecx, 0x44(%rsp)
movq %rax, 0x28(%rsp)
leaq 0x44(%rsp), %rax
movq %rax, 0x30(%rsp)
leaq 0x28(%rsp), %rdi
callq 0xd9d0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x3c(%rsp)
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
movl 0x40(%rsp), %eax
movl %eax, 0x24(%rsp)
cmpq $0x0, 0x48(%rsp)
je 0xcbf2
movl 0x24(%rsp), %ecx
subl $0x1, %ecx
movq 0x48(%rsp), %rax
movl %ecx, (%rax)
cmpl $0x1, 0x24(%rsp)
jne 0xcc45
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
movl 0x3c(%rsp), %eax
shlq $0x7, %rax
addq %rax, %rdi
movl $0x1, %edx
movl %edx, %esi
callq 0xdb50
movq 0x10(%rsp), %rax
movl 0x4(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x4(%rax)
leaq 0x3c(%rsp), %rdi
movl $0xffffffff, 0x20(%rsp) # imm = 0xFFFFFFFF
leaq 0x20(%rsp), %rsi
callq 0xdbb0
movq %rax, 0x60(%rsp)
jmp 0xcc92
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
movl 0x3c(%rsp), %eax
shlq $0x7, %rax
addq %rax, %rdi
movl 0x24(%rsp), %esi
movl 0x24(%rsp), %edx
subl $0x1, %edx
movl $0x1, %ecx
callq 0xdbe0
movl $0x0, 0x1c(%rsp)
movl $0x0, 0x18(%rsp)
leaq 0x1c(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0xdc30
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rax
addq $0x68, %rsp
retq
nopl (%rax)
// File: redpony[P]cpyp/./cpyp/msparse_vector.h
// Function: cpyp::SparseVector<unsigned int, 15u>::const_iterator::operator->() const
const std::pair<const unsigned, T>* operator->() const {
      if (local_)
        return reinterpret_cast<const std::pair<const unsigned, T>*>(local_it_);
      else
        return &*remote_it_;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
testb $0x1, (%rax)
je 0xdc86
movq (%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0xdc98
movq (%rsp), %rdi
addq $0x10, %rdi
callq 0xb1c0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: redpony[P]cpyp/./cpyp/msparse_vector.h
// Function: cpyp::SparseVector<unsigned int, 15u>::erase(unsigned int)
void erase(unsigned k) {
    if (is_remote_) {
      data_.rbmap->erase(k);
    } else {
      for (unsigned i = 0; i < local_size_; ++i) {
        if (data_.local[i].first() == k) {
          for (unsigned j = i+1; j < local_size_; ++j) {
            data_.local[j-1].first() = data_.local[j].first();
            data_.local[j-1].second() = data_.local[j].second();
          }
        }
      }
      --local_size_;
    }
  }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
testb $0x1, 0x79(%rax)
je 0xdd94
movq 0x8(%rsp), %rax
movq (%rax), %rdi
leaq 0x1c(%rsp), %rsi
callq 0xf940
jmp 0xde98
movl $0x0, 0x18(%rsp)
movq 0x8(%rsp), %rcx
movl 0x18(%rsp), %eax
movzbl 0x78(%rcx), %ecx
cmpl %ecx, %eax
jae 0xde8a
movq 0x8(%rsp), %rdi
movl 0x18(%rsp), %eax
shlq $0x3, %rax
addq %rax, %rdi
callq 0xe040
movl (%rax), %eax
cmpl 0x1c(%rsp), %eax
jne 0xde78
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
movq 0x8(%rsp), %rcx
movl 0x14(%rsp), %eax
movzbl 0x78(%rcx), %ecx
cmpl %ecx, %eax
jae 0xde76
movq 0x8(%rsp), %rdi
movl 0x14(%rsp), %eax
shlq $0x3, %rax
addq %rax, %rdi
callq 0xe040
movq 0x8(%rsp), %rdi
movl (%rax), %eax
movl %eax, (%rsp)
movl 0x14(%rsp), %eax
subl $0x1, %eax
movl %eax, %eax
shlq $0x3, %rax
addq %rax, %rdi
callq 0xe040
movl (%rsp), %ecx
movq 0x8(%rsp), %rdi
movl %ecx, (%rax)
movl 0x14(%rsp), %eax
shlq $0x3, %rax
addq %rax, %rdi
callq 0xe050
movq 0x8(%rsp), %rdi
movl (%rax), %eax
movl %eax, 0x4(%rsp)
movl 0x14(%rsp), %eax
subl $0x1, %eax
movl %eax, %eax
shlq $0x3, %rax
addq %rax, %rdi
callq 0xe050
movl 0x4(%rsp), %ecx
movl %ecx, (%rax)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0xdddd
jmp 0xde78
jmp 0xde7a
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0xdd9c
movq 0x8(%rsp), %rax
movb 0x78(%rax), %cl
addb $-0x1, %cl
movb %cl, 0x78(%rax)
addq $0x28, %rsp
retq
nopl (%rax)
// File: redpony[P]cpyp/./cpyp/msparse_vector.h
// Function: cpyp::SparseVector<unsigned int, 15u>::get_or_create_bin(unsigned int)
inline T& get_or_create_bin(unsigned k) {
    if (is_remote_) {
      return (*data_.rbmap)[k];
    } else {
      for (unsigned i = 0; i < local_size_; ++i)
        if (data_.local[i].first() == k) return data_.local[i].second();
    }
    assert(!is_remote_);
    // currently local!
    if (local_size_ < LOCAL_MAX) {
      PairIntT<T>& p = data_.local[local_size_];
      ++local_size_;
      p.first() = k;
      p.second() = T();
      return p.second();
    } else {
      swap_local_rbmap();
      return (*data_.rbmap)[k];  
    }
  }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
testb $0x1, 0x79(%rax)
je 0xded9
movq 0x10(%rsp), %rax
movq (%rax), %rdi
leaq 0x24(%rsp), %rsi
callq 0xe010
movq %rax, 0x30(%rsp)
jmp 0xdffb
movl $0x0, 0x20(%rsp)
movq 0x10(%rsp), %rcx
movl 0x20(%rsp), %eax
movzbl 0x78(%rcx), %ecx
cmpl %ecx, %eax
jae 0xdf3d
movq 0x10(%rsp), %rdi
movl 0x20(%rsp), %eax
shlq $0x3, %rax
addq %rax, %rdi
callq 0xe040
movl (%rax), %eax
cmpl 0x24(%rsp), %eax
jne 0xdf2e
movq 0x10(%rsp), %rdi
movl 0x20(%rsp), %eax
shlq $0x3, %rax
addq %rax, %rdi
callq 0xe050
movq %rax, 0x30(%rsp)
jmp 0xdffb
jmp 0xdf30
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0xdee1
jmp 0xdf3f
movq 0x10(%rsp), %rax
movb 0x79(%rax), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xdf4f
jmp 0xdf51
jmp 0xdf70
leaq 0x7933(%rip), %rdi      # 0x1588b
leaq 0x7938(%rip), %rsi      # 0x15897
movl $0x1aa, %edx            # imm = 0x1AA
leaq 0x7944(%rip), %rcx      # 0x158af
callq 0x20e0
movq 0x10(%rsp), %rax
movzbl 0x78(%rax), %eax
cmpl $0xf, %eax
jae 0xdfda
movq 0x10(%rsp), %rax
movzbl 0x78(%rax), %ecx
movl %ecx, %edx
shlq $0x3, %rdx
movq %rax, %rcx
addq %rdx, %rcx
movq %rcx, 0x18(%rsp)
movb 0x78(%rax), %cl
addb $0x1, %cl
movb %cl, 0x78(%rax)
movl 0x24(%rsp), %eax
movl %eax, 0xc(%rsp)
movq 0x18(%rsp), %rdi
callq 0xe040
movl 0xc(%rsp), %ecx
movl %ecx, (%rax)
movq 0x18(%rsp), %rdi
callq 0xe050
movl $0x0, (%rax)
movq 0x18(%rsp), %rdi
callq 0xe050
movq %rax, 0x30(%rsp)
jmp 0xdffb
movq 0x10(%rsp), %rdi
callq 0xe060
movq 0x10(%rsp), %rax
movq (%rax), %rdi
leaq 0x24(%rsp), %rsi
callq 0xe010
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: redpony[P]cpyp/./cpyp/crp_table_manager.h
// Function: unsigned int cpyp::crp_table_manager<1u>::share_table<cpyp::MT19937>(double, cpyp::MT19937&)
unsigned share_table(const double discount, Engine& eng) {
    const double z = customers - discount * num_tables();
    double r = z * sample_uniform01<double>(eng);
    const auto floor_count = [&]()->std::pair<unsigned,int> {
      for (unsigned floor = 0; floor < NumFloors; ++floor) {
        const auto end = h[floor].end();
        auto i = h[floor].begin();
        for (; i != end; ++i) {
          const double thresh = (i->first - discount) * i->second;
          if (thresh > r) return std::make_pair(floor, i->first);
          r -= thresh;
        }
      }
      std::cerr << "Serious error while incrementing: Floors=" << NumFloors
                << " r=" << r << std::endl;
      std::abort();
    }();
    const unsigned cc = floor_count.second;
    h[floor_count.first].move(cc, cc + 1);
    ++customers;
    return cc;
  }

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movsd %xmm0, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movq 0x70(%rsp), %rdi
movq %rdi, 0x20(%rsp)
movl (%rdi), %eax
cvtsi2sd %rax, %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x68(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
callq 0xb2e0
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
movl %eax, %eax
cvtsi2sd %rax, %xmm2
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x58(%rsp)
movsd 0x58(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
movq 0x60(%rsp), %rdi
callq 0x6510
movq 0x20(%rsp), %rax
movaps %xmm0, %xmm1
movsd 0x18(%rsp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, 0x50(%rsp)
movq %rax, 0x30(%rsp)
leaq 0x68(%rsp), %rax
movq %rax, 0x38(%rsp)
leaq 0x50(%rsp), %rax
movq %rax, 0x40(%rsp)
leaq 0x30(%rsp), %rdi
callq 0xff60
movq 0x20(%rsp), %rdi
movq %rax, 0x48(%rsp)
movl 0x4c(%rsp), %eax
movl %eax, 0x2c(%rsp)
addq $0x8, %rdi
movl 0x48(%rsp), %eax
shlq $0x7, %rax
addq %rax, %rdi
movl 0x2c(%rsp), %esi
movl 0x2c(%rsp), %edx
addl $0x1, %edx
movl $0x1, %ecx
callq 0xdbe0
movq 0x20(%rsp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movl 0x2c(%rsp), %eax
addq $0x78, %rsp
retq
// File: redpony[P]cpyp/./cpyp/crp.h
// Function: cpyp::crp<int, std::hash<int>>::update_llh_add_customer_to_table_seating(unsigned int)
void update_llh_add_customer_to_table_seating(unsigned n) {
    unsigned t = 0;
    if (n == 0) {
      t = 1;
    }
    llh_ -= log(strength_ + num_customers_);
    if (t == 1) {
      llh_ += log(discount_) + log(strength_ / discount_ + num_tables_);
    }
    if (n > 0) {
      llh_ += log(n - discount_);
    }
  }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x0, 0x18(%rsp)
cmpl $0x0, 0x1c(%rsp)
jne 0xfe1e
movl $0x1, 0x18(%rsp)
movq 0x10(%rsp), %rax
movsd 0x48(%rax), %xmm0
movl 0x4(%rax), %eax
cvtsi2sd %rax, %xmm1
addsd %xmm1, %xmm0
callq 0x2130
movq 0x10(%rsp), %rax
movaps %xmm0, %xmm1
movsd 0x70(%rax), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, 0x70(%rax)
cmpl $0x1, 0x18(%rsp)
jne 0xfeaa
movq 0x10(%rsp), %rax
movsd 0x40(%rax), %xmm0
callq 0x2130
movq 0x10(%rsp), %rax
movsd %xmm0, 0x8(%rsp)
movsd 0x48(%rax), %xmm0
movsd 0x40(%rax), %xmm1
divsd %xmm1, %xmm0
movl (%rax), %eax
cvtsi2sd %rax, %xmm1
addsd %xmm1, %xmm0
callq 0x2130
movq 0x10(%rsp), %rax
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
addsd %xmm1, %xmm0
addsd 0x70(%rax), %xmm0
movsd %xmm0, 0x70(%rax)
cmpl $0x0, 0x1c(%rsp)
jbe 0xfed8
movq 0x10(%rsp), %rax
movl 0x1c(%rsp), %ecx
cvtsi2sd %rcx, %xmm0
subsd 0x40(%rax), %xmm0
callq 0x2130
movq 0x10(%rsp), %rax
addsd 0x70(%rax), %xmm0
movsd %xmm0, 0x70(%rax)
addq $0x28, %rsp
retq
nopl (%rax)
// File: redpony[P]cpyp/./cpyp/crp_table_manager.h
// Function: cpyp::crp_table_manager<1u>::create_table(unsigned int)
inline void create_table(const unsigned floor = 0) {
    assert(floor < NumFloors);
    h[floor].increment(1);
    ++tables;
    ++customers;
  }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
cmpl $0x1, 0xc(%rsp)
jae 0xfeff
jmp 0xff1e
leaq 0x5ab8(%rip), %rdi      # 0x159be
leaq 0x5ac3(%rip), %rsi      # 0x159d0
movl $0x43, %edx
leaq 0x5ad2(%rip), %rcx      # 0x159eb
callq 0x20e0
movq (%rsp), %rdi
addq $0x8, %rdi
movl 0xc(%rsp), %eax
shlq $0x7, %rax
addq %rax, %rdi
movl $0x1, %edx
movl %edx, %esi
callq 0xfc70
movq (%rsp), %rax
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4(%rax)
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: redpony[P]cpyp/./cpyp/mf_crp.h
// Function: cpyp::mf_crp<2u, unsigned int, std::hash<unsigned int>>::check_hyperparameters()
void check_hyperparameters() {
    if (discount_ < 0.0 || discount_ >= 1.0) {
      std::cerr << "Bad discount: " << discount_ << std::endl;
      abort();
    }
    if (strength_ <= -discount_) {
      std::cerr << "Bad strength: " << strength_ << " (discount=" << discount_ << ")" << std::endl;
      abort();
    }

    llh_ = lgamma(strength_) - lgamma(strength_ / discount_);
    if (has_discount_prior())
      llh_ = Md::log_beta_density(discount_, discount_prior_strength_, discount_prior_beta_);
    if (has_strength_prior())
      llh_ += Md::log_gamma_density(strength_ + discount_, strength_prior_shape_, strength_prior_rate_);
    if (num_tables_ > 0) llh_ = log_likelihood(discount_, strength_);
  }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
xorps %xmm0, %xmm0
ucomisd 0x40(%rax), %xmm0
ja 0x118f5
movq 0x10(%rsp), %rax
movsd 0x40(%rax), %xmm0
movsd 0x3721(%rip), %xmm1     # 0x15010
ucomisd %xmm1, %xmm0
jb 0x1192e
movq 0xc6f4(%rip), %rdi      # 0x1dff0
leaq 0x3e9c(%rip), %rsi      # 0x1579f
callq 0x2180
movq %rax, %rdi
movq 0x10(%rsp), %rax
movsd 0x40(%rax), %xmm0
callq 0x2290
movq %rax, %rdi
movq 0xc6a4(%rip), %rsi      # 0x1dfc8
callq 0x21a0
callq 0x20d0
movq 0x10(%rsp), %rax
movsd 0x48(%rax), %xmm1
movsd 0x40(%rax), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
ucomisd %xmm1, %xmm0
jb 0x119c3
movq 0xc68f(%rip), %rdi      # 0x1dff0
leaq 0x3e46(%rip), %rsi      # 0x157ae
callq 0x2180
movq %rax, %rdi
movq 0x10(%rsp), %rax
movsd 0x48(%rax), %xmm0
callq 0x2290
movq %rax, %rdi
leaq 0x3e34(%rip), %rsi      # 0x157bd
callq 0x2180
movq %rax, %rdi
movq 0x10(%rsp), %rax
movsd 0x40(%rax), %xmm0
callq 0x2290
movq %rax, %rdi
leaq 0x3ab8(%rip), %rsi      # 0x15462
callq 0x2180
movq %rax, %rdi
movq 0xc60f(%rip), %rsi      # 0x1dfc8
callq 0x21a0
callq 0x20d0
movq 0x10(%rsp), %rax
movsd 0x48(%rax), %xmm0
callq 0x2110
movq 0x10(%rsp), %rax
movsd %xmm0, 0x8(%rsp)
movsd 0x48(%rax), %xmm0
divsd 0x40(%rax), %xmm0
callq 0x2110
movq 0x10(%rsp), %rdi
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, 0x70(%rdi)
callq 0x11bd0
testb $0x1, %al
jne 0x11a0e
jmp 0x11a34
movq 0x10(%rsp), %rdx
movq %rdx, %rdi
addq $0x40, %rdi
movq %rdx, %rsi
addq $0x50, %rsi
addq $0x58, %rdx
callq 0xa7a0
movq 0x10(%rsp), %rax
movsd %xmm0, 0x70(%rax)
movq 0x10(%rsp), %rdi
callq 0x11bf0
testb $0x1, %al
jne 0x11a44
jmp 0x11a7d
movq 0x10(%rsp), %rdx
movsd 0x48(%rdx), %xmm0
addsd 0x40(%rdx), %xmm0
movsd %xmm0, 0x18(%rsp)
movq %rdx, %rsi
addq $0x60, %rsi
addq $0x68, %rdx
leaq 0x18(%rsp), %rdi
callq 0xa950
movq 0x10(%rsp), %rax
addsd 0x70(%rax), %xmm0
movsd %xmm0, 0x70(%rax)
movq 0x10(%rsp), %rax
cmpl $0x0, (%rax)
jbe 0x11aa9
movq 0x10(%rsp), %rdi
movq %rdi, %rsi
addq $0x40, %rsi
movq %rdi, %rdx
addq $0x48, %rdx
callq 0x11c10
movq 0x10(%rsp), %rax
movsd %xmm0, 0x70(%rax)
addq $0x28, %rsp
retq
nop
// File: redpony[P]cpyp/./cpyp/mf_crp.h
// Function: cpyp::mf_crp<2u, unsigned int, std::hash<unsigned int>>::update_llh_remove_customer_from_table_seating(unsigned int)
void update_llh_remove_customer_from_table_seating(unsigned n) {
    unsigned t = 0;
    if (n == 1) t = 1;
    llh_ += log(strength_ + num_customers_ - 1);
    if (t == 1) llh_ -= log(discount_) + log(strength_ / discount_ + num_tables_ - 1);
    if (n > 1) llh_ -= log(n - discount_ - 1);
  }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x0, 0x18(%rsp)
cmpl $0x1, 0x1c(%rsp)
jne 0x13cee
movl $0x1, 0x18(%rsp)
movq 0x10(%rsp), %rax
movsd 0x48(%rax), %xmm0
movl 0x4(%rax), %eax
cvtsi2sd %rax, %xmm1
addsd %xmm1, %xmm0
movsd 0x1304(%rip), %xmm1     # 0x15010
subsd %xmm1, %xmm0
callq 0x2130
movq 0x10(%rsp), %rax
addsd 0x70(%rax), %xmm0
movsd %xmm0, 0x70(%rax)
cmpl $0x1, 0x18(%rsp)
jne 0x13d8c
movq 0x10(%rsp), %rax
movsd 0x40(%rax), %xmm0
callq 0x2130
movq 0x10(%rsp), %rax
movsd %xmm0, 0x8(%rsp)
movsd 0x48(%rax), %xmm0
movsd 0x40(%rax), %xmm1
divsd %xmm1, %xmm0
movl (%rax), %eax
cvtsi2sd %rax, %xmm1
addsd %xmm1, %xmm0
movsd 0x12aa(%rip), %xmm1     # 0x15010
subsd %xmm1, %xmm0
callq 0x2130
movsd 0x8(%rsp), %xmm1
movq 0x10(%rsp), %rax
addsd %xmm0, %xmm1
movsd 0x70(%rax), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, 0x70(%rax)
cmpl $0x1, 0x1c(%rsp)
jbe 0x13dcd
movq 0x10(%rsp), %rax
movl 0x1c(%rsp), %ecx
cvtsi2sd %rcx, %xmm0
subsd 0x40(%rax), %xmm0
movsd 0x1262(%rip), %xmm1     # 0x15010
subsd %xmm1, %xmm0
callq 0x2130
movq 0x10(%rsp), %rax
movaps %xmm0, %xmm1
movsd 0x70(%rax), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, 0x70(%rax)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: redpony[P]cpyp/./cpyp/msparse_vector.h
// Function: cpyp::SparseVector<unsigned int, 15u>::size() const
inline size_t size() const {
    if (is_remote_)
      return data_.rbmap->size();
    else
      return local_size_;
  }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
testb $0x1, 0x79(%rax)
je 0x13fcb
movq (%rsp), %rax
movq (%rax), %rdi
callq 0xee40
movq %rax, 0x10(%rsp)
jmp 0x13fd8
movq (%rsp), %rax
movzbl 0x78(%rax), %eax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: redpony[P]cpyp/./cpyp/crp.h
// Function: cpyp::crp<int, std::hash<int>>::print(std::ostream*) const
void print(std::ostream* out) const {
    (*out) << "PYP(d=" << discount_ << ",c=" << strength_
           << ") customers=" << num_customers_ << std::endl;
    for (auto& dish_loc : dish_locs_)
      (*out) << dish_loc.first << " : " << dish_loc.second << std::endl;
  }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
movq 0x28(%rsp), %rdi
leaq 0x1788(%rip), %rsi      # 0x15c1b
callq 0x2180
movq %rax, %rdi
movq (%rsp), %rax
movsd 0x40(%rax), %xmm0
callq 0x2290
movq %rax, %rdi
leaq 0x176f(%rip), %rsi      # 0x15c22
callq 0x2180
movq %rax, %rdi
movq (%rsp), %rax
movsd 0x48(%rax), %xmm0
callq 0x2290
movq %rax, %rdi
leaq 0x1753(%rip), %rsi      # 0x15c26
callq 0x2180
movq %rax, %rdi
movq (%rsp), %rax
movl 0x4(%rax), %esi
callq 0x2200
movq %rax, %rdi
movq 0x9ad7(%rip), %rsi      # 0x1dfc8
callq 0x21a0
movq (%rsp), %rax
addq $0x8, %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0xab00
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0xab30
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xab60
testb $0x1, %al
jne 0x14536
jmp 0x14591
leaq 0x18(%rsp), %rdi
callq 0xab80
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rax
movl (%rax), %esi
callq 0x2250
movq %rax, %rdi
leaq 0x16d3(%rip), %rsi      # 0x15c33
callq 0x2180
movq %rax, %rdi
movq 0x8(%rsp), %rsi
addq $0x8, %rsi
callq 0x145a0
movq %rax, %rdi
movq 0x9a48(%rip), %rsi      # 0x1dfc8
callq 0x21a0
leaq 0x18(%rsp), %rdi
callq 0xacd0
jmp 0x14521
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: kdungs[P]codecon/src/apples.cc
// Function: main
int main() {
  long long a0, o0, m0, x, y, mf;
  std::cin >> a0 >> o0 >> m0 >> x >> y >> mf;

  const auto dm = mf - m0;
  const auto mm = a0 * x + o0 * y - dm;

  const auto a = findSolution(mm, x, y);
  const auto o = findSolution(mm, y, x);

  if (a == -1 || o == -1) {
    std::cout << "Impossible\n";
  } else {
    std::cout << a << ' ' << o << '\n';
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl $0x0, -0x4(%rbp)
movq 0x2dfa(%rip), %rdi      # 0x3fe0
leaq -0x10(%rbp), %rsi
callq 0x1070
movq %rax, %rdi
leaq -0x18(%rbp), %rsi
callq 0x1070
movq %rax, %rdi
leaq -0x20(%rbp), %rsi
callq 0x1070
movq %rax, %rdi
leaq -0x28(%rbp), %rsi
callq 0x1070
movq %rax, %rdi
leaq -0x30(%rbp), %rsi
callq 0x1070
movq %rax, %rdi
leaq -0x38(%rbp), %rsi
callq 0x1070
movq -0x38(%rbp), %rax
subq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
imulq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
imulq -0x30(%rbp), %rcx
addq %rcx, %rax
subq -0x40(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x12e0
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x12e0
movq %rax, -0x58(%rbp)
cmpq $-0x1, -0x50(%rbp)
je 0x128c
cmpq $-0x1, -0x58(%rbp)
jne 0x12a1
movq 0x2d3d(%rip), %rdi      # 0x3fd0
leaq 0xd6a(%rip), %rsi       # 0x2004
callq 0x1050
jmp 0x12d7
movq -0x50(%rbp), %rsi
movq 0x2d24(%rip), %rdi      # 0x3fd0
callq 0x1030
movq %rax, %rdi
movl $0x20, %esi
callq 0x1060
movq %rax, %rdi
movq -0x58(%rbp), %rsi
callq 0x1030
movq %rax, %rdi
movl $0xa, %esi
callq 0x1060
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
// File: kdungs[P]codecon/src/apples.cc
// Function: long long findSolution<long long>(long long, long long, long long)
T findSolution(T max_money, const T my_price, const T other_price) {
  while (max_money > 0 && (max_money % my_price) != 0) {
    max_money -= other_price;
  }
  if (max_money <= 0) {
    return -1;
  }
  return max_money / my_price;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x10(%rbp)
movb %al, -0x21(%rbp)
jle 0x1310
movq -0x10(%rbp), %rax
cqto
idivq -0x18(%rbp)
cmpq $0x0, %rdx
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x1319
jmp 0x132a
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x10(%rbp)
jmp 0x12f0
cmpq $0x0, -0x10(%rbp)
jg 0x133b
movq $-0x1, -0x8(%rbp)
jmp 0x1349
movq -0x10(%rbp), %rax
cqto
idivq -0x18(%rbp)
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
// File: iZhangHui[P]CppPrimer/CH04_Expressions/examples/overflow.cc
// Function: main
int main() 
{
	short short_value = 32767; // max value if shorts are 16 bits

	short_value += 1; // this calculation overflows
	cout << "short_value: " << short_value << endl;

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movw $0x7fff, -0x6(%rbp)     # imm = 0x7FFF
movswl -0x6(%rbp), %eax
addl $0x1, %eax
movw %ax, -0x6(%rbp)
movq 0x2df1(%rip), %rdi      # 0x3fd8
leaq 0xe16(%rip), %rsi       # 0x2004
callq 0x1050
movq %rax, %rdi
movswl -0x6(%rbp), %esi
callq 0x1040
movq %rax, %rdi
movq 0x2dbf(%rip), %rsi      # 0x3fc8
callq 0x1060
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
// File: myudelson[P]hmm-scalable/inputconvert.cpp
// Function: main
int main (int argc, char ** argv) {
    
	clock_t tm0 = clock();
	char input_file[1024];
	char output_file[1024];
    
	set_task_defaults(&task);
	parse_arguments(argc, argv, input_file, output_file);
    
    if( source_format=='t') {
        InputUtilSt::readTxt(input_file, &task);
//        // vvv temporary
//        FILE *fid = fopen(output_file,"w");
//        for(NCAT i=0; i<task.map_group_bwd->size(); i++) {
//            fprintf(fid,"%s\n",task.map_group_bwd->find((NCAT)i)->second.c_str());
//        }
//        fclose(fid);
//        // ^^^ temporary
        InputUtilSt::toBin(&task, output_file);
    }
    else {
        InputUtilSt::readBin(input_file, &task);
    }
	// free data
	destroy_input_data(&task);
	
	if(task.quiet == 0)
		printf("overall time running is %8.6f seconds\n",(NUMBER)(clock()-tm0)/CLOCKS_PER_SEC);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x820, %rsp            # imm = 0x820
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x3180
movq %rax, -0x18(%rbp)
leaq 0x1299f(%rip), %rdi     # 0x162d8
callq 0x7a40
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
leaq -0x420(%rbp), %rdx
leaq -0x820(%rbp), %rcx
callq 0x3680
movsbl 0x12941(%rip), %eax     # 0x162a0
cmpl $0x74, %eax
jne 0x398c
leaq -0x420(%rbp), %rdi
leaq 0x12966(%rip), %rsi     # 0x162d8
callq 0x9fe0
leaq -0x820(%rbp), %rsi
leaq 0x12953(%rip), %rdi     # 0x162d8
callq 0xcd60
jmp 0x399f
leaq -0x420(%rbp), %rdi
leaq 0x1293e(%rip), %rsi     # 0x162d8
callq 0xc090
leaq 0x12932(%rip), %rdi     # 0x162d8
callq 0x8080
movsbl 0x12972(%rip), %eax     # 0x16324
cmpl $0x0, %eax
jne 0x39df
callq 0x3180
subq -0x18(%rbp), %rax
cvtsi2sd %rax, %xmm0
movsd 0xc693(%rip), %xmm1     # 0x10060
divsd %xmm1, %xmm0
leaq 0xc91c(%rip), %rdi      # 0x102f4
movb $0x1, %al
callq 0x3060
xorl %eax, %eax
addq $0x820, %rsp            # imm = 0x820
popq %rbp
retq
nopw (%rax,%rax)
// File: jflemer[P]boost-chat-server/chat_server.cpp
// Function: main
int main(int argc, char* argv[])
{
  try
  {
    if (argc < 2)
    {
      std::cerr << "Usage: chat_server <port> [<port> ...]\n";
      return 1;
    }

    boost::asio::io_service io_service;

    chat_server_list servers;
    for (int i = 1; i < argc; ++i)
    {
      using namespace std; // For atoi.
      tcp::endpoint endpoint(tcp::v4(), atoi(argv[i]));
      chat_server_ptr server(new chat_server(io_service, endpoint));
      servers.push_back(server);
    }

    io_service.run();
  }
  catch (std::exception& e)
  {
    std::cerr << "Exception: " << e.what() << "\n";
  }

  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x2, -0x8(%rbp)
jge 0x7b11
movq 0x3650a(%rip), %rdi     # 0x3dff0
leaq 0x20564(%rip), %rsi     # 0x28051
callq 0x73b0
jmp 0x7af4
movl $0x1, -0x4(%rbp)
jmp 0x7cd6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x7c3a
leaq -0x30(%rbp), %rdi
callq 0x8430
jmp 0x7b1c
leaq -0x48(%rbp), %rdi
callq 0x84e0
movl $0x1, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x7c06
callq 0x8500
movl %eax, -0x6c(%rbp)
movq -0x10(%rbp), %rax
movslq -0x4c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x75e0
movzwl %ax, %edx
leaq -0x68(%rbp), %rdi
leaq -0x6c(%rbp), %rsi
callq 0x8520
movl $0xd8, %edi
callq 0x73c0
movq %rax, -0x90(%rbp)
jmp 0x7b74
movq -0x90(%rbp), %rdi
leaq -0x30(%rbp), %rsi
leaq -0x68(%rbp), %rdx
callq 0x8560
jmp 0x7b8a
movq -0x90(%rbp), %rsi
leaq -0x80(%rbp), %rdi
callq 0x8600
jmp 0x7b9c
leaq -0x48(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x8670
jmp 0x7bab
leaq -0x80(%rbp), %rdi
callq 0x86b0
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0x7b2c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x7c28
movq -0x90(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0xd8, %esi
callq 0x73d0
jmp 0x7c28
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x86b0
jmp 0x7c28
leaq -0x30(%rbp), %rdi
callq 0x86d0
jmp 0x7c11
leaq -0x48(%rbp), %rdi
callq 0x8720
leaq -0x30(%rbp), %rdi
callq 0x8740
jmp 0x7cb8
leaq -0x48(%rbp), %rdi
callq 0x8720
leaq -0x30(%rbp), %rdi
callq 0x8740
movl -0x1c(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x7ce2
movq -0x18(%rbp), %rdi
callq 0x7170
movq %rax, -0x88(%rbp)
movq 0x3638f(%rip), %rdi     # 0x3dff0
leaq 0x20411(%rip), %rsi     # 0x28079
callq 0x73b0
movq %rax, -0x98(%rbp)
jmp 0x7c76
movq -0x88(%rbp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq -0x98(%rbp), %rdi
movq %rax, %rsi
callq 0x73b0
movq %rax, -0xa0(%rbp)
jmp 0x7c9e
movq -0xa0(%rbp), %rdi
leaq 0x203cb(%rip), %rsi     # 0x28077
callq 0x73b0
jmp 0x7cb3
callq 0x7600
movl $0x0, -0x4(%rbp)
jmp 0x7cd6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x7600
jmp 0x7cd4
jmp 0x7ce2
movl -0x4(%rbp), %eax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x7650
movq %rax, %rdi
callq 0x8210
nopw %cs:(%rax,%rax)
// File: jflemer[P]boost-chat-server/chat_server.cpp
// Function: chat_server::start_accept()
void start_accept()
  {
    chat_session_ptr new_session(new chat_session(io_service_, room_));
    acceptor_.async_accept(new_session->socket(),
        boost::bind(&chat_server::handle_accept, this, new_session,
          boost::asio::placeholders::error));
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
movl $0x2d0, %edi            # imm = 0x2D0
callq 0x73c0
movq -0x80(%rbp), %rdx
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x78(%rbp)
movq (%rdx), %rsi
addq $0x58, %rdx
callq 0x1a9e0
jmp 0xfe7d
movq -0x78(%rbp), %rsi
leaq -0x18(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x1aab0
movq -0x80(%rbp), %rax
movq -0x98(%rbp), %rdi
addq $0x8, %rax
movq %rax, -0x90(%rbp)
callq 0x1ab70
movq %rax, %rdi
callq 0x1abc0
movq %rax, -0x88(%rbp)
jmp 0xfebd
leaq -0x60(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
leaq -0x18(%rbp), %rsi
callq 0x1ad70
movq -0x80(%rbp), %rcx
movq -0xa0(%rbp), %r8
leaq 0xae3d(%rip), %rax      # 0x1ad20
movq %rax, -0x70(%rbp)
movq $0x0, -0x68(%rbp)
movq -0x70(%rbp), %rsi
movq -0x68(%rbp), %rdx
leaq 0xaeb2(%rip), %r9       # 0x1adb0
leaq -0x50(%rbp), %rdi
callq 0x1abe0
jmp 0xff09
movq -0x88(%rbp), %rsi
movq -0x90(%rbp), %rdi
xorl %eax, %eax
movl %eax, %ecx
leaq -0x50(%rbp), %rdx
callq 0x1ab20
jmp 0xff26
leaq -0x50(%rbp), %rdi
callq 0x1add0
leaq -0x60(%rbp), %rdi
callq 0x1adf0
leaq -0x18(%rbp), %rdi
callq 0x1adf0
addq $0xa0, %rsp
popq %rbp
retq
movq -0x78(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x2d0, %esi            # imm = 0x2D0
callq 0x73d0
jmp 0xffa9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0xffa0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0xff97
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x1add0
leaq -0x60(%rbp), %rdi
callq 0x1adf0
leaq -0x18(%rbp), %rdi
callq 0x1adf0
movq -0x20(%rbp), %rdi
callq 0x7650
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: jflemer[P]boost-chat-server/chat_server.cpp
// Function: chat_session::deliver(chat_message const&)
void deliver(const chat_message& msg)
  {
    bool write_in_progress = !write_msgs_.empty();
    write_msgs_.push_back(msg);
    if (!write_in_progress)
    {
      boost::asio::async_write(socket_,
          boost::asio::buffer(write_msgs_.front().data(),
            write_msgs_.front().length()),
          boost::bind(&chat_session::handle_write, shared_from_this(),
            boost::asio::placeholders::error));
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x80(%rbp)
addq $0x280, %rdi            # imm = 0x280
callq 0x1b3c0
movq -0x80(%rbp), %rdi
xorb $-0x1, %al
andb $0x1, %al
movb %al, -0x11(%rbp)
addq $0x280, %rdi            # imm = 0x280
movq -0x10(%rbp), %rsi
callq 0x1b3f0
testb $0x1, -0x11(%rbp)
jne 0x1b0c3
movq -0x80(%rbp), %rdi
movq %rdi, %rax
addq $0x18, %rax
movq %rax, -0xa0(%rbp)
addq $0x280, %rdi            # imm = 0x280
movq %rdi, -0x98(%rbp)
callq 0x1b4f0
movq %rax, %rdi
callq 0x1b520
movq -0x98(%rbp), %rdi
movq %rax, -0x90(%rbp)
callq 0x1b4f0
movq %rax, %rdi
callq 0x1b530
movq -0x90(%rbp), %rdi
movq %rax, %rsi
callq 0x1b4c0
movq -0x80(%rbp), %rsi
movq %rax, -0x28(%rbp)
movq %rdx, -0x20(%rbp)
addq $0x8, %rsi
leaq -0x58(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x1b880
movq -0x88(%rbp), %rcx
leaq 0x61f(%rip), %rax       # 0x1b660
movq %rax, -0x68(%rbp)
movq $0x0, -0x60(%rbp)
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rdx
leaq -0x2ac(%rip), %r8       # 0x1adb0
leaq -0x48(%rbp), %rdi
callq 0x1b550
jmp 0x1b067
movq -0xa0(%rbp), %rdi
xorl %eax, %eax
movl %eax, %ecx
leaq -0x28(%rbp), %rsi
leaq -0x48(%rbp), %rdx
callq 0x1b460
jmp 0x1b081
leaq -0x48(%rbp), %rdi
callq 0x1b920
leaq -0x58(%rbp), %rdi
callq 0x1adf0
jmp 0x1b0c3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x1b0b8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x1b920
leaq -0x58(%rbp), %rdi
callq 0x1adf0
jmp 0x1b0cc
addq $0xa0, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x7650
nopw %cs:(%rax,%rax)
nop
// File: jflemer[P]boost-chat-server/chat_server.cpp
// Function: chat_session::handle_write(boost::system::error_code const&)
void handle_write(const boost::system::error_code& error)
  {
    if (!error)
    {
      write_msgs_.pop_front();
      if (!write_msgs_.empty())
      {
        boost::asio::async_write(socket_,
            boost::asio::buffer(write_msgs_.front().data(),
              write_msgs_.front().length()),
            boost::bind(&chat_session::handle_write, shared_from_this(),
              boost::asio::placeholders::error));
      }
    }
    else
    {
      room_.leave(shared_from_this());
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0x10(%rbp), %rdi
callq 0xb870
testb $0x1, %al
jne 0x1b7d2
movq -0xa0(%rbp), %rdi
addq $0x280, %rdi            # imm = 0x280
callq 0x1f550
movq -0xa0(%rbp), %rdi
addq $0x280, %rdi            # imm = 0x280
callq 0x1b3c0
testb $0x1, %al
jne 0x1b7cd
movq -0xa0(%rbp), %rdi
movq %rdi, %rax
addq $0x18, %rax
movq %rax, -0xc0(%rbp)
addq $0x280, %rdi            # imm = 0x280
movq %rdi, -0xb8(%rbp)
callq 0x1b4f0
movq %rax, %rdi
callq 0x1b520
movq -0xb8(%rbp), %rdi
movq %rax, -0xb0(%rbp)
callq 0x1b4f0
movq %rax, %rdi
callq 0x1b530
movq -0xb0(%rbp), %rdi
movq %rax, %rsi
callq 0x1b4c0
movq -0xa0(%rbp), %rsi
movq %rax, -0x20(%rbp)
movq %rdx, -0x18(%rbp)
addq $0x8, %rsi
leaq -0x50(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x1b880
movq -0xa8(%rbp), %rcx
leaq -0xe8(%rip), %rax       # 0x1b660
movq %rax, -0x60(%rbp)
movq $0x0, -0x58(%rbp)
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdx
leaq -0x9b3(%rip), %r8       # 0x1adb0
leaq -0x40(%rbp), %rdi
callq 0x1b550
jmp 0x1b76e
movq -0xc0(%rbp), %rdi
xorl %eax, %eax
movl %eax, %ecx
leaq -0x20(%rbp), %rsi
leaq -0x40(%rbp), %rdx
callq 0x1b460
jmp 0x1b788
leaq -0x40(%rbp), %rdi
callq 0x1b920
leaq -0x50(%rbp), %rdi
callq 0x1adf0
jmp 0x1b7cd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x1b7bf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x1b920
leaq -0x50(%rbp), %rdi
callq 0x1adf0
jmp 0x1b86a
jmp 0x1b861
movq -0xa0(%rbp), %rsi
movq 0x68(%rsi), %rax
movq %rax, -0xd0(%rbp)
addq $0x8, %rsi
leaq -0x90(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
callq 0x1b880
movq -0xd8(%rbp), %rsi
leaq -0x80(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0x1f5f0
movq -0xd0(%rbp), %rdi
movq -0xc8(%rbp), %rsi
callq 0x1f5d0
jmp 0x1b827
leaq -0x80(%rbp), %rdi
callq 0x1a7f0
leaq -0x90(%rbp), %rdi
callq 0x1adf0
jmp 0x1b861
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x1a7f0
leaq -0x90(%rbp), %rdi
callq 0x1adf0
jmp 0x1b86a
addq $0xe0, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x7650
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: jflemer[P]boost-chat-server/chat_server.cpp
// Function: chat_session::start()
void start()
  {
    room_.join(shared_from_this());
    boost::asio::async_read(socket_,
        boost::asio::buffer(read_msg_.data(), chat_message::header_length),
        boost::bind(
          &chat_session::handle_read_header, shared_from_this(),
          boost::asio::placeholders::error));
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0xb0(%rbp)
movq 0x68(%rsi), %rax
movq %rax, -0xa0(%rbp)
addq $0x8, %rsi
leaq -0x28(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x1b880
movq -0xa8(%rbp), %rsi
leaq -0x18(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x1f5f0
movq -0xa0(%rbp), %rdi
movq -0x98(%rbp), %rsi
callq 0x22e60
jmp 0x22d35
leaq -0x18(%rbp), %rdi
callq 0x1a7f0
leaq -0x28(%rbp), %rdi
callq 0x1adf0
movq -0xb0(%rbp), %rdi
movq %rdi, %rax
addq $0x18, %rax
movq %rax, -0xc0(%rbp)
addq $0x70, %rdi
callq 0x1b520
movq %rax, %rdi
movl $0x4, %esi
callq 0x1b4c0
movq -0xb0(%rbp), %rsi
movq %rax, -0x50(%rbp)
movq %rdx, -0x48(%rbp)
addq $0x8, %rsi
leaq -0x80(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x1b880
movq -0xb8(%rbp), %rcx
leaq 0x25d(%rip), %rax       # 0x23000
movq %rax, -0x90(%rbp)
movq $0x0, -0x88(%rbp)
movq -0x90(%rbp), %rsi
movq -0x88(%rbp), %rdx
leaq -0x801a(%rip), %r8      # 0x1adb0
leaq -0x70(%rbp), %rdi
callq 0x1b550
jmp 0x22dd5
movq -0xc0(%rbp), %rdi
xorl %eax, %eax
movl %eax, %ecx
leaq -0x50(%rbp), %rsi
leaq -0x70(%rbp), %rdx
callq 0x22fa0
jmp 0x22def
leaq -0x70(%rbp), %rdi
callq 0x1b920
leaq -0x80(%rbp), %rdi
callq 0x1adf0
addq $0xc0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x1a7f0
leaq -0x28(%rbp), %rdi
callq 0x1adf0
jmp 0x22e56
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x22e4d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x1b920
leaq -0x80(%rbp), %rdi
callq 0x1adf0
movq -0x38(%rbp), %rdi
callq 0x7650
nop
// File: jflemer[P]boost-chat-server/chat_server.cpp
// Function: chat_session::handle_read_header(boost::system::error_code const&)
void handle_read_header(const boost::system::error_code& error)
  {
    if (!error && read_msg_.decode_header())
    {
      boost::asio::async_read(socket_,
          boost::asio::buffer(read_msg_.body(), read_msg_.body_length()),
          boost::bind(&chat_session::handle_read_body, shared_from_this(),
            boost::asio::placeholders::error));
    }
    else
    {
      room_.leave(shared_from_this());
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0x10(%rbp), %rdi
callq 0xb870
testb $0x1, %al
jne 0x23148
movq -0xa0(%rbp), %rdi
addq $0x70, %rdi
callq 0x25cd0
testb $0x1, %al
jne 0x23048
jmp 0x23148
movq -0xa0(%rbp), %rdi
movq %rdi, %rax
addq $0x18, %rax
movq %rax, -0xc0(%rbp)
addq $0x70, %rdi
movq %rdi, -0xb8(%rbp)
callq 0x25d50
movq -0xb8(%rbp), %rdi
movq %rax, -0xb0(%rbp)
callq 0x25d70
movq -0xb0(%rbp), %rdi
movq %rax, %rsi
callq 0x1b4c0
movq -0xa0(%rbp), %rsi
movq %rax, -0x20(%rbp)
movq %rdx, -0x18(%rbp)
addq $0x8, %rsi
leaq -0x50(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x1b880
movq -0xa8(%rbp), %rcx
leaq 0x2cd0(%rip), %rax      # 0x25d90
movq %rax, -0x60(%rbp)
movq $0x0, -0x58(%rbp)
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdx
leaq -0x832b(%rip), %r8      # 0x1adb0
leaq -0x40(%rbp), %rdi
callq 0x1b550
jmp 0x230e6
movq -0xc0(%rbp), %rdi
xorl %eax, %eax
movl %eax, %ecx
leaq -0x20(%rbp), %rsi
leaq -0x40(%rbp), %rdx
callq 0x22fa0
jmp 0x23100
leaq -0x40(%rbp), %rdi
callq 0x1b920
leaq -0x50(%rbp), %rdi
callq 0x1adf0
jmp 0x231d7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x2313a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x1b920
leaq -0x50(%rbp), %rdi
callq 0x1adf0
jmp 0x231e0
movq -0xa0(%rbp), %rsi
movq 0x68(%rsi), %rax
movq %rax, -0xd0(%rbp)
addq $0x8, %rsi
leaq -0x90(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
callq 0x1b880
movq -0xd8(%rbp), %rsi
leaq -0x80(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0x1f5f0
movq -0xd0(%rbp), %rdi
movq -0xc8(%rbp), %rsi
callq 0x1f5d0
jmp 0x2319d
leaq -0x80(%rbp), %rdi
callq 0x1a7f0
leaq -0x90(%rbp), %rdi
callq 0x1adf0
jmp 0x231d7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x1a7f0
leaq -0x90(%rbp), %rdi
callq 0x1adf0
jmp 0x231e0
addq $0xe0, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x7650
nopl (%rax)
// File: jflemer[P]boost-chat-server/chat_server.cpp
// Function: chat_session::handle_read_body(boost::system::error_code const&)
void handle_read_body(const boost::system::error_code& error)
  {
    if (!error)
    {
      room_.deliver(read_msg_);
      boost::asio::async_read(socket_,
          boost::asio::buffer(read_msg_.data(), chat_message::header_length),
          boost::bind(&chat_session::handle_read_header, shared_from_this(),
            boost::asio::placeholders::error));
    }
    else
    {
      room_.leave(shared_from_this());
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0x10(%rbp), %rdi
callq 0xb870
testb $0x1, %al
jne 0x25ebe
movq -0xa0(%rbp), %rsi
movq 0x68(%rsi), %rdi
addq $0x70, %rsi
movq %rsi, -0xb8(%rbp)
callq 0x25f60
movq -0xb8(%rbp), %rdi
movq -0xa0(%rbp), %rax
addq $0x18, %rax
movq %rax, -0xb0(%rbp)
callq 0x1b520
movq %rax, %rdi
movl $0x4, %esi
callq 0x1b4c0
movq -0xa0(%rbp), %rsi
movq %rax, -0x20(%rbp)
movq %rdx, -0x18(%rbp)
addq $0x8, %rsi
leaq -0x50(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x1b880
movq -0xa8(%rbp), %rcx
leaq -0x2e36(%rip), %rax     # 0x23000
movq %rax, -0x60(%rbp)
movq $0x0, -0x58(%rbp)
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdx
leaq -0xb0a1(%rip), %r8      # 0x1adb0
leaq -0x40(%rbp), %rdi
callq 0x1b550
jmp 0x25e5c
movq -0xb0(%rbp), %rdi
xorl %eax, %eax
movl %eax, %ecx
leaq -0x20(%rbp), %rsi
leaq -0x40(%rbp), %rdx
callq 0x22fa0
jmp 0x25e76
leaq -0x40(%rbp), %rdi
callq 0x1b920
leaq -0x50(%rbp), %rdi
callq 0x1adf0
jmp 0x25f4d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x25eb0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x1b920
leaq -0x50(%rbp), %rdi
callq 0x1adf0
jmp 0x25f56
movq -0xa0(%rbp), %rsi
movq 0x68(%rsi), %rax
movq %rax, -0xc8(%rbp)
addq $0x8, %rsi
leaq -0x90(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0x1b880
movq -0xd0(%rbp), %rsi
leaq -0x80(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x1f5f0
movq -0xc8(%rbp), %rdi
movq -0xc0(%rbp), %rsi
callq 0x1f5d0
jmp 0x25f13
leaq -0x80(%rbp), %rdi
callq 0x1a7f0
leaq -0x90(%rbp), %rdi
callq 0x1adf0
jmp 0x25f4d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x1a7f0
leaq -0x90(%rbp), %rdi
callq 0x1adf0
jmp 0x25f56
addq $0xd0, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x7650
nop
// File: jflemer[P]boost-chat-server/chat_server.cpp
// Function: chat_room::deliver(chat_message const&)
void deliver(const chat_message& msg)
  {
    recent_msgs_.push_back(msg);
    while (recent_msgs_.size() > max_recent_msgs)
      recent_msgs_.pop_front();

    std::for_each(participants_.begin(), participants_.end(),
        boost::bind(&chat_participant::deliver, _1, boost::ref(msg)));
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x28(%rbp)
movq %rsi, -0x30(%rbp)
movq -0x28(%rbp), %rdi
movq %rdi, -0x98(%rbp)
addq $0x30, %rdi
movq -0x30(%rbp), %rsi
callq 0x1b3f0
movq -0x98(%rbp), %rdi
addq $0x30, %rdi
callq 0x1ba70
cmpq $0x64, %rax
jbe 0x25fb3
movq -0x98(%rbp), %rdi
addq $0x30, %rdi
callq 0x1f550
jmp 0x25f8b
movq -0x98(%rbp), %rdi
callq 0x26100
movq -0x98(%rbp), %rdi
movq %rax, -0x38(%rbp)
callq 0x26130
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
leaq -0x18(%rbp), %rcx
movq %rcx, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0x10(%rbp), %rdi
callq 0x26590
movq %rax, %rcx
movq -0xa0(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x68(%rbp)
movq $0x0, -0x70(%rbp)
movq $0x11, -0x78(%rbp)
movq -0x78(%rbp), %rsi
movq -0x70(%rbp), %rdx
movq -0x68(%rbp), %rcx
leaq -0x58(%rbp), %rdi
callq 0x26160
movq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rdx
leaq -0x90(%rbp), %rdi
leaq -0x58(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x26080
addq $0xc0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: qhan1028[P]JPEG-Decoder/jpeg-decoder.cpp
// Function: skip(std::basic_ifstream<char, std::char_traits<char>>&)
void skip(ifstream& jpegfile) {
    char c1, c2;
    jpegfile.read(&c1, 1);
    jpegfile.read(&c2, 1);
    
    unsigned int length = to_num(c1, c2);

    if (debug)
        cout << length << endl;

    jpegfile.seekg(length - 2, ios::cur);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x9(%rbp), %rsi
movl $0x1, %edx
callq 0x2230
movq -0x8(%rbp), %rdi
leaq -0xa(%rbp), %rsi
movl $0x1, %edx
callq 0x2230
movb -0x9(%rbp), %al
movsbl %al, %edi
movsbl -0xa(%rbp), %esi
callq 0x61d0
movl %eax, -0x10(%rbp)
testb $0x1, 0xdd11(%rip)      # 0x1021a
je 0x2529
movl -0x10(%rbp), %esi
movq 0xdabb(%rip), %rdi      # 0xffd0
callq 0x2260
movq %rax, %rdi
movq 0xda9c(%rip), %rsi      # 0xffc0
callq 0x21f0
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %eax
subl $0x2, %eax
movl %eax, %eax
movl %eax, %esi
movl $0x1, %edx
callq 0x2270
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: qhan1028[P]JPEG-Decoder/jpeg-decoder.cpp
// Function: process_SOI(std::basic_ifstream<char, std::char_traits<char>>&)
bool process_SOI(ifstream& jpegfile) {
    char c1, c2;
    jpegfile.read(&c1, 1);
    jpegfile.read(&c2, 1);

    /* test file format is jpeg */
    if (to_uint(c1) == TAG && to_uint(c2) == SOI) {
        if (debug)
            cout << "[SOI]" << endl;
        return 0;
    } else {
        cout << "[Error] invalid file format." << endl;
        return 1;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x11(%rbp), %rsi
movl $0x1, %edx
callq 0x2230
movq -0x10(%rbp), %rdi
leaq -0x12(%rbp), %rsi
movl $0x1, %edx
callq 0x2230
movsbl -0x11(%rbp), %edi
callq 0x6210
cmpl $0xff, %eax
jne 0x3181
movsbl -0x12(%rbp), %edi
callq 0x6210
cmpl $0xd8, %eax
jne 0x3181
testb $0x1, 0xd0c3(%rip)      # 0x1021a
je 0x317b
movq 0xce70(%rip), %rdi      # 0xffd0
leaq 0x7f99(%rip), %rsi      # 0xb100
callq 0x21b0
movq %rax, %rdi
movq 0xce4a(%rip), %rsi      # 0xffc0
callq 0x21f0
movb $0x0, -0x1(%rbp)
jmp 0x31a7
movq 0xce48(%rip), %rdi      # 0xffd0
leaq 0x7f77(%rip), %rsi      # 0xb106
callq 0x21b0
movq %rax, %rdi
movq 0xce22(%rip), %rsi      # 0xffc0
callq 0x21f0
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: qhan1028[P]JPEG-Decoder/jpeg-decoder.cpp
// Function: init_qtable()
qtable_t init_qtable() {
    qtable_t qtable = new uint8_t*[4];
    for (int i = 0; i < 4; i++) {
        qtable[i] = new uint8_t[64];
    }
    return qtable;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x20, %edi
callq 0x2030
movq %rax, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x4, -0xc(%rbp)
jge 0x3207
movl $0x40, %edi
callq 0x2030
movq %rax, %rdx
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x31dd
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)