LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/ddu1[P]polarizedtext/src/dictionary.cc
// Function: fasttext::Dictionary::initTableDiscard()
void Dictionary::initTableDiscard() {
  pdiscard_.resize(size_);
  for (size_t i = 0; i < size_; i++) {
    real f = real(words_[i].count) / real(ntokens_);
    pdiscard_[i] = sqrt(args_->t / f) + args_->t / f;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
addq $0x40, %rdi
movslq 0x58(%rbx), %rsi
callq 0x7750
cmpl $0x0, 0x58(%rbx)
je 0x5e19
movl $0x8, %r14d
xorl %r15d, %r15d
xorpd %xmm2, %xmm2
movq 0x28(%rbx), %rax
xorps %xmm1, %xmm1
cvtsi2ssq (%rax,%r14,4), %xmm1
xorps %xmm0, %xmm0
cvtsi2ssq 0x68(%rbx), %xmm0
movq (%rbx), %rax
divss %xmm0, %xmm1
movsd 0xa0(%rax), %xmm0
xorps %xmm3, %xmm3
cvtss2sd %xmm1, %xmm3
divsd %xmm3, %xmm0
ucomisd %xmm2, %xmm0
jb 0x5dcc
sqrtsd %xmm0, %xmm0
jmp 0x5de1
movsd %xmm3, 0x8(%rsp)
callq 0x31c0
movsd 0x8(%rsp), %xmm3
xorpd %xmm2, %xmm2
movq (%rbx), %rax
movq 0x40(%rbx), %rcx
movsd 0xa0(%rax), %xmm1
divsd %xmm3, %xmm1
addsd %xmm0, %xmm1
xorps %xmm0, %xmm0
cvtsd2ss %xmm1, %xmm0
movss %xmm0, (%rcx,%r15,4)
incq %r15
movslq 0x58(%rbx), %rax
addq $0x1a, %r14
cmpq %rax, %r15
jb 0x5d90
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/ddu1[P]polarizedtext/src/dictionary.cc
// Function: fasttext::Dictionary::save(std::ostream&) const
void Dictionary::save(std::ostream& out) const {
  out.write((char*) &size_, sizeof(int32_t));
  out.write((char*) &nwords_, sizeof(int32_t));
  out.write((char*) &nlabels_, sizeof(int32_t));
  out.write((char*) &ntokens_, sizeof(int64_t));
  for (int32_t i = 0; i < size_; i++) {
    entry e = words_[i];
    out.write(e.word.data(), e.word.size() * sizeof(char));
    out.put(0);
    out.write((char*) &(e.count), sizeof(int64_t));
    out.write((char*) &(e.type), sizeof(entry_type));
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x58(%rdi), %rsi
movl $0x4, %edx
movq %rbx, %rdi
movq %rsi, (%rsp)
callq 0x3320
leaq 0x5c(%r14), %rsi
movl $0x4, %edx
movq %rbx, %rdi
callq 0x3320
leaq 0x60(%r14), %rsi
movl $0x4, %edx
movq %rbx, %rdi
callq 0x3320
leaq 0x68(%r14), %rsi
movl $0x8, %edx
movq %rbx, %rdi
callq 0x3320
movq %r14, 0x8(%rsp)
cmpl $0x0, 0x58(%r14)
jle 0x63c6
leaq 0x60(%rsp), %r12
movl $0x30, %r15d
xorl %ebp, %ebp
movq 0x8(%rsp), %rax
movq 0x28(%rax), %r14
leaq (%r14,%r15), %r13
leaq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq -0x30(%r14,%r15), %rsi
movq -0x28(%r14,%r15), %rdx
addq %rsi, %rdx
leaq 0x10(%rsp), %rdi
callq 0x7844
movb -0x8(%r14,%r15), %al
leaq 0x30(%rsp), %rcx
movb %al, 0x8(%rcx)
movq -0x10(%r14,%r15), %rax
movq %rax, (%rcx)
leaq 0x40(%rsp), %rdi
movq %r13, %rsi
callq 0x7676
leaq (%r14,%r15), %rsi
addq $0x20, %rsi
movb -0x8(%rsi), %al
movb %al, 0x58(%rsp)
movq %r12, %rdi
callq 0x7590
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq %rbx, %rdi
callq 0x3320
movq %rbx, %rdi
xorl %esi, %esi
callq 0x3040
movl $0x8, %edx
movq %rbx, %rdi
leaq 0x30(%rsp), %rsi
callq 0x3320
movl $0x1, %edx
movq %rbx, %rdi
leaq 0x38(%rsp), %rsi
callq 0x3320
movq %r12, %rdi
callq 0x761a
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x6393
movq 0x50(%rsp), %rsi
subq %rdi, %rsi
callq 0x3260
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x63af
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3260
incq %rbp
movq (%rsp), %rax
movslq (%rax), %rax
addq $0x68, %r15
cmpq %rax, %rbp
jl 0x62cd
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x63f4
movq %rax, %rbx
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x63f4
movq 0x50(%rsp), %rsi
subq %rdi, %rsi
callq 0x3260
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x641f
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3260
jmp 0x641f
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x7554
movq %rbx, %rdi
callq 0x3450
nop
// File: /workspace/github_cpp_makefile_star2_O1/ddu1[P]polarizedtext/src/dictionary.cc
// Function: fasttext::Dictionary::load(std::istream&)
void Dictionary::load(std::istream& in) {
  words_.clear();
  for (int32_t i = 0; i < MAX_VOCAB_SIZE; i++) {
    word2int_[i] = -1;
  }
  in.read((char*) &size_, sizeof(int32_t));
  in.read((char*) &nwords_, sizeof(int32_t));
  in.read((char*) &nlabels_, sizeof(int32_t));
  in.read((char*) &ntokens_, sizeof(int64_t));
  for (int32_t i = 0; i < size_; i++) {
    char c;
    entry e;
    while ((c = in.get()) != 0) {
      e.word.push_back(c);
    }
    in.read((char*) &e.count, sizeof(int64_t));
    in.read((char*) &e.type, sizeof(entry_type));
    words_.push_back(e);
    word2int_[find(e.word)] = i;
  }
  initTableDiscard();
  initNgrams();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %r14
movq %rdi, %rbx
addq $0x28, %rdi
movq 0x28(%rbx), %rsi
movq %rdi, 0x8(%rsp)
callq 0x89f2
movq 0x10(%rbx), %rdi
movl $0x7270e00, %edx        # imm = 0x7270E00
movl $0xff, %esi
callq 0x3150
leaq 0x58(%rbx), %rsi
movl $0x4, %edx
movq %r14, %rdi
movq %rsi, (%rsp)
callq 0x32e0
leaq 0x5c(%rbx), %rsi
movl $0x4, %edx
movq %r14, %rdi
callq 0x32e0
leaq 0x60(%rbx), %rsi
movl $0x4, %edx
movq %r14, %rdi
callq 0x32e0
leaq 0x68(%rbx), %rsi
movl $0x8, %edx
movq %r14, %rdi
callq 0x32e0
cmpl $0x0, 0x58(%rbx)
jle 0x6591
leaq 0x20(%rsp), %r15
xorl %r12d, %r12d
leaq 0x10(%rsp), %rbp
xorl %r13d, %r13d
movq %r15, 0x10(%rsp)
movq %r12, 0x18(%rsp)
movb $0x0, 0x20(%rsp)
movq %r12, 0x30(%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%r15)
leaq 0x60(%rsp), %rax
movq %r12, 0x10(%rax)
movups %xmm0, (%rax)
movq %r14, %rdi
callq 0x32a0
testb %al, %al
je 0x6503
movsbl %al, %esi
movq %rbp, %rdi
callq 0x31f0
jmp 0x64ea
movl $0x8, %edx
movq %r14, %rdi
leaq 0x30(%rsp), %rsi
callq 0x32e0
movl $0x1, %edx
movq %r14, %rdi
leaq 0x38(%rsp), %rsi
callq 0x32e0
movq 0x8(%rsp), %rdi
movq %rbp, %rsi
callq 0x752a
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x4a22
movq 0x10(%rbx), %rcx
movl %eax, %eax
movl %r13d, (%rcx,%rax,4)
leaq 0x60(%rsp), %rdi
callq 0x761a
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x656a
movq 0x50(%rsp), %rsi
subq %rdi, %rsi
callq 0x3260
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x6581
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3260
incl %r13d
movq (%rsp), %rax
cmpl (%rax), %r13d
jl 0x64c3
movq %rbx, %rdi
callq 0x5d60
movq %rbx, %rdi
callq 0x545a
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x65b2
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x7554
movq %rbx, %rdi
callq 0x3450
// File: /workspace/github_cpp_makefile_star2_O1/ddu1[P]polarizedtext/src/matrix.cc
// Function: fasttext::Matrix::addRow(fasttext::Vector const&, long, float)
void Matrix::addRow(const Vector& vec, int64_t i, real a) {
  assert(i >= 0);
  assert(i < m_);
  assert(vec.m_ == n_);
  for (int64_t j = 0; j < n_; j++) {
    data_[i * n_ + j] += a * vec.data_[j];
  }
}

// Assembly:
pushq %rax
testq %rdx, %rdx
js 0x933a
cmpq %rdx, 0x8(%rdi)
jle 0x9359
movq 0x10(%rdi), %rax
cmpq %rax, (%rsi)
jne 0x9378
testq %rax, %rax
jle 0x9338
movq 0x8(%rsi), %rcx
imulq %rax, %rdx
shlq $0x2, %rdx
addq (%rdi), %rdx
xorl %esi, %esi
movss (%rcx,%rsi,4), %xmm1
mulss %xmm0, %xmm1
addss (%rdx,%rsi,4), %xmm1
movss %xmm1, (%rdx,%rsi,4)
incq %rsi
cmpq %rsi, %rax
jne 0x931d
popq %rax
retq
leaq 0x8307(%rip), %rdi      # 0x11648
leaq 0x85b8(%rip), %rsi      # 0x11900
leaq 0x85bf(%rip), %rcx      # 0x1190e
movl $0x45, %edx
callq 0x3160
leaq 0x85eb(%rip), %rdi      # 0x1194b
leaq 0x8599(%rip), %rsi      # 0x11900
leaq 0x85a0(%rip), %rcx      # 0x1190e
movl $0x46, %edx
callq 0x3160
leaq 0x85d3(%rip), %rdi      # 0x11952
leaq 0x857a(%rip), %rsi      # 0x11900
leaq 0x8581(%rip), %rcx      # 0x1190e
movl $0x47, %edx
callq 0x3160
nop
// File: /workspace/github_cpp_makefile_star2_O1/ddu1[P]polarizedtext/src/matrix.cc
// Function: fasttext::Matrix::dotRow(fasttext::Vector const&, long)
real Matrix::dotRow(const Vector& vec, int64_t i) {
  assert(i >= 0);
  assert(i < m_);
  assert(vec.m_ == n_);
  real d = 0.0;
  for (int64_t j = 0; j < n_; j++) {
    d += data_[i * n_ + j] * vec.data_[j];
  }
  return d;
}

// Assembly:
pushq %rax
testq %rdx, %rdx
js 0x93e3
cmpq %rdx, 0x8(%rdi)
jle 0x9402
movq 0x10(%rdi), %rax
cmpq %rax, (%rsi)
jne 0x9421
testq %rax, %rax
jle 0x93de
imulq %rax, %rdx
shlq $0x2, %rdx
addq (%rdi), %rdx
movq 0x8(%rsi), %rcx
xorps %xmm0, %xmm0
xorl %esi, %esi
movss (%rdx,%rsi,4), %xmm1
mulss (%rcx,%rsi,4), %xmm1
addss %xmm1, %xmm0
incq %rsi
cmpq %rsi, %rax
jne 0x93c6
jmp 0x93e1
xorps %xmm0, %xmm0
popq %rax
retq
leaq 0x825e(%rip), %rdi      # 0x11648
leaq 0x850f(%rip), %rsi      # 0x11900
leaq 0x8567(%rip), %rcx      # 0x1195f
movl $0x4e, %edx
callq 0x3160
leaq 0x8542(%rip), %rdi      # 0x1194b
leaq 0x84f0(%rip), %rsi      # 0x11900
leaq 0x8548(%rip), %rcx      # 0x1195f
movl $0x4f, %edx
callq 0x3160
leaq 0x852a(%rip), %rdi      # 0x11952
leaq 0x84d1(%rip), %rsi      # 0x11900
leaq 0x8529(%rip), %rcx      # 0x1195f
movl $0x50, %edx
callq 0x3160
// File: /workspace/github_cpp_makefile_star2_O1/ddu1[P]polarizedtext/src/vector.cc
// Function: fasttext::Vector::Vector(long, std::vector<int, std::allocator<int>> const&)
Vector::Vector(int64_t m, const std::vector<int32_t>& lbs) 
  : m_(m), data_(new real[m])
{
  zero();
  for( auto l : lbs) {
    assert( l < m_);
    data_[l] = 1.0;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r13
movq %rsi, (%rdi)
movq %rsi, %rax
shrq $0x3e, %rax
leaq (,%rsi,4), %r12
xorl %edi, %edi
negq %rax
sbbq %rdi, %rdi
orq %r12, %rdi
callq 0x3030
movq %rax, %r14
movq %rax, 0x8(%r13)
testq %rbx, %rbx
jle 0x9577
movq %r14, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x3150
movq (%r15), %rax
movq 0x8(%r15), %rcx
cmpq %rcx, %rax
je 0x9599
movslq (%rax), %rdx
cmpq %rbx, %rdx
jge 0x95a3
movl $0x3f800000, (%r14,%rdx,4) # imm = 0x3F800000
addq $0x4, %rax
jmp 0x957e
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x83ec(%rip), %rdi      # 0x11996
leaq 0x83ec(%rip), %rsi      # 0x1199d
leaq 0x83f3(%rip), %rcx      # 0x119ab
movl $0x21, %edx
callq 0x3160
// File: /workspace/github_cpp_makefile_star2_O1/ddu1[P]polarizedtext/src/vector.cc
// Function: fasttext::Vector::addRow(fasttext::Matrix const&, long)
void Vector::addRow(const Matrix& A, int64_t i) {
  assert(i >= 0);
  assert(i < A.m_);
  assert(m_ == A.n_);
  for (int64_t j = 0; j < A.n_; j++) {
    data_[j] += A.data_[i * A.n_ + j];
  }
}

// Assembly:
pushq %rax
testq %rdx, %rdx
js 0x9674
cmpq %rdx, 0x8(%rsi)
jle 0x9693
movq 0x10(%rsi), %rax
cmpq %rax, (%rdi)
jne 0x96b2
testq %rax, %rax
jle 0x9672
imulq %rax, %rdx
shlq $0x2, %rdx
addq (%rsi), %rdx
movq 0x8(%rdi), %rcx
xorl %esi, %esi
movss (%rdx,%rsi,4), %xmm0
addss (%rcx,%rsi,4), %xmm0
movss %xmm0, (%rcx,%rsi,4)
incq %rsi
cmpq %rsi, %rax
jne 0x965b
popq %rax
retq
leaq 0x7fcd(%rip), %rdi      # 0x11648
leaq 0x831b(%rip), %rsi      # 0x1199d
leaq 0x8362(%rip), %rcx      # 0x119eb
movl $0x41, %edx
callq 0x3160
leaq 0x8388(%rip), %rdi      # 0x11a22
leaq 0x82fc(%rip), %rsi      # 0x1199d
leaq 0x8343(%rip), %rcx      # 0x119eb
movl $0x42, %edx
callq 0x3160
leaq 0x8372(%rip), %rdi      # 0x11a2b
leaq 0x82dd(%rip), %rsi      # 0x1199d
leaq 0x8324(%rip), %rcx      # 0x119eb
movl $0x43, %edx
callq 0x3160
nop
// File: /workspace/github_cpp_makefile_star2_O1/ddu1[P]polarizedtext/src/vector.cc
// Function: fasttext::Vector::addRow(fasttext::Matrix const&, long, float)
void Vector::addRow(const Matrix& A, int64_t i, real a) {
  assert(i >= 0);
  assert(i < A.m_);
  assert(m_ == A.n_);
  for (int64_t j = 0; j < A.n_; j++) {
    data_[j] += a * A.data_[i * A.n_ + j];
  }
}

// Assembly:
pushq %rax
testq %rdx, %rdx
js 0x971a
cmpq %rdx, 0x8(%rsi)
jle 0x9739
movq 0x10(%rsi), %rax
cmpq %rax, (%rdi)
jne 0x9758
testq %rax, %rax
jle 0x9718
imulq %rax, %rdx
shlq $0x2, %rdx
addq (%rsi), %rdx
movq 0x8(%rdi), %rcx
xorl %esi, %esi
movss (%rdx,%rsi,4), %xmm1
mulss %xmm0, %xmm1
addss (%rcx,%rsi,4), %xmm1
movss %xmm1, (%rcx,%rsi,4)
incq %rsi
cmpq %rsi, %rax
jne 0x96fd
popq %rax
retq
leaq 0x7f27(%rip), %rdi      # 0x11648
leaq 0x8275(%rip), %rsi      # 0x1199d
leaq 0x8307(%rip), %rcx      # 0x11a36
movl $0x4a, %edx
callq 0x3160
leaq 0x82e2(%rip), %rdi      # 0x11a22
leaq 0x8256(%rip), %rsi      # 0x1199d
leaq 0x82e8(%rip), %rcx      # 0x11a36
movl $0x4b, %edx
callq 0x3160
leaq 0x82cc(%rip), %rdi      # 0x11a2b
leaq 0x8237(%rip), %rsi      # 0x1199d
leaq 0x82c9(%rip), %rcx      # 0x11a36
movl $0x4c, %edx
callq 0x3160
nop
// File: /workspace/github_cpp_makefile_star2_O1/ddu1[P]polarizedtext/src/vector.cc
// Function: fasttext::Vector::mul(fasttext::Matrix const&, fasttext::Vector const&)
void Vector::mul(const Matrix& A, const Vector& vec) {
  assert(A.m_ == m_);
  assert(A.n_ == vec.m_);
  for (int64_t i = 0; i < m_; i++) {
    data_[i] = 0.0;
    for (int64_t j = 0; j < A.n_; j++) {
      data_[i] += A.data_[i * A.n_ + j] * vec.data_[j];
    }
  }
}

// Assembly:
pushq %rax
movq (%rdi), %rax
cmpq %rax, 0x8(%rsi)
jne 0x985f
movq 0x10(%rsi), %rcx
cmpq (%rdx), %rcx
jne 0x987e
testq %rax, %rax
jle 0x985d
movq 0x8(%rdi), %rdi
movq (%rsi), %rsi
movq 0x8(%rdx), %rdx
leaq (,%rcx,4), %r8
xorl %r9d, %r9d
movl $0x0, (%rdi,%r9,4)
testq %rcx, %rcx
jle 0x9852
movss (%rdi,%r9,4), %xmm0
xorl %r10d, %r10d
movss (%rsi,%r10,4), %xmm1
mulss (%rdx,%r10,4), %xmm1
addss %xmm1, %xmm0
movss %xmm0, (%rdi,%r9,4)
incq %r10
cmpq %r10, %rcx
jne 0x9834
incq %r9
addq %r8, %rsi
cmpq %rax, %r9
jne 0x981e
popq %rax
retq
leaq 0x820d(%rip), %rdi      # 0x11a73
leaq 0x8130(%rip), %rsi      # 0x1199d
leaq 0x820a(%rip), %rcx      # 0x11a7e
movl $0x5a, %edx
callq 0x3160
leaq 0x8234(%rip), %rdi      # 0x11ab9
leaq 0x8111(%rip), %rsi      # 0x1199d
leaq 0x81eb(%rip), %rcx      # 0x11a7e
movl $0x5b, %edx
callq 0x3160
nop
// File: /workspace/github_cpp_makefile_star2_O1/ddu1[P]polarizedtext/src/model.cc
// Function: fasttext::Model::polarization(int, float)
real Model::polarization(int32_t w, real lr) {

  real score = 0.0;
  Vector vec = Vector(hsz_, hidden_labels_);
  score = wo_->dotRow( vec, w);
  score = sigmoid(score);
  real alpha = lr * (1.0 - score);
  grad_.addRow(*wo_, w, alpha);
  wo_->addRow(vec, w, alpha);
  return -log(score);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movss %xmm0, 0x10(%rsp)
movl %esi, %ebp
movq %rdi, %rbx
movslq 0x78(%rdi), %rsi
leaq 0x40(%rdi), %rdx
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0x952a
movq 0x10(%rbx), %rdi
movslq %ebp, %r14
movq %r15, %rsi
movq %r14, %rdx
callq 0x9398
xorps %xmm2, %xmm2
movss 0x7b91(%rip), %xmm1     # 0x11af4
ucomiss %xmm0, %xmm1
ja 0x9fad
ucomiss 0x7b8d(%rip), %xmm0     # 0x11afc
jbe 0x9f7b
movss 0x7b7f(%rip), %xmm2     # 0x11af8
jmp 0x9fad
addss 0x7b79(%rip), %xmm0     # 0x11afc
mulss 0x7b75(%rip), %xmm0     # 0x11b00
mulss 0x7b71(%rip), %xmm0     # 0x11b04
mulss 0x7b6d(%rip), %xmm0     # 0x11b08
cvttss2si %xmm0, %eax
movq 0x90(%rbx), %rcx
cltq
movss (%rcx,%rax,4), %xmm2
xorps %xmm0, %xmm0
cvtss2sd 0x10(%rsp), %xmm0
movss %xmm2, 0xc(%rsp)
xorps %xmm1, %xmm1
cvtss2sd %xmm2, %xmm1
movsd 0x7635(%rip), %xmm2     # 0x11600
subsd %xmm1, %xmm2
mulsd %xmm0, %xmm2
xorps %xmm0, %xmm0
cvtsd2ss %xmm2, %xmm0
leaq 0x68(%rbx), %rdi
movq 0x10(%rbx), %rsi
movq %r14, %rdx
movss %xmm0, 0x10(%rsp)
callq 0x96d2
movq 0x10(%rbx), %rdi
leaq 0x28(%rsp), %rsi
movq %r14, %rdx
movss 0x10(%rsp), %xmm0
callq 0x92f2
xorps %xmm1, %xmm1
movss 0xc(%rsp), %xmm0
ucomiss 0x7ae1(%rip), %xmm0     # 0x11af8
ja 0xa033
mulss 0x7adf(%rip), %xmm0     # 0x11b00
cvttss2si %xmm0, %eax
movq 0x98(%rbx), %rcx
cltq
movss (%rcx,%rax,4), %xmm1
xorps 0x78b6(%rip), %xmm1     # 0x118f0
movaps %xmm1, 0x10(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x95da
movaps 0x10(%rsp), %xmm0
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0xa05b
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x95da
movq %rbx, %rdi
callq 0x3450
// File: /workspace/github_cpp_makefile_star2_O1/ddu1[P]polarizedtext/src/model.cc
// Function: fasttext::Model::computeOutputSoftmax(fasttext::Vector&, fasttext::Vector&) const
void Model::computeOutputSoftmax(Vector& hidden, Vector& output) const {
  output.mul(*wo_, hidden);
  real max = output[0], z = 0.0;
  for (int32_t i = 0; i < osz_; i++) {
    max = std::max(output[i], max);
  }
  for (int32_t i = 0; i < osz_; i++) {
    output[i] = exp(output[i] - max);
    z += output[i];
  }
  for (int32_t i = 0; i < osz_; i++) {
    output[i] /= z;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %rdx
movq %rdi, %r14
movq 0x10(%rdi), %rsi
movq %rbx, %rdi
callq 0x97f0
movq %rbx, %rdi
xorl %esi, %esi
callq 0x98d6
movss (%rax), %xmm0
cmpl $0x0, 0x80(%r14)
jle 0xa28d
xorl %r15d, %r15d
movss %xmm0, 0x8(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x98d6
movss 0x8(%rsp), %xmm0
maxss (%rax), %xmm0
incq %r15
movslq 0x80(%r14), %rax
cmpq %rax, %r15
jl 0xa263
cmpl $0x0, 0x80(%r14)
jle 0xa30c
xorps %xmm1, %xmm1
xorl %r15d, %r15d
movss %xmm0, 0x8(%rsp)
movss %xmm1, 0x4(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x98d6
movss (%rax), %xmm0
subss 0x8(%rsp), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x3460
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0xc(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x98d6
movss 0xc(%rsp), %xmm0
movss %xmm0, (%rax)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x98d6
movss 0x4(%rsp), %xmm1
addss (%rax), %xmm1
incq %r15
movslq 0x80(%r14), %rax
cmpq %rax, %r15
jl 0xa2a3
jmp 0xa30f
xorps %xmm1, %xmm1
cmpl $0x0, 0x80(%r14)
jle 0xa34e
xorl %r15d, %r15d
movss %xmm1, 0x4(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x98d6
movss 0x4(%rsp), %xmm1
movss (%rax), %xmm0
divss %xmm1, %xmm0
movss %xmm0, (%rax)
incq %r15
movslq 0x80(%r14), %rax
cmpq %rax, %r15
jl 0xa322
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/ddu1[P]polarizedtext/src/model.cc
// Function: fasttext::Model::computeHidden(std::vector<int, std::allocator<int>> const&, fasttext::Vector&) const
void Model::computeHidden(const std::vector<int32_t>& input, Vector& hidden) const {
  assert(hidden.size() == hsz_);
  hidden.zero();
  for (auto it = input.cbegin(); it != input.cend(); ++it) {
    hidden.addRow(*wi_, *it);
  }
  hidden.mul(1.0 / input.size());
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rdx, %rdi
callq 0x95e8
movslq 0x78(%r15), %rcx
cmpq %rcx, %rax
jne 0xa500
movq %rbx, %rdi
callq 0x95c2
movq (%r14), %r12
movq 0x8(%r14), %rax
cmpq %rax, %r12
je 0xa4b5
movq (%r15), %rsi
movslq (%r12), %rdx
movq %rbx, %rdi
callq 0x9630
addq $0x4, %r12
jmp 0xa497
subq (%r14), %rax
sarq $0x2, %rax
movq %rax, %xmm0
punpckldq 0x7157(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x715f(%rip), %xmm0     # 0x11630
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movsd 0x711b(%rip), %xmm0     # 0x11600
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x960a
leaq 0x7621(%rip), %rdi      # 0x11b28
leaq 0x7630(%rip), %rsi      # 0x11b3e
leaq 0x7636(%rip), %rcx      # 0x11b4b
movl $0x7d, %edx
callq 0x3160
nop
// File: /workspace/github_cpp_makefile_star2_O1/ddu1[P]polarizedtext/src/model.cc
// Function: fasttext::Model::update(std::vector<int, std::allocator<int>> const&, int, float)
void Model::update(const std::vector<int32_t>& input, int32_t target, real lr) {
  assert(target >= 0);
  assert(target < osz_);
  if (input.size() == 0) return;
  computeHidden(input, hidden_);

  // update negative sampling for both ns and polar
  if (args_->loss == loss_name::ns || args_->loss == loss_name::polar) {
    loss_ += negativeSampling(target, lr);
  } else if (args_->loss == loss_name::hs) {
    loss_ += hierarchicalSoftmax(target, lr);
  } else {
    loss_ += softmax(target, lr);
  }
  nexamples_ += 1;

  if (args_->model == model_name::sup) {
    grad_.mul(1.0 / input.size());
  }
  for (auto it = input.cbegin(); it != input.cend(); ++it) {
    wi_->addRow(grad_, *it, 1.0);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
testl %edx, %edx
js 0xace3
movl %edx, %ebp
movq %rdi, %r14
cmpl %edx, 0x80(%rdi)
jle 0xad02
movq %rsi, %rbx
movq 0x8(%rsi), %rax
cmpq (%rsi), %rax
je 0xacd6
movss %xmm0, 0xc(%rsp)
leaq 0x30(%r14), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0xa46a
movq 0x20(%r14), %rax
movl 0x88(%rax), %eax
cmpl $0x1, %eax
je 0xac21
cmpl $0x4, %eax
movss 0xc(%rsp), %xmm0
je 0xac15
cmpl $0x2, %eax
jne 0xac33
movq %r14, %rdi
movl %ebp, %esi
callq 0xa070
jmp 0xac3d
movq %r14, %rdi
movl %ebp, %esi
movss 0xc(%rsp), %xmm0
callq 0xa16a
jmp 0xac3d
movq %r14, %rdi
movl %ebp, %esi
callq 0xa366
addss 0x84(%r14), %xmm0
movss %xmm0, 0x84(%r14)
incq 0x88(%r14)
movq 0x20(%r14), %rax
cmpl $0x3, 0x8c(%rax)
jne 0xaca8
movq 0x8(%rbx), %rax
subq (%rbx), %rax
sarq $0x2, %rax
movq %rax, %xmm0
punpckldq 0x69a5(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x69ad(%rip), %xmm0     # 0x11630
leaq 0x68(%r14), %rdi
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movsd 0x6965(%rip), %xmm0     # 0x11600
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
callq 0x960a
movq (%rbx), %r12
cmpq 0x8(%rbx), %r12
je 0xacd6
leaq 0x68(%r14), %r15
movq (%r14), %rdi
movslq (%r12), %rdx
movq %r15, %rsi
movss 0x6e31(%rip), %xmm0     # 0x11af8
callq 0x92f2
addq $0x4, %r12
cmpq 0x8(%rbx), %r12
jne 0xacb5
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x6f41(%rip), %rdi      # 0x11c2b
leaq 0x6e4d(%rip), %rsi      # 0x11b3e
leaq 0x6f3f(%rip), %rcx      # 0x11c37
movl $0xc4, %edx
callq 0x3160
leaq 0x6f78(%rip), %rdi      # 0x11c81
leaq 0x6e2e(%rip), %rsi      # 0x11b3e
leaq 0x6f20(%rip), %rcx      # 0x11c37
movl $0xc5, %edx
callq 0x3160
nop
// File: /workspace/github_cpp_makefile_star2_O1/ddu1[P]polarizedtext/src/model.cc
// Function: fasttext::Model::updatePolarization(int, float)
void Model::updatePolarization(int32_t w, real lr) {
  assert(w >= 0);
  assert(w < osz_);
  loss_ += polarization(w, lr);
  wi_->addRow(grad_, w, 1.0);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
testl %esi, %esi
js 0xad6f
movl %esi, %ebp
movq %rdi, %rbx
cmpl %esi, 0x80(%rdi)
jle 0xad8e
movq %rbx, %rdi
movl %ebp, %esi
callq 0x9f1c
addss 0x84(%rbx), %xmm0
movss %xmm0, 0x84(%rbx)
movq (%rbx), %rdi
addq $0x68, %rbx
movl %ebp, %edx
movss 0x6d97(%rip), %xmm0     # 0x11af8
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x92f2
leaq 0x6f19(%rip), %rdi      # 0x11c8f
leaq 0x6dc1(%rip), %rsi      # 0x11b3e
leaq 0x6f12(%rip), %rcx      # 0x11c96
movl $0xdd, %edx
callq 0x3160
leaq 0x6f39(%rip), %rdi      # 0x11cce
leaq 0x6da2(%rip), %rsi      # 0x11b3e
leaq 0x6ef3(%rip), %rcx      # 0x11c96
movl $0xde, %edx
callq 0x3160
nop
// File: /workspace/github_cpp_makefile_star2_O1/ddu1[P]polarizedtext/src/fasttext.cc
// Function: fasttext::FastText::getVector(fasttext::Vector&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void FastText::getVector(Vector& vec, const std::string& word) {
  const std::vector<int32_t>& ngrams = dict_->getNgrams(word);
  vec.zero();
  for (auto it = ngrams.begin(); it != ngrams.end(); ++it) {
    vec.addRow(*input_, *it);
  }
  if (ngrams.size() > 0) {
    vec.mul(1.0 / ngrams.size());
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %rsi
leaq 0x8(%rsp), %rdi
callq 0x5016
movq %rbx, %rdi
callq 0x95c2
movq 0x8(%rsp), %r15
movq 0x10(%rsp), %rax
cmpq %rax, %r15
je 0xc729
movq 0x20(%r14), %rsi
movslq (%r15), %rdx
movq %rbx, %rdi
callq 0x9630
addq $0x4, %r15
jmp 0xc70a
subq 0x8(%rsp), %rax
je 0xc76d
sarq $0x2, %rax
movq %rax, %xmm0
punpckldq 0x4edf(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x4ee7(%rip), %xmm0     # 0x11630
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movsd 0x4ea3(%rip), %xmm0     # 0x11600
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movq %rbx, %rdi
callq 0x960a
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xc784
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x3260
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0xc790
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xc7aa
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x3260
movq %rbx, %rdi
callq 0x3450
// File: /workspace/github_cpp_makefile_star2_O1/ddu1[P]polarizedtext/src/fasttext.cc
// Function: fasttext::FastText::saveModel()
void FastText::saveModel() {
  std::ofstream ofs(args_->output + ".bin", std::ofstream::binary);
  if (!ofs.is_open()) {
    std::cerr << "Model file cannot be opened for saving!" << std::endl;
    exit(EXIT_FAILURE);
  }
  args_->save(ofs);
  dict_->save(ofs);
  input_->save(ofs);
  output_->save(ofs);
  ofs.close();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x220, %rsp            # imm = 0x220
movq %rdi, %rbx
movq (%rdi), %rax
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq 0x40(%rax), %rsi
movq 0x48(%rax), %rdx
addq %rsi, %rdx
movq %rsp, %r14
movq %r14, %rdi
callq 0x7844
leaq 0x5376(%rip), %rsi      # 0x11e14
movq %r14, %rdi
callq 0x3490
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
movl $0x4, %edx
callq 0x34a0
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0xcace
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3260
leaq 0x90(%rsp), %rdi
callq 0x3060
testb %al, %al
je 0xcb63
movq (%rbx), %rdi
leaq 0x20(%rsp), %rsi
callq 0x4646
movq 0x10(%rbx), %rdi
leaq 0x20(%rsp), %rsi
callq 0x6254
movq 0x20(%rbx), %rdi
leaq 0x20(%rsp), %rsi
callq 0x9440
movq 0x30(%rbx), %rdi
leaq 0x20(%rsp), %rsi
callq 0x9440
leaq 0x20(%rsp), %rdi
callq 0x3350
movq 0xb48d(%rip), %rax      # 0x17fb8
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq 0x28(%rsp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, 0x20(%rsp,%rcx)
callq 0x31e0
leaq 0x118(%rsp), %rdi
callq 0x30b0
addq $0x220, %rsp            # imm = 0x220
popq %rbx
popq %r14
popq %r15
retq
movq 0xb486(%rip), %rdi      # 0x17ff0
leaq 0x52a8(%rip), %rsi      # 0x11e19
movl $0x27, %edx
callq 0x3290
movq 0xb46e(%rip), %rdi      # 0x17ff0
callq 0x3110
movl $0x1, %edi
callq 0x32b0
jmp 0xcb93
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0xcbbb
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3260
jmp 0xcbbb
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x3370
movq %rbx, %rdi
callq 0x3450
nop
// File: /workspace/github_cpp_makefile_star2_O1/ddu1[P]polarizedtext/src/fasttext.cc
// Function: fasttext::FastText::loadModel(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void FastText::loadModel(const std::string& filename) {
  std::ifstream ifs(filename, std::ifstream::binary);
  if (!ifs.is_open()) {
    std::cerr << "Model file cannot be opened for loading!" << std::endl;
    exit(EXIT_FAILURE);
  }
  loadModel(ifs);
  ifs.close();
}

// Assembly:
pushq %rbx
subq $0x210, %rsp            # imm = 0x210
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
movl $0x4, %edx
callq 0x33c0
leaq 0x80(%rsp), %rdi
callq 0x3060
testb %al, %al
je 0xcc19
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xcc5c
leaq 0x8(%rsp), %rdi
callq 0x3050
leaq 0x8(%rsp), %rdi
callq 0x3070
addq $0x210, %rsp            # imm = 0x210
popq %rbx
retq
movq 0xb3d0(%rip), %rdi      # 0x17ff0
leaq 0x521a(%rip), %rsi      # 0x11e41
movl $0x28, %edx
callq 0x3290
movq 0xb3b8(%rip), %rdi      # 0x17ff0
callq 0x3110
movl $0x1, %edi
callq 0x32b0
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3070
movq %rbx, %rdi
callq 0x3450
// File: /workspace/github_cpp_makefile_star2_O1/ddu1[P]polarizedtext/src/fasttext.cc
// Function: fasttext::FastText::pwv(fasttext::Model&, float, std::vector<int, std::allocator<int>> const&)
void FastText::pwv(Model& model, real lr,
                        const std::vector<int32_t>& line) {
  std::uniform_int_distribution<> uniform(1, args_->ws);
  for (int32_t w = 0; w < line.size(); w++) {
    int32_t boundary = uniform(model.rng);
    model.setHiddenLabels( dict_->getLabels(line[w]));
    model.updatePolarization(line[w], lr);
    const std::vector<int32_t>& ngrams = dict_->getNgrams(line[w]);
    for (int32_t c = -boundary; c <= boundary; c++) {
      if (c != 0 && w + c >= 0 && w + c < line.size()) {
        model.update(ngrams, line[w + c], lr);
      }
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movss %xmm0, 0x4(%rsp)
movq %rsi, 0x8(%rsp)
movq (%rdi), %rax
movl 0x70(%rax), %eax
movl $0x1, 0x10(%rsp)
movl %eax, 0x14(%rsp)
movq 0x8(%rdx), %rax
cmpq (%rdx), %rax
je 0xd447
movq %rdx, %rbx
movq %rdi, %r14
movq 0x8(%rsp), %rax
addq $0x108, %rax            # imm = 0x108
movq %rax, 0x20(%rsp)
xorl %ebp, %ebp
movq %rdi, 0x18(%rsp)
leaq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq %rdi, %rdx
callq 0xf620
movl %eax, %r12d
movq 0x10(%r14), %rsi
movq (%rbx), %rax
movl (%rax,%rbp,4), %edx
leaq 0x30(%rsp), %r15
movq %r15, %rdi
callq 0x4dc4
movq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0xb2ce
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0xd3a9
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x3260
movq (%rbx), %rax
movl (%rax,%rbp,4), %esi
movq 0x8(%rsp), %rdi
movss 0x4(%rsp), %xmm0
callq 0xad22
movq 0x10(%r14), %rdi
movq (%rbx), %rax
movl (%rax,%rbp,4), %esi
callq 0x4fba
movq %rax, 0x28(%rsp)
testl %r12d, %r12d
js 0xd42b
leal 0x1(,%r12,2), %r15d
movl %ebp, %r14d
subl %r12d, %r14d
xorl %r13d, %r13d
cmpl %r13d, %r12d
je 0xd423
movl %r14d, %eax
addl %r13d, %eax
js 0xd423
movl %eax, %eax
movq (%rbx), %rcx
movq 0x8(%rbx), %rdx
subq %rcx, %rdx
sarq $0x2, %rdx
cmpq %rax, %rdx
jbe 0xd423
movl (%rcx,%rax,4), %edx
movq 0x8(%rsp), %rdi
movq 0x28(%rsp), %rsi
movss 0x4(%rsp), %xmm0
callq 0xabac
incl %r13d
cmpl %r13d, %r15d
jne 0xd3e9
incq %rbp
movq 0x8(%rbx), %rax
subq (%rbx), %rax
sarq $0x2, %rax
cmpq %rbp, %rax
movq 0x18(%rsp), %r14
ja 0xd359
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0xd470
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x3260
movq %rbx, %rdi
callq 0x3450
// File: /workspace/github_cpp_makefile_star2_O1/ddu1[P]polarizedtext/src/fasttext.cc
// Function: fasttext::FastText::textVectors()
void FastText::textVectors() {
  std::vector<int32_t> line, labels;
  Vector vec(args_->dim);
  while (std::cin.peek() != EOF) {
    dict_->getLine(std::cin, line, labels, model_->rng);
    dict_->addNgrams(line, args_->wordNgrams);
    vec.zero();
    for (auto it = line.cbegin(); it != line.cend(); ++it) {
      vec.addRow(*input_, *it);
    }
    if (!line.empty()) {
      vec.mul(1.0 / line.size());
    }
    std::cout << vec << std::endl;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
xorl %eax, %eax
movq %rax, 0x10(%rsp)
movq %rax, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
movq (%rdi), %rax
movslq 0x6c(%rax), %rsi
leaq 0x38(%rsp), %rdi
callq 0x9500
movq 0xa177(%rip), %r14      # 0x17fd8
movq %rsp, %r15
leaq 0x38(%rsp), %r13
movq 0xa158(%rip), %rbp      # 0x17fc8
movq %r14, %rdi
callq 0x30d0
cmpl $-0x1, %eax
je 0xdf65
movq 0x10(%rbx), %rdi
movq 0x40(%rbx), %r8
movl $0x108, %eax            # imm = 0x108
addq %rax, %r8
movq %r14, %rsi
movq %r15, %rdx
leaq 0x20(%rsp), %rcx
callq 0x5fc2
movq (%rbx), %rax
movq 0x10(%rbx), %rdi
movl 0x84(%rax), %edx
movq %r15, %rsi
callq 0x5eb8
movq %r13, %rdi
callq 0x95c2
movq (%rsp), %r12
movq 0x8(%rsp), %rax
cmpq %rax, %r12
je 0xdee2
movq 0x20(%rbx), %rsi
movslq (%r12), %rdx
movq %r13, %rdi
callq 0x9630
addq $0x4, %r12
jmp 0xdec2
movq (%rsp), %rcx
cmpq %rax, %rcx
je 0xdf2b
subq %rcx, %rax
sarq $0x2, %rax
movq %rax, %xmm0
punpckldq 0x3721(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x3729(%rip), %xmm0     # 0x11630
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movsd 0x36e5(%rip), %xmm0     # 0x11600
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movq %r13, %rdi
callq 0x960a
movq %rbp, %rdi
movq %r13, %rsi
callq 0x98f1
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x3230
movsbl %al, %esi
movq %r12, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3180
jmp 0xde70
leaq 0x38(%rsp), %rdi
callq 0x95da
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0xdf86
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x3260
movq (%rsp), %rdi
testq %rdi, %rdi
je 0xdf9c
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x3260
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0xdfbf
jmp 0xdfb2
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x95da
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0xdfd6
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x3260
movq (%rsp), %rdi
testq %rdi, %rdi
je 0xdfec
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x3260
movq %rbx, %rdi
callq 0x3450
// File: /workspace/github_cpp_makefile_star2_O1/ddu1[P]polarizedtext/src/main.cc
// Function: printVectors(int, char**)
void printVectors(int argc, char** argv) {
  if (argc != 3) {
    printPrintVectorsUsage();
    exit(EXIT_FAILURE);
  }
  FastText fasttext;
  fasttext.loadModel(std::string(argv[2]));
  fasttext.printVectors();
  exit(0);
}

// Assembly:
pushq %rbx
subq $0x90, %rsp
cmpl $0x3, %edi
jne 0x10808
xorps %xmm0, %xmm0
movaps %xmm0, 0x70(%rsp)
movaps %xmm0, 0x60(%rsp)
movaps %xmm0, 0x50(%rsp)
movaps %xmm0, 0x40(%rsp)
movaps %xmm0, 0x30(%rsp)
movq 0x10(%rsi), %rsi
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x485a
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xcbc4
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x107f7
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3260
leaq 0x30(%rsp), %rdi
callq 0xdff4
xorl %edi, %edi
callq 0x32b0
callq 0x102d4
movl $0x1, %edi
callq 0x32b0
jmp 0x10839
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1083c
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3260
jmp 0x1083c
movq %rax, %rbx
movq 0x78(%rsp), %rdi
testq %rdi, %rdi
je 0x1084b
callq 0x77d4
movq 0x68(%rsp), %rdi
testq %rdi, %rdi
je 0x1085a
callq 0x77d4
movq 0x58(%rsp), %rdi
testq %rdi, %rdi
je 0x10869
callq 0x77d4
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
je 0x10878
callq 0x77d4
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x10887
callq 0x77d4
movq %rbx, %rdi
callq 0x3450
// File: /workspace/github_cpp_makefile_star2_O1/ddu1[P]polarizedtext/src/main.cc
// Function: main
int main(int argc, char** argv) {
  if (argc < 2) {
    printUsage();
    exit(EXIT_FAILURE);
  }
  std::string command(argv[1]);
  if (command == "skipgram" || command == "cbow" || command == "supervised" || command == "pwv") {
    train(argc, argv);
  } else if (command == "test") {
    test(argc, argv);
  } else if (command == "print-vectors") {
    printVectors(argc, argv);
  } else if (command == "predict" || command == "predict-prob" ) {
    predict(argc, argv);
  } else {
    printUsage();
    exit(EXIT_FAILURE);
  }
  return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
cmpl $0x1, %edi
jle 0x10a7c
movq %rsi, %rbx
movl %edi, %ebp
movq 0x8(%rsi), %rsi
leaq 0x10(%rsp), %r14
leaq 0xf(%rsp), %rdx
movq %r14, %rdi
callq 0x485a
leaq 0x1a78(%rip), %rsi      # 0x12479
movq %r14, %rdi
callq 0x3090
testl %eax, %eax
je 0x10a4c
leaq 0x645(%rip), %rsi       # 0x11059
leaq 0x10(%rsp), %rdi
callq 0x3090
testl %eax, %eax
je 0x10a4c
leaq 0x621(%rip), %rsi       # 0x1104a
leaq 0x10(%rsp), %rdi
callq 0x3090
testl %eax, %eax
je 0x10a4c
leaq 0x617(%rip), %rsi       # 0x11055
leaq 0x10(%rsp), %rdi
callq 0x3090
testl %eax, %eax
jne 0x10a8b
movl %ebp, %edi
movq %rbx, %rsi
callq 0x1088f
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x10a71
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3260
xorl %eax, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
callq 0x100f0
movl $0x1, %edi
callq 0x32b0
leaq 0x619(%rip), %rsi       # 0x110ab
leaq 0x10(%rsp), %rdi
callq 0x3090
testl %eax, %eax
jne 0x10aaa
movl %ebp, %edi
movq %rbx, %rsi
callq 0x1032c
leaq 0x19d1(%rip), %rsi      # 0x12482
leaq 0x10(%rsp), %rdi
callq 0x3090
testl %eax, %eax
jne 0x10ac9
movl %ebp, %edi
movq %rbx, %rsi
callq 0x10791
leaq 0x19c0(%rip), %rsi      # 0x12490
leaq 0x10(%rsp), %rdi
callq 0x3090
testl %eax, %eax
je 0x10af3
leaq 0x1987(%rip), %rsi      # 0x1246c
leaq 0x10(%rsp), %rdi
callq 0x3090
testl %eax, %eax
jne 0x10afd
movl %ebp, %edi
movq %rbx, %rsi
callq 0x10535
callq 0x100f0
jmp 0x10a81
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x10b25
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3260
movq %rbx, %rdi
callq 0x3450
nop
// File: /workspace/github_cpp_makefile_star2_O1/iZhangHui[P]CppPrimer/CH18_ToolsForLargePrograms/examples/Animal.cc
// Function: main
int main() {
	Panda ying_yang("ying_yang");
	
	print(ying_yang);     // passes Panda to a reference to Bear
	highlight(ying_yang); // passes Panda to a reference to Endangered
	cout << ying_yang << endl; // passes Panda to a reference to ZooAnimal
	Panda ling_ling = ying_yang;    // uses the copy constructor 

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0xe0, %rsp
leaq -0x20(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0xd12(%rip), %rsi       # 0x304e
leaq 0xd14(%rip), %rdx       # 0x3057
leaq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x2e42
leaq -0x90(%rbp), %rdi
movq %rbx, %rsi
movl $0x1, %edx
callq 0x25a4
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x2378
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x20b0
callq 0x223c
callq 0x228a
movq 0x2c4f(%rip), %rdi      # 0x4fd8
callq 0x22d8
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x20a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2060
leaq 0x2999(%rip), %rax      # 0x4d58
leaq -0xe8(%rbp), %rdi
movq %rax, -0x8(%rdi)
leaq -0xd8(%rbp), %r14
movq %r14, -0x10(%r14)
movq -0x88(%rbp), %rsi
movq -0x80(%rbp), %rdx
addq %rsi, %rdx
callq 0x2a46
movb -0x68(%rbp), %al
leaq -0xc0(%rbp), %rdi
movb %al, -0x8(%rdi)
leaq -0xb0(%rbp), %rax
movq %rax, -0x10(%rax)
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdx
addq %rsi, %rdx
callq 0x2a46
leaq -0x90(%rbp), %rbx
movl 0x50(%rbx), %eax
leaq -0xf0(%rbp), %rdi
movl %eax, 0x50(%rdi)
leaq 0x27f5(%rip), %rax      # 0x4c20
movq %rax, (%rdi)
leaq 0x283b(%rip), %rax      # 0x4c70
movq %rax, 0x58(%rdi)
callq 0x2692
movq %rbx, %rdi
callq 0x2692
xorl %eax, %eax
addq $0xe0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq -0xe8(%rbp), %rdi
cmpq %r14, %rdi
je 0x2493
movq -0xd8(%rbp), %rsi
incq %rsi
callq 0x20b0
jmp 0x2493
jmp 0x2490
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x249f
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x20b0
jmp 0x249f
movq %rax, %rbx
leaq -0x90(%rbp), %rdi
callq 0x2692
movq %rbx, %rdi
callq 0x20e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/SYZYGYfpga[P]brain-tools/src/smartvio-brain.cpp
// Function: dumpDNA(int, unsigned short, unsigned char*)
int dumpDNA (int i2c_file, uint16_t port_addr, uint8_t *data)
{
	uint16_t dna_length;

	if (i2cRead(i2c_file, port_addr, 0x8000, 2, 2, (uint8_t *)&dna_length) != 0) {
		return -1;
	}

	if (dna_length > 1318) {
		printf("Invalid DNA Length\n");
		exit(EXIT_FAILURE);
	}

	if (readMCU(i2c_file, port_addr, 0x8000, data, dna_length) != 0) {
		return -1;
	}

	return dna_length;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %r14d
movl %edi, %ebp
leaq 0x6(%rsp), %r9
movl $0x8000, %edx           # imm = 0x8000
movl $0x2, %ecx
movl $0x2, %r8d
callq 0x360b
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %ecx, %ecx
jne 0x37f1
movzwl 0x6(%rsp), %r15d
cmpl $0x527, %r15d           # imm = 0x527
jae 0x37fc
movzwl %r14w, %esi
movl %ebp, %edi
movl $0x8000, %edx           # imm = 0x8000
movq %rbx, %rcx
movl %r15d, %r8d
callq 0x3715
movl %eax, %ecx
xorl %eax, %eax
negl %ecx
sbbl %eax, %eax
orl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x67a4(%rip), %rdi      # 0x9fa7
callq 0x3310
movl $0x1, %edi
callq 0x3280
// File: /workspace/github_cpp_makefile_star2_O1/SYZYGYfpga[P]brain-tools/src/smartvio-brain.cpp
// Function: readDNA(int, unsigned int*, unsigned int*)
int readDNA (int i2c_file, uint32_t *svio1, uint32_t *svio2)
{
	uint8_t i;
	int vmin;
	uint8_t dna_buf[64];

	for (i = 0; i < SVIO_NUM_PORTS; i++) {
		// Skip ports referring to the FPGA
		if (0x00 == svio.ports[i].i2c_addr) {
			continue;
		}

		if (i2cDetect(i2c_file, svio.ports[i].i2c_addr) != 0) {
			// Device is not present
			continue;
		}

		// Read the full DNA Header
		if (readMCU(i2c_file, svio.ports[i].i2c_addr, 0x8000, dna_buf,
		            SZG_DNA_HEADER_LENGTH_V1) != 0) {
			return -1;
		}

		if (szgParsePortDNA(i, &svio, dna_buf, SZG_DNA_HEADER_LENGTH_V1) != 0) {
			return -1;
		}

		if (svio.ports[i].attr & SZG_ATTR_LVDS) {
			switch (svio.ports[i].group) {
				case 0:
					svio.ports[0].ranges[0].min = 250;
					svio.ports[0].ranges[0].max = 250;
					break;
				case 1:
					svio.ports[2].ranges[0].min = 250;
					svio.ports[2].ranges[0].max = 250;
					break;
			}
		}
	}

	// Find a solution
	for (i = 0; i < SVIO_NUM_GROUPS; i++) {
		vmin = szgSolveSmartVIOGroup(svio.ports, svio.group_masks[i]);
		if (vmin > 0) {
			svio.svio_results[i] = vmin;
		}
	}

	*svio1 = svio.svio_results[0];
	*svio2 = svio.svio_results[1];

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, 0x8(%rsp)
movq %rsi, (%rsp)
movl %edi, %ebp
leaq 0xa9ee(%rip), %r14      # 0xe220
xorl %r12d, %r12d
leaq 0x10(%rsp), %r13
leaq 0xa9c7(%rip), %r15      # 0xe208
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl (%r14), %esi
testl %esi, %esi
je 0x38d1
movl %ebp, %edi
callq 0x350c
testl %eax, %eax
jne 0x38d1
movzwl (%r14), %esi
movl %ebp, %edi
movl $0x8000, %edx           # imm = 0x8000
movq %r13, %rcx
movl $0x28, %r8d
callq 0x3715
testl %eax, %eax
jne 0x3925
movl %r12d, %edi
movq %r15, %rsi
movq %r13, %rdx
movl $0x28, %ecx
callq 0x7f34
testl %eax, %eax
jne 0x3925
testb $0x1, 0x14(%r14)
je 0x38d1
movl 0x8(%r14), %edx
leaq 0xa99a(%rip), %rax      # 0xe244
leaq 0xa997(%rip), %rcx      # 0xe248
testl %edx, %edx
je 0x38c8
cmpl $0x1, %edx
jne 0x38d1
leaq 0xaa5b(%rip), %rax      # 0xe31c
leaq 0xaa58(%rip), %rcx      # 0xe320
movl $0xfa, %edx
movl %edx, (%rax)
movl %edx, (%rcx)
incq %r12
addq $0x6c, %r14
cmpq $0x6, %r12
jne 0x3846
xorl %ebx, %ebx
leaq 0xa935(%rip), %r12      # 0xe220
movl 0x10(%r15,%rbx,4), %esi
movq %r12, %rdi
callq 0x805f
testl %eax, %eax
jle 0x3901
movl %eax, 0x8(%r15,%rbx,4)
incq %rbx
cmpq $0x1, %rbx
je 0x38eb
movl 0xa900(%rip), %eax      # 0xe210
movq (%rsp), %rcx
movl %eax, (%rcx)
movl 0xa8f8(%rip), %eax      # 0xe214
movq 0x8(%rsp), %rcx
movl %eax, (%rcx)
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/SYZYGYfpga[P]brain-tools/src/smartvio-brain.cpp
// Function: applyVIO(int, unsigned int, unsigned int)
int applyVIO (int i2c_file, uint32_t svio1, uint32_t svio2)
{
	uint8_t temp_data[2];
	
	// Bounds check to be sure that everything is good to go
	if ((svio1 != 0) && ((svio1 < 120) || (svio1 > 330))) {
		printf("Invalid SmartVIO solution\n");
		exit(EXIT_FAILURE);
	}
	if ((svio2 != 0) && ((svio2 < 120) || (svio2 > 330))) {
		printf("Invalid SmartVIO solution\n");
		exit(EXIT_FAILURE);
	}

	// Disable write protect on TPS65400
	temp_data[0] = 0x20;
	if (i2cWrite(i2c_file, 0x6a, 0x10, 1, 1, temp_data) != 0) {
		return -1;
	}

	// TPS65400 VREF = VOUT * 531 - 60
	if (svio1 != 0) {
		printf("Setting VIO1 to: %d\n", svio1);
		temp_data[0] = 0x0;
		if (i2cWrite(i2c_file, 0x6a, 0x00, 1, 1, temp_data) != 0) {
			return -1;
		}
		temp_data[0] = svio1 * 531 / 1000 - 60;
		if (i2cWrite(i2c_file, 0x6a, 0xd8, 1, 1, temp_data) != 0) {
			return -1;
		}
	}
	if (svio2 != 0) {
		printf("Setting VIO2 to: %d\n", svio2);
		temp_data[0] = 0x1;
		if (i2cWrite(i2c_file, 0x6a, 0x00, 1, 1, temp_data) != 0) {
			return -1;
		}
		temp_data[0] = svio2 * 531 / 1000 - 60;
		if (i2cWrite(i2c_file, 0x6a, 0xd8, 1, 1, temp_data) != 0) {
			return -1;
		}
	}

	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r15d
testl %esi, %esi
sete %al
leal -0x14b(%r15), %ecx
cmpl $0xffffff2d, %ecx       # imm = 0xFFFFFF2D
setae %cl
orb %al, %cl
je 0x3abb
movl %edx, %r14d
testl %edx, %edx
sete %al
leal -0x14b(%r14), %ecx
cmpl $0xffffff2d, %ecx       # imm = 0xFFFFFF2D
setae %cl
orb %al, %cl
je 0x3abb
movl %edi, %ebx
leaq 0x6(%rsp), %r9
movb $0x20, (%r9)
movl $0x6a, %esi
movl $0x10, %edx
movl $0x1, %ecx
movl $0x1, %r8d
callq 0x3554
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testl %eax, %eax
je 0x39b8
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
testl %r15d, %r15d
je 0x3a34
leaq 0x56dc(%rip), %rdi      # 0x90a0
movl %r15d, %esi
xorl %eax, %eax
callq 0x3040
leaq 0x6(%rsp), %r9
movb $0x0, (%r9)
movl %ebx, %edi
movl $0x6a, %esi
xorl %edx, %edx
movl $0x1, %ecx
movl $0x1, %r8d
callq 0x3554
testl %eax, %eax
jne 0x39ab
imull $0x213, %r15d, %eax     # imm = 0x213
imulq $0x10624dd3, %rax, %rax # imm = 0x10624DD3
shrq $0x26, %rax
addb $-0x3c, %al
leaq 0x6(%rsp), %r9
movb %al, (%r9)
movl %ebx, %edi
movl $0x6a, %esi
movl $0xd8, %edx
movl $0x1, %ecx
movl $0x1, %r8d
callq 0x3554
testl %eax, %eax
jne 0x39ab
testl %r14d, %r14d
je 0x3ab4
leaq 0x5675(%rip), %rdi      # 0x90b5
movl %r14d, %esi
xorl %eax, %eax
callq 0x3040
leaq 0x6(%rsp), %r9
movb $0x1, (%r9)
movl %ebx, %edi
movl $0x6a, %esi
xorl %edx, %edx
movl $0x1, %ecx
movl $0x1, %r8d
callq 0x3554
testl %eax, %eax
jne 0x39ab
imull $0x213, %r14d, %eax     # imm = 0x213
imulq $0x10624dd3, %rax, %rax # imm = 0x10624DD3
shrq $0x26, %rax
addb $-0x3c, %al
leaq 0x6(%rsp), %r9
movb %al, (%r9)
movl %ebx, %edi
movl $0x6a, %esi
movl $0xd8, %edx
movl $0x1, %ecx
movl $0x1, %r8d
callq 0x3554
testl %eax, %eax
jne 0x39ab
xorl %ebp, %ebp
jmp 0x39ab
leaq 0x604c(%rip), %rdi      # 0x9b0e
callq 0x3310
movl $0x1, %edi
callq 0x3280
// File: /workspace/github_cpp_makefile_star2_O1/SYZYGYfpga[P]brain-tools/include/json.hpp
// Function: void nlohmann::detail::serializer<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>>::dump_integer<long, 0>(long)
void dump_integer(NumberType x)
    {
        // special case for "0"
        if (x == 0)
        {
            o->write_character('0');
            return;
        }

        const bool is_negative = (x <= 0) and (x != 0);  // see issue #755
        std::size_t i = 0;

        while (x != 0)
        {
            // spare 1 byte for '\0'
            assert(i < number_buffer.size() - 1);

            const auto digit = std::labs(static_cast<long>(x % 10));
            number_buffer[i++] = static_cast<char>('0' + digit);
            x /= 10;
        }

        if (is_negative)
        {
            // make sure there is capacity for the '-'
            assert(i < number_buffer.size() - 2);
            number_buffer[i++] = '-';
        }

        std::reverse(number_buffer.begin(), number_buffer.begin() + i);
        o->write_characters(number_buffer.data(), i);
    }

// Assembly:
pushq %rax
testq %rsi, %rsi
je 0x5cc0
xorl %ecx, %ecx
movabsq $0x6666666666666667, %r9 # imm = 0x6666666666666667
movq %rsi, %r8
cmpq $0x3f, %rcx
je 0x5cd1
movq %r8, %rax
imulq %r9
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x2, %rdx
addq %rax, %rdx
leaq (%rdx,%rdx), %rax
leaq (%rax,%rax,4), %rax
movq %r8, %r10
subq %rax, %r10
movq %r10, %rax
negq %rax
cmovsq %r10, %rax
addb $0x30, %al
movb %al, 0x10(%rdi,%rcx)
incq %rcx
addq $0x9, %r8
cmpq $0x12, %r8
movq %rdx, %r8
ja 0x5c1b
testq %rsi, %rsi
jg 0x5c7e
leaq -0x1(%rcx), %rax
cmpq $0x3d, %rax
jae 0x5cf0
movb $0x2d, 0x10(%rdi,%rcx)
incq %rcx
leaq 0x10(%rdi), %rsi
leaq (%rdi,%rcx), %rax
addq $0xf, %rax
cmpq %rsi, %rax
jbe 0x5cb0
leaq 0x11(%rdi), %rdx
movb -0x1(%rdx), %r8b
movb (%rax), %r9b
movb %r9b, -0x1(%rdx)
movb %r8b, (%rax)
decq %rax
leaq 0x1(%rdx), %r8
cmpq %rax, %rdx
movq %r8, %rdx
jb 0x5c93
movq (%rdi), %rdi
movq (%rdi), %rax
movq 0x8(%rax), %rax
movq %rcx, %rdx
popq %rcx
jmpq *%rax
movq (%rdi), %rdi
movq (%rdi), %rax
movq (%rax), %rax
movl $0x30, %esi
popq %rcx
jmpq *%rax
leaq 0x39aa(%rip), %rdi      # 0x9682
leaq 0x35a3(%rip), %rsi      # 0x9282
leaq 0x39b9(%rip), %rcx      # 0x969f
movl $0x19fd, %edx           # imm = 0x19FD
callq 0x3150
leaq 0x3a38(%rip), %rdi      # 0x972f
leaq 0x3584(%rip), %rsi      # 0x9282
leaq 0x399a(%rip), %rcx      # 0x969f
movl $0x1a07, %edx           # imm = 0x1A07
callq 0x3150
nop