LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/melop[P]admixem/./parser/parser.cpp
// Function: Parser::Comparison(bool)
const double Parser::Comparison (const bool get)  // LT, GT, LE, EQ etc.
  {
  double left = AddSubtract (get);
  while (true)
    {
    switch (type_)
      {
      case LT:  left = left <  AddSubtract (true) ? 1.0 : 0.0; break;
      case GT:  left = left >  AddSubtract (true) ? 1.0 : 0.0; break;
      case LE:  left = left <= AddSubtract (true) ? 1.0 : 0.0; break;
      case GE:  left = left >= AddSubtract (true) ? 1.0 : 0.0; break;
      case EQ:  left = left == AddSubtract (true) ? 1.0 : 0.0; break;
      case NE:  left = left != AddSubtract (true) ? 1.0 : 0.0; break;
           default:    return left;
      } // end of switch on type
    }   // end of loop
  }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
callq 0x90cc
leaq 0x23f29(%rip), %r14     # 0x2d068
pushq $0x1
popq %rbp
movl 0x30(%rbx), %eax
addl $-0x3c, %eax
cmpl $0x6, %eax
ja 0x9202
movslq (%r14,%rax,4), %rax
addq %r14, %rax
movsd %xmm0, 0x8(%rsp)
jmpq *%rax
movq %rbx, %rdi
movl %ebp, %esi
callq 0x90cc
ucomisd 0x8(%rsp), %xmm0
jmp 0x91c8
movq %rbx, %rdi
movl %ebp, %esi
callq 0x90cc
movsd 0x8(%rsp), %xmm1
cmpneqsd %xmm0, %xmm1
jmp 0x91e2
movq %rbx, %rdi
movl %ebp, %esi
callq 0x90cc
movsd 0x8(%rsp), %xmm1
ucomisd %xmm0, %xmm1
jmp 0x91af
movq %rbx, %rdi
movl %ebp, %esi
callq 0x90cc
ucomisd 0x8(%rsp), %xmm0
setae %al
jmp 0x91ea
movq %rbx, %rdi
movl %ebp, %esi
callq 0x90cc
movsd 0x8(%rsp), %xmm1
ucomisd %xmm0, %xmm1
seta %al
jmp 0x91ea
movq %rbx, %rdi
movl %ebp, %esi
callq 0x90cc
movsd 0x8(%rsp), %xmm1
cmpeqsd %xmm0, %xmm1
movq %xmm1, %rax
andl $0x1, %eax
movsd 0x23e1e(%rip), %xmm0    # 0x2d010
testb %al, %al
jne 0x9142
xorps %xmm0, %xmm0
jmp 0x9142
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/melop[P]admixem/./parser/parser.cpp
// Function: Parser::Evaluate()
const double Parser::Evaluate ()  // get result
  {
  pWord_    = program_.c_str ();
  type_     = NONE;
  double v = CommaList (true);
  if (type_ != END)
    throw std::runtime_error ("Unexpected text at end of expression: " + std::string (pWordStart_));
  return v;  
  }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %r14
