LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/NinjaDevelper[P]ReedSolomon/cxx/ReedSolomon.cpp
// Function: ReedSolomon::evaluatePoly(POLY&, unsigned char)
unsigned char ReedSolomon::evaluatePoly(POLY& x,unsigned char y){
    int i=0;
    unsigned char r=x.data[0];
    for(i=1;i<x.n;i++){
        r=multiply(r,y) ^ x.data[i];
    }
    return r;
}

// Assembly:
movq (%rsi), %rcx
movb (%rcx), %r10b
movslq 0x8(%rsi), %rsi
cmpq $0x2, %rsi
jl 0x24f5
movzbl %dl, %r8d
movl $0x1, %r9d
xorl %eax, %eax
testb %dl, %dl
je 0x24e5
testb %r10b, %r10b
je 0x24e5
movzbl %r10b, %eax
movzbl 0x200(%rdi,%rax), %eax
movzbl 0x200(%rdi,%r8), %r10d
addq %rax, %r10
movb (%rdi,%r10), %al
xorb (%rcx,%r9), %al
incq %r9
movl %eax, %r10d
cmpq %r9, %rsi
jne 0x24be
retq
movl %r10d, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/NinjaDevelper[P]ReedSolomon/cxx/ReedSolomon.cpp
// Function: ReedSolomon::encodeMessage(POLY&, POLY&)
unsigned char* ReedSolomon::encodeMessage(POLY& msgIn,POLY& generator){
    int i=0;
    int j=0;
    unsigned char coef=0;

    for(i=0;i<msgIn.n;i++){
        coef=msgIn.data[i];
        if(coef!=0){
            for(j=0;j<generator.n;j++){
                msgIn.data[i+j] ^= multiply(generator.data[j], coef);
            }
        }
    }
    return msgIn.data+msgIn.n;
}

