LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movq %rax, -0x18(%rbp)
subq $0x4, %rax
ja 0x1216e
movq -0x18(%rbp), %rax
leaq 0x643a0(%rip), %rcx     # 0x764ac
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
callq 0x88c0
jmp 0x1216e
movq -0x8(%rbp), %rdi
leaq 0x6438d(%rip), %rsi     # 0x764c0
callq 0x84a0
jmp 0x1216e
movq -0x8(%rbp), %rdi
leaq 0x64389(%rip), %rsi     # 0x764ce
callq 0x84a0
jmp 0x1216e
movq -0x8(%rbp), %rdi
leaq 0x64386(%rip), %rsi     # 0x764dd
callq 0x84a0
jmp 0x1216e
movq -0x8(%rbp), %rdi
leaq 0x6437f(%rip), %rsi     # 0x764e8
callq 0x84a0
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x97c01(%rip), %rax     # 0xaa5b8
addq $0x1, %rax
movq %rax, 0x97bf6(%rip)     # 0xaa5b8
movl $0x0, 0x97bfc(%rip)     # 0xaa5c8
cmpq $0x0, 0x97bec(%rip)     # 0xaa5c0
jne 0x12a15
movl $0x1ff, 0x97bec(%rip)   # imm = 0x1FF
movl $0x200, %edi            # imm = 0x200
callq 0x8040
movq %rax, 0x97bcf(%rip)     # 0xaa5c0
cmpq $0x0, 0x97bc7(%rip)     # 0xaa5c0
jne 0x12a13
movl $0x0, 0x97bc7(%rip)     # 0xaa5cc
leaq 0x63b49(%rip), %rax     # 0x76555
movq %rax, 0x97bad(%rip)     # 0xaa5c0
jmp 0x12a15
leaq 0x63b5e(%rip), %rdi     # 0x7657a
callq 0x12a40
movq -0x10(%rbp), %rdi
callq 0x12a40
cmpq $0x0, -0x10(%rbp)
je 0x12a36
callq 0x12b00
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x12aeb
movq -0x8(%rbp), %rdi
callq 0x8200
movl %eax, -0xc(%rbp)
movl 0x97b63(%rip), %eax     # 0xaa5cc
subl 0x97b59(%rip), %eax     # 0xaa5c8
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x12aa5
movq 0x97b3f(%rip), %rdi     # 0xaa5c0
movslq 0x97b40(%rip), %rax     # 0xaa5c8
addq %rax, %rdi
movq -0x8(%rbp), %rsi
callq 0x8450
movl -0xc(%rbp), %eax
addl 0x97b2b(%rip), %eax     # 0xaa5c8
movl %eax, 0x97b25(%rip)     # 0xaa5c8
jmp 0x12ae9
cmpl $0x0, -0x10(%rbp)
jle 0x12ae7
movq 0x97b0e(%rip), %rdi     # 0xaa5c0
movslq 0x97b0f(%rip), %rax     # 0xaa5c8
addq %rax, %rdi
movq -0x8(%rbp), %rsi
movslq -0x10(%rbp), %rdx
callq 0x8260
movq 0x97af0(%rip), %rax     # 0xaa5c0
movslq 0x97af5(%rip), %rcx     # 0xaa5cc
movb $0x0, (%rax,%rcx)
movl 0x97aeb(%rip), %eax     # 0xaa5cc
movl %eax, 0x97ae1(%rip)     # 0xaa5c8
jmp 0x12ae9
jmp 0x12aeb
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpq $0x0, 0x97ac0(%rip)     # 0xaa5d0
je 0x12b75
leaq 0x63a8a(%rip), %rdi     # 0x765a3
callq 0x12a40
movq 0x97aab(%rip), %rax     # 0xaa5d0
movq (%rax), %rdi
callq 0x12a40
movq 0x97a9c(%rip), %rax     # 0xaa5d0
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x12b69
leaq 0x63a61(%rip), %rdi     # 0x765ab
callq 0x12a40
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x12a40
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x12b3c
leaq 0x64246(%rip), %rdi     # 0x76db6
callq 0x12a40
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jne 0x12ba2
leaq 0x65163(%rip), %rdi     # 0x77cfb
callq 0x12a40
jmp 0x12ca5
cmpl $0x0, -0x4(%rbp)
jge 0x12bb6
xorl %eax, %eax
subl -0x4(%rbp), %eax
movl %eax, -0x4(%rbp)
movb $0x1, -0x5(%rbp)
jmp 0x12bba
movb $0x0, -0x5(%rbp)
jmp 0x12bbc
movl $0x0, -0xc(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
jle 0x12be8
movl -0x10(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x12bc9
testb $0x1, -0x5(%rbp)
je 0x12bf7
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movl 0x979cf(%rip), %eax     # 0xaa5cc
subl 0x979c5(%rip), %eax     # 0xaa5c8
cmpl -0xc(%rbp), %eax
jge 0x12c19
leaq 0x6398b(%rip), %rdi     # 0x7659a
callq 0x12a40
jmp 0x12ca5
movl -0xc(%rbp), %eax
addl 0x979a6(%rip), %eax     # 0xaa5c8
movl %eax, 0x979a0(%rip)     # 0xaa5c8
movl 0x9799a(%rip), %eax     # 0xaa5c8
movl %eax, -0xc(%rbp)
movq 0x97988(%rip), %rax     # 0xaa5c0
movslq -0xc(%rbp), %rcx
movb $0x0, (%rax,%rcx)
cmpl $0x0, -0x4(%rbp)
jle 0x12c86
movl -0x4(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
movl %eax, -0x14(%rbp)
movl -0x4(%rbp), %eax
imull $0xa, -0x14(%rbp), %ecx
subl %ecx, %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x18(%rbp), %eax
addl $0x30, %eax
movb %al, %dl
movq 0x9794b(%rip), %rax     # 0xaa5c0
movl -0xc(%rbp), %ecx
addl $-0x1, %ecx
movl %ecx, -0xc(%rbp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
jmp 0x12c40
testb $0x1, -0x5(%rbp)
je 0x12ca3
movq 0x9792d(%rip), %rax     # 0xaa5c0
movl -0xc(%rbp), %ecx
addl $-0x1, %ecx
movl %ecx, -0xc(%rbp)
movslq %ecx, %rcx
movb $0x2d, (%rax,%rcx)
jmp 0x12ca5
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x97249(%rip), %rdi     # 0xa9f88
leaq 0x63868(%rip), %rsi     # 0x765ae
callq 0x84a0
callq 0x130f0
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x12d7a
movq -0x8(%rbp), %rsi
movq 0x97222(%rip), %rdi     # 0xa9f88
callq 0x84a0
movq %rax, %rdi
leaq 0x644a7(%rip), %rsi     # 0x7721c
callq 0x84a0
movl $0x1, %edi
callq 0x85f0
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
cvttsd2si 0x9751b(%rip), %rax # 0xaa628
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x1f31d, %ecx          # imm = 0x1F31D
cqto
idivq %rcx
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
imulq $0x1f31d, -0x10(%rbp), %rcx # imm = 0x1F31D
subq %rcx, %rax
movq %rax, -0x18(%rbp)
imulq $0x41a7, -0x18(%rbp), %rax # imm = 0x41A7
imulq $0xb14, -0x10(%rbp), %rcx # imm = 0xB14
subq %rcx, %rax
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jg 0x13162
movq -0x8(%rbp), %rax
addq $0x7fffffff, %rax       # imm = 0x7FFFFFFF
movq %rax, -0x8(%rbp)
cvtsi2sdq -0x8(%rbp), %xmm0
movsd %xmm0, 0x974b8(%rip)    # 0xaa628
movsd 0x634f8(%rip), %xmm0    # 0x76670
mulsd 0x974a8(%rip), %xmm0    # 0xaa628
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movsd 0x97414(%rip), %xmm0    # 0xaa628
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x1326c
jp 0x1326c
movl $0x1, %edi
callq 0x8230
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x28(%rbp)
leaq 0x63753(%rip), %rsi     # 0x7698d
callq 0x12d90
jmp 0x13241
movq -0x28(%rbp), %rdi
leaq 0x9577c(%rip), %rsi     # 0xa89c8
xorl %eax, %eax
movl %eax, %edx
callq 0x8820
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x8370
jmp 0x132b9
callq 0x13100
movsd 0x633ff(%rip), %xmm1    # 0x76678
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, -0x18(%rbp)
movslq -0x18(%rbp), %rcx
leaq 0x973a1(%rip), %rax     # 0xaa630
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x20(%rbp)
callq 0x13100
movslq -0x18(%rbp), %rcx
leaq 0x97387(%rip), %rax     # 0xaa630
movsd %xmm0, (%rax,%rcx,8)
movsd -0x20(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
movq -0x10(%rbp), %rdi
callq 0x8860
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
movsd 0x62d06(%rip), %xmm1    # 0x76010
ucomisd %xmm1, %xmm0
jae 0x1331a
xorps %xmm0, %xmm0
ucomisd -0x8(%rbp), %xmm0
jb 0x13367
movl $0x1, %edi
callq 0x8230
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x20(%rbp)
leaq 0x63680(%rip), %rsi     # 0x769b5
callq 0x12d90
jmp 0x1333c
movq -0x20(%rbp), %rdi
leaq 0x95681(%rip), %rsi     # 0xa89c8
xorl %eax, %eax
movl %eax, %edx
callq 0x8820
movq -0x20(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x8370
jmp 0x133bc
movsd 0x62c99(%rip), %xmm0    # 0x76008
mulsd -0x8(%rbp), %xmm0
cvttsd2si %xmm0, %rax
cvtsi2sd %rax, %xmm0
movsd %xmm0, 0x972a2(%rip)    # 0xaa628
movl $0x0, -0x18(%rbp)
cmpl $0x80, -0x18(%rbp)
jge 0x133b6
callq 0x13100
movslq -0x18(%rbp), %rcx
leaq 0x9728a(%rip), %rax     # 0xaa630
movsd %xmm0, (%rax,%rcx,8)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1338d
addq $0x20, %rsp
popq %rbp
retq
movq -0x10(%rbp), %rdi
callq 0x8860
nopw %cs:(%rax,%rax)
// File: melop[P]admixem/./newran02/newran.cpp
// Function: PosGen::~PosGen()
PosGen::~PosGen()
{
   if (!NotReady)
   {
      #ifdef MONITOR
	 cout << "freeing PosGen arrays\n";
      #endif
      delete [] sx; delete [] sfx;
   }
   #ifdef MONITOR
      cout << "destructing PosGen\n";
   #endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x955b5(%rip), %rcx     # 0xa89e0
addq $0x10, %rcx
movq %rcx, (%rax)
testb $0x1, 0x20(%rax)
jne 0x13470
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x13453
movq -0x18(%rbp), %rdi
callq 0x8640
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x1346e
movq -0x20(%rbp), %rdi
callq 0x8640
jmp 0x13470
movq -0x10(%rbp), %rdi
callq 0x19e90
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
testb $0x1, 0x20(%rax)
je 0x13725
movq -0x38(%rbp), %rdi
xorl %esi, %esi
callq 0x134b0
jmp 0x13727
movq -0x38(%rbp), %rdi
callq 0x13200
movq -0x38(%rbp), %rdi
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
mulsd 0x8(%rdi), %xmm0
cvttsd2si %xmm0, %eax
movl %eax, -0x1c(%rbp)
movq 0x10(%rdi), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x50(%rbp)
movq 0x10(%rdi), %rax
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
subsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
callq 0x13200
movsd -0x50(%rbp), %xmm1
movq -0x38(%rbp), %rdi
movaps %xmm0, %xmm2
movsd -0x48(%rbp), %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x10(%rbp)
movq 0x18(%rdi), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x40(%rbp)
callq 0x13200
movaps %xmm0, %xmm1
movsd -0x40(%rbp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movq -0x38(%rbp), %rax
movsd -0x18(%rbp), %xmm0
movq 0x18(%rax), %rcx
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdx
xorl %eax, %eax
ucomisd (%rcx,%rdx,8), %xmm0
movb %al, -0x51(%rbp)
jb 0x1381a
movq -0x38(%rbp), %rdi
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x60(%rbp)
movsd -0x10(%rbp), %xmm0
movq (%rdi), %rax
callq *0x10(%rax)
movaps %xmm0, %xmm1
movsd -0x60(%rbp), %xmm0
ucomisd %xmm1, %xmm0
setae %al
movb %al, -0x51(%rbp)
movb -0x51(%rbp), %al
testb $0x1, %al
jne 0x13727
movsd -0x10(%rbp), %xmm0
addq $0x60, %rsp
popq %rbp
retq
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
testb $0x1, 0x20(%rax)
je 0x13858
movq -0x40(%rbp), %rdi
movl $0x1, %esi
callq 0x134b0
jmp 0x1385a
movq -0x40(%rbp), %rdi
movsd 0x627aa(%rip), %xmm0    # 0x76010
movsd %xmm0, -0x10(%rbp)
callq 0x13200
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
movsd 0x62e0e(%rip), %xmm1    # 0x76690
ucomisd %xmm1, %xmm0
jbe 0x138a7
movsd 0x62e08(%rip), %xmm0    # 0x76698
movsd %xmm0, -0x10(%rbp)
movsd 0x62773(%rip), %xmm0    # 0x76010
subsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x40(%rbp), %rdi
movsd -0x30(%rbp), %xmm0
mulsd 0x8(%rdi), %xmm0
cvttsd2si %xmm0, %eax
movl %eax, -0x24(%rbp)
movq 0x10(%rdi), %rax
movslq -0x24(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x58(%rbp)
movq 0x10(%rdi), %rax
movl -0x24(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
subsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x50(%rbp)
callq 0x13200
movsd -0x58(%rbp), %xmm1
movq -0x40(%rbp), %rdi
movaps %xmm0, %xmm2
movsd -0x50(%rbp), %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movq 0x18(%rdi), %rax
movslq -0x24(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x48(%rbp)
callq 0x13200
movaps %xmm0, %xmm1
movsd -0x48(%rbp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x40(%rbp), %rax
movsd -0x20(%rbp), %xmm0
movq 0x18(%rax), %rcx
movl -0x24(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdx
xorl %eax, %eax
ucomisd (%rcx,%rdx,8), %xmm0
movb %al, -0x59(%rbp)
jb 0x1398c
movq -0x40(%rbp), %rdi
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x68(%rbp)
movsd -0x18(%rbp), %xmm0
movq (%rdi), %rax
callq *0x10(%rax)
movaps %xmm0, %xmm1
movsd -0x68(%rbp), %xmm0
ucomisd %xmm1, %xmm0
setae %al
movb %al, -0x59(%rbp)
movb -0x59(%rbp), %al
testb $0x1, %al
jne 0x1385a
movsd -0x10(%rbp), %xmm0
mulsd -0x18(%rbp), %xmm0
addq $0x70, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
testb $0x1, 0x24(%rax)
je 0x13cc3
movq -0x40(%rbp), %rdi
callq 0x13a00
jmp 0x13cc5
movq -0x40(%rbp), %rdi
callq 0x13200
movq -0x40(%rbp), %rcx
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
mulsd 0x8(%rcx), %xmm0
cvttsd2si %xmm0, %eax
movl %eax, -0x2c(%rbp)
movq 0x10(%rcx), %rax
movslq -0x2c(%rbp), %rdx
movsd (%rax,%rdx,8), %xmm0
movsd %xmm0, -0x38(%rbp)
movl -0x2c(%rbp), %eax
cmpl 0x20(%rcx), %eax
jne 0x13d0c
movl $0x78, %eax
movl %eax, -0x44(%rbp)
jmp 0x13d15
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
movq -0x40(%rbp), %rdi
movl -0x44(%rbp), %eax
movl %eax, -0x1c(%rbp)
movsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x60(%rbp)
movq 0x10(%rdi), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
subsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x58(%rbp)
callq 0x13200
movsd -0x60(%rbp), %xmm1
movq -0x40(%rbp), %rdi
movaps %xmm0, %xmm2
movsd -0x58(%rbp), %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x10(%rbp)
movq 0x18(%rdi), %rax
movslq -0x2c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x50(%rbp)
callq 0x13200
movaps %xmm0, %xmm1
movsd -0x50(%rbp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movq -0x40(%rbp), %rax
movsd -0x18(%rbp), %xmm0
movq 0x18(%rax), %rcx
movslq -0x1c(%rbp), %rdx
xorl %eax, %eax
ucomisd (%rcx,%rdx,8), %xmm0
movb %al, -0x61(%rbp)
jb 0x13dd3
movq -0x40(%rbp), %rdi
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x70(%rbp)
movsd -0x10(%rbp), %xmm0
movq (%rdi), %rax
callq *0x10(%rax)
movaps %xmm0, %xmm1
movsd -0x70(%rbp), %xmm0
ucomisd %xmm1, %xmm0
setae %al
movb %al, -0x61(%rbp)
movb -0x61(%rbp), %al
testb $0x1, %al
jne 0x13cc5
movsd -0x10(%rbp), %xmm0
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: melop[P]admixem/./newran02/newran.cpp
// Function: AsymGen::~AsymGen()
AsymGen::~AsymGen()
{
   if (!NotReady)
   {
      #ifdef MONITOR
	 cout << "freeing AsymGen arrays\n";
      #endif
      delete [] sx; delete [] sfx;
   }
   #ifdef MONITOR
      cout << "destructing AsymGen\n";
   #endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x94c35(%rip), %rcx     # 0xa8a40
addq $0x10, %rcx
movq %rcx, (%rax)
testb $0x1, 0x24(%rax)
jne 0x13e50
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x13e33
movq -0x18(%rbp), %rdi
callq 0x8640
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x13e4e
movq -0x20(%rbp), %rdi
callq 0x8640
jmp 0x13e50
movq -0x10(%rbp), %rdi
callq 0x19e90
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl 0x18(%rax), %eax
movq %rax, -0x28(%rbp)
subq $0x5, %rax
ja 0x147f3
movq -0x28(%rbp), %rax
leaq 0x62030(%rip), %rcx     # 0x76770
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rdi
movq (%rdi), %rax
callq *(%rax)
movsd %xmm0, -0x8(%rbp)
jmp 0x147fb
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rdi
movq (%rdi), %rax
callq *(%rax)
movsd 0x61f3b(%rip), %xmm1    # 0x766b0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x147fb
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rdi
movq (%rdi), %rax
callq *(%rax)
movq -0x30(%rbp), %rax
movsd %xmm0, -0x38(%rbp)
movq 0x8(%rax), %rdi
movq (%rdi), %rax
callq *(%rax)
movaps %xmm0, %xmm1
movsd -0x38(%rbp), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x147fb
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rdi
movq (%rdi), %rax
callq *(%rax)
movq -0x30(%rbp), %rax
movsd 0x61ee5(%rip), %xmm1    # 0x766b0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movq 0x10(%rax), %rdi
movq (%rdi), %rax
callq *(%rax)
movsd %xmm0, -0x20(%rbp)
movsd -0x18(%rbp), %xmm0
addsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x147fb
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
xorps %xmm0, %xmm0
ucomisd -0x18(%rbp), %xmm0
jbe 0x14b30
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x14bcb
movsd -0x18(%rbp), %xmm0
callq 0x8950
movq -0x30(%rbp), %rax
movsd %xmm0, -0x20(%rbp)
movsd 0x38(%rax), %xmm0
movsd -0x20(%rbp), %xmm2
movsd 0x30(%rax), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movsd 0x61492(%rip), %xmm0    # 0x76010
addsd -0x20(%rbp), %xmm0
callq 0x14be0
movaps %xmm0, %xmm1
movsd -0x38(%rbp), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd 0x61b2f(%rip), %xmm0    # 0x766d0
ucomisd -0x28(%rbp), %xmm0
jbe 0x14bb2
xorps %xmm0, %xmm0
movsd %xmm0, -0x40(%rbp)
jmp 0x14bc1
movsd -0x28(%rbp), %xmm0
callq 0x8958
movsd %xmm0, -0x40(%rbp)
movsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movsd %xmm0, -0x10(%rbp)
movsd 0x6141b(%rip), %xmm0    # 0x76010
ucomisd -0x10(%rbp), %xmm0
jbe 0x14c6c
movsd 0x6140c(%rip), %xmm1    # 0x76010
subsd -0x10(%rbp), %xmm1
movsd 0x61ad7(%rip), %xmm0    # 0x766e8
mulsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x18(%rbp), %xmm0
callq 0x8928
movaps %xmm0, %xmm1
movsd -0x48(%rbp), %xmm0
divsd %xmm1, %xmm0
callq 0x8940
movsd %xmm0, -0x40(%rbp)
movsd 0x61a64(%rip), %xmm0    # 0x766b0
subsd -0x10(%rbp), %xmm0
callq 0x14be0
movaps %xmm0, %xmm1
movsd -0x40(%rbp), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x14d7b
movsd -0x10(%rbp), %xmm0
movsd 0x61397(%rip), %xmm1    # 0x76010
subsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movsd 0x61a4e(%rip), %xmm0    # 0x766d8
addsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd 0x619f4(%rip), %xmm0    # 0x76690
addsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x50(%rbp)
movsd -0x28(%rbp), %xmm0
callq 0x8940
movaps %xmm0, %xmm2
movsd -0x50(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd 0x61327(%rip), %xmm0    # 0x76010
movsd %xmm0, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
cmpl $0x5, -0x34(%rbp)
jg 0x14d37
movsd 0x6130d(%rip), %xmm0    # 0x76010
addsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movslq -0x34(%rbp), %rcx
leaq 0x95798(%rip), %rax     # 0xaa4b0
movsd (%rax,%rcx,8), %xmm0
divsd -0x20(%rbp), %xmm0
addsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x14cf5
movsd -0x28(%rbp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd %xmm0, -0x58(%rbp)
movsd 0x61980(%rip), %xmm0    # 0x766e0
mulsd -0x30(%rbp), %xmm0
callq 0x8940
movaps %xmm0, %xmm1
movsd -0x58(%rbp), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movsd -0x18(%rbp), %xmm0
callq 0x8950
movsd %xmm0, -0x20(%rbp)
xorps %xmm0, %xmm0
ucomisd -0x20(%rbp), %xmm0
ja 0x14eb6
movq -0x30(%rbp), %rax
movsd -0x20(%rbp), %xmm0
cvtsi2sdl 0x58(%rax), %xmm1
ucomisd %xmm1, %xmm0
jbe 0x14ec3
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x14f83
movq -0x30(%rbp), %rax
movsd 0x50(%rax), %xmm0
movsd %xmm0, -0x40(%rbp)
movsd 0x61137(%rip), %xmm0    # 0x76010
addsd -0x20(%rbp), %xmm0
callq 0x14be0
movq -0x30(%rbp), %rax
movaps %xmm0, %xmm1
movsd -0x40(%rbp), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
cvtsi2sdl 0x58(%rax), %xmm0
subsd -0x20(%rbp), %xmm0
movsd 0x61106(%rip), %xmm1    # 0x76010
addsd %xmm1, %xmm0
callq 0x14be0
movq -0x30(%rbp), %rax
movaps %xmm0, %xmm1
movsd -0x38(%rbp), %xmm0
subsd %xmm1, %xmm0
movsd -0x20(%rbp), %xmm1
movsd 0x40(%rax), %xmm2
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
cvtsi2sdl 0x58(%rax), %xmm0
subsd -0x20(%rbp), %xmm0
movsd 0x48(%rax), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd 0x61777(%rip), %xmm0    # 0x766d0
ucomisd -0x28(%rbp), %xmm0
jbe 0x14f6a
xorps %xmm0, %xmm0
movsd %xmm0, -0x48(%rbp)
jmp 0x14f79
movsd -0x28(%rbp), %xmm0
callq 0x8958
movsd %xmm0, -0x48(%rbp)
movsd -0x48(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x50, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x180, %rsp            # imm = 0x180
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x170(%rbp)
callq 0x198a0
movq -0x170(%rbp), %rax
leaq 0x93e3e(%rip), %rcx     # 0xa8e00
addq $0x10, %rcx
movq %rcx, (%rax)
movsd -0x10(%rbp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
callq 0x8958
movsd %xmm0, -0x150(%rbp)
movl $0x1, -0x154(%rbp)
cmpl $0x28, -0x154(%rbp)
jge 0x1504b
movl -0x154(%rbp), %eax
subl $0x1, %eax
cltq
movsd -0x150(%rbp,%rax,8), %xmm0
mulsd -0x10(%rbp), %xmm0
cvtsi2sdl -0x154(%rbp), %xmm1
divsd %xmm1, %xmm0
movslq -0x154(%rbp), %rax
movsd %xmm0, -0x150(%rbp,%rax,8)
movl -0x154(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x154(%rbp)
jmp 0x14ffc
movl $0x38, %edi
callq 0x84c0
movq %rax, -0x178(%rbp)
jmp 0x1505e
movq -0x178(%rbp), %rdi
movl $0x28, %esi
leaq -0x150(%rbp), %rdx
callq 0x15e90
jmp 0x15078
movq -0x170(%rbp), %rax
movq -0x178(%rbp), %rcx
movq %rcx, 0x8(%rax)
cmpq $0x0, 0x8(%rax)
jne 0x150d3
callq 0x136a0
jmp 0x15098
jmp 0x150d3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x160(%rbp)
movl %eax, -0x164(%rbp)
jmp 0x150dc
movq -0x178(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x160(%rbp)
movl %eax, -0x164(%rbp)
movl $0x38, %esi
callq 0x84d0
jmp 0x150dc
addq $0x180, %rsp            # imm = 0x180
popq %rbp
retq
movq -0x170(%rbp), %rdi
callq 0x19e90
movq -0x160(%rbp), %rdi
callq 0x8860
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
xorps %xmm0, %xmm0
ucomisd -0x18(%rbp), %xmm0
jbe 0x159a0
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x15a45
movsd -0x18(%rbp), %xmm0
callq 0x8950
movq -0x30(%rbp), %rax
movsd %xmm0, -0x20(%rbp)
movsd 0x58(%rax), %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x20(%rbp), %xmm0
addsd 0x30(%rax), %xmm0
callq 0x14be0
movaps %xmm0, %xmm1
movsd -0x40(%rbp), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movsd 0x6062b(%rip), %xmm0    # 0x76010
addsd -0x20(%rbp), %xmm0
callq 0x14be0
movsd -0x38(%rbp), %xmm1
movq -0x30(%rbp), %rax
subsd %xmm0, %xmm1
movsd -0x20(%rbp), %xmm0
movsd 0x50(%rax), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd 0x60cb5(%rip), %xmm0    # 0x766d0
ucomisd -0x28(%rbp), %xmm0
jbe 0x15a2c
xorps %xmm0, %xmm0
movsd %xmm0, -0x48(%rbp)
jmp 0x15a3b
movsd -0x28(%rbp), %xmm0
callq 0x8958
movsd %xmm0, -0x48(%rbp)
movsd -0x48(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x50, %rsp
popq %rbp
retq
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x198a0
movq -0x28(%rbp), %rax
leaq 0x93377(%rip), %rcx     # 0xa90a0
addq $0x10, %rcx
movq %rcx, (%rax)
movsd 0x602d8(%rip), %xmm0    # 0x76010
ucomisd -0x10(%rbp), %xmm0
jbe 0x15da0
movl $0x40, %edi
callq 0x84c0
movq %rax, -0x30(%rbp)
jmp 0x15d4f
movq -0x30(%rbp), %rdi
movsd -0x10(%rbp), %xmm0
callq 0x15a50
jmp 0x15d5f
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, 0x8(%rax)
jmp 0x15e58
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x15e72
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x40, %esi
callq 0x84d0
jmp 0x15e72
movsd -0x10(%rbp), %xmm0
movsd 0x60263(%rip), %xmm1    # 0x76010
ucomisd %xmm1, %xmm0
jne 0x15e0c
jp 0x15e0c
movl $0x28, %edi
callq 0x84c0
movq %rax, -0x38(%rbp)
jmp 0x15dc5
movq -0x38(%rbp), %rdi
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, (%rdi)
movq $0x0, 0x20(%rdi)
callq 0x19900
jmp 0x15de2
movq -0x28(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, 0x8(%rax)
jmp 0x15e56
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x28, %esi
callq 0x84d0
jmp 0x15e72
movl $0x40, %edi
callq 0x84c0
movq %rax, -0x40(%rbp)
jmp 0x15e1c
movq -0x40(%rbp), %rdi
movsd -0x10(%rbp), %xmm0
callq 0x15ba0
jmp 0x15e2c
movq -0x28(%rbp), %rax
movq -0x40(%rbp), %rcx
movq %rcx, 0x8(%rax)
jmp 0x15e56
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x40, %esi
callq 0x84d0
jmp 0x15e72
jmp 0x15e58
movq -0x28(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x15e6c
callq 0x136a0
jmp 0x15e6a
jmp 0x15e6c
addq $0x40, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x19e90
movq -0x18(%rbp), %rdi
callq 0x8860
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x198a0
movq -0x38(%rbp), %rdi
leaq 0x93255(%rip), %rax     # 0xa9110
movq %rax, (%rdi)
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
callq 0x15fd0
jmp 0x15ecc
movq -0x38(%rbp), %rax
movq $0x0, 0x20(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x28(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x30(%rax)
movl $0x0, -0x28(%rbp)
movq -0x38(%rbp), %rcx
movl -0x28(%rbp), %eax
cmpl 0x18(%rcx), %eax
jge 0x15f45
movq -0x38(%rbp), %rax
movsd 0x28(%rax), %xmm1
cvtsi2sdl -0x28(%rbp), %xmm0
movq -0x18(%rbp), %rcx
movslq -0x28(%rbp), %rdx
movsd (%rcx,%rdx,8), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x28(%rax)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x15eef
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x19e90
jmp 0x15fb9
movl $0x0, -0x2c(%rbp)
movq -0x38(%rbp), %rcx
movl -0x2c(%rbp), %eax
cmpl 0x18(%rcx), %eax
jge 0x15fb3
movq -0x38(%rbp), %rax
movsd 0x28(%rax), %xmm1
movsd 0x30(%rax), %xmm0
movsd %xmm0, -0x48(%rbp)
cvtsi2sdl -0x2c(%rbp), %xmm0
subsd %xmm1, %xmm0
callq 0x19940
movsd %xmm0, -0x40(%rbp)
jmp 0x15f80
movq -0x38(%rbp), %rax
movsd -0x48(%rbp), %xmm1
movsd -0x40(%rbp), %xmm0
movq -0x18(%rbp), %rcx
movslq -0x2c(%rbp), %rdx
movsd (%rcx,%rdx,8), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x30(%rax)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x15f4c
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x8860
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x198a0
movq -0x40(%rbp), %rdi
leaq 0x92d91(%rip), %rax     # 0xa9110
movq %rax, (%rdi)
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
callq 0x15fd0
jmp 0x16390
movslq -0xc(%rbp), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
movq $-0x1, %rax
cmovoq %rax, %rdi
callq 0x8040
movq %rax, -0x48(%rbp)
jmp 0x163b5
movq -0x40(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rcx, 0x20(%rax)
cmpq $0x0, 0x20(%rax)
jne 0x163eb
callq 0x136a0
jmp 0x163cf
jmp 0x163eb
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x19e90
jmp 0x16501
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x16423
movq -0x40(%rbp), %rax
movq -0x20(%rbp), %rcx
movslq -0x30(%rbp), %rdx
movsd (%rcx,%rdx,8), %xmm0
movq 0x20(%rax), %rax
movslq -0x30(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x163f2
movq -0x40(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x28(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x30(%rax)
movl $0x0, -0x34(%rbp)
movq -0x40(%rbp), %rcx
movl -0x34(%rbp), %eax
cmpl 0x18(%rcx), %eax
jge 0x16485
movq -0x40(%rbp), %rax
movsd 0x28(%rax), %xmm1
movq 0x20(%rax), %rcx
movslq -0x34(%rbp), %rdx
movsd (%rcx,%rdx,8), %xmm0
movq -0x18(%rbp), %rcx
movslq -0x34(%rbp), %rdx
movsd (%rcx,%rdx,8), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x28(%rax)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x1643e
movl $0x0, -0x38(%rbp)
movq -0x40(%rbp), %rcx
movl -0x38(%rbp), %eax
cmpl 0x18(%rcx), %eax
jge 0x164fb
movq -0x40(%rbp), %rax
movsd 0x30(%rax), %xmm0
movsd %xmm0, -0x58(%rbp)
movq 0x20(%rax), %rcx
movslq -0x38(%rbp), %rdx
movsd (%rcx,%rdx,8), %xmm0
movsd 0x28(%rax), %xmm1
subsd %xmm1, %xmm0
callq 0x19940
movsd %xmm0, -0x50(%rbp)
jmp 0x164c8
movq -0x40(%rbp), %rax
movsd -0x58(%rbp), %xmm1
movsd -0x50(%rbp), %xmm0
movq -0x18(%rbp), %rcx
movslq -0x38(%rbp), %rdx
movsd (%rcx,%rdx,8), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x30(%rax)
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x1648c
addq $0x60, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x8860
nopw (%rax,%rax)
// File: melop[P]admixem/./newran02/newran.cpp
// Function: DiscreteGen::~DiscreteGen()
DiscreteGen::~DiscreteGen()
{
   delete [] p; delete [] ialt; delete [] val;
   #ifdef MONITOR
      cout << "destructing DiscreteGen\n";
   #endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0x92bd5(%rip), %rcx     # 0xa9100
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x16549
movq -0x10(%rbp), %rdi
callq 0x8640
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x16564
movq -0x20(%rbp), %rdi
callq 0x8640
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x1657f
movq -0x28(%rbp), %rdi
callq 0x8640
movq -0x18(%rbp), %rdi
callq 0x19e90
addq $0x30, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x180, %rsp            # imm = 0x180
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x180(%rbp)
movq 0x8(%rax), %rdi
movq (%rdi), %rax
movq 0x28(%rax), %rax
callq *%rax
movl %eax, -0x40(%rbp)
movsd %xmm0, -0x48(%rbp)
movl -0x40(%rbp), %eax
movl %eax, -0x30(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x19c70
movl %eax, %ecx
movq -0x180(%rbp), %rax
movl %ecx, -0x50(%rbp)
movsd %xmm0, -0x58(%rbp)
movl -0x50(%rbp), %ecx
movl %ecx, -0x20(%rbp)
movq -0x58(%rbp), %rcx
movq %rcx, -0x28(%rbp)
movq 0x10(%rax), %rdi
movq (%rdi), %rax
movq 0x28(%rax), %rax
callq *%rax
movl %eax, -0x80(%rbp)
movsd %xmm0, -0x88(%rbp)
movl -0x80(%rbp), %eax
movl %eax, -0x70(%rbp)
movq -0x88(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x19c70
movl %eax, %ecx
movq -0x180(%rbp), %rax
movl %ecx, -0x90(%rbp)
movsd %xmm0, -0x98(%rbp)
movl -0x90(%rbp), %ecx
movl %ecx, -0x60(%rbp)
movq -0x98(%rbp), %rcx
movq %rcx, -0x68(%rbp)
movq 0x8(%rax), %rdi
movq (%rdi), %rax
movq 0x30(%rax), %rax
callq *%rax
movl %eax, %ecx
movq -0x180(%rbp), %rax
movl %ecx, -0xb0(%rbp)
movsd %xmm0, -0xb8(%rbp)
movl -0xb0(%rbp), %ecx
movl %ecx, -0xa0(%rbp)
movq -0xb8(%rbp), %rcx
movq %rcx, -0xa8(%rbp)
movq 0x10(%rax), %rdi
movq (%rdi), %rax
movq 0x30(%rax), %rax
callq *%rax
movl %eax, -0xd0(%rbp)
movsd %xmm0, -0xd8(%rbp)
movl -0xd0(%rbp), %eax
movl %eax, -0xc0(%rbp)
movq -0xd8(%rbp), %rax
movq %rax, -0xc8(%rbp)
leaq -0xa8(%rbp), %rdi
movq %rdi, -0x178(%rbp)
leaq -0xc8(%rbp), %rsi
movq %rsi, -0x170(%rbp)
callq 0x11e10
movq -0x178(%rbp), %rdi
movl %eax, -0x100(%rbp)
movsd %xmm0, -0x108(%rbp)
movl -0x100(%rbp), %eax
movl %eax, -0xf0(%rbp)
movq -0x108(%rbp), %rax
movq %rax, -0xf8(%rbp)
leaq -0x68(%rbp), %rsi
callq 0x11e10
movl %eax, -0x120(%rbp)
movsd %xmm0, -0x128(%rbp)
movl -0x120(%rbp), %eax
movl %eax, -0x110(%rbp)
movq -0x128(%rbp), %rax
movq %rax, -0x118(%rbp)
leaq -0xf8(%rbp), %rdi
leaq -0x118(%rbp), %rsi
callq 0x11b90
movq -0x170(%rbp), %rsi
movl %eax, -0x130(%rbp)
movsd %xmm0, -0x138(%rbp)
movl -0x130(%rbp), %eax
movl %eax, -0xe0(%rbp)
movq -0x138(%rbp), %rax
movq %rax, -0xe8(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x11e10
movl %eax, -0x150(%rbp)
movsd %xmm0, -0x158(%rbp)
movl -0x150(%rbp), %eax
movl %eax, -0x140(%rbp)
movq -0x158(%rbp), %rax
movq %rax, -0x148(%rbp)
leaq -0xe8(%rbp), %rdi
leaq -0x148(%rbp), %rsi
callq 0x11b90
movl %eax, -0x160(%rbp)
movsd %xmm0, -0x168(%rbp)
movl -0x160(%rbp), %eax
movl %eax, -0x8(%rbp)
movq -0x168(%rbp), %rax
movq %rax, -0x10(%rbp)
movsd -0x10(%rbp), %xmm0
movl -0x8(%rbp), %eax
addq $0x180, %rsp            # imm = 0x180
popq %rbp
retq
nop
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x198a0
movq -0x38(%rbp), %rdi
leaq 0x91541(%rip), %rax     # 0xa9170
movq %rax, (%rdi)
addq $0x20, %rdi
callq 0x19cb0
jmp 0x17c3d
movq -0x38(%rbp), %rdi
addq $0x30, %rdi
callq 0x19cb0
jmp 0x17c4c
movq -0x38(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, 0x8(%rax)
movslq 0x8(%rax), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
movq $-0x1, %rax
cmovoq %rax, %rdi
callq 0x8040
movq %rax, -0x40(%rbp)
jmp 0x17c7b
movq -0x38(%rbp), %rax
movq -0x40(%rbp), %rcx
movq %rcx, 0x18(%rax)
cmpq $0x0, 0x18(%rax)
jne 0x17cae
callq 0x136a0
jmp 0x17c95
jmp 0x17cae
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x19e90
jmp 0x17cfd
movl $0x0, -0x30(%rbp)
movq -0x38(%rbp), %rcx
movl -0x30(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x17ce8
movq -0x38(%rbp), %rax
movq -0x20(%rbp), %rcx
movslq -0x30(%rbp), %rdx
movq (%rcx,%rdx,8), %rdx
movq 0x18(%rax), %rax
movslq -0x30(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x17cb5
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x17d10
jmp 0x17cf7
addq $0x40, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x8860
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x198a0
movq -0x38(%rbp), %rdi
leaq 0x91028(%rip), %rax     # 0xa9170
movq %rax, (%rdi)
addq $0x20, %rdi
callq 0x19cb0
jmp 0x18156
movq -0x38(%rbp), %rdi
addq $0x30, %rdi
callq 0x19cb0
jmp 0x18165
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
movq 0x40(%rax), %rax
callq *%rax
movl %eax, -0x3c(%rbp)
jmp 0x18177
movq -0x38(%rbp), %rax
movl -0x3c(%rbp), %ecx
movl %ecx, 0x8(%rax)
movslq 0x8(%rax), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
movq $-0x1, %rax
cmovoq %rax, %rdi
callq 0x8040
movq %rax, -0x48(%rbp)
jmp 0x181a6
movq -0x38(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rcx, -0x28(%rbp)
movslq 0x8(%rax), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
movq $-0x1, %rax
cmovoq %rax, %rdi
callq 0x8040
movq %rax, -0x50(%rbp)
jmp 0x181d7
movq -0x38(%rbp), %rax
movq -0x50(%rbp), %rcx
movq %rcx, 0x18(%rax)
cmpq $0x0, -0x28(%rbp)
je 0x181f5
movq -0x38(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x18215
callq 0x136a0
jmp 0x181fc
jmp 0x18215
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x19e90
jmp 0x18267
movq -0x38(%rbp), %rax
movl $0x0, -0x2c(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rdx
movq 0x18(%rax), %rcx
movq (%rdi), %rax
movq 0x48(%rax), %rax
leaq -0x2c(%rbp), %rsi
callq *%rax
jmp 0x1823b
movq -0x38(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x17d10
jmp 0x1824a
movq -0x28(%rbp), %rax
movq %rax, -0x58(%rbp)
cmpq $0x0, %rax
je 0x18261
movq -0x58(%rbp), %rdi
callq 0x8640
addq $0x60, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x8860