LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: OpenFodder[P]SOS_Unpacker/capsimg/Core/MemoryFile.cpp
// Function: CMemoryFile::Write(void*, unsigned long)
size_t CMemoryFile::Write(void *buf, size_t size)
{
	// stop if: nothing to write; buffer is invalid; file is not open; file is read-only
	if (!buf || !size || filemt == mtLast || !(filemode & BFFLAG_WRITE))
		return 0;

	// grow class owned file buffer if needed
	if (filemt == mtAlloc)
		AllocBuffer(filepos+size);

	// limit writeable size to buffer size
	if (filesize[filemt]-filepos < size)
		size=filesize[filemt]-filepos;

	// write into file, update stream position
	if (size) {
		memcpy(filebuf[filemt]+filepos, buf, size);
		filepos+=size;

		// update valid content count if wrote past the current file size
		if (filepos > filecount)
			filecount=filepos;
	}

	return size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x19ba3
cmpq $0x0, -0x20(%rbp)
je 0x19ba3
movq -0x28(%rbp), %rax
cmpl $0x2, 0x10(%rax)
je 0x19ba3
movq -0x28(%rbp), %rax
movl 0xc(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x19bb0
movq $0x0, -0x8(%rbp)
jmp 0x19c4c
movq -0x28(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jne 0x19bcb
movq -0x28(%rbp), %rdi
movq 0x40(%rdi), %rsi
addq -0x20(%rbp), %rsi
callq 0x19960
movq -0x28(%rbp), %rcx
movslq 0x10(%rcx), %rax
movq 0x28(%rcx,%rax,8), %rax
subq 0x40(%rcx), %rax
cmpq -0x20(%rbp), %rax
jae 0x19bf7
movq -0x28(%rbp), %rcx
movslq 0x10(%rcx), %rax
movq 0x28(%rcx,%rax,8), %rax
subq 0x40(%rcx), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x19c44
movq -0x28(%rbp), %rax
movslq 0x10(%rax), %rcx
movq 0x18(%rax,%rcx,8), %rdi
addq 0x40(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x41a0
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
addq 0x40(%rcx), %rax
movq %rax, 0x40(%rcx)
movq 0x40(%rcx), %rax
cmpq 0x38(%rcx), %rax
jbe 0x19c42
movq -0x28(%rbp), %rax
movq 0x40(%rax), %rcx
movq %rcx, 0x38(%rax)
jmp 0x19c44
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: OpenFodder[P]SOS_Unpacker/capsimg/Core/MemoryFile.cpp
// Function: CMemoryFile::Seek(long, int)
long CMemoryFile::Seek(long pos, int mode)
{
	// default result 
	size_t res=0, tmppos;

	// return default result if file is not open
	if (filemt == mtLast)
		return (long)res;

	// seek in file
	switch (mode) {
		case Start:
			filepos=0;
			break;

		case Position:
			if (pos >= 0 && pos <= (long)filecount)
				filepos=pos;
			break;

		case Current:
			tmppos=filepos+pos;
			if (tmppos <= filecount)
				filepos = tmppos;
			break;

		case End:
			filepos=filecount;
			break;

		default:
			return (long)res;
	}

	return (long)filepos;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq $0x0, -0x28(%rbp)
cmpl $0x2, 0x10(%rax)
jne 0x19c92
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x19d30
movl -0x1c(%rbp), %eax
movq %rax, -0x40(%rbp)
subq $0x3, %rax
ja 0x19d1a
movq -0x40(%rbp), %rax
leaq 0x46a2(%rip), %rcx      # 0x1e34c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x38(%rbp), %rax
movq $0x0, 0x40(%rax)
jmp 0x19d24
cmpq $0x0, -0x18(%rbp)
jl 0x19ce2
movq -0x38(%rbp), %rcx
movq -0x18(%rbp), %rax
cmpq 0x38(%rcx), %rax
jg 0x19ce2
movq -0x38(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0x40(%rax)
jmp 0x19d24
movq -0x38(%rbp), %rcx
movq 0x40(%rcx), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq 0x38(%rcx), %rax
ja 0x19d0a
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, 0x40(%rax)
jmp 0x19d24
movq -0x38(%rbp), %rax
movq 0x38(%rax), %rcx
movq %rcx, 0x40(%rax)
jmp 0x19d24
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x19d30
movq -0x38(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: OpenFodder[P]SOS_Unpacker/SOS_Unpacker.cpp
// Function: trackbuffer_shift_bits(unsigned char**, int, int)
void trackbuffer_shift_bits(UBYTE **pBuffer, int d0, int d1) {
    d0 -= 1;
    if (d0 >= 0) {
        UBYTE *buffer = *pBuffer;
        buffer += d1; buffer += d1;
        d1 -= 2;

        do {
            UWORD *a3 = (UWORD*)buffer;
            int	 d2 = d1;
            bool extend = false;

            --a3;
            if (*a3 & 0x8000)
                extend = true;
            *a3 <<= 1;

            do {
                bool extend2 = false;
                --a3;
                if (*a3 & 0x8000)
                    extend2 = true;
                *a3 <<= 1;

                if (extend)
                    *a3 |= 0x01;
                extend = extend2;
            } while (--d2 >= 0);

        } while (--d0 >= 0);
    }

    // Skip past SYNC marker
    while (readLEWord(*pBuffer) == gTrackSyncMarker)
        *pBuffer += 2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0xc(%rbp), %eax
subl $0x1, %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jl 0x19f3a
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movl -0x10(%rbp), %ecx
movq -0x18(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movl -0x10(%rbp), %ecx
movq -0x18(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movl -0x10(%rbp), %eax
subl $0x2, %eax
movl %eax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x24(%rbp)
movb $0x0, -0x25(%rbp)
movq -0x20(%rbp), %rax
addq $-0x2, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movzwl (%rax), %eax
andl $0x8000, %eax           # imm = 0x8000
cmpl $0x0, %eax
je 0x19ebe
movb $0x1, -0x25(%rbp)
movq -0x20(%rbp), %rax
movzwl (%rax), %ecx
shll %ecx
movw %cx, (%rax)
movb $0x0, -0x26(%rbp)
movq -0x20(%rbp), %rax
addq $-0x2, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movzwl (%rax), %eax
andl $0x8000, %eax           # imm = 0x8000
cmpl $0x0, %eax
je 0x19eef
movb $0x1, -0x26(%rbp)
movq -0x20(%rbp), %rax
movzwl (%rax), %ecx
shll %ecx
movw %cx, (%rax)
testb $0x1, -0x25(%rbp)
je 0x19f0e
movq -0x20(%rbp), %rax
movzwl (%rax), %ecx
orl $0x1, %ecx
movw %cx, (%rax)
movb -0x26(%rbp), %al
andb $0x1, %al
movb %al, -0x25(%rbp)
movl -0x24(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, %eax
jge 0x19eca
jmp 0x19f26
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, %eax
jge 0x19e8b
jmp 0x19f3a
jmp 0x19f3c
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x19dc0
movzwl %ax, %eax
cmpl $0x4489, %eax           # imm = 0x4489
jne 0x19f62
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x2, %rcx
movq %rcx, (%rax)
jmp 0x19f3c
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: OpenFodder[P]SOS_Unpacker/SOS_Unpacker.cpp
// Function: sectorFindSync(unsigned char**, unsigned char*)
int sectorFindSync(UBYTE **pBuffer, UBYTE *pBufferEnd) {
    UDWORD	bits_shifted = 0;
    bool	found = false;

    for (; *pBuffer < pBufferEnd && !found; *pBuffer += 2) {
        UDWORD current = swapDWord(readLEDWord(*pBuffer));

        for (bits_shifted = 0; bits_shifted < 16; ++bits_shifted) {
            if (gTrackSyncMarker == (current & 0xFFFF)) {
                found = true;
                break;
            }
            current >>= 1;
        }
    }

    if (*pBuffer >= pBufferEnd)
        return -1;

    // track begins on next word boundry
    if (!bits_shifted)
        *pBuffer += 2;

    // Calculate number of bits shifted
    return (16 - bits_shifted);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movb $0x0, -0x1d(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
xorl %eax, %eax
cmpq -0x18(%rbp), %rcx
movb %al, -0x25(%rbp)
jae 0x19fa5
movb -0x1d(%rbp), %al
xorb $-0x1, %al
movb %al, -0x25(%rbp)
movb -0x25(%rbp), %al
testb $0x1, %al
jne 0x19fae
jmp 0x1a011
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x19de0
movl %eax, %edi
callq 0x19e00
movl %eax, -0x24(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x10, -0x1c(%rbp)
jae 0x19ffc
movl -0x24(%rbp), %ecx
andl $0xffff, %ecx           # imm = 0xFFFF
movl $0x4489, %eax           # imm = 0x4489
cmpl %ecx, %eax
jne 0x19fe9
movb $0x1, -0x1d(%rbp)
jmp 0x19ffc
movl -0x24(%rbp), %eax
shrl %eax
movl %eax, -0x24(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x19fcb
jmp 0x19ffe
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x2, %rcx
movq %rcx, (%rax)
jmp 0x19f8b
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpq -0x18(%rbp), %rax
jb 0x1a027
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1a046
cmpl $0x0, -0x1c(%rbp)
jne 0x1a03b
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x2, %rcx
movq %rcx, (%rax)
movl $0x10, %eax
subl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: OpenFodder[P]SOS_Unpacker/SOS_Unpacker.cpp
// Function: sos_ReadUDWord(unsigned char*&, unsigned char*&)
UDWORD sos_ReadUDWord(UBYTE*&pEven, UBYTE*& pOdd) {
    UDWORD D0 = *(UDWORD*)pEven;
    UDWORD D1 = *(UDWORD*)pOdd;

    pEven += 4;
    pOdd += 4;

    D0 &= 0x55555555;
    D1 &= 0x55555555;

    D1 <<= 1;
    D0 += D1;

    return swapDWord(D0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl (%rax), %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x4, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x4, %rcx
movq %rcx, (%rax)
movl -0x14(%rbp), %eax
andl $0x55555555, %eax       # imm = 0x55555555
movl %eax, -0x14(%rbp)
movl -0x18(%rbp), %eax
andl $0x55555555, %eax       # imm = 0x55555555
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
shll %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %edi
callq 0x19e00
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: OpenFodder[P]SOS_Unpacker/SOS_Unpacker.cpp
// Function: tool_EndianSwap(unsigned char*, unsigned long)
void tool_EndianSwap(UBYTE *pBuffer, size_t pSize) {
    UBYTE *pDest = pBuffer;

    pSize /= 2;

    while (pSize--) {
        UBYTE al = *pBuffer++;
        UBYTE ah = *pBuffer++;

        *pDest++ = ah;
        *pDest++ = al;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
shrq %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x10(%rbp)
cmpq $0x0, %rax
je 0x1a156
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movb (%rax), %al
movb %al, -0x19(%rbp)
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movb (%rax), %al
movb %al, -0x1a(%rbp)
movb -0x1a(%rbp), %cl
movq -0x18(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rbp)
movb %cl, (%rax)
movb -0x19(%rbp), %cl
movq -0x18(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rbp)
movb %cl, (%rax)
jmp 0x1a0ef
popq %rbp
retq
nopl (%rax,%rax)
// File: OpenFodder[P]SOS_Unpacker/stdafx.cpp
// Function: file_select(dirent const*)
int file_select(const struct dirent *entry) {
    std::string name = entry->d_name;

    std::transform(name.begin(), name.end(), name.begin(), ::toupper);

    if (name.find(findType) == std::string::npos)
        return false;

    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x13, %rax
movq %rax, -0x80(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x4430
movq -0x80(%rbp), %rsi
movq -0x78(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0x4320
jmp 0x1d48b
leaq -0x31(%rbp), %rdi
callq 0x4260
leaq -0x30(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x41c0
movq -0x90(%rbp), %rdi
movq %rax, -0x50(%rbp)
callq 0x4150
movq -0x90(%rbp), %rdi
movq %rax, -0x58(%rbp)
callq 0x41c0
movq %rax, -0x60(%rbp)
movq -0x50(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq -0x60(%rbp), %rdx
movq 0x9b05(%rip), %rcx      # 0x26fe0
callq 0x1da00
movq %rax, -0x88(%rbp)
jmp 0x1d4e9
movq -0x88(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x30(%rbp), %rdi
leaq 0xc1b1(%rip), %rsi      # 0x296b0
xorl %eax, %eax
movl %eax, %edx
callq 0x4470
cmpq $-0x1, %rax
jne 0x1d54c
movl $0x0, -0x4(%rbp)
movl $0x1, -0x6c(%rbp)
jmp 0x1d55a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x31(%rbp), %rdi
callq 0x4260
jmp 0x1d56f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x4488
jmp 0x1d56f
movl $0x1, -0x4(%rbp)
movl $0x1, -0x6c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x4488
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x4420
nopl (%rax,%rax)
// File: OpenFodder[P]SOS_Unpacker/stdafx.cpp
// Function: GetLocalTime
void GetLocalTime(LPSYSTEMTIME lpSystemTime)
{
    time_t t = time(NULL);
    struct tm *tp = localtime(&t);

    lpSystemTime->wYear = tp->tm_year + 1900;
    lpSystemTime->wMonth = tp->tm_mon + 1;
    lpSystemTime->wDayOfWeek = tp->tm_wday;
    lpSystemTime->wDay = tp->tm_mday;
    lpSystemTime->wHour = tp->tm_hour;
    lpSystemTime->wMinute = tp->tm_min;
    lpSystemTime->wSecond = tp->tm_sec;
    // we don't have milliseconds in struct tm
    lpSystemTime->wMilliseconds = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x41f0
movq %rax, -0x10(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x4180
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0x14(%rax), %eax
addl $0x76c, %eax            # imm = 0x76C
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, (%rax)
movq -0x18(%rbp), %rax
movl 0x10(%rax), %eax
addl $0x1, %eax
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, 0x2(%rax)
movq -0x18(%rbp), %rax
movl 0x18(%rax), %eax
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, 0x4(%rax)
movq -0x18(%rbp), %rax
movl 0xc(%rax), %eax
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, 0x6(%rax)
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, 0x8(%rax)
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, 0xa(%rax)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movw %ax, %cx
movq -0x8(%rbp), %rax
movw %cx, 0xc(%rax)
movq -0x8(%rbp), %rax
movw $0x0, 0xe(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: TooruAkagi[P]GCIS_Index/gcis_nep_locate.cpp
// Function: alldr(unsigned int*, int*, int*, int, int)
void alldr(unsigned int *D,int *D_2,int *D_3,int i,int round){
    //for(int i=0;i<60;i++){
    int rofs = 0;if(round>1){rofs=dc2s[round-1];}
        printf("\n%d > %d[%d(%d)]:",round,i,D_2[i],D_3[i]);
        for(int j=D_2[i];j<D_2[i+1];j++){printf("%d(%d) ",D[j]+rofs,D[j]);printf("(+%d)",D_3[D[j]+rofs]);
            //if(round>0){alldr(D,D_2,D_3,D[j]+rofs,round-1);}
        }
    //}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
cmpl $0x1, -0x20(%rbp)
jle 0x239e
movl -0x20(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rcx
leaq 0xb318(%rip), %rax      # 0xd6b0
movl (%rax,%rcx,4), %eax
movl %eax, -0x24(%rbp)
movl -0x20(%rbp), %esi
movl -0x1c(%rbp), %edx
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %ecx
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rdi
movl (%rax,%rdi,4), %r8d
leaq 0x6c66(%rip), %rdi      # 0x9028
movb $0x0, %al
callq 0x2030
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
movq -0x10(%rbp), %rcx
movl -0x1c(%rbp), %edx
addl $0x1, %edx
movslq %edx, %rdx
cmpl (%rcx,%rdx,4), %eax
jge 0x2443
movq -0x8(%rbp), %rax
movslq -0x28(%rbp), %rcx
movl (%rax,%rcx,4), %esi
addl -0x24(%rbp), %esi
movq -0x8(%rbp), %rax
movslq -0x28(%rbp), %rcx
movl (%rax,%rcx,4), %edx
leaq 0x6c2e(%rip), %rdi      # 0x903a
movb $0x0, %al
callq 0x2030
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq -0x28(%rbp), %rdx
movl (%rcx,%rdx,4), %ecx
addl -0x24(%rbp), %ecx
movl %ecx, %ecx
movl (%rax,%rcx,4), %esi
leaq 0x6c11(%rip), %rdi      # 0x9042
movb $0x0, %al
callq 0x2030
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x23d7
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: TooruAkagi[P]GCIS_Index/gcis_nep_locate.cpp
// Function: findintop(int*, int, int)
void findintop(int *D_3,int tg,int pofs){ //NS列からtgを探す
    if(DEBUGFLAG==1){printf("\n[%d]を探す(%d)",tg,dc2s[fround-1]);}
    int len = 0;
    for(int y1 = 0;y1<NSsize;y1++){
        if(DEBUGFLAG==1){printf("[%d]答え",NS[y1]);}
        if(NS[y1]==tg-dc2s[fround-1]){
            printf(" %d",len+pofs);
            if(ans<1000 && CHECKFLAG==1){checkans[ans]=len+pofs;}
            ans++;
        }
        len+= D_3[NS[y1]+dc2s[fround-1]];
    }
    //printf("\nend of searching.(%d)[%d]",len,tg);
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl 0xa5b7(%rip), %eax      # 0xd730
jge 0x323a
movq 0xa5a2(%rip), %rax      # 0xd728
movslq -0x18(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl -0xc(%rbp), %ecx
movl 0xa5a2(%rip), %edx      # 0xd738
subl $0x1, %edx
movslq %edx, %rsi
leaq 0xa50d(%rip), %rdx      # 0xd6b0
subl (%rdx,%rsi,4), %ecx
cmpl %ecx, %eax
jne 0x31f8
movl -0x14(%rbp), %esi
addl -0x10(%rbp), %esi
leaq 0x5fb6(%rip), %rdi      # 0x916d
movb $0x0, %al
callq 0x2030
cmpl $0x3e8, 0xa538(%rip)    # imm = 0x3E8
jge 0x31e9
xorl %eax, %eax
testb $0x1, %al
jne 0x31d2
jmp 0x31e9
movl -0x14(%rbp), %edx
addl -0x10(%rbp), %edx
movslq 0xa521(%rip), %rcx      # 0xd700
leaq 0x8faa(%rip), %rax      # 0xc190
movl %edx, (%rax,%rcx,4)
movl 0xa511(%rip), %eax      # 0xd700
addl $0x1, %eax
movl %eax, 0xa508(%rip)      # 0xd700
movq -0x8(%rbp), %rax
movq 0xa525(%rip), %rcx      # 0xd728
movslq -0x18(%rbp), %rdx
movl (%rcx,%rdx,4), %ecx
movl 0xa528(%rip), %edx      # 0xd738
subl $0x1, %edx
movslq %edx, %rsi
leaq 0xa493(%rip), %rdx      # 0xd6b0
addl (%rdx,%rsi,4), %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x3170
addq $0x20, %rsp
popq %rbp
retq
// File: TooruAkagi[P]GCIS_Index/gcis_nep_locate.cpp
// Function: leftopen(unsigned int*, int*, int*, int, int, int)
void leftopen(unsigned int *D,int *D_2,int *D_3,int round,int count,int tround){ //左の[0]をcount回開ける
    if(DEBUGFLAG==1){
         printf("\n[1-左%dオープン(%d)]",count,round);
         if(occart2[tround][0] > -1){alldr(D,D_2,D_3,occart2[tround][0],tround-1);}
    }
    int rofs=0;
    if(round>1){rofs=dc2s[round-1];}
    if(occart2[tround][0] > -1){
       occart2[tround][0] = rofs+D[D_2[1+occart2[tround][0]]-1];
       if(DEBUGFLAG==1){printf(" >> %d ",occart2[tround][0]);}
       if(count>1){leftopen(D,D_2,D_3,round-1,count-1,tround);}
    }
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
cmpl $0x1, -0x1c(%rbp)
jle 0x3bc2
movl -0x1c(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rcx
leaq 0x9af4(%rip), %rax      # 0xd6b0
movl (%rax,%rcx,4), %eax
movl %eax, -0x28(%rbp)
movslq -0x24(%rbp), %rcx
leaq 0x95b3(%rip), %rax      # 0xd180
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
cmpl $-0x1, (%rax)
jle 0x3c49
movl -0x28(%rbp), %ecx
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rdx
movslq -0x24(%rbp), %rdi
leaq 0x9591(%rip), %rsi      # 0xd180
imulq $0x28, %rdi, %rdi
addq %rdi, %rsi
movl (%rsi), %esi
addl $0x1, %esi
movslq %esi, %rsi
movl (%rdx,%rsi,4), %edx
subl $0x1, %edx
movslq %edx, %rdx
addl (%rax,%rdx,4), %ecx
movslq -0x24(%rbp), %rdx
leaq 0x956b(%rip), %rax      # 0xd180
imulq $0x28, %rdx, %rdx
addq %rdx, %rax
movl %ecx, (%rax)
cmpl $0x1, -0x20(%rbp)
jle 0x3c47
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
subl $0x1, %ecx
movl -0x20(%rbp), %r8d
subl $0x1, %r8d
movl -0x24(%rbp), %r9d
callq 0x3b80
jmp 0x3c49
addq $0x30, %rsp
popq %rbp
retq
nop
// File: TooruAkagi[P]GCIS_Index/gcis_nep_locate.cpp
// Function: findinround1(unsigned int*, int*, int*, int, int, int)
void findinround1(unsigned int *D,int *D_2,int *D_3,int tg,int round,int pofs){
    if(round==fround){return findintop(D_3,tg,pofs);}
    //あるラウンドから文字[tg]を探す
    //printf("%d(+%d)",tg,pofs); //引き継いだズレ値を記録
    int e2[2];
    int rofs = 0;
    if(round>1){rofs=dc2s[round-1];}
    for(int y8=dc2s[round];y8<dc2s[round+1];y8++){
        int ofs = 0;
        //printf("\n[%d(%d)]",y8,D_2[y8+1]-D_2[y8]);
        for(int y9=D_2[y8];y9<D_2[y8+1];y9++){
            //printf(" %d",rofs+D[y9]);
            if(rofs+D[y9]==tg){
                //if(round>15){printf("\n発見(%d,%d[+%d])",tg,ofs+pofs,ofs);}
                findinround1(D,D_2,D_3,y8,round+1,pofs+ofs);
            }
            if(round>0){ofs+=D_3[rofs+D[y9]];}else{ofs++;}
        }
    }
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movl -0x20(%rbp), %eax
cmpl 0x95e0(%rip), %eax      # 0xd738
jne 0x416e
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
movl -0x24(%rbp), %edx
callq 0x3150
jmp 0x426f
movl $0x0, -0x30(%rbp)
cmpl $0x1, -0x20(%rbp)
jle 0x4191
movl -0x20(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rcx
leaq 0x9525(%rip), %rax      # 0xd6b0
movl (%rax,%rcx,4), %eax
movl %eax, -0x30(%rbp)
movslq -0x20(%rbp), %rcx
leaq 0x9514(%rip), %rax      # 0xd6b0
movl (%rax,%rcx,4), %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
movl -0x20(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rdx
leaq 0x94fb(%rip), %rcx      # 0xd6b0
cmpl (%rcx,%rdx,4), %eax
jge 0x426d
movl $0x0, -0x38(%rbp)
movq -0x10(%rbp), %rax
movslq -0x34(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
movq -0x10(%rbp), %rcx
movl -0x34(%rbp), %edx
addl $0x1, %edx
movslq %edx, %rdx
cmpl (%rcx,%rdx,4), %eax
jge 0x425d
movl -0x30(%rbp), %eax
movq -0x8(%rbp), %rcx
movslq -0x3c(%rbp), %rdx
addl (%rcx,%rdx,4), %eax
cmpl -0x1c(%rbp), %eax
jne 0x421f
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x34(%rbp), %ecx
movl -0x20(%rbp), %r8d
addl $0x1, %r8d
movl -0x24(%rbp), %r9d
addl -0x38(%rbp), %r9d
callq 0x4130
cmpl $0x0, -0x20(%rbp)
jle 0x4244
movq -0x18(%rbp), %rax
movl -0x30(%rbp), %ecx
movq -0x8(%rbp), %rdx
movslq -0x3c(%rbp), %rsi
addl (%rdx,%rsi,4), %ecx
movl %ecx, %ecx
movl (%rax,%rcx,4), %eax
addl -0x38(%rbp), %eax
movl %eax, -0x38(%rbp)
jmp 0x424d
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x424f
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x41d3
jmp 0x425f
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x41a2
jmp 0x426f
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: TooruAkagi[P]GCIS_Index/gcis_nep_locate.cpp
// Function: queryload()
int queryload(){
    //load[qname] file and put it in array [m]
    char qname[] = "query.txt";
    char chr;
    FILE *fp;
    long long int qsize = 400;
    qsize = std::filesystem::file_size(qname);
    fp = fopen(qname, "r"); // open file or return null
    if(fp == NULL) {
        printf("%s such file doesn't exist!\n", qname);
        return -1;
    }
    int i = 0;
    for(i=0;i<qsize;i++) {
        chr = fgetc(fp);
        m[i] = chr;
        if(chr<0){m[i]=chr + 256;}
        //printf("\n%d(%d)",m[i],i);
    }
    return (int)qsize;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movabsq $0x78742e7972657571, %rax # imm = 0x78742E7972657571
movq %rax, -0x10(%rbp)
movw $0x74, -0x8(%rbp)
movq $0x190, -0x28(%rbp)     # imm = 0x190
leaq -0x50(%rbp), %rdi
movq %rdi, -0x70(%rbp)
leaq -0x10(%rbp), %rsi
movl $0x2, %edx
callq 0x83d0
movq -0x70(%rbp), %rdi
callq 0x21b0
movq %rax, -0x68(%rbp)
jmp 0x6b19
movq -0x68(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x84b0
leaq -0x10(%rbp), %rdi
leaq 0x2526(%rip), %rsi      # 0x905b
callq 0x2170
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x6b7a
leaq -0x10(%rbp), %rsi
leaq 0x250d(%rip), %rdi      # 0x905d
movb $0x0, %al
callq 0x2030
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x6be5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x84b0
jmp 0x6bee
movl $0x0, -0x60(%rbp)
movl $0x0, -0x60(%rbp)
movslq -0x60(%rbp), %rax
cmpq -0x28(%rbp), %rax
jge 0x6bde
movq -0x20(%rbp), %rdi
callq 0x21e0
movb %al, -0x11(%rbp)
movsbl -0x11(%rbp), %edx
movq 0x6b77(%rip), %rax      # 0xd720
movslq -0x60(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movsbl -0x11(%rbp), %eax
cmpl $0x0, %eax
jge 0x6bd1
movsbl -0x11(%rbp), %edx
addl $0x100, %edx            # imm = 0x100
movq 0x6b56(%rip), %rax      # 0xd720
movslq -0x60(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
jmp 0x6bd3
movl -0x60(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x60(%rbp)
jmp 0x6b88
movq -0x28(%rbp), %rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x21f0
nopw (%rax,%rax)
// File: brashi[P]PetFera/src/./banco_dados.cpp
// Function: BancoDados::salvarDados()
void BancoDados::salvarDados() {
    try {
        salvarFuncionarios();
        salvarAnimais();
    } catch(char const* msg) {
        cout << "Erro: " << msg << endl;
    }
    
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x7480
jmp 0x73eb
movq -0x28(%rbp), %rdi
callq 0x7c10
jmp 0x73f6
jmp 0x7460
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x7477
movq -0x10(%rbp), %rdi
callq 0x6170
movq %rax, -0x20(%rbp)
movq 0x5bba4(%rip), %rdi     # 0x62fc8
leaq 0x38cb0(%rip), %rsi     # 0x400db
callq 0x6310
movq %rax, -0x30(%rbp)
jmp 0x7436
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x6310
movq %rax, -0x38(%rbp)
jmp 0x7449
movq -0x38(%rbp), %rdi
movq 0x5bb4c(%rip), %rsi     # 0x62fa0
callq 0x6360
jmp 0x745b
callq 0x6550
addq $0x40, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x6550
movq -0x10(%rbp), %rdi
callq 0x6590
// File: brashi[P]PetFera/src/./banco_dados.cpp
// Function: BancoDados::lerDados()
void BancoDados::lerDados() {
    try {
        lerFuncionarios();
        lerAnimais();
    } catch(char const* msg) {
        cout << "Erro: " << msg << endl << "Caso os arquivos existam,"
         << endl << "Verifique a integridade deles na pasta " << diretorio << endl;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x8c20
jmp 0x8b0b
movq -0x28(%rbp), %rdi
callq 0x9380
jmp 0x8b16
jmp 0x8bf6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x8c0d
movq -0x10(%rbp), %rdi
callq 0x6170
movq %rax, -0x20(%rbp)
movq 0x5a47d(%rip), %rdi     # 0x62fc8
leaq 0x37589(%rip), %rsi     # 0x400db
callq 0x6310
movq %rax, -0x30(%rbp)
jmp 0x8b5d
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x6310
movq %rax, -0x38(%rbp)
jmp 0x8b70
movq -0x38(%rbp), %rdi
movq 0x5a425(%rip), %rsi     # 0x62fa0
callq 0x6360
movq %rax, -0x40(%rbp)
jmp 0x8b86
movq -0x40(%rbp), %rdi
leaq 0x3761b(%rip), %rsi     # 0x401ac
callq 0x6310
movq %rax, -0x48(%rbp)
jmp 0x8b9c
movq -0x48(%rbp), %rdi
movq 0x5a3f9(%rip), %rsi     # 0x62fa0
callq 0x6360
movq %rax, -0x50(%rbp)
jmp 0x8bb2
movq -0x50(%rbp), %rdi
leaq 0x37609(%rip), %rsi     # 0x401c6
callq 0x6310
movq %rax, -0x58(%rbp)
jmp 0x8bc8
movq -0x58(%rbp), %rdi
movq -0x28(%rbp), %rsi
addq $0x50, %rsi
callq 0x6300
movq %rax, -0x60(%rbp)
jmp 0x8bdf
movq -0x60(%rbp), %rdi
movq 0x5a3b6(%rip), %rsi     # 0x62fa0
callq 0x6360
jmp 0x8bf1
callq 0x6550
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x6550
movq -0x10(%rbp), %rdi
callq 0x6590
nopw %cs:(%rax,%rax)
// File: brashi[P]PetFera/src/./petshop.cpp
// Function: Petshop::findVeterinario(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
shared_ptr<Veterinario> Petshop::findVeterinario(string nome) {
    for(auto& vet : this->veterinarios) {
        if(vet->getNome() == nome) {
            return vet;
        }
    }
    return nullptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdx, -0x70(%rbp)
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, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0xb0b0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0xb0e0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xb110
testb $0x1, %al
jne 0x1af3b
jmp 0x1af9b
leaq -0x28(%rbp), %rdi
callq 0xb150
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0xb170
movq %rax, %rsi
leaq -0x58(%rbp), %rdi
callq 0x27920
movq -0x70(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0xe670
movb %al, -0x71(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x6678
movb -0x71(%rbp), %al
testb $0x1, %al
jne 0x1af7f
jmp 0x1af8e
movq -0x68(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0xc060
jmp 0x1afa8
jmp 0x1af90
leaq -0x28(%rbp), %rdi
callq 0xb190
jmp 0x1af28
movq -0x68(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x22170
movq -0x60(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: brashi[P]PetFera/src/./petshop.cpp
// Function: Petshop::findTratador(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
shared_ptr<Tratador> Petshop::findTratador(string nome) {
    for(auto& trata : this->tratadores) {
        if(trata->getNome() == nome) {
            return trata;
        }
    }
    return nullptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdx, -0x70(%rbp)
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
addq $0x18, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0xb210
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0xb240
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xb270
testb $0x1, %al
jne 0x1b3cf
jmp 0x1b42f
leaq -0x28(%rbp), %rdi
callq 0xb2b0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0xb2d0
movq %rax, %rsi
leaq -0x58(%rbp), %rdi
callq 0x27920
movq -0x70(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0xe670
movb %al, -0x71(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x6678
movb -0x71(%rbp), %al
testb $0x1, %al
jne 0x1b413
jmp 0x1b422
movq -0x68(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0xc090
jmp 0x1b43c
jmp 0x1b424
leaq -0x28(%rbp), %rdi
callq 0xb2f0
jmp 0x1b3bc
movq -0x68(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x22280
movq -0x60(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax)
// File: brashi[P]PetFera/src/./petshop.cpp
// Function: Petshop::findAnimal(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
shared_ptr<Animal> Petshop::findAnimal(string nome, string especie) {
    for(auto& animal : this->animais) {
        if(animal->getNome() == nome && animal->getEspecie() == especie) {
            return animal;
        }
    }
    return nullptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rcx, -0xb0(%rbp)
movq %rdx, -0xa8(%rbp)
movq %rdi, -0xa0(%rbp)
movq %rdi, %rax
movq %rax, -0x98(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
addq $0x30, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0xb370
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0xb3a0
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xb3d0
testb $0x1, %al
jne 0x1c6f6
jmp 0x1c7e8
leaq -0x30(%rbp), %rdi
callq 0xb410
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0xb480
movq %rax, %rsi
leaq -0x60(%rbp), %rdi
callq 0x297c0
movq -0xa8(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0xe670
movb %al, %cl
movb $0x0, -0x8d(%rbp)
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0xb1(%rbp)
jne 0x1c740
jmp 0x1c774
movq -0x40(%rbp), %rdi
callq 0xb480
movq %rax, %rsi
leaq -0x80(%rbp), %rdi
callq 0x29950
jmp 0x1c757
movq -0xb0(%rbp), %rsi
movb $0x1, -0x8d(%rbp)
leaq -0x80(%rbp), %rdi
callq 0xe670
movb %al, -0xb1(%rbp)
movb -0xb1(%rbp), %al
movb %al, -0xb2(%rbp)
testb $0x1, -0x8d(%rbp)
jne 0x1c78b
jmp 0x1c794
leaq -0x80(%rbp), %rdi
callq 0x6678
leaq -0x60(%rbp), %rdi
callq 0x6678
movb -0xb2(%rbp), %al
testb $0x1, %al
jne 0x1c7a9
jmp 0x1c7d8
movq -0xa0(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0xb430
jmp 0x1c7f8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x6678
jmp 0x1c808
jmp 0x1c7da
leaq -0x30(%rbp), %rdi
callq 0xbac0
jmp 0x1c6e0
movq -0xa0(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x223d0
movq -0x98(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
movq -0x88(%rbp), %rdi
callq 0x6590
nopw %cs:(%rax,%rax)
// File: brashi[P]PetFera/src/./petshop.cpp
// Function: Petshop::excluirAnimal(std::shared_ptr<Animal>)
shared_ptr<Animal> Petshop::excluirAnimal(shared_ptr<Animal> removido) {
    int index = 0;

    for(auto& animal : this->animais) {
        if(animal == removido) {
            shared_ptr<Animal> ptr_removido = animal;
            this->animais.erase(this->animais.begin() + index);
            Debug("Animal: " << ptr_removido->getNome() << " removido do registro.");
            return ptr_removido;
        }
        index++;
    }

    return nullptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdx, -0x98(%rbp)
movq %rdi, -0x90(%rbp)
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
movl $0x0, -0x1c(%rbp)
addq $0x30, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0xb370
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0xb3a0
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xb3d0
testb $0x1, %al
jne 0x204d6
jmp 0x205b5
leaq -0x30(%rbp), %rdi
callq 0xb410
movq -0x98(%rbp), %rsi
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0x222a0
testb $0x1, %al
jne 0x204fc
jmp 0x2059e
movq -0x90(%rbp), %rdi
movb $0x0, -0x41(%rbp)
movq -0x40(%rbp), %rsi
callq 0xb430
movq -0x80(%rbp), %rdi
addq $0x30, %rdi
movq %rdi, -0xa8(%rbp)
callq 0xb370
movq %rax, -0x60(%rbp)
movslq -0x1c(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0x22350
movq %rax, -0x58(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x22390
movq -0xa8(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x222e0
movq %rax, -0xa0(%rbp)
jmp 0x2055f
movq -0xa0(%rbp), %rax
movq %rax, -0x78(%rbp)
movb $0x1, -0x41(%rbp)
testb $0x1, -0x41(%rbp)
jne 0x2059c
jmp 0x20590
movq -0x90(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
callq 0xb460
jmp 0x205d5
movq -0x90(%rbp), %rdi
callq 0xb460
jmp 0x205c5
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xbac0
jmp 0x204c0
movq -0x90(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x223d0
movq -0x88(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x6590
nop
// File: brashi[P]PetFera/src/./petshop.cpp
// Function: Petshop::excluirVeterinario(std::shared_ptr<Veterinario>)
shared_ptr<Veterinario> Petshop::excluirVeterinario(shared_ptr<Veterinario> removido) {
    int index = 0;

    for(auto& vet : this->veterinarios) {
        if(vet == removido) {
            shared_ptr<Veterinario> ptr_removido = vet;
            this->veterinarios.erase(this->veterinarios.begin() + index);
            Debug("Veterinario: " << ptr_removido->getNome() << " removido do registro.");
            return ptr_removido;
        }
        index++;
    }

    return nullptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdx, -0x98(%rbp)
movq %rdi, -0x90(%rbp)
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
movl $0x0, -0x1c(%rbp)
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0xb0b0
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0xb0e0
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xb110
testb $0x1, %al
jne 0x20bd2
jmp 0x20ca3
leaq -0x30(%rbp), %rdi
callq 0xb150
movq -0x98(%rbp), %rsi
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0x21e20
testb $0x1, %al
jne 0x20bf8
jmp 0x20c8c
movq -0x90(%rbp), %rdi
movb $0x0, -0x41(%rbp)
movq -0x40(%rbp), %rsi
callq 0xc060
movq -0x80(%rbp), %rdi
callq 0xb0b0
movq %rax, -0x60(%rbp)
movslq -0x1c(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0x220f0
movq %rax, -0x58(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x22130
movq -0x80(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x22080
movq %rax, -0xa0(%rbp)
jmp 0x20c4d
movq -0xa0(%rbp), %rax
movq %rax, -0x78(%rbp)
movb $0x1, -0x41(%rbp)
testb $0x1, -0x41(%rbp)
jne 0x20c8a
jmp 0x20c7e
movq -0x90(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
callq 0xb4c0
jmp 0x20cc3
movq -0x90(%rbp), %rdi
callq 0xb4c0
jmp 0x20cb3
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xb190
jmp 0x20bbc
movq -0x90(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x22170
movq -0x88(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x6590
nopl (%rax)
// File: brashi[P]PetFera/src/./petshop.cpp
// Function: Petshop::excluirTratador(std::shared_ptr<Tratador>)
shared_ptr<Tratador> Petshop::excluirTratador(shared_ptr<Tratador> removido) {
    int index = 0;

    for(auto& tratador : this->tratadores) {
        if(tratador == removido) {
            shared_ptr<Tratador> ptr_removido = tratador;
            this->tratadores.erase(this->tratadores.begin() + index);
            Debug("Tratador: " << ptr_removido->getNome() << " removido do registro.");
            return ptr_removido;
        }
        index++;
    }

    return nullptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdx, -0x98(%rbp)
movq %rdi, -0x90(%rbp)
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
movl $0x0, -0x1c(%rbp)
addq $0x18, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0xb210
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0xb240
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xb270
testb $0x1, %al
jne 0x212d6
jmp 0x213b5
leaq -0x30(%rbp), %rdi
callq 0xb2b0
movq -0x98(%rbp), %rsi
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0x21d40
testb $0x1, %al
jne 0x212fc
jmp 0x2139e
movq -0x90(%rbp), %rdi
movb $0x0, -0x41(%rbp)
movq -0x40(%rbp), %rsi
callq 0xc090
movq -0x80(%rbp), %rdi
addq $0x18, %rdi
movq %rdi, -0xa8(%rbp)
callq 0xb210
movq %rax, -0x60(%rbp)
movslq -0x1c(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0x22200
movq %rax, -0x58(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x22240
movq -0xa8(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x22190
movq %rax, -0xa0(%rbp)
jmp 0x2135f
movq -0xa0(%rbp), %rax
movq %rax, -0x78(%rbp)
movb $0x1, -0x41(%rbp)
testb $0x1, -0x41(%rbp)
jne 0x2139c
jmp 0x21390
movq -0x90(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
callq 0xb4a0
jmp 0x213d5
movq -0x90(%rbp), %rdi
callq 0xb4a0
jmp 0x213c5
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xb2f0
jmp 0x212c0
movq -0x90(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x22280
movq -0x88(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x6590
nop
// File: brashi[P]PetFera/src/funcionarios/pessoa.cpp
// Function: Pessoa::setNome()
bool Pessoa::setNome() {
    string s;
    cout << endl << "Nome: " << endl;
    getline(cin, s);

    if(s.find(';') != std::string::npos)
        throw "O caractere (Ponto e vírgula) é proibido.";
    if(s.size() == 0)
        return false;
    else
        this->nome = s;
    
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x6480
movq 0x3b654(%rip), %rdi     # 0x62fc8
movq 0x3b625(%rip), %rsi     # 0x62fa0
callq 0x6360
movq %rax, -0x48(%rbp)
jmp 0x27986
movq -0x48(%rbp), %rdi
leaq 0x1a5e8(%rip), %rsi     # 0x41f79
callq 0x6310
movq %rax, -0x58(%rbp)
jmp 0x2799c
movq -0x58(%rbp), %rdi
movq 0x3b5f9(%rip), %rsi     # 0x62fa0
callq 0x6360
jmp 0x279ae
movq 0x3b62b(%rip), %rdi     # 0x62fe0
leaq -0x30(%rbp), %rsi
callq 0x6090
jmp 0x279c0
leaq -0x30(%rbp), %rdi
movl $0x3b, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x6450
cmpq $-0x1, %rax
je 0x27a18
movl $0x8, %edi
callq 0x61e0
movq %rax, %rdi
leaq 0x1a594(%rip), %rax     # 0x41f80
movq %rax, (%rdi)
movq 0x3b5b2(%rip), %rsi     # 0x62fa8
xorl %eax, %eax
movl %eax, %edx
callq 0x6570
jmp 0x27a71
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x6678
jmp 0x27a68
leaq -0x30(%rbp), %rdi
callq 0x6250
cmpq $0x0, %rax
jne 0x27a34
movb $0x0, -0x1(%rbp)
movl $0x1, -0x40(%rbp)
jmp 0x27a54
movq -0x50(%rbp), %rdi
addq $0x8, %rdi
leaq -0x30(%rbp), %rsi
callq 0x6050
jmp 0x27a47
jmp 0x27a49
movb $0x1, -0x1(%rbp)
movl $0x1, -0x40(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x6678
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x6590
nopw %cs:(%rax,%rax)
// File: brashi[P]PetFera/src/funcionarios/pessoa.cpp
// Function: Pessoa::setTelefone()
bool Pessoa::setTelefone() {
    string s;
    cout << endl << "Telefone: " << endl;
    getline(cin, s);

    if(s.find(';') != std::string::npos)
        throw "O caractere (Ponto e vírgula) é proibido.";
    if(s.size() == 0)
        return false;
    else
        this->telefone = s;
    
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x6480
movq 0x3b4c4(%rip), %rdi     # 0x62fc8
movq 0x3b495(%rip), %rsi     # 0x62fa0
callq 0x6360
movq %rax, -0x48(%rbp)
jmp 0x27b16
movq -0x48(%rbp), %rdi
leaq 0x1a48b(%rip), %rsi     # 0x41fac
callq 0x6310
movq %rax, -0x58(%rbp)
jmp 0x27b2c
movq -0x58(%rbp), %rdi
movq 0x3b469(%rip), %rsi     # 0x62fa0
callq 0x6360
jmp 0x27b3e
movq 0x3b49b(%rip), %rdi     # 0x62fe0
leaq -0x30(%rbp), %rsi
callq 0x6090
jmp 0x27b50
leaq -0x30(%rbp), %rdi
movl $0x3b, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x6450
cmpq $-0x1, %rax
je 0x27ba8
movl $0x8, %edi
callq 0x61e0
movq %rax, %rdi
leaq 0x1a404(%rip), %rax     # 0x41f80
movq %rax, (%rdi)
movq 0x3b422(%rip), %rsi     # 0x62fa8
xorl %eax, %eax
movl %eax, %edx
callq 0x6570
jmp 0x27c01
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x6678
jmp 0x27bf8
leaq -0x30(%rbp), %rdi
callq 0x6250
cmpq $0x0, %rax
jne 0x27bc4
movb $0x0, -0x1(%rbp)
movl $0x1, -0x40(%rbp)
jmp 0x27be4
movq -0x50(%rbp), %rdi
addq $0x28, %rdi
leaq -0x30(%rbp), %rsi
callq 0x6050
jmp 0x27bd7
jmp 0x27bd9
movb $0x1, -0x1(%rbp)
movl $0x1, -0x40(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x6678
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x6590
nopw %cs:(%rax,%rax)
// File: brashi[P]PetFera/src/funcionarios/pessoa.cpp
// Function: Pessoa::setEmail()
bool Pessoa::setEmail() {
    string s;
    cout << endl << "E-mail: " << endl;
    getline(cin, s);

    if(s.find(';') != std::string::npos)
        throw "O caractere (Ponto e vírgula) é proibido.";
    if(s.size() == 0)
        return false;
    else
        this->email = s;
    
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x6480
movq 0x3b334(%rip), %rdi     # 0x62fc8
movq 0x3b305(%rip), %rsi     # 0x62fa0
callq 0x6360
movq %rax, -0x48(%rbp)
jmp 0x27ca6
movq -0x48(%rbp), %rdi
leaq 0x1a306(%rip), %rsi     # 0x41fb7
callq 0x6310
movq %rax, -0x58(%rbp)
jmp 0x27cbc
movq -0x58(%rbp), %rdi
movq 0x3b2d9(%rip), %rsi     # 0x62fa0
callq 0x6360
jmp 0x27cce
movq 0x3b30b(%rip), %rdi     # 0x62fe0
leaq -0x30(%rbp), %rsi
callq 0x6090
jmp 0x27ce0
leaq -0x30(%rbp), %rdi
movl $0x3b, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x6450
cmpq $-0x1, %rax
je 0x27d38
movl $0x8, %edi
callq 0x61e0
movq %rax, %rdi
leaq 0x1a274(%rip), %rax     # 0x41f80
movq %rax, (%rdi)
movq 0x3b292(%rip), %rsi     # 0x62fa8
xorl %eax, %eax
movl %eax, %edx
callq 0x6570
jmp 0x27d91
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x6678
jmp 0x27d88
leaq -0x30(%rbp), %rdi
callq 0x6250
cmpq $0x0, %rax
jne 0x27d54
movb $0x0, -0x1(%rbp)
movl $0x1, -0x40(%rbp)
jmp 0x27d74
movq -0x50(%rbp), %rdi
addq $0x48, %rdi
leaq -0x30(%rbp), %rsi
callq 0x6050
jmp 0x27d67
jmp 0x27d69
movb $0x1, -0x1(%rbp)
movl $0x1, -0x40(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x6678
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x6590
nopw %cs:(%rax,%rax)
// File: brashi[P]PetFera/src/funcionarios/tratador.cpp
// Function: Tratador::setUniforme()
bool Tratador::setUniforme() {
    string s;
    cout << endl << "Nível de segurança do tratador: " << endl;
    cout << "V - verde" << endl;
    cout << "A - azul" << endl;
    cout << "M - vermelho" << endl;
    getline(cin, s);

    switch(toupper(s[0])) {
        case 'V':
            this->uniforme = Verde;
            break;
        case 'A':
            this->uniforme = Azul;
            break;
        case 'M':
            this->uniforme = Vermelho;
            break;
        default:
            return false;
            break;
    }

    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x6480
movq 0x3aec1(%rip), %rdi     # 0x62fc8
movq 0x3ae92(%rip), %rsi     # 0x62fa0
callq 0x6360
movq %rax, -0x48(%rbp)
jmp 0x28119
movq -0x48(%rbp), %rdi
leaq 0x19ea4(%rip), %rsi     # 0x41fc8
callq 0x6310
movq %rax, -0x58(%rbp)
jmp 0x2812f
movq -0x58(%rbp), %rdi
movq 0x3ae66(%rip), %rsi     # 0x62fa0
callq 0x6360
jmp 0x28141
movq 0x3ae80(%rip), %rdi     # 0x62fc8
leaq 0x19e9c(%rip), %rsi     # 0x41feb
callq 0x6310
movq %rax, -0x60(%rbp)
jmp 0x2815a
movq -0x60(%rbp), %rdi
movq 0x3ae3b(%rip), %rsi     # 0x62fa0
callq 0x6360
jmp 0x2816c
movq 0x3ae55(%rip), %rdi     # 0x62fc8
leaq 0x19e7b(%rip), %rsi     # 0x41ff5
callq 0x6310
movq %rax, -0x68(%rbp)
jmp 0x28185
movq -0x68(%rbp), %rdi
movq 0x3ae10(%rip), %rsi     # 0x62fa0
callq 0x6360
jmp 0x28197
movq 0x3ae2a(%rip), %rdi     # 0x62fc8
leaq 0x19e59(%rip), %rsi     # 0x41ffe
callq 0x6310
movq %rax, -0x70(%rbp)
jmp 0x281b0
movq -0x70(%rbp), %rdi
movq 0x3ade5(%rip), %rsi     # 0x62fa0
callq 0x6360
jmp 0x281c2
movq 0x3ae17(%rip), %rdi     # 0x62fe0
leaq -0x30(%rbp), %rsi
callq 0x6090
jmp 0x281d4
xorl %eax, %eax
movl %eax, %esi
leaq -0x30(%rbp), %rdi
callq 0x6660
movq %rax, -0x78(%rbp)
jmp 0x281e7
movq -0x78(%rbp), %rax
movsbl (%rax), %edi
callq 0x6600
movl %eax, %ecx
movl %ecx, -0x7c(%rbp)
subl $0x41, %eax
je 0x28237
jmp 0x281ff
movl -0x7c(%rbp), %eax
subl $0x4d, %eax
je 0x28244
jmp 0x28209
movl -0x7c(%rbp), %eax
subl $0x56, %eax
je 0x2822a
jmp 0x28251
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x6678
jmp 0x28280
movq -0x50(%rbp), %rax
movl $0x0, 0x68(%rax)
jmp 0x2825e
movq -0x50(%rbp), %rax
movl $0x1, 0x68(%rax)
jmp 0x2825e
movq -0x50(%rbp), %rax
movl $0x2, 0x68(%rax)
jmp 0x2825e
movb $0x0, -0x1(%rbp)
movl $0x1, -0x40(%rbp)
jmp 0x28269
movb $0x1, -0x1(%rbp)
movl $0x1, -0x40(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x6678
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x80, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x6590
nopl (%rax)