// Assembly:
movslq 0x8(%rsi), %rax
testq %rax, %rax
jle 0x2602
movl 0x8(%rdx), %r8d
xorl %ecx, %ecx
movl %eax, %r9d
movq (%rsi), %rax
movzbl (%rax,%rcx), %eax
testq %rax, %rax
je 0x25f7
testl %r8d, %r8d
jle 0x25f7
xorl %r9d, %r9d
movq (%rdx), %r8
movzbl (%r8,%r9), %r8d
testq %r8, %r8
je 0x25da
movzbl 0x200(%rdi,%r8), %r8d
movzbl 0x200(%rdi,%rax), %r10d
addq %r8, %r10
movb (%rdi,%r10), %r8b
jmp 0x25dd
xorl %r8d, %r8d
movq (%rsi), %r10
addq %rcx, %r10
xorb %r8b, (%r9,%r10)
incq %r9
movslq 0x8(%rdx), %r8
cmpq %r8, %r9
jl 0x25b2
movl 0x8(%rsi), %r9d
incq %rcx
movslq %r9d, %rax
cmpq %rax, %rcx
jl 0x259e
addq (%rsi), %rax
retq
// File: /workspace/github_cpp_makefile_star2_O3/NinjaDevelper[P]ReedSolomon/cxx/ReedSolomon.cpp
// Function: ReedSolomon::calcSyndrome(POLY&, POLY&)
POLY& ReedSolomon::calcSyndrome(POLY& msg, POLY& result){
    int i=0;
    for(i=0;i<result.n;i++){
        result.data[i] = evaluatePoly(msg, expTable[i]);
    }
    return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
cmpl $0x0, 0x8(%rdx)
jle 0x2643
movq %rsi, %r14
movq %rdi, %r15
xorl %r12d, %r12d
movzbl (%r15,%r12), %edx
movq %r15, %rdi
movq %r14, %rsi
callq 0x24a4
movq (%rbx), %rcx
movb %al, (%rcx,%r12)
incq %r12
movslq 0x8(%rbx), %rax
cmpq %rax, %r12
jl 0x2620
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/epfml[P]sent2vec/src/args.cc
// Function: fasttext::Args::Args()
Args::Args() {
  lr = 0.05;
  boostNgrams = 1.0;
  dim = 100;
  ws = 5;
  dropoutK = 0;
  epoch = 5;
  minCount = 5;
  minCountLabel = 0;
  neg = 5;
  wordNgrams = 1;
  loss = loss_name::ns;
  model = model_name::sg;
  bucket = 2000000;
  bucketChar = 1;
  minn = 3;
  maxn = 6;
  thread = 12;
  lrUpdateRate = 100;
  t = 1e-4;
  label = "__label__";
  verbose = 2;
  pretrainedVectors = "";
  saveOutput = 0;
  maxVocabSize = -1;
  numCheckPoints = 1;
  qout = false;
  retrain = false;
  qnorm = false;
  cutoff = 0;
  dsub = 2;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, 0x18(%rsp)
movq %rax, (%rdi)
xorl %eax, %eax
movq %rax, 0x8(%rdi)
movb %al, 0x10(%rdi)
leaq 0x30(%rdi), %rcx
movq %rcx, 0x10(%rsp)
movq %rcx, 0x20(%rdi)
movq %rax, 0x28(%rdi)
movb %al, 0x30(%rdi)
leaq 0x50(%rdi), %rcx
movq %rcx, 0x8(%rsp)
movq %rcx, 0x40(%rdi)
movq %rax, 0x48(%rdi)
movb %al, 0x50(%rdi)
leaq 0x70(%rdi), %r13
movq %r13, 0x60(%rdi)
movq %rax, 0x68(%rdi)
movb %al, 0x70(%rdi)
leaq 0xe0(%rdi), %r15
leaq 0xf0(%rdi), %rbp
movq %rbp, 0xe0(%rdi)
movq %rax, 0xe8(%rdi)
movb %al, 0xf0(%rdi)
leaq 0x108(%rdi), %r12
leaq 0x118(%rdi), %r14
movq %r14, 0x108(%rdi)
movq %rax, 0x110(%rdi)
movb %al, 0x118(%rdi)
movaps 0x192ec(%rip), %xmm0    # 0x1e010
movups %xmm0, 0x80(%rdi)
movl $0x5, 0xa0(%rdi)
movaps 0x192e4(%rip), %xmm0    # 0x1e020
movups %xmm0, 0xa8(%rdi)
movaps 0x192e6(%rip), %xmm0    # 0x1e030
movups %xmm0, 0xbc(%rdi)
movabsq $0x600000003, %rax      # imm = 0x600000003
movq %rax, 0xcc(%rdi)
movl $0xc, 0xd4(%rdi)
movaps 0x192cd(%rip), %xmm0    # 0x1e040
movups %xmm0, 0x90(%rdi)
movabsq $0x3f1a36e2eb1c432d, %rax # imm = 0x3F1A36E2EB1C432D
movq %rax, 0xd8(%rdi)
leaq 0x192be(%rip), %rcx     # 0x1e050
movl $0x9, %r8d
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x44b0
movl $0x2, 0x100(%rbx)
movq 0x110(%rbx), %rdx
leaq 0x1ad1d(%rip), %rcx     # 0x1fad9
movq %r12, %rdi
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x44b0
movl $0x0, 0x128(%rbx)
movl $0xffffffff, 0xa4(%rbx) # imm = 0xFFFFFFFF
movl $0x1, 0xb8(%rbx)
movw $0x0, 0x12c(%rbx)
movb $0x0, 0x12e(%rbx)
movq $0x0, 0x130(%rbx)
movq $0x2, 0x138(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, 0x20(%rsp)
movq (%r12), %rdi
cmpq %r14, %rdi
je 0x4e35
movq (%r14), %rsi
incq %rsi
callq 0x4300
movq (%r15), %rdi
cmpq %rbp, %rdi
je 0x4e49
movq (%rbp), %rsi
incq %rsi
callq 0x4300
movq 0x60(%rbx), %rdi
cmpq %r13, %rdi
je 0x4e5e
movq (%r13), %rsi
incq %rsi
callq 0x4300
movq 0x40(%rbx), %rdi
cmpq 0x8(%rsp), %rdi
je 0x4e79
movq 0x8(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x4300
movq 0x20(%rbx), %rdi
cmpq 0x10(%rsp), %rdi
je 0x4e94
movq 0x10(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x4300
movq (%rbx), %rdi
cmpq 0x18(%rsp), %rdi
je 0x4eae
movq 0x18(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x4300
movq 0x20(%rsp), %rdi
callq 0x45b0
// File: /workspace/github_cpp_makefile_star2_O3/epfml[P]sent2vec/src/args.cc
// Function: fasttext::Args::save(std::ostream&)
void Args::save(std::ostream& out) {
  out.write((char*) &(dim), sizeof(int));
  out.write((char*) &(ws), sizeof(int));
  out.write((char*) &(epoch), sizeof(int));
  out.write((char*) &(minCount), sizeof(int));
  out.write((char*) &(neg), sizeof(int));
  out.write((char*) &(wordNgrams), sizeof(int));
  out.write((char*) &(loss), sizeof(loss_name));
  out.write((char*) &(model), sizeof(model_name));
  out.write((char*) &(bucket), sizeof(int));
  if (model == model_name::cbowCWNgrams)
    out.write((char*) &(bucketChar), sizeof(int));
  out.write((char*) &(minn), sizeof(int));
  out.write((char*) &(maxn), sizeof(int));
  out.write((char*) &(lrUpdateRate), sizeof(int));
  out.write((char*) &(t), sizeof(double));
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x94(%rdi), %rsi
movl $0x4, %edx
movq %rbx, %rdi
callq 0x43f0
leaq 0x98(%r14), %rsi
movl $0x4, %edx
movq %rbx, %rdi
callq 0x43f0
leaq 0xa0(%r14), %rsi
movl $0x4, %edx
movq %rbx, %rdi
callq 0x43f0
leaq 0xa8(%r14), %rsi
movl $0x4, %edx
movq %rbx, %rdi
callq 0x43f0
leaq 0xb0(%r14), %rsi
movl $0x4, %edx
movq %rbx, %rdi
callq 0x43f0
leaq 0xb4(%r14), %rsi
movl $0x4, %edx
movq %rbx, %rdi
callq 0x43f0
leaq 0xbc(%r14), %rsi
movl $0x4, %edx
movq %rbx, %rdi
callq 0x43f0
leaq 0xc0(%r14), %rsi
movl $0x4, %edx
movq %rbx, %rdi
callq 0x43f0
leaq 0xc4(%r14), %rsi
movl $0x4, %edx
movq %rbx, %rdi
callq 0x43f0
cmpl $0x5, 0xc0(%r14)
jne 0x6142
leaq 0xc8(%r14), %rsi
movl $0x4, %edx
movq %rbx, %rdi
callq 0x43f0
leaq 0xcc(%r14), %rsi
movl $0x4, %edx
movq %rbx, %rdi
callq 0x43f0
leaq 0xd0(%r14), %rsi
movl $0x4, %edx
movq %rbx, %rdi
callq 0x43f0
leaq 0x90(%r14), %rsi
movl $0x4, %edx
movq %rbx, %rdi
callq 0x43f0
addq $0xd8, %r14
movl $0x8, %edx
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x43f0
// File: /workspace/github_cpp_makefile_star2_O3/epfml[P]sent2vec/src/args.cc
// Function: fasttext::Args::load(std::istream&)
void Args::load(std::istream& in) {
  in.read((char*) &(dim), sizeof(int));
  in.read((char*) &(ws), sizeof(int));
  in.read((char*) &(epoch), sizeof(int));
  in.read((char*) &(minCount), sizeof(int));
  in.read((char*) &(neg), sizeof(int));
  in.read((char*) &(wordNgrams), sizeof(int));
  in.read((char*) &(loss), sizeof(loss_name));
  in.read((char*) &(model), sizeof(model_name));
  in.read((char*) &(bucket), sizeof(int));
  if (model == model_name::cbowCWNgrams)
    in.read((char*) &(bucketChar), sizeof(int));
  in.read((char*) &(minn), sizeof(int));
  in.read((char*) &(maxn), sizeof(int));
  in.read((char*) &(lrUpdateRate), sizeof(int));
  in.read((char*) &(t), sizeof(double));
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x94(%rdi), %rsi
movl $0x4, %edx
movq %rbx, %rdi
callq 0x43b0
leaq 0x98(%r14), %rsi
movl $0x4, %edx
movq %rbx, %rdi
callq 0x43b0
leaq 0xa0(%r14), %rsi
movl $0x4, %edx
movq %rbx, %rdi
callq 0x43b0
leaq 0xa8(%r14), %rsi
movl $0x4, %edx
movq %rbx, %rdi
callq 0x43b0
leaq 0xb0(%r14), %rsi
movl $0x4, %edx
movq %rbx, %rdi
callq 0x43b0
leaq 0xb4(%r14), %rsi
movl $0x4, %edx
movq %rbx, %rdi
callq 0x43b0
leaq 0xbc(%r14), %rsi
movl $0x4, %edx
movq %rbx, %rdi
callq 0x43b0
leaq 0xc0(%r14), %rsi
movl $0x4, %edx
movq %rbx, %rdi
callq 0x43b0
leaq 0xc4(%r14), %rsi
movl $0x4, %edx
movq %rbx, %rdi
callq 0x43b0
cmpl $0x5, 0xc0(%r14)
jne 0x6278
leaq 0xc8(%r14), %rsi
movl $0x4, %edx
movq %rbx, %rdi
callq 0x43b0
leaq 0xcc(%r14), %rsi
movl $0x4, %edx
movq %rbx, %rdi
callq 0x43b0
leaq 0xd0(%r14), %rsi
movl $0x4, %edx
movq %rbx, %rdi
callq 0x43b0
leaq 0x90(%r14), %rsi
movl $0x4, %edx
movq %rbx, %rdi
callq 0x43b0
addq $0xd8, %r14
movl $0x8, %edx
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x43b0
// File: /workspace/github_cpp_makefile_star2_O3/epfml[P]sent2vec/src/dictionary.cc
// Function: fasttext::Dictionary::discard(int, float) const
bool Dictionary::discard(int32_t id, real rand) const {
  assert(id >= 0);
  assert(id < nwords_);
  if (args_->model == model_name::sup || args_->model == model_name::sent2vec || args_->model == model_name::cbowCWNgrams) return false;
  return rand > pdiscard_[id];
}

// Assembly:
pushq %rax
testl %esi, %esi
js 0x6e8a
cmpl %esi, 0x5c(%rdi)
jle 0x6ea9
movq (%rdi), %rax
movl 0xc0(%rax), %eax
addl $-0x3, %eax
cmpl $0x3, %eax
jae 0x6e7b
xorl %eax, %eax
jmp 0x6e88
movl %esi, %eax
movq 0x40(%rdi), %rcx
ucomiss (%rcx,%rax,4), %xmm0
seta %al
popq %rcx
retq
leaq 0x17d88(%rip), %rdi     # 0x1ec19
leaq 0x17b17(%rip), %rsi     # 0x1e9af
leaq 0x17b79(%rip), %rcx     # 0x1ea18
movl $0x62, %edx
callq 0x41d0
leaq 0x17ba0(%rip), %rdi     # 0x1ea50
leaq 0x17af8(%rip), %rsi     # 0x1e9af
leaq 0x17b5a(%rip), %rcx     # 0x1ea18
movl $0x63, %edx
callq 0x41d0
// File: /workspace/github_cpp_makefile_star2_O3/epfml[P]sent2vec/src/dictionary.cc
// Function: fasttext::Dictionary::getLine(std::istream&, std::vector<int, std::allocator<int>>&, std::vector<int, std::allocator<int>>&, std::linear_congruential_engine<unsigned long, 48271ul, 0ul, 2147483647ul>&) const
int32_t Dictionary::getLine(std::istream& in,
                            std::vector<int32_t>& words,
                            std::vector<int32_t>& labels,
                            std::minstd_rand& rng) const {
  std::vector<int32_t> word_hashes;
  int32_t ntokens = getLine(in, words, word_hashes, labels, rng);
  if (args_->model == model_name::sup) {
    addNgrams(words, word_hashes, args_->wordNgrams);
  }
  return ntokens;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %r8, %r9
movq %rcx, %r8
movq %rdx, %r14
movq %rdi, %r15
xorps %xmm0, %xmm0
movq %rsp, %rcx
movaps %xmm0, (%rcx)
movq $0x0, 0x10(%rcx)
callq 0x85c2
movl %eax, %ebx
movq (%r15), %rax
cmpl $0x3, 0xc0(%rax)
jne 0x8939
movl 0xb4(%rax), %ecx
movq %rsp, %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x7daa
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x894f
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x4300
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x8974
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x4300
movq %rbx, %rdi
callq 0x45b0
// File: /workspace/github_cpp_makefile_star2_O3/epfml[P]sent2vec/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_);
  if (args_->loss == loss_name::ns) {
    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 || args_->model == model_name::sent2vec) {
    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 0x1094e
movl %edx, %ebp
movq %rdi, %r14
cmpl %edx, 0x88(%rdi)
jle 0x1096d
movq %rsi, %rbx
movq 0x8(%rsi), %rax
cmpq (%rsi), %rax
je 0x10941
movss %xmm0, 0xc(%rsp)
leaq 0x50(%r14), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x10266
movq 0x40(%r14), %rax
movl 0xbc(%rax), %eax
cmpl $0x1, %eax
je 0x1088c
cmpl $0x2, %eax
movss 0xc(%rsp), %xmm0
movq %r14, %rdi
movl %ebp, %esi
jne 0x1089e
callq 0xfe52
jmp 0x108a3
movq %r14, %rdi
movl %ebp, %esi
movss 0xc(%rsp), %xmm0
callq 0xff4c
jmp 0x108a3
callq 0x10162
addss 0x8c(%r14), %xmm0
movss %xmm0, 0x8c(%r14)
incq 0x90(%r14)
movq 0x40(%r14), %rax
movl 0xc0(%rax), %eax
addl $-0x3, %eax
cmpl $0x1, %eax
ja 0x10913
movq 0x8(%rbx), %rax
subq (%rbx), %rax
sarq $0x2, %rax
movq %rax, %xmm0
punpckldq 0xe09a(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0xe0a2(%rip), %xmm0     # 0x1e990
leaq 0x70(%r14), %rdi
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movsd 0xe062(%rip), %xmm0     # 0x1e968
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
callq 0xf43c
movq (%rbx), %r12
cmpq 0x8(%rbx), %r12
je 0x10941
leaq 0x70(%r14), %r15
movq (%r14), %rdi
movslq (%r12), %rdx
movq %r15, %rsi
movss 0xe8c6(%rip), %xmm0     # 0x1f1f8
callq 0xe3ce
addq $0x4, %r12
cmpq 0x8(%rbx), %r12
jne 0x10920
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0xecde(%rip), %rdi      # 0x1f633
leaq 0xebea(%rip), %rsi      # 0x1f546
leaq 0xecdc(%rip), %rcx      # 0x1f63f
movl $0xcc, %edx
callq 0x41d0
leaq 0xed15(%rip), %rdi      # 0x1f689
leaq 0xebcb(%rip), %rsi      # 0x1f546
leaq 0xecbd(%rip), %rcx      # 0x1f63f
movl $0xcd, %edx
callq 0x41d0
// File: /workspace/github_cpp_makefile_star2_O3/epfml[P]sent2vec/src/fasttext.cc
// Function: fasttext::FastText::loadModel(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool, bool, int)
void FastText::loadModel(const std::string& filename,
                         const bool inference_mode /* = false */,
                         const bool shared_mem_enabled /* = true */,
                         const int timeout_sec /* = -1 */) {
  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);
  }
  if (!checkModel(ifs)) {
    std::cerr << "Model file has wrong file format!" << std::endl;
    exit(EXIT_FAILURE);
  }
  if (inference_mode) {
    if (shared_mem_enabled) {
      loadModelWithSharedMemory(ifs, filename, timeout_sec);
    } else {
      loadModel(ifs, false);
    }
  } else {
    loadModel(ifs, true);
  }
  ifs.close();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x210, %rsp            # imm = 0x210
movl %r8d, %ebp
movl %ecx, %r12d
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
movl $0x4, %edx
callq 0x44f0
leaq 0x80(%rsp), %rdi
callq 0x40b0
testb %al, %al
je 0x12f34
leaq 0x8(%rsp), %rsi
callq 0x124da
testb %al, %al
je 0x12f5a
andb %r15b, %r12b
cmpb $0x1, %r12b
jne 0x12efb
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
movq %r14, %rdx
movl %ebp, %ecx
callq 0x12f9e
jmp 0x12f10
xorb $0x1, %r15b
movzbl %r15b, %edx
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x13440
leaq 0x8(%rsp), %rdi
callq 0x4090
leaq 0x8(%rsp), %rdi
callq 0x40c0
addq $0x210, %rsp            # imm = 0x210
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x170b5(%rip), %rdi     # 0x29ff0
leaq 0xcad0(%rip), %rsi      # 0x1fa12
movl $0x28, %edx
callq 0x4350
movq 0x1709d(%rip), %rdi     # 0x29ff0
callq 0x4170
jmp 0x12f7e
movq 0x1708f(%rip), %rdi     # 0x29ff0
leaq 0xcad3(%rip), %rsi      # 0x1fa3b
movl $0x21, %edx
callq 0x4350
movq 0x17077(%rip), %rdi     # 0x29ff0
callq 0x4170
movl $0x1, %edi
callq 0x4380
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x40c0
movq %rbx, %rdi
callq 0x45b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/epfml[P]sent2vec/src/fasttext.cc
// Function: fasttext::FastText::skipgram(fasttext::Model&, float, std::vector<int, std::allocator<int>> const&)
void FastText::skipgram(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);
    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 $0x38, %rsp
movss %xmm0, 0xc(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdi, 0x28(%rsp)
movq (%rdi), %rax
movl 0x98(%rax), %eax
movl $0x1, 0x18(%rsp)
movl %eax, 0x1c(%rsp)
movq 0x8(%rdx), %rax
cmpq (%rdx), %rax
je 0x1431a
movq %rdx, %rbx
movq 0x10(%rsp), %rax
addq $0x110, %rax            # imm = 0x110
movq %rax, 0x20(%rsp)
xorl %r12d, %r12d
leaq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq %rdi, %rdx
callq 0xc280
movl %eax, %ebp
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rdi
movq (%rbx), %rax
movl (%rax,%r12,4), %esi
callq 0x66ba
movq %rax, 0x30(%rsp)
testl %ebp, %ebp
js 0x14303
leal 0x1(,%rbp,2), %r13d
movl %r12d, %r14d
subl %ebp, %r14d
xorl %r15d, %r15d
cmpl %r15d, %ebp
je 0x142fb
movl %r14d, %eax
addl %r15d, %eax
js 0x142fb
movl %eax, %eax
movq (%rbx), %rcx
movq 0x8(%rbx), %rdx
subq %rcx, %rdx
sarq $0x2, %rdx
cmpq %rax, %rdx
jbe 0x142fb
movl (%rcx,%rax,4), %edx
movq 0x10(%rsp), %rdi
movq 0x30(%rsp), %rsi
movss 0xc(%rsp), %xmm0
callq 0x1081c
incl %r15d
cmpl %r15d, %r13d
jne 0x142c1
incq %r12
movq 0x8(%rbx), %rax
subq (%rbx), %rax
sarq $0x2, %rax
cmpq %r12, %rax
ja 0x1427e
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/epfml[P]sent2vec/src/fasttext.cc
// Function: fasttext::FastText::sent2vec(fasttext::Model&, float, std::vector<int, std::allocator<int>> const&)
void FastText::sent2vec(Model& model, real lr, const std::vector<int32_t>& line){
  if (line.size() <= 1) return;
  std::vector<int32_t> context;
  std::uniform_real_distribution<> uniform(0, 1);
  for (int32_t i=0; i<line.size(); ++i){
    if (uniform(model.rng) > dict_->getPDiscard(line[i]) || dict_->getTokenCount(line[i]) < args_->minCountLabel)
      continue;
    context = line;
    context[i] = 0;
    dict_->addNgrams(context, args_->wordNgrams, args_->dropoutK, model.rng);
    model.update(context, line[i], lr);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rbx
movss %xmm0, 0xc(%rsp)
movq (%rdx), %rax
movq 0x8(%rdx), %rcx
movq %rcx, %rdx
subq %rax, %rdx
cmpq $0x5, %rdx
jb 0x1499d
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
cmpq %rax, %rcx
je 0x1499d
movq %rsi, %r14
movq %rdi, %r15
leaq 0x110(%rsi), %r12
xorl %ebp, %ebp
leaq 0x10(%rsp), %r13
movq %r12, %rdi
callq 0xc408
movsd %xmm0, 0x30(%rsp)
movq 0x10(%r15), %rdi
movq (%rbx), %rax
movl (%rax,%rbp,4), %esi
callq 0x7044
cvtss2sd %xmm0, %xmm0
movsd 0x30(%rsp), %xmm1
ucomisd %xmm0, %xmm1
ja 0x1496f
movq 0x10(%r15), %rdi
movq (%rbx), %rax
movl (%rax,%rbp,4), %esi
callq 0x6fea
movq (%r15), %rcx
movslq 0xac(%rcx), %rcx
cmpq %rcx, %rax
jl 0x1496f
movq %r13, %rdi
movq %rbx, %rsi
callq 0xa9b6
movq 0x10(%rsp), %rax
movl $0x0, (%rax,%rbp,4)
movq (%r15), %rax
movq 0x10(%r15), %rdi
movl 0x9c(%rax), %ecx
movl 0xb4(%rax), %edx
movq %r13, %rsi
movq %r12, %r8
callq 0x8260
movq (%rbx), %rax
movl (%rax,%rbp,4), %edx
movq %r14, %rdi
movq %r13, %rsi
movss 0xc(%rsp), %xmm0
callq 0x1081c
incq %rbp
movq 0x8(%rbx), %rax
subq (%rbx), %rax
sarq $0x2, %rax
cmpq %rbp, %rax
ja 0x148d8
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1499d
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x4300
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x149c6
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x4300
movq %rbx, %rdi
callq 0x45b0
// File: /workspace/github_cpp_makefile_star2_O3/DimitriDaSilva[P]42_ft_containers/containers/utils/red_black_tree.hpp
// Function: ft::red_black_tree<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, ft::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, custom_allocator<ft::red_black_tree_node<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::clear_helper(ft::red_black_tree_node<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>* const&)
void
		clear_helper(node_pointer const& node)
		{
			// Base case of recursion
			if (node == _nil)
				return;

			// Clear all nodes to the left and right of it
			clear_helper(node->left);
			clear_helper(node->right);

			// Clear the node itself
			_alloc.destroy(node);
			_alloc.deallocate(node, 1);

			_size--;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq (%rsi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x72d3
movq %rdi, %rbx
addq $0x28, %rsi
callq 0x7282
movq (%r14), %rsi
addq $0x30, %rsi
movq %rbx, %rdi
callq 0x7282
movq (%r14), %rdi
movq (%rdi), %rax
leaq 0x10(%rdi), %rcx
cmpq %rcx, %rax
je 0x72ca
movq %rax, %rdi
callq 0x5190
movq (%r14), %rdi
callq 0x5190
decq 0x18(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/DimitriDaSilva[P]42_ft_containers/containers/utils/red_black_tree.hpp
// Function: ft::red_black_tree<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, greater<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<ft::red_black_tree_node<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::insert_helper(ft::red_black_tree_node<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>*, ft::red_black_tree_node<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>*)
node_pointer
		insert_helper(node_pointer node, node_pointer hint)
		{
			node->parent = find_right_position(node, hint);

			// Set node in the position found. Either left or right
			// If parent NULL then it means we are at the root of the tree
			// so we can retrun
			if (node->parent == NULL)
			{
				_root = node;
				_root->color = black;

				return _root;
			}
			else if (_comp(get_key_from_val(node->data), get_key_from_val(node->parent->data)))
				node->parent->left = node;
			else
				node->parent->right = node;

			// If parent is _root then we are at level 1 of the tree
			// so we can't be unbalancing the tree
			// Else the new node could have unbalanced the red-black tree
			// so we need to check after each insert
			if (node->parent != _root)
				check_insert(node);

			return node;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, -0x30(%rbp)
callq 0xa6d8
movq %rax, 0x20(%rbx)
testq %rax, %rax
je 0xa59b
movq (%r14), %rax
leaq -0x50(%rbp), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq *0x10(%rax)
movq 0x20(%rbx), %rdx
movq (%r14), %rax
leaq -0x70(%rbp), %rdi
movq %r14, %rsi
callq *0x10(%rax)
movq -0x48(%rbp), %r13
movq -0x70(%rbp), %rcx
movq -0x68(%rbp), %r15
cmpq %r13, %r15
movq %r13, %rdx
cmovbq %r15, %rdx
testq %rdx, %rdx
je 0xa52c
movq -0x50(%rbp), %rdi
movq %rcx, %r12
movq %rcx, %rsi
callq 0x50c0
movq %r12, %rcx
movl %eax, %r12d
testl %eax, %eax
jne 0xa54d
subq %r15, %r13
cmpq $-0x7fffffff, %r13      # imm = 0x80000001
movq $-0x80000000, %r12      # imm = 0x80000000
cmovgeq %r13, %r12
movl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
cmpq %rax, %r12
cmovgeq %rax, %r12
leaq -0x60(%rbp), %rax
cmpq %rax, %rcx
je 0xa55e
movq %rcx, %rdi
callq 0x5190
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa570
callq 0x5190
xorl %eax, %eax
testl %r12d, %r12d
setle %al
movq 0x20(%rbx), %rcx
movq %rbx, 0x28(%rcx,%rax,8)
cmpq 0x8(%r14), %rcx
je 0xa5a6
leaq -0x30(%rbp), %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0xa7ec
movq (%rbx), %rbx
jmp 0xa5a6
movq %rbx, 0x8(%r14)
movl $0x1, 0x38(%rbx)
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa5cd
callq 0x5190
movq %rbx, %rdi
callq 0x52f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/DimitriDaSilva[P]42_ft_containers/containers/utils/red_black_tree.hpp
// Function: ft::red_black_tree<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, ft::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, custom_allocator<ft::red_black_tree_node<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::find_helper(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, ft::red_black_tree_node<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>* const&) const
node_pointer
		find_helper(key_type const& key, node_pointer const& node) const
		{
			// Base case of recursion
			if (node == _nil)
				return NULL;
			else if (get_key_from_val(node->data) == key)
				return node;

			if (_comp(key, get_key_from_val(node->data)))
				return find_helper(key, node->left);
			else
				return find_helper(key, node->right);
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r15
movq (%rdx), %rdx
cmpq 0x10(%rdi), %rdx
je 0x745c
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
leaq -0x48(%rbp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq *0x10(%rax)
movq 0x8(%r12), %rdx
cmpq 0x8(%rbx), %rdx
jne 0x7460
movq -0x48(%rbp), %r12
testq %rdx, %rdx
je 0x7469
movq (%rbx), %rsi
movq %r12, %rdi
callq 0x51f0
testl %eax, %eax
sete %r13b
jmp 0x746c
xorl %eax, %eax
jmp 0x74d7
movq -0x48(%rbp), %r12
xorl %r13d, %r13d
jmp 0x746c
movb $0x1, %r13b
leaq -0x38(%rbp), %rax
cmpq %rax, %r12
je 0x747d
movq %r12, %rdi
callq 0x5190
testb %r13b, %r13b
je 0x7487
movq (%r15), %rax
jmp 0x74d7
movq (%r15), %rdx
movq (%r14), %rax
leaq -0x48(%rbp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq *0x10(%rax)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x5040
movl %eax, %r12d
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x74ba
callq 0x5190
movq (%r15), %rdx
testl %r12d, %r12d
js 0x74c8
addq $0x30, %rdx
jmp 0x74cc
addq $0x28, %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x7402
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x74fb
callq 0x5190
movq %rbx, %rdi
callq 0x52f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/DimitriDaSilva[P]42_ft_containers/containers/utils/red_black_tree.hpp
// Function: ft::red_black_tree<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, ft::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, custom_allocator<ft::red_black_tree_node<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>::find_right_position(ft::red_black_tree_node<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>*, ft::red_black_tree_node<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>*)
node_pointer
		find_right_position(node_pointer node, node_pointer hint)
		{
			node_pointer	parent = NULL;
			node_pointer	child = hint;

			while (child != _nil)
			{
				parent = child;
				if (_comp(get_key_from_val(node->data), get_key_from_val(child->data)))
					child = child->left;
				else
					child = child->right;
			}

			return parent;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, -0x38(%rbp)
cmpq %rdx, 0x10(%rdi)
je 0x75e6
movq %rdi, %rbx
movq %rdi, -0x30(%rbp)
movq %rdx, %r12
movq (%rbx), %rax
leaq -0x58(%rbp), %rdi
movq %rbx, %rsi
movq -0x38(%rbp), %rdx
callq *0x10(%rax)
movq (%rbx), %rax
leaq -0x78(%rbp), %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq *0x10(%rax)
movq -0x50(%rbp), %r13
movq -0x78(%rbp), %r15
movq -0x70(%rbp), %r14
cmpq %r13, %r14
movq %r13, %rdx
cmovbq %r14, %rdx
testq %rdx, %rdx
je 0x7585
movq -0x58(%rbp), %rdi
movq %r15, %rsi
callq 0x50c0
movl %eax, %ebx
testl %eax, %eax
jne 0x75a9
subq %r14, %r13
cmpq $-0x7fffffff, %r13      # imm = 0x80000001
movq $-0x80000000, %rax      # imm = 0x80000000
cmovlq %rax, %r13
movl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
cmpq %rax, %r13
cmovgeq %rax, %r13
movl %r13d, %ebx
leaq -0x68(%rbp), %rax
cmpq %rax, %r15
je 0x75ba
movq %r15, %rdi
callq 0x5190
movq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rax
cmpq %rax, %rdi
je 0x75cc
callq 0x5190
notl %ebx
shrl $0x1f, %ebx
movq 0x28(%r12,%rbx,8), %rdx
movq -0x30(%rbp), %rbx
cmpq 0x10(%rbx), %rdx
jne 0x7534
jmp 0x75e9
xorl %r12d, %r12d
movq %r12, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rax
cmpq %rax, %rdi
je 0x7610
callq 0x5190
movq %rbx, %rdi
callq 0x52f0
// File: /workspace/github_cpp_makefile_star2_O3/DimitriDaSilva[P]42_ft_containers/containers/utils/red_black_tree.hpp
// Function: ft::red_black_tree<int, int, ft::less<int>, custom_allocator<ft::red_black_tree_node<int>>>::rotate_left(ft::red_black_tree_node<int>*&)
void
		rotate_left(node_pointer& node)
		{
			node_pointer grandparent = node->parent->parent;
			node_pointer parent = node->parent;
			node_pointer tmp = _nil;

			// Update grandparent
			if (grandparent == NULL)
				_root = node;
			else if (grandparent->left == parent)
				grandparent->left = node;
			else
				grandparent->right = node;

			// Save node to the left of node before overwritting it
			if (node->left != _nil)
			{
				tmp = node->left;
				tmp->parent = parent;
			}

			// Update node itself
			node->left = parent;
			if (node == _root)
				node->parent = NULL;
			else
				node->parent = grandparent;

			// Update parent
			parent->parent = node;
			parent->right = tmp;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq (%rsi), %r8
movq 0x8(%r8), %rax
movq 0x8(%rax), %rcx
movq 0x10(%rdi), %rdx
testq %rcx, %rcx
je 0x6f7e
leaq 0x10(%rcx), %r10
leaq 0x18(%rcx), %r9
cmpq %rax, 0x10(%rcx)
cmoveq %r10, %r9
jmp 0x6f82
leaq 0x8(%rdi), %r9
movq %r8, (%r9)
movq (%rsi), %r8
movq 0x10(%r8), %r9
cmpq %rdx, %r9
je 0x6f9b
movq %rax, 0x8(%r9)
movq (%rsi), %r8
movq %r9, %rdx
movq %rax, 0x10(%r8)
movq (%rsi), %r8
xorl %r9d, %r9d
cmpq 0x8(%rdi), %r8
cmoveq %r9, %rcx
movq %rcx, 0x8(%r8)
movq (%rsi), %rcx
movq %rcx, 0x8(%rax)
movq %rdx, 0x18(%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/DimitriDaSilva[P]42_ft_containers/containers/utils/red_black_tree.hpp
// Function: ft::red_black_tree<int, int, ft::less<int>, custom_allocator<ft::red_black_tree_node<int>>>::rotate_right(ft::red_black_tree_node<int>*&)
void
		rotate_right(node_pointer& node)
		{
			node_pointer grandparent = node->parent->parent;
			node_pointer parent = node->parent;
			node_pointer tmp = _nil;

			// Update grandparent
			if (grandparent == NULL)
				_root = node;
			else if (grandparent->left == parent)
				grandparent->left = node;
			else
				grandparent->right = node;

			// Save node to the right of node before overwritting it
			// and set its new parent
			if (node->right != _nil)
			{
				tmp = node->right;
				tmp->parent = parent;
			}

			// Update node itself
			node->right = parent;
			if (node == _root)
				node->parent = NULL;
			else
				node->parent = grandparent;

			// Update parent
			parent->parent = node;
			parent->left = tmp;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq (%rsi), %r8
movq 0x8(%r8), %rax
movq 0x8(%rax), %rcx
movq 0x10(%rdi), %rdx
testq %rcx, %rcx
je 0x6fe8
leaq 0x10(%rcx), %r10
leaq 0x18(%rcx), %r9
cmpq %rax, 0x10(%rcx)
cmoveq %r10, %r9
jmp 0x6fec
leaq 0x8(%rdi), %r9
movq %r8, (%r9)
movq (%rsi), %r8
movq 0x18(%r8), %r9
cmpq %rdx, %r9
je 0x7005
movq %rax, 0x8(%r9)
movq (%rsi), %r8
movq %r9, %rdx
movq %rax, 0x18(%r8)
movq (%rsi), %r8
xorl %r9d, %r9d
cmpq 0x8(%rdi), %r8
cmoveq %r9, %rcx
movq %rcx, 0x8(%r8)
movq (%rsi), %rcx
movq %rcx, 0x8(%rax)
movq %rdx, 0x10(%rax)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/DimitriDaSilva[P]42_ft_containers/containers/utils/red_black_tree.hpp
// Function: ft::red_black_tree<char, ft::pair<char const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, ft::less<char>, std::allocator<ft::red_black_tree_node<ft::pair<char const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>>::red_black_tree(ft::less<char> const&, std::allocator<ft::red_black_tree_node<ft::pair<char const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>> const&)
explicit
		red_black_tree(key_compare const& comp = key_compare(),
						allocator_type const& alloc = allocator_type()) :
			_root(NULL),
			_nil(NULL),
			_size(0),
			_comp(comp),
			_alloc(alloc)
		{
			_nil = _alloc.allocate(1);
			_alloc.construct(_nil, node_type(value_type(), NULL, NULL, NULL, black));

			// All leaf nodes will point to _nil and _nil is a black node
			// Set root pointing to _nil for an empty tree
			_root = _nil;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x70, %rsp
movq %rdi, %r14
leaq 0x2d489(%rip), %rax     # 0x47908
movq %rax, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
xorl %r12d, %r12d
movq %r12, 0x18(%rdi)
movl $0x48, %edi
callq 0x51e0
movq %rax, %r15
movq %rax, 0x10(%r14)
leaq -0x78(%rbp), %rbx
movb %r12b, -0x18(%rbx)
movq %rbx, -0x10(%rbx)
movq %r12, -0x8(%rbx)
movb %r12b, (%rbx)
leaq -0x60(%rbp), %rdi
movb %r12b, -0x8(%rdi)
leaq -0x50(%rbp), %r12
movq %r12, -0x10(%r12)
movq %rbx, %rsi
movq %rbx, %rdx
callq 0x71e4
xorps %xmm0, %xmm0
movups %xmm0, -0x40(%rbp)
movq $0x0, -0x30(%rbp)
movl $0x1, -0x28(%rbp)
movb -0x68(%rbp), %al
movb %al, (%r15)
leaq 0x8(%r15), %rdi
movq %r15, %rax
addq $0x18, %rax
movq %rax, 0x8(%r15)
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdx
addq %rsi, %rdx
callq 0x71e4
leaq -0x40(%rbp), %rax
movups (%rax), %xmm0
movups 0xc(%rax), %xmm1
movups %xmm1, 0x34(%r15)
movups %xmm0, 0x28(%r15)
movq -0x20(%rax), %rdi
cmpq %r12, %rdi
je 0x1a52e
callq 0x5190
movq -0x88(%rbp), %rdi
cmpq %rbx, %rdi
je 0x1a53f
callq 0x5190
movq 0x10(%r14), %rax
movq %rax, 0x8(%r14)
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq -0x60(%rbp), %rdi
cmpq %r12, %rdi
je 0x1a56a
callq 0x5190
jmp 0x1a56a
movq %rax, %r14
movq -0x88(%rbp), %rdi
cmpq %rbx, %rdi
je 0x1a57b
callq 0x5190
movq %r14, %rdi
callq 0x52f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/DimitriDaSilva[P]42_ft_containers/containers/utils/red_black_tree.hpp
// Function: ft::red_black_tree<int, int, ft::less<int>, std::allocator<ft::red_black_tree_node<int>>>::operator=(ft::red_black_tree<int, int, ft::less<int>, std::allocator<ft::red_black_tree_node<int>>> const&)
red_black_tree&
		operator=(red_black_tree const& rhs)
		{
			// Self-assignement check
			if (this == &rhs)
				return *this;

			// Clear current
			if (_root != NULL)
				clear();
			copy_helper(_root, rhs._root, NULL, rhs._nil);

			_size = rhs._size;

			return *this;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x93b0
movq %rsi, %r14
leaq 0x8(%rbx), %r15
cmpq $0x0, 0x8(%rbx)
je 0x9393
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6be4
movq 0x10(%rbx), %rax
movq %rax, 0x8(%rbx)
movq 0x8(%r14), %rdx
movq 0x10(%r14), %r8
movq %rbx, %rdi
movq %r15, %rsi
xorl %ecx, %ecx
callq 0x93be
movq 0x18(%r14), %rax
movq %rax, 0x18(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/DimitriDaSilva[P]42_ft_containers/containers/utils/red_black_tree.hpp
// Function: ft::red_black_tree<char, ft::pair<char const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, ft::less<char>, std::allocator<ft::red_black_tree_node<ft::pair<char const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>>::copy_helper(ft::red_black_tree_node<ft::pair<char const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>*&, ft::red_black_tree_node<ft::pair<char const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>*, ft::red_black_tree_node<ft::pair<char const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>*, ft::red_black_tree_node<ft::pair<char const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>*)
void
		copy_helper(node_pointer& lhs,
				node_pointer rhs,
				node_pointer parent,
				node_pointer nil_rhs)
		{
			// Base case of the recursion
			if (rhs == nil_rhs)
			{
				lhs = _nil;
				return;
			}

			lhs = _alloc.allocate(1);
			_alloc.construct(lhs, *rhs);
			// Parent is the previously created node pased as argument
			lhs->parent = parent;

			copy_helper(lhs->left, rhs->left, lhs, nil_rhs);
			copy_helper(lhs->right, rhs->right, lhs, nil_rhs);
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpq %r8, %rdx
je 0x217cf
movq %rcx, %r13
movq %rdx, %r12
movq %r8, -0x30(%rbp)
movl $0x48, %edi
callq 0x51e0
movq %r14, %r15
movq %rax, %r14
movq %rax, (%rbx)
movb (%r12), %al
movb %al, (%r14)
leaq 0x8(%r14), %rdi
leaq 0x18(%r14), %rax
movq %rax, 0x8(%r14)
movq 0x8(%r12), %rsi
movq 0x10(%r12), %rdx
addq %rsi, %rdx
callq 0x71e4
movups 0x28(%r12), %xmm0
movups 0x34(%r12), %xmm1
movups %xmm1, 0x34(%r14)
movups %xmm0, 0x28(%r14)
movq %r15, %r14
movq -0x30(%rbp), %r15
movq (%rbx), %rax
movq %r13, 0x28(%rax)
movq (%rbx), %rcx
leaq 0x30(%rcx), %rsi
movq 0x30(%r12), %rdx
movq %r14, %rdi
movq %r15, %r8
callq 0x21720
movq (%rbx), %r13
leaq 0x38(%r13), %rbx
movq 0x38(%r12), %r12
cmpq %r15, %r12
jne 0x21747
movq 0x10(%r14), %rax
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/DimitriDaSilva[P]42_ft_containers/containers/utils/red_black_tree.hpp
// Function: ft::red_black_tree<char, ft::pair<char const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, ft::less<char>, std::allocator<ft::red_black_tree_node<ft::pair<char const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>>::red_black_tree(ft::red_black_tree<char, ft::pair<char const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, ft::less<char>, std::allocator<ft::red_black_tree_node<ft::pair<char const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>> const&)
red_black_tree(red_black_tree const& rhs) :
			_root(NULL),
			_nil(NULL),
			_size(0),
			_comp(rhs._comp),
			_alloc(rhs._alloc)
		{
			_nil = _alloc.allocate(1);
			_alloc.construct(_nil, node_type(value_type(), NULL, NULL, NULL, black));

			// All leaf nodes will point to _nil and _nil is a black node
			// Set root pointing to _nil for an empty tree
			_root = _nil;

			*this = rhs;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x2635c(%rip), %rax     # 0x47908
movq %rax, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
xorl %r13d, %r13d
movq %r13, 0x18(%rdi)
movl $0x48, %edi
callq 0x51e0
movq %rax, %r12
movq %rax, 0x10(%r14)
leaq -0x80(%rbp), %r15
movb %r13b, -0x18(%r15)
movq %r15, -0x10(%r15)
movq %r13, -0x8(%r15)
movb %r13b, (%r15)
leaq -0x68(%rbp), %rdi
movb %r13b, -0x8(%rdi)
leaq -0x58(%rbp), %r13
movq %r13, -0x10(%r13)
movq %r15, %rsi
movq %r15, %rdx
callq 0x71e4
xorps %xmm0, %xmm0
movups %xmm0, -0x48(%rbp)
movq $0x0, -0x38(%rbp)
movl $0x1, -0x30(%rbp)
movb -0x70(%rbp), %al
movb %al, (%r12)
leaq 0x8(%r12), %rdi
movq %r12, %rax
addq $0x18, %rax
movq %rax, 0x8(%r12)
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rdx
addq %rsi, %rdx
callq 0x71e4
leaq -0x48(%rbp), %rax
movups (%rax), %xmm0
movups 0xc(%rax), %xmm1
movups %xmm1, 0x34(%r12)
movups %xmm0, 0x28(%r12)
movq -0x20(%rax), %rdi
cmpq %r13, %rdi
je 0x2165f
callq 0x5190
movq -0x90(%rbp), %rdi
cmpq %r15, %rdi
je 0x21670
callq 0x5190
movq 0x10(%r14), %rax
movq %rax, 0x8(%r14)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x216c2
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x216a8
callq 0x5190
jmp 0x216a8
movq %rax, %rbx
movq -0x90(%rbp), %rdi
cmpq %r15, %rdi
je 0x216b9
callq 0x5190
movq %rbx, %rdi
callq 0x52f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/DimitriDaSilva[P]42_ft_containers/containers/utils/red_black_tree.hpp
// Function: ft::red_black_tree<int, int, ft::less<int>, std::allocator<ft::red_black_tree_node<int>>>::insert(ft::bidirectional_iterator<ft::red_black_tree_node<int>>, int const&)
iterator
		insert(iterator hint, value_type const& val)
		{
			node_pointer successor = get_successor(hint._ptr);
			node_pointer node;

			// Check if position is correct
			if (_comp(get_key_from_iterator(hint), get_key_from_val(val))
					&& _comp(get_key_from_val(val), get_key_from_val(successor->data)))
			{
				// New nodes are necessarily red and leaf nodes so they point
				// to _nil
				node = _alloc.allocate(1);
				_alloc.construct(node, node_type(val, NULL, _nil, _nil, red));

				_size++;

				return iterator(insert_helper(node, hint._ptr), _root, _nil);
			}
			else
				return insert(val).first;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r14
movq 0x8(%rdx), %rax
movq 0x18(%rax), %rdx
movq 0x10(%rsi), %rsi
cmpq %rsi, %rdx
je 0xcdec
cmpq $0x0, 0x18(%r14)
je 0xce07
movq %rdx, %r13
movq 0x10(%rdx), %rdx
cmpq %rsi, %rdx
jne 0xcdde
jmp 0xce0a
movq 0x8(%r14), %rcx
movq %rax, %rdx
movq 0x8(%rdx), %r13
cmpq %rcx, %rdx
je 0xce0a
cmpq 0x18(%r13), %rdx
movq %r13, %rdx
je 0xcdf3
jmp 0xce0a
xorl %r13d, %r13d
movq %rdi, -0x30(%rbp)
leaq 0x3a1db(%rip), %rcx     # 0x46ff0
leaq -0x50(%rbp), %rsi
movq %rcx, (%rsi)
movq %rax, 0x8(%rsi)
movq 0x10(%r15), %rax
movq %rax, 0x10(%rsi)
movq 0x18(%r15), %rax
movq %rax, 0x18(%rsi)
movq (%r14), %rax
movq %r14, %rdi
callq *0x18(%rax)
movl %eax, %r12d
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
callq *0x10(%rax)
cmpl %eax, %r12d
jge 0xcec6
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
callq *0x10(%rax)
movl %eax, %r12d
movq (%r14), %rax
movq %r14, %rdi
movq %r13, %rsi
callq *0x10(%rax)
cmpl %eax, %r12d
jge 0xcec6
movl $0x28, %edi
callq 0x51e0
movl (%rbx), %ecx
movq 0x10(%r14), %rdx
movl %ecx, (%rax)
movq $0x0, 0x8(%rax)
movq %rdx, 0x10(%rax)
movq %rdx, 0x18(%rax)
movl $0x0, 0x20(%rax)
incq 0x18(%r14)
movq 0x8(%r15), %rdx
movq %r14, %rdi
movq %rax, %rsi
callq 0x9010
movups 0x8(%r14), %xmm0
movq -0x30(%rbp), %rcx
leaq 0x3a137(%rip), %rdx     # 0x46ff0
movq %rdx, (%rcx)
movq %rax, 0x8(%rcx)
movups %xmm0, 0x10(%rcx)
jmp 0xcefe
leaq -0x78(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x8452
movq -0x30(%rbp), %rcx
leaq 0x3a10d(%rip), %rax     # 0x46ff0
movq %rax, (%rcx)
movq 0x8(%r15), %rax
movq %rax, 0x8(%rcx)
movq 0x10(%r15), %rax
movq %rax, 0x10(%rcx)
movq 0x18(%r15), %rax
movq %rax, 0x18(%rcx)
movq %rcx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/DimitriDaSilva[P]42_ft_containers/containers/utils/red_black_tree.hpp
// Function: ft::red_black_tree<int, int, ft::less<int>, std::allocator<ft::red_black_tree_node<int>>>::erase(int const&)
size_type
		erase(key_type const& key)
		{
			iterator it = find(key);

			// Val not found in tree so nothing erased
			if (it == end())
				return 0;

			erase(it);
			return 1;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x8(%rdi), %rdx
callq 0x9092
movq 0x18(%rbx), %rdx
testq %rdx, %rdx
je 0xcf2f
movq 0x10(%rbx), %rdx
xorl %ecx, %ecx
testq %rax, %rax
je 0xcf4f
cmpq %rdx, %rax
je 0xcf4f
movq %rbx, %rdi
movq %rax, %rsi
callq 0xd060
decq 0x18(%rbx)
movl $0x1, %ecx
movq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/DimitriDaSilva[P]42_ft_containers/containers/utils/red_black_tree.hpp
// Function: ft::red_black_tree<int, int, ft::less<int>, std::allocator<ft::red_black_tree_node<int>>>::erase_helper(ft::red_black_tree_node<int>*)
void
		erase_helper(node_pointer node)
		{
			node_pointer	tmp;

			// Case: leaf node (base case of the recursion)
			// We only delete leaf nodes. Internal nodes are replaced
			if (node->left == _nil && node->right == _nil)
			{
				// Fix double black case. If we delete a black leaf node
				// we are violating the rule that states that all paths
				// in a red-black tree have the same number of black nodes
				if (node->color == black)
					fix_double_black(node);

				// Update parent
				if (node == _root)
					_root = _nil;
				else if (node->parent->left == node)
					node->parent->left = _nil;
				else
					node->parent->right = _nil;

				_alloc.destroy(node);
				_alloc.deallocate(node, 1);

			}
			// Case: node one or two childs
			// If two childs, we get successor
			else
			{
				// Find predecessor or successor
				if (node->right != _nil)
					tmp = get_successor(node);
				else
					tmp = get_predecessor(node);

				// Swap nodes but they switch colors and node gets tmp's data
				// but tmp keeps it's data
				swap_nodes(node, tmp);

				// Recursively replace and delete node
				erase_helper(node);
			}
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rbx), %rsi
movq 0x18(%rbx), %rcx
movq 0x10(%r14), %rax
cmpq %rax, %rsi
je 0xd098
cmpq %rax, %rcx
jne 0xd09d
cmpq $0x0, 0x18(%r14)
je 0xd0b2
movq %rsi, %rdx
movq 0x18(%rsi), %rsi
cmpq %rax, %rsi
jne 0xd08a
jmp 0xd0b4
cmpq %rsi, %rcx
je 0xd0c1
cmpq $0x0, 0x18(%r14)
je 0xd0b2
movq %rcx, %rdx
movq 0x10(%rcx), %rcx
cmpq %rax, %rcx
jne 0xd0a4
jmp 0xd0b4
xorl %edx, %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0xd2d8
jmp 0xd06d
cmpl $0x1, 0x20(%rbx)
jne 0xd0d2
movq %r14, %rdi
movq %rbx, %rsi
callq 0xd106
cmpq %rbx, 0x8(%r14)
je 0xd0ec
movq 0x8(%rbx), %rax
movq 0x10(%r14), %rcx
cmpq %rbx, 0x10(%rax)
je 0xd0f6
movq %rcx, 0x18(%rax)
jmp 0xd0fa
movq 0x10(%r14), %rax
movq %rax, 0x8(%r14)
jmp 0xd0fa
movq %rcx, 0x10(%rax)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x5190