LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/melop[P]admixem/./parser/parser.cpp
// Function: Parser::Evaluate(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
const double Parser::Evaluate (const std::string & program)  // get result
  {
  program_  = program;
  this->IsOne = (program=="1");
  this->IsZero =  (program=="0");
  return Evaluate ();
  }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x71d0
leaq 0x2ea2f(%rip), %rsi     # 0x3836b
movq %rbx, %rdi
callq 0x7100
testl %eax, %eax
sete 0x60(%r14)
leaq 0x2d0a8(%rip), %rsi     # 0x369fa
movq %rbx, %rdi
callq 0x7100
testl %eax, %eax
sete 0x61(%r14)
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x9836
// File: /workspace/github_cpp_makefile_star2_O1/melop[P]admixem/./parser/parser.h
// Function: Parser::CheckToken(Parser::TokenType)
inline void CheckToken (const TokenType wanted)
    {
    if (type_ != wanted)
      {
      std::ostringstream s;
      s << "'" << static_cast <char> (wanted) << "' expected.";
      throw std::runtime_error (s.str ());    
      }
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
cmpl %esi, 0x30(%rdi)
jne 0x9a96
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r14
popq %rbp
retq
movl %esi, %ebx
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x74c0
leaq 0x2b691(%rip), %rsi     # 0x3513d
movl $0x1, %edx
movq %r14, %rdi
callq 0x7400
leaq 0x8(%rsp), %rsi
movb %bl, (%rsi)
leaq 0x28(%rsp), %rdi
movl $0x1, %edx
callq 0x7400
leaq 0x2b707(%rip), %rsi     # 0x351dd
movl $0xb, %edx
movq %rax, %rdi
callq 0x7400
movl $0x10, %edi
callq 0x7180
movq %rax, %rbx
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x75a0
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x75d0
xorl %ebp, %ebp
movq 0x3f4d8(%rip), %rsi     # 0x48ff0
movq 0x3f461(%rip), %rdx     # 0x48f80
movq %rbx, %rdi
callq 0x7660
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9b4d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x7390
jmp 0x9b4d
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x9b5f
movq %rbx, %rdi
callq 0x72a0
jmp 0x9b5f
movq %rax, %r14
movq 0x3f422(%rip), %rsi     # 0x48f88
leaq 0x28(%rsp), %rdi
callq 0x71c0
leaq 0x98(%rsp), %rdi
callq 0x7120
movq %r14, %rdi
callq 0x76a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/melop[P]admixem/./newran02/extreal.cpp
// Function: ExtReal::operator+(ExtReal const&) const
ExtReal ExtReal::operator+(const ExtReal& er) const
{
   if (c==Finite && er.c==Finite) return ExtReal(value+er.value);
   if (c==Missing || er.c==Missing) return ExtReal(Missing);
   if (c==Indefinite || er.c==Indefinite) return ExtReal(Indefinite);
   if (c==PlusInfinity)
   {
      if (er.c==MinusInfinity) return ExtReal(Indefinite);
      return *this;
   }
   if (c==MinusInfinity)
   {
      if (er.c==PlusInfinity) return ExtReal(Indefinite);
      return *this;
   }
   return er;
}

// Assembly:
movl 0x8(%rdi), %ecx
movl 0x8(%rsi), %edx
movl %ecx, %eax
orl %edx, %eax
jne 0xae0f
movsd (%rdi), %xmm0
addsd (%rsi), %xmm0
xorl %eax, %eax
retq
cmpl $0x4, %ecx
sete %al
cmpl $0x4, %edx
sete %r8b
orb %al, %r8b
je 0xae27
movl $0x4, %eax
retq
cmpl $0x3, %ecx
sete %al
cmpl $0x3, %edx
sete %r8b
orb %al, %r8b
movl $0x3, %eax
je 0xae3f
retq
cmpl $0x2, %ecx
je 0xae4f
cmpl $0x1, %ecx
jne 0xae5b
cmpl $0x2, %edx
jne 0xae54
retq
cmpl $0x1, %edx
je 0xae4e
movsd (%rdi), %xmm0
movl %ecx, %eax
retq
movsd (%rsi), %xmm0
movl %edx, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/melop[P]admixem/./newran02/extreal.cpp
// Function: ExtReal::operator*(ExtReal const&) const
ExtReal ExtReal::operator*(const ExtReal& er) const
{
   if (c==Finite && er.c==Finite) return ExtReal(value*er.value);
   if (c==Missing || er.c==Missing) return ExtReal(Missing);
   if (c==Indefinite || er.c==Indefinite) return ExtReal(Indefinite);
   if (c==Finite)
   {
      if (value==0.0) return ExtReal(Indefinite);
      if (value>0.0) return er;
      return (-er);
   }
   if (er.c==Finite)
   {
      if (er.value==0.0) return ExtReal(Indefinite);
      if (er.value>0.0) return *this;
      return -(*this);
   }
   if (c==PlusInfinity) return er;
   return (-er);
}

// Assembly:
movl 0x8(%rdi), %edx
movl 0x8(%rsi), %ecx
movl %edx, %eax
orl %ecx, %eax
jne 0xaee3
movsd (%rdi), %xmm0
mulsd (%rsi), %xmm0
xorl %eax, %eax
retq
cmpl $0x4, %edx
sete %al
cmpl $0x4, %ecx
sete %r8b
orb %al, %r8b
je 0xaefb
movl $0x4, %eax
retq
cmpl $0x3, %edx
sete %al
cmpl $0x3, %ecx
sete %r8b
orb %al, %r8b
movl $0x3, %eax
jne 0xaefa
testl %edx, %edx
je 0xaf3a
testl %ecx, %ecx
je 0xaf52
cmpl $0x1, %edx
je 0xaf4c
cmpl $0x4, %ecx
ja 0xafbb
movl %ecx, %eax
leaq 0x2a2e3(%rip), %rdx     # 0x35214
movslq (%rdx,%rax,4), %rax
addq %rdx, %rax
jmpq *%rax
movsd (%rdi), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xaf4a
jnp 0xafc0
jbe 0xaf6a
movsd (%rsi), %xmm0
jmp 0xaf81
movsd (%rsi), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xaf62
jnp 0xafc0
jbe 0xaf95
movsd (%rdi), %xmm0
jmp 0xafac
cmpl $0x4, %ecx
ja 0xafbb
movl %ecx, %eax
leaq 0x2a2c4(%rip), %rdx     # 0x3523c
movslq (%rdx,%rax,4), %rax
addq %rdx, %rax
jmpq *%rax
movl %ecx, %eax
retq
movsd (%rsi), %xmm0
xorpd 0x2a100(%rip), %xmm0    # 0x35090
jmp 0xaee0
cmpl $0x4, %edx
ja 0xafbb
movl %edx, %eax
leaq 0x2a285(%rip), %rcx     # 0x35228
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl %edx, %eax
retq
movl $0x1, %eax
retq
movl $0x2, %eax
retq
xorl %eax, %eax
xorps %xmm0, %xmm0
retq
movsd (%rdi), %xmm0
jmp 0xaf88
nop
// File: /workspace/github_cpp_makefile_star2_O1/melop[P]admixem/./newran02/extreal.cpp
// Function: operator<<(std::ostream&, ExtReal const&)
ostream& operator<<(ostream& os, const ExtReal& er)
{
   switch (er.c)
   {
      case Finite:        os << er.value;         break;
      case PlusInfinity:  os << "plus-infinity";  break;
      case MinusInfinity: os << "minus-infinity"; break;
      case Indefinite:    os << "indefinite";     break;
      case Missing:       os << "missing";        break;
   }
   return os;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl 0x8(%rsi), %eax
cmpq $0x4, %rax
ja 0xb06a
leaq 0x2a24f(%rip), %rcx     # 0x35264
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movsd (%rsi), %xmm0
movq %rbx, %rdi
callq 0x75c0
jmp 0xb06a
leaq 0x2a26d(%rip), %rsi     # 0x352a0
movl $0x7, %edx
jmp 0xb062
leaq 0x2a245(%rip), %rsi     # 0x35286
movl $0xe, %edx
jmp 0xb062
leaq 0x2a246(%rip), %rsi     # 0x35295
movl $0xa, %edx
jmp 0xb062
leaq 0x2a21b(%rip), %rsi     # 0x35278
movl $0xd, %edx
movq %rbx, %rdi
callq 0x7400
movq %rbx, %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/melop[P]admixem/./newran02/myexcept.cpp
// Function: Exception::Exception(char const*)
Exception::Exception(const char* a_what)
{
   Select++; SoFar = 0;
   if (!what_error)                   // make space for exception message
   {
      LastOne = 511;
      what_error = new char[512];
      if (!what_error)                // fail to make space
      {
         LastOne = 0;
         what_error = (char *)"No heap space for exception message\n";
      }
   }
   AddMessage("\n\nAn exception has been thrown\n");
   AddMessage(a_what);
   if (a_what) Tracer::AddTrace();
}

// Assembly:
pushq %rbx
incq 0x3df90(%rip)           # 0x49468
movq %rsi, %rbx
movl $0x0, 0x3df93(%rip)     # 0x49478
cmpq $0x0, 0x3df83(%rip)     # 0x49470
jne 0xb50a
movl $0x1ff, 0x3df83(%rip)   # imm = 0x1FF
movl $0x200, %edi            # imm = 0x200
callq 0x7030
movq %rax, 0x3df66(%rip)     # 0x49470
leaq 0x29de2(%rip), %rdi     # 0x352f3
callq 0xb52c
movq %rbx, %rdi
callq 0xb52c
testq %rbx, %rbx
je 0xb529
popq %rbx
jmp 0xb5aa
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/melop[P]admixem/./newran02/myexcept.cpp
// Function: Exception::AddMessage(char const*)
void Exception::AddMessage(const char* a_what)
{
   if (a_what)
   {
      int l = strlen(a_what); int r = LastOne - SoFar;
      if (l < r) { strcpy(what_error+SoFar, a_what); SoFar += l; }
      else if (r > 0)
      {
         strncpy(what_error+SoFar, a_what, r);
         what_error[LastOne] = 0;
         SoFar = LastOne;
      }
   }
}

// Assembly:
testq %rdi, %rdi
je 0xb5a8
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x7170
movq %rax, %r14
movl 0x3df36(%rip), %eax     # 0x4947c
movslq 0x3df2b(%rip), %rdi     # 0x49478
subl %edi, %eax
cmpl %r14d, %eax
jle 0xb56c
addq 0x3df15(%rip), %rdi     # 0x49470
movq %rbx, %rsi
callq 0x7330
addl 0x3df0e(%rip), %r14d    # 0x49478
jmp 0xb59a
testl %eax, %eax
jle 0xb5a1
addq 0x3def9(%rip), %rdi     # 0x49470
movl %eax, %edx
movq %rbx, %rsi
callq 0x71a0
movq 0x3dee8(%rip), %rax     # 0x49470
movslq 0x3deed(%rip), %rcx     # 0x4947c
movb $0x0, (%rax,%rcx)
movl 0x3dee2(%rip), %r14d    # 0x4947c
movl %r14d, 0x3ded7(%rip)    # 0x49478
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/melop[P]admixem/./newran02/myexcept.cpp
// Function: Tracer::AddTrace()
void Tracer::AddTrace()
{
   if (last)
   {
      Exception::AddMessage("Trace: ");
      Exception::AddMessage(last->entry);
      for (Tracer* et = last->previous; et; et=et->previous)
      {
         Exception::AddMessage("; ");
         Exception::AddMessage(et->entry);
      }
      Exception::AddMessage(".\n");
   }
}

// Assembly:
cmpq $0x0, 0x3dece(%rip)     # 0x49480
je 0xb616
pushq %r14
pushq %rbx
pushq %rax
leaq 0x29d5d(%rip), %rdi     # 0x3531c
callq 0xb52c
movq 0x3deb5(%rip), %rax     # 0x49480
movq (%rax), %rdi
callq 0xb52c
movq 0x3dea6(%rip), %rax     # 0x49480
movq 0x8(%rax), %r14
testq %r14, %r14
je 0xb603
leaq 0x29d3a(%rip), %rbx     # 0x35324
movq %rbx, %rdi
callq 0xb52c
movq (%r14), %rdi
callq 0xb52c
movq 0x8(%r14), %r14
testq %r14, %r14
jne 0xb5ea
leaq 0x2a5b4(%rip), %rdi     # 0x35bbe
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xb52c
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/melop[P]admixem/./newran02/myexcept.cpp
// Function: Exception::AddInt(int)
void Exception::AddInt(int value)
{
   bool negative;
   if (value == 0) { AddMessage("0"); return; }
   else if (value < 0) { value = -value; negative = true; }
   else negative = false;
   int n = 0; int v = value;        // how many digits will we need?
   while (v > 0) { v /= 10; n++; }
   if (negative) n++;
   if (LastOne-SoFar < n) { AddMessage("***"); return; }

   SoFar += n; n = SoFar; what_error[n] = 0;
   while (value > 0)
   {
      int nv = value / 10; int rm = value - nv * 10;  value = nv;
      what_error[--n] = (char)(rm + '0');
   }
   if (negative) what_error[--n] = '-';
   return;
}

// Assembly:
testl %edi, %edi
je 0xb662
movl %edi, %eax
negl %eax
cmovsl %edi, %eax
movl %edi, %ecx
shrl $0x1f, %ecx
movl $0xcccccccd, %edx       # imm = 0xCCCCCCCD
movl %eax, %esi
incl %ecx
movl %esi, %r8d
imulq %rdx, %r8
shrq $0x23, %r8
cmpl $0x9, %esi
movl %r8d, %esi
ja 0xb62f
movl 0x3de32(%rip), %esi     # 0x4947c
movl 0x3de28(%rip), %edx     # 0x49478
subl %edx, %esi
cmpl %ecx, %esi
jge 0xb66e
leaq 0x29cb6(%rip), %rdi     # 0x35313
jmp 0xb52c
leaq 0x2b391(%rip), %rdi     # 0x369fa
jmp 0xb52c
addl %ecx, %edx
movl %edx, 0x3de02(%rip)     # 0x49478
movq 0x3ddf3(%rip), %rcx     # 0x49470
movslq %edx, %rdx
movb $0x0, (%rcx,%rdx)
movq %rdx, %rcx
shlq $0x20, %rcx
decq %rdx
movl $0xcccccccd, %esi       # imm = 0xCCCCCCCD
movabsq $-0x100000000, %r8      # imm = 0xFFFFFFFF00000000
addq %r8, %rcx
movl %eax, %r9d
imulq %rsi, %r9
shrq $0x23, %r9
imull $0xf6, %r9d, %r10d
addl %eax, %r10d
addb $0x30, %r10b
movq 0x3ddb0(%rip), %r11     # 0x49470
movb %r10b, (%r11,%rdx)
decq %rdx
cmpl $0x9, %eax
movl %r9d, %eax
ja 0xb69d
testl %edi, %edi
js 0xb6d4
retq
movq 0x3dd95(%rip), %rax     # 0x49470
sarq $0x20, %rcx
movb $0x2d, -0x1(%rax,%rcx)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/melop[P]admixem/./newran02/newran.cpp
// Function: Random::Raw()
Real Random::Raw()                           // get new uniform random number
{
   // m = 2147483647 = 2^31 - 1; a = 16807;
   // 127773 = m div a; 2836 = m mod a
   long iseed = (long)seed;
   long hi = iseed / 127773L;                 // integer division
   long lo = iseed - hi * 127773L;            // modulo
   iseed = 16807 * lo - 2836 * hi;
   if (iseed <= 0) iseed += 2147483647L;
   seed = (double)iseed; return seed*4.656612875e-10;
}

// Assembly:
cvttsd2si 0x3dad3(%rip), %rcx # 0x494d8
movabsq $0x41a705af1fe3fb79, %rdx # imm = 0x41A705AF1FE3FB79
movq %rcx, %rax
imulq %rdx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0xf, %rdx
addq %rax, %rdx
imulq $-0x1f31d, %rdx, %rax   # imm = 0xFFFE0CE3
addq %rcx, %rax
imulq $0x41a7, %rax, %rax     # imm = 0x41A7
imulq $-0xb14, %rdx, %rcx     # imm = 0xF4EC
leaq (%rax,%rcx), %rdx
testq %rdx, %rdx
leaq 0x7fffffff(%rax,%rcx), %rax
cmovgq %rdx, %rax
cvtsi2sd %rax, %xmm0
movsd %xmm0, 0x3da7d(%rip)    # 0x494d8
mulsd 0x29985(%rip), %xmm0    # 0x353e8
retq
// File: /workspace/github_cpp_makefile_star2_O1/melop[P]admixem/./newran02/newran.cpp
// Function: Random::Next()
Real Random::Next()                          // get new mixed random number
{
   if (!seed)
      Throw(Logic_error("Random number generator not initialised"));
   int i = (int)(Raw()*128);               // 0 <= i < 128
#ifdef _MSC_VER
   DoNothing(i); DoNothing(i);
#endif
   Real f = Buffer[i]; Buffer[i] = Raw();  // Microsoft release gets this wrong
   return f;

   // return Mother(&iseed);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movsd 0x3da24(%rip), %xmm0    # 0x494d8
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xbac4
jnp 0xbb9f
cvttsd2si %xmm0, %rcx
movabsq $0x41a705af1fe3fb79, %rdi # imm = 0x41A705AF1FE3FB79
movq %rcx, %rax
imulq %rdi
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0xf, %rdx
addq %rax, %rdx
imulq $-0x1f31d, %rdx, %rax   # imm = 0xFFFE0CE3
addq %rcx, %rax
imulq $0x41a7, %rax, %rax     # imm = 0x41A7
imulq $-0xb14, %rdx, %rcx     # imm = 0xF4EC
addq %rax, %rcx
movl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
leaq (%rcx,%rsi), %rax
testq %rcx, %rcx
cmovgq %rcx, %rax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
cvttsd2si %xmm0, %rcx
movsd 0x298c1(%rip), %xmm1    # 0x353e8
mulsd %xmm1, %xmm0
mulsd 0x298bd(%rip), %xmm0    # 0x353f0
cvttsd2si %xmm0, %eax
movslq %eax, %r8
leaq 0x3d99f(%rip), %r9      # 0x494e0
movsd (%r9,%r8,8), %xmm0
movq %rcx, %rax
imulq %rdi
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0xf, %rdx
addq %rax, %rdx
imulq $-0x1f31d, %rdx, %rax   # imm = 0xFFFE0CE3
addq %rcx, %rax
imulq $0x41a7, %rax, %rax     # imm = 0x41A7
imulq $-0xb14, %rdx, %rcx     # imm = 0xF4EC
addq %rax, %rcx
addq %rcx, %rsi
testq %rcx, %rcx
cmovgq %rcx, %rsi
cvtsi2sd %rsi, %xmm2
movsd %xmm2, 0x3d94b(%rip)    # 0x494d8
mulsd %xmm1, %xmm2
movsd %xmm2, (%r9,%r8,8)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x1, %edi
callq 0x7180
movq %rax, %rbx
leaq 0x29ba2(%rip), %rsi     # 0x35755
movq %rax, %rdi
callq 0xb7f2
leaq 0x3bdf6(%rip), %rsi     # 0x479b8
movq %rbx, %rdi
xorl %edx, %edx
callq 0x7660
movq %rax, %r14
movq %rbx, %rdi
callq 0x72a0
movq %r14, %rdi
callq 0x76a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/melop[P]admixem/./newran02/newran.cpp
// Function: Random::Set(double)
void Random::Set(double s)            // set random number seed
                                      // s must be between 0 and 1
{
   if (s>=1.0 || s<=0.0)
      Throw(Logic_error("Newran: seed out of range"));
   //iseed = 2147483648L * s;         // for Mother
   seed = (long)(s*2147483648L);
   for (int i = 0; i<128; i++) Buffer[i] = Raw();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
ucomisd 0x2941a(%rip), %xmm0    # 0x35018
jae 0xbcc1
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
jae 0xbcc1
mulsd 0x297de(%rip), %xmm0    # 0x353f8
cvttsd2si %xmm0, %rax
xorps %xmm1, %xmm1
cvtsi2sd %rax, %xmm1
movsd %xmm1, 0x3d8a9(%rip)    # 0x494d8
xorl %esi, %esi
movabsq $0x41a705af1fe3fb79, %rdi # imm = 0x41A705AF1FE3FB79
movsd 0x297a5(%rip), %xmm0    # 0x353e8
leaq 0x3d896(%rip), %r8      # 0x494e0
cvttsd2si %xmm1, %rcx
movq %rcx, %rax
imulq %rdi
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0xf, %rdx
addq %rax, %rdx
imulq $-0x1f31d, %rdx, %rax   # imm = 0xFFFE0CE3
addq %rcx, %rax
imulq $0x41a7, %rax, %rax     # imm = 0x41A7
imulq $-0xb14, %rdx, %rcx     # imm = 0xF4EC
leaq (%rax,%rcx), %rdx
testq %rdx, %rdx
leaq 0x7fffffff(%rax,%rcx), %rax
cmovgq %rdx, %rax
xorps %xmm1, %xmm1
cvtsi2sd %rax, %xmm1
movapd %xmm1, %xmm2
mulsd %xmm0, %xmm2
movsd %xmm2, (%rsi,%r8)
addq $0x8, %rsi
cmpq $0x400, %rsi            # imm = 0x400
jne 0xbc4a
movsd %xmm1, 0x3d81f(%rip)    # 0x494d8
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x1, %edi
callq 0x7180
movq %rax, %rbx
leaq 0x29aa8(%rip), %rsi     # 0x3577d
movq %rax, %rdi
callq 0xb7f2
leaq 0x3bcd4(%rip), %rsi     # 0x479b8
movq %rbx, %rdi
xorl %edx, %edx
callq 0x7660
movq %rax, %r14
movq %rbx, %rdi
callq 0x72a0
movq %r14, %rdi
callq 0x76a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/melop[P]admixem/./newran02/newran.cpp
// Function: PosGen::Build(bool)
void PosGen::Build(bool sym)                 // set up arrays
{
   #ifdef MONITOR
      cout << "building PosGen arrays\n";
   #endif
   int i;
   NotReady=false;
   sx=new Real[60]; sfx=new Real[60];
   if (!sx || !sfx) ErrorNoSpace();
   Real sxi=0.0; Real inc = sym ? 0.01 : 0.02;
   for (i=0; i<60; i++)
   {
      sx[i]=sxi; Real f1=Density(sxi); sfx[i]=f1;
      if (f1<=0.0) goto L20;
      sxi+=inc/f1;
   }
   Throw(Runtime_error("Newran: area too large"));
L20:
   if (i<50) Throw(Runtime_error("Newran: area too small"));
   xi = sym ? 2*i : i;
   return;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movb $0x0, 0x20(%rdi)
movl $0x1e0, %edi            # imm = 0x1E0
callq 0x7030
movq %rax, 0x10(%rbx)
movl $0x1e0, %edi            # imm = 0x1E0
callq 0x7030
movq %rax, 0x18(%rbx)
testl %ebp, %ebp
jne 0xbd65
movsd 0x296a5(%rip), %xmm0    # 0x35408
jmp 0xbd6d
movsd 0x29693(%rip), %xmm0    # 0x35400
movsd %xmm0, (%rsp)
xorl %r14d, %r14d
xorpd %xmm0, %xmm0
movq 0x10(%rbx), %rax
movsd %xmm0, (%rax,%r14,8)
movq (%rbx), %rax
movq %rbx, %rdi
movsd %xmm0, 0x8(%rsp)
callq *0x10(%rax)
movq 0x18(%rbx), %rax
movsd %xmm0, (%rax,%r14,8)
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
jae 0xbdef
movsd (%rsp), %xmm1
divsd %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
addsd %xmm1, %xmm0
incq %r14
cmpq $0x3c, %r14
jne 0xbd79
movl $0x1, %edi
callq 0x7180
movq %rax, %rbx
leaq 0x299c1(%rip), %rsi     # 0x35797
movq %rax, %rdi
callq 0xb82c
leaq 0x3cea3(%rip), %rsi     # 0x48c88
movq %rbx, %rdi
xorl %edx, %edx
callq 0x7660
cmpq $0x31, %r14
jbe 0xbe10
movl %ebp, %ecx
shll %cl, %r14d
xorps %xmm0, %xmm0
cvtsi2sd %r14d, %xmm0
movsd %xmm0, 0x8(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x1, %edi
callq 0x7180
movq %rax, %rbx
leaq 0x2998a(%rip), %rsi     # 0x357ae
movq %rax, %rdi
callq 0xb82c
jmp 0xbdde
jmp 0xbe30
movq %rax, %r14
movq %rbx, %rdi
callq 0x72a0
movq %r14, %rdi
callq 0x76a0
// File: /workspace/github_cpp_makefile_star2_O1/melop[P]admixem/./newran02/newran.cpp
// Function: PosGen::Next()
Real PosGen::Next()
{
   Real ak,y; int ir;
   if (NotReady) Build(false);
   do
   {
      Real r1=Random::Next();
      ir = (int)(r1*xi); Real sxi=sx[ir];
      ak=sxi+(sx[ir+1]-sxi)*Random::Next();
      y=sfx[ir]*Random::Next();
   }
   while ( y>=sfx[ir+1] && y>=Density(ak) );
   return ak;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
cmpb $0x1, 0x20(%rdi)
jne 0xbea2
movq %rbx, %rdi
xorl %esi, %esi
callq 0xbd2a
callq 0xbaa8
mulsd 0x8(%rbx), %xmm0
cvttsd2si %xmm0, %eax
movq 0x10(%rbx), %rcx
movslq %eax, %r14
movsd (%rcx,%r14,8), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x8(%rcx,%r14,8), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
callq 0xbaa8
mulsd 0x8(%rsp), %xmm0
addsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movq 0x18(%rbx), %rax
movsd (%rax,%r14,8), %xmm0
movsd %xmm0, 0x8(%rsp)
callq 0xbaa8
mulsd 0x8(%rsp), %xmm0
movq 0x18(%rbx), %rax
ucomisd 0x8(%rax,%r14,8), %xmm0
jb 0xbf38
movq (%rbx), %rax
movq %rbx, %rdi
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rsp), %xmm0
callq *0x10(%rax)
movsd 0x8(%rsp), %xmm1
ucomisd %xmm0, %xmm1
jae 0xbea2
movsd 0x10(%rsp), %xmm0
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/melop[P]admixem/./newran02/newran.cpp
// Function: SymGen::Next()
Real SymGen::Next()
{
   Real s,ak,y; int ir;
   if (NotReady) Build(true);
   do
   {
      s=1.0;
      Real r1=Random::Next();
      if (r1>0.5) { s=-1.0; r1=1.0-r1; }
      ir = (int)(r1*xi); Real sxi=sx[ir];
      ak=sxi+(sx[ir+1]-sxi)*Random::Next();
      y=sfx[ir]*Random::Next();
   }
   while ( y>=sfx[ir+1] && y>=Density(ak) );
   return s*ak;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
cmpb $0x1, 0x20(%rdi)
jne 0xbf63
movq %rbx, %rdi
movl $0x1, %esi
callq 0xbd2a
callq 0xbaa8
movsd 0x290a8(%rip), %xmm1    # 0x35018
subsd %xmm0, %xmm1
movsd 0x29494(%rip), %xmm2    # 0x35410
cmpltsd %xmm0, %xmm2
andpd %xmm2, %xmm1
movapd %xmm2, 0x20(%rsp)
andnpd %xmm0, %xmm2
orpd %xmm1, %xmm2
mulsd 0x8(%rbx), %xmm2
cvttsd2si %xmm2, %eax
movq 0x10(%rbx), %rcx
movslq %eax, %r14
movsd (%rcx,%r14,8), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x8(%rcx,%r14,8), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
callq 0xbaa8
mulsd 0x8(%rsp), %xmm0
addsd 0x10(%rsp), %xmm0
movapd %xmm0, 0x10(%rsp)
movq 0x18(%rbx), %rax
movsd (%rax,%r14,8), %xmm0
movsd %xmm0, 0x8(%rsp)
callq 0xbaa8
mulsd 0x8(%rsp), %xmm0
movq 0x18(%rbx), %rax
ucomisd 0x8(%rax,%r14,8), %xmm0
jb 0xc024
movq (%rbx), %rax
movq %rbx, %rdi
movsd %xmm0, 0x8(%rsp)
movapd 0x10(%rsp), %xmm0
callq *0x10(%rax)
movsd 0x8(%rsp), %xmm1
ucomisd %xmm0, %xmm1
jae 0xbf63
movaps 0x29065(%rip), %xmm1    # 0x35090
movaps 0x10(%rsp), %xmm2
xorps %xmm2, %xmm1
movaps 0x20(%rsp), %xmm0
andps %xmm0, %xmm1
andnps %xmm2, %xmm0
orps %xmm1, %xmm0
addq $0x38, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/melop[P]admixem/./newran02/newran.cpp
// Function: AsymGen::Build()
void AsymGen::Build()                        // set up arrays
{
   #ifdef MONITOR
      cout << "building AsymGen arrays\n";
   #endif
   int i;
   NotReady=false;
   sx=new Real[121]; sfx=new Real[121];
   if (!sx || !sfx)  ErrorNoSpace();
   Real sxi=mode;
   for (i=0; i<120; i++)
   {
      sx[i]=sxi; Real f1=Density(sxi); sfx[i]=f1;
      if (f1<=0.0) goto L20;
      sxi+=0.01/f1;
   }
   Throw(Runtime_error("Newran: area too large (a)"));
L20:
   ic=i-1; sx[120]=sxi; sfx[120]=0.0;
   sxi=mode;
   for (; i<120; i++)
   {
      sx[i]=sxi; Real f1=Density(sxi); sfx[i]=f1;
      if (f1<=0.0) goto L30;
      sxi-=0.01/f1;
   }
   Throw(Runtime_error("Newran: area too large (b)"));
L30:
   if (i<100)  Throw(Runtime_error("Newran: area too small"));
   xi=i;
   return;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movb $0x0, 0x24(%rdi)
movl $0x3c8, %edi            # imm = 0x3C8
callq 0x7030
movq %rax, 0x10(%rbx)
movl $0x3c8, %edi            # imm = 0x3C8
callq 0x7030
movq %rax, 0x18(%rbx)
movsd 0x28(%rbx), %xmm0
xorl %r14d, %r14d
movq 0x10(%rbx), %rax
movsd %xmm0, (%rax,%r14,8)
movq (%rbx), %rax
movq %rbx, %rdi
movapd %xmm0, (%rsp)
callq *0x10(%rax)
movq 0x18(%rbx), %rax
movsd %xmm0, (%rax,%r14,8)
xorpd %xmm2, %xmm2
ucomisd %xmm0, %xmm2
movsd 0x2933e(%rip), %xmm1    # 0x35400
divsd %xmm0, %xmm1
movapd (%rsp), %xmm3
addsd %xmm3, %xmm1
cmpnlesd %xmm2, %xmm0
andpd %xmm0, %xmm1
andnpd %xmm3, %xmm0
orpd %xmm1, %xmm0
jae 0xc10c
incq %r14
cmpq $0x78, %r14
jne 0xc090
movl $0x1, %edi
callq 0x7180
movq %rax, %rbx
leaq 0x296c6(%rip), %rsi     # 0x357c5
movq %rax, %rdi
callq 0xb82c
jmp 0xc19b
leal -0x1(%r14), %ecx
movl %ecx, 0x20(%rbx)
movq 0x10(%rbx), %rcx
movsd %xmm0, 0x3c0(%rcx)
movq $0x0, 0x3c0(%rax)
cmpq $0x77, %r14
ja 0xc17f
movsd 0x28(%rbx), %xmm0
movq 0x10(%rbx), %rax
movsd %xmm0, (%rax,%r14,8)
movq (%rbx), %rax
movq %rbx, %rdi
movsd %xmm0, (%rsp)
callq *0x10(%rax)
movq 0x18(%rbx), %rax
movsd %xmm0, (%rax,%r14,8)
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
jae 0xc1ac
movsd 0x292af(%rip), %xmm1    # 0x35418
divsd %xmm0, %xmm1
movsd (%rsp), %xmm0
addsd %xmm1, %xmm0
incq %r14
cmpq $0x78, %r14
jne 0xc135
movl $0x1, %edi
callq 0x7180
movq %rax, %rbx
leaq 0x2964d(%rip), %rsi     # 0x357e0
movq %rax, %rdi
callq 0xb82c
leaq 0x3cae6(%rip), %rsi     # 0x48c88
movq %rbx, %rdi
xorl %edx, %edx
callq 0x7660
cmpq $0x63, %r14
jbe 0xc1c7
xorps %xmm0, %xmm0
cvtsi2sd %r14d, %xmm0
movsd %xmm0, 0x8(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movl $0x1, %edi
callq 0x7180
movq %rax, %rbx
leaq 0x295d3(%rip), %rsi     # 0x357ae
movq %rax, %rdi
callq 0xb82c
jmp 0xc19b
jmp 0xc1e9
jmp 0xc1e9
movq %rax, %r14
movq %rbx, %rdi
callq 0x72a0
movq %r14, %rdi
callq 0x76a0
// File: /workspace/github_cpp_makefile_star2_O1/melop[P]admixem/./newran02/newran.cpp
// Function: AsymGen::Next()
Real AsymGen::Next()
{
   Real ak,y; int ir1;
   if (NotReady) Build();
   do
   {
      Real r1=Random::Next();
      int ir=(int)(r1*xi); Real sxi=sx[ir];
      ir1 = (ir==ic) ? 120 : ir+1;
      ak=sxi+(sx[ir1]-sxi)*Random::Next();
      y=sfx[ir]*Random::Next();
   }
   while ( y>=sfx[ir1] && y>=Density(ak) );
   return ak;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
cmpb $0x1, 0x24(%rdi)
jne 0xc217
movq %rbx, %rdi
callq 0xc05e
movl $0x78, %ebp
callq 0xbaa8
mulsd 0x8(%rbx), %xmm0
cvttsd2si %xmm0, %eax
movq 0x10(%rbx), %rcx
movslq %eax, %r14
leal 0x1(%r14), %eax
cmpl %r14d, 0x20(%rbx)
cmovel %ebp, %eax
movsd (%rcx,%r14,8), %xmm0
movsd %xmm0, 0x10(%rsp)
movslq %eax, %r15
movsd (%rcx,%r15,8), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
callq 0xbaa8
mulsd 0x8(%rsp), %xmm0
addsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movq 0x18(%rbx), %rax
movsd (%rax,%r14,8), %xmm0
movsd %xmm0, 0x8(%rsp)
callq 0xbaa8
mulsd 0x8(%rsp), %xmm0
movq 0x18(%rbx), %rax
ucomisd (%rax,%r15,8), %xmm0
jb 0xc2be
movq (%rbx), %rax
movq %rbx, %rdi
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rsp), %xmm0
callq *0x10(%rax)
movsd 0x8(%rsp), %xmm1
ucomisd %xmm0, %xmm1
jae 0xc21c
movsd 0x10(%rsp), %xmm0
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/melop[P]admixem/./newran02/newran.cpp
// Function: ChiSq::Next()
Real ChiSq::Next()
{
   switch(version)
   {
   case 0: return c1->Next();
   case 1: case 2: return c1->Next()*2.0;
   case 3: return c1->Next() + c1->Next();
   case 4: case 5: Real s1 = c1->Next()*2.0; Real s2 = c2->Next();
	   return s1 + s2; // this is to make it work with Microsoft VC5
   }
   return 0;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movl 0x18(%rdi), %eax
cmpq $0x5, %rax
ja 0xc8b3
movq %rdi, %rbx
leaq 0x28c9e(%rip), %rcx     # 0x35500
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
addsd %xmm0, %xmm0
jmp 0xc8b7
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
addsd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x10(%rbx), %rdi
jmp 0xc8a6
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
movsd %xmm0, 0x8(%rsp)
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
addsd 0x8(%rsp), %xmm0
jmp 0xc8b7
xorpd %xmm0, %xmm0
addq $0x10, %rsp
popq %rbx
retq
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
addq $0x10, %rsp
popq %rbx
jmpq *(%rax)
nop
// File: /workspace/github_cpp_makefile_star2_O1/melop[P]admixem/./newran02/newran.cpp
// Function: Poisson1::Density(double) const
Real Poisson1::Density(Real x) const             // Poisson density function
{
   if (x < 0.0) return 0.0;
   double ix = floor(x);                         // use integer part
   double l = ln_mu * ix - mu - ln_gamma(1.0 + ix);
   return  (l < -40.0) ? 0.0 : exp(l);
}

// Assembly:
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
ja 0xca6a
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
callq 0x7740
movsd 0x38(%rbx), %xmm1
mulsd %xmm0, %xmm1
subsd 0x30(%rbx), %xmm1
movsd %xmm1, 0x8(%rsp)
addsd 0x285d1(%rip), %xmm0    # 0x35018
callq 0xca78
movsd 0x8(%rsp), %xmm1
subsd %xmm0, %xmm1
movsd 0x28a0a(%rip), %xmm0    # 0x35468
ucomisd %xmm1, %xmm0
leaq 0x10(%rsp), %rsp
popq %rbx
jbe 0xca6f
xorpd %xmm0, %xmm0
retq
movapd %xmm1, %xmm0
jmp 0x7748
// File: /workspace/github_cpp_makefile_star2_O1/melop[P]admixem/./newran02/newran.cpp
// Function: ln_gamma(double)
Real ln_gamma(Real xx)
{
   // log gamma function adapted from numerical recipes in C

   if (xx<1.0)                           // Use reflection formula
   {
      double piz = 3.14159265359 * (1.0-xx);
      return log(piz/sin(piz))-ln_gamma(2.0-xx);
   }
   else
   {
      static double cof[6]={76.18009173,-86.50532033,24.01409822,
         -1.231739516,0.120858003e-2,-0.536382e-5};

      double x=xx-1.0; double tmp=x+5.5;
      tmp -= (x+0.5)*log(tmp); double ser=1.0;
      for (int j=0;j<=5;j++) { x += 1.0; ser += cof[j]/x; }
      return -tmp+log(2.50662827465*ser);
   }
}

// Assembly:
subq $0x28, %rsp
movapd %xmm0, %xmm1
movsd 0x28590(%rip), %xmm0    # 0x35018
ucomisd %xmm1, %xmm0
jbe 0xcaee
movsd 0x28582(%rip), %xmm0    # 0x35018
subsd %xmm1, %xmm0
mulsd 0x289de(%rip), %xmm0    # 0x35480
movsd %xmm0, (%rsp)
movsd %xmm1, 0x18(%rsp)
callq 0x7718
movsd (%rsp), %xmm1
divsd %xmm0, %xmm1
movapd %xmm1, %xmm0
callq 0x7730
movsd %xmm0, (%rsp)
movsd 0x28977(%rip), %xmm0    # 0x35448
subsd 0x18(%rsp), %xmm0
callq 0xca78
movsd (%rsp), %xmm1
subsd %xmm0, %xmm1
movapd %xmm1, %xmm0
jmp 0xcb8c
addsd 0x28942(%rip), %xmm1    # 0x35438
movsd %xmm1, 0x18(%rsp)
movsd 0x2896c(%rip), %xmm0    # 0x35470
addsd %xmm1, %xmm0
movsd 0x28900(%rip), %xmm2    # 0x35410
addsd %xmm1, %xmm2
movapd %xmm2, (%rsp)
movsd %xmm0, 0x20(%rsp)
callq 0x7730
movsd 0x284ec(%rip), %xmm5    # 0x35018
movsd 0x18(%rsp), %xmm3
movapd (%rsp), %xmm4
xorpd 0x28551(%rip), %xmm4    # 0x35090
xorl %eax, %eax
leaq 0x289d8(%rip), %rcx     # 0x35520
movapd %xmm5, %xmm1
addsd %xmm5, %xmm3
movsd (%rax,%rcx), %xmm2
divsd %xmm3, %xmm2
addsd %xmm2, %xmm1
addq $0x8, %rax
cmpq $0x30, %rax
jne 0xcb4c
mulsd %xmm0, %xmm4
addsd 0x20(%rsp), %xmm4
movapd %xmm4, (%rsp)
mulsd 0x288fa(%rip), %xmm1    # 0x35478
movapd %xmm1, %xmm0
callq 0x7730
subsd (%rsp), %xmm0
addq $0x28, %rsp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/melop[P]admixem/./newran02/newran.cpp
// Function: Binomial1::Density(double) const
Real Binomial1::Density(Real x) const            // Binomial density function
{
   double ix = floor(x);                         // use integer part
   if (ix < 0.0 || ix > n) return 0.0;
   double l = ln_n_fac - ln_gamma(ix+1) - ln_gamma(n-ix+1)
      + ix * ln_p + (n-ix) * ln_q;
   return  (l < -40.0) ? 0.0 : exp(l);
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
callq 0x7740
movapd %xmm0, %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm1, %xmm0
ja 0xccb8
xorps %xmm0, %xmm0
cvtsi2sdl 0x58(%rbx), %xmm0
ucomisd %xmm0, %xmm1
ja 0xccb8
movsd 0x50(%rbx), %xmm0
movsd %xmm0, (%rsp)
movapd %xmm1, %xmm0
addsd 0x283d3(%rip), %xmm0    # 0x35018
movsd %xmm1, 0x8(%rsp)
callq 0xca78
movsd (%rsp), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
xorps %xmm0, %xmm0
cvtsi2sdl 0x58(%rbx), %xmm0
subsd 0x8(%rsp), %xmm0
addsd 0x283a4(%rip), %xmm0    # 0x35018
callq 0xca78
movsd (%rsp), %xmm2
subsd %xmm0, %xmm2
movsd 0x40(%rbx), %xmm1
movsd 0x8(%rsp), %xmm3
mulsd %xmm3, %xmm1
xorps %xmm0, %xmm0
cvtsi2sdl 0x58(%rbx), %xmm0
addsd %xmm2, %xmm1
subsd %xmm3, %xmm0
mulsd 0x48(%rbx), %xmm0
addsd %xmm1, %xmm0
movsd 0x287b6(%rip), %xmm1    # 0x35468
ucomisd %xmm0, %xmm1
jbe 0xccc2
xorpd %xmm0, %xmm0
addq $0x10, %rsp
popq %rbx
retq
addq $0x10, %rsp
popq %rbx
jmp 0x7748
// File: /workspace/github_cpp_makefile_star2_O1/melop[P]admixem/./newran02/newran.cpp
// Function: Poisson2::Poisson2(double)
Poisson2::Poisson2(Real mux)
{
   Real probs[40];
   probs[0]=exp(-mux);
   for (int i=1; i<40; i++) probs[i]=probs[i-1]*mux/i;
   dg=new DiscreteGen(40,probs);
   if (!dg) ErrorNoSpace();
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x158, %rsp            # imm = 0x158
movapd %xmm0, %xmm1
movapd %xmm0, (%rsp)
movq %rdi, %rbx
leaq 0x3b117(%rip), %rax     # 0x47e00
movq %rax, (%rdi)
movapd 0x2839c(%rip), %xmm0    # 0x35090
xorpd %xmm1, %xmm0
callq 0x7748
movapd (%rsp), %xmm2
movsd %xmm0, 0x10(%rsp)
movl $0x1, %eax
mulsd %xmm2, %xmm0
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rsp,%rax,8)
incq %rax
cmpq $0x28, %rax
jne 0xcd0d
movl $0x38, %edi
callq 0x7380
movq %rax, %r14
leaq 0x10(%rsp), %rdx
movq %rax, %rdi
movl $0x28, %esi
callq 0xd4f0
movq %r14, 0x8(%rbx)
addq $0x158, %rsp            # imm = 0x158
popq %rbx
popq %r14
retq
movq %rax, %rbx
movl $0x38, %esi
movq %r14, %rdi
callq 0x7390
movq %rbx, %rdi
callq 0x76a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/melop[P]admixem/./newran02/newran.cpp
// Function: Binomial2::Binomial2(int, double)
Binomial2::Binomial2(int nx, Real px)
{
   Real qx = 1.0 - px;
   Real probs[40];
   int k = (int)(nx * px);
   probs[k] = exp(ln_gamma(nx+1) - ln_gamma(k+1) - ln_gamma(nx-k+1)
      + k * log(px) + (nx-k) * log(qx));
   int i;
   int m = (nx >= 40) ? 39 : nx;
   for (i=k+1; i<=m; i++) probs[i]=probs[i-1] * px * (nx-i+1) / qx / i;
   for (i=k-1; i>=0; i--) probs[i]=probs[i+1] * qx * (i+1) / px / (nx-i);
   dg = new DiscreteGen(m + 1, probs);
   if (!dg) ErrorNoSpace();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x188, %rsp            # imm = 0x188
movsd %xmm0, 0x28(%rsp)
movl %esi, %ebx
leaq 0x3b088(%rip), %rax     # 0x47e60
movq %rdi, 0x30(%rsp)
movq %rax, (%rdi)
cvtsi2sd %esi, %xmm2
movsd 0x2822c(%rip), %xmm1    # 0x35018
mulsd %xmm0, %xmm2
movapd %xmm2, 0x10(%rsp)
cvttsd2si %xmm2, %r12d
subsd %xmm0, %xmm1
movsd %xmm1, 0x20(%rsp)
leal 0x1(%rbx), %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
callq 0xca78
movsd %xmm0, 0x8(%rsp)
leal 0x1(%r12), %r13d
xorps %xmm0, %xmm0
cvtsi2sd %r13d, %xmm0
callq 0xca78
movsd %xmm0, 0x38(%rsp)
movl %ebx, %r14d
subl %r12d, %r14d
leal 0x1(%r14), %r15d
xorps %xmm0, %xmm0
cvtsi2sd %r15d, %xmm0
callq 0xca78
movsd 0x8(%rsp), %xmm1
subsd 0x38(%rsp), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
cvttpd2dq 0x10(%rsp), %xmm0
cvtdq2pd %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movsd 0x28(%rsp), %xmm0
callq 0x7730
mulsd 0x10(%rsp), %xmm0
addsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
xorps %xmm0, %xmm0
cvtsi2sd %r14d, %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x20(%rsp), %xmm0
callq 0x7730
mulsd 0x10(%rsp), %xmm0
addsd 0x8(%rsp), %xmm0
callq 0x7748
movsd 0x20(%rsp), %xmm3
movsd 0x28(%rsp), %xmm2
movslq %r12d, %rax
movsd %xmm0, 0x40(%rsp,%rax,8)
cmpl $0x27, %ebx
movl $0x27, %ebp
cmovll %ebx, %ebp
cmpl %eax, %ebp
jle 0xcf2c
leaq (%rsp,%rax,8), %rax
addq $0x48, %rax
movsd -0x8(%rax), %xmm0
movl %ebp, %ecx
negl %ecx
mulsd %xmm2, %xmm0
xorps %xmm1, %xmm1
cvtsi2sd %r14d, %xmm1
mulsd %xmm0, %xmm1
divsd %xmm3, %xmm1
xorps %xmm0, %xmm0
cvtsi2sd %r13d, %xmm0
divsd %xmm0, %xmm1
movsd %xmm1, (%rax)
decl %r14d
addq $0x8, %rax
leal (%rcx,%r13), %edx
incl %edx
movl %r13d, %esi
incl %esi
movl %esi, %r13d
movapd %xmm1, %xmm0
cmpl $0x1, %edx
jne 0xceea
testl %r12d, %r12d
jle 0xcf73
movl %r12d, %eax
movsd 0x40(%rsp,%rax,8), %xmm0
xorps %xmm1, %xmm1
cvtsi2sd %eax, %xmm1
mulsd %xmm3, %xmm0
mulsd %xmm0, %xmm1
xorps %xmm0, %xmm0
cvtsi2sd %r15d, %xmm0
divsd %xmm2, %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, 0x38(%rsp,%rax,8)
leaq -0x1(%rax), %rcx
incl %r15d
movapd %xmm1, %xmm0
cmpq $0x1, %rax
movq %rcx, %rax
jg 0xcf3a
movl $0x38, %edi
callq 0x7380
movq %rax, %r14
incl %ebp
leaq 0x40(%rsp), %rdx
movq %rax, %rdi
movl %ebp, %esi
callq 0xd4f0
movq 0x30(%rsp), %rax
movq %r14, 0x8(%rax)
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x38, %esi
movq %r14, %rdi
callq 0x7390
movq %rbx, %rdi
callq 0x76a0
// File: /workspace/github_cpp_makefile_star2_O1/melop[P]admixem/./newran02/newran.cpp
// Function: NegativeBinomial::Density(double) const
Real NegativeBinomial::Density(Real x) const
{
   if (x < 0.0) return 0.0;
   Real ix = floor(x);
   Real l = c + ln_gamma(ix + N) - ln_gamma(ix + 1) + ix * ln_q;
   return  (l < -40.0) ? 0.0 : exp(l);
}

// Assembly:
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
ja 0xd2ac
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
callq 0x7740
movapd %xmm0, %xmm1
movsd %xmm0, 0x8(%rsp)
movsd 0x58(%rbx), %xmm0
movsd %xmm0, (%rsp)
movsd 0x30(%rbx), %xmm0
addsd %xmm1, %xmm0
callq 0xca78
addsd (%rsp), %xmm0
movsd %xmm0, (%rsp)
movsd 0x27da3(%rip), %xmm0    # 0x35018
addsd 0x8(%rsp), %xmm0
callq 0xca78
movsd (%rsp), %xmm2
subsd %xmm0, %xmm2
movsd 0x8(%rsp), %xmm1
mulsd 0x50(%rbx), %xmm1
addsd %xmm2, %xmm1
movsd 0x281c8(%rip), %xmm0    # 0x35468
ucomisd %xmm1, %xmm0
leaq 0x10(%rsp), %rsp
popq %rbx
jbe 0xd2b1
xorpd %xmm0, %xmm0
retq
movapd %xmm1, %xmm0
jmp 0x7748
// File: /workspace/github_cpp_makefile_star2_O1/melop[P]admixem/./newran02/newran.cpp
// Function: Gamma::Gamma(double)
Gamma::Gamma(Real alpha)                         // general gamma generator
{
   if (alpha<1.0) method = new Gamma1(alpha);
   else if (alpha==1.0) method = new Exponential();
   else method = new Gamma2(alpha);
   if (!method)  ErrorNoSpace();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x3acaa(%rip), %rax     # 0x480a0
movq %rax, (%rdi)
movsd 0x27c17(%rip), %xmm1    # 0x35018
ucomisd %xmm0, %xmm1
jbe 0xd45b
movl $0x40, %edi
movsd %xmm0, (%rsp)
callq 0x7380
movq %rax, %r14
movb $0x1, 0x20(%rax)
leaq 0x3abbc(%rip), %rax     # 0x47fe0
movq %rax, (%r14)
movsd (%rsp), %xmm1
movapd %xmm1, %xmm0
movsd 0x27be0(%rip), %xmm2    # 0x35018
addsd %xmm2, %xmm0
divsd %xmm1, %xmm2
movsd %xmm2, 0x30(%r14)
callq 0xca78
movsd %xmm0, 0x28(%r14)
movsd (%rsp), %xmm0
jmp 0xd4de
ucomisd 0x27bb5(%rip), %xmm0    # 0x35018
jne 0xd499
jp 0xd499
movl $0x28, %edi
callq 0x7380
movq %rax, %r14
xorpd %xmm0, %xmm0
movapd %xmm0, (%rax)
movapd %xmm0, 0x10(%rax)
movq $0x0, 0x20(%rax)
movb $0x1, 0x20(%rax)
leaq 0x3b624(%rip), %rax     # 0x48ab8
movq %rax, (%r14)
jmp 0xd4e4
movl $0x40, %edi
movsd %xmm0, (%rsp)
callq 0x7380
movq %rax, %r14
movsd 0x27f85(%rip), %xmm0    # 0x35438
movsd (%rsp), %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, 0x28(%rax)
movb $0x1, 0x24(%rax)
leaq 0x3ab74(%rip), %rax     # 0x48040
movq %rax, (%r14)
movsd %xmm1, 0x30(%r14)
movapd %xmm1, %xmm0
callq 0xca78
movsd %xmm0, 0x38(%r14)
movq %r14, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/melop[P]admixem/./newran02/newran.cpp
// Function: DiscreteGen::DiscreteGen(int, double*)
DiscreteGen::DiscreteGen(int n1, Real* prob)     // discrete generator
						 // values on 0,...,n1-1
{
   #ifdef MONITOR
      cout << "constructing DiscreteGen\n";
   #endif
   Gen(n1, prob); val=0;
   mean=0.0; var=0.0;
   { for (int i=0; i<n; i++) mean = mean + i*prob[i]; }
   { for (int i=0; i<n; i++) var = var + square(i-mean) * prob[i]; }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
leaq 0x3abff(%rip), %rax     # 0x48100
movq %rax, (%rdi)
callq 0xd588
xorpd %xmm0, %xmm0
movupd %xmm0, 0x20(%r14)
movq $0x0, 0x30(%r14)
movslq 0x18(%r14), %rax
testq %rax, %rax
jle 0xd548
xorpd %xmm0, %xmm0
xorl %ecx, %ecx
xorps %xmm1, %xmm1
cvtsi2sd %ecx, %xmm1
mulsd (%rbx,%rcx,8), %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, 0x28(%r14)
incq %rcx
cmpq %rcx, %rax
jne 0xd52a
testl %eax, %eax
jle 0xd580
movsd 0x28(%r14), %xmm0
movsd 0x30(%r14), %xmm1
xorl %ecx, %ecx
xorps %xmm2, %xmm2
cvtsi2sd %ecx, %xmm2
subsd %xmm0, %xmm2
mulsd %xmm2, %xmm2
mulsd (%rbx,%rcx,8), %xmm2
addsd %xmm2, %xmm1
movsd %xmm1, 0x30(%r14)
incq %rcx
cmpq %rcx, %rax
jne 0xd55a
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/melop[P]admixem/./newran02/newran.cpp
// Function: DiscreteGen::DiscreteGen(int, double*, double*)
DiscreteGen::DiscreteGen(int n1, Real* prob, Real* val1)
                                                 // discrete generator
                                                 // values on *val
{
   #ifdef MONITOR
      cout << "constructing DiscreteGen\n";
   #endif
   Gen(n1, prob); val = new Real[n1];
   if (!val)  ErrorNoSpace();
   for (int i=0; i<n1; i++) val[i]=val1[i];
   mean=0.0; var=0.0;
   { for (int i=0; i<n; i++) mean = mean + val[i]*prob[i]; }
   { for (int i=0; i<n; i++) var = var + square(val[i]-mean)*prob[i]; }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r12
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
leaq 0x3a939(%rip), %rax     # 0x48100
movq %rax, (%rdi)
callq 0xd588
movslq %ebp, %r13
leaq (,%r13,8), %rax
testl %r13d, %r13d
movq $-0x1, %rdi
cmovnsq %rax, %rdi
callq 0x7030
movq %rax, %r15
movq %rax, 0x20(%r14)
testl %r13d, %r13d
jle 0xd80a
movl %ebp, %edx
shlq $0x3, %rdx
movq %r15, %rdi
movq %r12, %rsi
callq 0x72e0
xorpd %xmm0, %xmm0
movupd %xmm0, 0x28(%r14)
movslq 0x18(%r14), %rax
testq %rax, %rax
jle 0xd842
leaq 0x28(%r14), %rcx
xorpd %xmm0, %xmm0
xorl %edx, %edx
movsd (%r15,%rdx,8), %xmm1
mulsd (%rbx,%rdx,8), %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, (%rcx)
incq %rdx
cmpq %rdx, %rax
jne 0xd827
testl %eax, %eax
jle 0xd879
movsd 0x28(%r14), %xmm0
movsd 0x30(%r14), %xmm1
xorl %ecx, %ecx
movsd (%r15,%rcx,8), %xmm2
subsd %xmm0, %xmm2
mulsd %xmm2, %xmm2
mulsd (%rbx,%rcx,8), %xmm2
addsd %xmm2, %xmm1
movsd %xmm1, 0x30(%r14)
incq %rcx
cmpq %rcx, %rax
jne 0xd854
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/melop[P]admixem/./newran02/newran.cpp
// Function: MultipliedRandom::Variance() const
ExtReal MultipliedRandom::Variance() const
{
   ExtReal e1 = square(rv1->Mean()); ExtReal e2 = square(rv2->Mean());
   ExtReal v1 = rv1->Variance(); ExtReal v2 = rv2->Variance();
   ExtReal r=v1*v2+v1*e2+e1*v2;
   return r;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdi, %r14
movq 0x8(%rdi), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
leaq 0x18(%rsp), %r15
movsd %xmm0, (%r15)
movl %eax, 0x8(%r15)
movq %r15, %rdi
movq %r15, %rsi
callq 0xaecc
leaq 0x78(%rsp), %rbx
movsd %xmm0, (%rbx)
movl %eax, 0x8(%rbx)
movq 0x10(%r14), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
leaq 0x8(%rsp), %r12
movsd %xmm0, (%r12)
movl %eax, 0x8(%r12)
movq %r12, %rdi
movq %r12, %rsi
callq 0xaecc
movsd %xmm0, (%r15)
movl %eax, 0x8(%r15)
movq 0x8(%r14), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
movsd %xmm0, (%r12)
movl %eax, 0x8(%r12)
movq 0x10(%r14), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
leaq 0x68(%rsp), %r14
movsd %xmm0, (%r14)
movl %eax, 0x8(%r14)
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xaecc
leaq 0x48(%rsp), %r12
movsd %xmm0, (%r12)
movl %eax, 0x8(%r12)
leaq 0x18(%rsp), %rsi
movq %r15, %rdi
callq 0xaecc
leaq 0x38(%rsp), %rsi
movsd %xmm0, (%rsi)
movl %eax, 0x8(%rsi)
movq %r12, %rdi
callq 0xadf8
leaq 0x58(%rsp), %r15
movsd %xmm0, (%r15)
movl %eax, 0x8(%r15)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xaecc
leaq 0x28(%rsp), %rsi
movsd %xmm0, (%rsi)
movl %eax, 0x8(%rsi)
movq %r15, %rdi
callq 0xadf8
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/melop[P]admixem/./newran02/newran.cpp
// Function: MixedRandom::MixedRandom(int, double*, Random**)
MixedRandom::MixedRandom(int nx, Real* probs, Random** rvx)
{
   n = nx;
   rv = new Random*[n]; if (!rv) ErrorNoSpace();
   for (int i=0; i<n; i++) rv[i]=rvx[i];
   Build(probs);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r15
leaq 0x39e8a(%rip), %rax     # 0x48160
movq %rax, (%rdi)
movl $0x4, %eax
movl %eax, 0x28(%rdi)
movl %eax, 0x38(%rdi)
movl %esi, 0x8(%rdi)
movslq %esi, %r12
leaq (,%r12,8), %rax
testl %r12d, %r12d
movq $-0x1, %rdi
cmovnsq %rax, %rdi
callq 0x7030
movq %rax, 0x18(%r15)
testl %r12d, %r12d
jle 0xe326
movl %ebp, %eax
xorl %ecx, %ecx
movq (%r14,%rcx,8), %rdx
movq 0x18(%r15), %rsi
movq %rdx, (%rsi,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0xe312
movq %r15, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xe33a
nop
// File: /workspace/github_cpp_makefile_star2_O1/melop[P]admixem/./newran02/newran.cpp
// Function: MixedRandom::Build(double*)
void MixedRandom::Build(Real* probs)
{
   int i;
   dg=new DiscreteGen(n,probs);
   if (!dg) ErrorNoSpace();
   mean=0.0; var=0.0;
   for (i=0; i<n; i++) mean = mean + (rv[i])->Mean()*probs[i];
   for (i=0; i<n; i++)
   {
      ExtReal sigsq=(rv[i])->Variance();
      ExtReal mudif=(rv[i])->Mean()-mean;
      var = var + (sigsq+square(mudif))*probs[i];
   }

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movl $0x38, %edi
callq 0x7380
movq %rax, %r15
movl 0x8(%r14), %esi
movq %rax, %rdi
movq %rbx, %rdx
callq 0xd4f0
movq %r15, 0x10(%r14)
leaq 0x20(%r14), %r15
xorl %eax, %eax
movq %rax, 0x20(%r14)
movl %eax, 0x28(%r14)
movq %rax, 0x30(%r14)
movl %eax, 0x38(%r14)
cmpl %eax, 0x8(%r14)
jle 0xe3f8
xorl %r12d, %r12d
movq %rsp, %r13
leaq 0x20(%rsp), %rbp
movq 0x18(%r14), %rax
movq (%rax,%r12,8), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
movsd %xmm0, 0x10(%rsp)
movl %eax, 0x18(%rsp)
movsd (%rbx,%r12,8), %xmm0
movl $0x0, 0x8(%rsp)
movsd %xmm0, (%rsp)
leaq 0x10(%rsp), %rdi
movq %r13, %rsi
callq 0xaecc
movsd %xmm0, 0x20(%rsp)
movl %eax, 0x28(%rsp)
movq %r15, %rdi
movq %rbp, %rsi
callq 0xadf8
movsd %xmm0, 0x20(%r14)
movl %eax, 0x28(%r14)
incq %r12
movslq 0x8(%r14), %rax
cmpq %rax, %r12
jl 0xe395
cmpl $0x0, 0x8(%r14)
jle 0xe4dc
leaq 0x30(%r14), %rax
movq %rax, 0x30(%rsp)
xorl %r12d, %r12d
movq %rsp, %r13
leaq 0x10(%rsp), %rbp
movq 0x18(%r14), %rax
movq (%rax,%r12,8), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
movsd %xmm0, 0x20(%rsp)
movl %eax, 0x28(%rsp)
movq 0x18(%r14), %rax
movq (%rax,%r12,8), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
movsd %xmm0, (%rsp)
movl %eax, 0x8(%rsp)
movq %r13, %rdi
movq %r15, %rsi
callq 0xae62
movsd %xmm0, 0x10(%rsp)
movl %eax, 0x18(%rsp)
movq %rbp, %rdi
movq %rbp, %rsi
callq 0xaecc
movsd %xmm0, 0x48(%rsp)
movl %eax, 0x50(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0xadf8
movsd %xmm0, 0x58(%rsp)
movl %eax, 0x60(%rsp)
movsd (%rbx,%r12,8), %xmm0
movl $0x0, 0x40(%rsp)
movsd %xmm0, 0x38(%rsp)
leaq 0x58(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0xaecc
movsd %xmm0, (%rsp)
movl %eax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
movq %r13, %rsi
callq 0xadf8
movsd %xmm0, 0x30(%r14)
movl %eax, 0x38(%r14)
incq %r12
movslq 0x8(%r14), %rax
cmpq %rax, %r12
jl 0xe417
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x38, %esi
movq %r15, %rdi
callq 0x7390
movq %rbx, %rdi
callq 0x76a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/melop[P]admixem/./newran02/newran.cpp
// Function: MixedRandom::MixedRandom(AddedSelectedRandom&)
MixedRandom::MixedRandom(AddedSelectedRandom& sr)
{
   n = sr.nelems();                       // number of terms;
   Real* probs = new Real[n]; rv = new Random*[n];
   if (!probs || !rv) ErrorNoSpace();
   int i=0; sr.load(&i,probs,rv);
   Build(probs); delete [] probs;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x39c47(%rip), %rax     # 0x48160
movq %rax, (%rdi)
movl $0x4, %eax
movl %eax, 0x28(%rdi)
movl %eax, 0x38(%rdi)
movq (%rsi), %rax
movq %rsi, %rdi
callq *0x40(%rax)
movl %eax, 0x8(%rbx)
cltq
leaq (,%rax,8), %rcx
testl %eax, %eax
movq $-0x1, %r15
cmovnsq %rcx, %r15
movq %r15, %rdi
callq 0x7030
movq %rax, %r12
movq %r15, %rdi
callq 0x7030
movq %rax, 0x18(%rbx)
leaq 0x4(%rsp), %rsi
movl $0x0, (%rsi)
movq (%r14), %r8
movq %r14, %rdi
movq %r12, %rdx
movq %rax, %rcx
callq *0x48(%r8)
movq %rbx, %rdi
movq %r12, %rsi
callq 0xe33a
movq %r12, %rdi
callq 0x7490
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop