LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/Chrom3D[P]Chrom3D/src/Randomizer.cpp
// Function: TranslateRandomizer::randomize(Chromosome&, boost::random::mersenne_twister_engine<unsigned int, 32ul, 624ul, 397ul, 31ul, 2567483615u, 11ul, 4294967295u, 7ul, 2636928640u, 15ul, 4022730752u, 18ul, 1812433253u>&)
Move TranslateRandomizer::randomize(Chromosome &chr, ENG &eng) {
   
  CoordinateVector tvec(3);
  tvec(0) = util::unif_int(-this->maxmove, this->maxmove, eng);
  tvec(1) = util::unif_int(-this->maxmove, this->maxmove, eng);
  tvec(2) = util::unif_int(-this->maxmove, this->maxmove, eng);

  CoordinateMatrix mat = chr.translate(tvec);
  Move mov(chr);
  mov.start = 0;
  mov.stop = chr.size()-1;
  mov.mat = mat;
  return mov;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
pushq $0x3
popq %rsi
callq 0x7d3c
movsd 0x8(%r12), %xmm0
movapd 0x140fc(%rip), %xmm1    # 0x20040
xorpd %xmm0, %xmm1
cvttsd2si %xmm1, %rdi
cvttsd2si %xmm0, %rsi
movq %r15, %rdx
callq 0x6ebd
movl %eax, %ebp
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x8638
cvtsi2sd %ebp, %xmm0
movsd %xmm0, (%rax)
movsd 0x8(%r12), %xmm0
movapd 0x140c1(%rip), %xmm1    # 0x20040
xorpd %xmm0, %xmm1
cvttsd2si %xmm1, %rdi
cvttsd2si %xmm0, %rsi
movq %r15, %rdx
callq 0x6ebd
movl %eax, %ebp
leaq 0x8(%rsp), %rdi
pushq $0x1
popq %rsi
callq 0x8638
cvtsi2sd %ebp, %xmm0
movsd %xmm0, (%rax)
movsd 0x8(%r12), %xmm0
movapd 0x14085(%rip), %xmm1    # 0x20040
xorpd %xmm0, %xmm1
cvttsd2si %xmm1, %rdi
cvttsd2si %xmm0, %rsi
movq %r15, %rdx
callq 0x6ebd
movl %eax, %ebp
leaq 0x8(%rsp), %rdi
pushq $0x2
popq %rsi
callq 0x8638
cvtsi2sd %ebp, %xmm0
movsd %xmm0, (%rax)
leaq 0x20(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x8932
leaq 0x38(%rsp), %rdi
leaq 0x20(%rsp), %rdx
movq %r14, %rsi
callq 0xb0a2
leaq 0x20(%rsp), %rdi
callq 0x8012
movq %r14, (%rbx)
xorpd %xmm0, %xmm0
movupd %xmm0, 0x28(%rbx)
movupd %xmm0, 0x10(%rbx)
andl $0x0, 0x8(%rbx)
movq %r14, %rdi
callq 0xa75e
leaq 0x10(%rbx), %rdi
decl %eax
movl %eax, 0xc(%rbx)
leaq 0x38(%rsp), %rsi
callq 0xb528
leaq 0x48(%rsp), %rdi
callq 0x8012
leaq 0x8(%rsp), %rdi
callq 0x8012
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x20(%rsp), %rdi
jmp 0xc087
jmp 0xc08e
movq %rax, %r14
addq $0x20, %rbx
movq %rbx, %rdi
callq 0x8012
leaq 0x48(%rsp), %rdi
callq 0x8012
jmp 0xc091
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x8012
movq %r14, %rdi
callq 0x65d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/Chrom3D[P]Chrom3D/src/Randomizer.cpp
// Function: ArmRotateRandomizer::randomize(Chromosome&, boost::random::mersenne_twister_engine<unsigned int, 32ul, 624ul, 397ul, 31ul, 2567483615u, 11ul, 4294967295u, 7ul, 2636928640u, 15ul, 4022730752u, 18ul, 1812433253u>&)
Move ArmRotateRandomizer::randomize(Chromosome &chr, ENG &eng) {
  uint r1 = util::unif_int(1, chr.size()-2, eng);
  bool goRight = util::unif_int(0, 1, eng);
  double theta = util::unif_real(0.0, 2*util::PI-0.001, eng);
  
  CoordinateMatrix mat = chr.armRotate(r1, theta, goRight);
  Move mov(chr);
  if(goRight){
    mov.start = r1+1;
    mov.stop = chr.size()-1;
  } 
  else {
    mov.start = 0;
    mov.stop = r1-1;
  }
  mov.mat = mat;
  return mov;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r15
movq %rdx, %r14
movq %rdi, %rbx
movq %rdx, %rdi
callq 0xa75e
leal -0x2(%rax), %esi
pushq $0x1
popq %r12
movl %r12d, %edi
movq %r15, %rdx
callq 0x6ebd
movl %eax, %ebp
xorl %edi, %edi
movl %r12d, %esi
movq %r15, %rdx
callq 0x6ebd
movl %eax, %r12d
xorl %r13d, %r13d
testl %eax, %eax
setne %r13b
movsd 0x14d9e(%rip), %xmm1    # 0x211e8
xorps %xmm0, %xmm0
movq %r15, %rdi
callq 0x6e93
movq %rsp, %rdi
movq %r14, %rsi
movl %ebp, %edx
movl %r13d, %ecx
callq 0xadaa
movq %r14, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rbx)
movups %xmm0, 0x10(%rbx)
testl %r12d, %r12d
je 0xc489
incl %ebp
movl %ebp, 0x8(%rbx)
movq %r14, %rdi
callq 0xa75e
movl %eax, %ebp
jmp 0xc48d
andl $0x0, 0x8(%rbx)
leaq 0x10(%rbx), %rdi
decl %ebp
movl %ebp, 0xc(%rbx)
movq %rsp, %rsi
callq 0xb528
leaq 0x10(%rsp), %rdi
callq 0x8012
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
addq $0x20, %rbx
movq %rbx, %rdi
callq 0x8012
leaq 0x10(%rsp), %rdi
callq 0x8012
movq %r14, %rdi
callq 0x65d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/Chrom3D[P]Chrom3D/src/Randomizer.cpp
// Function: MicroCrankShaftRandomizer::randomize(Chromosome&, boost::random::mersenne_twister_engine<unsigned int, 32ul, 624ul, 397ul, 31ul, 2567483615u, 11ul, 4294967295u, 7ul, 2636928640u, 15ul, 4022730752u, 18ul, 1812433253u>&)
Move MicroCrankShaftRandomizer::randomize(Chromosome &chr, ENG &eng) {
  uint r1 = util::unif_int(0, chr.size()-3, eng);
  uint r2 = r1+2;
  double theta = util::unif_real(0.0, 2*util::PI-0.001, eng);
  CoordinateMatrix mat = chr.crankshaft(r1,r2,theta);
  Move mov(chr);
  mov.start = r1+1; // We return the positions of the start and end of the 
  mov.stop = r2-1;  //  beads that have their coords altered (so, r1 and r2 are not included in crankshaft)
  mov.mat = mat;
  return mov;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rcx, %r15
movq %rdx, %r14
movq %rdi, %rbx
movq %rdx, %rdi
callq 0xa75e
leal -0x3(%rax), %esi
xorl %edi, %edi
movq %r15, %rdx
callq 0x6ebd
movl %eax, %r12d
leal 0x2(%r12), %ebp
movsd 0x14cd2(%rip), %xmm1    # 0x211e8
xorps %xmm0, %xmm0
movq %r15, %rdi
callq 0x6e93
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movl %r12d, %edx
movl %ebp, %ecx
callq 0xab08
movq %r14, (%rbx)
leaq 0x10(%rbx), %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rbx)
movups %xmm0, 0x10(%rbx)
incl %r12d
movl %r12d, 0x8(%rbx)
movl %r12d, 0xc(%rbx)
movq %r15, %rsi
callq 0xb528
leaq 0x18(%rsp), %rdi
callq 0x8012
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
addq $0x20, %rbx
movq %rbx, %rdi
callq 0x8012
leaq 0x18(%rsp), %rdi
callq 0x8012
movq %r14, %rdi
callq 0x65d0
// File: /workspace/github_cpp_makefile_star2_O2/Chrom3D[P]Chrom3D/src/Randomizer.cpp
// Function: RotationRandomizer::randomize(Chromosome&, boost::random::mersenne_twister_engine<unsigned int, 32ul, 624ul, 397ul, 31ul, 2567483615u, 11ul, 4294967295u, 7ul, 2636928640u, 15ul, 4022730752u, 18ul, 1812433253u>&)
Move RotationRandomizer::randomize(Chromosome &chr, ENG &eng) {
  uint r1 = util::unif_int(0, chr.size()-2, eng);
  uint r2 = util::unif_int(r1+1, chr.size()-1, eng);
  double theta = util::unif_real(0.0, 2*util::PI-0.001, eng);
  CoordinateMatrix mat = chr.rotation(r1,r2,theta);
  Move mov(chr);
  mov.start = 0; // We return the positions of the start and end of the 
  mov.stop = chr.size()-1;  //  beads that have their coords altered (so, r1 and r2 are not included in crankshaft)
  mov.mat = mat;
  return mov;


}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rcx, %r15
movq %rdx, %r14
movq %rdi, %rbx
movq %rdx, %rdi
callq 0xa75e
leal -0x2(%rax), %esi
xorl %edi, %edi
movq %r15, %rdx
callq 0x6ebd
movl %eax, %r12d
leal 0x1(%r12), %ebp
movq %r14, %rdi
callq 0xa75e
leal -0x1(%rax), %esi
movl %ebp, %edi
movq %r15, %rdx
callq 0x6ebd
movl %eax, %ebp
movsd 0x14c01(%rip), %xmm1    # 0x211e8
xorps %xmm0, %xmm0
movq %r15, %rdi
callq 0x6e93
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movl %r12d, %edx
movl %ebp, %ecx
callq 0xac58
movq %r14, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rbx)
movups %xmm0, 0x10(%rbx)
andl $0x0, 0x8(%rbx)
movq %r14, %rdi
callq 0xa75e
leaq 0x10(%rbx), %rdi
decl %eax
movl %eax, 0xc(%rbx)
leaq 0x8(%rsp), %rsi
callq 0xb528
leaq 0x18(%rsp), %rdi
callq 0x8012
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
addq $0x20, %rbx
movq %rbx, %rdi
callq 0x8012
leaq 0x18(%rsp), %rdi
callq 0x8012
movq %r14, %rdi
callq 0x65d0
// File: /workspace/github_cpp_makefile_star2_O2/Chrom3D[P]Chrom3D/src/Constraint.cpp
// Function: Constraint::eval()
double Constraint::eval() {
  double beadDist=(*bead1) - (*bead2);
  if(beadDist > this->lower and beadDist < this->upper) {
    return this->k * pow(beadDist - this->distance,2);
  }
  return 0;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
movq 0x8(%rbx), %rsi
callq 0xa42d
ucomisd 0x20(%rbx), %xmm0
xorpd %xmm1, %xmm1
jbe 0xc9ca
movsd 0x28(%rbx), %xmm2
ucomisd %xmm0, %xmm2
jbe 0xc9ca
subsd 0x30(%rbx), %xmm0
mulsd %xmm0, %xmm0
mulsd 0x18(%rbx), %xmm0
movapd %xmm0, %xmm1
movapd %xmm1, %xmm0
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/Chrom3D[P]Chrom3D/src/Constraint.cpp
// Function: Constraint::getConstraintType[abi:cxx11]()
string Constraint::getConstraintType(){

  switch(this->constType){
    case INTERACTION: return "INTERACTION";
    case PERIPHERY: return "PERIPHERY";
    case NUCLEUS: return "NUCLEUS";
    case BOUNDARY: return "BOUNDARY";
    case CENTER: return "CENTER";
    case INTERACTION_INTRA: return "INTERACTION_INTRA";
    case INTERACTION_INTER: return "INTERACTION_INTER";
    case INTERACTION_DIST: return "INTERACTION_DIST";
    case REGULAR: return "REGULAR";
    case C_T_COUNT: return "C_T_COUNT";
   }
   return "REGULAR";
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl 0x10(%rsi), %eax
cmpq $0x9, %rax
ja 0xca76
leaq 0x14978(%rip), %rcx     # 0x21364
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x149e1(%rip), %rsi     # 0x213dd
leaq 0x7(%rsp), %rdx
jmp 0xca90
leaq 0x1499d(%rip), %rsi     # 0x213aa
leaq 0xc(%rsp), %rdx
jmp 0xca90
leaq 0x149b1(%rip), %rsi     # 0x213cc
leaq 0x8(%rsp), %rdx
jmp 0xca90
leaq 0x1496f(%rip), %rsi     # 0x21398
leaq 0xe(%rsp), %rdx
jmp 0xca90
leaq 0x1496b(%rip), %rsi     # 0x213a2
leaq 0xd(%rsp), %rdx
jmp 0xca90
leaq 0x14975(%rip), %rsi     # 0x213ba
leaq 0xa(%rsp), %rdx
jmp 0xca90
leaq 0x14939(%rip), %rsi     # 0x2138c
leaq 0xf(%rsp), %rdx
jmp 0xca90
leaq 0x14952(%rip), %rsi     # 0x213b3
leaq 0xb(%rsp), %rdx
jmp 0xca90
leaq 0x14976(%rip), %rsi     # 0x213e5
leaq 0x6(%rsp), %rdx
jmp 0xca90
leaq 0x14960(%rip), %rsi     # 0x213dd
leaq 0x5(%rsp), %rdx
jmp 0xca90
leaq 0x14c02(%rip), %rsi     # 0x2168d
leaq 0x9(%rsp), %rdx
movq %rbx, %rdi
callq 0xcaa6
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Chrom3D[P]Chrom3D/src/Model.cpp
// Function: Model::Model(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned int)
Model::Model(string modelName, uint seed /*=1234*/) {
  name=modelName;
  randEngine.seed(seed);
  centerBead.setCoordinates(0,0,0);
  hasNucleus=false;

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movl %edx, 0x14(%rsp)
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rsi, %r15
movb $0x0, 0x10(%rdi)
leaq 0x20(%rdi), %r14
movq %r14, %rdi
callq 0x13b3e
leaq 0x9f0(%rbx), %rax
andl $0x0, 0x9f0(%rbx)
andq $0x0, 0x9f8(%rbx)
movq %rax, 0xa00(%rbx)
movq %rax, 0xa08(%rbx)
andq $0x0, 0xa10(%rbx)
leaq 0xa20(%rbx), %rax
andl $0x0, 0xa20(%rbx)
andq $0x0, 0xa28(%rbx)
movq %rax, 0xa30(%rbx)
movq %rax, 0xa38(%rbx)
andl $0x0, 0xaa8(%rbx)
leaq 0xaa8(%rbx), %rax
andq $0x0, 0xab0(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0xa40(%rbx)
movups %xmm0, 0xa50(%rbx)
movups %xmm0, 0xa60(%rbx)
movups %xmm0, 0xa70(%rbx)
movups %xmm0, 0xa80(%rbx)
movq %rax, 0xab8(%rbx)
movq %rax, 0xac0(%rbx)
andq $0x0, 0xac8(%rbx)
leaq 0xad0(%rbx), %r12
movq %r12, %rdi
callq 0xa2cc
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6200
leaq 0x14(%rsp), %rsi
movq %r14, %rdi
callq 0x12d94
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
xorps %xmm2, %xmm2
movq %r12, %rdi
callq 0xa3bc
movb $0x0, 0xa90(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, 0x8(%rsp)
jmp 0xcce3
movq %rax, 0x8(%rsp)
jmp 0xcd3a
movq %rax, 0x8(%rsp)
leaq 0xb08(%rbx), %rdi
callq 0x66d0
leaq 0x9e8(%rbx), %r15
leaq 0xa18(%rbx), %r12
leaq 0xa48(%rbx), %r13
leaq 0xa60(%rbx), %rbp
leaq 0xa78(%rbx), %r14
leaq 0xaa0(%rbx), %rdi
callq 0x13646
movq %r14, %rdi
callq 0x12dca
movq %rbp, %rdi
callq 0x92fe
movq %r13, %rdi
callq 0x12dec
movq %r12, %rdi
callq 0x13718
movq %r15, %rdi
callq 0x13718
movq %rbx, %rdi
callq 0x66d0
movq 0x8(%rsp), %rdi
callq 0x65d0
// File: /workspace/github_cpp_makefile_star2_O2/Chrom3D[P]Chrom3D/src/Model.cpp
// Function: Model::updateBeadMap()
void Model::updateBeadMap() {
  this->getBead.clear();
  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++) {
      getBead[beaditer->getID()] = &(*beaditer);
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0xaa0(%rdi), %r14
movq %r14, %rdi
callq 0x13bfc
movq %rsp, %r15
andq $0x0, (%r15)
movq 0xa78(%rbx), %r12
leaq 0x8(%rsp), %r13
cmpq 0xa80(%rbx), %r12
je 0xce07
movq %r13, %rdi
movq %r12, %rsi
callq 0xa778
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
movq %r13, %rdi
movq %r12, %rsi
callq 0xa784
movq (%rsp), %rax
cmpq 0x8(%rsp), %rax
je 0xcdfe
movq %r15, %rdi
callq 0xb1c4
movq %rax, %rbp
movq (%rsp), %rsi
movq %r13, %rdi
callq 0xa3fa
movq %r14, %rdi
movq %r13, %rsi
callq 0x12e06
movq %rbp, (%rax)
movq %r13, %rdi
callq 0x66d0
movq %r13, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0xb1ee
jmp 0xcdac
addq $0x75330, %r12          # imm = 0x75330
jmp 0xcd8f
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x66d0
movq %rbx, %rdi
callq 0x65d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/Chrom3D[P]Chrom3D/src/Model.cpp
// Function: Model::addChromosome(Chromosome)
void Model::addChromosome(Chromosome chr) {
  assert ( find(chromosomes.begin(), chromosomes.end(), chr) == chromosomes.end() ); // Chromosomes must be unique
  // Assert that all Bead IDS ARE UNIQUE HERE AND NOT FOUND ON ANY CHR HERE
  chromosomes.push_back(chr);  
  this->updateBeadMap();
  //hasUpdatedHashMap = false;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0xa78(%rdi), %rdi
movq 0xa80(%rbx), %rsi
movq %r14, %rdx
callq 0x13fd0
cmpq 0xa80(%rbx), %rax
jne 0xce73
leaq 0xa78(%rbx), %rdi
movq %r14, %rsi
callq 0x12e6c
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xcd5c
leaq 0x14646(%rip), %rdi     # 0x214c0
leaq 0x14686(%rip), %rsi     # 0x21507
leaq 0x1468d(%rip), %rcx     # 0x21515
pushq $0x29
popq %rdx
callq 0x6250
// File: /workspace/github_cpp_makefile_star2_O2/Chrom3D[P]Chrom3D/src/Model.cpp
// Function: Model::addConstraint(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, double, double, double)
void Model::addConstraint(string beadId1, string beadId2, double targetDistance, ConstraintType ct /*=REGULAR*/, double springConstant /*=1*/, double lowerBound /*=0*/, double upperBound /*=INF*/) {
  assert(getBead.find(beadId1) != getBead.end()); 
  assert(getBead.find(beadId2) != getBead.end()); 
  Bead* b1 = getBead[beadId1];
  Bead* b2 = getBead[beadId2];
  this->addConstraint(Constraint(b1, b2, targetDistance, ct, springConstant, lowerBound, upperBound));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movsd %xmm3, 0x58(%rsp)
movsd %xmm2, 0x50(%rsp)
movsd %xmm1, 0x48(%rsp)
movl %ecx, %ebp
movsd %xmm0, 0x40(%rsp)
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
leaq 0xaa0(%rdi), %r15
movq %r15, %rdi
callq 0x14872
leaq 0xaa8(%rbx), %r13
cmpq %r13, %rax
je 0xcfde
movq %r15, %rdi
movq %r14, %rsi
callq 0x14872
cmpq %r13, %rax
je 0xcff7
movq %r15, %rdi
movq %r12, %rsi
callq 0x12f4e
movq (%rax), %r12
movq %r15, %rdi
movq %r14, %rsi
callq 0x12f4e
movq (%rax), %rdx
leaq 0x60(%rsp), %r14
movq %r14, %rdi
movq %r12, %rsi
movsd 0x40(%rsp), %xmm0
movl %ebp, %ecx
movsd 0x48(%rsp), %xmm1
movsd 0x50(%rsp), %xmm2
movsd 0x58(%rsp), %xmm3
callq 0xc904
movq 0x30(%r14), %rax
movq %rax, 0x30(%rsp)
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0xce90
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x14556(%rip), %rdi     # 0x2153b
leaq 0x1451b(%rip), %rsi     # 0x21507
leaq 0x1456f(%rip), %rcx     # 0x21562
pushq $0x37
jmp 0xd00e
leaq 0x145be(%rip), %rdi     # 0x215bc
leaq 0x14502(%rip), %rsi     # 0x21507
leaq 0x14556(%rip), %rcx     # 0x21562
pushq $0x38
popq %rdx
callq 0x6250
// File: /workspace/github_cpp_makefile_star2_O2/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, 0x10(%rsp)
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
leaq 0xaa0(%rdi), %r13
movq %r13, %rdi
callq 0x14872
leaq 0xaa8(%r14), %rbp
cmpq %rbp, %rax
je 0xd11f
movq %r13, %rdi
movq %r15, %rsi
callq 0x14872
cmpq %rbp, %rax
je 0xd138
cmpl $0x8, %ebx
ja 0xd151
movl $0x182, %eax            # imm = 0x182
btl %ebx, %eax
jae 0xd151
movq %r13, %rdi
movq %r12, %rsi
callq 0x12f4e
movq (%rax), %rbp
movq %r13, %rdi
movq %r15, %rsi
callq 0x12f4e
movq (%rax), %r13
leaq 0x38(%rsp), %rdi
movq %r12, %rsi
callq 0x6430
leaq 0x18(%rsp), %rdi
movq %r15, %rsi
callq 0x6430
movq %rbp, %rdi
callq 0xa3e8
movsd %xmm0, 0x8(%rsp)
movq %r13, %rdi
callq 0xa3e8
movsd 0x8(%rsp), %xmm1
addsd %xmm0, %xmm1
leaq 0x38(%rsp), %rsi
leaq 0x18(%rsp), %rdx
movsd 0x1433b(%rip), %xmm3    # 0x21420
xorps %xmm2, %xmm2
movq %r14, %rdi
movapd %xmm1, %xmm0
movl %ebx, %ecx
movsd 0x10(%rsp), %xmm1
callq 0xcef2
leaq 0x18(%rsp), %rdi
callq 0x66d0
leaq 0x38(%rsp), %rdi
callq 0x66d0
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x14415(%rip), %rdi     # 0x2153b
leaq 0x143da(%rip), %rsi     # 0x21507
leaq 0x144af(%rip), %rcx     # 0x215e3
pushq $0x3f
jmp 0xd168
leaq 0x1447d(%rip), %rdi     # 0x215bc
leaq 0x143c1(%rip), %rsi     # 0x21507
leaq 0x14496(%rip), %rcx     # 0x215e3
pushq $0x40
jmp 0xd168
leaq 0x144d8(%rip), %rdi     # 0x21630
leaq 0x143a8(%rip), %rsi     # 0x21507
leaq 0x1447d(%rip), %rcx     # 0x215e3
pushq $0x41
popq %rdx
callq 0x6250
movq %rax, %rbx
jmp 0xd180
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x66d0
leaq 0x38(%rsp), %rdi
callq 0x66d0
movq %rbx, %rdi
callq 0x65d0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x60, %rsp
movsd %xmm1, 0x18(%rsp)
movsd %xmm0, 0x10(%rsp)
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0xaa0(%rdi), %r12
movq %r12, %rdi
callq 0x14872
leaq 0xaa8(%rbx), %r13
cmpq %r13, %rax
je 0xd28f
movq %r12, %rdi
movq %r14, %rsi
callq 0x14872
cmpq %r13, %rax
je 0xd2a8
movq %r12, %rdi
movq %r15, %rsi
callq 0x12f4e
movq (%rax), %r13
movq %r12, %rdi
movq %r14, %rsi
callq 0x12f4e
movq (%rax), %r12
leaq 0x40(%rsp), %rdi
movq %r15, %rsi
callq 0x6430
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
callq 0x6430
movq %r13, %rdi
callq 0xa3e8
movsd %xmm0, 0x8(%rsp)
movq %r12, %rdi
callq 0xa3e8
movsd 0x8(%rsp), %xmm1
addsd %xmm0, %xmm1
addsd 0x10(%rsp), %xmm1
leaq 0x40(%rsp), %rsi
leaq 0x20(%rsp), %rdx
pushq $0x9
popq %rcx
movsd 0x141c8(%rip), %xmm3    # 0x21420
xorps %xmm2, %xmm2
movq %rbx, %rdi
movapd %xmm1, %xmm0
movsd 0x18(%rsp), %xmm1
callq 0xcef2
leaq 0x20(%rsp), %rdi
callq 0x66d0
leaq 0x40(%rsp), %rdi
callq 0x66d0
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x142a5(%rip), %rdi     # 0x2153b
leaq 0x1426a(%rip), %rsi     # 0x21507
leaq 0x143fb(%rip), %rcx     # 0x2169f
pushq $0x49
jmp 0xd2bf
leaq 0x1430d(%rip), %rdi     # 0x215bc
leaq 0x14251(%rip), %rsi     # 0x21507
leaq 0x143e2(%rip), %rcx     # 0x2169f
pushq $0x4a
popq %rdx
callq 0x6250
movq %rax, %rbx
jmp 0xd2d7
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x66d0
leaq 0x40(%rsp), %rdi
callq 0x66d0
movq %rbx, %rdi
callq 0x65d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x70, %rsp
movsd %xmm1, 0x28(%rsp)
movsd %xmm0, 0x20(%rsp)
movq %rdx, %r14
movq %rsi, %r13
movq %rdi, %rbx
leaq 0xaa0(%rdi), %r15
movq %r15, %rdi
callq 0x14872
leaq 0xaa8(%rbx), %r12
cmpq %r12, %rax
je 0xd40f
movq %r15, %rdi
movq %r14, %rsi
callq 0x14872
cmpq %r12, %rax
je 0xd428
movq %r15, %rdi
movq %r13, %rsi
callq 0x12f4e
movq (%rax), %r12
movq %r15, %rdi
movq %r14, %rsi
callq 0x12f4e
movq (%rax), %r15
leaq 0x50(%rsp), %rdi
movq %r13, %rsi
callq 0x6430
leaq 0x30(%rsp), %rdi
movq %r14, %rsi
callq 0x6430
movq %r12, %rdi
callq 0xa3e8
movsd %xmm0, 0x18(%rsp)
movq %r15, %rdi
callq 0xa3e8
movsd %xmm0, 0x10(%rsp)
movq %r12, %rdi
callq 0xa3e8
movsd %xmm0, 0x8(%rsp)
movq %r15, %rdi
callq 0xa3e8
movsd 0x18(%rsp), %xmm4
addsd 0x10(%rsp), %xmm4
movsd 0x20(%rsp), %xmm1
addsd %xmm1, %xmm4
movsd 0x8(%rsp), %xmm3
addsd %xmm0, %xmm3
addsd %xmm1, %xmm3
leaq 0x50(%rsp), %rsi
leaq 0x30(%rsp), %rdx
pushq $0x9
popq %rcx
xorps %xmm2, %xmm2
movq %rbx, %rdi
movapd %xmm4, %xmm0
movsd 0x28(%rsp), %xmm1
callq 0xcef2
leaq 0x30(%rsp), %rdi
callq 0x66d0
leaq 0x50(%rsp), %rdi
callq 0x66d0
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x14125(%rip), %rdi     # 0x2153b
leaq 0x140ea(%rip), %rsi     # 0x21507
leaq 0x142c8(%rip), %rcx     # 0x216ec
pushq $0x53
jmp 0xd43f
leaq 0x1418d(%rip), %rdi     # 0x215bc
leaq 0x140d1(%rip), %rsi     # 0x21507
leaq 0x142af(%rip), %rcx     # 0x216ec
pushq $0x54
popq %rdx
callq 0x6250
movq %rax, %rbx
jmp 0xd457
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x66d0
leaq 0x50(%rsp), %rdi
callq 0x66d0
movq %rbx, %rdi
callq 0x65d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x70, %rsp
movsd %xmm1, 0x28(%rsp)
movsd %xmm0, 0x20(%rsp)
movq %rdx, %r14
movq %rsi, %r13
movq %rdi, %rbx
leaq 0xaa0(%rdi), %r15
movq %r15, %rdi
callq 0x14872
leaq 0xaa8(%rbx), %r12
cmpq %r12, %rax
je 0xd594
movq %r15, %rdi
movq %r14, %rsi
callq 0x14872
cmpq %r12, %rax
je 0xd5ad
movq %r15, %rdi
movq %r13, %rsi
callq 0x12f4e
movq (%rax), %r12
movq %r15, %rdi
movq %r14, %rsi
callq 0x12f4e
movq (%rax), %r15
leaq 0x50(%rsp), %rdi
movq %r13, %rsi
callq 0x6430
leaq 0x30(%rsp), %rdi
movq %r14, %rsi
callq 0x6430
movq %r12, %rdi
callq 0xa3e8
movsd %xmm0, 0x18(%rsp)
movq %r15, %rdi
callq 0xa3e8
movsd %xmm0, 0x10(%rsp)
movq %r12, %rdi
callq 0xa3e8
movsd %xmm0, 0x8(%rsp)
movq %r15, %rdi
callq 0xa3e8
movsd 0x18(%rsp), %xmm4
addsd 0x10(%rsp), %xmm4
movsd 0x20(%rsp), %xmm1
addsd %xmm1, %xmm4
movsd 0x8(%rsp), %xmm2
addsd %xmm0, %xmm2
addsd %xmm1, %xmm2
leaq 0x50(%rsp), %rsi
leaq 0x30(%rsp), %rdx
pushq $0x9
popq %rcx
movsd 0x13ec0(%rip), %xmm3    # 0x21420
movq %rbx, %rdi
movapd %xmm4, %xmm0
movsd 0x28(%rsp), %xmm1
callq 0xcef2
leaq 0x30(%rsp), %rdi
callq 0x66d0
leaq 0x50(%rsp), %rdi
callq 0x66d0
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x13fa0(%rip), %rdi     # 0x2153b
leaq 0x13f65(%rip), %rsi     # 0x21507
leaq 0x14195(%rip), %rcx     # 0x2173e
pushq $0x5c
jmp 0xd5c4
leaq 0x14008(%rip), %rdi     # 0x215bc
leaq 0x13f4c(%rip), %rsi     # 0x21507
leaq 0x1417c(%rip), %rcx     # 0x2173e
pushq $0x5d
popq %rdx
callq 0x6250
movq %rax, %rbx
jmp 0xd5dc
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x66d0
leaq 0x50(%rsp), %rdi
callq 0x66d0
movq %rbx, %rdi
callq 0x65d0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x14872
leaq 0xaa8(%rbx), %rcx
cmpq %rcx, %rax
je 0xd7c5
cmpb $0x0, 0xa90(%rbx)
je 0xd7de
movq %r15, %rdi
movq %r14, %rsi
callq 0x12f4e
movq (%rax), %r14
leaq 0xad0(%rbx), %r15
movsd 0xa98(%rbx), %xmm0
movsd %xmm0, 0x38(%rsp)
movq %r14, %rdi
callq 0xa3e8
movsd 0x38(%rsp), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, 0x38(%rsp)
movsd 0xa98(%rbx), %xmm0
movsd %xmm0, 0x40(%rsp)
movq %r14, %rdi
callq 0xa3e8
movsd 0x40(%rsp), %xmm2
subsd %xmm0, %xmm2
leaq 0x50(%rsp), %r12
pushq $0x3
popq %rcx
movsd 0x13cb5(%rip), %xmm3    # 0x21420
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
movsd 0x38(%rsp), %xmm0
movsd 0x48(%rsp), %xmm1
callq 0xc904
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 0xce90
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x13fc4(%rip), %rdi     # 0x21790
leaq 0x13d34(%rip), %rsi     # 0x21507
leaq 0x14016(%rip), %rcx     # 0x217f0
pushq $0x6e
jmp 0xd7f5
leaq 0x1403c(%rip), %rdi     # 0x21821
leaq 0x13d1b(%rip), %rsi     # 0x21507
leaq 0x13ffd(%rip), %rcx     # 0x217f0
pushq $0x6f
popq %rdx
callq 0x6250
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0xd8e2
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xaa0(%rdi), %r15
movq %r15, %rdi
callq 0x14872
leaq 0xaa8(%rbx), %rcx
cmpq %rcx, %rax
je 0xd8fb
movq %r15, %rdi
movq %r14, %rsi
callq 0x12f4e
movq (%rax), %r14
leaq 0xad0(%rbx), %r15
movsd 0xa98(%rbx), %xmm0
movsd %xmm0, 0x40(%rsp)
movq %r14, %rdi
callq 0xa3e8
movsd 0x40(%rsp), %xmm1
subsd %xmm0, %xmm1
leaq 0x50(%rsp), %r12
pushq $0x2
popq %rcx
movsd 0x13b99(%rip), %xmm3    # 0x21420
xorps %xmm2, %xmm2
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
movapd %xmm1, %xmm0
movsd 0x48(%rsp), %xmm1
callq 0xc904
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 0xce90
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x13f38(%rip), %rdi     # 0x21821
leaq 0x13c17(%rip), %rsi     # 0x21507
leaq 0x13f3b(%rip), %rcx     # 0x21832
pushq $0x75
jmp 0xd912
leaq 0x13e8e(%rip), %rdi     # 0x21790
leaq 0x13bfe(%rip), %rsi     # 0x21507
leaq 0x13f22(%rip), %rcx     # 0x21832
pushq $0x76
popq %rdx
callq 0x6250
// File: /workspace/github_cpp_makefile_star2_O2/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
movl %esi, %ebx
movq %rdi, %r14
movq 0xa00(%rdi), %rax
addq $0x9f0, %r14            # imm = 0x9F0
movsd %xmm0, (%rsp)
cmpq %r14, %rax
je 0xda63
movq 0x40(%rax), %rcx
movq 0x48(%rax), %rdx
cmpq %rdx, %rcx
je 0xda54
cmpl %ebx, 0x10(%rcx)
jne 0xda4e
movsd %xmm0, 0x18(%rcx)
addq $0x38, %rcx
jmp 0xda3f
movq %rax, %rdi
callq 0x6280
movsd (%rsp), %xmm0
jmp 0xda32
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Chrom3D[P]Chrom3D/src/Model.cpp
// Function: Model::switchConstraints(ConstraintType, bool)
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 $0x98, %rsp
leaq 0x28(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
xorl %ecx, %ecx
movb %cl, (%rax)
leaq 0x48(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movl %esi, 0xc(%rsp)
movq %rdi, %r14
movb %cl, (%rax)
testl %edx, %edx
je 0xdb49
movq 0xa30(%r14), %r15
leaq 0xa20(%r14), %rax
movq %rax, 0x10(%rsp)
addq $0x9e8, %r14            # imm = 0x9E8
leaq 0x58(%rsp), %r12
leaq 0x18(%rsp), %rbx
cmpq 0x10(%rsp), %r15
je 0xdbe6
leaq 0x40(%r15), %rbp
movq 0x40(%r15), %r13
cmpq 0x48(%r15), %r13
je 0xdb3c
movl 0xc(%rsp), %eax
cmpl %eax, 0x10(%r13)
jne 0xdb36
movq %r12, %rdi
movq %r13, %rsi
callq 0xc924
movq %rbx, %rdi
movq %r12, %rsi
callq 0x12fb4
movq %r12, %rdi
callq 0x12f38
movq %r14, %rdi
movq %rbx, %rsi
callq 0x12e9c
movq %rax, %rdi
movq %r13, %rsi
callq 0x12f02
movq %rbp, %rdi
movq %r13, %rsi
callq 0x12fde
jmp 0xdae5
addq $0x38, %r13
jmp 0xdae5
movq %r15, %rdi
callq 0x6280
movq %rax, %r15
jmp 0xdad2
movq 0xa00(%r14), %r15
leaq 0x9f0(%r14), %rax
movq %rax, 0x10(%rsp)
addq $0xa18, %r14            # imm = 0xA18
leaq 0x58(%rsp), %r12
cmpq 0x10(%rsp), %r15
je 0xdbe6
movq %r14, %rbx
leaq 0x40(%r15), %rbp
movq 0x40(%r15), %r13
cmpq 0x48(%r15), %r13
je 0xdbd6
movl 0xc(%rsp), %eax
cmpl %eax, 0x10(%r13)
jne 0xdbd0
movq %r12, %rdi
movq %r13, %rsi
callq 0xc924
leaq 0x18(%rsp), %r14
movq %r14, %rdi
movq %r12, %rsi
callq 0x12fb4
movq %r12, %rdi
callq 0x12f38
movq %rbx, %rdi
movq %r14, %rsi
callq 0x12e9c
movq %rax, %rdi
movq %r13, %rsi
callq 0x12f02
movq %rbp, %rdi
movq %r13, %rsi
callq 0x12fde
jmp 0xdb7a
addq $0x38, %r13
jmp 0xdb7a
movq %r15, %rdi
callq 0x6280
movq %rax, %r15
movq %rbx, %r14
jmp 0xdb68
leaq 0x18(%rsp), %rdi
callq 0x12f38
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xdc08
jmp 0xdc08
jmp 0xdc08
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x12f38
movq %rbx, %rdi
callq 0x65d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rax
subq (%rdi), %rax
sarq $0x3, %rax
movq %rax, %xmm0
punpckldq 0x130a1(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
movq %rsi, %r14
subpd 0x130a6(%rip), %xmm0    # 0x21480
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
leaq 0x18(%rsp), %rdx
movsd %xmm1, (%rdx)
leaq 0x20(%rsp), %rdi
leaq 0xf(%rsp), %rcx
xorl %esi, %esi
callq 0x131ba
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
xorl %edx, %edx
callq 0x13210
cvtsi2sd %eax, %xmm0
movsd %xmm0, 0x10(%rsp)
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
movq %rdi, %rdx
callq 0x1322a
xorpd %xmm0, %xmm0
movsd 0x10(%rsp), %xmm1
movq %r14, %rdi
callq 0x6e93
leaq 0x18(%rsp), %rdx
movsd %xmm0, (%rdx)
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
callq 0x1501e
movq %rax, %r14
subq (%rbx), %r14
shrq $0x3, %r14
leaq 0x20(%rsp), %rdi
callq 0x92fe
movl %r14d, %eax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
jmp 0xe46f
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x92fe
movq %rbx, %rdi
callq 0x65d0
// File: /workspace/github_cpp_makefile_star2_O2/Chrom3D[P]Chrom3D/src/Model.cpp
// Function: Model::detectClash()
bool Model::detectClash(){

  vector<Chromosome>::iterator chriter1; 
  vector<Chromosome>::iterator chriter2;  
  boost::container::static_vector<Bead,MAXSIZE>::iterator beaditer1;
  boost::container::static_vector<Bead,MAXSIZE>::iterator beaditer2;
  
  for(chriter1 = chromosomes.begin(); chriter1 != chromosomes.end(); chriter1++) {
    for(beaditer1 = chriter1->begin(); beaditer1 != chriter1->end(); beaditer1++) {
      for(chriter2 = chromosomes.begin(); chriter2 != chromosomes.end(); chriter2++) {
        for(beaditer2 = chriter2->begin(); beaditer2 != chriter2->end(); beaditer2++) {
          if(*beaditer1 != *beaditer2) { 
            
            if(util::coordClash(beaditer1->getX(),beaditer1->getY(), beaditer1->getZ(), beaditer2->getX(),beaditer2->getY(), beaditer2->getZ(), beaditer1->getRadius(), beaditer2->getRadius())) {              
	      return true;
            }
          }
        }
      }
    }
  }

  
  return false; 
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
leaq 0x10(%rsp), %rbx
andq $0x0, (%rbx)
leaq 0x8(%rsp), %r14
andq $0x0, (%r14)
movq %rdi, %r12
movq 0xa78(%rdi), %r15
leaq 0x18(%rsp), %r13
movq 0xa80(%r12), %rax
movq %r15, 0x20(%rsp)
movq %rax, 0x28(%rsp)
cmpq %rax, %r15
je 0xea1a
movq %r13, %rdi
movq 0x20(%rsp), %r15
movq %r15, %rsi
callq 0xa778
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
movq %r13, %rdi
movq %r15, %rsi
callq 0xa784
movq 0x10(%rsp), %rax
cmpq 0x18(%rsp), %rax
je 0xea0e
movq 0xa78(%r12), %rbp
cmpq 0xa80(%r12), %rbp
je 0xe9f7
movq %r13, %rdi
movq %rbp, %rsi
callq 0xa778
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq %r13, %rdi
movq %rbp, %rsi
callq 0xa784
movq 0x8(%rsp), %rax
cmpq 0x18(%rsp), %rax
je 0xe9eb
movq %rbx, %rdi
callq 0xb1c4
movq %rax, %r15
movq %r14, %rdi
callq 0xb1c4
movq %r15, %rdi
movq %rax, %rsi
callq 0xa47f
testb %al, %al
je 0xe9d9
movq 0x10(%rsp), %rdi
callq 0xa3d6
movsd %xmm0, 0x60(%rsp)
movq 0x10(%rsp), %rdi
callq 0xa3dc
movsd %xmm0, 0x58(%rsp)
movq 0x10(%rsp), %rdi
callq 0xa3e2
movsd %xmm0, 0x50(%rsp)
movq 0x8(%rsp), %rdi
callq 0xa3d6
movsd %xmm0, 0x48(%rsp)
movq 0x8(%rsp), %rdi
callq 0xa3dc
movsd %xmm0, 0x40(%rsp)
movq 0x8(%rsp), %rdi
callq 0xa3e2
movsd %xmm0, 0x38(%rsp)
movq 0x10(%rsp), %rdi
callq 0xa3e8
movsd %xmm0, 0x30(%rsp)
movq 0x8(%rsp), %rdi
callq 0xa3e8
movaps %xmm0, %xmm7
movsd 0x60(%rsp), %xmm0
movsd 0x58(%rsp), %xmm1
movsd 0x50(%rsp), %xmm2
movsd 0x48(%rsp), %xmm3
movsd 0x40(%rsp), %xmm4
movsd 0x38(%rsp), %xmm5
movsd 0x30(%rsp), %xmm6
callq 0x6ee6
testb %al, %al
jne 0xea1a
movq %r13, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0xb1ee
jmp 0xe8e8
addq $0x75330, %rbp          # imm = 0x75330
jmp 0xe8c5
movq %r13, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0xb1ee
movq 0x20(%rsp), %r15
jmp 0xe8a2
addq $0x75330, %r15          # imm = 0x75330
jmp 0xe86d
movq 0x28(%rsp), %rax
cmpq %rax, 0x20(%rsp)
setne %al
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Chrom3D[P]Chrom3D/src/Model.cpp
// Function: Model::accept(Move&)
Move Model::accept(Move &mov) { // Accepts the coordinates of mov, returns the coordinates of the altered beads (as a new Move).
  Move oldStructure(mov.chr);
  oldStructure.start = mov.start;
  oldStructure.stop = mov.stop;
  
  uint movSize = (mov.stop-mov.start)+1;
  CoordinateMatrix oldMat(movSize,3);
  for(uint i=0; i!=movSize; i++) {
    // Store old coordinates:
    oldMat(i,0) = mov.chr[mov.start+i].getX();
    oldMat(i,1) = mov.chr[mov.start+i].getY();
    oldMat(i,2) = mov.chr[mov.start+i].getZ();
    // Set new coordinates:
    mov.chr[mov.start+i].setCoordinates(mov.mat(i,0), mov.mat(i,1), mov.mat(i,2));
  }
  oldStructure.mat = oldMat;
  
  return oldStructure;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movq (%rdx), %rsi
callq 0xbce8
movl 0x8(%r14), %eax
movl %eax, 0x8(%rbx)
movl 0xc(%r14), %r15d
movq %rbx, 0x10(%rsp)
movl %r15d, 0xc(%rbx)
subl %eax, %r15d
incl %r15d
leaq 0x20(%rsp), %rdi
pushq $0x3
popq %rdx
movq %r15, %rsi
callq 0x7af6
leaq 0x10(%r14), %r12
xorl %r13d, %r13d
leaq 0x20(%rsp), %rbp
cmpq %r13, %r15
je 0xeb9e
movq (%r14), %rdi
movl 0x8(%r14), %esi
addl %r13d, %esi
callq 0xb174
movq %rax, %rdi
callq 0xa3d6
movsd %xmm0, 0x8(%rsp)
movq %rbp, %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0x8614
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rax)
movq (%r14), %rdi
movl 0x8(%r14), %esi
addl %r13d, %esi
callq 0xb174
movq %rax, %rdi
callq 0xa3dc
movsd %xmm0, 0x8(%rsp)
movq %rbp, %rdi
movq %r13, %rsi
pushq $0x1
popq %rdx
callq 0x8614
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rax)
movq (%r14), %rdi
movl 0x8(%r14), %esi
addl %r13d, %esi
callq 0xb174
movq %rax, %rdi
callq 0xa3e2
movsd %xmm0, 0x8(%rsp)
movq %rbp, %rdi
movq %r13, %rsi
pushq $0x2
popq %rdx
callq 0x8614
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rax)
movq (%r14), %rdi
movl 0x8(%r14), %esi
addl %r13d, %esi
callq 0xb174
movq %rax, %rbx
movq %r12, %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0x8614
movsd (%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
movq %r12, %rdi
movq %r13, %rsi
pushq $0x1
popq %rdx
callq 0x8614
movsd (%rax), %xmm0
movsd %xmm0, 0x18(%rsp)
movq %r12, %rdi
movq %r13, %rsi
pushq $0x2
popq %rdx
callq 0x8614
movsd (%rax), %xmm2
movq %rbx, %rdi
movsd 0x8(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
callq 0xa3bc
incq %r13
jmp 0xea88
movq 0x10(%rsp), %rbx
leaq 0x10(%rbx), %rdi
leaq 0x20(%rsp), %rsi
callq 0xb528
leaq 0x30(%rsp), %rdi
callq 0x8012
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xebd4
movq %rax, %rbx
jmp 0xebe1
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x8012
movq 0x10(%rsp), %rdi
addq $0x20, %rdi
callq 0x8012
movq %rbx, %rdi
callq 0x65d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x6570
movq (%r14), %rsi
pushq $0x10
popq %rdx
movq %r15, %rdi
callq 0x6040
movq %rsp, %rdi
movq %rbx, %rsi
callq 0xf06e
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
callq 0x6320
movq %rsp, %rdi
callq 0x66d0
leaq 0x20(%rsp), %rdi
callq 0x6450
leaq 0x20(%rsp), %rdi
callq 0x6480
addq $0x220, %rsp            # imm = 0x220
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x66d0
jmp 0xf606
jmp 0xf603
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x6480
movq %rbx, %rdi
callq 0x65d0
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x28, %rsp
movsd %xmm0, 0x20(%rsp)
cmpb $0x0, 0xa90(%rdi)
je 0x11ffc
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
andq $0x0, (%r14)
callq 0x12c3e
movq %rbx, %rdi
callq 0x12cf0
movsd %xmm0, 0x18(%rsp)
movq 0xa78(%rbx), %r15
leaq 0x10(%rsp), %r12
cmpq 0xa80(%rbx), %r15
je 0x11ff0
movq %r12, %rdi
movq %r15, %rsi
callq 0xa778
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq %r12, %rdi
movq %r15, %rsi
callq 0xa784
movq 0x8(%rsp), %rdi
cmpq 0x10(%rsp), %rdi
je 0x11fe4
callq 0xa3ee
movl %eax, %eax
cvtsi2sd %rax, %xmm0
mulsd 0x20(%rsp), %xmm0
divsd 0x18(%rsp), %xmm0
movsd 0xf482(%rip), %xmm1     # 0x21440
callq 0x65b0
mulsd 0xa98(%rbx), %xmm0
movq 0x8(%rsp), %rdi
callq 0xa3d0
movq %r12, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0xb1ee
jmp 0x11f87
addq $0x75330, %r15          # imm = 0x75330
jmp 0x11f69
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0xf81e(%rip), %rdi      # 0x21821
leaq 0xf4fd(%rip), %rsi      # 0x21507
leaq 0xff7a(%rip), %rcx      # 0x21f8b
movl $0x3c2, %edx            # imm = 0x3C2
callq 0x6250
nop
// File: /workspace/github_cpp_makefile_star2_O2/Chrom3D[P]Chrom3D/src/Model.cpp
// Function: Model::interactionSpecifiedSymmetricly(std::vector<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::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>&)
bool Model::interactionSpecifiedSymmetricly(std::vector<std::pair<std::string,std::string> > &interactionVector) {
  std::vector<std::pair<std::string,std::string> > tmpVec;
  string left,right;
  for(std::vector<std::pair<std::string,std::string> >::iterator it = interactionVector.begin(); it != interactionVector.end(); it++) {
    if(it->first < it->second) {
      tmpVec.push_back(*it);     
    }
    else {
      left = it->first;
      right = it->second;
      tmpVec.push_back(make_pair(right,left));
    }
  }
  int num_interactions;
  for(std::vector<std::pair<std::string,std::string> >::iterator it = tmpVec.begin(); it != tmpVec.end(); it++) {    
      num_interactions = std::count(tmpVec.begin(), tmpVec.end(), *it);
      if (num_interactions != 2) {
	return false;
      }
  }
  return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rsi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %rax
movaps %xmm0, (%rax)
andq $0x0, 0x10(%rax)
leaq 0x48(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
xorl %ecx, %ecx
movb %cl, (%rax)
leaq 0x28(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb %cl, (%rax)
movq (%rsi), %r15
leaq 0x38(%rsp), %r12
leaq 0x18(%rsp), %r13
leaq 0x58(%rsp), %rbp
cmpq 0x8(%rbx), %r15
je 0x120d5
leaq 0x20(%r15), %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0x9a0a
testb %al, %al
je 0x12098
movq %rsp, %rdi
movq %r15, %rsi
callq 0x13546
jmp 0x120cf
movq %r12, %rdi
movq %r15, %rsi
callq 0x6200
movq %r13, %rdi
movq %r14, %rsi
callq 0x6200
movq %rbp, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x13968
movq %rsp, %rdi
movq %rbp, %rsi
callq 0x16f2c
movq %rbp, %rdi
callq 0x12f38
addq $0x40, %r15
jmp 0x12072
movq (%rsp), %rcx
movq %rcx, %rbx
movq 0x8(%rsp), %r14
cmpq %r14, %rcx
je 0x120fe
movq (%rsp), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x17022
leaq 0x40(%rbx), %rcx
cmpl $0x2, %eax
je 0x120d9
cmpq %r14, %rbx
sete %bl
leaq 0x18(%rsp), %rdi
callq 0x66d0
leaq 0x38(%rsp), %rdi
callq 0x66d0
movq %rsp, %rdi
callq 0x13624
movl %ebx, %eax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x12f38
jmp 0x1214a
jmp 0x12147
jmp 0x12147
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x66d0
leaq 0x38(%rsp), %rdi
callq 0x66d0
movq %rsp, %rdi
callq 0x13624
movq %rbx, %rdi
callq 0x65d0
// File: /workspace/github_cpp_makefile_star2_O2/Chrom3D[P]Chrom3D/src/Model.cpp
// Function: Model::getNumberOfBeads()
uint Model::getNumberOfBeads() {
  vector<Chromosome>::iterator chriter;
  uint res = 0;
  for(chriter = chromosomes.begin(); chriter != chromosomes.end(); chriter++) {
    res += chriter->size();
  }
  return res;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0xa78(%rdi), %r14
xorl %ebp, %ebp
cmpq 0xa80(%rbx), %r14
je 0x1261e
movq %r14, %rdi
callq 0xa75e
addl %eax, %ebp
addq $0x75330, %r14          # imm = 0x75330
jmp 0x12602
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop