LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: Laakeri[P]Triangulator/src/PMC.cpp
// Function: PMC::mergeCost(PMC::valueT, PMC::valueT, int)
valueT mergeCost(valueT cost1, valueT cost2, int PROBLEM) {
	if (PROBLEM == PROBLEM_TREEWIDTH) return max(cost1, cost2);
	else if (PROBLEM == PROBLEM_MINFILL) return cost1+cost2;
	else if (PROBLEM == PROBLEM_BAYES) return cost1+cost2;
	else if (PROBLEM == PROBLEM_HYPER) return max(cost1, cost2);
	else if (PROBLEM == PROBLEM_DECIDE) return (int64_t)0;
	else if (PROBLEM == PROBLEM_FRACHYPER) return max(cost1, cost2);
	else assert(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, -0x20(%rbp)
leaq 0x40(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movl %esi, -0x4(%rbp)
cmpl $0x2, -0x4(%rbp)
jne 0x3b42c
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
callq 0x433d0
movq -0x28(%rbp), %rdi
movq %rax, %rsi
movl $0x30, %edx
callq 0x3250
jmp 0x3b4e4
cmpl $0x1, -0x4(%rbp)
jne 0x3b448
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdi
callq 0x3a510
jmp 0x3b4e4
cmpl $0x3, -0x4(%rbp)
jne 0x3b464
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdi
callq 0x3a510
jmp 0x3b4e4
cmpl $0x4, -0x4(%rbp)
jne 0x3b48a
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
callq 0x433d0
movq -0x28(%rbp), %rdi
movq %rax, %rsi
movl $0x30, %edx
callq 0x3250
jmp 0x3b4e4
cmpl $0x5, -0x4(%rbp)
jne 0x3b49f
movq -0x28(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3a0f0
jmp 0x3b4e4
cmpl $0x6, -0x4(%rbp)
jne 0x3b4c5
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdi
callq 0x433d0
movq -0x28(%rbp), %rdi
movq %rax, %rsi
movl $0x30, %edx
callq 0x3250
jmp 0x3b4e4
leaq 0x1dca4(%rip), %rdi     # 0x59170
leaq 0x1f1a3(%rip), %rsi     # 0x5a676
movl $0xfc, %edx
leaq 0x1f4df(%rip), %rcx     # 0x5a9be
callq 0x31a0
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: Laakeri[P]Triangulator/src/PMC.cpp
// Function: PMC::dfs4(Graph const&, int, std::vector<int, std::allocator<int>>&)
void dfs4(const Graph& G, int x, vector<int>& nb) {
	assert(u[x] == 0);
	u[x] = 1;
	for (int nx : G.g[x]) {
		if (u[nx] == 0) dfs4(G, nx, nb);
		else if (u[nx] == 2) {
			nb.push_back(nx);
			u[nx] = 3;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movslq -0xc(%rbp), %rcx
leaq 0x5f66a2(%rip), %rax    # 0x6330f0
cmpl $0x0, (%rax,%rcx,4)
jne 0x3ca56
jmp 0x3ca75
leaq 0x1d391(%rip), %rdi     # 0x59dee
leaq 0x1dc12(%rip), %rsi     # 0x5a676
movl $0x18b, %edx            # imm = 0x18B
leaq 0x1e142(%rip), %rcx     # 0x5abb2
callq 0x31a0
movslq -0xc(%rbp), %rcx
leaq 0x5f6670(%rip), %rax    # 0x6330f0
movl $0x1, (%rax,%rcx,4)
movq -0x8(%rbp), %rdi
addq $0x38, %rdi
movslq -0xc(%rbp), %rsi
callq 0xbba0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x6680
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x66b0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xbbc0
testb $0x1, %al
jne 0x3cac9
jmp 0x3cb3c
leaq -0x28(%rbp), %rdi
callq 0xbc00
movl (%rax), %eax
movl %eax, -0x34(%rbp)
movslq -0x34(%rbp), %rcx
leaq 0x5f660e(%rip), %rax    # 0x6330f0
cmpl $0x0, (%rax,%rcx,4)
jne 0x3cafa
movq -0x8(%rbp), %rdi
movl -0x34(%rbp), %esi
movq -0x18(%rbp), %rdx
callq 0x3ca30
jmp 0x3cb2c
movslq -0x34(%rbp), %rcx
leaq 0x5f65eb(%rip), %rax    # 0x6330f0
cmpl $0x2, (%rax,%rcx,4)
jne 0x3cb2a
movq -0x18(%rbp), %rdi
leaq -0x34(%rbp), %rsi
callq 0xdff0
movslq -0x34(%rbp), %rcx
leaq 0x5f65cd(%rip), %rax    # 0x6330f0
movl $0x3, (%rax,%rcx,4)
jmp 0x3cb2c
jmp 0x3cb2e
leaq -0x28(%rbp), %rdi
callq 0xbc80
jmp 0x3cab6
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Laakeri[P]Triangulator/src/PMC.cpp
// Function: PMC::dfs(int, Graph const&, std::vector<int, std::allocator<int>>&, std::vector<int, std::allocator<int>>&)
void dfs(int x, const Graph& G, vector<int>& used, vector<int>& o) {
	if (used[x]) return;
	used[x]=1;
	o.push_back(x);
	for (int nx : G.g[x]) {
		dfs(nx, G, used, o);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movslq -0x4(%rbp), %rsi
callq 0x178f0
cmpl $0x0, (%rax)
je 0x3d73e
jmp 0x3d7cd
movq -0x18(%rbp), %rdi
movslq -0x4(%rbp), %rsi
callq 0x178f0
movl $0x1, (%rax)
movq -0x20(%rbp), %rdi
leaq -0x4(%rbp), %rsi
callq 0xdff0
movq -0x10(%rbp), %rdi
addq $0x38, %rdi
movslq -0x4(%rbp), %rsi
callq 0xbba0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x6680
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x66b0
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xbbc0
testb $0x1, %al
jne 0x3d7a0
jmp 0x3d7cd
leaq -0x30(%rbp), %rdi
callq 0xbc00
movl (%rax), %eax
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x3d710
leaq -0x30(%rbp), %rdi
callq 0xbc80
jmp 0x3d78d
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Laakeri[P]Triangulator/src/PMC.cpp
// Function: PMC::dfsord(Graph const&)
vector<int> dfsord(const Graph& G) {
	vector<int> used(G.n);
	vector<int> o;
	dfs(0, G, used, o);
	return o;
}

// 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 -0x10(%rbp), %rax
movslq 0x50(%rax), %rax
movq %rax, -0x50(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x111b0
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
leaq -0x28(%rbp), %rdi
callq 0x17ab0
jmp 0x3d827
leaq -0x29(%rbp), %rdi
callq 0x6620
movq -0x60(%rbp), %rdi
movb $0x0, -0x3d(%rbp)
callq 0xdf40
movq -0x60(%rbp), %rcx
movq -0x10(%rbp), %rsi
xorl %edi, %edi
leaq -0x28(%rbp), %rdx
callq 0x3d710
jmp 0x3d852
movb $0x1, -0x3d(%rbp)
testb $0x1, -0x3d(%rbp)
jne 0x3d89e
jmp 0x3d895
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x29(%rbp), %rdi
callq 0x6620
jmp 0x3d8b1
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x6d30
leaq -0x28(%rbp), %rdi
callq 0x6d30
jmp 0x3d8b1
movq -0x60(%rbp), %rdi
callq 0x6d30
leaq -0x28(%rbp), %rdi
callq 0x6d30
movq -0x58(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x3480
nopw (%rax,%rax)
// File: Laakeri[P]Triangulator/src/PMC.cpp
// Function: PMC::dfs5(Graph const&, int, std::vector<int, std::allocator<int>>&)
int dfs5(const Graph& G, int x, vector<int>& co) {
	assert(u2[x] == 0);
	assert(u[x] != 3);
	u2[x] = 1;
	co.push_back(x);
	int r = 0;
	if (u[x] == 2) r++;
	for (int nx : G.g[x]) {
		if (!u2[nx] && u[nx] != 3) {
			r += dfs5(G, nx, co);
		}
	}
	return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movslq -0xc(%rbp), %rcx
leaq 0x625992(%rip), %rax    # 0x663e30
cmpl $0x0, (%rax,%rcx,4)
jne 0x3e4a6
jmp 0x3e4c5
leaq 0x1c832(%rip), %rdi     # 0x5acdf
leaq 0x1c1c2(%rip), %rsi     # 0x5a676
movl $0x220, %edx            # imm = 0x220
leaq 0x1c82a(%rip), %rcx     # 0x5acea
callq 0x31a0
movslq -0xc(%rbp), %rcx
leaq 0x5f4c20(%rip), %rax    # 0x6330f0
cmpl $0x3, (%rax,%rcx,4)
je 0x3e4d8
jmp 0x3e4f7
leaq 0x1c83c(%rip), %rdi     # 0x5ad1b
leaq 0x1c190(%rip), %rsi     # 0x5a676
movl $0x221, %edx            # imm = 0x221
leaq 0x1c7f8(%rip), %rcx     # 0x5acea
callq 0x31a0
movslq -0xc(%rbp), %rcx
leaq 0x62592e(%rip), %rax    # 0x663e30
movl $0x1, (%rax,%rcx,4)
movq -0x18(%rbp), %rdi
leaq -0xc(%rbp), %rsi
callq 0xdff0
movl $0x0, -0x1c(%rbp)
movslq -0xc(%rbp), %rcx
leaq 0x5f4bc8(%rip), %rax    # 0x6330f0
cmpl $0x2, (%rax,%rcx,4)
jne 0x3e537
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
addq $0x38, %rdi
movslq -0xc(%rbp), %rsi
callq 0xbba0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x6680
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x66b0
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xbbc0
testb $0x1, %al
jne 0x3e579
jmp 0x3e5cc
leaq -0x30(%rbp), %rdi
callq 0xbc00
movl (%rax), %eax
movl %eax, -0x3c(%rbp)
movslq -0x3c(%rbp), %rcx
leaq 0x62589e(%rip), %rax    # 0x663e30
cmpl $0x0, (%rax,%rcx,4)
jne 0x3e5bf
movslq -0x3c(%rbp), %rcx
leaq 0x5f4b4d(%rip), %rax    # 0x6330f0
cmpl $0x3, (%rax,%rcx,4)
je 0x3e5bf
movq -0x8(%rbp), %rdi
movl -0x3c(%rbp), %esi
movq -0x18(%rbp), %rdx
callq 0x3e480
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0x3e5c1
leaq -0x30(%rbp), %rdi
callq 0xbc80
jmp 0x3e566
movl -0x1c(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Laakeri[P]Triangulator/src/PMC.cpp
// Function: PMC::dfs6(Graph const&, int, std::vector<int, std::allocator<int>>&, std::vector<int, std::allocator<int>>&)
void dfs6(const Graph& G, int x, vector<int>& co, vector<int>& nb) {
	assert(u[x] == 0);
	u[x] = 1;
	co.push_back(x);
	for (int nx : G.g[x]) {
		if (u[nx] == 0) dfs6(G, nx, co, nb);
		if (u[nx] >= 2 && u[nx] < it) {
			nb.push_back(nx);
			u[nx] = it;
		}
	}
}

// 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)
movslq -0xc(%rbp), %rcx
leaq 0x5f4aee(%rip), %rax    # 0x6330f0
cmpl $0x0, (%rax,%rcx,4)
jne 0x3e60a
jmp 0x3e629
leaq 0x1b7dd(%rip), %rdi     # 0x59dee
leaq 0x1c05e(%rip), %rsi     # 0x5a676
movl $0x22f, %edx            # imm = 0x22F
leaq 0x1c701(%rip), %rcx     # 0x5ad25
callq 0x31a0
movslq -0xc(%rbp), %rcx
leaq 0x5f4abc(%rip), %rax    # 0x6330f0
movl $0x1, (%rax,%rcx,4)
movq -0x18(%rbp), %rdi
leaq -0xc(%rbp), %rsi
callq 0xdff0
movq -0x8(%rbp), %rdi
addq $0x38, %rdi
movslq -0xc(%rbp), %rsi
callq 0xbba0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x6680
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x66b0
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xbbc0
testb $0x1, %al
jne 0x3e68d
jmp 0x3e718
leaq -0x30(%rbp), %rdi
callq 0xbc00
movl (%rax), %eax
movl %eax, -0x3c(%rbp)
movslq -0x3c(%rbp), %rcx
leaq 0x5f4a4a(%rip), %rax    # 0x6330f0
cmpl $0x0, (%rax,%rcx,4)
jne 0x3e6c0
movq -0x8(%rbp), %rdi
movl -0x3c(%rbp), %esi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x3e5e0
movslq -0x3c(%rbp), %rcx
leaq 0x5f4a25(%rip), %rax    # 0x6330f0
cmpl $0x2, (%rax,%rcx,4)
jl 0x3e708
movslq -0x3c(%rbp), %rcx
leaq 0x5f4a14(%rip), %rax    # 0x6330f0
movl (%rax,%rcx,4), %eax
cmpl 0x65648b(%rip), %eax    # 0x694b70
jge 0x3e708
movq -0x20(%rbp), %rdi
leaq -0x3c(%rbp), %rsi
callq 0xdff0
movl 0x656476(%rip), %edx    # 0x694b70
movslq -0x3c(%rbp), %rcx
leaq 0x5f49eb(%rip), %rax    # 0x6330f0
movl %edx, (%rax,%rcx,4)
jmp 0x3e70a
leaq -0x30(%rbp), %rdi
callq 0xbc80
jmp 0x3e677
addq $0x40, %rsp
popq %rbp
retq
nop
// File: Laakeri[P]Triangulator/src/setcover.cpp
// Function: SetCover::init(std::vector<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>>)
void init(vector<vector<int> > ss) {
	assert(!hasInit);
	hasInit = true;
	gm = ss.size();
	for (int i = 0; i < gm; i++) {
		Gsets[i] = ss[i];
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movq %rdi, -0x8(%rbp)
movb 0xba0b4e(%rip), %al     # 0xbebf14
xorb $-0x1, %al
testb $0x1, %al
jne 0x4b3ce
jmp 0x4b3d0
jmp 0x4b3ef
leaq 0xfd61(%rip), %rdi      # 0x5b138
leaq 0xfd63(%rip), %rsi      # 0x5b141
movl $0x32, %edx
leaq 0xfd64(%rip), %rcx      # 0x5b14e
callq 0x31a0
movq -0x18(%rbp), %rdi
movb $0x1, 0xba0b1a(%rip)    # 0xbebf14
callq 0x5e80
movl %eax, 0x6497fb(%rip)    # 0x694c00
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl 0x6497eb(%rip), %eax    # 0x694c00
jge 0x4b449
movq -0x18(%rbp), %rdi
movslq -0xc(%rbp), %rsi
callq 0x178a0
movq %rax, %rsi
movslq -0xc(%rbp), %rax
leaq 0x8f515e(%rip), %rdi    # 0x940590
imulq $0x18, %rax, %rax
addq %rax, %rdi
callq 0x42f30
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x4b40c
addq $0x20, %rsp
popq %rbp
retq
nop
// File: Jumperr-labs[P]at25sf081/AT25SF081.cpp
// Function: AT25SF081::ReadArray(bool)
void AT25SF081::ReadArray(bool with_dummy_byte) {
    int address = ReadAddress();
    if (address < 0) return;

    if (with_dummy_byte) {
        if (ReadDummyBytes(1) != 1 || !spi_slave_->IsSsActive()) return;
    }

    bool done = false;
    while (!done) {
        size_t length = spi_slave_->Transmit(nullptr, &memory_[address], MEMORY_SIZE - address);
        if (length == 0) {
            return;
        }
        address = (address + 1) % (int) MEMORY_SIZE;
        done = !spi_slave_->IsSsActive();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0xdd90
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
jge 0xee3f
jmp 0xeed8
testb $0x1, -0x9(%rbp)
je 0xee6f
movq -0x28(%rbp), %rdi
movl $0x1, %esi
callq 0xd710
cmpq $0x1, %rax
jne 0xee6b
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
testb $0x1, %al
jne 0xee6d
jmp 0xeed8
jmp 0xee6f
movb $0x0, -0x11(%rbp)
movb -0x11(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xee7e
jmp 0xeed8
movq -0x28(%rbp), %rdx
movq 0x8(%rdx), %rdi
addq $0x10, %rdx
movslq -0x10(%rbp), %rax
addq %rax, %rdx
movl $0x100000, %eax         # imm = 0x100000
subl -0x10(%rbp), %eax
movslq %eax, %rcx
movq (%rdi), %rax
xorl %esi, %esi
callq *(%rax)
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xeeb0
jmp 0xeed8
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl $0x100000, %ecx         # imm = 0x100000
cltd
idivl %ecx
movq -0x28(%rbp), %rax
movl %edx, -0x10(%rbp)
movq 0x8(%rax), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
xorb $-0x1, %al
andb $0x1, %al
movb %al, -0x11(%rbp)
jmp 0xee73
addq $0x30, %rsp
popq %rbp
retq
nop
// File: Jumperr-labs[P]at25sf081/AT25SF081.cpp
// Function: AT25SF081::ByteOrPageProgram()
void AT25SF081::ByteOrPageProgram() {
    if (!WelStatus()) {
        throw std::logic_error("AT25SF081: Trying to program the device while WEL bit in status register is 0");
    }
    int address = ReadAddress();
    if (address < 0) return;

    bool done = false;
    while (!done) {
        uint8_t byte = 0;
        size_t length = spi_slave_->Transmit(&byte, nullptr, 1);
        if (length == 0) {
            return;
        }
        memory_[address] = byte;
        address = (address & ~0xff) | ((address + 1) & 0xff);
        done = !spi_slave_->IsSsActive();
    }

    SetWel(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0xe100
testb $0x1, %al
jne 0xef50
movl $0x10, %edi
callq 0xd430
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
leaq 0x5147(%rip), %rsi      # 0x1405f
callq 0xde90
jmp 0xef1f
movq -0x38(%rbp), %rdi
movq 0xa09e(%rip), %rsi      # 0x18fc8
movq 0xa07f(%rip), %rdx      # 0x18fb0
callq 0xe150
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0xd630
jmp 0xefee
movq -0x30(%rbp), %rdi
callq 0xdd90
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jge 0xef67
jmp 0xefe8
movb $0x0, -0x19(%rbp)
movb -0x19(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xef76
jmp 0xefdd
movq -0x30(%rbp), %rax
movb $0x0, -0x1a(%rbp)
movq 0x8(%rax), %rdi
movq (%rdi), %rax
leaq -0x1a(%rbp), %rsi
xorl %ecx, %ecx
movl %ecx, %edx
movl $0x1, %ecx
callq *(%rax)
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0xefa1
jmp 0xefe8
movq -0x30(%rbp), %rax
movb -0x1a(%rbp), %dl
movslq -0x18(%rbp), %rcx
movb %dl, 0x10(%rax,%rcx)
movl -0x18(%rbp), %ecx
andl $0xffffff00, %ecx       # imm = 0xFFFFFF00
movl -0x18(%rbp), %edx
addl $0x1, %edx
andl $0xff, %edx
orl %edx, %ecx
movl %ecx, -0x18(%rbp)
movq 0x8(%rax), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
xorb $-0x1, %al
andb $0x1, %al
movb %al, -0x19(%rbp)
jmp 0xef6b
movq -0x30(%rbp), %rdi
xorl %esi, %esi
callq 0xd1a0
addq $0x40, %rsp
popq %rbp
retq
movq -0x10(%rbp), %rdi
callq 0xe1f0
nopw (%rax,%rax)
// File: Jumperr-labs[P]at25sf081/AT25SF081.cpp
// Function: AT25SF081::BlockErase(unsigned long)
void AT25SF081::BlockErase(size_t block_size) {
    if (!WelStatus()) {
        throw std::logic_error("AT25SF081: Trying to erase block while WEL bit in status register is 0");
    }

    int address = ReadAddress();
    if (address == -1)
        return;

    address = ((unsigned int) block_size) * (address / (unsigned int) block_size);

    IgnoreUntilSsInactive();

    memset(memory_ + address, 0xff, block_size);
    SetWel(true);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0xe100
testb $0x1, %al
jne 0xf111
movl $0x10, %edi
callq 0xd430
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
leaq 0x4fd1(%rip), %rsi      # 0x140ad
callq 0xde90
jmp 0xf0e3
movq -0x30(%rbp), %rdi
movq 0x9eda(%rip), %rsi      # 0x18fc8
movq 0x9ebb(%rip), %rdx      # 0x18fb0
callq 0xe150
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0xd630
jmp 0xf17c
movq -0x28(%rbp), %rdi
callq 0xdd90
movl %eax, -0x20(%rbp)
cmpl $-0x1, -0x20(%rbp)
jne 0xf125
jmp 0xf176
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
movl %eax, -0x34(%rbp)
movl -0x20(%rbp), %eax
movq -0x10(%rbp), %rcx
xorl %edx, %edx
divl %ecx
movl %eax, %ecx
movl -0x34(%rbp), %eax
imull %ecx, %eax
movl %eax, -0x20(%rbp)
callq 0xd9c0
movq -0x28(%rbp), %rdi
addq $0x10, %rdi
movslq -0x20(%rbp), %rax
addq %rax, %rdi
movq -0x10(%rbp), %rdx
movl $0xff, %esi
callq 0xd4a0
movq -0x28(%rbp), %rdi
movl $0x1, %esi
callq 0xd1a0
addq $0x40, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0xe1f0
nopw %cs:(%rax,%rax)
// File: Jumperr-labs[P]at25sf081/AT25SF081.cpp
// Function: AT25SF081::ChipErase()
void AT25SF081::ChipErase() {
    if (!WelStatus()) {
        throw std::logic_error("AT25SF081: Trying to erase chip while WEL bit in status register is 0");
    }
    IgnoreUntilSsInactive();
    MemReset();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0xe100
testb $0x1, %al
jne 0xf1fd
movl $0x10, %edi
callq 0xd430
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x28(%rbp)
leaq 0x4f2c(%rip), %rsi      # 0x140f4
callq 0xde90
jmp 0xf1cf
movq -0x28(%rbp), %rdi
movq 0x9dee(%rip), %rsi      # 0x18fc8
movq 0x9dcf(%rip), %rdx      # 0x18fb0
callq 0xe150
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0xd630
jmp 0xf215
movq -0x20(%rbp), %rdi
callq 0xd9c0
movq -0x20(%rbp), %rdi
callq 0xdc10
addq $0x30, %rsp
popq %rbp
retq
movq -0x10(%rbp), %rdi
callq 0xe1f0
nop
// File: Jumperr-labs[P]at25sf081/AT25SF081.cpp
// Function: AT25SF081::ReadDeviceId()
void AT25SF081::ReadDeviceId() {
    static uint8_t response[2] = {MANUFACTURER_ID, DEVICE_CODE};
    int i = 0;
    ReadDummyBytes(3);
    while (spi_slave_->IsSsActive()) {
        spi_slave_->Transmit(nullptr, &response[i], 1);
        i = (i + 1) % 2;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x3, %esi
callq 0xd710
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
testb $0x1, %al
jne 0xf319
jmp 0xf350
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movslq -0xc(%rbp), %rax
leaq 0xa707(%rip), %rdx      # 0x19a33
addq %rax, %rdx
movq (%rdi), %rax
xorl %ecx, %ecx
movl %ecx, %esi
movl $0x1, %ecx
callq *(%rax)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %edx, -0xc(%rbp)
jmp 0xf305
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Jumperr-labs[P]at25sf081/AT25SF081.cpp
// Function: AT25SF081::ReadAddress()
int AT25SF081::ReadAddress() {
    uint8_t data[3];
    if (spi_slave_->Transmit(data, nullptr, 3) != 3 || !spi_slave_->IsSsActive()) {
        return -1;
    }

    return ((data[0] << 16) | (data[1] << 8) | data[2]) % (int) MEMORY_SIZE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x8(%rax), %rdi
leaq -0x13(%rbp), %rsi
movq (%rdi), %rax
xorl %ecx, %ecx
movl %ecx, %edx
movl $0x3, %ecx
callq *(%rax)
cmpq $0x3, %rax
jne 0xf3c2
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
testb $0x1, %al
jne 0xf3cb
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xf3ec
movzbl -0x13(%rbp), %eax
shll $0x10, %eax
movzbl -0x12(%rbp), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movzbl -0x11(%rbp), %ecx
orl %ecx, %eax
movl $0x100000, %ecx         # imm = 0x100000
cltd
idivl %ecx
movl %edx, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Jumperr-labs[P]at25sf081/AT25SF081.cpp
// Function: AT25SF081::SetWel(bool)
void AT25SF081::SetWel(bool enable) {
    if (enable) {
        status_register1_ |= STATUS_REGISTER_WEL_MASK;
    } else {
        status_register1_ &= ~STATUS_REGISTER_WEL_MASK;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
testb $0x1, -0x9(%rbp)
je 0xf4b4
movq -0x18(%rbp), %rax
movzbl 0x100019(%rax), %ecx
orl $0x2, %ecx
movb %cl, 0x100019(%rax)
jmp 0xf4c8
movq -0x18(%rbp), %rax
movzbl 0x100019(%rax), %ecx
andl $-0x3, %ecx
movb %cl, 0x100019(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: Jumperr-labs[P]at25sf081/modeling-framework/src/ModelingFramework.cpp
// Function: AddTimedCallback(unsigned long, std::function<void ()> const&, bool)
int AddTimedCallback(uint64_t ns, const callback_t &callback, bool run_once) {
    assert(jemu_interface_);
    int id = jemu_interface_->AddTimedCallback(ns, &TimedCallback, run_once);
    timers_callbacks_map_[id] = callback;
    return id;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq 0x8c12(%rip), %rax      # 0x18f60
cmpq $0x0, (%rax)
je 0x10356
jmp 0x10375
leaq 0x3f03(%rip), %rdi      # 0x14260
leaq 0x3f0c(%rip), %rsi      # 0x14270
movl $0x55, %edx
leaq 0x4175(%rip), %rcx      # 0x144e5
callq 0xd570
movq 0x8be4(%rip), %rax      # 0x18f60
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
movb -0x11(%rbp), %cl
movq (%rdi), %rax
movq 0x8c00(%rip), %rdx      # 0x18f90
andb $0x1, %cl
movzbl %cl, %ecx
callq *0x20(%rax)
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x8c25(%rip), %rdi      # 0x18fd0
leaq -0x18(%rbp), %rsi
callq 0xdde0
movq -0x20(%rbp), %rsi
movq %rax, %rdi
callq 0xd160
movl -0x18(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: Jumperr-labs[P]at25sf081/modeling-framework/src/ModelingFramework.cpp
// Function: SetMultiplePinsLevel(std::vector<WireChange, std::allocator<WireChange>> const&)
void SetMultiplePinsLevel(const pin_level_changes_t& pin_changes) {
    assert(jemu_interface_);

    if (pin_changes.empty()) 
        return;

    std::unique_ptr<WireChange> arr(new WireChange[pin_changes.size()]);
    std::copy(pin_changes.begin(),pin_changes.end(), arr.get() );
    jemu_interface_->SetMultiplePinsLevel(arr.get(), pin_changes.size());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq 0x8abd(%rip), %rax      # 0x18f60
cmpq $0x0, (%rax)
je 0x104ab
jmp 0x104ca
leaq 0x3dae(%rip), %rdi      # 0x14260
leaq 0x3db7(%rip), %rsi      # 0x14270
movl $0x66, %edx
leaq 0x409f(%rip), %rcx      # 0x14564
callq 0xd570
movq -0x8(%rbp), %rdi
callq 0xe3c0
testb $0x1, %al
jne 0x104d9
jmp 0x104de
jmp 0x105e2
movq -0x8(%rbp), %rdi
callq 0xe2d0
movq %rax, -0x40(%rbp)
movl $0xc, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0xd030
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, -0x38(%rbp)
cmpq $0x0, %rax
je 0x10559
movq -0x38(%rbp), %rax
movq -0x40(%rbp), %rcx
imulq $0xc, %rcx, %rdx
movq %rax, %rcx
addq %rdx, %rcx
movq %rcx, -0x50(%rbp)
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0xda30
movq -0x58(%rbp), %rax
movq -0x50(%rbp), %rcx
addq $0xc, %rax
cmpq %rcx, %rax
movq %rax, -0x48(%rbp)
jne 0x10537
movq -0x38(%rbp), %rsi
leaq -0x10(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0xdfa0
movq -0x8(%rbp), %rdi
callq 0xd890
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0xd6d0
movq -0x60(%rbp), %rdi
movq %rax, -0x20(%rbp)
callq 0xd670
movq %rax, %rdx
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xe1a0
jmp 0x1059f
movq 0x89ba(%rip), %rax      # 0x18f60
movq (%rax), %rax
movq %rax, -0x70(%rbp)
leaq -0x10(%rbp), %rdi
callq 0xd670
movq %rax, -0x68(%rbp)
movq -0x8(%rbp), %rdi
callq 0xe2d0
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rsi
movq %rax, %rdx
movq (%rdi), %rax
movq 0x60(%rax), %rax
callq *%rax
jmp 0x105d9
leaq -0x10(%rbp), %rdi
callq 0xdbd0
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x10(%rbp), %rdi
callq 0xdbd0
movq -0x28(%rbp), %rdi
callq 0xe1f0
nopw %cs:(%rax,%rax)
// File: Jumperr-labs[P]at25sf081/modeling-framework/src/ModelingFramework.cpp
// Function: SetPinChangeLevelEventCallback(unsigned int, std::function<void (std::vector<WireLogicLevelEvent, std::allocator<WireLogicLevelEvent>>&)> const&)
int SetPinChangeLevelEventCallback(uint32_t pin_id, const pin_change_level_callback_t& callback) {
    assert(jemu_interface_);
    static int id = 0;
    auto pin_change_level_callback = new PinChangeLevelEventCallback(callback);
    jemu_interface_->SetPinChangeLevelEventCallback(pin_id, pin_change_level_callback);
    return id++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x88ca(%rip), %rax      # 0x18f60
cmpq $0x0, (%rax)
je 0x1069e
jmp 0x106bd
leaq 0x3bbb(%rip), %rdi      # 0x14260
leaq 0x3bc4(%rip), %rsi      # 0x14270
movl $0x83, %edx
leaq 0x3f19(%rip), %rcx      # 0x145d1
callq 0xd570
movl $0x28, %edi
callq 0xd980
movq %rax, -0x50(%rbp)
movb $0x1, -0x45(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0xd530
jmp 0x106de
movq -0x50(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xd640
jmp 0x106ed
movb $0x0, -0x45(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xe2c0
movq -0x50(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x8857(%rip), %rax      # 0x18f60
movq (%rax), %rdi
movl -0x4(%rbp), %esi
movq -0x18(%rbp), %rdx
movq (%rdi), %rax
callq *0x70(%rax)
movl 0x9371(%rip), %eax      # 0x19a90
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0x9366(%rip)      # 0x19a90
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x10753
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xe2c0
testb $0x1, -0x45(%rbp)
jne 0x1075b
jmp 0x10769
movq -0x50(%rbp), %rdi
movl $0x28, %esi
callq 0xd9b0
jmp 0x1076b
movq -0x40(%rbp), %rdi
callq 0xe1f0
nopw %cs:(%rax,%rax)
nop
// File: Sherhang[P]redis-for-cpp/./credis.h
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> Redis::num2str<int>(int const&)
std::string num2str(const T& num)
    {
        std::stringstream ss;
        ss << num;
        std::string str;
        ss >> str;
        return str;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1c0, %rsp            # imm = 0x1C0
movq %rdi, -0x1c0(%rbp)
movq %rdi, %rax
movq %rax, -0x1b8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x1a0(%rbp), %rdi
callq 0x32e0
leaq -0x190(%rbp), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %esi
callq 0x3650
jmp 0x45a8
movq -0x1c0(%rbp), %rdi
movb $0x0, -0x1ad(%rbp)
callq 0x3530
movq -0x1c0(%rbp), %rsi
leaq -0x1a0(%rbp), %rdi
callq 0x34c0
jmp 0x45d0
movb $0x1, -0x1ad(%rbp)
testb $0x1, -0x1ad(%rbp)
jne 0x4622
jmp 0x4616
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
jmp 0x463e
movq -0x1c0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
callq 0x3290
jmp 0x463e
movq -0x1c0(%rbp), %rdi
callq 0x3290
leaq -0x1a0(%rbp), %rdi
callq 0x3300
movq -0x1b8(%rbp), %rax
addq $0x1c0, %rsp            # imm = 0x1C0
popq %rbp
retq
leaq -0x1a0(%rbp), %rdi
callq 0x3300
movq -0x1a8(%rbp), %rdi
callq 0x3660
nopw %cs:(%rax,%rax)
// File: Sherhang[P]redis-for-cpp/credis.cpp
// Function: Redis::~Redis()
Redis::~Redis() 
{
    if(_connected)
    {
        //DEBUG<<"free _context"<<std::endl;
        ::redisFree(_context);
        _connected = false;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x1ab45(%rip), %rcx     # 0x1fd80
addq $0x10, %rcx
movq %rcx, (%rax)
testb $0x1, 0x60(%rax)
je 0x525f
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x10ca0
jmp 0x5257
movq -0x10(%rbp), %rax
movb $0x0, 0x60(%rax)
movq -0x10(%rbp), %rdi
addq $0x40, %rdi
callq 0x3290
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
callq 0x3290
addq $0x10, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x4b40
nopw (%rax,%rax)
// File: Sherhang[P]redis-for-cpp/credis.cpp
// Function: Redis::connect()
void Redis::connect()
{
    if(_connected)
    {
        //DEBUG
        return;
    }
    _connected = true;
    _context = ::redisConnect(_ip.c_str(), _port);
    if (_context && _context->err)
    {
        exit(EXIT_FAILURE);
    }
    if(_pwd.empty())
    {
        std::vector<std::string> status;
        exec("PING",status);
        if((!status.empty()) && strcasecmp(status[0].c_str(),"PONG") == 0)
        {
            return ;
        }
        else
        {
            //debug
            exit(EXIT_FAILURE);
        }
    }

    if (auth(_pwd))
    {
        //debug
    }
    else
    {
        exit(EXIT_FAILURE);
    }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
testb $0x1, 0x60(%rax)
je 0x532f
jmp 0x5483
movq -0x60(%rbp), %rdi
movb $0x1, 0x60(%rdi)
addq $0x18, %rdi
callq 0x3190
movq %rax, %rdi
movq -0x60(%rbp), %rax
movl 0x38(%rax), %esi
callq 0x10f60
movq %rax, %rcx
movq -0x60(%rbp), %rax
movq %rcx, 0x8(%rax)
cmpq $0x0, 0x8(%rax)
je 0x5378
movq -0x60(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0x0, (%rax)
je 0x5378
movl $0x1, %edi
callq 0x3490
movq -0x60(%rbp), %rdi
addq $0x40, %rdi
callq 0x3610
testb $0x1, %al
jne 0x538e
jmp 0x5461
leaq -0x20(%rbp), %rdi
callq 0x4850
leaq -0x41(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x3670
movq -0x68(%rbp), %rdx
leaq 0x12ce5(%rip), %rsi     # 0x18094
leaq -0x40(%rbp), %rdi
callq 0x3510
jmp 0x53ba
movq -0x60(%rbp), %rdi
leaq -0x40(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x54a0
jmp 0x53cd
leaq -0x40(%rbp), %rdi
callq 0x3290
leaq -0x41(%rbp), %rdi
callq 0x3410
leaq -0x20(%rbp), %rdi
callq 0xb4d0
testb $0x1, %al
jne 0x5457
leaq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x4660
movq %rax, %rdi
callq 0x3190
movq %rax, %rdi
leaq 0x12c8e(%rip), %rsi     # 0x18099
callq 0x3430
cmpl $0x0, %eax
jne 0x5457
leaq -0x20(%rbp), %rdi
callq 0x47f0
jmp 0x5483
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x5443
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3290
leaq -0x41(%rbp), %rdi
callq 0x3410
leaq -0x20(%rbp), %rdi
callq 0x47f0
jmp 0x5489
movl $0x1, %edi
callq 0x3490
movq -0x60(%rbp), %rdi
movq %rdi, %rsi
addq $0x40, %rsi
callq 0x58c0
testb $0x1, %al
jne 0x5477
jmp 0x5479
jmp 0x5483
movl $0x1, %edi
callq 0x3490
addq $0x70, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x3660
nopw %cs:(%rax,%rax)
// File: Sherhang[P]redis-for-cpp/credis.cpp
// Function: Redis::del(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
int64_t Redis::del(const std::string& key)
{
    int64_t ret=0;
    std::string cmd = "DEL " + key;
    if(execReplyInt(cmd, ret))
    {
        return ret;
    }
    DEBUG<<"execReplyInt error "<<std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rdx
leaq 0x12650(%rip), %rsi     # 0x1809e
leaq -0x38(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0xb510
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0x5bc0
movb %al, -0x45(%rbp)
jmp 0x5a71
movb -0x45(%rbp), %al
testb $0x1, %al
jne 0x5a7a
jmp 0x5ab2
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3290
movq -0x60(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3290
jmp 0x5bab
movq 0x1a51f(%rip), %rdi     # 0x1ffd8
leaq 0x125e3(%rip), %rsi     # 0x180a3
callq 0x33b0
movq %rax, -0x68(%rbp)
jmp 0x5acb
movq -0x68(%rbp), %rdi
leaq 0x125d5(%rip), %rsi     # 0x180ab
callq 0x33b0
movq %rax, -0x70(%rbp)
jmp 0x5ae1
movq -0x70(%rbp), %rdi
leaq 0x125ca(%rip), %rsi     # 0x180b6
callq 0x33b0
movq %rax, -0x78(%rbp)
jmp 0x5af7
movq -0x78(%rbp), %rdi
leaq 0x125b6(%rip), %rsi     # 0x180b8
callq 0x33b0
movq %rax, -0x80(%rbp)
jmp 0x5b0d
movq -0x80(%rbp), %rdi
leaq 0x1259e(%rip), %rsi     # 0x180b6
callq 0x33b0
movq %rax, -0x88(%rbp)
jmp 0x5b26
movq -0x88(%rbp), %rdi
leaq 0x12588(%rip), %rsi     # 0x180bc
callq 0x33b0
movq %rax, -0x90(%rbp)
jmp 0x5b42
movq -0x90(%rbp), %rdi
movl $0x75, %esi
callq 0x3650
movq %rax, -0x98(%rbp)
jmp 0x5b5c
movq -0x98(%rbp), %rdi
leaq 0x13068(%rip), %rsi     # 0x18bd2
callq 0x33b0
movq %rax, -0xa0(%rbp)
jmp 0x5b78
movq -0xa0(%rbp), %rdi
leaq 0x1253b(%rip), %rsi     # 0x180c1
callq 0x33b0
movq %rax, -0xa8(%rbp)
jmp 0x5b94
movq -0xa8(%rbp), %rdi
movq 0x1a426(%rip), %rsi     # 0x1ffc8
callq 0x33f0
jmp 0x5ba9
ud2
movq -0x40(%rbp), %rdi
callq 0x3660
nopw %cs:(%rax,%rax)
// File: Sherhang[P]redis-for-cpp/credis.cpp
// Function: Redis::execReplyInt(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, long&)
bool Redis::execReplyInt(const std::string& cmd, int64_t& ret)
{
    if(_context==NULL)
    {
        return false;
    }

    redisReply* _reply = (redisReply*)::redisCommand(_context, cmd.c_str());
    if (!isError(_reply))
    {
        //DEBUG<<"_reply->type "<<_reply->type<<std::endl;
        if (_reply->type == REDIS_REPLY_INTEGER)
        {
            ret = _reply->integer;
            freeReply(_reply);
            return true;
        }
        if (_reply->type == REDIS_REPLY_ERROR)
        {
            std::string reason = _reply->str;
            reason.resize(_reply->len);
            freeReply(_reply);
            return false;
        }
    }
    freeReply(_reply);
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
cmpq $0x0, 0x8(%rax)
jne 0x5bef
movb $0x0, -0x1(%rbp)
jmp 0x5d0d
movq -0x68(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x70(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3190
movq -0x70(%rbp), %rdi
movq %rax, %rsi
movb $0x0, %al
callq 0x11a60
movq -0x68(%rbp), %rdi
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
callq 0x59f0
testb $0x1, %al
jne 0x5cfc
movq -0x28(%rbp), %rax
cmpl $0x3, (%rax)
jne 0x5c59
movq -0x68(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rsi
callq 0x59c0
movb $0x1, -0x1(%rbp)
jmp 0x5d0d
movq -0x28(%rbp), %rax
cmpl $0x6, (%rax)
jne 0x5cfa
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x80(%rbp)
leaq -0x49(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x3670
movq -0x80(%rbp), %rsi
movq -0x78(%rbp), %rdx
leaq -0x48(%rbp), %rdi
callq 0x3510
jmp 0x5c92
leaq -0x49(%rbp), %rdi
callq 0x3410
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rsi
leaq -0x48(%rbp), %rdi
callq 0x3520
jmp 0x5cae
movq -0x68(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x59c0
jmp 0x5cbd
movb $0x0, -0x1(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x3290
jmp 0x5d0d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x49(%rbp), %rdi
callq 0x3410
jmp 0x5d1b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x3290
jmp 0x5d1b
jmp 0x5cfc
movq -0x68(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x59c0
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x80, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x3660
nopw %cs:(%rax,%rax)
// File: Sherhang[P]redis-for-cpp/credis.cpp
// Function: Redis::exists(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool Redis::exists(const std::string& key)
{  
    int64_t ret = 0;
    std::string cmd = "DEL " + key;
    execReplyInt(cmd, ret);
    return (ret > 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rdx
leaq 0x12343(%rip), %rsi     # 0x1809e
leaq -0x38(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0xb510
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0x5bc0
jmp 0x5d7b
cmpq $0x0, -0x18(%rbp)
setg %al
movb %al, -0x59(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3290
movb -0x59(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3290
movq -0x40(%rbp), %rdi
callq 0x3660
nopl (%rax,%rax)
// File: Sherhang[P]redis-for-cpp/credis.cpp
// Function: Redis::expire(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, long)
bool Redis::expire(const std::string& key, int64_t seconds)
{
    int64_t ret = 0;
    std::string cmd = "EXPIRE " + key + " " +  num2str<int64_t>(seconds);
    execReplyInt(cmd, ret);
    return (ret > 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xc0(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rdx
leaq 0x122e0(%rip), %rsi     # 0x180d5
leaq -0x80(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0xb510
movq -0xb8(%rbp), %rsi
leaq 0x12dbf(%rip), %rdx     # 0x18bd2
leaq -0x60(%rbp), %rdi
callq 0xb6f0
jmp 0x5e1e
movq -0xc0(%rbp), %rsi
leaq -0xb0(%rbp), %rdi
leaq -0x18(%rbp), %rdx
callq 0xb740
jmp 0x5e37
leaq -0x40(%rbp), %rdi
leaq -0x60(%rbp), %rsi
leaq -0xb0(%rbp), %rdx
callq 0xb620
jmp 0x5e4d
leaq -0xb0(%rbp), %rdi
callq 0x3290
leaq -0x60(%rbp), %rdi
callq 0x3290
leaq -0x80(%rbp), %rdi
callq 0x3290
movq -0xc0(%rbp), %rdi
leaq -0x40(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x5bc0
jmp 0x5e81
cmpq $0x0, -0x20(%rbp)
setg %al
movb %al, -0xc1(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3290
movb -0xc1(%rbp), %al
andb $0x1, %al
addq $0xd0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0x5ef8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0x5eef
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x3290
leaq -0x60(%rbp), %rdi
callq 0x3290
leaq -0x80(%rbp), %rdi
callq 0x3290
jmp 0x5f1e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3290
movq -0x88(%rbp), %rdi
callq 0x3660
nopw (%rax,%rax)
// File: Sherhang[P]redis-for-cpp/credis.cpp
// Function: Redis::expireat(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, long)
bool Redis::expireat(const std::string& key, int64_t timestamp)
{
    int64_t ret = 0;
    std::string cmd = "EXPIREAT " + key + " " + num2str<int64_t>(timestamp);
    execReplyInt(cmd, ret);
    return (ret > 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xc0(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rdx
leaq 0x12178(%rip), %rsi     # 0x180dd
leaq -0x80(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0xb510
movq -0xb8(%rbp), %rsi
leaq 0x12c4f(%rip), %rdx     # 0x18bd2
leaq -0x60(%rbp), %rdi
callq 0xb6f0
jmp 0x5f8e
movq -0xc0(%rbp), %rsi
leaq -0xb0(%rbp), %rdi
leaq -0x18(%rbp), %rdx
callq 0xb740
jmp 0x5fa7
leaq -0x40(%rbp), %rdi
leaq -0x60(%rbp), %rsi
leaq -0xb0(%rbp), %rdx
callq 0xb620
jmp 0x5fbd
leaq -0xb0(%rbp), %rdi
callq 0x3290
leaq -0x60(%rbp), %rdi
callq 0x3290
leaq -0x80(%rbp), %rdi
callq 0x3290
movq -0xc0(%rbp), %rdi
leaq -0x40(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x5bc0
jmp 0x5ff1
cmpq $0x0, -0x20(%rbp)
setg %al
movb %al, -0xc1(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3290
movb -0xc1(%rbp), %al
andb $0x1, %al
addq $0xd0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0x6068
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0x605f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x3290
leaq -0x60(%rbp), %rdi
callq 0x3290
leaq -0x80(%rbp), %rdi
callq 0x3290
jmp 0x608e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3290
movq -0x88(%rbp), %rdi
callq 0x3660
nopw (%rax,%rax)
// File: Sherhang[P]redis-for-cpp/credis.cpp
// Function: Redis::keys(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&)
bool Redis::keys(const std::string& pattern, std::vector<std::string>& key_list)
{
    std::string cmd = "KEYS " + pattern; 
    if (execReplyArray(cmd, key_list))
    {
        return true;
    }
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x18(%rbp), %rdx
leaq 0x12020(%rip), %rsi     # 0x180e7
leaq -0x40(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0xb510
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x6140
movb %al, -0x51(%rbp)
jmp 0x60ea
movb -0x51(%rbp), %al
testb $0x1, %al
jne 0x60f3
jmp 0x6117
movb $0x1, -0x1(%rbp)
movl $0x1, -0x50(%rbp)
jmp 0x6122
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3290
jmp 0x6136
movb $0x0, -0x1(%rbp)
movl $0x1, -0x50(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3290
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x3660
nop
// File: Sherhang[P]redis-for-cpp/credis.cpp
// Function: Redis::execReplyArray(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&)
bool Redis::execReplyArray(const std::string& cmd, std::vector<std::string>& ret)
{
    if(_context==NULL)
    {
        return false;
    }

    redisReply* _reply = (redisReply*)::redisCommand(_context, cmd.c_str());
    if (!isError(_reply))
    {
        if (_reply->type == REDIS_REPLY_ARRAY)
        {
            int32_t elements = _reply->elements;
            ret.reserve(elements);
            for(int32_t i=0; i<elements; ++i)
            {
                std::string strTemp(_reply->element[i]->str, _reply->element[i]->len);
                ret.push_back(strTemp);
            }
            freeReply(_reply);
            return true;
        }
    }
    freeReply(_reply);
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
cmpq $0x0, 0x8(%rax)
jne 0x616f
movb $0x0, -0x1(%rbp)
jmp 0x62b6
movq -0x70(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x78(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3190
movq -0x78(%rbp), %rdi
movq %rax, %rsi
movb $0x0, %al
callq 0x11a60
movq -0x70(%rbp), %rdi
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
callq 0x59f0
testb $0x1, %al
jne 0x62a5
movq -0x28(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x62a3
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rax
movl %eax, -0x2c(%rbp)
movq -0x20(%rbp), %rdi
movslq -0x2c(%rbp), %rsi
callq 0xb8b0
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jge 0x6290
movq -0x28(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x10(%rax), %rcx
movq %rcx, -0x88(%rbp)
movq 0x18(%rax), %rax
movq %rax, -0x90(%rbp)
leaq -0x51(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x3670
movq -0x90(%rbp), %rsi
movq -0x88(%rbp), %rdx
movq -0x80(%rbp), %rcx
leaq -0x50(%rbp), %rdi
callq 0x3450
jmp 0x6233
leaq -0x51(%rbp), %rdi
callq 0x3410
movq -0x20(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0xb9b0
jmp 0x624b
leaq -0x50(%rbp), %rdi
callq 0x3290
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x61d7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x51(%rbp), %rdi
callq 0x3410
jmp 0x62c4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x3290
jmp 0x62c4
movq -0x70(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x59c0
movb $0x1, -0x1(%rbp)
jmp 0x62b6
jmp 0x62a5
movq -0x70(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x59c0
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x90, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x3660
nopl (%rax)
// File: Sherhang[P]redis-for-cpp/credis.cpp
// Function: Redis::type(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string Redis::type(const std::string& key)
{
    std::string ret;
    std::string cmd = "TYPE " + key;
    execReplyString(cmd, ret);
    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 0x3530
movq -0x18(%rbp), %rdx
leaq 0x11057(%rip), %rsi     # 0x18102
leaq -0x40(%rbp), %rdi
callq 0xb510
jmp 0x70b6
movq -0x68(%rbp), %rdx
movq -0x58(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x71c0
jmp 0x70c9
movb $0x1, -0x19(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3290
testb $0x1, -0x19(%rbp)
jne 0x710c
jmp 0x7103
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x7116
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3290
jmp 0x7116
movq -0x68(%rbp), %rdi
callq 0x3290
movq -0x60(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x3290
movq -0x48(%rbp), %rdi
callq 0x3660
nopl (%rax,%rax)
// File: Sherhang[P]redis-for-cpp/credis.cpp
// Function: Redis::ttl(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
int64_t Redis::ttl(const std::string& key)
{
    int64_t ret = -3;
    std::string cmd = "TTL " + key;
    execReplyInt(cmd, ret);
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq $-0x3, -0x18(%rbp)
movq -0x10(%rbp), %rdx
leaq 0x10fa2(%rip), %rsi     # 0x180fd
leaq -0x38(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0xb510
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0x5bc0
jmp 0x717b
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3290
movq -0x60(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3290
movq -0x40(%rbp), %rdi
callq 0x3660
nopw %cs:(%rax,%rax)