movq (%rdi), %rax
movq %rax, 0x20(%rdi)
andl $0x0, 0x30(%rdi)
pushq $0x1
popq %rsi
callq 0x8fea
cmpl $0x3, 0x30(%r14)
jne 0x923a
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x71d0
movq %rax, %rbx
movq 0x28(%r14), %rsi
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x9512
leaq 0x23f15(%rip), %rsi     # 0x2d174
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0x939b
movb $0x1, %bpl
leaq 0x30(%rsp), %rsi
movq %rbx, %rdi
callq 0x7630
xorl %ebp, %ebp
movq 0x3bd69(%rip), %rsi     # 0x44ff0
movq 0x3bcfa(%rip), %rdx     # 0x44f88
movq %rbx, %rdi
callq 0x76a0
movq %rax, %r14
leaq 0x30(%rsp), %rdi
callq 0x71a0
jmp 0x92ab
movq %rax, %r14
movb $0x1, %bpl
leaq 0x10(%rsp), %rdi
callq 0x71a0
testb %bpl, %bpl
jne 0x92bf
jmp 0x92c7
movq %rax, %r14
movq %rbx, %rdi
callq 0x7300
movq %r14, %rdi
callq 0x76d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x7220
leaq 0x2705d(%rip), %rsi     # 0x30343
movq %rbx, %rdi
callq 0x954d
movb %al, 0x60(%r14)
leaq 0x256d1(%rip), %rsi     # 0x2e9ca
movq %rbx, %rdi
callq 0x954d
movb %al, 0x61(%r14)
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x920c
// File: /workspace/github_cpp_makefile_star2_O2/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 0x93dc
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r14
popq %rbp
retq
movl %esi, %ebx
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x7530
leaq 0x23d4b(%rip), %rsi     # 0x2d13d
movq %r14, %rdi
callq 0x73d0
movsbl %bl, %esi
movq %rax, %rdi
callq 0x7490
leaq 0x23df5(%rip), %rsi     # 0x2d201
movq %rax, %rdi
callq 0x73d0
pushq $0x10
popq %rdi
callq 0x71d0
movq %rax, %rbx
leaq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x75f0
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x7630
xorl %ebp, %ebp
movq 0x3bba9(%rip), %rsi     # 0x44ff0
movq 0x3bb3a(%rip), %rdx     # 0x44f88
movq %rbx, %rdi
callq 0x76a0
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x71a0
testb %bpl, %bpl
jne 0x946d
jmp 0x947a
movq %rax, %r14
movq %rbx, %rdi
callq 0x7300
jmp 0x947a
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x70e0
movq %r14, %rdi
callq 0x76d0
// File: /workspace/github_cpp_makefile_star2_O2/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), %edx
movl 0x8(%rsi), %ecx
movl %edx, %eax
orl %ecx, %eax
jne 0xa7f3
movsd (%rdi), %xmm0
addsd (%rsi), %xmm0
xorl %eax, %eax
retq
cmpl $0x4, %edx
sete %al
cmpl $0x4, %ecx
sete %r8b
orb %al, %r8b
je 0xa809
pushq $0x4
popq %rax
retq
cmpl $0x3, %edx
sete %al
cmpl $0x3, %ecx
sete %r8b
orb %al, %r8b
pushq $0x3
popq %rax
je 0xa81f
retq
cmpl $0x2, %edx
je 0xa836
cmpl $0x1, %edx
jne 0xa843
cmpl $0x2, %ecx
je 0xa849
movsd (%rdi), %xmm0
pushq $0x1
jmp 0xa841
cmpl $0x1, %ecx
je 0xa849
movsd (%rdi), %xmm0
pushq $0x2
popq %rax
retq
movsd (%rsi), %xmm0
movl %ecx, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rax
movl 0x8(%rdi), %edx
movl 0x8(%rsi), %ecx
movl %edx, %eax
orl %ecx, %eax
jne 0xa8d1
movsd (%rdi), %xmm0
mulsd (%rsi), %xmm0
xorl %eax, %eax
jmp 0xa8fd
cmpl $0x4, %edx
sete %al
cmpl $0x4, %ecx
sete %r8b
orb %al, %r8b
je 0xa8e8
pushq $0x4
popq %rax
jmp 0xa8fd
cmpl $0x3, %edx
sete %al
cmpl $0x3, %ecx
sete %r8b
orb %al, %r8b
pushq $0x3
popq %rax
je 0xa8ff
popq %rcx
retq
testl %edx, %edx
je 0xa914
testl %ecx, %ecx
je 0xa930
cmpl $0x1, %edx
jne 0xa926
movsd (%rsi), %xmm0
movl %ecx, %eax
jmp 0xa8fd
movsd (%rdi), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xa924
jnp 0xa8fd
ja 0xa90c
movq %rsi, %rdi
callq 0xa94a
jmp 0xa8fd
movsd (%rsi), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xa940
jnp 0xa8fd
jbe 0xa929
movsd (%rdi), %xmm0
movl %edx, %eax
jmp 0xa8fd
// File: /workspace/github_cpp_makefile_star2_O2/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 0xa9d4
leaq 0x228b9(%rip), %rcx     # 0x2d24c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movsd (%rsi), %xmm0
movq %rbx, %rdi
callq 0x7620
jmp 0xa9d4
leaq 0x228d7(%rip), %rsi     # 0x2d288
jmp 0xa9cc
leaq 0x228b4(%rip), %rsi     # 0x2d26e
jmp 0xa9cc
leaq 0x228ba(%rip), %rsi     # 0x2d27d
jmp 0xa9cc
leaq 0x22894(%rip), %rsi     # 0x2d260
movq %rbx, %rdi
callq 0x73d0
movq %rbx, %rax
popq %rbx
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3a6fc(%rip)           # 0x45498
andl $0x0, 0x3a705(%rip)     # 0x454a8
movq %rsi, %rbx
cmpq $0x0, 0x3a6f2(%rip)     # 0x454a0
jne 0xadcb
movl $0x1ff, 0x3a6f2(%rip)   # imm = 0x1FF
movl $0x200, %edi            # imm = 0x200
callq 0x7030
movq %rax, 0x3a6d5(%rip)     # 0x454a0
leaq 0x22509(%rip), %rdi     # 0x2d2db
callq 0xadec
movq %rbx, %rdi
callq 0xadec
testq %rbx, %rbx
je 0xadea
popq %rbx
jmp 0xae6a
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0xae68
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x7180
movq %rax, %r14
movl 0x3a6a6(%rip), %eax     # 0x454ac
movslq 0x3a69b(%rip), %rdi     # 0x454a8
subl %edi, %eax
cmpl %r14d, %eax
jle 0xae2c
addq 0x3a685(%rip), %rdi     # 0x454a0
movq %rbx, %rsi
callq 0x7390
addl 0x3a67e(%rip), %r14d    # 0x454a8
jmp 0xae5a
testl %eax, %eax
jle 0xae61
addq 0x3a669(%rip), %rdi     # 0x454a0
movl %eax, %edx
movq %rbx, %rsi
callq 0x7200
movq 0x3a658(%rip), %rax     # 0x454a0
movslq 0x3a65d(%rip), %rcx     # 0x454ac
movb $0x0, (%rax,%rcx)
movl 0x3a652(%rip), %r14d    # 0x454ac
movl %r14d, 0x3a647(%rip)    # 0x454a8
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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, 0x3a63e(%rip)     # 0x454b0
je 0xaecf
pushq %r14
pushq %rbx
pushq %rax
leaq 0x22485(%rip), %rdi     # 0x2d304
callq 0xadec
movq 0x3a625(%rip), %rax     # 0x454b0
movq (%rax), %rdi
callq 0xadec
movq 0x3a616(%rip), %r14     # 0x454b0
leaq 0x2246b(%rip), %rbx     # 0x2d30c
movq 0x8(%r14), %r14
testq %r14, %r14
je 0xaebc
movq %rbx, %rdi
callq 0xadec
movq (%r14), %rdi
callq 0xadec
jmp 0xaea1
leaq 0x22ccb(%rip), %rdi     # 0x2db8e
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xadec
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0xaf13
movl %edi, %ecx
negl %ecx
cmovsl %edi, %ecx
movl %edi, %r8d
shrl $0x1f, %r8d
pushq $0xa
popq %rsi
movl %ecx, %eax
testl %eax, %eax
je 0xaef4
xorl %edx, %edx
divl %esi
incl %r8d
jmp 0xaee7
movl 0x3a5b2(%rip), %edx     # 0x454ac
movl 0x3a5a8(%rip), %eax     # 0x454a8
subl %eax, %edx
cmpl %r8d, %edx
jge 0xaf1f
leaq 0x223ed(%rip), %rdi     # 0x2d2fb
jmp 0xadec
leaq 0x23ab0(%rip), %rdi     # 0x2e9ca
jmp 0xadec
addl %r8d, %eax
movl %eax, 0x3a580(%rip)     # 0x454a8
movq 0x3a571(%rip), %rdx     # 0x454a0
movslq %eax, %r9
movb $0x0, (%rdx,%r9)
movq %r9, %r8
shlq $0x20, %r8
decq %r9
movabsq $-0x100000000, %r10     # imm = 0xFFFFFFFF00000000
testl %ecx, %ecx
je 0xaf75
movl %ecx, %eax
xorl %edx, %edx
divl %esi
imull $0xf6, %eax, %edx
addl %ecx, %edx
addb $0x30, %dl
movq 0x3a539(%rip), %rcx     # 0x454a0
movb %dl, (%rcx,%r9)
addq %r10, %r8
decq %r9
movl %eax, %ecx
jmp 0xaf4b
testl %edi, %edi
js 0xaf7a
retq
movq 0x3a51f(%rip), %rax     # 0x454a0
sarq $0x20, %r8
movb $0x2d, -0x1(%rax,%r8)
retq
// File: /workspace/github_cpp_makefile_star2_O2/melop[P]admixem/./newran02/myexcept.cpp
// Function: Terminate()
void Terminate()
{
   std::cout << "\n\nThere has been an exception with no handler - exiting";
   const char* what = Exception::what();
   if (what) std::cout << what << "\n";
   exit(1);
}

