LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: besm6[P]pascal-re/dtran.cc
// Function: Dtran::gak[abi:cxx11](unsigned int)
std::string gak(uint i) {
        std::string ret("G");
        ret += 'A'+i/128;
        ret += 'K'+i/8%16;
        ret += '/';
        ret += '0'+i%8;
        return ret;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movb $0x0, -0x15(%rbp)
leaq -0x16(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x3380
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rdx
leaq 0x20d1(%rip), %rsi      # 0x84af
callq 0x4ee0
jmp 0x63e5
leaq -0x16(%rbp), %rdi
callq 0x31f0
movq -0x38(%rbp), %rdi
movl -0x14(%rbp), %eax
shrl $0x7, %eax
addl $0x41, %eax
movsbl %al, %esi
callq 0x3120
jmp 0x6405
movq -0x38(%rbp), %rdi
movl -0x14(%rbp), %esi
shrl $0x3, %esi
andl $0xf, %esi
addl $0x4b, %esi
callq 0x3120
jmp 0x641c
movq -0x38(%rbp), %rdi
movl $0x2f, %esi
callq 0x3120
jmp 0x642c
movq -0x38(%rbp), %rdi
movl -0x14(%rbp), %esi
andl $0x7, %esi
orl $0x30, %esi
callq 0x3120
jmp 0x6440
movb $0x1, -0x15(%rbp)
testb $0x1, -0x15(%rbp)
jne 0x6483
jmp 0x647a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x16(%rbp), %rdi
callq 0x31f0
jmp 0x648d
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x3110
jmp 0x648d
movq -0x38(%rbp), %rdi
callq 0x3110
movq -0x40(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x3370
nopw %cs:(%rax,%rax)
// File: besm6[P]pascal-re/dtran.cc
// Function: Dtran::is_likely_iso(unsigned long long)
bool is_likely_iso (uint64 word) {
        for (uint i = 0; i < 48; i += 8) {
            uint val = (word >> i) & 0377;
            if (val < 040 || val >= 0177)
                return false;
        }
        return true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x30, -0x1c(%rbp)
jae 0x734b
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
shrq %cl, %rax
andq $0xff, %rax
movl %eax, -0x20(%rbp)
cmpl $0x20, -0x20(%rbp)
jb 0x7338
cmpl $0x7f, -0x20(%rbp)
jb 0x733e
movb $0x0, -0x1(%rbp)
jmp 0x734f
jmp 0x7340
movl -0x1c(%rbp), %eax
addl $0x8, %eax
movl %eax, -0x1c(%rbp)
jmp 0x7313
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: besm6[P]pascal-re/dtran.cc
// Function: Dtran::get_iso_word[abi:cxx11](unsigned long long)
std::string get_iso_word(uint64 word) {
        std::string ret;
        for (uint i = 40; i <= 40; i-=8) {
            ret += get_iso_char(word >> i);
        }
        return ret;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x32b0
movl $0x28, -0x20(%rbp)
cmpl $0x28, -0x20(%rbp)
ja 0x7401
movq -0x58(%rbp), %rsi
movq -0x18(%rbp), %rax
movb -0x20(%rbp), %cl
shrq %cl, %rax
movzbl %al, %edx
leaq -0x40(%rbp), %rdi
callq 0x7510
jmp 0x73b9
movq -0x68(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x3280
jmp 0x73c8
leaq -0x40(%rbp), %rdi
callq 0x3110
movl -0x20(%rbp), %eax
subl $0x8, %eax
movl %eax, -0x20(%rbp)
jmp 0x7397
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x741e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3110
jmp 0x741e
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x7414
movq -0x68(%rbp), %rdi
callq 0x3110
movq -0x60(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x3110
movq -0x48(%rbp), %rdi
callq 0x3370
// File: besm6[P]pascal-re/dtran.cc
// Function: Dtran::is_likely_text(unsigned long long)
bool is_likely_text(uint64 word) {
        // Of all groups of 6 bits, they should be left-
        // or right-aligned, there must be no spaces in the middle,
        // and no unused codes or Cyrillics.
        int seen0 = 0, seen_char = 0;
        bool last0 = false;
        for (uint i = 42; i <= 42; i-=6) {
            uint val = (word >> i) & 077;
            switch (val) {
            case 001 ... 011:
            case 013 ... 016:
            case 032 ... 034:
            case 037:
            case 040:
            case 073 ... 077:
                return false;
            case 0:
                if (seen_char && seen0 && !last0) return false;
                ++seen0;
                last0 = true;
                break;
            default:
                if (seen_char && seen0 && last0) return false;
                ++seen_char;
                last0 = false;
            }
        }
        return seen_char > 1;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
movl $0x2a, -0x28(%rbp)
cmpl $0x2a, -0x28(%rbp)
ja 0x74fa
movq -0x18(%rbp), %rax
movb -0x28(%rbp), %cl
shrq %cl, %rax
andl $0x3f, %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movq %rax, -0x38(%rbp)
subq $0x3f, %rax
ja 0x74c5
movq -0x38(%rbp), %rax
leaq 0xbf5(%rip), %rcx       # 0x807c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0x7492
jmp 0x7494
jmp 0x7496
jmp 0x7498
movb $0x0, -0x1(%rbp)
jmp 0x7506
cmpl $0x0, -0x20(%rbp)
je 0x74b6
cmpl $0x0, -0x1c(%rbp)
je 0x74b6
testb $0x1, -0x21(%rbp)
jne 0x74b6
movb $0x0, -0x1(%rbp)
jmp 0x7506
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movb $0x1, -0x21(%rbp)
jmp 0x74ea
cmpl $0x0, -0x20(%rbp)
je 0x74dd
cmpl $0x0, -0x1c(%rbp)
je 0x74dd
testb $0x1, -0x21(%rbp)
je 0x74dd
movb $0x0, -0x1(%rbp)
jmp 0x7506
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
jmp 0x74ec
movl -0x28(%rbp), %eax
subl $0x6, %eax
movl %eax, -0x28(%rbp)
jmp 0x7455
cmpl $0x1, -0x20(%rbp)
setg %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax)
// File: besm6[P]pascal-re/dtran.cc
// Function: Dtran::get_bytes[abi:cxx11](unsigned long long)
std::string get_bytes(uint64 word) {
        std::string ret;
        for (uint i = 40; i <= 40; i-=8) {
            ret += strprintf("%03o ", int(word >> i) & 0377);
        }
        return ret;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x32b0
movl $0x28, -0x20(%rbp)
cmpl $0x28, -0x20(%rbp)
ja 0x76ae
movq -0x18(%rbp), %rax
movb -0x20(%rbp), %cl
shrq %cl, %rax
movzbl %al, %edx
leaq 0x1136(%rip), %rsi      # 0x878f
xorl %eax, %eax
leaq -0x40(%rbp), %rdi
callq 0x34c0
jmp 0x7666
movq -0x60(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x3280
jmp 0x7675
leaq -0x40(%rbp), %rdi
callq 0x3110
movl -0x20(%rbp), %eax
subl $0x8, %eax
movl %eax, -0x20(%rbp)
jmp 0x763f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x76cb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3110
jmp 0x76cb
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x76c1
movq -0x60(%rbp), %rdi
callq 0x3110
movq -0x58(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x3110
movq -0x48(%rbp), %rdi
callq 0x3370
nopl (%rax)
// File: tewalds[P]morat/y/board.h
// Function: Morat::Y::Board::update_hash(Morat::MoveValid const&, Morat::Side)
void update_hash(const MoveValid & pos, Side side) {
		int turn = side.to_i();
		if(num_moves_ > unique_depth){ //simple update, no rotations/symmetry
			hash.update(0, 3 * pos.xy + turn);
			return;
		}

		//mirror is simply flip x,y
		int x = pos.x,
		    y = pos.y,
		    z = sizem1_ - x - y;

		hash.update(0,  3*xy(x, y) + turn);
		hash.update(1,  3*xy(z, y) + turn);
		hash.update(2,  3*xy(z, x) + turn);
		hash.update(3,  3*xy(x, z) + turn);
		hash.update(4,  3*xy(y, z) + turn);
		hash.update(5,  3*xy(y, x) + turn);
	}

// Assembly:
subq $0x68, %rsp
movb %dl, %al
movb %al, 0x67(%rsp)
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x38(%rsp)
leaq 0x67(%rsp), %rdi
callq 0x1fda0
movb %al, %cl
movq 0x38(%rsp), %rax
movsbl %cl, %ecx
movl %ecx, 0x4c(%rsp)
movswl 0x4(%rax), %eax
cmpl $0x5, %eax
jle 0x1f7c4
movq 0x38(%rsp), %rdi
addq $0x28, %rdi
movq 0x50(%rsp), %rax
movswl 0x2(%rax), %eax
imull $0x3, %eax, %edx
addl 0x4c(%rsp), %edx
xorl %esi, %esi
callq 0x1fdb0
jmp 0x1f922
movq 0x38(%rsp), %rdi
movq 0x50(%rsp), %rax
movsbl 0x1(%rax), %eax
movl %eax, 0x48(%rsp)
movq 0x50(%rsp), %rax
movsbl (%rax), %eax
movl %eax, 0x44(%rsp)
movsbl 0x1(%rdi), %eax
subl 0x48(%rsp), %eax
subl 0x44(%rsp), %eax
movl %eax, 0x40(%rsp)
movq %rdi, %rax
addq $0x28, %rax
movq %rax, 0x8(%rsp)
movl 0x48(%rsp), %esi
movl 0x44(%rsp), %edx
callq 0x1fde0
movq 0x8(%rsp), %rdi
imull $0x3, %eax, %edx
addl 0x4c(%rsp), %edx
xorl %esi, %esi
callq 0x1fdb0
movq 0x38(%rsp), %rdi
movq %rdi, %rax
addq $0x28, %rax
movq %rax, 0x10(%rsp)
movl 0x40(%rsp), %esi
movl 0x44(%rsp), %edx
callq 0x1fde0
movq 0x10(%rsp), %rdi
imull $0x3, %eax, %edx
addl 0x4c(%rsp), %edx
movl $0x1, %esi
callq 0x1fdb0
movq 0x38(%rsp), %rdi
movq %rdi, %rax
addq $0x28, %rax
movq %rax, 0x18(%rsp)
movl 0x40(%rsp), %esi
movl 0x48(%rsp), %edx
callq 0x1fde0
movq 0x18(%rsp), %rdi
imull $0x3, %eax, %edx
addl 0x4c(%rsp), %edx
movl $0x2, %esi
callq 0x1fdb0
movq 0x38(%rsp), %rdi
movq %rdi, %rax
addq $0x28, %rax
movq %rax, 0x20(%rsp)
movl 0x48(%rsp), %esi
movl 0x40(%rsp), %edx
callq 0x1fde0
movq 0x20(%rsp), %rdi
imull $0x3, %eax, %edx
addl 0x4c(%rsp), %edx
movl $0x3, %esi
callq 0x1fdb0
movq 0x38(%rsp), %rdi
movq %rdi, %rax
addq $0x28, %rax
movq %rax, 0x28(%rsp)
movl 0x44(%rsp), %esi
movl 0x40(%rsp), %edx
callq 0x1fde0
movq 0x28(%rsp), %rdi
imull $0x3, %eax, %edx
addl 0x4c(%rsp), %edx
movl $0x4, %esi
callq 0x1fdb0
movq 0x38(%rsp), %rdi
movq %rdi, %rax
addq $0x28, %rax
movq %rax, 0x30(%rsp)
movl 0x44(%rsp), %esi
movl 0x48(%rsp), %edx
callq 0x1fde0
movq 0x30(%rsp), %rdi
imull $0x3, %eax, %edx
addl 0x4c(%rsp), %edx
movl $0x5, %esi
callq 0x1fdb0
addq $0x68, %rsp
retq
nopw (%rax,%rax)
// File: tewalds[P]morat/y/board.h
// Function: Morat::Y::Board::test_outcome(Morat::MoveValid const&, Morat::Side) const
Outcome test_outcome(const MoveValid & pos, Side turn) const {
		if(test_local(pos, turn)){
			Cell testcell = cells_[find_group(pos.xy)];
			int numgroups = 0;
			auto it = neighbors_small(pos);
			for (const MoveValid *i = it.begin(), *e = it.end(); i < e; i++) {
				if(i->on_board() && turn == get(i->xy)){
					const Cell * g = & cells_[find_group(i->xy)];
					testcell.edge   |= g->edge;
					testcell.size   += g->size;
					i++; //skip the next one
					numgroups++;
				}
			}

			if(testcell.numedges() == 3)
				return +turn;
		}

		return Outcome::UNKNOWN;
	}

// Assembly:
subq $0x98, %rsp
movb %dl, %al
movb %al, 0x96(%rsp)
movq %rdi, 0x88(%rsp)
movq %rsi, 0x80(%rsp)
movq 0x88(%rsp), %rdi
movq %rdi, 0x20(%rsp)
movq 0x80(%rsp), %rsi
movb 0x96(%rsp), %al
movb %al, 0x7f(%rsp)
movzbl 0x7f(%rsp), %edx
callq 0x2aa00
testb $0x1, %al
jne 0x296b3
jmp 0x2984c
movq 0x20(%rsp), %rdi
movq %rdi, %rax
addq $0x10, %rax
movq %rax, 0x18(%rsp)
movq 0x80(%rsp), %rax
movswl 0x2(%rax), %esi
callq 0x1fc30
movq 0x18(%rsp), %rdi
movslq %eax, %rsi
callq 0x1fe50
movq 0x20(%rsp), %rdi
movq (%rax), %rcx
movq %rcx, 0x68(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x70(%rsp)
movl $0x0, 0x64(%rsp)
movq 0x80(%rsp), %rsi
callq 0x1fa30
movq %rax, 0x50(%rsp)
movq %rdx, 0x58(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x11720
movq %rax, 0x48(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x11730
movq %rax, 0x40(%rsp)
movq 0x48(%rsp), %rax
cmpq 0x40(%rsp), %rax
jae 0x2981d
movq 0x48(%rsp), %rdi
callq 0x11740
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0x17(%rsp)
jne 0x2975e
jmp 0x2978b
movq 0x20(%rsp), %rdi
movq 0x48(%rsp), %rax
movswl 0x2(%rax), %esi
callq 0x1fab0
movb %al, 0x3f(%rsp)
leaq 0x96(%rsp), %rdi
leaq 0x3f(%rsp), %rsi
callq 0x1fa70
movb %al, 0x17(%rsp)
movb 0x17(%rsp), %al
testb $0x1, %al
jne 0x29795
jmp 0x29808
movq 0x20(%rsp), %rdi
movq %rdi, %rax
addq $0x10, %rax
movq %rax, 0x8(%rsp)
movq 0x48(%rsp), %rax
movswl 0x2(%rax), %esi
callq 0x1fc30
movq 0x8(%rsp), %rdi
movslq %eax, %rsi
callq 0x1fe50
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movzbl 0x6(%rax), %ecx
movzbl 0x6e(%rsp), %eax
orl %ecx, %eax
movb %al, 0x6e(%rsp)
movq 0x30(%rsp), %rax
movzwl 0x2(%rax), %ecx
movzwl 0x6a(%rsp), %eax
addl %ecx, %eax
movw %ax, 0x6a(%rsp)
movq 0x48(%rsp), %rax
addq $0x4, %rax
movq %rax, 0x48(%rsp)
movl 0x64(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x64(%rsp)
jmp 0x2980a
movq 0x48(%rsp), %rax
addq $0x4, %rax
movq %rax, 0x48(%rsp)
jmp 0x29735
leaq 0x68(%rsp), %rdi
callq 0x1fce0
cmpl $0x3, %eax
jne 0x2984a
movb 0x96(%rsp), %al
movb %al, 0x2f(%rsp)
movzbl 0x2f(%rsp), %edi
callq 0x1fd00
movb %al, 0x97(%rsp)
jmp 0x2985c
jmp 0x2984c
leaq 0x43c6d(%rip), %rax     # 0x6d4c0
movb (%rax), %al
movb %al, 0x97(%rsp)
movb 0x97(%rsp), %al
addq $0x98, %rsp
retq
nopl (%rax,%rax)
// File: tewalds[P]morat/y/lbdist.h
// Function: Morat::Y::LBDists::init_player(bool, Morat::Side)
void init_player(bool crossvcs, Side player){
		int m = board->lines();
		int m1 = m-1;

		for(int x = 0; x < m; x++) { init(x,    0, 0,  player, 3); } flood(0,  player, crossvcs); //edge 0
		for(int y = 0; y < m; y++) { init(0,    y, 1,  player, 1); } flood(1,  player, crossvcs); //edge 1
		for(int y = 0; y < m; y++) { init(m1-y, y, 2,  player, 5); } flood(2,  player, crossvcs); //edge 2
	}

// Assembly:
subq $0x48, %rsp
movb %dl, %cl
movb %sil, %al
movb %cl, 0x47(%rsp)
movq %rdi, 0x38(%rsp)
andb $0x1, %al
movb %al, 0x37(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0xafe0(%rax), %rdi
callq 0x1ffe0
movl %eax, 0x30(%rsp)
movl 0x30(%rsp), %eax
subl $0x1, %eax
movl %eax, 0x2c(%rsp)
movl $0x0, 0x28(%rsp)
movl 0x28(%rsp), %eax
cmpl 0x30(%rsp), %eax
jge 0x2add2
movq 0x8(%rsp), %rdi
movl 0x28(%rsp), %esi
movb 0x47(%rsp), %al
movb %al, 0x27(%rsp)
xorl %ecx, %ecx
movl $0x3, %r9d
movl %ecx, %edx
movzbl 0x27(%rsp), %r8d
callq 0x2aee0
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0x2ad95
movq 0x8(%rsp), %rdi
movb 0x47(%rsp), %al
movb %al, 0x26(%rsp)
movb 0x37(%rsp), %al
xorl %esi, %esi
andb $0x1, %al
movzbl 0x26(%rsp), %edx
movzbl %al, %ecx
callq 0x2b030
movl $0x0, 0x20(%rsp)
movl 0x20(%rsp), %eax
cmpl 0x30(%rsp), %eax
jge 0x2ae3a
movq 0x8(%rsp), %rdi
movl 0x20(%rsp), %edx
movb 0x47(%rsp), %al
movb %al, 0x1f(%rsp)
xorl %esi, %esi
movl $0x1, %r9d
movl %r9d, %ecx
movzbl 0x1f(%rsp), %r8d
callq 0x2aee0
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0x2adfc
movq 0x8(%rsp), %rdi
movb 0x47(%rsp), %al
movb %al, 0x1e(%rsp)
movb 0x37(%rsp), %al
movl $0x1, %esi
andb $0x1, %al
movzbl 0x1e(%rsp), %edx
movzbl %al, %ecx
callq 0x2b030
movl $0x0, 0x18(%rsp)
movl 0x18(%rsp), %eax
cmpl 0x30(%rsp), %eax
jge 0x2aead
movq 0x8(%rsp), %rdi
movl 0x2c(%rsp), %esi
subl 0x18(%rsp), %esi
movl 0x18(%rsp), %edx
movb 0x47(%rsp), %al
movb %al, 0x17(%rsp)
movl $0x2, %ecx
movl $0x5, %r9d
movzbl 0x17(%rsp), %r8d
callq 0x2aee0
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x2ae67
movq 0x8(%rsp), %rdi
movb 0x47(%rsp), %al
movb %al, 0x16(%rsp)
movb 0x37(%rsp), %al
movl $0x2, %esi
andb $0x1, %al
movzbl 0x16(%rsp), %edx
movzbl %al, %ecx
callq 0x2b030
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: tewalds[P]morat/y/lbdist.h
// Function: Morat::Y::LBDists::_get(int, Morat::Side)
int _get(int pos, Side player){
		int sum = 0;
		for(int i = 0; i < 3; i++)
			sum += dist(i, player, pos);
		return sum;
	}

// Assembly:
subq $0x28, %rsp
movb %dl, %al
movb %al, 0x27(%rsp)
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movl $0x0, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
cmpl $0x3, 0xc(%rsp)
jge 0x2c8d8
movq (%rsp), %rdi
movl 0xc(%rsp), %esi
movb 0x27(%rsp), %al
movb %al, 0xb(%rsp)
movl 0x14(%rsp), %ecx
movzbl 0xb(%rsp), %edx
callq 0x2b460
movl (%rax), %eax
addl 0x10(%rsp), %eax
movl %eax, 0x10(%rsp)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x2c89c
movl 0x10(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: sirak92[P]TradeMatchingEngine/src/TradeMatchingEngine.cpp
// Function: dumpOrder(Order*)
void dumpOrder(Order* order)
{
	std::cout << "\nOrder:"
		<< "\nTradeId = " << order->m_traderId
		<< "\nisBuy = " << order->m_isBuy
		<< "\nQuantity = " << order->m_quantity
		<< "\nPrice = " << order->m_price << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0xaabd(%rip), %rdi      # 0xcfd0
leaq 0x5aea(%rip), %rsi      # 0x8004
callq 0x2170
movq %rax, %rdi
leaq 0x5ae3(%rip), %rsi      # 0x800c
callq 0x2170
movq %rax, %rdi
movq -0x8(%rbp), %rsi
callq 0x2150
movq %rax, %rdi
leaq 0x5ad4(%rip), %rsi      # 0x8018
callq 0x2170
movq %rax, %rdi
movq -0x8(%rbp), %rax
movb 0x20(%rax), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x22a0
movq %rax, %rdi
leaq 0x5abb(%rip), %rsi      # 0x8022
callq 0x2170
movq %rax, %rdi
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rsi
callq 0x2070
movq %rax, %rdi
leaq 0x5aa9(%rip), %rsi      # 0x802f
callq 0x2170
movq %rax, %rdi
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rsi
callq 0x2070
movq %rax, %rdi
movq 0xaa1b(%rip), %rsi      # 0xcfc0
callq 0x21a0
addq $0x10, %rsp
popq %rbp
retq
// File: sirak92[P]TradeMatchingEngine/src/TradeMatchingEngine.cpp
// Function: TradeMatchingEngine::start()
void TradeMatchingEngine::start()
{
	std::cout << "Trade Matching Engine started....\n";

	Order *order = getOrder();

	while (order) {
		processOrder(order);

		// get next order
		order = getOrder();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0xa995(%rip), %rdi      # 0xcfd0
leaq 0x59f7(%rip), %rsi      # 0x8039
callq 0x2170
movq -0x18(%rbp), %rdi
callq 0x2680
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x2677
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2700
movq -0x18(%rbp), %rdi
callq 0x2680
movq %rax, -0x10(%rbp)
jmp 0x2654
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: sirak92[P]TradeMatchingEngine/src/TradeMatchingEngine.cpp
// Function: TradeMatchingEngine::getOrder()
Order* TradeMatchingEngine::getOrder()
{
	Order *ord = new Order();

	std::cout << "\nInput request <Trader Identifier> <Side> <Quantity> <Price>: \n";
	std::cin >> *ord;
	
	return ord;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl $0x38, %edi
callq 0x2180
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x28(%rbp)
callq 0x27c0
jmp 0x26a7
movq -0x28(%rbp), %rax
movq %rax, -0x10(%rbp)
movq 0xa91a(%rip), %rdi      # 0xcfd0
leaq 0x599f(%rip), %rsi      # 0x805c
callq 0x2170
movq -0x10(%rbp), %rsi
movq 0xa913(%rip), %rdi      # 0xcfe0
callq 0x7ca0
movq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x2160
movq -0x18(%rbp), %rdi
callq 0x2280
nopw (%rax,%rax)
// File: sirak92[P]TradeMatchingEngine/src/TradeMatchingEngine.cpp
// Function: TradeMatchingEngine::processOrder(Order*)
void TradeMatchingEngine::processOrder(Order* o)
{
	m_orderBook->makeOrder(o);

	// for testing purposes only
	if (m_debug_enabled) {
		m_orderBook->dumpAsks();
		m_orderBook->dumpBids();
	}

	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x2b00
movq -0x18(%rbp), %rax
testb $0x1, 0x8(%rax)
je 0x2746
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x2f80
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x2fd0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: sirak92[P]TradeMatchingEngine/src/OrdersBook.cpp
// Function: OrdersBook::makeOrder(Order*)
void OrdersBook::makeOrder(Order *order)
{
	// starts from empty logs for each order
	m_tradeLogs.clear();

	// store the original quantity of item
	int origQnty = order->m_quantity;

	if (order->m_isBuy) {
		handleRequest<OrdersAskTable>(m_asks, order, origQnty);
	}
	else {
		handleRequest<OrdersBidTable>(m_bids, order, origQnty);
	}

	// requested quantity isn't satisfied then store the request as a resting order
	if (origQnty != 0) {
		// update quantity with the remain count
		order->m_quantity = origQnty;
		addOrder(order);
	}
	else {
		// release memory
		delete order;
	}

	// dump trade logs
	dumpTradeLogs();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x60, %rdi
callq 0x3020
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
testb $0x1, 0x20(%rax)
je 0x2b4c
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq -0x14(%rbp), %rcx
movq %rsi, %rdi
callq 0x3040
jmp 0x2b64
movq -0x20(%rbp), %rdi
movq %rdi, %rsi
addq $0x30, %rsi
movq -0x10(%rbp), %rdx
leaq -0x14(%rbp), %rcx
callq 0x33e0
cmpl $0x0, -0x14(%rbp)
je 0x2b85
movq -0x20(%rbp), %rdi
movslq -0x14(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rsi
callq 0x2bc0
jmp 0x2ba7
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x2ba5
movq -0x28(%rbp), %rdi
callq 0x3770
movq -0x28(%rbp), %rdi
callq 0x2160
jmp 0x2ba7
movq -0x20(%rbp), %rdi
callq 0x2c40
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sirak92[P]TradeMatchingEngine/src/OrdersBook.cpp
// Function: OrdersBook::dumpTradeLogs()
void OrdersBook::dumpTradeLogs()
{
	if (m_tradeLogs.empty())
		return;

	std::cout << "\n-----------------------------------------\n";
	for (auto iter = m_tradeLogs.begin(); iter != m_tradeLogs.end(); iter++) {
		std::cout << iter->second;
	}
	std::cout << "\n-----------------------------------------\n";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
addq $0x60, %rdi
callq 0x3b70
testb $0x1, %al
jne 0x2c63
jmp 0x2c68
jmp 0x2cf0
movq 0xa361(%rip), %rdi      # 0xcfd0
leaq 0x5426(%rip), %rsi      # 0x809c
callq 0x2170
movq -0x28(%rbp), %rdi
addq $0x60, %rdi
callq 0x3b90
movq %rax, -0x10(%rbp)
movq -0x28(%rbp), %rdi
addq $0x60, %rdi
callq 0x3bc0
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x3a20
testb $0x1, %al
jne 0x2cb0
jmp 0x2cdd
leaq -0x10(%rbp), %rdi
callq 0x3a50
movq %rax, %rsi
addq $0x20, %rsi
movq 0xa309(%rip), %rdi      # 0xcfd0
callq 0x7c00
leaq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x3a70
movq %rax, -0x20(%rbp)
jmp 0x2c8c
movq 0xa2ec(%rip), %rdi      # 0xcfd0
leaq 0x53b1(%rip), %rsi      # 0x809c
callq 0x2170
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sirak92[P]TradeMatchingEngine/src/OrdersBook.cpp
// Function: OrdersBook::addTradeInfo(Order*, Order, int)
void OrdersBook::addTradeInfo(Order *origOrder, Order curOrder, int performedQnty)
{
	// store the first log
	curOrder.m_quantity = performedQnty;
	logOrder(curOrder);

	// update the quantity and price of original order and store it
	Order order = *origOrder;
	order.m_quantity = performedQnty;
	order.m_price = curOrder.m_price;
	logOrder(order);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdx, -0xf8(%rbp)
movq %rsi, %rax
movq -0xf8(%rbp), %rsi
movq %rsi, -0xf0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xe8(%rbp)
movslq -0x1c(%rbp), %rax
movq %rax, 0x28(%rsi)
leaq -0x58(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
callq 0x3790
movq -0xe8(%rbp), %rdi
movq -0xe0(%rbp), %rsi
callq 0x2e40
jmp 0x2d6a
leaq -0x58(%rbp), %rdi
callq 0x3770
movq -0x10(%rbp), %rsi
leaq -0xa0(%rbp), %rdi
movq %rdi, -0x100(%rbp)
callq 0x3790
movq -0xf0(%rbp), %rax
movq -0x100(%rbp), %rsi
movslq -0x1c(%rbp), %rcx
movq %rcx, -0x78(%rbp)
movq 0x30(%rax), %rax
movq %rax, -0x70(%rbp)
leaq -0xd8(%rbp), %rdi
callq 0x3790
jmp 0x2db6
movq -0xe8(%rbp), %rdi
leaq -0xd8(%rbp), %rsi
callq 0x2e40
jmp 0x2dcb
leaq -0xd8(%rbp), %rdi
callq 0x3770
leaq -0xa0(%rbp), %rdi
callq 0x3770
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x3770
jmp 0x2e35
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x2e29
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0xd8(%rbp), %rdi
callq 0x3770
leaq -0xa0(%rbp), %rdi
callq 0x3770
movq -0x60(%rbp), %rdi
callq 0x2280
nop
// File: sirak92[P]TradeMatchingEngine/src/OrdersBook.cpp
// Function: OrdersBook::logOrder(Order)
void OrdersBook::logOrder(Order order)
{
	std::pair<OrdersLog::iterator, OrdersLog::iterator> range = m_tradeLogs.equal_range(order.m_traderId);

	for (auto iter = range.first; iter != range.second; iter++)
		if (iter->second == order) {
			iter->second += order;
			return;
		}
			
	m_tradeLogs.insert(std::pair < std::string, Order>(order.m_traderId, order));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rsi, -0xb0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
addq $0x60, %rdi
callq 0x39e0
movq %rax, -0x20(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rsi
addq $0x8, %rsi
leaq -0x28(%rbp), %rdi
callq 0x3a20
testb $0x1, %al
jne 0x2e95
jmp 0x2ee8
leaq -0x28(%rbp), %rdi
callq 0x3a50
movq -0xb0(%rbp), %rsi
movq %rax, %rdi
addq $0x20, %rdi
callq 0x7ab0
testb $0x1, %al
jne 0x2eb7
jmp 0x2ed5
leaq -0x28(%rbp), %rdi
callq 0x3a50
movq -0xb0(%rbp), %rsi
movq %rax, %rdi
addq $0x20, %rdi
callq 0x7bd0
jmp 0x2f4d
jmp 0x2ed7
leaq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x3a70
movq %rax, -0x30(%rbp)
jmp 0x2e7e
movq -0xb0(%rbp), %rdx
movq -0xa8(%rbp), %rax
addq $0x60, %rax
movq %rax, -0xc8(%rbp)
leaq -0x88(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
movq %rdx, %rsi
callq 0x3ae0
movq -0xc8(%rbp), %rdi
movq -0xc0(%rbp), %rsi
callq 0x3ab0
movq %rax, -0xb8(%rbp)
jmp 0x2f33
movq -0xb8(%rbp), %rax
movq %rax, -0xa0(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x3b40
addq $0xd0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x3b40
movq -0x90(%rbp), %rdi
callq 0x2280
// File: sirak92[P]TradeMatchingEngine/src/OrdersBook.cpp
// Function: void OrdersBook::dumpHelper<std::map<int, std::__cxx11::list<Order*, std::allocator<Order*>>, std::less<int>, std::allocator<std::pair<int const, std::__cxx11::list<Order*, std::allocator<Order*>>>>>>(std::map<int, std::__cxx11::list<Order*, std::allocator<Order*>>, std::less<int>, std::allocator<std::pair<int const, std::__cxx11::list<Order*, std::allocator<Order*>>>>> const&)
void OrdersBook::dumpHelper(const T &table)
{
	for (auto it = table.begin(); it != table.end(); it++) {
		std::cout << it->first << " => ";
		for (auto order : it->second) {
			std::cout << "( traderId=" << order->m_traderId
				<< ", isBuy=" << order->m_isBuy
				<< ", quantity=" << order->m_quantity
				<< ", price=" << order->m_price << " )";
		}
		std::cout << std::endl;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x7730
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x7790
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x7760
testb $0x1, %al
jne 0x3c30
jmp 0x3d6b
leaq -0x18(%rbp), %rdi
callq 0x77c0
movl (%rax), %esi
movq 0x938e(%rip), %rdi      # 0xcfd0
callq 0x2270
movq %rax, %rdi
leaq 0x44c4(%rip), %rsi      # 0x8115
callq 0x2170
leaq -0x18(%rbp), %rdi
callq 0x77c0
addq $0x8, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x77e0
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x7810
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x7840
testb $0x1, %al
jne 0x3c97
jmp 0x3d44
leaq -0x30(%rbp), %rdi
callq 0x7870
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq 0x9322(%rip), %rdi      # 0xcfd0
leaq 0x4465(%rip), %rsi      # 0x811a
callq 0x2170
movq %rax, %rdi
movq -0x40(%rbp), %rsi
callq 0x2150
movq %rax, %rdi
leaq 0x4456(%rip), %rsi      # 0x8126
callq 0x2170
movq %rax, %rdi
movq -0x40(%rbp), %rax
movb 0x20(%rax), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x22a0
movq %rax, %rdi
leaq 0x443c(%rip), %rsi      # 0x812f
callq 0x2170
movq %rax, %rdi
movq -0x40(%rbp), %rax
movq 0x28(%rax), %rsi
callq 0x2070
movq %rax, %rdi
leaq 0x4429(%rip), %rsi      # 0x813b
callq 0x2170
movq %rax, %rdi
movq -0x40(%rbp), %rax
movq 0x30(%rax), %rsi
callq 0x2070
movq %rax, %rdi
leaq 0x4413(%rip), %rsi      # 0x8144
callq 0x2170
leaq -0x30(%rbp), %rdi
callq 0x78a0
jmp 0x3c81
movq 0x9285(%rip), %rdi      # 0xcfd0
movq 0x926e(%rip), %rsi      # 0xcfc0
callq 0x21a0
leaq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x78c0
movq %rax, -0x48(%rbp)
jmp 0x3c0d
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: sirak92[P]TradeMatchingEngine/src/Order.cpp
// Function: Order::operator==(Order const&)
bool Order::operator == (const Order &o)
{
	if (this->m_traderId == o.m_traderId &&
		this->m_isBuy == o.m_isBuy &&
		this->m_price == o.m_price)
		return true;
	else
		return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq -0x18(%rbp), %rsi
callq 0x7d10
testb $0x1, %al
jne 0x7ad7
jmp 0x7b0c
movq -0x20(%rbp), %rax
movb 0x20(%rax), %al
andb $0x1, %al
movzbl %al, %eax
movq -0x18(%rbp), %rcx
movb 0x20(%rcx), %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
jne 0x7b0c
movq -0x20(%rbp), %rax
movq 0x30(%rax), %rax
movq -0x18(%rbp), %rcx
cmpq 0x30(%rcx), %rax
jne 0x7b0c
movb $0x1, -0x1(%rbp)
jmp 0x7b10
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: sirak92[P]TradeMatchingEngine/src/Order.cpp
// Function: operator>>(std::istream&, Order&)
std::istream& operator >> (std::istream &in, Order &order)
{
	char side;
	in >> order.m_traderId >> side >> order.m_quantity >> order.m_price;
	if (toupper(side) == 'B')
		order.m_isBuy = true;

	return in;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x21e0
movq %rax, %rdi
leaq -0x11(%rbp), %rsi
callq 0x2200
movq %rax, %rdi
movq -0x10(%rbp), %rsi
addq $0x28, %rsi
callq 0x2220
movq %rax, %rdi
movq -0x10(%rbp), %rsi
addq $0x30, %rsi
callq 0x2220
movsbl -0x11(%rbp), %edi
callq 0x22b0
cmpl $0x42, %eax
jne 0x7cff
movq -0x10(%rbp), %rax
movb $0x1, 0x20(%rax)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: redpony[P]cpyp/crp_test.cc
// Function: llh(cpyp::crp<int, std::hash<int>> const&, double const*)
double llh(const cpyp::crp<int>& crp, const double* pp0) {
  double l = crp.log_likelihood();
  for (int i = 0; i < 3; ++i)
    l += crp.num_tables(i) * log(pp0[i]);
  return l;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x5d90
movsd %xmm0, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
cmpl $0x3, 0xc(%rsp)
jge 0x2495
movq 0x20(%rsp), %rdi
leaq 0xc(%rsp), %rsi
callq 0x5db0
movl %eax, %eax
cvtsi2sd %rax, %xmm0
movsd %xmm0, (%rsp)
movq 0x18(%rsp), %rax
movslq 0xc(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
callq 0x2130
movaps %xmm0, %xmm2
movsd (%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rsp)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x2436
movsd 0x10(%rsp), %xmm0
addq $0x28, %rsp
retq
// File: redpony[P]cpyp/./cpyp/crp.h
// Function: int cpyp::crp<int, std::hash<int>>::increment<double, cpyp::MT19937>(int const&, double const&, cpyp::MT19937&)
int increment(const Dish& dish, const F& p0, Engine& eng) {
    crp_table_manager<1>& loc = dish_locs_[dish];
    bool share_table = false;
    if (loc.num_customers()) {
      const F p_empty = F(strength_ + num_tables_ * discount_) * p0;
      const F p_share = F(loc.num_customers() - loc.num_tables() * discount_);
      share_table = sample_bernoulli(p_empty, p_share, eng);
    }

    if (share_table) {
      unsigned n = loc.share_table(discount_, eng);
      update_llh_add_customer_to_table_seating(n);
    } else {
      loc.create_table();
      update_llh_add_customer_to_table_seating(0);
      ++num_tables_;
    }
    ++num_customers_;
    return (share_table ? 0 : 1);
  }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x8, %rdi
movq 0x48(%rsp), %rsi
callq 0xc9c0
movq %rax, 0x30(%rsp)
movb $0x0, 0x2f(%rsp)
movq 0x30(%rsp), %rdi
callq 0xc9f0
cmpl $0x0, %eax
je 0x648d
movq 0x8(%rsp), %rax
movsd 0x48(%rax), %xmm1
movl (%rax), %ecx
cvtsi2sd %rcx, %xmm0
movsd 0x40(%rax), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq 0x40(%rsp), %rax
movsd (%rax), %xmm1
mulsd %xmm1, %xmm0
movsd %xmm0, 0x20(%rsp)
movq 0x30(%rsp), %rdi
callq 0xc9f0
movl %eax, %eax
cvtsi2sd %rax, %xmm0
movsd %xmm0, (%rsp)
movq 0x30(%rsp), %rdi
callq 0xb2e0
movsd (%rsp), %xmm1
movl %eax, %ecx
movq 0x8(%rsp), %rax
movl %ecx, %ecx
cvtsi2sd %rcx, %xmm0
movsd 0x40(%rax), %xmm2
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x20(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
movq 0x38(%rsp), %rdi
callq 0x6ae0
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, 0x2f(%rsp)
testb $0x1, 0x2f(%rsp)
je 0x64c1
movq 0x8(%rsp), %rax
movq 0x30(%rsp), %rdi
movsd 0x40(%rax), %xmm0
movq 0x38(%rsp), %rsi
callq 0xfce0
movq 0x8(%rsp), %rdi
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %esi
callq 0xfdf0
jmp 0x64e5
movq 0x30(%rsp), %rdi
xorl %esi, %esi
callq 0xfee0
movq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0xfdf0
movq 0x8(%rsp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq 0x8(%rsp), %rax
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4(%rax)
movb 0x2f(%rsp), %dl
movl $0x1, %eax
xorl %ecx, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
addq $0x58, %rsp
retq
nopl (%rax)
// File: redpony[P]cpyp/./cpyp/msparse_vector.h
// Function: cpyp::SparseVector<unsigned int, 15u>::operator=(cpyp::SparseVector<unsigned int, 15u> const&)
const SparseVector<T>& operator=(const SparseVector<T>& other) {
    if (&other == this) return *this;
    clear();
    std::memcpy(this, &other, sizeof(SparseVector));
    if (is_remote_) {
      data_.rbmap = new std::unordered_map<unsigned, T>(*data_.rbmap);
    }
    return *this;
  }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq %rax, 0x20(%rsp)
jne 0x760b
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x7688
movq 0x8(%rsp), %rdi
callq 0x86f0
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl $0x80, %edx
callq 0x2140
movq 0x8(%rsp), %rax
testb $0x1, 0x79(%rax)
je 0x767e
movl $0x38, %edi
callq 0x2190
movq %rax, %rdi
movq 0x8(%rsp), %rax
movq %rdi, %rcx
movq %rcx, (%rsp)
movq (%rax), %rsi
callq 0x76b0
jmp 0x7657
movq 0x8(%rsp), %rax
movq (%rsp), %rcx
movq %rcx, (%rax)
jmp 0x767e
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
callq 0x2170
jmp 0x7692
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0x2260
nopl (%rax)
// File: redpony[P]cpyp/./cpyp/random.h
// Function: cpyp::MT19937::GetTrulyRandomSeed()
static uint32_t GetTrulyRandomSeed() {
    uint32_t seed;
    std::ifstream r("/dev/urandom");
    if (r) {
      r.read((char*)&seed,sizeof(uint32_t));
    }
    if (r.fail() || !r) {
      std::cerr << "Warning: could not read from /dev/urandom. Seeding from clock" << std::endl;
      seed = std::time(NULL);
    }
    std::cerr << "Seeding random number sequence to " << seed << std::endl;
    return seed;
  }

// Assembly:
subq $0x248, %rsp            # imm = 0x248
leaq 0xcc9e(%rip), %rsi      # 0x1553c
leaq 0x38(%rsp), %rdi
movl $0x8, %edx
callq 0x2280
movq 0x38(%rsp), %rax
movq -0x18(%rax), %rax
leaq 0x38(%rsp,%rax), %rdi
callq 0x21d0
movb %al, 0x2b(%rsp)
jmp 0x88c6
movb 0x2b(%rsp), %al
testb $0x1, %al
jne 0x88d0
jmp 0x8908
leaq 0x38(%rsp), %rdi
leaq 0x244(%rsp), %rsi
movl $0x4, %edx
callq 0x21e0
jmp 0x88e9
jmp 0x8908
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x2050
jmp 0x89f1
movq 0x38(%rsp), %rax
movq -0x18(%rax), %rax
leaq 0x38(%rsp,%rax), %rdi
callq 0x2030
movb %al, 0x2a(%rsp)
jmp 0x8921
movb 0x2a(%rsp), %al
testb $0x1, %al
jne 0x894e
jmp 0x892b
movq 0x38(%rsp), %rax
movq -0x18(%rax), %rax
leaq 0x38(%rsp,%rax), %rdi
callq 0x2090
movb %al, 0x29(%rsp)
jmp 0x8944
movb 0x29(%rsp), %al
testb $0x1, %al
jne 0x894e
jmp 0x898b
movq 0x1569b(%rip), %rdi     # 0x1dff0
leaq 0xcbed(%rip), %rsi      # 0x15549
callq 0x2180
movq %rax, 0x20(%rsp)
jmp 0x8968
movq 0x20(%rsp), %rdi
movq 0x15654(%rip), %rsi     # 0x1dfc8
callq 0x21a0
jmp 0x897b
xorl %eax, %eax
movl %eax, %edi
callq 0x2160
movl %eax, 0x244(%rsp)
movq 0x1565e(%rip), %rdi     # 0x1dff0
leaq 0xcbee(%rip), %rsi      # 0x15587
callq 0x2180
movq %rax, 0x18(%rsp)
jmp 0x89a5
movq 0x18(%rsp), %rdi
movl 0x244(%rsp), %esi
callq 0x2200
movq %rax, 0x10(%rsp)
jmp 0x89bd
movq 0x10(%rsp), %rdi
movq 0x155ff(%rip), %rsi     # 0x1dfc8
callq 0x21a0
jmp 0x89d0
movl 0x244(%rsp), %eax
movl %eax, 0xc(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x2050
movl 0xc(%rsp), %eax
addq $0x248, %rsp            # imm = 0x248
retq
movq 0x30(%rsp), %rdi
callq 0x2260
nopl (%rax,%rax)
// File: redpony[P]cpyp/./cpyp/m.h
// Function: cpyp::M<double>::log_beta_density(double const&, double const&, double const&)
static inline F log_beta_density(const F& x, const F& alpha, const F& beta) {
    assert(x > 0.0);  // should be >= but need to work out the density
    assert(x < 1.0);  // should be <= but need to work out the density
    assert(alpha > 0.0);
    assert(beta > 0.0);
    return (alpha - 1) * std::log(x) +
        (beta - 1) * std::log(1 - x) -
        log_beta_fn(alpha, beta);
  }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rax
movsd (%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0xa7c7
jmp 0xa7e6
leaq 0xae9b(%rip), %rdi      # 0x15669
leaq 0xae9c(%rip), %rsi      # 0x15671
movl $0x3b, %edx
leaq 0xae9b(%rip), %rcx      # 0x1567c
callq 0x20e0
movq 0x30(%rsp), %rax
movsd 0xa81d(%rip), %xmm0     # 0x15010
ucomisd (%rax), %xmm0
jbe 0xa7fb
jmp 0xa81a
leaq 0xaed3(%rip), %rdi      # 0x156d5
leaq 0xae68(%rip), %rsi      # 0x15671
movl $0x3c, %edx
leaq 0xae67(%rip), %rcx      # 0x1567c
callq 0x20e0
movq 0x28(%rsp), %rax
movsd (%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0xa82e
jmp 0xa84d
leaq 0xaea8(%rip), %rdi      # 0x156dd
leaq 0xae35(%rip), %rsi      # 0x15671
movl $0x3d, %edx
leaq 0xae34(%rip), %rcx      # 0x1567c
callq 0x20e0
movq 0x20(%rsp), %rax
movsd (%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0xa861
jmp 0xa880
leaq 0xae81(%rip), %rdi      # 0x156e9
leaq 0xae02(%rip), %rsi      # 0x15671
movl $0x3e, %edx
leaq 0xae01(%rip), %rcx      # 0x1567c
callq 0x20e0
movq 0x28(%rsp), %rax
movsd (%rax), %xmm0
movsd 0xa77f(%rip), %xmm1     # 0x15010
subsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rsp)
movq 0x30(%rsp), %rax
movsd (%rax), %xmm0
callq 0x2130
movsd %xmm0, 0x8(%rsp)
movq 0x20(%rsp), %rax
movsd (%rax), %xmm0
movsd 0xa750(%rip), %xmm1     # 0x15010
subsd %xmm1, %xmm0
movsd %xmm0, (%rsp)
movq 0x30(%rsp), %rax
movsd 0xa73a(%rip), %xmm0     # 0x15010
subsd (%rax), %xmm0
callq 0x2130
movsd (%rsp), %xmm1
movsd 0x8(%rsp), %xmm2
movaps %xmm0, %xmm3
movsd 0x10(%rsp), %xmm0
mulsd %xmm3, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x18(%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0xad20
movaps %xmm0, %xmm1
movsd 0x18(%rsp), %xmm0
subsd %xmm1, %xmm0
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: redpony[P]cpyp/./cpyp/m.h
// Function: cpyp::M<double>::log_gamma_density(double const&, double const&, double const&)
static F log_gamma_density(const F& x, const F& shape, const F& rate) {
    assert(x >= 0.0);
    assert(shape > 0.0);
    assert(rate > 0.0);
    return (shape-1)*std::log(x) - shape*std::log(rate) -
        x/rate - lgamma(shape);
  }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rax
movsd (%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0xa977
jmp 0xa996
leaq 0xad76(%rip), %rdi      # 0x156f4
leaq 0xacec(%rip), %rsi      # 0x15671
movl $0x31, %edx
leaq 0xad6c(%rip), %rcx      # 0x156fd
callq 0x20e0
movq 0x28(%rsp), %rax
movsd (%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0xa9aa
jmp 0xa9c9
leaq 0xada6(%rip), %rdi      # 0x15757
leaq 0xacb9(%rip), %rsi      # 0x15671
movl $0x32, %edx
leaq 0xad39(%rip), %rcx      # 0x156fd
callq 0x20e0
movq 0x20(%rsp), %rax
movsd (%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0xa9dd
jmp 0xa9fc
leaq 0xad7f(%rip), %rdi      # 0x15763
leaq 0xac86(%rip), %rsi      # 0x15671
movl $0x33, %edx
leaq 0xad06(%rip), %rcx      # 0x156fd
callq 0x20e0
movq 0x28(%rsp), %rax
movsd (%rax), %xmm0
movsd 0xa603(%rip), %xmm1     # 0x15010
subsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rsp)
movq 0x30(%rsp), %rax
movsd (%rax), %xmm0
callq 0x2130
movsd %xmm0, 0x8(%rsp)
movq 0x28(%rsp), %rax
movsd (%rax), %xmm0
movsd %xmm0, (%rsp)
movq 0x20(%rsp), %rax
movsd (%rax), %xmm0
callq 0x2130
movsd (%rsp), %xmm1
movsd 0x8(%rsp), %xmm2
movaps %xmm0, %xmm3
movsd 0x10(%rsp), %xmm0
mulsd %xmm3, %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq 0x30(%rsp), %rax
movsd (%rax), %xmm1
movq 0x20(%rsp), %rax
divsd (%rax), %xmm1
subsd %xmm1, %xmm0
movsd %xmm0, 0x18(%rsp)
movq 0x28(%rsp), %rax
movsd (%rax), %xmm0
callq 0x2110
movaps %xmm0, %xmm1
movsd 0x18(%rsp), %xmm0
subsd %xmm1, %xmm0
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: redpony[P]cpyp/./cpyp/msparse_vector.h
// Function: cpyp::SparseVector<unsigned int, 15u>::const_iterator::operator*() const
const std::pair<const unsigned, T>& operator*() const {
      if (local_)
        return *reinterpret_cast<const std::pair<const unsigned, T>*>(local_it_);
      else
        return *remote_it_;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
testb $0x1, (%rax)
je 0xac56
movq (%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0xac68
movq (%rsp), %rdi
addq $0x10, %rdi
callq 0xb1c0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: redpony[P]cpyp/./cpyp/msparse_vector.h
// Function: cpyp::SparseVector<unsigned int, 15u>::const_iterator::const_iterator(cpyp::SparseVector<unsigned int, 15u> const&, bool)
const_iterator(const SparseVector<T>& v, const bool is_end) : local_(!v.is_remote_) {
      if (local_) {
        local_it_ = &v.data_.local[is_end ? v.local_size_ : 0];
      } else {
        if (is_end)
          remote_it_ = v.data_.rbmap->end();
        else
          remote_it_ = v.data_.rbmap->begin();
      }
    }

// Assembly:
subq $0x58, %rsp
movb %dl, %al
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
andb $0x1, %al
movb %al, 0x47(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movq 0x48(%rsp), %rax
movb 0x79(%rax), %al
xorb $-0x1, %al
andb $0x1, %al
movb %al, (%rdi)
addq $0x10, %rdi
callq 0xaf70
movq 0x18(%rsp), %rax
testb $0x1, (%rax)
je 0xaef7
movq 0x48(%rsp), %rax
movq %rax, 0x10(%rsp)
testb $0x1, 0x47(%rsp)
je 0xaed1
movq 0x48(%rsp), %rax
movzbl 0x78(%rax), %eax
movl %eax, 0xc(%rsp)
jmp 0xaed9
xorl %eax, %eax
movl %eax, 0xc(%rsp)
jmp 0xaed9
movq 0x18(%rsp), %rax
movq 0x10(%rsp), %rcx
movl 0xc(%rsp), %edx
movslq %edx, %rdx
shlq $0x3, %rdx
addq %rdx, %rcx
movq %rcx, 0x8(%rax)
jmp 0xaf60
testb $0x1, 0x47(%rsp)
je 0xaf2f
movq 0x48(%rsp), %rax
movq (%rax), %rdi
callq 0xaf80
movq %rax, 0x30(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0xafb0
movq 0x18(%rsp), %rax
movq 0x38(%rsp), %rcx
movq %rcx, 0x10(%rax)
jmp 0xaf5e
movq 0x48(%rsp), %rax
movq (%rax), %rdi
callq 0xafe0
movq %rax, 0x20(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0xafb0
movq 0x18(%rsp), %rax
movq 0x28(%rsp), %rcx
movq %rcx, 0x10(%rax)
jmp 0xaf60
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: redpony[P]cpyp/./cpyp/msparse_vector.h
// Function: cpyp::SparseVector<unsigned int, 15u>::const_iterator::operator==(cpyp::SparseVector<unsigned int, 15u>::const_iterator const&) const
inline bool operator==(const const_iterator& o) const {
      if (o.local_ != local_) return false;
      if (local_) {
        return local_it_ == o.local_it_;
      } else {
        return remote_it_ == o.remote_it_;
      }
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rsp), %rax
movb (%rax), %al
andb $0x1, %al
movzbl %al, %eax
movb (%rcx), %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
je 0xb147
movb $0x0, 0x27(%rsp)
jmp 0xb18b
movq 0x8(%rsp), %rax
testb $0x1, (%rax)
je 0xb16e
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rsp), %rcx
cmpq 0x8(%rcx), %rax
sete %al
andb $0x1, %al
movb %al, 0x27(%rsp)
jmp 0xb18b
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
movq 0x10(%rsp), %rsi
addq $0x10, %rsi
callq 0xb1a0
andb $0x1, %al
movb %al, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: redpony[P]cpyp/./cpyp/crp.h
// Function: cpyp::crp<int, std::hash<int>>::update_llh_remove_customer_from_table_seating(unsigned int)
void update_llh_remove_customer_from_table_seating(unsigned n) {
    unsigned t = 0;
    if (n == 1) {
      t = 1;
    }
    llh_ += log(strength_ + num_customers_ - 1);
    if (t == 1) {
      llh_ -= log(discount_) + log(strength_ / discount_ + num_tables_ - 1);
    }
    if (n > 1) {
      llh_ -= log(n - discount_ - 1);
    }
  }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x0, 0x18(%rsp)
cmpl $0x1, 0x1c(%rsp)
jne 0xca2e
movl $0x1, 0x18(%rsp)
movq 0x10(%rsp), %rax
movsd 0x48(%rax), %xmm0
movl 0x4(%rax), %eax
cvtsi2sd %rax, %xmm1
addsd %xmm1, %xmm0
movsd 0x85c4(%rip), %xmm1     # 0x15010
subsd %xmm1, %xmm0
callq 0x2130
movq 0x10(%rsp), %rax
addsd 0x70(%rax), %xmm0
movsd %xmm0, 0x70(%rax)
cmpl $0x1, 0x18(%rsp)
jne 0xcacc
movq 0x10(%rsp), %rax
movsd 0x40(%rax), %xmm0
callq 0x2130
movq 0x10(%rsp), %rax
movsd %xmm0, 0x8(%rsp)
movsd 0x48(%rax), %xmm0
movsd 0x40(%rax), %xmm1
divsd %xmm1, %xmm0
movl (%rax), %eax
cvtsi2sd %rax, %xmm1
addsd %xmm1, %xmm0
movsd 0x856a(%rip), %xmm1     # 0x15010
subsd %xmm1, %xmm0
callq 0x2130
movsd 0x8(%rsp), %xmm1
movq 0x10(%rsp), %rax
addsd %xmm0, %xmm1
movsd 0x70(%rax), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, 0x70(%rax)
cmpl $0x1, 0x1c(%rsp)
jbe 0xcb0d
movq 0x10(%rsp), %rax
movl 0x1c(%rsp), %ecx
cvtsi2sd %rcx, %xmm0
subsd 0x40(%rax), %xmm0
movsd 0x8522(%rip), %xmm1     # 0x15010
subsd %xmm1, %xmm0
callq 0x2130
movq 0x10(%rsp), %rax
movaps %xmm0, %xmm1
movsd 0x70(%rax), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, 0x70(%rax)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)