LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: cyamonide[P]md2html/./src/md2html.cpp
// Function: Md2html::~Md2html()
Md2html::~Md2html()
{
    buffer.push_front("");
    closeAllTags();
    flushBuffer();
    fin.close();
    fout.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq %rax, -0x40(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x56d0
movq -0x38(%rbp), %rdx
leaq 0x6e01(%rip), %rsi      # 0x392e1
leaq -0x28(%rbp), %rdi
callq 0x6eb0
jmp 0x324eb
movq -0x48(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x35b60
jmp 0x324fa
leaq -0x28(%rbp), %rdi
callq 0x5798
leaq -0x29(%rbp), %rdi
callq 0x5440
movq -0x40(%rbp), %rdi
callq 0x325b0
jmp 0x32517
movq -0x40(%rbp), %rdi
callq 0x325e0
jmp 0x32522
movq -0x40(%rbp), %rdi
addq $0xe0, %rdi
callq 0x50d0
jmp 0x32534
movq -0x40(%rbp), %rdi
addq $0x2e8, %rdi            # imm = 0x2E8
callq 0x5590
jmp 0x32546
movq -0x40(%rbp), %rdi
addq $0x2e8, %rdi            # imm = 0x2E8
callq 0x55c0
movq -0x40(%rbp), %rdi
addq $0xe0, %rdi
callq 0x5100
movq -0x40(%rbp), %rdi
addq $0xc0, %rdi
callq 0x5798
movq -0x40(%rbp), %rdi
addq $0xa0, %rdi
callq 0x5798
movq -0x40(%rbp), %rdi
addq $0x50, %rdi
callq 0x35ad0
movq -0x40(%rbp), %rdi
callq 0x35af0
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0xa2a0
nopw (%rax,%rax)
// File: cyamonide[P]md2html/./src/md2html.cpp
// Function: Md2html::start()
void Md2html::start()
{
    buffer.push_front("");

    while (getNextLine())
    {
        resolveNextLine();
        writeBuffer();
    }

    buffer.push_front("");
    closeAllTags();
    flushBuffer();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
movq %rax, -0x78(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x56d0
movq -0x70(%rbp), %rdx
leaq 0x6c5e(%rip), %rsi      # 0x392e1
leaq -0x28(%rbp), %rdi
callq 0x6eb0
jmp 0x3268e
movq -0x80(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x35b60
jmp 0x3269d
leaq -0x28(%rbp), %rdi
callq 0x5798
leaq -0x29(%rbp), %rdi
callq 0x5440
movq -0x78(%rbp), %rdi
callq 0x327b0
testb $0x1, %al
jne 0x326be
jmp 0x32703
movq -0x78(%rbp), %rdi
callq 0x32870
movq -0x78(%rbp), %rdi
callq 0x33be0
jmp 0x326af
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x326f5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x5798
leaq -0x29(%rbp), %rdi
callq 0x5440
jmp 0x327a2
movq -0x78(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x61(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x56d0
movq -0x88(%rbp), %rdx
leaq 0x6bb5(%rip), %rsi      # 0x392e1
leaq -0x60(%rbp), %rdi
callq 0x6eb0
jmp 0x32737
movq -0x90(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x35b60
jmp 0x32749
leaq -0x60(%rbp), %rdi
callq 0x5798
leaq -0x61(%rbp), %rdi
callq 0x5440
movq -0x78(%rbp), %rdi
callq 0x325b0
movq -0x78(%rbp), %rdi
callq 0x325e0
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x32799
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x5798
leaq -0x61(%rbp), %rdi
callq 0x5440
movq -0x38(%rbp), %rdi
callq 0x56c0
nopl (%rax,%rax)
// File: cyamonide[P]md2html/./src/md2html.cpp
// Function: Md2html::getNextLine()
bool Md2html::getNextLine()
{
    string line_buf;
    if (getline(fin, line_buf))
    {
        buffer.push_front(line_buf);
        return true;
    }

    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x5560
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
addq $0xe0, %rdi
callq 0x50b0
movq %rax, -0x48(%rbp)
jmp 0x327eb
movq -0x48(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x54f0
movb %al, -0x59(%rbp)
jmp 0x32803
movb -0x59(%rbp), %al
testb $0x1, %al
jne 0x3280c
jmp 0x3283f
movq -0x58(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x35b90
jmp 0x3281b
movb $0x1, -0x1(%rbp)
movl $0x1, -0x40(%rbp)
jmp 0x3284a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x5798
jmp 0x3285e
movb $0x0, -0x1(%rbp)
movl $0x1, -0x40(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x5798
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x56c0
nopw (%rax,%rax)
// File: cyamonide[P]md2html/./src/md2html.cpp
// Function: Md2html::closeLastTag()
bool Md2html::closeLastTag()
{
    if (buffer.size() == 1)
    {
        return false;
    }
    else if (state.size() == 0)
    {
        return false;
    }
    else
    {
        buffer[1] += ct(state.top().type);
        state.pop();
    }

    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x35bf0
cmpq $0x1, %rax
jne 0x33dc8
movb $0x0, -0x1(%rbp)
jmp 0x33e81
movq -0x68(%rbp), %rdi
addq $0x50, %rdi
callq 0x35d00
cmpq $0x0, %rax
jne 0x33de4
movb $0x0, -0x1(%rbp)
jmp 0x33e81
movq -0x68(%rbp), %rdi
addq $0x50, %rdi
callq 0x35d40
movq %rax, %rsi
leaq -0x50(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x51b0
movq -0x70(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x27d30
jmp 0x33e10
movq -0x68(%rbp), %rdi
movl $0x1, %esi
callq 0x35d60
movq %rax, %rdi
leaq -0x30(%rbp), %rsi
callq 0x5510
jmp 0x33e2c
leaq -0x30(%rbp), %rdi
callq 0x5798
leaq -0x50(%rbp), %rdi
callq 0x5798
movq -0x68(%rbp), %rdi
addq $0x50, %rdi
callq 0x35d20
jmp 0x33e7b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x33e70
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x5798
leaq -0x50(%rbp), %rdi
callq 0x5798
jmp 0x33e8c
jmp 0x33e7d
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x56c0
nopw %cs:(%rax,%rax)
// File: iZhangHui[P]CppPrimer/CH06_Functions/examples/stl-arr-fcns.cc
// Function: main
int main() 
{
	print("hi world!"); // calls first version of print
	cout << endl;

    // j is converted to a pointer to the first element in j
    // the second argument is a pointer to one past the end of j
    int j[2] = {0, 1};  
    print(begin(j), end(j));  // library begin and end functions
	cout << endl;

	// equivalent call, directly calculate the begin and end pointers
	print(j, j + 2); 
	cout << endl;

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
leaq 0xd80(%rip), %rdi       # 0x2006
callq 0x11d0
movq 0x2d46(%rip), %rdi      # 0x3fd8
movq 0x2d2f(%rip), %rsi      # 0x3fc8
callq 0x1050
movq 0xd6b(%rip), %rax       # 0x2010
movq %rax, -0xc(%rbp)
leaq -0xc(%rbp), %rdi
callq 0x1310
movq %rax, -0x18(%rbp)
leaq -0xc(%rbp), %rdi
callq 0x1320
movq -0x18(%rbp), %rdi
movq %rax, %rsi
callq 0x1220
movq 0x2d06(%rip), %rdi      # 0x3fd8
movq 0x2cef(%rip), %rsi      # 0x3fc8
callq 0x1050
leaq -0xc(%rbp), %rdi
leaq -0xc(%rbp), %rsi
addq $0x8, %rsi
callq 0x1220
movq 0x2ce2(%rip), %rdi      # 0x3fd8
movq 0x2ccb(%rip), %rsi      # 0x3fc8
callq 0x1050
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: flastest[P]HW2_Systems_flaster_strand/cache.cc
// Function: Cache::Impl::get(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned int&)
cache_val_type get(key_type key, size_type& val_size)
	{
	    if (mCache.find(key) != mCache.cend()){
	        auto ret = mCache[key].second;
	        val_size = mCache[key].first;
	        return ret;
	    }
	    return nullptr;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdx, -0x68(%rbp)
movq %rsi, %rax
movq -0x68(%rbp), %rsi
movq %rdi, -0x60(%rbp)
movq %rdi, %rdx
movq %rdx, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x50(%rbp)
addq $0x38, %rdi
callq 0x3d90
movq -0x50(%rbp), %rdi
movq %rax, -0x28(%rbp)
addq $0x38, %rdi
callq 0x3dc0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x58b0
testb $0x1, %al
jne 0x2d2a
jmp 0x2da0
movq -0x68(%rbp), %rsi
movq -0x50(%rbp), %rdi
movb $0x0, -0x31(%rbp)
addq $0x38, %rdi
movq %rdi, -0x78(%rbp)
callq 0x3cf0
movq -0x60(%rbp), %rdi
movq %rax, %rsi
addq $0x8, %rsi
callq 0x4220
movq -0x78(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0x3cf0
movq %rax, -0x70(%rbp)
jmp 0x2d66
movq -0x70(%rbp), %rax
movl (%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movb $0x1, -0x31(%rbp)
testb $0x1, -0x31(%rbp)
jne 0x2d9e
jmp 0x2d95
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0x2df0
jmp 0x2dba
movq -0x60(%rbp), %rdi
callq 0x2df0
jmp 0x2dad
movq -0x60(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x58e0
movq -0x58(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x22d0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: flastest[P]HW2_Systems_flaster_strand/cache.cc
// Function: Cache::Impl::del(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool del(key_type key)
	{
	    size_type size;
	    cache_val_type item = get(key, size);
	    if (item){

            mCache.erase(key);
            memory_used -= size;
            return true;

	    }
		return false;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rsi, -0x78(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x50(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x20b0
movq -0x70(%rbp), %rsi
movq -0x68(%rbp), %rdx
leaq -0x30(%rbp), %rdi
leaq -0x1c(%rbp), %rcx
callq 0x2cc0
jmp 0x2e53
leaq -0x50(%rbp), %rdi
callq 0x2100
leaq -0x30(%rbp), %rdi
callq 0x5900
testb $0x1, %al
jne 0x2e6b
jmp 0x2ec8
movq -0x78(%rbp), %rsi
movq -0x70(%rbp), %rdi
addq $0x38, %rdi
callq 0x5920
jmp 0x2e7e
movq -0x70(%rbp), %rax
movl -0x1c(%rbp), %edx
movl 0x30(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x30(%rax)
movb $0x1, -0x1(%rbp)
movl $0x1, -0x60(%rbp)
jmp 0x2ed3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x2100
jmp 0x2eea
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x2df0
jmp 0x2eea
movb $0x0, -0x1(%rbp)
movl $0x1, -0x60(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x2df0
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x80, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x22d0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: flastest[P]HW2_Systems_flaster_strand/test_cache_lib.cc
// Function: makeCache(unsigned int)
auto makeCache(Cache::size_type cache_size=2048){
    Fifo_Evictor *my_evictor = new Fifo_Evictor();
    Cache* my_cache = new Cache(cache_size, 0.75, my_evictor);
    char value[]{ "four" };
    my_cache->set("apple", value, 5);
    return my_cache;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movl %edi, -0x4(%rbp)
movl $0x58, %edi
callq 0x21c0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x80(%rbp)
callq 0x7ff0
jmp 0x6459
movq -0x80(%rbp), %rax
movq %rax, -0x10(%rbp)
movl $0x8, %edi
callq 0x21c0
movq %rax, -0xa0(%rbp)
movq %rax, -0xa8(%rbp)
movb $0x1, -0x4a(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x94(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x48(%rbp), %rdi
movq %rdi, -0x88(%rbp)
leaq -0x49(%rbp), %rsi
callq 0x8060
movq -0xa0(%rbp), %rdi
movl -0x94(%rbp), %esi
movq -0x90(%rbp), %rdx
movq -0x88(%rbp), %rcx
movss 0x4bdc(%rip), %xmm0     # 0xb0a4
callq 0x24d0
jmp 0x64cf
movb $0x0, -0x4a(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x2970
movq -0xa8(%rbp), %rax
movq %rax, -0x28(%rbp)
movb $0x0, -0x4c(%rbp)
movl $0x72756f66, -0x50(%rbp) # imm = 0x72756F66
movq -0x28(%rbp), %rax
movq %rax, -0xb8(%rbp)
leaq -0x71(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x22e0
movq -0xb0(%rbp), %rdx
leaq 0x4ba2(%rip), %rsi      # 0xb0bd
leaq -0x70(%rbp), %rdi
callq 0x80f0
jmp 0x6526
movq -0xb8(%rbp), %rdi
leaq -0x70(%rbp), %rsi
leaq -0x50(%rbp), %rdx
movl $0x5, %ecx
callq 0x25c0
jmp 0x6541
leaq -0x70(%rbp), %rdi
callq 0x2100
leaq -0x71(%rbp), %rdi
callq 0x2200
movq -0x28(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
movq -0x80(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x58, %esi
callq 0x21d0
jmp 0x65d8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x2970
testb $0x1, -0x4a(%rbp)
jne 0x6599
jmp 0x65aa
movq -0xa8(%rbp), %rdi
movl $0x8, %esi
callq 0x21d0
jmp 0x65d8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x65cf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x2100
leaq -0x71(%rbp), %rdi
callq 0x2200
movq -0x18(%rbp), %rdi
callq 0x22d0
nopw %cs:(%rax,%rax)
// File: flastest[P]HW2_Systems_flaster_strand/test_cache_lib.cc
// Function: testGet(bool)
bool testGet(bool DEBUG_PRINT_MESSAGES){
    if (DEBUG_PRINT_MESSAGES) std::cout<<"testing putting and getting something from the cache"<<std::endl;
    auto my_cache = makeCache();
    Cache::size_type size;
    auto ret = (my_cache->get("apple", size));
    std::string p(ret);
    if (DEBUG_PRINT_MESSAGES) {
        std::cout << p << std::endl;
    }
    return (p == "four");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movb %dil, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
testb $0x1, -0x1(%rbp)
je 0x662b
movq 0xa9c8(%rip), %rdi      # 0x10fd8
leaq 0x4aac(%rip), %rsi      # 0xb0c3
callq 0x21b0
movq %rax, %rdi
movq 0xa99a(%rip), %rsi      # 0x10fc0
callq 0x21e0
movl $0x800, %edi            # imm = 0x800
callq 0x6430
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x22e0
movq -0x88(%rbp), %rdx
leaq 0x4a5b(%rip), %rsi      # 0xb0bd
leaq -0x40(%rbp), %rdi
callq 0x80f0
jmp 0x666d
movq -0x90(%rbp), %rdi
leaq -0x40(%rbp), %rsi
leaq -0x14(%rbp), %rdx
callq 0x2640
movq %rax, -0x98(%rbp)
jmp 0x668a
leaq -0x40(%rbp), %rdi
callq 0x2100
leaq -0x41(%rbp), %rdi
callq 0x2200
movq -0x98(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0xa8(%rbp)
leaq -0x79(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x22e0
movq -0xa8(%rbp), %rsi
movq -0xa0(%rbp), %rdx
leaq -0x78(%rbp), %rdi
callq 0x80f0
jmp 0x66db
leaq -0x79(%rbp), %rdi
callq 0x2200
testb $0x1, -0x1(%rbp)
je 0x677a
movq 0xa8e3(%rip), %rdi      # 0x10fd8
leaq -0x78(%rbp), %rsi
callq 0x21a0
movq %rax, -0xb0(%rbp)
jmp 0x6707
movq -0xb0(%rbp), %rdi
movq 0xa8ab(%rip), %rsi      # 0x10fc0
callq 0x21e0
jmp 0x671c
jmp 0x677a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x6741
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x2100
leaq -0x41(%rbp), %rdi
callq 0x2200
jmp 0x67ac
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x79(%rbp), %rdi
callq 0x2200
jmp 0x67ac
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x2100
jmp 0x67ac
leaq 0x4937(%rip), %rsi      # 0xb0b8
leaq -0x78(%rbp), %rdi
callq 0x81a0
movb %al, -0xb1(%rbp)
jmp 0x6792
leaq -0x78(%rbp), %rdi
callq 0x2100
movb -0xb1(%rbp), %al
andb $0x1, %al
addq $0xc0, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x22d0
nopw %cs:(%rax,%rax)
// File: flastest[P]HW2_Systems_flaster_strand/test_cache_lib.cc
// Function: testGetNull(bool)
bool testGetNull(bool DEBUG_PRINT_MESSAGES){
    if (DEBUG_PRINT_MESSAGES) std::cout<<"testing getting something that isn't in the cache"<<std::endl;
    auto my_cache = makeCache();
    Cache::size_type size;
    auto ret = (my_cache->get("pear", size));
    if (ret == nullptr){
        return true;
    }
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movb %dil, %al
andb $0x1, %al
movb %al, -0x2(%rbp)
testb $0x1, -0x2(%rbp)
je 0x67f8
movq 0xa7fb(%rip), %rdi      # 0x10fd8
leaq 0x4914(%rip), %rsi      # 0xb0f8
callq 0x21b0
movq %rax, %rdi
movq 0xa7cd(%rip), %rsi      # 0x10fc0
callq 0x21e0
movl $0x800, %edi            # imm = 0x800
callq 0x6430
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x22e0
movq -0x60(%rbp), %rdx
leaq 0x4904(%rip), %rsi      # 0xb12a
leaq -0x40(%rbp), %rdi
callq 0x80f0
jmp 0x6831
movq -0x68(%rbp), %rdi
leaq -0x40(%rbp), %rsi
leaq -0x14(%rbp), %rdx
callq 0x2640
movq %rax, -0x70(%rbp)
jmp 0x6848
leaq -0x40(%rbp), %rdi
callq 0x2100
leaq -0x41(%rbp), %rdi
callq 0x2200
movq -0x70(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x689d
movb $0x1, -0x1(%rbp)
jmp 0x68a1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x6892
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x2100
leaq -0x41(%rbp), %rdi
callq 0x2200
jmp 0x68ac
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x22d0
nopw %cs:(%rax,%rax)
// File: flastest[P]HW2_Systems_flaster_strand/test_cache_lib.cc
// Function: testDel(bool)
bool testDel(bool DEBUG_PRINT_MESSAGES){
    if (DEBUG_PRINT_MESSAGES) std::cout<<"testing that a deleted item is no longer in the cache"<<std::endl;
    auto my_cache = makeCache();
    Cache::size_type size;
    return ((my_cache->del("apple")) && (my_cache->get("apple", size)== nullptr));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movb %dil, %al
andb $0x1, %al
movb %al, -0x2(%rbp)
testb $0x1, -0x2(%rbp)
je 0x68fb
movq 0xa6f8(%rip), %rdi      # 0x10fd8
leaq 0x4848(%rip), %rsi      # 0xb12f
callq 0x21b0
movq %rax, %rdi
movq 0xa6ca(%rip), %rsi      # 0x10fc0
callq 0x21e0
movl $0x800, %edi            # imm = 0x800
callq 0x6430
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x22e0
movq -0x80(%rbp), %rdx
movb $0x0, -0x72(%rbp)
movb $0x0, -0x73(%rbp)
leaq 0x4789(%rip), %rsi      # 0xb0bd
leaq -0x38(%rbp), %rdi
callq 0x80f0
jmp 0x693f
movq -0x88(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x26e0
movb %al, -0x89(%rbp)
jmp 0x6957
movb -0x89(%rbp), %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x8a(%rbp)
jne 0x696c
jmp 0x69d9
movq -0x10(%rbp), %rax
movq %rax, -0xa0(%rbp)
leaq -0x71(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x22e0
movq -0x98(%rbp), %rdx
movb $0x1, -0x72(%rbp)
leaq 0x4724(%rip), %rsi      # 0xb0bd
leaq -0x70(%rbp), %rdi
callq 0x80f0
jmp 0x69a4
movq -0xa0(%rbp), %rdi
movb $0x1, -0x73(%rbp)
leaq -0x70(%rbp), %rsi
leaq -0x14(%rbp), %rdx
callq 0x2640
movq %rax, -0xa8(%rbp)
jmp 0x69c5
movq -0xa8(%rbp), %rax
cmpq $0x0, %rax
sete %al
movb %al, -0x8a(%rbp)
movb -0x8a(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
testb $0x1, -0x73(%rbp)
jne 0x69ec
jmp 0x69f5
leaq -0x70(%rbp), %rdi
callq 0x2100
testb $0x1, -0x72(%rbp)
jne 0x69fd
jmp 0x6a06
leaq -0x71(%rbp), %rdi
callq 0x2200
leaq -0x38(%rbp), %rdi
callq 0x2100
leaq -0x39(%rbp), %rdi
callq 0x2200
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xb0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x6a8b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x6a82
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x6a6f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
testb $0x1, -0x73(%rbp)
jne 0x6a64
jmp 0x6a6d
leaq -0x70(%rbp), %rdi
callq 0x2100
jmp 0x6a6f
testb $0x1, -0x72(%rbp)
jne 0x6a77
jmp 0x6a80
leaq -0x71(%rbp), %rdi
callq 0x2200
jmp 0x6a82
leaq -0x38(%rbp), %rdi
callq 0x2100
leaq -0x39(%rbp), %rdi
callq 0x2200
movq -0x48(%rbp), %rdi
callq 0x22d0
nopl (%rax)
// File: flastest[P]HW2_Systems_flaster_strand/test_cache_lib.cc
// Function: testSpaceUsed(bool)
bool testSpaceUsed(bool DEBUG_PRINT_MESSAGES){
    if (DEBUG_PRINT_MESSAGES) std::cout<<"testing to make sure that space used is equal to the space of everything we put in"<<std::endl;
    auto my_cache = makeCache();
    Cache::size_type size = 5;
    auto ret = my_cache->space_used();
    if (DEBUG_PRINT_MESSAGES) std::cout<<"ret is: "<< ret <<", size is: "<<size<<std::endl;
    return (ret == size);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dil, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
testb $0x1, -0x1(%rbp)
je 0x6bb8
movq 0xa43b(%rip), %rdi      # 0x10fd8
leaq 0x45f4(%rip), %rsi      # 0xb198
callq 0x21b0
movq %rax, %rdi
movq 0xa40d(%rip), %rsi      # 0x10fc0
callq 0x21e0
movl $0x800, %edi            # imm = 0x800
callq 0x6430
movq %rax, -0x10(%rbp)
movl $0x5, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2760
movl %eax, -0x18(%rbp)
testb $0x1, -0x1(%rbp)
je 0x6c26
movq 0xa3f2(%rip), %rdi      # 0x10fd8
leaq 0x45fe(%rip), %rsi      # 0xb1eb
callq 0x21b0
movq %rax, %rdi
movl -0x18(%rbp), %esi
callq 0x2270
movq %rax, %rdi
leaq 0x45ed(%rip), %rsi      # 0xb1f4
callq 0x21b0
movq %rax, %rdi
movl -0x14(%rbp), %esi
callq 0x2270
movq %rax, %rdi
movq 0xa39f(%rip), %rsi      # 0x10fc0
callq 0x21e0
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
sete %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: flastest[P]HW2_Systems_flaster_strand/test_cache_lib.cc
// Function: testReset(bool)
bool testReset(bool DEBUG_PRINT_MESSAGES){
    if (DEBUG_PRINT_MESSAGES) std::cout<<"Testing resetting the cache and making sure it's empty afterwards"<<std::endl;
    auto my_cache = makeCache();
    Cache::size_type size;
    if (DEBUG_PRINT_MESSAGES) std::cout<<"Cache created"<<std::endl;
    my_cache->reset();
    if (DEBUG_PRINT_MESSAGES) std::cout<<"Cache reset"<<std::endl;
    auto ret = (my_cache->get("apple", size));
    if (DEBUG_PRINT_MESSAGES) std::cout<<"Ret gotten"<<std::endl;
    if ((ret == nullptr) && (my_cache->space_used() == 0)){
        return true;
    }
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movb %dil, %al
andb $0x1, %al
movb %al, -0x2(%rbp)
testb $0x1, -0x2(%rbp)
je 0x6c78
movq 0xa37b(%rip), %rdi      # 0x10fd8
leaq 0x459c(%rip), %rsi      # 0xb200
callq 0x21b0
movq %rax, %rdi
movq 0xa34d(%rip), %rsi      # 0x10fc0
callq 0x21e0
movl $0x800, %edi            # imm = 0x800
callq 0x6430
movq %rax, -0x10(%rbp)
testb $0x1, -0x2(%rbp)
je 0x6cae
movq 0xa345(%rip), %rdi      # 0x10fd8
leaq 0x45a8(%rip), %rsi      # 0xb242
callq 0x21b0
movq %rax, %rdi
movq 0xa317(%rip), %rsi      # 0x10fc0
callq 0x21e0
movq -0x10(%rbp), %rdi
callq 0x2790
testb $0x1, -0x2(%rbp)
je 0x6cdf
movq 0xa314(%rip), %rdi      # 0x10fd8
leaq 0x4585(%rip), %rsi      # 0xb250
callq 0x21b0
movq %rax, %rdi
movq 0xa2e6(%rip), %rsi      # 0x10fc0
callq 0x21e0
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x22e0
movq -0x60(%rbp), %rdx
leaq 0x43be(%rip), %rsi      # 0xb0bd
leaq -0x40(%rbp), %rdi
callq 0x80f0
jmp 0x6d0a
movq -0x68(%rbp), %rdi
leaq -0x40(%rbp), %rsi
leaq -0x14(%rbp), %rdx
callq 0x2640
movq %rax, -0x70(%rbp)
jmp 0x6d21
leaq -0x40(%rbp), %rdi
callq 0x2100
leaq -0x41(%rbp), %rdi
callq 0x2200
movq -0x70(%rbp), %rax
movq %rax, -0x20(%rbp)
testb $0x1, -0x2(%rbp)
je 0x6d93
movq 0xa290(%rip), %rdi      # 0x10fd8
leaq 0x450d(%rip), %rsi      # 0xb25c
callq 0x21b0
movq %rax, %rdi
movq 0xa262(%rip), %rsi      # 0x10fc0
callq 0x21e0
jmp 0x6d93
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x6d88
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x2100
leaq -0x41(%rbp), %rdi
callq 0x2200
jmp 0x6dbd
cmpq $0x0, -0x20(%rbp)
jne 0x6dae
movq -0x10(%rbp), %rdi
callq 0x2760
cmpl $0x0, %eax
jne 0x6dae
movb $0x1, -0x1(%rbp)
jmp 0x6db2
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x22d0
nopw %cs:(%rax,%rax)
// File: flastest[P]HW2_Systems_flaster_strand/test_cache_lib.cc
// Function: main
int main(){
    assert(testGet(false));
    assert(testGetNull(false));
    assert(testDel(false));
    assert(testDelNull(false));
    assert(testSpaceUsed(false));
    assert(testReset(false));
    assert(testSameKey(false));
    assert(testEvictorWithFullCache(false));
    assert(testEvictorEvictingSameItemTwice(false));

    std::cout<<"all tests pass!"<<std::endl;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
xorl %edi, %edi
callq 0x65f0
testb $0x1, %al
jne 0x7e2c
jmp 0x7e2e
jmp 0x7e4d
leaq 0x3646(%rip), %rdi      # 0xb47b
leaq 0x364e(%rip), %rsi      # 0xb48a
movl $0xb5, %edx
leaq 0x3654(%rip), %rcx      # 0xb49c
callq 0x2110
xorl %edi, %edi
callq 0x67c0
testb $0x1, %al
jne 0x7e5a
jmp 0x7e5c
jmp 0x7e7b
leaq 0x3644(%rip), %rdi      # 0xb4a7
leaq 0x3620(%rip), %rsi      # 0xb48a
movl $0xb6, %edx
leaq 0x3626(%rip), %rcx      # 0xb49c
callq 0x2110
xorl %edi, %edi
callq 0x68c0
testb $0x1, %al
jne 0x7e88
jmp 0x7e8a
jmp 0x7ea9
leaq 0x3629(%rip), %rdi      # 0xb4ba
leaq 0x35f2(%rip), %rsi      # 0xb48a
movl $0xb7, %edx
leaq 0x35f8(%rip), %rcx      # 0xb49c
callq 0x2110
xorl %edi, %edi
callq 0x6aa0
testb $0x1, %al
jne 0x7eb6
jmp 0x7eb8
jmp 0x7ed7
leaq 0x360a(%rip), %rdi      # 0xb4c9
leaq 0x35c4(%rip), %rsi      # 0xb48a
movl $0xb8, %edx
leaq 0x35ca(%rip), %rcx      # 0xb49c
callq 0x2110
xorl %edi, %edi
callq 0x6b80
testb $0x1, %al
jne 0x7ee4
jmp 0x7ee6
jmp 0x7f05
leaq 0x35ef(%rip), %rdi      # 0xb4dc
leaq 0x3596(%rip), %rsi      # 0xb48a
movl $0xb9, %edx
leaq 0x359c(%rip), %rcx      # 0xb49c
callq 0x2110
xorl %edi, %edi
callq 0x6c40
testb $0x1, %al
jne 0x7f12
jmp 0x7f14
jmp 0x7f33
leaq 0x35d6(%rip), %rdi      # 0xb4f1
leaq 0x3568(%rip), %rsi      # 0xb48a
movl $0xba, %edx
leaq 0x356e(%rip), %rcx      # 0xb49c
callq 0x2110
xorl %edi, %edi
callq 0x6dd0
testb $0x1, %al
jne 0x7f40
jmp 0x7f42
jmp 0x7f61
leaq 0x35b9(%rip), %rdi      # 0xb502
leaq 0x353a(%rip), %rsi      # 0xb48a
movl $0xbb, %edx
leaq 0x3540(%rip), %rcx      # 0xb49c
callq 0x2110
xorl %edi, %edi
callq 0x7050
testb $0x1, %al
jne 0x7f6e
jmp 0x7f70
jmp 0x7f8f
leaq 0x359e(%rip), %rdi      # 0xb515
leaq 0x350c(%rip), %rsi      # 0xb48a
movl $0xbc, %edx
leaq 0x3512(%rip), %rcx      # 0xb49c
callq 0x2110
xorl %edi, %edi
callq 0x7760
testb $0x1, %al
jne 0x7f9c
jmp 0x7f9e
jmp 0x7fbd
leaq 0x3590(%rip), %rdi      # 0xb535
leaq 0x34de(%rip), %rsi      # 0xb48a
movl $0xbd, %edx
leaq 0x34e4(%rip), %rcx      # 0xb49c
callq 0x2110
movq 0x9014(%rip), %rdi      # 0x10fd8
leaq 0x3592(%rip), %rsi      # 0xb55d
callq 0x21b0
movq %rax, %rdi
movq 0x8fe6(%rip), %rsi      # 0x10fc0
callq 0x21e0
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: linuxmao-org[P]VL1-emulator/utils/sources/json.hpp
// Function: nlohmann::detail::iteration_proxy_value<nlohmann::detail::iter_impl<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>>>::key() const
const string_type& key() const
    {
        assert(anchor.m_object != nullptr);

        switch (anchor.m_object->type())
        {
            // use integer array index as key
            case value_t::array:
            {
                if (array_index != array_index_last)
                {
                    int_to_string( array_index_str, array_index );
                    array_index_last = array_index;
                }
                return array_index_str;
            }

            // use key from the object
            case value_t::object:
                return anchor.key();

            // use an empty key for all primitive types
            default:
                return empty_str;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, (%rax)
je 0x56ac
jmp 0x56cb
leaq 0x23675(%rip), %rdi     # 0x28d28
leaq 0x2046e(%rip), %rsi     # 0x25b28
movl $0xd18, %edx            # imm = 0xD18
leaq 0x2367d(%rip), %rcx     # 0x28d43
callq 0x4220
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x22220
movb %al, %cl
movb %cl, -0x19(%rbp)
subb $0x1, %al
je 0x5727
jmp 0x56e2
movb -0x19(%rbp), %al
subb $0x2, %al
jne 0x5736
jmp 0x56eb
movq -0x18(%rbp), %rcx
movq 0x20(%rcx), %rax
cmpq 0x28(%rcx), %rax
je 0x5719
movq -0x18(%rbp), %rax
movq %rax, %rdi
addq $0x30, %rdi
movq 0x20(%rax), %rsi
callq 0x22230
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rcx
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rax
addq $0x30, %rax
movq %rax, -0x8(%rbp)
jmp 0x5742
movq -0x18(%rbp), %rdi
callq 0x22270
movq %rax, -0x8(%rbp)
jmp 0x5742
movq -0x18(%rbp), %rax
addq $0x50, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: linuxmao-org[P]VL1-emulator/utils/sources/json.hpp
// Function: nlohmann::detail::iter_impl<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>>::key() const
const typename object_t::key_type& key() const
    {
        assert(m_object != nullptr);

        if (JSON_HEDLEY_LIKELY(m_object->is_object()))
        {
            return m_it.object_iterator->first;
        }

        JSON_THROW(invalid_iterator::create(207, "cannot use key() for non-object iterators"));
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, (%rax)
je 0x2228c
jmp 0x222ab
leaq 0x6a9c(%rip), %rdi      # 0x28d2f
leaq 0x388e(%rip), %rsi      # 0x25b28
movl $0x26be, %edx           # imm = 0x26BE
leaq 0x6b5f(%rip), %rcx      # 0x28e05
callq 0x4220
movq -0x48(%rbp), %rax
movq (%rax), %rdi
callq 0x129e0
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x222c1
jmp 0x222d4
movq -0x48(%rbp), %rdi
addq $0x8, %rdi
callq 0x184c0
addq $0x60, %rsp
popq %rbp
retq
movb $0x1, -0x3d(%rbp)
movl $0x20, %edi
callq 0x4180
movq %rax, -0x58(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x4560
movq -0x50(%rbp), %rdx
leaq 0x6b94(%rip), %rsi      # 0x28e92
leaq -0x28(%rbp), %rdi
callq 0x5430
jmp 0x22309
movq -0x58(%rbp), %rdi
movl $0xcf, %esi
leaq -0x28(%rbp), %rdx
callq 0x17890
jmp 0x2231d
movq -0x58(%rbp), %rdi
movb $0x0, -0x3d(%rbp)
leaq 0x16924(%rip), %rsi     # 0x38c50
leaq -0xa953(%rip), %rdx     # 0x179e0
callq 0x4530
jmp 0x22382
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x2235d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x4200
leaq -0x29(%rbp), %rdi
callq 0x4360
testb $0x1, -0x3d(%rbp)
jne 0x2236e
jmp 0x22377
movq -0x58(%rbp), %rdi
callq 0x4280
jmp 0x22379
movq -0x38(%rbp), %rdi
callq 0x4550
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: ethanmick[P]Blowfish482/Blowfish.cpp
// Function: Blowfish::computeHexPi()
uint32_t Blowfish::computeHexPi() {

    double s1 = series(hexStart, 1);
    double s2 = series(hexStart, 4);
    double s3 = series(hexStart, 5);
    double s4 = series(hexStart, 6);

    double pi = (4.0 * s1) - (2.0 * s2) - s3 - s4;
    pi = pi - (int)pi + 1.0;

    uint32_t pihex= 0;

    for (int i=0; i < 8; i++) {
    	pi *= 16;
    	uint32_t hVal = floor(pi);
    	pihex <<= 4;
    	pihex |= hVal;
    	pi -= hVal;
    }

    hexStart += 8;

    return pihex;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movl 0x8(%rdi), %esi
movl $0x1, %edx
callq 0x2c00
movq -0x48(%rbp), %rdi
movsd %xmm0, -0x10(%rbp)
movl 0x8(%rdi), %esi
movl $0x4, %edx
callq 0x2c00
movq -0x48(%rbp), %rdi
movsd %xmm0, -0x18(%rbp)
movl 0x8(%rdi), %esi
movl $0x5, %edx
callq 0x2c00
movq -0x48(%rbp), %rdi
movsd %xmm0, -0x20(%rbp)
movl 0x8(%rdi), %esi
movl $0x6, %edx
callq 0x2c00
movsd %xmm0, -0x28(%rbp)
movsd -0x10(%rbp), %xmm0
movsd 0x1743(%rip), %xmm1     # 0x4018
mulsd -0x18(%rbp), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
movsd 0x1717(%rip), %xmm2     # 0x4010
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
subsd -0x20(%rbp), %xmm0
subsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
cvttsd2si -0x30(%rbp), %eax
cvtsi2sd %eax, %xmm1
subsd %xmm1, %xmm0
movsd 0x16de(%rip), %xmm1     # 0x4008
addsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movl $0x0, -0x38(%rbp)
cmpl $0x8, -0x38(%rbp)
jge 0x29a4
movsd -0x30(%rbp), %xmm0
movsd 0x16cc(%rip), %xmm1     # 0x4020
mulsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
callq 0x21f0
cvttsd2si %xmm0, %rax
movl %eax, -0x3c(%rbp)
movl -0x34(%rbp), %eax
shll $0x4, %eax
movl %eax, -0x34(%rbp)
movl -0x3c(%rbp), %ecx
movl -0x34(%rbp), %eax
orl %ecx, %eax
movl %eax, -0x34(%rbp)
movl -0x3c(%rbp), %eax
cvtsi2sd %rax, %xmm1
movsd -0x30(%rbp), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x2941
movq -0x48(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x8, %ecx
movl %ecx, 0x8(%rax)
movl -0x34(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: ethanmick[P]Blowfish482/Blowfish.cpp
// Function: Blowfish::pack32BitWord(unsigned char*, unsigned int)
uint32_t Blowfish::pack32BitWord( uint8_t* input, uint32_t startVal ){
    uint32_t result = 0;
    for( unsigned int i = startVal; i < startVal + 4; i++ ){
        result <<= 8;
        result |= input[ i ];
    }
    return result; 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl -0x14(%rbp), %ecx
addl $0x4, %ecx
cmpl %ecx, %eax
jae 0x2a0e
movl -0x18(%rbp), %eax
shll $0x8, %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
movzbl (%rax,%rcx), %eax
orl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x29dc
movl -0x18(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ethanmick[P]Blowfish482/Blowfish.cpp
// Function: Blowfish::encrypt(unsigned char*)
void Blowfish::encrypt(uint8_t* text){
    
    uint32_t xL, xR, temp;
    xL = pack32BitWord( text, 0 );
    xR = pack32BitWord( text, 4 );
        
    for( int i = 0; i <= 15; i++ ){
        
        xL ^= pArray[ i ];
        xR ^= F( xL );
        
        temp = xL;
        xL = xR;
        xR = temp;
    }
    
    temp = xL;
    xL = xR;
    xR = temp;
    
    xR ^= pArray[ 16 ];
    xL ^= pArray[ 17 ];
    
    //merge into xR and xL into xL
    uint64_t final = 0;
    final |= xL;
    final <<= 32;
    final |= xR;
    //now final is the ciphertext, need to convert to ascii
    
    text[ 0 ] = final >> 56;
    text[ 1 ] = final >> 48;
    text[ 2 ] = final >> 40;
    text[ 3 ] = final >> 32;
    text[ 4 ] = final >> 24;
    text[ 5 ] = final >> 16;
    text[ 6 ] = final >> 8;
    text[ 7 ] = final;
    
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x29c0
movq -0x30(%rbp), %rdi
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rsi
movl $0x4, %edx
callq 0x29c0
movl %eax, -0x18(%rbp)
movl $0x0, -0x20(%rbp)
cmpl $0xf, -0x20(%rbp)
jg 0x2aa8
movq -0x30(%rbp), %rdi
movslq -0x20(%rbp), %rax
movl 0x100c(%rdi,%rax,4), %eax
xorl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %esi
callq 0x2b90
xorl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x2a62
movq -0x30(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, -0x1c(%rbp)
movl -0x18(%rbp), %ecx
movl %ecx, -0x14(%rbp)
movl -0x1c(%rbp), %ecx
movl %ecx, -0x18(%rbp)
movl 0x104c(%rax), %ecx
xorl -0x18(%rbp), %ecx
movl %ecx, -0x18(%rbp)
movl 0x1050(%rax), %eax
xorl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movq $0x0, -0x28(%rbp)
movl -0x14(%rbp), %eax
orq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
shlq $0x20, %rax
movq %rax, -0x28(%rbp)
movl -0x18(%rbp), %eax
orq -0x28(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
shrq $0x38, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
movq -0x28(%rbp), %rax
shrq $0x30, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x1(%rax)
movq -0x28(%rbp), %rax
shrq $0x28, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x2(%rax)
movq -0x28(%rbp), %rax
shrq $0x20, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x3(%rax)
movq -0x28(%rbp), %rax
shrq $0x18, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x4(%rax)
movq -0x28(%rbp), %rax
shrq $0x10, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x5(%rax)
movq -0x28(%rbp), %rax
shrq $0x8, %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x6(%rax)
movq -0x28(%rbp), %rax
movb %al, %cl
movq -0x10(%rbp), %rax
movb %cl, 0x7(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: ethanmick[P]Blowfish482/Blowfish.cpp
// Function: Blowfish::F(unsigned int)
uint32_t Blowfish::F( uint32_t input ){
    uint8_t a, b, c, d;
        
    d = (uint8_t) input;
    input >>= 8;
    c = (uint8_t) input;
    input >>= 8;
    b = (uint8_t) input;
    input >>= 8;
    a = (uint8_t) input;
    
    return ( ( s1[ a ] + s2[ b ] ) ^ s3[ c ] ) + s4[ d ];
    
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rcx
movl -0xc(%rbp), %eax
movb %al, -0x10(%rbp)
movl -0xc(%rbp), %eax
shrl $0x8, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movb %al, -0xf(%rbp)
movl -0xc(%rbp), %eax
shrl $0x8, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movb %al, -0xe(%rbp)
movl -0xc(%rbp), %eax
shrl $0x8, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movb %al, -0xd(%rbp)
movzbl -0xd(%rbp), %eax
movl 0xc(%rcx,%rax,4), %eax
movzbl -0xe(%rbp), %edx
addl 0x40c(%rcx,%rdx,4), %eax
movzbl -0xf(%rbp), %edx
xorl 0x80c(%rcx,%rdx,4), %eax
movzbl -0x10(%rbp), %edx
addl 0xc0c(%rcx,%rdx,4), %eax
popq %rbp
retq
nopl (%rax)
// File: ethanmick[P]Blowfish482/Blowfish.cpp
// Function: Blowfish::series(unsigned int, unsigned int)
double Blowfish::series(uint32_t d, uint32_t j) {

    double sum = 0;
    for ( unsigned int k = 0; k < d; k++ ) {
        sum += (binaryExp(16, (d - k), (8 * k + j))) / (8 * k + j);
        sum = sum - (int)sum;
    }

    for ( unsigned int k = d; k < d + 100; k++ ) {
        sum += pow(16.0, (double) d - k) / (8 * k + j);
        sum = sum - (int)sum;
    }

    return sum;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jae 0x2c98
movq -0x28(%rbp), %rdi
movl -0xc(%rbp), %edx
movl -0x1c(%rbp), %eax
subl %eax, %edx
movl -0x10(%rbp), %esi
movl %eax, %ecx
movl %esi, %eax
leal (%rax,%rcx,8), %eax
cvtsi2sd %rax, %xmm0
movl $0x10, %esi
callq 0x2d20
movl -0x1c(%rbp), %eax
movl -0x10(%rbp), %edx
movl %eax, %ecx
movl %edx, %eax
leal (%rax,%rcx,8), %eax
cvtsi2sd %rax, %xmm1
divsd %xmm1, %xmm0
addsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
cvttsd2si -0x18(%rbp), %eax
cvtsi2sd %eax, %xmm1
subsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x2c29
movl -0xc(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl -0xc(%rbp), %ecx
addl $0x64, %ecx
cmpl %ecx, %eax
jae 0x2d0e
movl -0xc(%rbp), %eax
cvtsi2sd %rax, %xmm1
movl -0x20(%rbp), %eax
cvtsi2sd %rax, %xmm0
subsd %xmm0, %xmm1
movsd 0x1359(%rip), %xmm0     # 0x4020
callq 0x2200
movl -0x20(%rbp), %eax
movl -0x10(%rbp), %edx
movl %eax, %ecx
movl %edx, %eax
leal (%rax,%rcx,8), %eax
cvtsi2sd %rax, %xmm1
divsd %xmm1, %xmm0
addsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
cvttsd2si -0x18(%rbp), %eax
cvtsi2sd %eax, %xmm1
subsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x2c9e
movsd -0x18(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: ethanmick[P]Blowfish482/Blowfish.cpp
// Function: Blowfish::binaryExp(int, int, double)
double Blowfish::binaryExp(int b, int n, double mod) {

    if (mod == 1.0) {
        return 0;
    }
    
    // Largest power of 2 less than n
    double t = pow(2, floor(log2(n)));

    double r = 1;
    while (t >= 1) {
        if (n >= t) {
            r = fmod(b * r, mod);
            n = n - t;
        }
        
        t = t / 2;

        if (t >= 1) {
            r = fmod(r * r, mod);
        }
    }

    return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
movsd 0x12c4(%rip), %xmm1     # 0x4008
ucomisd %xmm1, %xmm0
jne 0x2d59
jp 0x2d59
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x2e1c
movl -0x18(%rbp), %edi
callq 0x2e80
callq 0x21f0
movl $0x2, %edi
callq 0x2e50
movsd %xmm0, -0x28(%rbp)
movsd 0x128b(%rip), %xmm0     # 0x4008
movsd %xmm0, -0x30(%rbp)
movsd -0x28(%rbp), %xmm0
movsd 0x1279(%rip), %xmm1     # 0x4008
ucomisd %xmm1, %xmm0
jb 0x2e12
cvtsi2sdl -0x18(%rbp), %xmm0
ucomisd -0x28(%rbp), %xmm0
jb 0x2dcb
cvtsi2sdl -0x14(%rbp), %xmm0
mulsd -0x30(%rbp), %xmm0
movsd -0x20(%rbp), %xmm1
callq 0x21a0
movsd %xmm0, -0x30(%rbp)
cvtsi2sdl -0x18(%rbp), %xmm0
subsd -0x28(%rbp), %xmm0
cvttsd2si %xmm0, %eax
movl %eax, -0x18(%rbp)
movsd -0x28(%rbp), %xmm0
movsd 0x1240(%rip), %xmm1     # 0x4018
divsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
movsd 0x121a(%rip), %xmm1     # 0x4008
ucomisd %xmm1, %xmm0
jb 0x2e0d
movsd -0x30(%rbp), %xmm0
mulsd -0x30(%rbp), %xmm0
movsd -0x20(%rbp), %xmm1
callq 0x21a0
movsd %xmm0, -0x30(%rbp)
jmp 0x2d82
movsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: ethanmick[P]Blowfish482/Profile.cpp
// Function: print_uint8_hex(unsigned char*, unsigned int, char const*)
void print_uint8_hex(uint8_t* buffer, uint32_t size, const char* label) {
    printf("%s: ", label);
    for ( unsigned int i = 0; i < size; i++ ) {
        printf("%.2X ", buffer[ i ]);
        //cout << (uint32_t) buffer[ i ] << " ";
    }
    printf("\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rsi
leaq 0x1182(%rip), %rdi      # 0x4040
movb $0x0, %al
callq 0x2040
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jae 0x2ef8
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
movzbl (%rax,%rcx), %esi
leaq 0x115f(%rip), %rdi      # 0x4045
movb $0x0, %al
callq 0x2040
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x2ecc
leaq 0x114c(%rip), %rdi      # 0x404b
movb $0x0, %al
callq 0x2040
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: Fohlen[P]cubescript-standalone/main.cpp
// Function: writelog(_IO_FILE*, char const*)
static void writelog(FILE *file, const char *buf)
{
    static uchar ubuf[512];
    size_t len = strlen(buf), carry = 0;
    while(carry < len)
    {
        size_t numu = encodeutf8(ubuf, sizeof(ubuf)-1, &((const uchar *)buf)[carry], len - carry, &carry);
        if(carry >= len) ubuf[numu++] = '\n';
        fwrite(ubuf, 1, numu, file);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x20b0
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x4097
movq -0x10(%rbp), %rdx
addq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rcx
subq -0x20(%rbp), %rcx
leaq 0x2343a(%rip), %rdi     # 0x27480
movl $0x1ff, %esi            # imm = 0x1FF
leaq -0x20(%rbp), %r8
callq 0x17ec0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jb 0x407c
movq -0x28(%rbp), %rcx
movq %rcx, %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
leaq 0x23408(%rip), %rax     # 0x27480
movb $0xa, (%rax,%rcx)
movq -0x28(%rbp), %rdx
movq -0x8(%rbp), %rcx
leaq 0x233f5(%rip), %rdi     # 0x27480
movl $0x1, %esi
callq 0x2420
jmp 0x4025
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: Fohlen[P]cubescript-standalone/main.cpp
// Function: main
int main(int argc, char* argv[])
{
	vector<char> line;
	for(int i=1;i<argc;i++)
	{
		if(argv[i][0] == '-')
		{
			switch(argv[i][1])
			{
				case 'f':  //file
					execfile(argv[i]+2);
					break;

				case 'e': //evaluate
					execute(argv[i]+2);
					break;
					
				case 'h' : //help
					printf("Valid options: -f (executes file), -e (evaluates input) \n");
					break;

				default:
					conoutf("unkown option!");
					break;
			}
		}
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x43a0
movl $0x1, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x432c
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x431c
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsbl 0x1(%rax), %eax
movl %eax, -0x38(%rbp)
subl $0x65, %eax
je 0x42dd
jmp 0x4294
movl -0x38(%rbp), %eax
subl $0x66, %eax
je 0x42a8
jmp 0x429e
movl -0x38(%rbp), %eax
subl $0x68, %eax
je 0x42f6
jmp 0x4308
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
addq $0x2, %rdi
movl $0x1, %esi
callq 0xb140
jmp 0x42c4
jmp 0x431a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x43d0
jmp 0x4345
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
addq $0x2, %rdi
callq 0xaf40
jmp 0x42f4
jmp 0x431a
leaq 0x18d07(%rip), %rdi     # 0x1d004
xorl %eax, %eax
callq 0x2030
jmp 0x4306
jmp 0x431a
leaq 0x18d2f(%rip), %rdi     # 0x1d03e
xorl %eax, %eax
callq 0x40f0
jmp 0x4318
jmp 0x431a
jmp 0x431c
jmp 0x431e
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x4256
movl $0x0, -0x4(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x43d0
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x23e0
nop
// File: Fohlen[P]cubescript-standalone/command.cpp
// Function: clearoverride(ident&)
void clearoverride(ident &i)
{
    if(!(i.flags&IDF_OVERRIDDEN)) return;
    switch(i.type)
    {
        case ID_ALIAS:
            if(i.valtype==VAL_STR) 
            {
                if(!i.val.s[0]) break;
                delete[] i.val.s;
            }
            cleancode(i);
            i.valtype = VAL_STR;
            i.val.s = newstring("");
            break;
        case ID_VAR:
            *i.storage.i = i.overrideval.i;
            i.changed();
            break;
        case ID_FVAR:
            *i.storage.f = i.overrideval.f;
            i.changed();
            break;
        case ID_SVAR:
            delete[] *i.storage.s;
            *i.storage.s = i.overrideval.s;
            i.changed();
            break;
    }
    i.flags &= ~IDF_OVERRIDDEN;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x38(%rax), %eax
andl $0x10, %eax
cmpl $0x0, %eax
jne 0x4690
jmp 0x47a1
movq -0x8(%rbp), %rax
movl (%rax), %eax
movq %rax, -0x10(%rbp)
subq $0x4, %rax
ja 0x4794
movq -0x10(%rbp), %rax
leaq 0x189a1(%rip), %rcx     # 0x1d050
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rax
cmpl $0x3, 0x10(%rax)
jne 0x46f1
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
cmpb $0x0, (%rax)
jne 0x46d4
jmp 0x4794
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x46ef
movq -0x18(%rbp), %rdi
callq 0x1b110
jmp 0x46f1
movq -0x8(%rbp), %rdi
callq 0x47b0
movq -0x8(%rbp), %rax
movl $0x3, 0x10(%rax)
leaq 0x19c73(%rip), %rdi     # 0x1e37f
callq 0x15990
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
jmp 0x4794
movq -0x8(%rbp), %rax
movl 0x28(%rax), %ecx
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rdi
callq 0x159e0
jmp 0x4794
movq -0x8(%rbp), %rax
movss 0x28(%rax), %xmm0
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movss %xmm0, (%rax)
movq -0x8(%rbp), %rdi
callq 0x159e0
jmp 0x4794
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x4778
movq -0x20(%rbp), %rdi
callq 0x1b110
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
callq 0x159e0
movq -0x8(%rbp), %rax
movl 0x38(%rax), %ecx
andl $-0x11, %ecx
movl %ecx, 0x38(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)