// Assembly:
pushq %rax
movq 0x39f90(%rip), %rdi     # 0x44f90
leaq 0x22308(%rip), %rsi     # 0x2d30f
callq 0x73d0
movq 0x3a48d(%rip), %rsi     # 0x454a0
testq %rsi, %rsi
je 0xb033
movq 0x39f71(%rip), %rdi     # 0x44f90
callq 0x73d0
leaq 0x22f1c(%rip), %rsi     # 0x2df47
movq %rax, %rdi
callq 0x73d0
pushq $0x1
popq %rdi
callq 0x74b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3a2b7(%rip), %rcx # 0x45508
movl $0x1f31d, %esi          # imm = 0x1F31D
movq %rcx, %rax
cqto
idivq %rsi
imulq $-0x1f31d, %rax, %rdx   # imm = 0xFFFE0CE3
addq %rcx, %rdx
imulq $0x41a7, %rdx, %rcx     # imm = 0x41A7
imulq $-0xb14, %rax, %rax     # imm = 0xF4EC
leaq (%rcx,%rax), %rdx
testq %rdx, %rdx
leaq 0x7fffffff(%rcx,%rax), %rax
cmovgq %rdx, %rax
cvtsi2sd %rax, %xmm0
movsd %xmm0, 0x3a272(%rip)    # 0x45508
mulsd 0x22132(%rip), %xmm0    # 0x2d3d0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3a21a(%rip), %xmm0    # 0x45508
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0xb2fa
jnp 0xb338
callq 0xb248
mulsd 0x220d1(%rip), %xmm0    # 0x2d3d8
cvttsd2si %xmm0, %eax
movslq %eax, %rbx
leaq 0x3a1fb(%rip), %r14     # 0x45510
movsd (%r14,%rbx,8), %xmm0
movsd %xmm0, (%rsp)
callq 0xb248
movsd %xmm0, (%r14,%rbx,8)
movsd (%rsp), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
pushq $0x1
popq %rdi
callq 0x71d0
movq %rax, %rbx
leaq 0x223fb(%rip), %rsi     # 0x2d745
movq %rax, %rdi
callq 0xb03c
leaq 0x3867f(%rip), %rsi     # 0x439d8
movq %rbx, %rdi
xorl %edx, %edx
callq 0x76a0
movq %rax, %r14
movq %rbx, %rdi
callq 0x7300
movq %r14, %rdi
callq 0x76d0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x21c7c(%rip), %xmm0    # 0x2d010
jae 0xb3e5
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
jae 0xb3e5
mulsd 0x22038(%rip), %xmm0    # 0x2d3e0
cvttsd2si %xmm0, %rax
cvtsi2sd %rax, %xmm0
movsd %xmm0, 0x3a14e(%rip)    # 0x45508
xorl %ebx, %ebx
leaq 0x3a14d(%rip), %r14     # 0x45510
cmpq $0x400, %rbx            # imm = 0x400
je 0xb3dd
callq 0xb248
movsd %xmm0, (%rbx,%r14)
addq $0x8, %rbx
jmp 0xb3c3
addq $0x8, %rsp
popq %rbx
popq %r14
retq
pushq $0x1
popq %rdi
callq 0x71d0
movq %rax, %rbx
leaq 0x22376(%rip), %rsi     # 0x2d76d
movq %rax, %rdi
callq 0xb03c
leaq 0x385d2(%rip), %rsi     # 0x439d8
movq %rbx, %rdi
xorl %edx, %edx
callq 0x76a0
movq %rax, %r14
movq %rbx, %rdi
callq 0x7300
movq %r14, %rdi
callq 0x76d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0xb485
movsd 0x21f6d(%rip), %xmm0    # 0x2d3f0
jmp 0xb48d
movsd 0x21f5b(%rip), %xmm0    # 0x2d3e8
movsd %xmm0, (%rsp)
xorl %r14d, %r14d
xorpd %xmm0, %xmm0
cmpq $0x3c, %r14
je 0xb502
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 0xb4e4
movsd (%rsp), %xmm1
divsd %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
addsd %xmm1, %xmm0
incq %r14
jmp 0xb499
cmpq $0x31, %r14
jbe 0xb52d
movl %ebp, %ecx
shll %cl, %r14d
cvtsi2sd %r14d, %xmm0
movsd %xmm0, 0x8(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x1
popq %rdi
callq 0x71d0
movq %rax, %rbx
leaq 0x22273(%rip), %rsi     # 0x2d787
movq %rax, %rdi
callq 0xb076
leaq 0x39785(%rip), %rsi     # 0x44ca8
movq %rbx, %rdi
xorl %edx, %edx
callq 0x76a0
pushq $0x1
popq %rdi
callq 0x71d0
movq %rax, %rbx
leaq 0x2225f(%rip), %rsi     # 0x2d79e
movq %rax, %rdi
callq 0xb076
jmp 0xb51c
jmp 0xb54b
movq %rax, %r14
movq %rbx, %rdi
callq 0x7300
movq %r14, %rdi
callq 0x76d0
// File: /workspace/github_cpp_makefile_star2_O2/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 0xb5ba
movq %rbx, %rdi
xorl %esi, %esi
callq 0xb44a
callq 0xb2e2
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 0xb2e2
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 0xb2e2
mulsd 0x8(%rsp), %xmm0
movq 0x18(%rbx), %rax
ucomisd 0x8(%rax,%r14,8), %xmm0
jb 0xb650
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 0xb5ba
movsd 0x10(%rsp), %xmm0
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0xb679
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0xb44a
callq 0xb2e2
movsd 0x2198a(%rip), %xmm1    # 0x2d010
subsd %xmm0, %xmm1
movsd 0x21d66(%rip), %xmm2    # 0x2d3f8
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 0xb2e2
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 0xb2e2
mulsd 0x8(%rsp), %xmm0
movq 0x18(%rbx), %rax
ucomisd 0x8(%rax,%r14,8), %xmm0
jb 0xb73a
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 0xb679
movaps 0x2194f(%rip), %xmm1    # 0x2d090
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_O2/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
pushq %rax
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
cmpq $0x78, %r14
je 0xb87c
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 0xb7f3
movsd 0x21c07(%rip), %xmm1    # 0x2d3e8
divsd %xmm0, %xmm1
movsd (%rsp), %xmm0
addsd %xmm1, %xmm0
incq %r14
jmp 0xb7a3
leal -0x1(%r14), %ecx
movl %ecx, 0x20(%rbx)
movq 0x10(%rbx), %rcx
movsd (%rsp), %xmm0
movsd %xmm0, 0x3c0(%rcx)
andq $0x0, 0x3c0(%rax)
movsd 0x28(%rbx), %xmm0
cmpq $0x78, %r14
je 0xb898
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 0xb864
movsd 0x21bae(%rip), %xmm1    # 0x2d400
divsd %xmm0, %xmm1
movsd (%rsp), %xmm0
addsd %xmm1, %xmm0
incq %r14
jmp 0xb818
cmpq $0x63, %r14
jbe 0xb8c3
cvtsi2sd %r14d, %xmm0
movsd %xmm0, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
pushq $0x1
popq %rdi
callq 0x71d0
movq %rax, %rbx
leaq 0x21f27(%rip), %rsi     # 0x2d7b5
movq %rax, %rdi
callq 0xb076
jmp 0xb8b2
pushq $0x1
popq %rdi
callq 0x71d0
movq %rax, %rbx
leaq 0x21f26(%rip), %rsi     # 0x2d7d0
movq %rax, %rdi
callq 0xb076
leaq 0x393ef(%rip), %rsi     # 0x44ca8
movq %rbx, %rdi
xorl %edx, %edx
callq 0x76a0
pushq $0x1
popq %rdi
callq 0x71d0
movq %rax, %rbx
leaq 0x21ec9(%rip), %rsi     # 0x2d79e
movq %rax, %rdi
callq 0xb076
jmp 0xb8b2
jmp 0xb8e3
jmp 0xb8e3
movq %rax, %r14
movq %rbx, %rdi
callq 0x7300
movq %r14, %rdi
callq 0x76d0
// File: /workspace/github_cpp_makefile_star2_O2/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 0xb911
movq %rbx, %rdi
callq 0xb774
pushq $0x78
popq %rbp
callq 0xb2e2
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 0xb2e2
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 0xb2e2
mulsd 0x8(%rsp), %xmm0
movq 0x18(%rbx), %rax
ucomisd (%rax,%r15,8), %xmm0
jb 0xb9b6
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 0xb914
movsd 0x10(%rsp), %xmm0
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0xbe8b
movq %rdi, %rbx
leaq 0x216b6(%rip), %rcx     # 0x2d4f0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
addsd %xmm0, %xmm0
jmp 0xbe8f
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
addsd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x10(%rbx), %rdi
jmp 0xbe7e
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 0xbe8f
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_O2/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 0xc03e
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
callq 0x7790
movsd 0x38(%rbx), %xmm1
mulsd %xmm0, %xmm1
subsd 0x30(%rbx), %xmm1
movsd %xmm1, 0x8(%rsp)
addsd 0x20ff5(%rip), %xmm0    # 0x2d010
callq 0xc04c
movsd 0x8(%rsp), %xmm1
subsd %xmm0, %xmm1
movsd 0x2141e(%rip), %xmm0    # 0x2d450
ucomisd %xmm1, %xmm0
leaq 0x10(%rsp), %rsp
popq %rbx
jbe 0xc043
xorpd %xmm0, %xmm0
retq
movapd %xmm1, %xmm0
jmp 0x7798
// File: /workspace/github_cpp_makefile_star2_O2/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 0x20fb4(%rip), %xmm0    # 0x2d010
ucomisd %xmm1, %xmm0
jbe 0xc0c2
movsd 0x20fa6(%rip), %xmm0    # 0x2d010
subsd %xmm1, %xmm0
mulsd 0x213f2(%rip), %xmm0    # 0x2d468
movsd %xmm0, (%rsp)
movsd %xmm1, 0x18(%rsp)
callq 0x7768
movsd (%rsp), %xmm1
divsd %xmm0, %xmm1
movapd %xmm1, %xmm0
callq 0x7780
movsd %xmm0, (%rsp)
movsd 0x2138b(%rip), %xmm0    # 0x2d430
subsd 0x18(%rsp), %xmm0
callq 0xc04c
movsd (%rsp), %xmm1
subsd %xmm0, %xmm1
movapd %xmm1, %xmm0
jmp 0xc162
addsd 0x2135e(%rip), %xmm1    # 0x2d428
movsd %xmm1, 0x18(%rsp)
movsd 0x21380(%rip), %xmm0    # 0x2d458
addsd %xmm1, %xmm0
movsd 0x21314(%rip), %xmm2    # 0x2d3f8
addsd %xmm1, %xmm2
movapd %xmm2, (%rsp)
movsd %xmm0, 0x20(%rsp)
callq 0x7780
movsd 0x20f10(%rip), %xmm5    # 0x2d010
movsd 0x18(%rsp), %xmm3
movapd (%rsp), %xmm4
xorpd 0x20f7d(%rip), %xmm4    # 0x2d090
xorl %eax, %eax
leaq 0x213f4(%rip), %rcx     # 0x2d510
movapd %xmm5, %xmm1
cmpq $0x30, %rax
je 0xc13d
addsd %xmm5, %xmm3
movsd (%rax,%rcx), %xmm2
divsd %xmm3, %xmm2
addsd %xmm2, %xmm1
addq $0x8, %rax
jmp 0xc120
mulsd %xmm0, %xmm4
addsd 0x20(%rsp), %xmm4
movapd %xmm4, (%rsp)
mulsd 0x2130c(%rip), %xmm1    # 0x2d460
movapd %xmm1, %xmm0
callq 0x7780
subsd (%rsp), %xmm0
addq $0x28, %rsp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x7790
movapd %xmm0, %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm1, %xmm0
ja 0xc283
cvtsi2sdl 0x58(%rbx), %xmm0
ucomisd %xmm0, %xmm1
ja 0xc283
movsd 0x50(%rbx), %xmm0
movsd %xmm0, (%rsp)
movapd %xmm1, %xmm0
addsd 0x20dfa(%rip), %xmm0    # 0x2d010
movsd %xmm1, 0x8(%rsp)
callq 0xc04c
movsd (%rsp), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
cvtsi2sdl 0x58(%rbx), %xmm0
subsd 0x8(%rsp), %xmm0
addsd 0x20dce(%rip), %xmm0    # 0x2d010
callq 0xc04c
movsd (%rsp), %xmm2
subsd %xmm0, %xmm2
movsd 0x40(%rbx), %xmm1
movsd 0x8(%rsp), %xmm3
mulsd %xmm3, %xmm1
cvtsi2sdl 0x58(%rbx), %xmm0
addsd %xmm2, %xmm1
subsd %xmm3, %xmm0
mulsd 0x48(%rbx), %xmm0
addsd %xmm1, %xmm0
movsd 0x211d3(%rip), %xmm1    # 0x2d450
ucomisd %xmm0, %xmm1
jbe 0xc28d
xorpd %xmm0, %xmm0
addq $0x10, %rsp
popq %rbx
retq
addq $0x10, %rsp
popq %rbx
jmp 0x7798
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x37b6b(%rip), %rax     # 0x43e20
movq %rax, (%rdi)
movapd 0x20dd0(%rip), %xmm0    # 0x2d090
xorpd %xmm1, %xmm0
callq 0x7798
movapd (%rsp), %xmm2
movsd %xmm0, 0x10(%rsp)
pushq $0x1
popq %rax
cmpq $0x28, %rax
je 0xc2f4
cvtsi2sd %eax, %xmm1
mulsd %xmm2, %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rsp,%rax,8)
incq %rax
jmp 0xc2d7
pushq $0x38
popq %rdi
callq 0x73f0
movq %rax, %r14
pushq $0x28
popq %rsi
leaq 0x10(%rsp), %rdx
movq %rax, %rdi
callq 0xc9ac
movq %r14, 0x8(%rbx)
addq $0x158, %rsp            # imm = 0x158
popq %rbx
popq %r14
retq
movq %rax, %rbx
pushq $0x38
popq %rsi
movq %r14, %rdi
callq 0x7400
movq %rbx, %rdi
callq 0x76d0
// File: /workspace/github_cpp_makefile_star2_O2/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, 0x30(%rsp)
movl %esi, %r14d
movq %rdi, %rbx
leaq 0x37af8(%rip), %rax     # 0x43e80
movq %rax, (%rdi)
cvtsi2sd %esi, %xmm2
movsd 0x20c79(%rip), %xmm1    # 0x2d010
mulsd %xmm0, %xmm2
movapd %xmm2, 0x10(%rsp)
cvttsd2si %xmm2, %r15d
subsd %xmm0, %xmm1
movsd %xmm1, 0x28(%rsp)
leal 0x1(%r14), %eax
cvtsi2sd %eax, %xmm0
callq 0xc04c
movsd %xmm0, 0x8(%rsp)
leal 0x1(%r15), %r13d
cvtsi2sd %r13d, %xmm0
callq 0xc04c
movsd %xmm0, 0x38(%rsp)
movl %r14d, %r12d
subl %r15d, %r12d
leal 0x1(%r12), %eax
cvtsi2sd %eax, %xmm0
callq 0xc04c
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 0x30(%rsp), %xmm0
callq 0x7780
mulsd 0x10(%rsp), %xmm0
addsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
cvtsi2sd %r12d, %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x28(%rsp), %xmm0
callq 0x7780
mulsd 0x10(%rsp), %xmm0
addsd 0x8(%rsp), %xmm0
callq 0x7798
movsd 0x28(%rsp), %xmm3
movsd 0x30(%rsp), %xmm2
movslq %r15d, %rax
movsd %xmm0, 0x40(%rsp,%rax,8)
cmpl $0x27, %r14d
pushq $0x27
popq %rbp
cmovll %r14d, %ebp
movslq %r13d, %rax
movslq %ebp, %rcx
cmpq %rcx, %rax
jg 0xc4ac
movsd 0x38(%rsp,%rax,8), %xmm0
mulsd %xmm2, %xmm0
cvtsi2sd %r12d, %xmm1
mulsd %xmm0, %xmm1
divsd %xmm3, %xmm1
cvtsi2sd %eax, %xmm0
divsd %xmm0, %xmm1
movsd %xmm1, 0x40(%rsp,%rax,8)
incq %rax
decl %r12d
jmp 0xc47a
movl %r15d, %eax
subl %r15d, %r14d
incl %r14d
testl %eax, %eax
jle 0xc4e5
cvtsi2sd %eax, %xmm0
movsd 0x40(%rsp,%rax,8), %xmm1
decq %rax
mulsd %xmm3, %xmm1
mulsd %xmm1, %xmm0
divsd %xmm2, %xmm0
cvtsi2sd %r14d, %xmm1
divsd %xmm1, %xmm0
movl %eax, %ecx
movsd %xmm0, 0x40(%rsp,%rcx,8)
jmp 0xc4b2
pushq $0x38
popq %rdi
callq 0x73f0
movq %rax, %r14
incl %ebp
leaq 0x40(%rsp), %rdx
movq %rax, %rdi
movl %ebp, %esi
callq 0xc9ac
movq %r14, 0x8(%rbx)
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
pushq $0x38
popq %rsi
movq %r14, %rdi
callq 0x7400
movq %rbx, %rdi
callq 0x76d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0xc7d0
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
callq 0x7790
movapd %xmm0, %xmm1
movsd %xmm0, 0x8(%rsp)
movsd 0x58(%rbx), %xmm0
movsd %xmm0, (%rsp)
movsd 0x30(%rbx), %xmm0
addsd %xmm1, %xmm0
callq 0xc04c
addsd (%rsp), %xmm0
movsd %xmm0, (%rsp)
movsd 0x20877(%rip), %xmm0    # 0x2d010
addsd 0x8(%rsp), %xmm0
callq 0xc04c
movsd (%rsp), %xmm2
subsd %xmm0, %xmm2
movsd 0x8(%rsp), %xmm1
mulsd 0x50(%rbx), %xmm1
addsd %xmm2, %xmm1
movsd 0x20c8c(%rip), %xmm0    # 0x2d450
ucomisd %xmm1, %xmm0
leaq 0x10(%rsp), %rsp
popq %rbx
jbe 0xc7d5
xorpd %xmm0, %xmm0
retq
movapd %xmm1, %xmm0
jmp 0x7798
// File: /workspace/github_cpp_makefile_star2_O2/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 0x377a6(%rip), %rax     # 0x440c0
movq %rax, (%rdi)
movsd 0x206eb(%rip), %xmm1    # 0x2d010
ucomisd %xmm0, %xmm1
jbe 0xc94a
pushq $0x40
popq %rdi
movsd %xmm0, (%rsp)
callq 0x73f0
movq %rax, %r14
movq %rax, %rdi
movsd (%rsp), %xmm0
callq 0xc7de
jmp 0xc9a0
ucomisd 0x206be(%rip), %xmm0    # 0x2d010
jne 0xc983
jp 0xc983
pushq $0x28
popq %rdi
callq 0x73f0
movq %rax, %r14
xorpd %xmm0, %xmm0
movapd %xmm0, (%rax)
andq $0x0, 0x20(%rax)
movapd %xmm0, 0x10(%rax)
movb $0x1, 0x20(%rax)
leaq 0x3815a(%rip), %rax     # 0x44ad8
movq %rax, (%r14)
jmp 0xc9a0
pushq $0x40
popq %rdi
movsd %xmm0, (%rsp)
callq 0x73f0
movq %rax, %r14
movq %rax, %rdi
movsd (%rsp), %xmm0
callq 0xc87c
movq %r14, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x37763(%rip), %rax     # 0x44120
movq %rax, (%rdi)
callq 0xca34
andq $0x0, 0x30(%r14)
xorpd %xmm0, %xmm0
movupd %xmm0, 0x20(%r14)
movl 0x18(%r14), %eax
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
xorpd %xmm0, %xmm0
cmpq %rcx, %rax
je 0xca00
cvtsi2sd %ecx, %xmm1
mulsd (%rbx,%rcx,8), %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, 0x28(%r14)
incq %rcx
jmp 0xc9e3
xorpd %xmm1, %xmm1
xorl %ecx, %ecx
cmpq %rcx, %rax
je 0xca2b
cvtsi2sd %ecx, %xmm2
subsd %xmm0, %xmm2
mulsd %xmm2, %xmm2
mulsd (%rbx,%rcx,8), %xmm2
addsd %xmm2, %xmm1
movsd %xmm1, 0x30(%r14)
incq %rcx
jmp 0xca06
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r15
movq %rdx, %rbx
movl %esi, %r12d
movq %rdi, %r14
leaq 0x374e2(%rip), %rax     # 0x44120
movq %rax, (%rdi)
callq 0xca34
movl %r12d, %eax
shlq $0x3, %rax
xorl %r13d, %r13d
testl %r12d, %r12d
pushq $-0x1
popq %rdi
cmovnsq %rax, %rdi
cmovlel %r13d, %r12d
callq 0x7030
movq %rax, 0x20(%r14)
cmpq %r13, %r12
je 0xcc7d
movsd (%r15,%r13,8), %xmm0
movsd %xmm0, (%rax,%r13,8)
incq %r13
jmp 0xcc67
leaq 0x28(%r14), %rdx
xorpd %xmm0, %xmm0
movupd %xmm0, 0x28(%r14)
movl 0x18(%r14), %ecx
xorl %esi, %esi
testl %ecx, %ecx
cmovlel %esi, %ecx
xorpd %xmm0, %xmm0
cmpq %rsi, %rcx
je 0xccb6
movsd (%rax,%rsi,8), %xmm1
mulsd (%rbx,%rsi,8), %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, (%rdx)
incq %rsi
jmp 0xcc9a
xorpd %xmm1, %xmm1
xorl %edx, %edx
cmpq %rdx, %rcx
je 0xcce2
movsd (%rax,%rdx,8), %xmm2
subsd %xmm0, %xmm2
mulsd %xmm2, %xmm2
mulsd (%rbx,%rdx,8), %xmm2
addsd %xmm2, %xmm1
movsd %xmm1, 0x30(%r14)
incq %rdx
jmp 0xccbc
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
callq 0xe64b
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
callq 0xe64b
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 0xa8b8
leaq 0x48(%rsp), %r12
movsd %xmm0, (%r12)
movl %eax, 0x8(%r12)
leaq 0x18(%rsp), %rsi
movq %r15, %rdi
callq 0xa8b8
leaq 0x38(%rsp), %rsi
movsd %xmm0, (%rsi)
movl %eax, 0x8(%rsi)
movq %r12, %rdi
callq 0xa7dc
leaq 0x58(%rsp), %r15
movsd %xmm0, (%r15)
movl %eax, 0x8(%r15)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xa8b8
leaq 0x28(%rsp), %rsi
movsd %xmm0, (%rsi)
movl %eax, 0x8(%rsi)
movq %r15, %rdi
callq 0xa7dc
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rdx, %rbx
movl %esi, %r12d
movq %rdi, %r15
leaq 0x36a90(%rip), %rax     # 0x44180
movq %rax, (%rdi)
pushq $0x4
popq %rax
movl %eax, 0x28(%rdi)
movl %eax, 0x38(%rdi)
movl %esi, 0x8(%rdi)
movl %esi, %eax
shlq $0x3, %rax
xorl %r13d, %r13d
testl %esi, %esi
pushq $-0x1
popq %rdi
cmovnsq %rax, %rdi
cmovlel %r13d, %r12d
callq 0x7030
movq %rax, 0x18(%r15)
cmpq %r13, %r12
je 0xd734
movq (%r14,%r13,8), %rax
movq 0x18(%r15), %rcx
movq %rax, (%rcx,%r13,8)
incq %r13
jmp 0xd71e
movq %r15, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xd748
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x38
popq %rdi
callq 0x73f0
movq %rax, %r15
movl 0x8(%r14), %esi
movq %rax, %rdi
movq %rbx, %rdx
callq 0xc9ac
movq %r15, 0x10(%r14)
andq $0x0, 0x20(%r14)
andl $0x0, 0x28(%r14)
leaq 0x20(%r14), %r15
andq $0x0, 0x30(%r14)
leaq 0x30(%r14), %rax
movq %rax, 0x30(%rsp)
andl $0x0, 0x38(%r14)
xorl %r13d, %r13d
movq %rsp, %rbp
leaq 0x20(%rsp), %r12
movslq 0x8(%r14), %rax
cmpq %rax, %r13
jge 0xd808
movq 0x18(%r14), %rax
movq (%rax,%r13,8), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
movsd %xmm0, 0x10(%rsp)
movl %eax, 0x18(%rsp)
movsd (%rbx,%r13,8), %xmm0
andl $0x0, 0x8(%rsp)
movsd %xmm0, (%rsp)
leaq 0x10(%rsp), %rdi
movq %rbp, %rsi
callq 0xa8b8
movsd %xmm0, 0x20(%rsp)
movl %eax, 0x28(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0xa7dc
movsd %xmm0, 0x20(%r14)
movl %eax, 0x28(%r14)
incq %r13
jmp 0xd7a6
xorl %r12d, %r12d
movq %rsp, %r13
leaq 0x38(%rsp), %rbp
cltq
cmpq %rax, %r12
jge 0xd8d9
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 0xa84a
movsd %xmm0, 0x10(%rsp)
movl %eax, 0x18(%rsp)
leaq 0x10(%rsp), %rdi
callq 0xe64b
movsd %xmm0, 0x48(%rsp)
movl %eax, 0x50(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0xa7dc
movsd %xmm0, 0x58(%rsp)
movl %eax, 0x60(%rsp)
movsd (%rbx,%r12,8), %xmm0
andl $0x0, 0x40(%rsp)
movsd %xmm0, 0x38(%rsp)
leaq 0x58(%rsp), %rdi
movq %rbp, %rsi
callq 0xa8b8
movsd %xmm0, (%rsp)
movl %eax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
movq %r13, %rsi
callq 0xa7dc
movsd %xmm0, 0x30(%r14)
movl %eax, 0x38(%r14)
incq %r12
movl 0x8(%r14), %eax
jmp 0xd813
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
pushq $0x38
popq %rsi
movq %r15, %rdi
callq 0x7400
movq %rbx, %rdi
callq 0x76d0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3686d(%rip), %rax     # 0x44180
movq %rax, (%rdi)
pushq $0x4
popq %rax
movl %eax, 0x28(%rdi)
movl %eax, 0x38(%rdi)
movq (%rsi), %rax
movq %rsi, %rdi
callq *0x40(%rax)
movl %eax, 0x8(%rbx)
movl %eax, %ecx
shlq $0x3, %rcx
testl %eax, %eax
pushq $-0x1
popq %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
andl $0x0, (%rsi)
movq (%r14), %r8
movq %r14, %rdi
movq %r12, %rdx
movq %rax, %rcx
callq *0x48(%r8)
movq %rbx, %rdi
movq %r12, %rsi
callq 0xd748
movq %r12, %rdi
callq 0x74f0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop