LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/Chrom3D[P]Chrom3D/src/Model.cpp
// Function: Model::addInteractionConstraint(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, double, ConstraintType)
void Model::addInteractionConstraint(string beadId1, string beadId2, double springConstant /*=1*/, ConstraintType interactionType/*= INTERACTION*/) {
  assert(getBead.find(beadId1) != getBead.end()); 
  assert(getBead.find(beadId2) != getBead.end());
  assert(interactionType == INTERACTION || interactionType == INTERACTION_INTRA || interactionType == INTERACTION_INTER);

  Bead* b1 = getBead[beadId1];
  Bead* b2 = getBead[beadId2];
  this->addConstraint(beadId1, beadId2, b1->getRadius()+b2->getRadius(), interactionType, springConstant);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %ecx, %ebx
movsd %xmm0, 0x30(%rsp)
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
leaq 0xaa0(%rdi), %r13
movq %r13, %rdi
callq 0x180e2
leaq 0xaa8(%r14), %rbp
cmpq %rbp, %rax
je 0xe6d7
movq %r13, %rdi
movq %r15, %rsi
callq 0x180e2
cmpq %rbp, %rax
je 0xe6f6
leal -0x7(%rbx), %eax
cmpl $0x2, %eax
jb 0xe5f3
cmpl $0x1, %ebx
jne 0xe715
movq %r13, %rdi
movq %r12, %rsi
callq 0x167fa
movq (%rax), %rbp
movq %r13, %rdi
movq %r15, %rsi
callq 0x167fa
movq (%rax), %r13
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0xa4a2
leaq 0x48(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq 0x38(%rsp), %rdi
callq 0xa4a2
movq %rbp, %rdi
callq 0xad7e
movsd %xmm0, 0x28(%rsp)
movq %r13, %rdi
callq 0xad7e
movsd 0x28(%rsp), %xmm1
addsd %xmm0, %xmm1
leaq 0x8(%rsp), %rsi
leaq 0x38(%rsp), %rdx
movsd 0x1bc6a(%rip), %xmm3    # 0x2a2e8
xorps %xmm2, %xmm2
movq %r14, %rdi
movapd %xmm1, %xmm0
movl %ebx, %ecx
movsd 0x30(%rsp), %xmm1
callq 0xe466
movq 0x38(%rsp), %rdi
cmpq %r12, %rdi
je 0xe6ac
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x6310
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xe6c8
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6310
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1bcfd(%rip), %rdi     # 0x2a3db
leaq 0x1bcc2(%rip), %rsi     # 0x2a3a7
leaq 0x1bd97(%rip), %rcx     # 0x2a483
movl $0x3f, %edx
callq 0x6210
leaq 0x1bd5f(%rip), %rdi     # 0x2a45c
leaq 0x1bca3(%rip), %rsi     # 0x2a3a7
leaq 0x1bd78(%rip), %rcx     # 0x2a483
movl $0x40, %edx
callq 0x6210
leaq 0x1bdb4(%rip), %rdi     # 0x2a4d0
leaq 0x1bc84(%rip), %rsi     # 0x2a3a7
leaq 0x1bd59(%rip), %rcx     # 0x2a483
movl $0x41, %edx
callq 0x6210
movq %rax, %rbx
jmp 0xe753
movq %rax, %rbx
movq 0x38(%rsp), %rdi
cmpq %r12, %rdi
je 0xe753
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x6310
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xe76f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6310
movq %rbx, %rdi
callq 0x65b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/Chrom3D[P]Chrom3D/src/Model.cpp
// Function: Model::addInteractionDistanceConstraint(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, double, double)
void Model::addInteractionDistanceConstraint(string beadId1, string beadId2, double beadPairDesiredDistance, double springConstant /*=1*/) {
  assert(getBead.find(beadId1) != getBead.end()); 
  assert(getBead.find(beadId2) != getBead.end());

  Bead* b1 = getBead[beadId1];
  Bead* b2 = getBead[beadId2];
  this->addConstraint(beadId1, beadId2, b1->getRadius()+b2->getRadius() + beadPairDesiredDistance, INTERACTION_DIST, springConstant);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movsd %xmm1, 0x10(%rsp)
movsd %xmm0, 0x8(%rsp)
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
leaq 0xaa0(%rdi), %r15
movq %r15, %rdi
callq 0x180e2
leaq 0xaa8(%rbx), %r13
cmpq %r13, %rax
je 0xe8b4
movq %r15, %rdi
movq %r14, %rsi
callq 0x180e2
cmpq %r13, %rax
je 0xe8d3
movq %r15, %rdi
movq %r12, %rsi
callq 0x167fa
movq (%rax), %r13
movq %r15, %rdi
movq %r14, %rsi
callq 0x167fa
movq (%rax), %r15
leaq 0x48(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
leaq 0x38(%rsp), %rdi
callq 0xa4a2
leaq 0x28(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x18(%rsp), %rdi
callq 0xa4a2
movq %r13, %rdi
callq 0xad7e
movsd %xmm0, (%rsp)
movq %r15, %rdi
callq 0xad7e
movsd (%rsp), %xmm1
addsd %xmm0, %xmm1
addsd 0x8(%rsp), %xmm1
leaq 0x38(%rsp), %rsi
leaq 0x18(%rsp), %rdx
movsd 0x1ba8b(%rip), %xmm3    # 0x2a2e8
xorps %xmm2, %xmm2
movq %rbx, %rdi
movapd %xmm1, %xmm0
movl $0x9, %ecx
movsd 0x10(%rsp), %xmm1
callq 0xe466
movq 0x18(%rsp), %rdi
cmpq %r12, %rdi
je 0xe88e
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x6310
movq 0x38(%rsp), %rdi
cmpq %rbp, %rdi
je 0xe8a5
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x6310
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1bb20(%rip), %rdi     # 0x2a3db
leaq 0x1bae5(%rip), %rsi     # 0x2a3a7
leaq 0x1bc76(%rip), %rcx     # 0x2a53f
movl $0x49, %edx
callq 0x6210
leaq 0x1bb82(%rip), %rdi     # 0x2a45c
leaq 0x1bac6(%rip), %rsi     # 0x2a3a7
leaq 0x1bc57(%rip), %rcx     # 0x2a53f
movl $0x4a, %edx
callq 0x6210
movq %rax, %rbx
jmp 0xe911
movq %rax, %rbx
movq 0x18(%rsp), %rdi
cmpq %r12, %rdi
je 0xe911
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x6310
movq 0x38(%rsp), %rdi
cmpq %rbp, %rdi
je 0xe928
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x6310
movq %rbx, %rdi
callq 0x65b0
// File: /workspace/github_cpp_makefile_star2_O3/Chrom3D[P]Chrom3D/src/Model.cpp
// Function: Model::addInteractionLowerDistanceConstraint(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, double, double)
void Model::addInteractionLowerDistanceConstraint(string beadId1, string beadId2, double beadPairDesiredDistance, double springConstant /*=1*/) {
  assert(getBead.find(beadId1) != getBead.end()); 
  assert(getBead.find(beadId2) != getBead.end());

  Bead* b1 = getBead[beadId1];
  Bead* b2 = getBead[beadId2];
  this->addConstraint(beadId1, beadId2, b1->getRadius()+b2->getRadius() + beadPairDesiredDistance, INTERACTION_DIST, springConstant, 0, b1->getRadius()+b2->getRadius() + beadPairDesiredDistance);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movsd %xmm1, 0x20(%rsp)
movsd %xmm0, 0x18(%rsp)
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
leaq 0xaa0(%rdi), %r14
movq %r14, %rdi
callq 0x180e2
leaq 0xaa8(%rbx), %r15
cmpq %r15, %rax
je 0xea94
movq %r14, %rdi
movq %r12, %rsi
callq 0x180e2
cmpq %r15, %rax
je 0xeab3
movq %r14, %rdi
movq %r13, %rsi
callq 0x167fa
movq (%rax), %r15
movq %r14, %rdi
movq %r12, %rsi
callq 0x167fa
movq (%rax), %r14
leaq 0x58(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq (%r13), %rsi
movq 0x8(%r13), %rdx
addq %rsi, %rdx
leaq 0x48(%rsp), %rdi
callq 0xa4a2
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %rdi
callq 0xa4a2
movq %r15, %rdi
callq 0xad7e
movsd %xmm0, 0x10(%rsp)
movq %r14, %rdi
callq 0xad7e
movsd %xmm0, 0x8(%rsp)
movq %r15, %rdi
callq 0xad7e
movsd %xmm0, (%rsp)
movq %r14, %rdi
callq 0xad7e
movsd 0x10(%rsp), %xmm4
addsd 0x8(%rsp), %xmm4
movsd 0x18(%rsp), %xmm1
addsd %xmm1, %xmm4
movsd (%rsp), %xmm3
addsd %xmm0, %xmm3
addsd %xmm1, %xmm3
leaq 0x48(%rsp), %rsi
leaq 0x28(%rsp), %rdx
xorps %xmm2, %xmm2
movq %rbx, %rdi
movapd %xmm4, %xmm0
movl $0x9, %ecx
movsd 0x20(%rsp), %xmm1
callq 0xe466
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0xea6e
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x6310
movq 0x48(%rsp), %rdi
cmpq %rbp, %rdi
je 0xea85
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x6310
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1b940(%rip), %rdi     # 0x2a3db
leaq 0x1b905(%rip), %rsi     # 0x2a3a7
leaq 0x1bae3(%rip), %rcx     # 0x2a58c
movl $0x53, %edx
callq 0x6210
leaq 0x1b9a2(%rip), %rdi     # 0x2a45c
leaq 0x1b8e6(%rip), %rsi     # 0x2a3a7
leaq 0x1bac4(%rip), %rcx     # 0x2a58c
movl $0x54, %edx
callq 0x6210
movq %rax, %rbx
jmp 0xeaf1
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0xeaf1
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x6310
movq 0x48(%rsp), %rdi
cmpq %rbp, %rdi
je 0xeb08
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x6310
movq %rbx, %rdi
callq 0x65b0
// File: /workspace/github_cpp_makefile_star2_O3/Chrom3D[P]Chrom3D/src/Model.cpp
// Function: Model::addInteractionUpperDistanceConstraint(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, double, double)
void Model::addInteractionUpperDistanceConstraint(string beadId1, string beadId2, double beadPairDesiredDistance, double springConstant /*=1*/) {
  assert(getBead.find(beadId1) != getBead.end()); 
  assert(getBead.find(beadId2) != getBead.end());

  Bead* b1 = getBead[beadId1];
  Bead* b2 = getBead[beadId2];
  this->addConstraint(beadId1, beadId2, b1->getRadius()+b2->getRadius() + beadPairDesiredDistance, INTERACTION_DIST, springConstant, b1->getRadius()+b2->getRadius() + beadPairDesiredDistance);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movsd %xmm1, 0x20(%rsp)
movsd %xmm0, 0x18(%rsp)
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
leaq 0xaa0(%rdi), %r14
movq %r14, %rdi
callq 0x180e2
leaq 0xaa8(%rbx), %r15
cmpq %r15, %rax
je 0xec79
movq %r14, %rdi
movq %r12, %rsi
callq 0x180e2
cmpq %r15, %rax
je 0xec98
movq %r14, %rdi
movq %r13, %rsi
callq 0x167fa
movq (%rax), %r15
movq %r14, %rdi
movq %r12, %rsi
callq 0x167fa
movq (%rax), %r14
leaq 0x58(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq (%r13), %rsi
movq 0x8(%r13), %rdx
addq %rsi, %rdx
leaq 0x48(%rsp), %rdi
callq 0xa4a2
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %rdi
callq 0xa4a2
movq %r15, %rdi
callq 0xad7e
movsd %xmm0, 0x10(%rsp)
movq %r14, %rdi
callq 0xad7e
movsd %xmm0, 0x8(%rsp)
movq %r15, %rdi
callq 0xad7e
movsd %xmm0, (%rsp)
movq %r14, %rdi
callq 0xad7e
movsd 0x10(%rsp), %xmm4
addsd 0x8(%rsp), %xmm4
movsd 0x18(%rsp), %xmm1
addsd %xmm1, %xmm4
movsd (%rsp), %xmm2
addsd %xmm0, %xmm2
addsd %xmm1, %xmm2
leaq 0x48(%rsp), %rsi
leaq 0x28(%rsp), %rdx
movsd 0x1b6c3(%rip), %xmm3    # 0x2a2e8
movq %rbx, %rdi
movapd %xmm4, %xmm0
movl $0x9, %ecx
movsd 0x20(%rsp), %xmm1
callq 0xe466
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0xec53
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x6310
movq 0x48(%rsp), %rdi
cmpq %rbp, %rdi
je 0xec6a
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x6310
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1b75b(%rip), %rdi     # 0x2a3db
leaq 0x1b720(%rip), %rsi     # 0x2a3a7
leaq 0x1b950(%rip), %rcx     # 0x2a5de
movl $0x5c, %edx
callq 0x6210
leaq 0x1b7bd(%rip), %rdi     # 0x2a45c
leaq 0x1b701(%rip), %rsi     # 0x2a3a7
leaq 0x1b931(%rip), %rcx     # 0x2a5de
movl $0x5d, %edx
callq 0x6210
movq %rax, %rbx
jmp 0xecd6
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0xecd6
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x6310
movq 0x48(%rsp), %rdi
cmpq %rbp, %rdi
je 0xeced
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x6310
movq %rbx, %rdi
callq 0x65b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/Chrom3D[P]Chrom3D/src/Model.cpp
// Function: Model::addNucleusConstraint(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, double)
void Model::addNucleusConstraint(string beadId, double springConstant /*=1*/) {
  assert(getBead.find(beadId) != getBead.end()); 
  assert(this->hasNucleus);
  Bead* b1 = getBead[beadId];  
  this->addConstraint(Constraint(b1, &(this->centerBead), this->nucleusRadius - b1->getRadius(), NUCLEUS, springConstant, this->nucleusRadius - b1->getRadius()));
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x88, %rsp
movsd %xmm0, 0x48(%rsp)
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xaa0(%rdi), %r15
movq %r15, %rdi
callq 0x180e2
leaq 0xaa8(%rbx), %rcx
cmpq %rcx, %rax
je 0xeed3
cmpb $0x0, 0xa90(%rbx)
je 0xeef2
movq %r15, %rdi
movq %r14, %rsi
callq 0x167fa
movq (%rax), %r14
leaq 0xad0(%rbx), %r15
movsd 0xa98(%rbx), %xmm0
movsd %xmm0, 0x38(%rsp)
movq %r14, %rdi
callq 0xad7e
movsd 0x38(%rsp), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, 0x38(%rsp)
movsd 0xa98(%rbx), %xmm0
movsd %xmm0, 0x40(%rsp)
movq %r14, %rdi
callq 0xad7e
movsd 0x40(%rsp), %xmm2
subsd %xmm0, %xmm2
leaq 0x50(%rsp), %r12
movsd 0x1b474(%rip), %xmm3    # 0x2a2e8
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
movsd 0x38(%rsp), %xmm0
movl $0x3, %ecx
movsd 0x48(%rsp), %xmm1
callq 0xdda0
movq 0x30(%r12), %rax
movq %rax, 0x30(%rsp)
movups (%r12), %xmm0
movups 0x10(%r12), %xmm1
movups 0x20(%r12), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0xe3a8
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x1b756(%rip), %rdi     # 0x2a630
leaq 0x1b4c6(%rip), %rsi     # 0x2a3a7
leaq 0x1b7a8(%rip), %rcx     # 0x2a690
movl $0x6e, %edx
callq 0x6210
leaq 0x1b7c8(%rip), %rdi     # 0x2a6c1
leaq 0x1b4a7(%rip), %rsi     # 0x2a3a7
leaq 0x1b789(%rip), %rcx     # 0x2a690
movl $0x6f, %edx
callq 0x6210
nop
// File: /workspace/github_cpp_makefile_star2_O3/Chrom3D[P]Chrom3D/src/Model.cpp
// Function: Model::addPeripheryConstraint(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, double)
void Model::addPeripheryConstraint(string beadId, double springConstant /*=1*/) {
  assert(this->hasNucleus);
  assert(getBead.find(beadId) != getBead.end()); 
  Bead* b1 = getBead[beadId];  
  this->addConstraint(Constraint(b1, &(this->centerBead), this->nucleusRadius - b1->getRadius(), PERIPHERY, springConstant));
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x88, %rsp
movsd %xmm0, 0x48(%rsp)
cmpb $0x0, 0xa90(%rdi)
je 0xeffa
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xaa0(%rdi), %r15
movq %r15, %rdi
callq 0x180e2
leaq 0xaa8(%rbx), %rcx
cmpq %rcx, %rax
je 0xf019
movq %r15, %rdi
movq %r14, %rsi
callq 0x167fa
movq (%rax), %r14
leaq 0xad0(%rbx), %r15
movsd 0xa98(%rbx), %xmm0
movsd %xmm0, 0x40(%rsp)
movq %r14, %rdi
callq 0xad7e
movsd 0x40(%rsp), %xmm1
subsd %xmm0, %xmm1
leaq 0x50(%rsp), %r12
movsd 0x1b34e(%rip), %xmm3    # 0x2a2e8
xorps %xmm2, %xmm2
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
movapd %xmm1, %xmm0
movl $0x2, %ecx
movsd 0x48(%rsp), %xmm1
callq 0xdda0
movq 0x30(%r12), %rax
movq %rax, 0x30(%rsp)
movups (%r12), %xmm0
movups 0x10(%r12), %xmm1
movups 0x20(%r12), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0xe3a8
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x1b6c0(%rip), %rdi     # 0x2a6c1
leaq 0x1b39f(%rip), %rsi     # 0x2a3a7
leaq 0x1b6c3(%rip), %rcx     # 0x2a6d2
movl $0x75, %edx
callq 0x6210
leaq 0x1b610(%rip), %rdi     # 0x2a630
leaq 0x1b380(%rip), %rsi     # 0x2a3a7
leaq 0x1b6a4(%rip), %rcx     # 0x2a6d2
movl $0x76, %edx
callq 0x6210
// File: /workspace/github_cpp_makefile_star2_O3/Chrom3D[P]Chrom3D/src/Model.cpp
// Function: Model::reweightConstraints(ConstraintType, double)
void Model::reweightConstraints(ConstraintType ct, double newSpringConstant) {
  map<string,vector<Constraint> >::iterator cm_it;
  vector<Constraint>::iterator c_it;   
  for(cm_it = constraints.begin(); cm_it != constraints.end(); cm_it++) {
      for(c_it = cm_it->second.begin(); c_it != cm_it->second.end();c_it++) {
        if(c_it->constType == ct) {
	  c_it->k = newSpringConstant;
      }
    }
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0xa00(%rdi), %rax
addq $0x9f0, %r14            # imm = 0x9F0
cmpq %r14, %rax
je 0xf18a
movl %esi, %ebx
movsd %xmm0, (%rsp)
movq 0x40(%rax), %rcx
movq 0x48(%rax), %rdx
cmpq %rdx, %rcx
je 0xf178
cmpl %ebx, 0x10(%rcx)
jne 0xf172
movsd %xmm0, 0x18(%rcx)
addq $0x38, %rcx
jmp 0xf163
movq %rax, %rdi
callq 0x6250
movsd (%rsp), %xmm0
cmpq %r14, %rax
jne 0xf15b
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/Chrom3D[P]Chrom3D/src/Model.cpp
// Function: Model::interactionWeightsSpecifiedSymmetricly(std::map<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, double, std::less<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, std::allocator<std::pair<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const, double>>>&)
double Model::getLossScore() {
  map<string,vector<Constraint> >::iterator it1;
  vector<Constraint>::iterator it2;  
  double res = 0;
  string constraintType;
  for(it1 = constraints.begin(); it1 != constraints.end(); it1++) {
      for(it2 = it1->second.begin(); it2 != it1->second.end(); it2++) {
	constraintType = it2->getConstraintType();
	if(constraintType == "INTERACTION" || constraintType == "INTERACTION_DIST" || constraintType == "INTERACTION_INTRA" || constraintType == "INTERACTION_INTER") {
	  res += it2->eval()/2;
	}
	else {
	  res += it2->eval();
	}
      }
  }
  return res; 
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
leaq 0x18(%rsp), %rcx
movq %rcx, -0x10(%rcx)
xorl %eax, %eax
movq %rax, -0x8(%rcx)
movb %al, (%rcx)
leaq 0x38(%rsp), %rdx
movq %rdx, -0x10(%rdx)
movq %rax, -0x8(%rdx)
movb %al, (%rdx)
movq 0x18(%rsi), %r14
leaq 0x8(%rsi), %r15
cmpq %r15, %r14
je 0x158af
movq %rsi, %rbx
leaq 0x58(%rsp), %r12
leaq 0x48(%rsp), %r13
leaq 0x8(%rsp), %rbp
leaq 0x20(%r14), %rdx
leaq 0x40(%r14), %rsi
movq %r13, %rdi
callq 0x1730c
movq %rbp, %rdi
movq %r13, %rsi
callq 0x63b0
leaq 0x28(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x63b0
movq 0x68(%rsp), %rdi
leaq 0x78(%rsp), %rax
cmpq %rax, %rdi
je 0x15824
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x6310
movq 0x48(%rsp), %rdi
cmpq %r12, %rdi
je 0x1583b
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x6310
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x1ab62
cmpq %r15, %rax
je 0x1588a
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x16c94
movsd (%rax), %xmm0
subsd 0x60(%r14), %xmm0
andpd 0x14ac8(%rip), %xmm0    # 0x2a330
ucomisd 0x14aa0(%rip), %xmm0    # 0x2a310
ja 0x1588a
movq %r14, %rdi
callq 0x6250
movq %rax, %r14
cmpq %r15, %rax
jne 0x157de
movb $0x1, %bl
jmp 0x1588c
xorl %ebx, %ebx
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x158a8
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x6310
leaq 0x18(%rsp), %rcx
jmp 0x158b1
movb $0x1, %bl
movq 0x8(%rsp), %rdi
cmpq %rcx, %rdi
je 0x158c8
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6310
movl %ebx, %eax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x158e0
jmp 0x158e0
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x167c4
movq %rbx, %rdi
callq 0x65b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/Chrom3D[P]Chrom3D/src/Model.cpp
// Function: weightedSamplePos(std::vector<double, std::allocator<double>>, boost::random::mersenne_twister_engine<unsigned int, 32ul, 624ul, 397ul, 31ul, 2567483615u, 11ul, 4294967295u, 7ul, 2636928640u, 15ul, 4022730752u, 18ul, 1812433253u>&)
uint weightedSamplePos(std::vector<double> weights, ENG &eng) {  
  std::vector<double> cumSumWeights(0, weights.size());
  double weightSum = accumulate(weights.begin(), weights.end(), 0);
  partial_sum(weights.begin(), weights.end(), weights.begin());
  double rnd = util::unif_real(0.0,weightSum, eng);
  uint pos = std::lower_bound(weights.begin(), weights.end(), rnd) - weights.begin();
  return pos;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rcx
movq 0x8(%rdi), %rax
cmpq %rax, %rcx
je 0xfe04
xorl %edx, %edx
movq %rcx, %rdi
xorps %xmm0, %xmm0
cvtsi2sd %edx, %xmm0
addsd (%rdi), %xmm0
cvttsd2si %xmm0, %edx
addq $0x8, %rdi
cmpq %rax, %rdi
jne 0xfdc8
cvtsi2sd %edx, %xmm1
leaq 0x8(%rcx), %rdx
cmpq %rax, %rdx
je 0xfe08
movsd (%rcx), %xmm0
addsd (%rdx), %xmm0
movsd %xmm0, (%rdx)
addq $0x8, %rdx
cmpq %rax, %rdx
jne 0xfdf1
jmp 0xfe08
xorpd %xmm1, %xmm1
xorpd %xmm0, %xmm0
movq %rsi, %rdi
callq 0x72c4
movq (%rbx), %rcx
movq 0x8(%rbx), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
movq %rcx, %rax
testq %rdx, %rdx
jle 0xfe4d
movq %rdx, %rsi
shrq %rsi
ucomisd (%rax,%rsi,8), %xmm0
jbe 0xfe45
leaq (%rax,%rsi,8), %rax
addq $0x8, %rax
notq %rsi
addq %rdx, %rsi
movq %rsi, %rdx
testq %rsi, %rsi
jg 0xfe2d
subq %rcx, %rax
shrq $0x3, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/Chrom3D[P]Chrom3D/src/Model.cpp
// Function: Model::writeCMM(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Model::writeCMM(string fileName) {
  std::ofstream myfile;
  myfile.open(fileName.c_str());
  myfile << this->getCMM();
  myfile.close();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x220, %rsp            # imm = 0x220
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0x6540
movq (%r14), %rsi
movq %r15, %rdi
movl $0x10, %edx
callq 0x6050
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x10e64
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
leaq 0x20(%rsp), %rdi
callq 0x6370
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x115b6
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6310
leaq 0x20(%rsp), %rdi
callq 0x6410
movq 0x26981(%rip), %rax     # 0x37f48
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 0x62d0
leaq 0x118(%rsp), %rdi
callq 0x6120
addq $0x220, %rsp            # imm = 0x220
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x11624
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6310
jmp 0x11624
jmp 0x11621
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x6450
movq %rbx, %rdi
callq 0x65b0
// File: /workspace/github_cpp_makefile_star2_O3/Chrom3D[P]Chrom3D/src/Model.cpp
// Function: Model::rescaleBeadSizes(double)
void Model::rescaleBeadSizes(double occupancyFactor) {
  assert(this->hasNucleus);
  vector<Chromosome>::iterator chriter;
  boost::container::static_vector<Bead,MAXSIZE>::iterator beaditer;
  double beadVol = this->getTotalBeadVolume();
  double genomeLength = this->getTotalGenomeLength();
  for(chriter = chromosomes.begin(); chriter != chromosomes.end(); chriter++) {
    for(beaditer=chriter->begin(); beaditer!=chriter->end(); beaditer++) {
      double newRadius = pow((occupancyFactor * (beaditer->getBpSpan()) / (genomeLength)),1/3.0) * (this->nucleusRadius);
      beaditer->setRadius(newRadius);
    }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movsd %xmm0, 0x10(%rsp)
cmpb $0x0, 0xa90(%rdi)
je 0x15558
movq %rdi, %rbx
callq 0x16498
movq %rbx, %rdi
callq 0x16548
movsd %xmm0, 0x8(%rsp)
movq 0xa78(%rbx), %r14
cmpq 0xa80(%rbx), %r14
je 0x1554c
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xb164
movq (%rsp), %r12
movq %r15, %rdi
movq %r14, %rsi
callq 0xb170
cmpq (%rsp), %r12
je 0x1553c
movq %r12, %rdi
callq 0xad84
movl %eax, %eax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
mulsd 0x10(%rsp), %xmm0
divsd 0x8(%rsp), %xmm0
movsd 0x14de7(%rip), %xmm1    # 0x2a308
callq 0x6590
mulsd 0xa98(%rbx), %xmm0
movq %r12, %rdi
callq 0xad66
addq $0x60, %r12
jmp 0x154ea
addq $0x75330, %r14          # imm = 0x75330
cmpq 0xa80(%rbx), %r14
jne 0x154db
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x15162(%rip), %rdi     # 0x2a6c1
leaq 0x14e41(%rip), %rsi     # 0x2a3a7
leaq 0x158be(%rip), %rcx     # 0x2ae2b
movl $0x3c2, %edx            # imm = 0x3C2
callq 0x6210
nop
// File: /workspace/github_cpp_makefile_star2_O3/Chrom3D[P]Chrom3D/src/Model.cpp
// Function: Model::addNucleusConstraints(double)
void Model::addNucleusConstraints(double springConstant /*=1*/) {
  assert(this->hasNucleus);
  vector<Chromosome>::iterator chriter;
  boost::container::static_vector<Bead,MAXSIZE>::iterator beaditer;  
  for(chriter = chromosomes.begin(); chriter != chromosomes.end(); chriter++) {
    for(beaditer=chriter->begin(); beaditer!=chriter->end(); beaditer++) {
      this->addNucleusConstraint(beaditer->getID(),springConstant);
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movsd %xmm0, 0x10(%rsp)
cmpb $0x0, 0xa90(%rdi)
je 0x15f61
movq %rdi, %rbx
movq 0xa78(%rdi), %r14
cmpq 0xa80(%rdi), %r14
je 0x15f52
leaq 0x28(%rsp), %rbp
leaq 0x8(%rsp), %r15
leaq 0x18(%rsp), %r12
movq %r15, %rdi
movq %r14, %rsi
callq 0xb164
movq 0x8(%rsp), %r13
movq %r15, %rdi
movq %r14, %rsi
callq 0xb170
cmpq 0x8(%rsp), %r13
je 0x15f42
movq %r12, %rdi
movq %r13, %rsi
callq 0xad90
movq %rbx, %rdi
movq %r12, %rsi
movsd 0x10(%rsp), %xmm0
callq 0xedc6
movq 0x18(%rsp), %rdi
cmpq %rbp, %rdi
je 0x15f3c
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x6310
addq $0x60, %r13
jmp 0x15ef7
addq $0x75330, %r14          # imm = 0x75330
cmpq 0xa80(%rbx), %r14
jne 0x15ee7
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x14759(%rip), %rdi     # 0x2a6c1
leaq 0x14438(%rip), %rsi     # 0x2a3a7
leaq 0x14e62(%rip), %rcx     # 0x2add8
movl $0x372, %edx            # imm = 0x372
callq 0x6210
movq %rax, %rbx
movq 0x18(%rsp), %rdi
cmpq %rbp, %rdi
je 0x15f9a
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x6310
movq %rbx, %rdi
callq 0x65b0
// File: /workspace/github_cpp_makefile_star2_O3/Chrom3D[P]Chrom3D/src/Model.cpp
// Function: Model::addCenterConstraints(double)
void Model::addCenterConstraints(double springConstant /*=1*/) {
  assert(this->hasNucleus);
  vector<Chromosome>::iterator chriter;
  boost::container::static_vector<Bead,MAXSIZE>::iterator beaditer;  
  for(chriter = chromosomes.begin(); chriter != chromosomes.end(); chriter++) {
    for(beaditer=chriter->begin(); beaditer!=chriter->end(); beaditer++) {
      this->addCenterConstraint(beaditer->getID(), springConstant);
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movsd %xmm0, 0x10(%rsp)
cmpb $0x0, 0xa90(%rdi)
je 0x1605f
movq %rdi, %rbx
movq 0xa78(%rdi), %r14
cmpq 0xa80(%rdi), %r14
je 0x16050
leaq 0x28(%rsp), %rbp
leaq 0x8(%rsp), %r15
leaq 0x18(%rsp), %r12
movq %r15, %rdi
movq %r14, %rsi
callq 0xb164
movq 0x8(%rsp), %r13
movq %r15, %rdi
movq %r14, %rsi
callq 0xb170
cmpq 0x8(%rsp), %r13
je 0x16040
movq %r12, %rdi
movq %r13, %rsi
callq 0xad90
movq %rbx, %rdi
movq %r12, %rsi
movsd 0x10(%rsp), %xmm0
callq 0xf038
movq 0x18(%rsp), %rdi
cmpq %rbp, %rdi
je 0x1603a
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x6310
addq $0x60, %r13
jmp 0x15ff5
addq $0x75330, %r14          # imm = 0x75330
cmpq 0xa80(%rbx), %r14
jne 0x15fe5
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1465b(%rip), %rdi     # 0x2a6c1
leaq 0x1433a(%rip), %rsi     # 0x2a3a7
leaq 0x14d8e(%rip), %rcx     # 0x2ae02
movl $0x38a, %edx            # imm = 0x38A
callq 0x6210
movq %rax, %rbx
movq 0x18(%rsp), %rdi
cmpq %rbp, %rdi
je 0x16098
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x6310
movq %rbx, %rdi
callq 0x65b0
// File: /workspace/github_cpp_makefile_star2_O3/Chrom3D[P]Chrom3D/src/MCMC.cpp
// Function: MCMC::doMetropolisHastingsStep(double, unsigned int)
bool MCMC::doMetropolisHastingsStep(double T /*=1*/, uint maxAttempts /*=10000*/) {
  uint i=0;
  bool success = false;
  while(i < maxAttempts and !success) {
    try {
      Move proposedMove = model.proposeMove(); // Idea: if this fails (no move proposed), we could set the proposed Move to the same (identity) move.
      double before = model.getPartialLossScore(proposedMove.chr, proposedMove.start, proposedMove.stop); // score before move
      Move oldCoords = model.accept(proposedMove); //, true);
      double after = model.getPartialLossScore(proposedMove.chr, proposedMove.start, proposedMove.stop); // score after move
      if(after > before) {
	double pAccept = exp((before-after)/T);
	bool accept = util::unif_real(0,1, model.randEngine) < pAccept;
	if(not accept) {
	  Move tmp = model.accept(oldCoords); //, true); // roll back to previous coordinates.
	}
      }
      success = true;
    }
    catch(util::MoveException& e){
      i++;
    }
  }
  return success;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movsd %xmm0, 0x18(%rsp)
xorl %ebp, %ebp
testl %esi, %esi
je 0x1aee8
movl %esi, %ebx
movq %rdi, %r14
leaq 0x20(%rsp), %r15
leaq 0x58(%rsp), %r12
leaq 0x90(%rsp), %r13
movq (%r14), %rsi
movq %r15, %rdi
movl $0x1, %edx
callq 0xfc0c
movq (%r14), %rdi
movq 0x20(%rsp), %rsi
movl 0x28(%rsp), %edx
movl 0x2c(%rsp), %ecx
callq 0xf7c4
movsd %xmm0, 0x8(%rsp)
movq (%r14), %rsi
movq %r12, %rdi
movq %r15, %rdx
callq 0x10420
movq (%r14), %rdi
movq 0x20(%rsp), %rsi
movl 0x28(%rsp), %edx
movl 0x2c(%rsp), %ecx
callq 0xf7c4
movsd 0x8(%rsp), %xmm1
ucomisd %xmm1, %xmm0
jbe 0x1aeae
subsd %xmm0, %xmm1
divsd 0x18(%rsp), %xmm1
movapd %xmm1, %xmm0
callq 0x65c0
movsd %xmm0, 0x8(%rsp)
movq (%r14), %rdi
addq $0x20, %rdi
xorpd %xmm0, %xmm0
movsd 0xe226(%rip), %xmm1     # 0x29008
callq 0x72c4
movsd 0x8(%rsp), %xmm1
ucomisd %xmm0, %xmm1
ja 0x1aeae
movq (%r14), %rsi
movq %r13, %rdi
movq %r12, %rdx
callq 0x10420
jmp 0x1ae90
jmp 0x1ae28
jmp 0x1ae28
jmp 0x1ae10
movq %rdx, 0x10(%rsp)
movq %rax, 0x8(%rsp)
jmp 0x1ae50
movq %rdx, 0x10(%rsp)
movq %rax, 0x8(%rsp)
jmp 0x1ae68
movq %rdx, 0x10(%rsp)
movq %rax, 0x8(%rsp)
movq 0x80(%rsp), %rsi
testq %rsi, %rsi
je 0x1ae50
movq 0x88(%rsp), %rdi
shlq $0x3, %rsi
callq 0x6310
movq 0x48(%rsp), %rsi
testq %rsi, %rsi
je 0x1ae68
movq 0x50(%rsp), %rdi
shlq $0x3, %rsi
callq 0x6310
cmpl $0x1, 0x10(%rsp)
jne 0x1aefc
movq 0x8(%rsp), %rdi
callq 0x6160
incl %ebp
callq 0x64f0
xorl %eax, %eax
cmpl %ebx, %ebp
jb 0x1ad58
jmp 0x1aeea
movq 0xb8(%rsp), %rsi
testq %rsi, %rsi
je 0x1aeae
movq 0xc0(%rsp), %rdi
shlq $0x3, %rsi
callq 0x6310
movq 0x80(%rsp), %rsi
testq %rsi, %rsi
je 0x1aecc
movq 0x88(%rsp), %rdi
shlq $0x3, %rsi
callq 0x6310
movq 0x48(%rsp), %rsi
testq %rsi, %rsi
je 0x1aee4
movq 0x50(%rsp), %rdi
shlq $0x3, %rsi
callq 0x6310
movb $0x1, %al
jmp 0x1aeea
xorl %eax, %eax
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%rsp), %rdi
callq 0x65b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/Chrom3D[P]Chrom3D/src/tclap-1.2.1/include/tclap/SwitchArg.h
// Function: TCLAP::SwitchArg::commonProcessing()
inline void SwitchArg::commonProcessing()
{
	if ( _xorSet )
		throw(CmdLineParseException(
		      "Mutually exclusive argument already set!", toString()));

	if ( _alreadySet ) 
		throw(CmdLineParseException("Argument already set!", toString()));

	_alreadySet = true;

	if ( _value == true )
		_value = false;
	else
		_value = true;

	_checkWithVisitor();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r14
cmpb $0x1, 0xa1(%rdi)
je 0x1e23d
cmpb $0x1, 0x91(%r14)
je 0x1e2a8
movb $0x1, 0x91(%r14)
xorb $0x1, 0xa3(%r14)
movq 0x98(%r14), %rdi
testq %rdi, %rdi
je 0x1e232
movq (%rdi), %rax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmpq *0x10(%rax)
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x68, %edi
callq 0x61a0
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xd821(%rip), %rsi      # 0x2ba7b
leaq 0xd842(%rip), %rdx      # 0x2baa3
leaq 0x8(%rsp), %rdi
callq 0xdf94
movq (%r14), %rax
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
callq *0x38(%rax)
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
leaq 0x28(%rsp), %rdx
movq %rbx, %rdi
callq 0x1e520
xorl %ebp, %ebp
leaq 0x19311(%rip), %rsi     # 0x375a8
leaq 0x6d50(%rip), %rdx      # 0x24fee
movq %rbx, %rdi
callq 0x6550
jmp 0x1e311
movl $0x68, %edi
callq 0x61a0
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xd043(%rip), %rsi      # 0x2b308
leaq 0xd051(%rip), %rdx      # 0x2b31d
leaq 0x8(%rsp), %rdi
callq 0xdf94
movq (%r14), %rax
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
callq *0x38(%rax)
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
leaq 0x28(%rsp), %rdx
movq %rbx, %rdi
callq 0x1e520
xorl %ebp, %ebp
leaq 0x192a6(%rip), %rsi     # 0x375a8
leaq 0x6ce5(%rip), %rdx      # 0x24fee
movq %rbx, %rdi
callq 0x6550
jmp 0x1e315
jmp 0x1e351
movq %rax, %r14
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1e333
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x6310
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x1e34a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6310
testb %bpl, %bpl
jne 0x1e372
jmp 0x1e37a
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x1e372
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6310
jmp 0x1e372
jmp 0x1e36f
movq %rax, %r14
movq %rbx, %rdi
callq 0x6280
movq %r14, %rdi
callq 0x65b0
// File: /workspace/github_cpp_makefile_star2_O3/Chrom3D[P]Chrom3D/src/tclap-1.2.1/include/tclap/ValuesConstraint.h
// Function: TCLAP::ValuesConstraint<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::ValuesConstraint(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&)
ValuesConstraint<T>::ValuesConstraint(std::vector<T>& allowed)
: _allowed(allowed),
  _typeDesc("")
{ 
    for ( unsigned int i = 0; i < _allowed.size(); i++ )
    {

#if defined(HAVE_SSTREAM)
        std::ostringstream os;
#elif defined(HAVE_STRSTREAM)
        std::ostrstream os;
#else
#error "Need a stringstream (sstream or strstream) to compile!"
#endif

        os << _allowed[i];

        std::string temp( os.str() ); 

        if ( i > 0 )
			_typeDesc += "|";
        _typeDesc += temp;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rdi, %rbx
leaq 0x17c73(%rip), %rax     # 0x37c70
movq %rax, (%rdi)
leaq 0x8(%rdi), %r14
movq %r14, %rdi
callq 0x16a42
leaq 0x20(%rbx), %r15
leaq 0x30(%rbx), %rax
movq %rax, 0x28(%rsp)
movq %rax, 0x20(%rbx)
leaq 0xbe77(%rip), %rdx      # 0x2be9b
movq %r15, %rdi
movq %rdx, %rsi
callq 0xdf94
movq 0x10(%rbx), %rax
cmpq 0x8(%rbx), %rax
je 0x200f4
movl $0x1, %r12d
xorl %r13d, %r13d
leaq 0x30(%rsp), %rbp
movq %rbp, %rdi
callq 0x63e0
movq (%r14), %rax
shlq $0x5, %r13
movq (%rax,%r13), %rsi
movq 0x8(%rax,%r13), %rdx
movq %rbp, %rdi
callq 0x6370
leaq 0x8(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x64b0
cmpl $0x1, %r12d
je 0x2008f
movq %r15, %rdi
leaq 0xba8f(%rip), %rsi      # 0x2bb19
callq 0x6630
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r15, %rdi
callq 0x6110
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x200bd
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6310
movq %rbp, %rdi
movq 0x17ea9(%rip), %rsi     # 0x37f70
callq 0x61c0
leaq 0xa0(%rsp), %rdi
callq 0x6120
movq 0x10(%rbx), %rax
subq 0x8(%rbx), %rax
movl %r12d, %r13d
sarq $0x5, %rax
incl %r12d
cmpq %r13, %rax
ja 0x2004b
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r12
jmp 0x20171
movq %rax, %r12
jmp 0x20179
movq %rax, %r12
jmp 0x20159
jmp 0x20117
movq %rax, %r12
jmp 0x2013b
movq %rax, %r12
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x2013b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6310
movq 0x17e2e(%rip), %rsi     # 0x37f70
leaq 0x30(%rsp), %rdi
callq 0x61c0
leaq 0xa0(%rsp), %rdi
callq 0x6120
movq (%r15), %rdi
movq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x20171
movq (%rax), %rsi
incq %rsi
callq 0x6310
movq %r14, %rdi
callq 0x8860
leaq 0x17b50(%rip), %rax     # 0x37cd0
movq %rax, (%rbx)
movq %r12, %rdi
callq 0x65b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/Chrom3D[P]Chrom3D/src/tclap-1.2.1/include/tclap/StdOutput.h
// Function: TCLAP::StdOutput::version(TCLAP::CmdLineInterface&)
inline void StdOutput::version(CmdLineInterface& _cmd) 
{
	std::string progName = _cmd.getProgramName();
	std::string xversion = _cmd.getVersion();

	std::cout << std::endl << progName << "  version: " 
			  << xversion << std::endl << std::endl;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movq (%rsi), %rax
movq %rsi, %rdi
callq *0x50(%rax)
leaq 0x30(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
leaq 0x20(%rsp), %rdi
callq 0xa4a2
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x48(%rax)
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
movq %rsp, %rdi
callq 0xa4a2
movq 0x1640b(%rip), %rdi     # 0x37f80
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl $0xa, %esi
callq 0x62f0
movsbl %al, %esi
movq 0x163f0(%rip), %rdi     # 0x37f80
callq 0x6030
movq %rax, %rdi
callq 0x6240
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq %rax, %rdi
callq 0x6370
movq %rax, %rbx
leaq 0xa2bb(%rip), %rsi      # 0x2be74
movl $0xb, %edx
movq %rax, %rdi
callq 0x6370
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x6370
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x62f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x6030
movq %rax, %rdi
callq 0x6240
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x62f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x6030
movq %rax, %rdi
callq 0x6240
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x21c41
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6310
movq 0x20(%rsp), %rdi
cmpq %r14, %rdi
je 0x21c58
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x6310
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
jmp 0x21c80
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x21c80
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x6310
movq 0x20(%rsp), %rdi
cmpq %r14, %rdi
je 0x21c97
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x6310
movq %rbx, %rdi
callq 0x65b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/Chrom3D[P]Chrom3D/src/../src/tclap-1.2.1/include/tclap/CmdLine.h
// Function: TCLAP::CmdLine::setOutput(TCLAP::CmdLineOutput*)
inline void CmdLine::setOutput(CmdLineOutput* co)
{
	if ( !_userSetOutput )
		delete _output;
	_userSetOutput = true;
	_output = co;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x0, 0xd9(%rdi)
jne 0x22215
movq 0xd0(%r14), %rdi
testq %rdi, %rdi
je 0x22215
movq (%rdi), %rax
callq *0x8(%rax)
movb $0x1, 0xd9(%r14)
movq %rbx, 0xd0(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/Chrom3D[P]Chrom3D/src/tclap-1.2.1/include/tclap/UnlabeledValueArg.h
// Function: TCLAP::UnlabeledValueArg<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::processArg(int*, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&)
bool UnlabeledValueArg<T>::processArg(int *i, std::vector<std::string>& args) 
{
	
	if ( _alreadySet )
		return false;
	
	if ( _hasBlanks( args[*i] ) )
		return false;

	// never ignore an unlabeled arg
	
	_extractValue( args[*i] );
	_alreadySet = true;
	return true;
}

// Assembly:
cmpb $0x0, 0x91(%rdi)
je 0x278c4
xorl %eax, %eax
retq
pushq %rbx
movq %rdi, %rbx
movslq (%rsi), %rax
movq (%rdx), %rcx
shlq $0x5, %rax
leaq (%rcx,%rax), %rsi
movq 0x8(%rcx,%rax), %rax
cmpq $0x2, %rax
jb 0x2790a
movq (%rsi), %rcx
cmpb $0x7, 0x1(%rcx)
je 0x27906
movl $0x2, %edi
movq %rdi, %rdx
cmpq %rdi, %rax
je 0x27901
leaq 0x1(%rdx), %rdi
cmpb $0x7, (%rcx,%rdx)
jne 0x278ef
cmpq %rdx, %rax
jbe 0x2790a
xorl %eax, %eax
jmp 0x2791b
movq %rbx, %rdi
callq 0x2588c
movb $0x1, 0x91(%rbx)
movb $0x1, %al
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Chrom3D[P]Chrom3D/src/tclap-1.2.1/include/tclap/UnlabeledValueArg.h
// Function: TCLAP::UnlabeledValueArg<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::operator==(TCLAP::Arg const&) const
bool UnlabeledValueArg<T>::operator==(const Arg& a ) const
{
	if ( _name == a.getName() || _description == a.getDescription() )
		return true;
	else
		return false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r15
movq %rdi, %r14
movq 0x30(%rdi), %rdx
cmpq 0x30(%rsi), %rdx
jne 0x2794f
movb $0x1, %bl
testq %rdx, %rdx
je 0x279a7
movq 0x28(%r15), %rsi
movq 0x28(%r14), %rdi
callq 0x6320
testl %eax, %eax
je 0x279a7
movq %rsp, %rbx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x22a60
movq 0x50(%r14), %rdx
cmpq 0x8(%rbx), %rdx
jne 0x27983
movq (%rsp), %r15
testq %rdx, %rdx
je 0x2798b
movq 0x48(%r14), %rdi
movq %r15, %rsi
callq 0x6320
testl %eax, %eax
sete %bl
jmp 0x2798d
movq (%rsp), %r15
xorl %ebx, %ebx
jmp 0x2798d
movb $0x1, %bl
leaq 0x10(%rsp), %rax
cmpq %rax, %r15
je 0x279a7
movq 0x10(%rsp), %rsi
incq %rsi
movq %r15, %rdi
callq 0x6310
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Chrom3D[P]Chrom3D/src/tclap-1.2.1/include/tclap/UnlabeledValueArg.h
// Function: TCLAP::UnlabeledValueArg<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::longID(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
std::string UnlabeledValueArg<T>::longID(const std::string& val) const
{
	static_cast<void>(val); // Ignore input, don't warn

	// Ideally we would like to be able to use RTTI to return the name
	// of the type required for this argument.  However, g++ at least, 
	// doesn't appear to return terribly useful "names" of the types.  
	return std::string("<") + _typeDesc + ">";
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x433a(%rip), %rsi      # 0x2be6c
leaq 0x4334(%rip), %rdx      # 0x2be6d
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0xdf94
movq 0xe8(%r14), %rsi
movq 0xf0(%r14), %rdx
movq %r15, %rdi
callq 0x6110
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x27b83
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
jmp 0x27b8a
movups (%rcx), %xmm0
movups %xmm0, (%r14)
movq 0x8(%rax), %rdx
leaq 0x8(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x2c2c(%rip), %rsi      # 0x2a7d9
callq 0x6630
leaq 0x10(%rbx), %rdx
movq %rdx, (%rbx)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
je 0x27bd4
movq %rsi, (%rbx)
movq (%rcx), %rdx
movq %rdx, 0x10(%rbx)
jmp 0x27bda
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rbx)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x27c08
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6310
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x27c1f
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x6310
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x27c4d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6310
jmp 0x27c4d
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x27c64
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x6310
movq %rbx, %rdi
callq 0x65b0
// File: /workspace/github_cpp_makefile_star2_O3/QZzcoder[P]LiveChat/SocketManager.cpp
// Function: getSocket(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool)
int getSocket(int port,std::string ip,bool isServer){
    int socket_fd = socket(AF_INET, SOCK_STREAM,0);
    if(socket_fd == -1)
    {
        cout<<"socket 创建失败："<<endl;
        exit(-1);
    }
    struct sockaddr_in addr;
    addr.sin_family = AF_INET;
    addr.sin_port = htons(port);
    addr.sin_addr.s_addr = inet_addr(ip.c_str());
    bool nOptval = true;
    setsockopt(socket_fd,SOL_SOCKET,SO_REUSEADDR,(const void*)&nOptval,sizeof(bool));
    int res;
    if(!isServer){
        res = connect(socket_fd,(struct sockaddr*)&addr,sizeof(addr));
    }else{
        res = bind(socket_fd,(struct sockaddr*)&addr,sizeof(addr));
        listen(socket_fd,30);
    }
    if(res == -1){
        cout<<"bind 链接失败："<<endl;
        exit(-1);
    }
    return socket_fd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %edx, %r14d
movq %rsi, %r15
movl %edi, %r12d
movl $0x2, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x2070
cmpl $-0x1, %eax
je 0x2d8e
movl %eax, %ebx
movw $0x2, -0x34(%rbp)
rolw $0x8, %r12w
movw %r12w, -0x32(%rbp)
movq (%r15), %rdi
callq 0x21f0
movl %eax, -0x30(%rbp)
leaq -0x21(%rbp), %rcx
movb $0x1, (%rcx)
movl %ebx, %edi
movl $0x1, %esi
movl $0x2, %edx
movl $0x1, %r8d
callq 0x22d0
leaq -0x34(%rbp), %rsi
movl %ebx, %edi
movl $0x10, %edx
testb %r14b, %r14b
je 0x2d71
callq 0x2050
movl %eax, %r14d
movl %ebx, %edi
movl $0x1e, %esi
callq 0x2220
jmp 0x2d79
callq 0x2170
movl %eax, %r14d
cmpl $-0x1, %r14d
je 0x2d9e
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x323b(%rip), %rdi      # 0x5fd0
leaq 0x131d(%rip), %rsi      # 0x40b9
jmp 0x2dac
movq 0x322b(%rip), %rdi      # 0x5fd0
leaq 0x1324(%rip), %rsi      # 0x40d0
callq 0x21d0
movq %rax, %rdi
callq 0x20d0
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O3/QZzcoder[P]LiveChat/SocketManager.cpp
// Function: mySelect(fd_set&, std::set<int, std::less<int>, std::allocator<int>>, int)
int mySelect(fd_set& fds,set<int> fd,int usec){
    timeval timeout = {0};
    timeout.tv_usec = usec;
    FD_ZERO(&fds);
    int maxfd = 0;
    for(int i:fd){
        maxfd = maxfd>i?maxfd:i;
        FD_SET(i,&fds);
    }
    switch(select(maxfd+1,&fds,NULL,NULL,&timeout)){
        case -1:{
            cout<<"select error";
            exit(1);
        }case 0:break;
        default:{
            for(int i:fd){
                if(FD_ISSET(i,&fds)){
                    return i;
                }
            }
        }
    }
    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq $0x0, -0x30(%rbp)
movslq %edx, %rax
movq %rax, -0x28(%rbp)
xorps %xmm0, %xmm0
movups %xmm0, 0x70(%rdi)
movups %xmm0, 0x60(%rdi)
movups %xmm0, 0x50(%rdi)
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movq 0x18(%rsi), %rax
leaq 0x8(%rsi), %r12
cmpq %r12, %rax
je 0x2e56
xorl %r15d, %r15d
movl 0x20(%rax), %ecx
cmpl %ecx, %r15d
cmovlel %ecx, %r15d
leal 0x3f(%rcx), %edx
testl %ecx, %ecx
cmovnsl %ecx, %edx
movl %edx, %esi
andl $-0x40, %esi
subl %esi, %ecx
movl $0x1, %esi
shlq %cl, %rsi
sarl $0x6, %edx
movslq %edx, %rcx
orq %rsi, (%rbx,%rcx,8)
movq %rax, %rdi
callq 0x2240
cmpq %r12, %rax
jne 0x2e19
incl %r15d
jmp 0x2e5c
movl $0x1, %r15d
leaq -0x30(%rbp), %r8
movl %r15d, %edi
movq %rbx, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x21b0
testl %eax, %eax
je 0x2ea6
cmpl $-0x1, %eax
je 0x2eba
movq 0x18(%r14), %rax
cmpq %r12, %rax
je 0x2ea6
movl 0x20(%rax), %ecx
leal 0x3f(%rcx), %edx
testl %ecx, %ecx
cmovnsl %ecx, %edx
sarl $0x6, %edx
movslq %edx, %rdx
movq (%rbx,%rdx,8), %rdx
btq %rcx, %rdx
jb 0x2eab
movq %rax, %rdi
callq 0x2240
jmp 0x2e7c
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movl %ecx, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x310f(%rip), %rdi      # 0x5fd0
leaq 0x121d(%rip), %rsi      # 0x40e5
callq 0x21d0
movl $0x1, %edi
callq 0x2250