LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/renzibei[P]TSProxy/proxyserver.cpp
// Function: cleanDeadHosts(std::unordered_map<int, ClientNode*, std::hash<int>, std::equal_to<int>, std::allocator<std::pair<int const, ClientNode*>>>&, std::unordered_map<int, HostNode, std::hash<int>, std::equal_to<int>, std::allocator<std::pair<int const, HostNode>>>&, fd_set&, fd_set&, int&, int&, int&)
void cleanDeadHosts(ClientMap &cMap, HostMap &sMap, fd_set &readSet, fd_set &writeSet, int &max_read_sd, int &max_write_sd, int &max_all_sd) {
    time_t now = time(NULL);
    for (auto it = sMap.begin(); it != sMap.end();) {
        if (now - it->second.lastTime > constants::SocketTimeOutSeconds) {
            LogHelper::log(Debug, "Clean timeout host fd: %d, localFd: %d", it->first, it->second.localFd);
            eraseHostFromFdSets(it->first, readSet, writeSet, max_read_sd, max_write_sd, max_all_sd);
            cMap[it->second.clientFd]->sMap.erase(it->second.localFd);
            it = sMap.erase(it);
        }
        else it++;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, 0x10(%rsp)
movq %r8, 0x8(%rsp)
movq %rcx, (%rsp)
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbp
xorl %edi, %edi
callq 0x2190
movq 0x10(%r13), %r14
testq %r14, %r14
je 0x3505
movq %rax, %rbx
movq %rbx, %rax
subq 0x18(%r14), %rax
cmpq $0xb5, %rax
jl 0x34fd
leaq 0x14(%r14), %r15
movl 0x8(%r14), %edx
movl 0x14(%r14), %ecx
movl $0x3, %edi
leaq 0x4165(%rip), %rsi      # 0x7611
xorl %eax, %eax
callq 0x273c
movl 0x8(%r14), %edi
movq %r12, %rsi
movq (%rsp), %rdx
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %r8
movq 0x50(%rsp), %r9
callq 0x31cd
leaq 0x10(%r14), %rsi
movq %rbp, %rdi
callq 0x48c8
movq (%rax), %rdi
addq $0x18, %rdi
movq %r15, %rsi
callq 0x5322
movq %r13, %rdi
movq %r14, %rsi
callq 0x5384
movq %rax, %r14
jmp 0x3500
movq (%r14), %r14
testq %r14, %r14
jne 0x3485
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/renzibei[P]TSProxy/proxyserver.cpp
// Function: cleanDeadClients(std::unordered_map<int, ClientNode*, std::hash<int>, std::equal_to<int>, std::allocator<std::pair<int const, ClientNode*>>>&, std::unordered_map<int, HostNode, std::hash<int>, std::equal_to<int>, std::allocator<std::pair<int const, HostNode>>>&, fd_set&, fd_set&, int&, int&, int&)
void cleanDeadClients(ClientMap &cMap, HostMap &h2lMap, fd_set &readSet, fd_set &writeSet, int &max_read_sd, int &max_write_sd, int &max_all_sd) {
    time_t now = time(NULL);
    for (auto it = cMap.begin(); it != cMap.end(); ) {
        if (now - it->second->lastTime > constants::ClientTimeOutSeconds) {
            LogHelper::log(Debug, "Clean timeout client fd: %d", it->first);
            cleanDeadLocalFds(it->first, h2lMap, it->second->sMap, readSet, writeSet, max_read_sd, max_write_sd, max_all_sd, true);
            eraseClientFromFdSet(it->first, readSet, max_read_sd, max_write_sd, max_all_sd);
            delete it->second;
            it = cMap.erase(it);
        }
        else {
            cleanDeadLocalFds(it->first, h2lMap, it->second->sMap, readSet, writeSet, max_read_sd, max_write_sd, max_all_sd);
            it++;
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r9, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq %rcx, %r13
movq %rdx, 0x8(%rsp)
movq %rsi, %rbp
movq %rdi, %rbx
xorl %edi, %edi
callq 0x2190
movq %rax, 0x30(%rsp)
movq %rbx, 0x28(%rsp)
movq 0x10(%rbx), %r15
testq %r15, %r15
je 0x3658
movq %rbp, 0x20(%rsp)
movq 0x8(%rsp), %rbx
movq 0x10(%rsp), %r12
movq 0x10(%r15), %rdx
movq 0x30(%rsp), %rcx
subq 0x10(%rdx), %rcx
movl 0x8(%r15), %eax
cmpq $0x79, %rcx
jl 0x361c
movl $0x3, %edi
leaq 0x40aa(%rip), %rsi      # 0x7638
movl %eax, %edx
xorl %eax, %eax
callq 0x273c
movl 0x8(%r15), %edi
movq 0x10(%r15), %rdx
addq $0x18, %rdx
subq $0x8, %rsp
movq %rbp, %rsi
movq %rbx, %rcx
movq %r13, %rbp
movq %r13, %r8
movq %r12, %r9
pushq $0x1
movq 0x80(%rsp), %r14
pushq %r14
movq 0x30(%rsp), %r13
pushq %r13
callq 0x3378
addq $0x20, %rsp
movl 0x8(%r15), %edi
movl (%r13), %ecx
movq %rbx, %rsi
movq %r12, %rdx
movq %r14, %r8
callq 0x32fc
movq 0x10(%r15), %r13
testq %r13, %r13
je 0x35fa
leaq 0x18(%r13), %rdi
callq 0x4730
movq %r13, %rdi
callq 0x21a0
movq 0x28(%rsp), %rdi
movq %r15, %rsi
callq 0x53ae
movq %rax, %r15
movq %rbp, %r13
movq 0x20(%rsp), %rbp
jmp 0x364f
addq $0x18, %rdx
subq $0x8, %rsp
movl %eax, %edi
movq %rbp, %rsi
movq 0x10(%rsp), %rcx
movq %r13, %r8
movq 0x18(%rsp), %r9
pushq $0x0
pushq 0x80(%rsp)
pushq 0x30(%rsp)
callq 0x3378
addq $0x20, %rsp
movq (%r15), %r15
testq %r15, %r15
jne 0x3567
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/renzibei[P]TSProxy/utils.cpp
// Function: make_socket(unsigned short, int, int)
int make_socket(uint16_t port, int on, int bindToLoopback)
{
    int sock;
    struct sockaddr_in6 name;

    /* Create the socket. */    
    sock = socket(AF_INET6, SOCK_STREAM, 0);
    if (sock < 0)
    {
        LogHelper::log(Error, "failed to create socket, %s", strerror(errno));
        return -1;
    }

    // set reuseable
    int rc = setsockopt(sock, SOL_SOCKET,  SO_REUSEADDR,
                   (char *)&on, sizeof(on));
    if (rc < 0)
    {
        LogHelper::log(Error, "setsockopt() failed, %s", strerror(errno));
        close(sock);
        return -2;
    }

    /* Give the socket a name. */
    memset(&name, 0, sizeof(name));
    name.sin6_family = AF_INET6;
    name.sin6_port = htons (port);
    //   name.sin6_addr.s_addr = htonl (INADDR_ANY);
    
    if (bindToLoopback)
        memcpy(&name.sin6_addr, &in6addr_loopback, sizeof(in6addr_loopback));
    else
        memcpy(&name.sin6_addr, &in6addr_any, sizeof(in6addr_any));

    if (bind (sock, (struct sockaddr *) &name, sizeof (name)) < 0)
    {
        LogHelper::log(Error, "Failed to bind, %s", strerror(errno));
        return -3;
    }

    return sock;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %edx, %ebp
movl %edi, %r14d
movl %esi, (%rsp)
movl $0xa, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x2080
testl %eax, %eax
js 0x57d3
movl %eax, %ebx
movq %rsp, %rcx
movl %eax, %edi
movl $0x1, %esi
movl $0x2, %edx
movl $0x4, %r8d
callq 0x2320
testl %eax, %eax
js 0x57f9
xorps %xmm0, %xmm0
leaq 0xc(%rsp), %rax
movups %xmm0, -0x4(%rax)
movq $0x0, 0xc(%rax)
movw $0xa, -0x8(%rax)
rolw $0x8, %r14w
movw %r14w, -0x6(%rax)
testl %ebp, %ebp
je 0x5826
movq 0x67ff(%rip), %rcx      # 0xbfd0
jmp 0x582d
callq 0x2040
movl (%rax), %edi
callq 0x20d0
leaq 0x221f(%rip), %rsi      # 0x7a05
xorl %edi, %edi
movq %rax, %rdx
xorl %eax, %eax
callq 0x273c
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jmp 0x586c
callq 0x2040
movl (%rax), %edi
callq 0x20d0
leaq 0x2215(%rip), %rsi      # 0x7a21
xorl %edi, %edi
movq %rax, %rdx
xorl %eax, %eax
callq 0x273c
movl %ebx, %edi
callq 0x2340
movl $0xfffffffe, %ebx       # imm = 0xFFFFFFFE
jmp 0x586c
movq 0x67b3(%rip), %rcx      # 0xbfe0
movups (%rcx), %xmm0
movups %xmm0, (%rax)
leaq 0x4(%rsp), %rsi
movl %ebx, %edi
movl $0x1c, %edx
callq 0x2060
testl %eax, %eax
jns 0x586c
callq 0x2040
movl (%rax), %edi
callq 0x20d0
leaq 0x21de(%rip), %rsi      # 0x7a39
xorl %edi, %edi
movq %rax, %rdx
xorl %eax, %eax
callq 0x273c
movl $0xfffffffd, %ebx       # imm = 0xFFFFFFFD
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/renzibei[P]TSProxy/utils.cpp
// Function: readNBytes(int, void*, unsigned long, int)
ssize_t readNBytes(int fd, void *buf, size_t nbyte, int isNonBlocking) {
    size_t hasRead = 0;
    char* dest = (char*)buf;
    while(hasRead < nbyte) {
        ssize_t tempLen = recv(fd, dest + hasRead, nbyte - hasRead, 0);
        if(tempLen < 0) {
            if (isNonBlocking && errno == EAGAIN) {
                continue;
            }
            LogHelper::log(Error, "Error happens when read fd , errno: %d %s", errno, strerror(errno));
            return -1;
        }
        if(isNonBlocking && tempLen == 0) {
            LogHelper::log(Error, "Connection has been closed in sockFd %d when tried to recv", fd);
            return hasRead;
        }
        hasRead += tempLen;
        
    }
    
    return hasRead;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdx, %rdx
je 0x58ce
movl %ecx, %r14d
movq %rdx, %r15
movq %rsi, %r12
movl %edi, %ebp
xorl %ebx, %ebx
leaq (%r12,%rbx), %rsi
movq %r15, %rdx
subq %rbx, %rdx
movl %ebp, %edi
xorl %ecx, %ecx
callq 0x20c0
testq %rax, %rax
js 0x58b8
testl %r14d, %r14d
je 0x58b3
testq %rax, %rax
je 0x58f9
addq %rax, %rbx
jmp 0x58c7
callq 0x2040
testl %r14d, %r14d
je 0x58d2
cmpl $0xb, (%rax)
jne 0x58d2
cmpq %r15, %rbx
jb 0x5891
jmp 0x590b
xorl %ebx, %ebx
jmp 0x590b
movl (%rax), %ebx
movl %ebx, %edi
callq 0x20d0
leaq 0x216a(%rip), %rsi      # 0x7a4c
xorl %edi, %edi
movl %ebx, %edx
movq %rax, %rcx
xorl %eax, %eax
callq 0x273c
movq $-0x1, %rbx
jmp 0x590b
leaq 0x2176(%rip), %rsi      # 0x7a76
xorl %edi, %edi
movl %ebp, %edx
xorl %eax, %eax
callq 0x273c
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/renzibei[P]TSProxy/utils.cpp
// Function: disAssembleInnerMsg(InnerMsg*, unsigned char const*, unsigned long)
int disAssembleInnerMsg(InnerMsg *msg ,const uint8_t *src_data, size_t nbyte) {
    // memset(msg, 0, sizeof(InnerMsg));
    if (nbyte < sizeof(msg->cSeq) + sizeof(msg->sSeq) + sizeof(msg->msgType) + sizeof(msg->dataLength) ) {
        LogHelper::log(Warn, "nbyte less than InnerMsg header, nbyte: %lu", nbyte); 
        return -1;
    }
    ntoh_copy8bytes(&(msg->cSeq), src_data); src_data += sizeof(msg->cSeq);
    ntoh_copy8bytes(&(msg->sSeq), src_data); src_data += sizeof(msg->sSeq);
    ntoh_copy2bytes(&(msg->msgType), src_data); src_data += sizeof(msg->msgType);
    ntoh_copy2bytes(&(msg->dataLength), src_data); src_data += sizeof(msg->dataLength);
    memcpy(msg->data, src_data, msg->dataLength);
    return 0;
}

// Assembly:
pushq %rax
cmpq $0x13, %rdx
ja 0x59d5
leaq 0x214b(%rip), %rsi      # 0x7b0d
movl $0x1, %edi
xorl %eax, %eax
callq 0x273c
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x5a13
movq (%rsi), %rax
bswapq %rax
movq %rax, (%rdi)
movq 0x8(%rsi), %rax
bswapq %rax
movq %rax, 0x8(%rdi)
movzwl 0x10(%rsi), %eax
rolw $0x8, %ax
movw %ax, 0x10(%rdi)
movzwl 0x12(%rsi), %eax
rolw $0x8, %ax
movw %ax, 0x12(%rdi)
addq $0x14, %rsi
addq $0x14, %rdi
movzwl %ax, %edx
callq 0x2150
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O3/renzibei[P]TSProxy/utils.cpp
// Function: assembleInnerMsg(unsigned char*, unsigned long, InnerMsg const*)
ssize_t assembleInnerMsg(uint8_t *dst, size_t buffer_size, const InnerMsg *src_msg) {
    uint8_t *old_dst = dst;
    if (buffer_size < sizeof(src_msg->cSeq) + sizeof(src_msg->sSeq) + sizeof(src_msg->msgType) + sizeof(src_msg->dataLength)) {
        LogHelper::log(Warn, "buffer size less than inner msg header, buffer_size: %lu");
        return -1;
    }
    hton_copy8bytes(dst, &(src_msg->cSeq)); dst += sizeof(src_msg->cSeq);
    hton_copy8bytes(dst, &(src_msg->sSeq)); dst += sizeof(src_msg->sSeq);
    hton_copy2bytes(dst, &(src_msg->msgType)); dst += sizeof(src_msg->msgType);
    hton_copy2bytes(dst, &(src_msg->dataLength)); dst += sizeof(src_msg->dataLength);
    buffer_size -= sizeof(src_msg->cSeq) + sizeof(src_msg->sSeq) + sizeof(src_msg->dataLength);
    if (buffer_size < src_msg->dataLength) {
        LogHelper::log(Warn, "buffer size less than InnerMsg dataLength, buffer_size: %lu, dataLength: %lu", buffer_size, src_msg->dataLength);
        return -2;
    }
    memcpy(dst, src_msg->data, src_msg->dataLength); dst += src_msg->dataLength;
    return dst - old_dst; 
}

// Assembly:
pushq %rbx
cmpq $0x13, %rsi
ja 0x5b6d
leaq 0x20bd(%rip), %rsi      # 0x7c15
movl $0x1, %edi
xorl %eax, %eax
callq 0x273c
movq $-0x1, %rax
jmp 0x5be0
movq %rdx, %rbx
movq %rsi, %rdx
movq (%rbx), %rax
bswapq %rax
movq %rax, (%rdi)
movq 0x8(%rbx), %rax
bswapq %rax
movq %rax, 0x8(%rdi)
movzwl 0x10(%rbx), %eax
rolw $0x8, %ax
movw %ax, 0x10(%rdi)
movzwl 0x12(%rbx), %eax
rolw $0x8, %ax
movw %ax, 0x12(%rdi)
addq $-0x12, %rdx
movzwl 0x12(%rbx), %ecx
cmpq %rcx, %rdx
jae 0x5bc8
leaq 0x209b(%rip), %rsi      # 0x7c4e
movl $0x1, %edi
xorl %eax, %eax
callq 0x273c
movq $-0x2, %rax
jmp 0x5be0
addq $0x14, %rdi
leaq 0x14(%rbx), %rsi
movq %rcx, %rdx
callq 0x2150
movzwl 0x12(%rbx), %eax
addq $0x14, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/renzibei[P]TSProxy/utils.cpp
// Function: getRand63()
uint64_t getRand63() {
    uint64_t ret = 0;
    for (int i = 0; i < 63; ++i) {
        ret = (ret << 1) + (rand() & 1);
    }
    ret &= 0x7fffffffffffffffULL;
    return ret;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl $0x3f, %ebp
xorl %ebx, %ebx
callq 0x2090
andl $0x1, %eax
leaq (%rax,%rbx,2), %rbx
decl %ebp
jne 0x6042
btrq $0x3f, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O3/renzibei[P]TSProxy/constants.cpp
// Function: constants::getKey(char (&) [16])
int getKey(char (&dst)[16]) {
    // uuid_t id;
    if (hasParsedKey == 0) {
        int code = uuid_parse(constants::uuidKey, storedId);
        if (code != 0)
            return code;
        hasParsedKey = 1;
    }
    memcpy(dst, storedId, 16);
    return 0;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x0, 0xb6411(%rip)     # 0xbc480
jne 0x608f
leaq 0x1e78(%rip), %rdi      # 0x7ef0
leaq 0xb6411(%rip), %rsi     # 0xbc490
callq 0x22e0
testl %eax, %eax
jne 0x609b
movb $0x1, 0xb63f1(%rip)     # 0xbc480
movaps 0xb63fa(%rip), %xmm0    # 0xbc490
movups %xmm0, (%rbx)
xorl %eax, %eax
popq %rbx
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O3/renzibei[P]TSProxy/aes.cpp
// Function: addKey(int (&) [4][4], int)
static void addKey(int (&array)[4][4], int round) {
	int warray[4];
	int i,j;
	for(i = 0; i < 4; i++) {
		intToArray(w[round*4 + i], warray);
		for(j = 0; j < 4; j++) {
			array[j][i] = array[j][i] ^ warray[j];
		}
	}
}

// Assembly:
shll $0x2, %esi
movslq %esi, %rax
xorl %ecx, %ecx
leaq 0xb689e(%rip), %rdx     # 0xbcce0
movl $0xff, %esi
leaq (%rcx,%rax), %r8
movl (%rdx,%r8,4), %r8d
movl %r8d, %r9d
shrl $0x18, %r9d
movl %r9d, -0x18(%rsp)
movl %r8d, %r9d
shrl $0x10, %r9d
andl %esi, %r9d
movl %r9d, -0x14(%rsp)
movl %r8d, %r9d
shrl $0x8, %r9d
andl %esi, %r9d
movl %r9d, -0x10(%rsp)
andl %esi, %r8d
movl %r8d, -0xc(%rsp)
xorl %r8d, %r8d
movl -0x18(%rsp,%r8), %r9d
xorl %r9d, (%rdi,%r8,4)
addq $0x4, %r8
cmpq $0x10, %r8
jne 0x6484
incq %rcx
addq $0x4, %rdi
cmpq $0x4, %rcx
jne 0x6447
retq
// File: /workspace/github_cpp_makefile_star2_O3/renzibei[P]TSProxy/aes.cpp
// Function: showStr(char*)
void showStr(char *str){
	int i;
	for(i=0;i<16;i++)
		printf("%02x", (unsigned char)str[i]);
		// printf("%c", (unsigned char)str[i]);
	printf("\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x1f1c(%rip), %r14      # 0x83d0
xorl %r15d, %r15d
movzbl (%rbx,%r15), %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x2050
incq %r15
cmpq $0x10, %r15
jne 0x64b7
movl $0xa, %edi
popq %rbx
popq %r14
popq %r15
jmp 0x2290
// File: /workspace/github_cpp_makefile_star2_O3/renzibei[P]TSProxy/aes.cpp
// Function: compute_hh(unsigned char (&) [16])
int compute_hh(unsigned char (&h)[16])
{//计算h<<1，h<<2，h<<3，....h<<127；p(x)=x128+ x7 + x2 +x + 1; 
		int i,msb,j;    
	memcpy(hh[0],h,16);//hh[0]=h
	for(i=1;i<128;i++)
	{
		msb=hh[i-1][0]>>7;//最高位
		for(j=0;j<15;j++)//h[i]=h[i-1]<<1 | ...
			hh[i][j] = ((hh[i-1][j]<<1) | (hh[i-1][j+1]>>7)) &255;
		hh[i][15] = hh[i-1][15]<<1;
		if(msb==1)
			hh[i][15] ^= 0x87;
	}
	return 0;
}

// Assembly:
pushq %rbx
movups (%rdi), %xmm0
movaps %xmm0, 0xb5ff7(%rip)    # 0xbc4e0
movl $0x1, %eax
leaq 0xb5ffb(%rip), %rcx     # 0xbc4f0
leaq 0xb5fe4(%rip), %rdx     # 0xbc4e0
movq %rax, %rsi
shlq $0x4, %rsi
leaq (%rsi,%rdx), %r8
addq $-0x10, %r8
movb (%r8), %dil
movq $-0xf, %r9
movl %edi, %r10d
movb (%rcx,%r9), %r11b
movl %r11d, %ebx
shrb $0x7, %bl
addb %r10b, %r10b
orb %bl, %r10b
movb %r10b, 0xf(%rcx,%r9)
movl %r11d, %r10d
incq %r9
jne 0x6518
movb 0xf(%r8), %r8b
addb %r8b, %r8b
movzbl %r8b, %r9d
xorb $-0x79, %r8b
testb %dil, %dil
movzbl %r8b, %edi
cmovnsl %r9d, %edi
movb %dil, 0xf(%rsi,%rdx)
incq %rax
addq $0x10, %rcx
cmpq $0x80, %rax
jne 0x64fc
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/renzibei[P]TSProxy/aes.cpp
// Function: mult_h(unsigned char (&) [16], unsigned char (&) [16])
static int mult_h(unsigned char (&a)[16],unsigned char (&b)[16])
{//有限域乘法G(2128);注意：a，b不能为同一个地址（b在不停的更新）
	int i,j,k,m;
	memset(b,0,16);
	for(k=0,i=15; i>=0; i--)//从低位开始，数据都是从高位开始的，所以从15开始。
	{//k为从低位开始的计数器
		for(j=0; j<8; j++,k++)
		{
			if( ((a[i]>>j)&1) == 1)//每个字节也从低位开始
			{
				for(m=0;m<16;m++)
					b[m] ^= hh[k][m] ;
			}
		}
	}
	return 0;
}

// Assembly:
xorps %xmm0, %xmm0
movups %xmm0, (%rsi)
movl $0xf, %eax
xorl %ecx, %ecx
leaq 0xb5d9d(%rip), %rdx     # 0xbc4e0
movslq %ecx, %rcx
movq %rcx, %r8
shlq $0x4, %r8
addq %rdx, %r8
xorl %r9d, %r9d
movzbl (%rdi,%rax), %r10d
btl %r9d, %r10d
jae 0x6765
xorps (%r8), %xmm0
movups %xmm0, (%rsi)
addq $0x10, %r8
incq %r9
cmpl $0x8, %r9d
jne 0x6753
addq %r9, %rcx
subq $0x1, %rax
jae 0x6743
retq
// File: /workspace/github_cpp_makefile_star2_O3/renzibei[P]TSProxy/aes.cpp
// Function: encrypt(char*, int, char const*, int, char const (&) [16], char (&) [16], char (&) [16])
int encrypt(char *dst, int dst_size, const char *src, int src_size, const char (&key)[16], char (&random)[16], char (&mac)[16]) {
	int valid_size = (src_size >> 4) << 4;
	if (valid_size < src_size)
		valid_size += 16;
	if (valid_size < src_size + 2) {
		valid_size += 16;
	}
	// static char buf[constants::AES_MAX_DATA_LENGTH];
	
	if (valid_size > constants::AES_MAX_DATA_LENGTH) {
		LogHelper::log(Error, "data size should be no longer than: %lu, but size is: %d", constants::AES_MAX_DATA_LENGTH, valid_size);
		return -5;
	}
	
	if (dst_size < valid_size) {
		LogHelper::log(Error, "dst_size is less than valid size, dst_size: %d, valid_size: %d", dst_size, valid_size);
		return -5;
	}
	char *buf = new char[valid_size];
	memcpy(buf, src, src_size);
	
	//Padding
	memset(buf + src_size, 0, valid_size - src_size);
	buf[src_size] = 0xf;

	int retCode = encode(dst, dst_size, buf, valid_size, key, random, mac);
	delete[] buf;
	if (retCode != 0) {
		LogHelper::log(Error, "Fail to encrypt");
		return retCode;
	}
	
	return valid_size;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, %r13d
movl %ecx, %eax
andl $-0x10, %eax
leal 0x10(%rax), %ecx
cmpl %r13d, %eax
cmovel %eax, %ecx
leal 0x2(%r13), %eax
leal 0x10(%rcx), %ebx
cmpl %eax, %ecx
cmovgel %ecx, %ebx
cmpl $0xffcd, %ebx           # imm = 0xFFCD
jb 0x698e
leaq 0x1afd(%rip), %rsi      # 0x8479
movl $0xffcc, %edx           # imm = 0xFFCC
xorl %edi, %edi
movl %ebx, %ecx
xorl %eax, %eax
callq 0x273c
jmp 0x69a8
movl %esi, %ebp
cmpl %esi, %ebx
jle 0x69be
leaq 0x1b17(%rip), %rsi      # 0x84b2
xorl %edi, %edi
movl %ebp, %edx
movl %ebx, %ecx
xorl %eax, %eax
callq 0x273c
movl $0xfffffffb, %ebx       # imm = 0xFFFFFFFB
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rdx, %r14
movq %rdi, 0x10(%rsp)
movslq %ebx, %rdi
movq %r9, 0x20(%rsp)
movq %r8, 0x18(%rsp)
callq 0x2030
movq %rax, %r15
movslq %r13d, %r12
movq %rax, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x2150
leaq (%r15,%r12), %rdi
movl %ebx, %eax
subl %r13d, %eax
movslq %eax, %rdx
xorl %esi, %esi
callq 0x2120
movb $0xf, (%r15,%r12)
movq 0x60(%rsp), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
movl %ebp, %esi
movq %r15, %rdx
movl %ebx, %ecx
movq 0x18(%rsp), %r8
movq 0x20(%rsp), %r9
callq 0x6567
movl %eax, %ebp
movq %r15, %rdi
callq 0x2240
testl %ebp, %ebp
je 0x69ad
leaq 0x1ab0(%rip), %rsi      # 0x84f1
xorl %edi, %edi
xorl %eax, %eax
callq 0x273c
movl %ebp, %ebx
jmp 0x69ad
// File: /workspace/github_cpp_makefile_star2_O3/renzibei[P]TSProxy/aes.cpp
// Function: testEncodeAndDecode()
int testEncodeAndDecode() {
	char key[16], random[16], mac[16];
	for (int i = 0; i < 16; ++i) {
		key[i] = rand() & 0xff;
	}
	char text[30] = "12345678901234566543210987654";
	for (int i = 0; i < sizeof(text) - 1; i++) {
		text[i] -= '0';
	}
	char buf[60] = {0};
	int codeLen = encrypt(buf, sizeof(buf), text, sizeof(text) - 1, key, random, mac);
	if (codeLen < 0) {
		printf("encode error, ret :%d", codeLen);
		return codeLen;
	}
	printf("after encode:\n");
	
	for(int i = 0; i < codeLen; ++i) {
		printf("%u ", buf[i]);
	}
	printf("\n");
	memset(text, 0, sizeof(text));
	// memset(random, 0, 2);
	codeLen = decrypt(text, sizeof(text), buf, codeLen, key, random, mac);
	if (codeLen < 0) {
		printf("decode error, ret :%d", codeLen);
		return codeLen;
	}
	printf("after decode:\n");
	for(int i = 0; i < codeLen; ++i) {
		printf("%u ", text[i]);
	}
	printf("\n");
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa0, %rsp
xorl %ebx, %ebx
callq 0x2090
movb %al, 0x30(%rsp,%rbx)
incq %rbx
cmpq $0x10, %rbx
jne 0x6bd9
movups 0x1a3c(%rip), %xmm0     # 0x862e
movups %xmm0, 0x1e(%rsp)
movaps 0x1a22(%rip), %xmm0     # 0x8620
movaps %xmm0, 0x10(%rsp)
xorl %eax, %eax
addb $-0x30, 0x10(%rsp,%rax)
incq %rax
cmpq $0x1d, %rax
jne 0x6c05
xorps %xmm0, %xmm0
leaq 0x60(%rsp), %rdi
movups %xmm0, 0x2c(%rdi)
movaps %xmm0, 0x20(%rdi)
movaps %xmm0, 0x10(%rdi)
movaps %xmm0, (%rdi)
leaq 0x50(%rsp), %r15
movq %r15, (%rsp)
leaq 0x10(%rsp), %rdx
leaq 0x30(%rsp), %r8
leaq 0x40(%rsp), %r9
movl $0x3c, %esi
movl $0x1d, %ecx
callq 0x6942
movl %eax, %ebx
testl %eax, %eax
js 0x6d11
leaq 0x1994(%rip), %rdi      # 0x85f6
callq 0x22c0
testl %ebx, %ebx
je 0x6c90
movl %ebx, %r12d
leaq 0x1967(%rip), %r14      # 0x85dc
xorl %r13d, %r13d
movsbl 0x60(%rsp,%r13), %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x2050
incq %r13
cmpq %r13, %r12
jne 0x6c78
movl $0xa, %edi
callq 0x2290
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rdi
movaps %xmm0, (%rdi)
movups %xmm0, 0xe(%rdi)
movq %r15, (%rsp)
leaq 0x60(%rsp), %rdx
leaq 0x30(%rsp), %r8
leaq 0x40(%rsp), %r9
movl $0x1e, %esi
movl %ebx, %ecx
callq 0x6a51
movl %eax, %ebx
testl %eax, %eax
js 0x6d1a
leaq 0x192f(%rip), %rdi      # 0x8604
callq 0x22c0
testl %ebx, %ebx
je 0x6d03
movl %ebx, %r14d
leaq 0x18f4(%rip), %rbx      # 0x85dc
xorl %r15d, %r15d
movsbl 0x10(%rsp,%r15), %esi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2050
incq %r15
cmpq %r15, %r14
jne 0x6ceb
movl $0xa, %edi
callq 0x2290
xorl %ebx, %ebx
jmp 0x6d2a
leaq 0x18ae(%rip), %rdi      # 0x85c6
jmp 0x6d21
leaq 0x18bf(%rip), %rdi      # 0x85e0
movl %ebx, %esi
xorl %eax, %eax
callq 0x2050
movl %ebx, %eax
addq $0xa0, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/renzibei[P]TSProxy/aes.cpp
// Function: GFMul(int, int)
static int GFMul(int n, int s) {
	int result;

	if(n == 1)
		result = s;
	else if(n == 2)
		result = GFMul2(s);
	else if(n == 3)
		result = GFMul3(s);
	else if(n == 0x9)
		result = GFMul9(s);
	else if(n == 0xb)//11
		result = GFMul11(s);
	else if(n == 0xd)//13
		result = GFMul13(s);
	else if(n == 0xe)//14
		result = GFMul14(s);

	return result;
}

// Assembly:
movl %esi, %eax
addl $-0x2, %edi
cmpl $0xc, %edi
ja 0x6dd1
leaq 0x11ce(%rip), %rcx      # 0x7f20
movslq (%rcx,%rdi,4), %rdx
addq %rcx, %rdx
jmpq *%rdx
leal (%rax,%rax), %ecx
movzbl %cl, %edx
xorl $0x1b, %edx
testb %al, %al
cmovnsl %ecx, %edx
jmp 0x6de2
leal (%rax,%rax), %ecx
movl $0xff, %edx
movl %ecx, %esi
andl %edx, %esi
xorl $0x1b, %esi
testb %al, %al
cmovnsl %ecx, %esi
leal (%rsi,%rsi), %ecx
movl %ecx, %edi
andl %edx, %edi
xorl $0x1b, %edi
testb %sil, %sil
cmovnsl %ecx, %edi
leal (%rdi,%rdi), %ecx
andl %ecx, %edx
xorl $0x1b, %edx
testb %dil, %dil
jmp 0x6ddd
leal (%rax,%rax), %edx
movl $0xff, %ecx
movl %edx, %esi
andl %ecx, %esi
xorl $0x1b, %esi
testb %al, %al
cmovnsl %edx, %esi
leal (%rsi,%rsi), %edx
movl %edx, %eax
andl %ecx, %eax
xorl $0x1b, %eax
testb %sil, %sil
cmovnsl %edx, %eax
leal (%rax,%rax), %edx
andl %edx, %ecx
xorl $0x1b, %ecx
testb %al, %al
cmovnsl %edx, %ecx
xorl %esi, %eax
xorl %ecx, %eax
retq
leal (%rax,%rax), %ecx
movzbl %cl, %edx
xorl $0x1b, %edx
testb %al, %al
cmovnsl %ecx, %edx
xorl %eax, %edx
movl %edx, %eax
retq
leal (%rax,%rax), %esi
movl $0xff, %ecx
movl %esi, %edx
andl %ecx, %edx
xorl $0x1b, %edx
testb %al, %al
cmovnsl %esi, %edx
leal (%rdx,%rdx), %esi
movl %esi, %edi
andl %ecx, %edi
xorl $0x1b, %edi
testb %dl, %dl
cmovnsl %esi, %edi
leal (%rdi,%rdi), %esi
andl %esi, %ecx
xorl $0x1b, %ecx
testb %dil, %dil
cmovnsl %esi, %ecx
xorl %eax, %edx
xorl %ecx, %edx
movl %edx, %eax
retq
leal (%rax,%rax), %edx
movl $0xff, %ecx
movl %edx, %esi
andl %ecx, %esi
xorl $0x1b, %esi
testb %al, %al
cmovnsl %edx, %esi
leal (%rsi,%rsi), %edx
movl %edx, %edi
andl %ecx, %edi
xorl $0x1b, %edi
testb %sil, %sil
cmovnsl %edx, %edi
leal (%rdi,%rdi), %edx
andl %edx, %ecx
xorl $0x1b, %ecx
testb %dil, %dil
cmovnsl %edx, %ecx
xorl %eax, %edi
xorl %ecx, %edi
movl %edi, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/millanek[P]evo/./process_vcf_utils.h
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> numToString<double>(double)
std::string numToString(T i) {
    std::string ret;
    std::stringstream out;
    out << i;
    ret = out.str();
    return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x1b0, %rsp            # imm = 0x1B0
movsd %xmm0, (%rsp)
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq 0x28(%rsp), %rdi
callq 0x8320
leaq 0x38(%rsp), %rdi
movsd (%rsp), %xmm0
callq 0x8730
leaq 0x40(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x8700
leaq 0x8(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8540
movq (%r14), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x42f89
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x8480
movq 0xbefd8(%rip), %rsi     # 0x101f68
leaq 0x28(%rsp), %rdi
callq 0x8370
leaq 0xa8(%rsp), %rdi
callq 0x8190
movq %rbx, %rax
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
popq %r14
popq %r15
retq
jmp 0x42fb9
movq %rax, %r14
movq 0xbefa5(%rip), %rsi     # 0x101f68
leaq 0x28(%rsp), %rdi
callq 0x8370
leaq 0xa8(%rsp), %rdi
callq 0x8190
jmp 0x42fdf
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x42ff2
movq (%r15), %rsi
incq %rsi
callq 0x8480
movq %r14, %rdi
callq 0x8840
// File: /workspace/github_cpp_makefile_star2_O3/millanek[P]evo/./process_vcf_annotation_tools.h
// Function: LinkedCoordsBed::getElementNames[abi:cxx11]()
std::vector<string> getElementNames() {
        std::vector<string> elementNames;
        for (int i = 0; i < (int)elementCoordsVector.size(); i++) {
            std::vector<std::vector<string> > thisElement = elementCoordsVector[i];
            //if (thisElement[0].size() < 4) {
            //    std::cerr << "thisElement[0].size()" << thisElement.size() << std::endl;
            //}
            elementNames.push_back(thisElement[0][3]);
        }
        return elementNames;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq (%rsi), %rsi
movq 0x8(%r14), %rax
subq %rsi, %rax
shrq $0x3, %rax
imull $0xaaaaaaab, %eax, %eax # imm = 0xAAAAAAAB
testl %eax, %eax
jle 0x2ee97
xorl %r12d, %r12d
leaq 0x8(%rsp), %r15
xorl %r13d, %r13d
addq %r12, %rsi
movq %r15, %rdi
callq 0x30dd2
movq 0x8(%rsp), %rax
movq (%rax), %rsi
addq $0x60, %rsi
movq %rbx, %rdi
callq 0x3133c
movq %r15, %rdi
callq 0x2efec
incq %r13
movq (%r14), %rsi
movq 0x8(%r14), %rax
subq %rsi, %rax
shrq $0x3, %rax
imull $0xaaaaaaab, %eax, %eax # imm = 0xAAAAAAAB
cltq
addq $0x18, %r12
cmpq %rax, %r13
jl 0x2ee4e
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
jmp 0x2eeba
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x2efec
movq %rbx, %rdi
callq 0x2e784
movq %r14, %rdi
callq 0x8840
// File: /workspace/github_cpp_makefile_star2_O3/millanek[P]evo/./process_vcf_annotation_tools.h
// Function: LinkedCoordsBed::getElementOuterBoundaries[abi:cxx11]()
std::vector<std::vector<string> > getElementOuterBoundaries() {
        std::vector<std::vector<string> > allOuterBounds;
        for (int i = 0; i < (int)elementCoordsVector.size(); i++) {
            std::vector<std::vector<string> > thisElement = elementCoordsVector[i];
            //if (thisElement[0].size() < 4) {
            //    std::cerr << "thisElement[0].size()" << thisElement.size() << std::endl;
            //}
            std::vector<string> elementOuterBounds;
            elementOuterBounds.push_back(thisElement[0][0]);
            elementOuterBounds.push_back(thisElement[0][1]);
            elementOuterBounds.push_back(thisElement.back()[2]);
            allOuterBounds.push_back(elementOuterBounds);
        }
        return allOuterBounds;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq (%rsi), %rsi
movq 0x8(%r14), %rax
subq %rsi, %rax
shrq $0x3, %rax
imull $0xaaaaaaab, %eax, %eax # imm = 0xAAAAAAAB
testl %eax, %eax
jle 0x2efad
xorl %r13d, %r13d
leaq 0x8(%rsp), %r15
leaq 0x20(%rsp), %r12
xorl %ebp, %ebp
addq %r13, %rsi
movq %r15, %rdi
callq 0x30dd2
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movq $0x0, 0x30(%rsp)
movq 0x8(%rsp), %rax
movq (%rax), %rsi
movq %r12, %rdi
callq 0x3133c
movq 0x8(%rsp), %rax
movq (%rax), %rsi
addq $0x20, %rsi
movq %r12, %rdi
callq 0x3133c
movq 0x10(%rsp), %rax
movq -0x18(%rax), %rsi
addq $0x40, %rsi
movq %r12, %rdi
callq 0x3133c
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2f876
movq %r12, %rdi
callq 0x2e784
movq %r15, %rdi
callq 0x2efec
incq %rbp
movq (%r14), %rsi
movq 0x8(%r14), %rax
subq %rsi, %rax
shrq $0x3, %rax
imull $0xaaaaaaab, %eax, %eax # imm = 0xAAAAAAAB
cltq
addq $0x18, %r13
cmpq %rax, %rbp
jl 0x2ef17
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x2efdb
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x2e784
leaq 0x8(%rsp), %rdi
callq 0x2efec
movq %rbx, %rdi
callq 0x2efec
movq %r14, %rdi
callq 0x8840
nop
// File: /workspace/github_cpp_makefile_star2_O3/millanek[P]evo/./process_vcf_utils.h
// Function: void print_vector<std::deque<int, std::allocator<int>>>(std::deque<int, std::allocator<int>>, std::ostream&, char, bool)
void print_vector(T vector, std::ostream& outFile, char delim = '\t', bool endLine = true) {
    for (int i = 0; i < vector.size(); i++) {
        if (i == (vector.size()-1)) {
            if (endLine) outFile << vector[i] << std::endl;
            else outFile << vector[i];
        } else {
            outFile << vector[i] << delim;
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %r13d
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
xorl %r12d, %r12d
xorl %ebx, %ebx
movl %ecx, 0x4(%rsp)
movq 0x48(%r15), %rcx
movq 0x28(%r15), %rax
movq %rcx, %rdi
subq %rax, %rdi
shrq $0x3, %rdi
cmpq $0x1, %rcx
adcq $-0x1, %rdi
shlq $0x7, %rdi
movq 0x30(%r15), %rcx
subq 0x38(%r15), %rcx
sarq $0x2, %rcx
movq 0x10(%r15), %rdx
movq 0x20(%r15), %rsi
subq %rdx, %rsi
sarq $0x2, %rsi
addq %rcx, %rsi
addq %rdi, %rsi
cmpq %rbx, %rsi
jbe 0x4789c
movq %rdx, %rcx
subq 0x18(%r15), %rcx
decq %rsi
sarq $0x2, %rcx
addq %rbx, %rcx
cmpq %rsi, %rbx
jne 0x47792
testb %r13b, %r13b
je 0x477a5
testq %rcx, %rcx
js 0x47807
cmpq $0x7f, %rcx
ja 0x47819
addq %r12, %rdx
movq %rdx, %rcx
jmp 0x47832
testq %rcx, %rcx
js 0x477bf
cmpq $0x7f, %rcx
ja 0x477c8
addq %r12, %rdx
movq %rdx, %rcx
jmp 0x477e1
testq %rcx, %rcx
js 0x47810
cmpq $0x7f, %rcx
ja 0x4786d
addq %r12, %rdx
movq %rdx, %rcx
jmp 0x47886
movq %rcx, %rdx
sarq $0x7, %rdx
jmp 0x477cf
movq %rcx, %rdx
shrq $0x7, %rdx
movq %rdx, %rsi
shlq $0x7, %rsi
subq %rsi, %rcx
shlq $0x2, %rcx
addq (%rax,%rdx,8), %rcx
movl (%rcx), %esi
movq %r14, %rdi
callq 0x8810
movb %bpl, 0x3(%rsp)
movl $0x1, %edx
movq %rax, %rdi
leaq 0x3(%rsp), %rsi
callq 0x84e0
jmp 0x47890
movq %rcx, %rdx
sarq $0x7, %rdx
jmp 0x47820
movq %rcx, %rdx
sarq $0x7, %rdx
jmp 0x47874
movq %rcx, %rdx
shrq $0x7, %rdx
movq %rdx, %rsi
shlq $0x7, %rsi
subq %rsi, %rcx
shlq $0x2, %rcx
addq (%rax,%rdx,8), %rcx
movl (%rcx), %esi
movq %r14, %rdi
callq 0x8810
movq %rax, %r13
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x8450
movsbl %al, %esi
movq %r13, %rdi
callq 0x8040
movq %rax, %rdi
callq 0x8300
movl 0x4(%rsp), %r13d
jmp 0x47890
movq %rcx, %rdx
shrq $0x7, %rdx
movq %rdx, %rsi
shlq $0x7, %rsi
subq %rsi, %rcx
shlq $0x2, %rcx
addq (%rax,%rdx,8), %rcx
movl (%rcx), %esi
movq %r14, %rdi
callq 0x8810
incq %rbx
addq $0x4, %r12
jmp 0x47711
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/millanek[P]evo/evo_abba_baba.cpp
// Function: getAAfromInfo(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>>>> const&)
inline std::string getAAfromInfo(const std::vector<std::string>& info) {
    string AA = "?";
    for (std::vector<std::string>::size_type i = 0; i != info.size(); i++) {
        string infoKey = split(info[i],'=')[0];
        if (infoKey == "AA") {
            AA = split(info[i],'=')[1];
        }
    }
    return AA;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
leaq 0x10(%rdi), %rax
movq %rax, 0x8(%rsp)
movq %rax, (%rdi)
leaq 0xa3484(%rip), %rsi     # 0xda8b3
leaq 0xa347e(%rip), %rdx     # 0xda8b4
movq %rdi, (%rsp)
callq 0x28a52
movq (%r14), %rsi
cmpq %rsi, 0x8(%r14)
je 0x37509
leaq 0x20(%rsp), %rbp
xorl %ebx, %ebx
leaq 0x30(%rsp), %r15
leaq 0x10(%rsp), %r12
xorl %r13d, %r13d
addq %rbx, %rsi
movq %r15, %rdi
movl $0x3d, %edx
callq 0x4d650
movq 0x30(%rsp), %rax
movq %rbp, 0x10(%rsp)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
movq %r12, %rdi
callq 0x2ba06
movq %r15, %rdi
callq 0x2e784
movq %r12, %rdi
leaq 0x92bd1(%rip), %rsi     # 0xca06f
callq 0x8160
testl %eax, %eax
jne 0x374d4
movq (%r14), %rsi
addq %rbx, %rsi
movq %r15, %rdi
movl $0x3d, %edx
callq 0x4d650
movq 0x30(%rsp), %rsi
addq $0x20, %rsi
movq (%rsp), %rdi
callq 0x8270
movq %r15, %rdi
callq 0x2e784
movq 0x10(%rsp), %rdi
cmpq %rbp, %rdi
je 0x374eb
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x8480
incq %r13
movq (%r14), %rsi
movq 0x8(%r14), %rax
subq %rsi, %rax
sarq $0x5, %rax
addq $0x20, %rbx
cmpq %rax, %r13
jne 0x37460
movq (%rsp), %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x30(%rsp), %rdi
callq 0x2e784
jmp 0x3752e
movq %rax, %r14
movq 0x10(%rsp), %rdi
cmpq %rbp, %rdi
je 0x37559
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x8480
jmp 0x37559
movq %rax, %r14
jmp 0x37559
movq %rax, %r14
leaq 0x30(%rsp), %rdi
callq 0x2e784
movq (%rsp), %rax
movq (%rax), %rdi
cmpq 0x8(%rsp), %rdi
je 0x37577
movq 0x8(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x8480
movq %r14, %rdi
callq 0x8840
nop
// File: /workspace/github_cpp_makefile_star2_O3/millanek[P]evo/./process_vcf_annotation_tools.h
// Function: Annotation::getTranscriptName(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool&)
std::string getTranscriptName(const string& geneColumn, bool& bPartial) {
        string thisTranscriptName;
        std::vector<string> findIfPartial = split(geneColumn, '-');
        if (findIfPartial.size() == 2) {
            bPartial = true;
            thisTranscriptName = findIfPartial[1];
        } else if (findIfPartial.size() == 1) {
            thisTranscriptName = geneColumn;
        }
        return thisTranscriptName;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r15
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq %rsp, %rdi
movq %rdx, %rsi
movl $0x2d, %edx
callq 0x4d650
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
subq %rax, %rcx
sarq $0x5, %rcx
cmpq $0x1, %rcx
je 0x3bb46
cmpq $0x2, %rcx
jne 0x3bb51
movb $0x1, (%r15)
addq $0x20, %rax
movq %rax, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8270
movq %rsp, %rdi
callq 0x2e784
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rsp, %rdi
callq 0x2e784
jmp 0x3bb78
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x3bb8c
movq (%r12), %rsi
incq %rsi
callq 0x8480
movq %r14, %rdi
callq 0x8840
// File: /workspace/github_cpp_makefile_star2_O3/millanek[P]evo/process_vcf_cbs.cpp
// Function: numToStringVector[abi:cxx11](std::vector<int, std::allocator<int>>&)
std::vector<string> numToStringVector(std::vector<int>& vec) {
    std::vector<string> converted;
    for (std::vector<int>::size_type i = 0; i != vec.size(); i++) {
        converted.push_back(numToString(vec[i]));
    }
    return converted;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq (%rsi), %rax
cmpq %rax, 0x8(%rsi)
je 0x4437b
movq %rsi, %r14
leaq 0x10(%rsp), %r12
xorl %r13d, %r13d
movq %rsp, %r15
movl (%rax,%r13,4), %esi
movq %r15, %rdi
callq 0x2e7e2
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3e784
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x44365
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x8480
incq %r13
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %rcx, %r13
jne 0x44338
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
jmp 0x443aa
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x443aa
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x8480
movq %rbx, %rdi
callq 0x2e784
movq %r14, %rdi
callq 0x8840
// File: /workspace/github_cpp_makefile_star2_O3/millanek[P]evo/process_vcf_cbs.cpp
// Function: numToStringMinFilterVector[abi:cxx11](std::vector<int, std::allocator<int>>&, int)
std::vector<string> numToStringMinFilterVector(std::vector<int>& vec, int min) {
    std::vector<string> converted;
    for (std::vector<int>::size_type i = 0; i != vec.size(); i++) {
        if (vec[i] >= min)
            converted.push_back(numToString(vec[i]));
    }
    return converted;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq (%rsi), %rax
movq 0x8(%rsi), %rcx
cmpq %rax, %rcx
je 0x44442
movl %edx, %ebp
movq %rsi, %r14
leaq 0x18(%rsp), %r12
xorl %r13d, %r13d
leaq 0x8(%rsp), %r15
movl (%rax,%r13,4), %esi
cmpl %ebp, %esi
jl 0x44430
movq %r15, %rdi
callq 0x2e7e2
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3e784
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x44429
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x8480
movq (%r14), %rax
movq 0x8(%r14), %rcx
incq %r13
movq %rcx, %rdx
subq %rax, %rdx
sarq $0x2, %rdx
cmpq %rdx, %r13
jne 0x443f7
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x44473
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x44473
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x8480
movq %rbx, %rdi
callq 0x2e784
movq %r14, %rdi
callq 0x8840
// File: /workspace/github_cpp_makefile_star2_O3/millanek[P]evo/process_vcf_cbs.cpp
// Function: cbsMain(int, char**)
int cbsMain(int argc, char** argv) {
    parseCbsOptions(argc, argv);
    
    if (!opt::vcfFile.empty()) {
        std::cerr << "Calculating the lenghts of cbs tracts from: " << opt::vcfFile << std::endl;
        std::cerr << "and using information about scaffold lengths and the location of undetermined regions from: " << opt::undeterminedLociFile << std::endl;
        calculateCbs();
    } else if (!opt::genomeFile.empty()) {
        std::cerr << "Looking for undetermined regions (runs of Ns) in the reference genome: " << std::endl;
        std::cerr << opt::genomeFile << std::endl;
        findUndeterminedRegions();
    } else {
        assert(false);
    }
    
    return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
callq 0x4627d
cmpq $0x0, 0xbcf43(%rip)     # 0x103048
jne 0x461aa
cmpq $0x0, 0xbcf55(%rip)     # 0x103068
je 0x4625e
movq 0xbbec8(%rip), %rbx     # 0x101fe8
leaq 0x8904a(%rip), %rsi     # 0xcf171
movl $0x47, %edx
movq %rbx, %rdi
callq 0x84e0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x8450
movsbl %al, %esi
movq %rbx, %rdi
callq 0x8040
movq %rax, %rdi
callq 0x8300
movq 0xbcefe(%rip), %rsi     # 0x103060
movq 0xbceff(%rip), %rdx     # 0x103068
movq %rbx, %rdi
callq 0x84e0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x8450
movsbl %al, %esi
movq %rbx, %rdi
callq 0x8040
movq %rax, %rdi
callq 0x8300
callq 0x43e30
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0xbbe37(%rip), %rbx     # 0x101fe8
leaq 0x88f2f(%rip), %rsi     # 0xcf0e7
movl $0x2c, %edx
movq %rbx, %rdi
callq 0x84e0
movq 0xbce74(%rip), %rsi     # 0x103040
movq 0xbce75(%rip), %rdx     # 0x103048
movq %rbx, %rdi
callq 0x84e0
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x8450
movsbl %al, %esi
movq %r14, %rdi
callq 0x8040
movq %rax, %rdi
callq 0x8300
leaq 0x88f08(%rip), %rsi     # 0xcf114
movl $0x5c, %edx
movq %rbx, %rdi
callq 0x84e0
movq 0xbcec0(%rip), %rsi     # 0x1030e0
movq 0xbcec1(%rip), %rdx     # 0x1030e8
movq %rbx, %rdi
callq 0x84e0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x8450
movsbl %al, %esi
movq %rbx, %rdi
callq 0x8040
movq %rax, %rdi
callq 0x8300
callq 0x44498
leaq 0x88f54(%rip), %rdi     # 0xcf1b9
leaq 0x88d68(%rip), %rsi     # 0xcefd4
leaq 0x88f4c(%rip), %rcx     # 0xcf1bf
movl $0x176, %edx            # imm = 0x176
callq 0x82c0
// File: /workspace/github_cpp_makefile_star2_O3/millanek[P]evo/./process_vcf_seq_utils.h
// Function: readScaffold(std::basic_ifstream<char, std::char_traits<char>>*&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
inline std::string readScaffold(std::ifstream*& genomeFile, std::string& nextScaffoldName) {
    std::string scaffoldString;
    scaffoldString.reserve(100000000);
    std::string line = "";
    while (getline(*genomeFile, line) && line[0] != '>') {
        scaffoldString.append(line);
    }
    if (line[0] == '>')
        nextScaffoldName = split(line,' ')[0];
    else
        nextScaffoldName = "";
    return scaffoldString;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %rbp
movq %rbp, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movl $0x5f5e100, %esi        # imm = 0x5F5E100
callq 0x86f0
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x87395(%rip), %rdx     # 0xcd9cb
movq %rsp, %rdi
movq %rdx, %rsi
callq 0x28a52
movq %rsp, %r12
movq (%r15), %r13
movq (%r13), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x8450
movsbl %al, %edx
movq %r13, %rdi
movq %r12, %rsi
callq 0x8870
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
movq (%rsp), %rsi
movb (%rsi), %al
jne 0x46691
cmpb $0x3e, %al
je 0x46695
movq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x8180
jmp 0x46644
cmpb $0x3e, %al
jne 0x466c0
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
movl $0x20, %edx
callq 0x4d650
movq 0x20(%rsp), %rsi
movq %r14, %rdi
callq 0x8270
leaq 0x20(%rsp), %rdi
callq 0x2e784
jmp 0x466d8
movq 0x8(%r14), %rdx
leaq 0x87300(%rip), %rcx     # 0xcd9cb
movq %r14, %rdi
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x86c0
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x466f3
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x8480
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4671f
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x2e784
jmp 0x46722
jmp 0x4671f
jmp 0x4671a
movq %rax, %r14
jmp 0x4673d
movq %rax, %r14
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x4673d
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x8480
movq (%rbx), %rdi
cmpq %rbp, %rdi
je 0x46751
movq (%rbp), %rsi
incq %rsi
callq 0x8480
movq %r14, %rdi
callq 0x8840
nop
// File: /workspace/github_cpp_makefile_star2_O3/millanek[P]evo/./process_vcf_utils.h
// Function: void print_matrix<std::vector<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>>>>, std::allocator<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>>>>>>>(std::vector<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>>>>, std::allocator<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>>>>>>, std::ostream&)
void print_matrix(T matrix, std::ostream& outFile) {
    for (int i = 0; i < matrix.size(); i++) {
        for (int j = 0; j < matrix[i].size(); j++) {
            if (j == (matrix[i].size()-1))
                outFile << matrix[i][j] << std::endl;
            else 
                outFile << matrix[i][j] << "\t";
        }    
    }    
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, 0x10(%rsp)
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
cmpq %rax, %rcx
je 0x47506
movq %rdi, %r14
xorl %esi, %esi
leaq (%rsi,%rsi,2), %rbp
movq (%rax,%rbp,8), %rdx
movq 0x8(%rax,%rbp,8), %rbx
subq %rdx, %rbx
je 0x474e2
movq %rsi, 0x8(%rsp)
sarq $0x5, %rbx
movl $0x8, %r15d
xorl %r13d, %r13d
decq %rbx
movq -0x8(%rdx,%r15), %rsi
movq (%rdx,%r15), %rdx
movq 0x10(%rsp), %rdi
callq 0x84e0
movq %rax, %r12
cmpq %rbx, %r13
jne 0x474a6
movq (%r12), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x8450
movsbl %al, %esi
movq %r12, %rdi
callq 0x8040
movq %rax, %rdi
callq 0x8300
jmp 0x474ba
movl $0x1, %edx
movq %r12, %rdi
leaq 0x86515(%rip), %rsi     # 0xcd9ca
callq 0x84e0
incq %r13
movq (%r14), %rax
movq (%rax,%rbp,8), %rdx
movq 0x8(%rax,%rbp,8), %rbx
subq %rdx, %rbx
sarq $0x5, %rbx
addq $0x20, %r15
cmpq %r13, %rbx
ja 0x4745e
movq 0x8(%r14), %rcx
movq 0x8(%rsp), %rsi
incq %rsi
movq %rcx, %rdx
subq %rax, %rdx
sarq $0x3, %rdx
movabsq $-0x5555555555555555, %rdi # imm = 0xAAAAAAAAAAAAAAAB
imulq %rdi, %rdx
cmpq %rsi, %rdx
ja 0x47436
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/millanek[P]evo/./process_vcf_utils.h
// Function: double vector_average<std::deque<int, std::allocator<int>>>(std::deque<int, std::allocator<int>>)
double vector_average(T vector) {
    double sum = 0;
    for (int i = 0; i < vector.size(); i++) {
        sum += vector[i];
    }
    double average = (double)sum / (double)vector.size();
    return average;
}

// Assembly:
movq 0x48(%rdi), %rcx
movq 0x28(%rdi), %rax
movq %rcx, %rdx
subq %rax, %rdx
shrq $0x3, %rdx
cmpq $0x1, %rcx
adcq $-0x1, %rdx
movq 0x30(%rdi), %rsi
subq 0x38(%rdi), %rsi
shlq $0x7, %rdx
sarq $0x2, %rsi
addq %rdx, %rsi
movq 0x10(%rdi), %rdx
movq 0x20(%rdi), %rcx
subq %rdx, %rcx
sarq $0x2, %rcx
addq %rsi, %rcx
je 0x475c3
pushq %rbx
movq %rdx, %rsi
subq 0x18(%rdi), %rsi
sarq $0x2, %rsi
xorpd %xmm0, %xmm0
xorl %edi, %edi
movq %rcx, %r8
movq %rsi, %r9
testq %r9, %r9
js 0x47588
movq %rdx, %r11
cmpq $0x80, %r9
jb 0x475a5
movq %r9, %r10
shrq $0x7, %r10
jmp 0x4758f
movq %r9, %r10
sarq $0x7, %r10
leaq (%rsi,%rdi), %r11
movq %r10, %rbx
shlq $0x7, %rbx
subq %rbx, %r11
shlq $0x2, %r11
addq (%rax,%r10,8), %r11
xorps %xmm1, %xmm1
cvtsi2sdl (%r11), %xmm1
addsd %xmm1, %xmm0
incq %rdi
addq $0x4, %rdx
incq %r9
decq %r8
jne 0x4756e
popq %rbx
jmp 0x475c7
xorpd %xmm0, %xmm0
xorps %xmm1, %xmm1
cvtsi2sd %rcx, %xmm1
divsd %xmm1, %xmm0
retq