LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/Myyura[P]MyyuraSat/./source/./solver_basic.cpp
// Function: MyyuraSat::Solver::print_clauses() const
inline void Solver::print_clauses(void) const {
    std::cout << "print clauses begin: ==================================" << std::endl;
    for (int i = 0; i < _clauses.size(); i++) {
        const Clause& c = _ca[_clauses[i]];
        std::cout << i << " : ";
        for (int j = 0; j < c.size(); j++) {
            std::cout << c[j].to_int() << " ";
        }
        std::cout << std::endl;
    }
    std::cout << "print clauses end: ====================================" << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
movq 0x5ac7(%rip), %rbx      # 0xbf98
leaq 0x1f6a(%rip), %rsi      # 0x8442
movl $0x37, %edx
movq %rbx, %rdi
callq 0x2150
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2120
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20e0
cmpl $0x0, 0x10(%r14)
jle 0x65d2
leaq 0xf8(%r14), %rax
movq %rax, -0x30(%rbp)
xorl %r12d, %r12d
leaq 0x1f50(%rip), %r13      # 0x847c
movq %r14, -0x38(%rbp)
movq 0x8(%r14), %rax
movl (%rax,%r12,4), %esi
movq -0x30(%rbp), %rdi
callq 0x69f0
movq %rax, %r15
movq %rbx, %rdi
movl %r12d, %esi
callq 0x2260
movl $0x3, %edx
movq %rax, %rdi
leaq 0x1f1c(%rip), %rsi      # 0x847a
callq 0x2150
cmpl $0x20, (%r15)
jb 0x6597
xorl %r14d, %r14d
movl 0x4(%r15,%r14,4), %esi
movq %rbx, %rdi
callq 0x2260
movl $0x1, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x2150
incq %r14
movl (%r15), %eax
shrl $0x5, %eax
cmpq %rax, %r14
jb 0x656c
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2120
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20e0
incq %r12
movq -0x38(%rbp), %r14
movslq 0x10(%r14), %rax
cmpq %rax, %r12
jl 0x6530
leaq 0x1ea5(%rip), %rsi      # 0x847e
movl $0x37, %edx
movq %rbx, %rdi
callq 0x2150
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2120
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x20e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/Myyura[P]MyyuraSat/./source/../include/core/../type/../util/alloc.hpp
// Function: MyyuraSat::RegionAllocator<unsigned int>::alloc(int)
RARef alloc(int size) {
        if (size <= 0) {
            throw std::invalid_argument("RegionAllocator<T>::alloc(int size) : the argument size must be greater than 0");
        }

        reserve(_size + size);

        uint32_t prev_size = _size;
        _size += size;

        // Handle overflow
        if (_size < prev_size) { throw std::bad_alloc(); }

        return prev_size;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
testl %esi, %esi
jle 0x6647
movl %esi, %ebx
movq %rdi, %r14
movl 0x8(%rdi), %esi
addl %ebx, %esi
callq 0x671e
movl 0x8(%r14), %eax
addl %eax, %ebx
movl %ebx, 0x8(%r14)
jb 0x6679
popq %rbx
popq %r14
popq %rbp
retq
movl $0x10, %edi
callq 0x20a0
movq %rax, %rbx
leaq 0x1c6d(%rip), %rsi      # 0x82c8
movq %rax, %rdi
callq 0x2280
movq 0x5976(%rip), %rsi      # 0xbfe0
movq 0x5947(%rip), %rdx      # 0xbfb8
movq %rbx, %rdi
callq 0x2250
movl $0x8, %edi
callq 0x20a0
movq 0x58f6(%rip), %rcx      # 0xbf80
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x5908(%rip), %rsi      # 0xbfa0
movq 0x58d1(%rip), %rdx      # 0xbf70
movq %rax, %rdi
callq 0x2250
movq %rax, %r14
movq %rbx, %rdi
callq 0x20f0
movq %r14, %rdi
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O3/Myyura[P]MyyuraSat/./source/../include/core/../type/clause.hpp
// Function: MyyuraSat::Clause::Clause(MyyuraSat::Vector<MyyuraSat::Literal, int> const&, bool, bool)
Clause(const Vector<Literal>& ps, bool use_extra, bool learnt) {
        _header.mark = 0;
        _header.learnt = learnt;
        _header.has_extra = use_extra;
        _header.reloced = 0;
        _header.size = ps.size();

        for (int i = 0; i < ps.size(); i++) {
            _data[i].lit = ps[i];
        }

        if (_header.has_extra) {
            if (_header.learnt) {
                _data[_header.size].act = 0;
            } else {
                calc_abstraction();
            }
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl (%rdi), %eax
andl $-0x20, %eax
leal (%rax,%rdx,8), %eax
leal (%rax,%rcx,4), %eax
movl %eax, (%rdi)
movl 0x8(%rsi), %eax
movl %eax, %r8d
shll $0x5, %r8d
leal (%r8,%rdx,8), %r8d
leal (%r8,%rcx,4), %r8d
movl %r8d, (%rdi)
cmpl $0x0, 0x8(%rsi)
jle 0x6701
movq (%rsi), %r8
xorl %r9d, %r9d
movl (%r8,%r9,4), %r10d
movl %r10d, 0x4(%rdi,%r9,4)
incq %r9
movslq 0x8(%rsi), %r10
cmpq %r10, %r9
jl 0x66ec
testb %dl, %dl
je 0x6716
testb %cl, %cl
je 0x6718
andl $0x7ffffff, %eax        # imm = 0x7FFFFFF
movl $0x0, 0x4(%rdi,%rax,4)
popq %rbp
retq
popq %rbp
jmp 0x67fa
// File: /workspace/github_cpp_makefile_star2_O3/Myyura[P]MyyuraSat/./source/../include/core/../type/../util/alloc.hpp
// Function: MyyuraSat::RegionAllocator<unsigned int>::reserve(unsigned int)
void reserve(uint32_t min_cap) {
        if (_capacity >= min_cap) { return; }

        uint32_t prev_cap = _capacity;
        for (; _capacity < min_cap;) {
            /**
             * NOTE: Multiply by a factor (13/8) without causing overflow, then 
             * add 2 and make the result even by clearing the least significant 
             * bit. The resulting sequence of capacities is carefully chosen to 
             * hit a maximum capacity that is close to the '2^32-1' limit when
             * using 'uint32_t' as indices so that as much as possible of this 
             * space can be used.
             */
            uint32_t delta = ((_capacity >> 1) + (_capacity >> 3) + 2) & ~1;
            _capacity += delta;

            if (_capacity <= prev_cap) {
                throw std::bad_alloc();
            }
        }

        _memory = (T *)std::realloc(_memory, UNIT_SIZE * _capacity);
        if (_memory == NULL) { throw std::bad_alloc(); }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl 0xc(%rdi), %eax
cmpl %esi, %eax
jae 0x6792
movq %rdi, %rbx
movl %eax, %ecx
cmpl %esi, %ecx
jae 0x677c
movl %ecx, %edx
shrl %edx
movl %ecx, %edi
shrl $0x3, %edi
addl %edx, %edi
andl $-0x2, %edi
addl %edi, %ecx
addl $0x2, %ecx
movl %ecx, 0xc(%rbx)
cmpl %eax, %ecx
ja 0x6730
movl $0x8, %edi
callq 0x20a0
movq 0x5821(%rip), %rcx      # 0xbf80
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x5833(%rip), %rsi      # 0xbfa0
movq 0x57fc(%rip), %rdx      # 0xbf70
movq %rax, %rdi
callq 0x2250
movq (%rbx), %rdi
movl %ecx, %esi
shlq $0x2, %rsi
callq 0x2240
movq %rax, (%rbx)
testq %rax, %rax
je 0x674e
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Myyura[P]MyyuraSat/./source/../include/core/../type/clause.hpp
// Function: MyyuraSat::Clause::calc_abstraction()
void calc_abstraction(void) {
        if (!_header.has_extra) {
            throw std::logic_error("Clause::calc_abstraction : has_extra is false");
        }

        uint32_t abstraction = 0;
        for (int i = 0; i < size(); i++) {
            abstraction |= _data[i].lit.abstraction();
        }
        _data[_header.size].abst = abstraction;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl (%rdi), %ecx
testb $0x8, %cl
je 0x6838
movl %ecx, %eax
shrl $0x5, %eax
cmpl $0x1f, %ecx
ja 0x6816
xorl %ecx, %ecx
jmp 0x682f
movl %eax, %eax
xorl %edx, %edx
xorl %ecx, %ecx
movb 0x4(%rdi,%rdx,4), %sil
shrb %sil
btsl %esi, %ecx
incq %rdx
cmpq %rdx, %rax
jne 0x681c
movl %ecx, 0x4(%rdi,%rax,4)
popq %rbx
popq %r14
popq %rbp
retq
movl $0x10, %edi
callq 0x20a0
movq %rax, %rbx
leaq 0x1afd(%rip), %rsi      # 0x8349
movq %rax, %rdi
callq 0x21d0
movq 0x577d(%rip), %rsi      # 0xbfd8
movq 0x572e(%rip), %rdx      # 0xbf90
movq %rbx, %rdi
callq 0x2250
movq %rax, %r14
movq %rbx, %rdi
callq 0x20f0
movq %r14, %rdi
callq 0x2270
nop
// File: /workspace/github_cpp_makefile_star2_O3/Myyura[P]MyyuraSat/./source/../include/core/../type/clause.hpp
// Function: MyyuraSat::ClauseAllocator::alloc(MyyuraSat::Clause const&)
CRARef alloc(const Clause& from) {
        bool use_extra = from.learnt() | _extra_clause_field;
        CRARef cid = _ra.alloc(clause_word32size(from.size(), use_extra));
        new (lea(cid)) Clause(from, use_extra);
        return cid;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl (%rsi), %eax
movzbl 0x18(%rdi), %ecx
movl %eax, %r15d
shrl $0x2, %r15d
andl $0x1, %r15d
orl %ecx, %r15d
shrl $0x5, %eax
leal (%rax,%r15), %esi
incl %esi
callq 0x661c
movl %eax, %r12d
movq %r14, %rdi
movl %eax, %esi
callq 0x679a
movq %rax, %rdi
movq %rbx, %rsi
movl %r15d, %edx
callq 0x6938
movl %r12d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Myyura[P]MyyuraSat/./source/../include/core/../type/clause.hpp
// Function: MyyuraSat::Clause::Clause(MyyuraSat::Clause const&, bool)
Clause(const Clause& from, bool use_extra) {
        _header = from._header;
        _header.has_extra = use_extra;
        // NOTE: the copied clause may lose the extra field.

        for (int i = 0; i < from.size(); i++) {
            _data[i].lit = from[i];
        }

        if (_header.has_extra) {
            if (_header.learnt) {
                _data[_header.size].act = from._data[_header.size].act;
            } else {
                _data[_header.size].abst = from._data[_header.size].abst;
            }
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl (%rsi), %eax
movl %eax, %ecx
andl $-0x9, %ecx
leal (%rcx,%rdx,8), %ecx
movl %ecx, (%rdi)
cmpl $0x20, (%rsi)
jb 0x6968
xorl %ecx, %ecx
movl 0x4(%rsi,%rcx,4), %r8d
movl %r8d, 0x4(%rdi,%rcx,4)
incq %rcx
movl (%rsi), %r8d
shrl $0x5, %r8d
cmpq %r8, %rcx
jb 0x694f
testb %dl, %dl
je 0x698e
movl %eax, %ecx
shrl $0x5, %ecx
shll $0x2, %ecx
testb $0x4, %al
jne 0x6982
movl 0x4(%rsi,%rcx), %eax
movl %eax, 0x4(%rdi,%rcx)
jmp 0x698e
movss 0x4(%rsi,%rcx), %xmm0
movss %xmm0, 0x4(%rdi,%rcx)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Myyura[P]MyyuraSat/./source/../include/core/../type/../util/vector.hpp
// Function: MyyuraSat::Vector<MyyuraSat::Vector<unsigned int, int>, int>::clear(bool)
void clear(bool dealloc = false) {
        if (_data != NULL) {
            for (SizeType i = 0; i < _size; i++) { _data[i].~T(); }
            _size = 0;
            if (dealloc) {
                free(_data);
                _data = NULL;
                _capacity = 0;
            }
        }
    }

// Assembly:
cmpq $0x0, (%rdi)
je 0x6c42
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl %esi, -0x2c(%rbp)
movl 0x8(%rdi), %eax
testl %eax, %eax
jle 0x6c11
xorl %r15d, %r15d
xorl %r12d, %r12d
xorl %r13d, %r13d
movq (%rbx), %r14
movq (%r14,%r12), %rdi
testq %rdi, %rdi
je 0x6c02
movl %r15d, 0x8(%r14,%r12)
callq 0x2180
movq $0x0, (%r14,%r12)
movl %r15d, 0xc(%r14,%r12)
movl 0x8(%rbx), %eax
incq %r13
movslq %eax, %rcx
addq $0x10, %r12
cmpq %rcx, %r13
jl 0x6bdc
movl $0x0, 0x8(%rbx)
cmpb $0x0, -0x2c(%rbp)
je 0x6c34
movq (%rbx), %rdi
callq 0x2180
movq $0x0, (%rbx)
movl $0x0, 0xc(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Myyura[P]MyyuraSat/./source/../include/core/../type/clause.hpp
// Function: MyyuraSat::Clause::shrink(int)
void shrink (int i) {
        if (i > size()) {
            throw std::out_of_range("Clause::shrink : out of size");
        }

        if (_header.has_extra) {
            _data[_header.size - i] = _data[_header.size];
        }

        _header.size -= i;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl (%rdi), %eax
movl %eax, %ecx
shrl $0x5, %ecx
movl %ecx, %edx
subl %esi, %edx
jl 0x6d75
testb $0x8, %al
je 0x6d5f
movslq %edx, %rax
movl 0x4(%rdi,%rcx,4), %ecx
movl %ecx, 0x4(%rdi,%rax,4)
movl (%rdi), %eax
shll $0x5, %esi
movl %eax, %ecx
subl %esi, %ecx
andl $-0x20, %ecx
andl $0x1f, %eax
orl %ecx, %eax
movl %eax, (%rdi)
popq %rbx
popq %r14
popq %rbp
retq
movl $0x10, %edi
callq 0x20a0
movq %rax, %rbx
leaq 0x169c(%rip), %rsi      # 0x8425
movq %rax, %rdi
callq 0x2050
movq 0x5230(%rip), %rsi      # 0xbfc8
movq 0x5211(%rip), %rdx      # 0xbfb0
movq %rbx, %rdi
callq 0x2250
movq %rax, %r14
movq %rbx, %rdi
callq 0x20f0
movq %r14, %rdi
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O3/Myyura[P]MyyuraSat/./source/../include/core/../util/occurence_list.hpp
// Function: MyyuraSat::OccurenceList<MyyuraSat::Literal, unsigned int, MyyuraSat::Vector<unsigned int, int>, MyyuraSat::LiteralIndexDefault>::clean(MyyuraSat::Literal const&)
void clean(const K& idx) {
        Vec& vec = _occs[idx];
        int i, j;
        for (i = j = 0; i < vec.size(); i++) {
            if (!_deleted(vec[i])) { vec[j++] = vec[i]; }
        }

        vec.shrink(i - j);
        _dirty[idx] = 0;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl (%rsi), %esi
callq 0x73aa
movq %rax, %r15
cmpl $0x0, 0x8(%rax)
jle 0x7375
movq %r14, -0x30(%rbp)
leaq 0x40(%rbx), %rax
movq %rax, -0x38(%rbp)
xorl %r14d, %r14d
xorl %r12d, %r12d
xorl %r13d, %r13d
cmpq $0x0, 0x50(%rbx)
je 0x73a4
movq (%r15), %rsi
addq %r14, %rsi
movq -0x38(%rbp), %rdi
callq *0x58(%rbx)
testb %al, %al
jne 0x735c
movq (%r15), %rax
movl (%rax,%r14), %ecx
movslq %r13d, %rdx
incl %r13d
movl %ecx, (%rax,%rdx,4)
incq %r12
movslq 0x8(%r15), %rax
addq $0x4, %r14
cmpq %rax, %r12
jl 0x7334
subl %r13d, %r12d
movq -0x30(%rbp), %r14
jmp 0x7378
xorl %r12d, %r12d
movq %r15, %rdi
movl %r12d, %esi
callq 0x5c9e
addq $0x18, %rbx
movl (%r14), %esi
movq %rbx, %rdi
callq 0x718a
movb $0x0, (%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x2080
nop
// File: /workspace/github_cpp_makefile_star2_O3/Myyura[P]MyyuraSat/./source/../include/core/../type/../util/vector.hpp
// Function: MyyuraSat::Vector<MyyuraSat::Vector<MyyuraSat::Solver::_Watcher, int>, int>::grow_to(int)
void grow_to(SizeType size) {
        if (_size >= size) { return; }
        reserve(size);
        for (SizeType i = _size; i < size; i++) { new (&_data[i]) T(); }
        _size = size;
    }

// Assembly:
cmpl %esi, 0x8(%rdi)
jge 0x7519
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
callq 0x751a
movslq 0x8(%r14), %rax
cmpl %ebx, %eax
jge 0x7511
movslq %ebx, %rcx
subq %rax, %rcx
shlq $0x4, %rax
xorps %xmm0, %xmm0
movq (%r14), %rdx
movups %xmm0, (%rdx,%rax)
addq $0x10, %rax
decq %rcx
jne 0x7501
movl %ebx, 0x8(%r14)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Myyura[P]MyyuraSat/./source/../include/core/../type/../util/vector.hpp
// Function: MyyuraSat::Vector<bool, int>::grow_to(int, bool const&)
void grow_to(SizeType size, const T& pad) {
        if (_size >= size) { return; }
        reserve(size);
        for (SizeType i = _size; i < size; i++) { _data[i] = pad; }
        _size = size;
    }

// Assembly:
cmpl %esi, 0x8(%rdi)
jge 0x75e5
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r15
movl %esi, %ebx
movq %rdi, %r14
callq 0x75e6
movslq 0x8(%r14), %rax
cmpl %ebx, %eax
jge 0x75d7
movq (%r14), %rcx
movslq %ebx, %rdx
movb (%r15), %sil
movb %sil, (%rcx,%rax)
incq %rax
cmpq %rax, %rdx
jne 0x75cb
movl %ebx, 0x8(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/akw0088[P]openssl/adler32.c
// Function: adler32_roll
unsigned int adler32_roll(unsigned int adler, unsigned char buf_in, unsigned char buf_out, unsigned int block_size)
{
	unsigned short a = adler & 0xFFFF;
	unsigned short b = adler >> 16;

	int a32 = (a + buf_in - buf_out);
	while (a32 < 0)
	{
		a32 += MOD_ADLER;
	}
	a = a32 % MOD_ADLER;

	int b32 = b + a - 1 - block_size * buf_out;
	while (b32 < 0)
	{
		b32 += MOD_ADLER;
	}
	b = b32 % MOD_ADLER;

	return (b << 16) | a;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movzwl %di, %eax
addl %esi, %eax
movl %eax, %r8d
subl %edx, %r8d
xorl %r9d, %r9d
testl %r8d, %r8d
cmovlel %r9d, %r8d
addl %edx, %r8d
xorl %r10d, %r10d
cmpl %eax, %r8d
setne %r10b
subl %r10d, %r8d
subl %eax, %r8d
movl $0x80078071, %esi       # imm = 0x80078071
imulq %rsi, %r8
shrq $0x2f, %r8
addl %r10d, %r8d
imull $0xfff1, %r8d, %r10d    # imm = 0xFFF1
addl %eax, %r10d
shrl $0x10, %edi
subl %edx, %r10d
movl %r10d, %r8d
subl $0xfff1, %r8d           # imm = 0xFFF1
cmovbl %r10d, %r8d
imull %edx, %ecx
movl %ecx, %eax
notl %eax
leal (%rdi,%rax), %edx
addl %r8d, %edx
leal (%r8,%rdi), %r10d
testl %edx, %edx
cmovlel %r9d, %edx
addl %ecx, %edx
subl %r8d, %edx
incl %edx
xorl %ecx, %ecx
cmpl %edi, %edx
setne %cl
addl %ecx, %edi
subl %edi, %edx
imulq %rsi, %rdx
shrq $0x2f, %rdx
addl %ecx, %edx
imull $0xfff1, %edx, %ecx     # imm = 0xFFF1
addl %r10d, %eax
addl %ecx, %eax
imulq %rax, %rsi
shrq $0x2f, %rsi
imull $0xfff1, %esi, %ecx     # imm = 0xFFF1
subl %ecx, %eax
shll $0x10, %eax
addl %r8d, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/akw0088[P]openssl/adler32.c
// Function: main
int main(int argc, char** argv)
{
	if (argc < 2)
	{
		printf("Usage: adler32 file\r\n");
		return -1;
	}

	unsigned int length = 0;
	char *data = get_file(argv[1], &length);
	if (data == NULL)
	{
		printf("Unable to open %s\r\n", argv[1]);
	}

	
	unsigned int checksum = 0;
	checksum = adler32(data, length);
	printf("%08X\r\n", checksum);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
cmpl $0x1, %edi
jg 0x13ca
leaq 0xc67(%rip), %rdi       # 0x2022
callq 0x1040
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jmp 0x1493
movq %rsi, %rbx
leaq -0xc(%rbp), %rsi
movl $0x0, (%rsi)
movq 0x8(%rbx), %rdi
callq 0x12f7
testq %rax, %rax
je 0x146c
movl -0xc(%rbp), %ecx
testq %rcx, %rcx
je 0x147e
movl $0x1, %edx
xorl %edi, %edi
movl $0xffff, %r8d           # imm = 0xFFFF
movl $0x80078071, %r9d       # imm = 0x80078071
xorl %esi, %esi
andl %r8d, %edx
movsbl (%rax,%rdi), %r10d
addl %edx, %r10d
movslq %r10d, %rdx
imulq $-0x7ff87f8f, %rdx, %r10 # imm = 0x80078071
shrq $0x20, %r10
addl %edx, %r10d
movl %r10d, %r11d
shrl $0x1f, %r11d
sarl $0xf, %r10d
addl %r11d, %r10d
imull $0xfff1, %r10d, %r10d   # imm = 0xFFF1
subl %r10d, %edx
movl %edx, %r10d
andl %r8d, %r10d
addl %r10d, %esi
movq %rsi, %r11
imulq %r9, %r11
shrq $0x2f, %r11
imull $0xfff1, %r11d, %r11d   # imm = 0xFFF1
subl %r11d, %esi
incq %rdi
cmpq %rdi, %rcx
jne 0x140a
shll $0x10, %esi
orl %r10d, %esi
jmp 0x1483
movq 0x8(%rbx), %rsi
leaq 0xb90(%rip), %rdi       # 0x2007
xorl %eax, %eax
callq 0x1070
movl $0x1, %esi
leaq 0xb91(%rip), %rdi       # 0x201b
xorl %ebx, %ebx
xorl %eax, %eax
callq 0x1070
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/TsukiGva2[P]Blade-lang/blade.cpp
// Function: read_a_line(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::string read_a_line(std::string p){
	std::string read;
	std::cout << p;
	if (!std::getline(std::cin, read)){
		std::cout << "error reading line\n";
		exit(1); // 1 is an error code
	}
	return read;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
leaq 0x1083e6(%rip), %rdi    # 0x11f980
movq %rax, %rsi
callq 0x96cb0
leaq 0x1084f7(%rip), %rdi    # 0x11faa0
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl $0xa, %esi
callq 0x77e00
movsbl %al, %edx
leaq 0x1084dc(%rip), %rdi    # 0x11faa0
movq %rbx, %rsi
callq 0x2d3d0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x175e8
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x108391(%rip), %rdi    # 0x11f980
leaq 0xc1b12(%rip), %rsi     # 0xd9108
callq 0x971e0
movl $0x1, %edi
callq 0x14150
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x1761b
movq (%r15), %rsi
incq %rsi
callq 0x2a9a0
movq %r14, %rdi
callq 0xd5f80
// File: /workspace/github_cpp_makefile_star2_O3/TsukiGva2[P]Blade-lang/blade.cpp
// Function: replace_str(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::string replace_str (std::string str, int start, int end, std::string new_str) {
	std::string result = str.substr(0,start);
	result += new_str;
	result += str.substr(std::min((int)str.size(), end));
	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %r8, %r12
movl %ecx, %r15d
movq %rsi, %r14
movq %rdi, %rbx
movslq %edx, %rcx
xorl %edx, %edx
callq 0xa9bf0
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %rbx, %rdi
callq 0xa8bb0
movl 0x8(%r14), %eax
cmpl %r15d, %eax
cmovll %eax, %r15d
movslq %r15d, %rdx
leaq -0x40(%rbp), %rdi
movq %r14, %rsi
movq $-0x1, %rcx
callq 0xa9bf0
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
movq %rbx, %rdi
callq 0xa8bb0
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x176f7
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x2a9a0
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1772a
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x2a9a0
jmp 0x1772a
jmp 0x17727
movq %rax, %r14
movq (%rbx), %rdi
addq $0x10, %rbx
cmpq %rbx, %rdi
je 0x17741
movq (%rbx), %rsi
incq %rsi
callq 0x2a9a0
movq %r14, %rdi
callq 0xd5f80
// File: /workspace/github_cpp_makefile_star2_O3/TsukiGva2[P]Blade-lang/blade.cpp
// Function: add(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>)
std::string add(std::vector<std::string> nums){
	int acc = 0;
	for (std::string i : nums) {
		if (std::regex_match(i, is_number)) { acc += std::stoi(i); }
	}
	return std::to_string(acc);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, -0x78(%rbp)
movq (%rsi), %r12
movq 0x8(%rsi), %r13
xorl %r14d, %r14d
cmpq %r13, %r12
je 0x18107
leaq -0x40(%rbp), %r15
movq %r15, -0x50(%rbp)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
leaq -0x50(%rbp), %rdi
callq 0x1abf2
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
addq %rdi, %rsi
xorps %xmm0, %xmm0
movaps %xmm0, -0x60(%rbp)
movaps %xmm0, -0x70(%rbp)
leaq -0x70(%rbp), %rdx
leaq 0x10694f(%rip), %rcx    # 0x11e9b8
xorl %r8d, %r8d
callq 0x271d9
movl %eax, %ebx
movq -0x70(%rbp), %rdi
testq %rdi, %rdi
je 0x18088
movq -0x60(%rbp), %rsi
subq %rdi, %rsi
callq 0x2a9a0
testb %bl, %bl
je 0x180e5
movq -0x50(%rbp), %r15
callq 0x144c0
movq %rax, %rbx
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
movl $0x0, (%rbx)
movq %r15, %rdi
leaq -0x70(%rbp), %rsi
movl $0xa, %edx
callq 0x14400
cmpq %r15, -0x70(%rbp)
je 0x181aa
movslq %eax, %rcx
cmpq %rax, %rcx
jne 0x181b6
movl (%rbx), %ecx
cmpl $0x22, %ecx
je 0x181b6
testl %ecx, %ecx
jne 0x180de
movl -0x2c(%rbp), %ecx
movl %ecx, (%rbx)
addl %eax, %r14d
leaq -0x40(%rbp), %r15
movq -0x50(%rbp), %rdi
cmpq %r15, %rdi
je 0x180fa
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x2a9a0
addq $0x20, %r12
cmpq %r13, %r12
jne 0x1802f
movl %r14d, %r15d
negl %r15d
cmovsl %r14d, %r15d
movl $0x1, %r12d
cmpl $0xa, %r15d
jb 0x18167
movl $0x4, %r12d
movl $0xd1b71759, %eax       # imm = 0xD1B71759
movl %r15d, %ecx
cmpl $0x63, %ecx
jbe 0x1815e
cmpl $0x3e7, %ecx            # imm = 0x3E7
jbe 0x18164
cmpl $0x2710, %ecx           # imm = 0x2710
jb 0x18167
movl %ecx, %edx
imulq %rax, %rdx
shrq $0x2d, %rdx
addl $0x4, %r12d
cmpl $0x1869f, %ecx          # imm = 0x1869F
movl %edx, %ecx
ja 0x1812b
addl $-0x3, %r12d
jmp 0x18167
addl $-0x2, %r12d
jmp 0x18167
decl %r12d
shrl $0x1f, %r14d
leal (%r12,%r14), %esi
movq -0x78(%rbp), %rbx
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq %rbx, %rdi
movl $0x2d, %edx
callq 0xa6ea0
addq (%rbx), %r14
movq %r14, %rdi
movl %r12d, %esi
movl %r15d, %edx
callq 0x1aa4f
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xc1139(%rip), %rdi     # 0xd92ea
callq 0x1625c
leaq 0xc112d(%rip), %rdi     # 0xd92ea
callq 0x1630c
movq %rax, %r15
movq -0x70(%rbp), %rdi
testq %rdi, %rdi
je 0x181e9
movq -0x60(%rbp), %rsi
subq %rdi, %rsi
callq 0x2a9a0
jmp 0x181e9
movq %rax, %r15
cmpl $0x0, (%rbx)
jne 0x181e9
movl -0x2c(%rbp), %eax
movl %eax, (%rbx)
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x18202
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x2a9a0
movq %r15, %rdi
callq 0xd5f80
// File: /workspace/github_cpp_makefile_star2_O3/TsukiGva2[P]Blade-lang/blade.cpp
// Function: mul(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>)
std::string mul(std::vector<std::string> nums){
	long int acc = 1;
	for (std::string i : nums) {
		if (std::regex_match(i, is_number)) {
			acc *= std::stol(i);
		}
	}
	return std::to_string(acc);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, -0x78(%rbp)
movq (%rsi), %r12
movq 0x8(%rsi), %r15
movl $0x1, %r14d
cmpq %r15, %r12
je 0x18661
leaq -0x50(%rbp), %r13
leaq -0x40(%rbp), %rax
movq %rax, -0x50(%rbp)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
movq %r13, %rdi
callq 0x1abf2
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
addq %rdi, %rsi
xorps %xmm0, %xmm0
movaps %xmm0, -0x60(%rbp)
movaps %xmm0, -0x70(%rbp)
leaq -0x70(%rbp), %rdx
leaq 0x1063f5(%rip), %rcx    # 0x11e9b8
xorl %r8d, %r8d
callq 0x271d9
movl %eax, %ebx
movq -0x70(%rbp), %rdi
testq %rdi, %rdi
je 0x185e2
movq -0x60(%rbp), %rsi
subq %rdi, %rsi
callq 0x2a9a0
testb %bl, %bl
je 0x1863b
movq %r15, %r13
movq -0x50(%rbp), %r15
callq 0x144c0
movq %rax, %rbx
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
movl $0x0, (%rbx)
movq %r15, %rdi
leaq -0x70(%rbp), %rsi
movl $0xa, %edx
callq 0x14400
cmpq %r15, -0x70(%rbp)
je 0x1870e
movl (%rbx), %ecx
testl %ecx, %ecx
je 0x1862b
cmpl $0x22, %ecx
jne 0x18630
jmp 0x1871a
movl -0x2c(%rbp), %ecx
movl %ecx, (%rbx)
imulq %rax, %r14
movq %r13, %r15
leaq -0x50(%rbp), %r13
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x18654
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x2a9a0
addq $0x20, %r12
cmpq %r15, %r12
jne 0x18586
movq %r14, %r15
negq %r15
cmovsq %r14, %r15
movl $0x1, %r12d
cmpq $0xa, %r15
jb 0x186cb
movl $0x4, %r12d
movabsq $0x346dc5d63886594b, %rsi # imm = 0x346DC5D63886594B
movq %r15, %rcx
cmpq $0x63, %rcx
jbe 0x186c2
cmpq $0x3e7, %rcx            # imm = 0x3E7
jbe 0x186c8
cmpq $0x2710, %rcx           # imm = 0x2710
jb 0x186cb
movq %rcx, %rax
mulq %rsi
shrq $0xb, %rdx
addl $0x4, %r12d
cmpq $0x1869f, %rcx          # imm = 0x1869F
movq %rdx, %rcx
ja 0x1868a
addl $-0x3, %r12d
jmp 0x186cb
addl $-0x2, %r12d
jmp 0x186cb
decl %r12d
shrq $0x3f, %r14
leal (%r14,%r12), %esi
movq -0x78(%rbp), %rbx
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq %rbx, %rdi
movl $0x2d, %edx
callq 0xa6ea0
addq (%rbx), %r14
movq %r14, %rdi
movl %r12d, %esi
movq %r15, %rdx
callq 0x1aac1
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xc0bda(%rip), %rdi     # 0xd92ef
callq 0x1625c
leaq 0xc0bce(%rip), %rdi     # 0xd92ef
callq 0x1630c
movq %rax, %r15
cmpl $0x0, (%rbx)
jne 0x1874d
movl -0x2c(%rbp), %eax
movl %eax, (%rbx)
jmp 0x1874d
movq %rax, %r15
movq -0x70(%rbp), %rdi
testq %rdi, %rdi
je 0x1874d
movq -0x60(%rbp), %rsi
subq %rdi, %rsi
callq 0x2a9a0
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x18766
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x2a9a0
movq %r15, %rdi
callq 0xd5f80
// File: /workspace/github_cpp_makefile_star2_O3/TsukiGva2[P]Blade-lang/blade.cpp
// Function: makefun(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>)
std::string makefun(std::vector<std::string> exprs){
	std::string aexpr = *(exprs.begin()+1);
	std::cout << aexpr << endl;
	usfuns_map[*exprs.begin()] = "[_xfun \"" + aexpr + "\"]";
	return usfuns_map[*exprs.begin()];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
leaq -0x58(%rbp), %r12
movq %r12, -0x10(%r12)
movq 0x20(%rax), %rsi
movq 0x28(%rax), %rdx
addq %rsi, %rdx
leaq -0x68(%rbp), %r15
movq %r15, %rdi
callq 0x1abf2
movq (%r15), %rsi
movq 0x8(%r15), %rdx
leaq 0x106859(%rip), %rdi    # 0x11f980
callq 0x96cb0
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x77e00
movsbl %al, %esi
movq %r15, %rdi
callq 0x967b0
movq %rax, %rdi
callq 0x95d80
leaq 0xc0076(%rip), %rsi     # 0xd91d3
leaq -0x88(%rbp), %rdi
leaq -0x68(%rbp), %rdx
callq 0x1a811
leaq 0xc0068(%rip), %rsi     # 0xd91dc
leaq -0x88(%rbp), %rdi
callq 0xa8cf0
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x191a4
movq %rdx, -0x48(%rbp)
movq (%rcx), %rdx
movq %rdx, -0x38(%rbp)
jmp 0x191ac
movups (%rcx), %xmm0
movups %xmm0, (%r13)
movq 0x8(%rax), %rdx
movq %rdx, -0x40(%rbp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq (%r14), %rsi
leaq 0x105773(%rip), %rdi    # 0x11e940
callq 0x1a50e
leaq -0x48(%rbp), %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0xa7590
movq (%r15), %rdi
cmpq %r13, %rdi
je 0x191f5
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2a9a0
leaq -0x78(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1920e
movq -0x78(%rbp), %rsi
incq %rsi
callq 0x2a9a0
movq (%r14), %rsi
leaq 0x105728(%rip), %rdi    # 0x11e940
callq 0x1a50e
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x1abf2
movq -0x68(%rbp), %rdi
cmpq %r12, %rdi
je 0x1924b
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x2a9a0
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x1927a
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2a9a0
jmp 0x1927a
movq %rax, %rbx
leaq -0x78(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1929c
movq -0x78(%rbp), %rsi
incq %rsi
callq 0x2a9a0
jmp 0x1929c
jmp 0x19299
jmp 0x19299
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r12, %rdi
je 0x192b1
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x2a9a0
movq %rbx, %rdi
callq 0xd5f80
// File: /workspace/github_cpp_makefile_star2_O3/TsukiGva2[P]Blade-lang/blade.cpp
// Function: bit_(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>)
std::string bit_(std::vector<std::string> binds){
	if (binds.size() < 2){
		return "too few arguments for _bit";
	}
	if (binds[1].size() > 1){
		return "this value is to big, use 'bits' or 'let' instead";
	}
	vars[binds[0]] = binds[1];
	return vars[binds[0]];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rsi
movq 0x8(%r14), %rax
subq %rsi, %rax
cmpq $0x20, %rax
ja 0x192f1
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0xbfef7(%rip), %rsi     # 0xd91df
leaq 0xbff0a(%rip), %rdx     # 0xd91f9
jmp 0x1930d
cmpq $0x2, 0x28(%rsi)
jb 0x19317
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0xbfef4(%rip), %rsi     # 0xd91fa
leaq 0xbff1e(%rip), %rdx     # 0xd922b
movq %rbx, %rdi
callq 0x1ac90
jmp 0x19359
leaq 0x20(%rsi), %r15
leaq 0x105666(%rip), %r12    # 0x11e988
movq %r12, %rdi
callq 0x1a50e
movq %rax, %rdi
movq %r15, %rsi
callq 0xa7170
movq (%r14), %rsi
movq %r12, %rdi
callq 0x1a50e
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x1abf2
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/TsukiGva2[P]Blade-lang/blade.cpp
// Function: let_(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>)
std::string let_(std::vector<std::string> binds){
	if (binds.size() < 2){
		return "too few arguments for _let";
	}
	vars[binds[0]] = binds[1];
	return vars[binds[0]];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rsi
movq 0x8(%r14), %rax
subq %rsi, %rax
cmpq $0x20, %rax
ja 0x193a5
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0xbfe98(%rip), %rsi     # 0xd922c
leaq 0xbfeab(%rip), %rdx     # 0xd9246
movq %rbx, %rdi
callq 0x1ac90
jmp 0x193e7
leaq 0x20(%rsi), %r15
leaq 0x1055d8(%rip), %r12    # 0x11e988
movq %r12, %rdi
callq 0x1a50e
movq %rax, %rdi
movq %r15, %rsi
callq 0xa7170
movq (%r14), %rsi
movq %r12, %rdi
callq 0x1a50e
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x1abf2
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/TsukiGva2[P]Blade-lang/blade.cpp
// Function: at(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>)
std::string _at(std::vector<std::string> args){ // @ -> at -> Append To.
	if (args.size() < 2){
		return "too few arguments for appendTo";
	}
	std::string result = args[0];
	std::vector<std::string> argsbf(args.begin()+1, args.end());
	for (std::string i : argsbf){
		result += i;
	}
	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq (%rsi), %rax
movq 0x8(%rsi), %rcx
subq %rax, %rcx
leaq 0x10(%rdi), %rdx
movq %rdx, (%rdi)
cmpq $0x20, %rcx
ja 0x19793
leaq 0xbfaff(%rip), %rsi     # 0xd927e
leaq 0xbfb16(%rip), %rdx     # 0xd929c
movq %rbx, %rdi
callq 0x1ac90
jmp 0x19828
movq %rsi, %r14
movq %rdx, -0x30(%rbp)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x1abf2
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq $0x20, %rsi
leaq -0x68(%rbp), %rdi
leaq -0x50(%rbp), %rcx
callq 0x1a7d0
movq -0x68(%rbp), %r12
movq -0x60(%rbp), %r15
cmpq %r15, %r12
je 0x1981f
leaq -0x40(%rbp), %r13
leaq -0x50(%rbp), %r14
movq %r13, -0x50(%rbp)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
movq %r14, %rdi
callq 0x1abf2
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
movq %rbx, %rdi
callq 0xa8bb0
movq -0x50(%rbp), %rdi
cmpq %r13, %rdi
je 0x19816
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x2a9a0
addq $0x20, %r12
cmpq %r15, %r12
jne 0x197d9
leaq -0x68(%rbp), %rdi
callq 0x1a1ee
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x19865
movq %rax, %r14
jmp 0x1985c
movq %rax, %r14
movq -0x50(%rbp), %rdi
cmpq %r13, %rdi
je 0x1985c
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x2a9a0
leaq -0x68(%rbp), %rdi
callq 0x1a1ee
movq (%rbx), %rdi
cmpq -0x30(%rbp), %rdi
je 0x1987d
movq -0x30(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x2a9a0
movq %r14, %rdi
callq 0xd5f80
// File: /workspace/github_cpp_makefile_star2_O3/obliviousram[P]PathOHeap/src/Block.cpp
// Function: operator<<(std::ostream&, Block const&)
std::ostream& operator<<(std::ostream& out, const Block& b) {
  if (b.leaf_id != -1) {
    out << "Block (leaf, t, k, v) = " << b.leaf_id << " " << b.t << " " << b.k << " [ ";
    for (std::byte byte : b.v) {
      out << std::to_integer<int>(byte) << " ";
    }
    out << "]";
  } else {
    out << "Dummy block";
  }
  return out;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $-0x1, (%rsi)
je 0x272f
movq %rsi, %r14
leaq 0x497e(%rip), %rsi      # 0x7004
movl $0x18, %edx
movq %rbx, %rdi
callq 0x2190
movl (%r14), %esi
movq %rbx, %rdi
callq 0x2240
movq %rax, %r12
leaq 0x4be5(%rip), %r15      # 0x728d
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x2190
movq 0x8(%r14), %rsi
movq %r12, %rdi
callq 0x2140
movq %rax, %r12
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x2190
movl 0x10(%r14), %esi
movq %r12, %rdi
callq 0x2240
leaq 0x4933(%rip), %rsi      # 0x701d
movl $0x3, %edx
movq %rax, %rdi
callq 0x2190
xorl %r12d, %r12d
movzbl 0x14(%r14,%r12), %esi
movq %rbx, %rdi
callq 0x2240
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x2190
incq %r12
cmpq $0x20, %r12
jne 0x26fa
leaq 0x48f9(%rip), %rsi      # 0x7021
movl $0x1, %edx
jmp 0x273b
leaq 0x48ed(%rip), %rsi      # 0x7023
movl $0xb, %edx
movq %rbx, %rdi
callq 0x2190
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/obliviousram[P]PathOHeap/src/Bucket.cpp
// Function: Bucket::removeBlock(long)
std::optional<Block> Bucket::removeBlock(long t) {
  int removed_index = -1;
  for (int i = 0; i < this->blocks.size(); i++) {
    if (this->blocks.at(i).t == t) {
      removed_index = i;
      break;
    }
  }

  if (removed_index == -1) {
    return std::nullopt;
  } else {
    Block removed_copy = Block(this->blocks.at(removed_index));
    this->blocks.erase(this->blocks.begin() + removed_index);
    return std::optional<Block>{removed_copy};
  }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x38(%rsi), %rdi
movq 0x40(%rsi), %rdx
movq %rdx, %rsi
subq %rdi, %rsi
je 0x2893
sarq $0x3, %rsi
movabsq $0x6db6db6db6db6db7, %rcx # imm = 0x6DB6DB6DB6DB6DB7
imulq %rsi, %rcx
cmpq $0x1, %rcx
adcq $0x0, %rcx
leaq 0x8(%rdi), %r8
xorl %esi, %esi
cmpq %rax, (%r8)
je 0x2899
incq %rsi
addq $0x38, %r8
cmpq %rsi, %rcx
jne 0x2882
movb $0x0, 0x38(%rbx)
jmp 0x290c
movl %esi, %eax
imulq $0x38, %rax, %rax
leaq (%rdi,%rax), %rsi
addq $0x38, %rsi
movq -0x8(%rsi), %rcx
movq %rcx, 0x30(%rsp)
movups -0x38(%rsi), %xmm0
movups -0x28(%rsi), %xmm1
movups -0x18(%rsi), %xmm2
movaps %xmm2, 0x20(%rsp)
movaps %xmm1, 0x10(%rsp)
movaps %xmm0, (%rsp)
cmpq %rdx, %rsi
je 0x28de
addq %rax, %rdi
subq %rsi, %rdx
callq 0x2210
movq 0x40(%r14), %rdx
addq $-0x38, %rdx
movq %rdx, 0x40(%r14)
movq 0x30(%rsp), %rax
movq %rax, 0x30(%rbx)
movaps (%rsp), %xmm0
movaps 0x10(%rsp), %xmm1
movaps 0x20(%rsp), %xmm2
movups %xmm2, 0x20(%rbx)
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
movb $0x1, 0x38(%rbx)
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/obliviousram[P]PathOHeap/src/Bucket.cpp
// Function: Bucket::setMaxSize(int)
void Bucket::setMaxSize(int maximum_size) {
  if (Bucket::is_init) {
    throw std::runtime_error("Max Bucket Size was already set");
  }
  Bucket::max_size = maximum_size;
  Bucket::is_init = true;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpb $0x1, 0x883a(%rip)      # 0xb163
je 0x2940
movl %edi, 0x881f(%rip)      # 0xb150
movb $0x1, 0x882b(%rip)      # 0xb163
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x20c0
movq %rax, %rbx
leaq 0x470b(%rip), %rsi      # 0x705f
movq %rax, %rdi
callq 0x2090
movq 0x868d(%rip), %rsi      # 0xaff0
movq 0x865e(%rip), %rdx      # 0xafc8
movq %rbx, %rdi
callq 0x2230
movq %rax, %r14
movq %rbx, %rdi
callq 0x2110
movq %r14, %rdi
callq 0x2250
nop
// File: /workspace/github_cpp_makefile_star2_O3/obliviousram[P]PathOHeap/src/OHeapReadPathEviction.cpp
// Function: OHeapReadPathEviction::findMin()
Block OHeapReadPathEviction::findMin() {
  Block ret = this->onlyFindMin();

  if (this->type_hiding_security) {
    this->onlyDeleteBlock(-1, -1);
    this->insertDummyBlock();
  }

  return ret;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x3f68
cmpb $0x1, 0x28(%r14)
jne 0x3f5c
movq %rsp, %rdi
movq %r14, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq $-0x1, %rcx
callq 0x4056
movq %r14, %rdi
callq 0x4472
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/obliviousram[P]PathOHeap/src/OHeapReadPathEviction.cpp
// Function: OHeapReadPathEviction::onlyFindMin()
Block OHeapReadPathEviction::onlyFindMin() {
  Block min = this->storage->readBucket(P(0,0)).subtree_min;
  if (this->stash.size() > 0) {
    const Block& stash_min = *std::min_element(this->stash.begin(), this->stash.end());
    if (stash_min < min) {
      min = stash_min;
    }
  }
  return min;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
movq 0x30(%rsi), %r15
movq %rsi, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq *0x30(%rax)
movq (%r15), %rcx
movq %rsp, %r12
movq %r12, %rdi
movq %r15, %rsi
movl %eax, %edx
callq *0x8(%rcx)
movq 0x30(%r12), %rax
movq %rax, 0x30(%rbx)
movups (%r12), %xmm0
movups 0x10(%r12), %xmm1
movups 0x20(%r12), %xmm2
movups %xmm2, 0x20(%rbx)
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
movq 0x38(%r12), %rdi
testq %rdi, %rdi
je 0x3fd9
movq 0x48(%rsp), %rsi
subq %rdi, %rsi
callq 0x2170
movq 0x40(%r14), %r15
movq 0x48(%r14), %r13
cmpq %r15, %r13
je 0x4044
leaq 0x38(%r15), %r12
cmpq %r13, %r12
je 0x4012
movq %r12, %rdi
movq %r15, %rsi
callq 0x2609
movq %r12, %r14
testb %al, %al
jne 0x4004
movq %r15, %r14
addq $0x38, %r12
movq %r14, %r15
cmpq %r13, %r12
jne 0x3fef
jmp 0x4015
movq %r15, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2609
testb %al, %al
je 0x4044
movl 0x30(%r14), %eax
movl %eax, 0x30(%rbx)
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups %xmm2, 0x20(%rbx)
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/obliviousram[P]PathOHeap/src/OHeapReadPathEviction.cpp
// Function: OHeapReadPathEviction::onlyDeleteBlock(int, long)
Block OHeapReadPathEviction::onlyDeleteBlock(int leaf, long t) {
  // try to delete from stash
  int removed_index = -1;
  for (int i = 0; i < stash.size(); i++) {
    Block& stash_block_ref = stash.at(i);
    if (stash_block_ref.leaf_id == leaf && stash_block_ref.t == t) {
      removed_index = i;
      break;
    }
  }

  Block stash_block = Block();
  if (removed_index != -1) {
    stash_block = Block(stash.at(removed_index));
    stash.erase(stash.begin() + removed_index);
  }

  // try to delete from storage (dummy ops if block was found in stash)
  Block storage_block = this->readAndRemove(leaf, t);
  this->evictAndUpdateMin(leaf);

  if (stash_block.t != -1) {
    return stash_block;
  } else {
    return storage_block;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rcx, %r15
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x40(%rsi), %rax
movq 0x48(%rsi), %rcx
subq %rax, %rcx
je 0x4138
sarq $0x3, %rcx
movabsq $0x6db6db6db6db6db7, %r12 # imm = 0x6DB6DB6DB6DB6DB7
imulq %r12, %rcx
cmpq $0x1, %rcx
adcq $0x0, %rcx
addq $0x8, %rax
xorl %r13d, %r13d
cmpl %ebp, -0x8(%rax)
jne 0x40ab
cmpq %r15, (%rax)
je 0x40bd
incq %r13
addq $0x38, %rax
cmpq %r13, %rcx
jne 0x40a1
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
movq %rsp, %rdi
callq 0x25e8
cmpl $-0x1, %r13d
je 0x4140
movslq %r13d, %rsi
movq 0x40(%r14), %rdi
movq 0x48(%r14), %rdx
movq %rdx, %rax
subq %rdi, %rax
sarq $0x3, %rax
imulq %r12, %rax
cmpq %rsi, %rax
jbe 0x419b
imulq $0x38, %rsi, %rax
leaq (%rdi,%rax), %rsi
addq $0x38, %rsi
movups -0x38(%rsi), %xmm0
movups -0x28(%rsi), %xmm1
movups -0x18(%rsi), %xmm2
movl -0x8(%rsi), %ecx
movl %ecx, 0x30(%rsp)
movaps %xmm2, 0x20(%rsp)
movaps %xmm1, 0x10(%rsp)
movaps %xmm0, (%rsp)
cmpq %rdx, %rsi
je 0x412e
addq %rax, %rdi
subq %rsi, %rdx
callq 0x2210
movq 0x48(%r14), %rdx
addq $-0x38, %rdx
movq %rdx, 0x48(%r14)
jmp 0x4140
movq %rsp, %rdi
callq 0x25e8
leaq 0x40(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
movl %ebp, %edx
movq %r15, %rcx
callq 0x499a
movq %r14, %rdi
movl %ebp, %esi
callq 0x44ca
movq %rsp, %rax
cmpq $-0x1, 0x8(%rax)
cmoveq %r12, %rax
movq 0x30(%rax), %rcx
movq %rcx, 0x30(%rbx)
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups 0x20(%rax), %xmm2
movups %xmm2, 0x20(%rbx)
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
movq %rbx, %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2f7b(%rip), %rdi      # 0x711d
movq %rax, %rdx
xorl %eax, %eax
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O3/obliviousram[P]PathOHeap/src/OHeapReadPathEviction.cpp
// Function: OHeapReadPathEviction::deleteBlock(int, long)
Block OHeapReadPathEviction::deleteBlock(int leaf, long t) {
  if (this->type_hiding_security) {
    this->onlyFindMin();
  }
    
  Block ret = this->onlyDeleteBlock(leaf, t);
    
  if (this->type_hiding_security) {
    this->insertDummyBlock();
  }

  this->t++;
  return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rcx, %r15
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x1, 0x28(%rsi)
jne 0x41d8
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x3f68
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
movq %r15, %rcx
callq 0x4056
cmpb $0x1, 0x28(%rbx)
jne 0x41f6
movq %rbx, %rdi
callq 0x4472
incq 0x20(%rbx)
movq %r14, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/obliviousram[P]PathOHeap/src/OHeapReadPathEviction.cpp
// Function: OHeapReadPathEviction::insertBlock(int, std::array<std::byte, 32ul>)
std::pair<int, int> OHeapReadPathEviction::insertBlock(int k, std::array<std::byte, Block::BLOCK_SIZE> v) {
  if (this->type_hiding_security) {
    this->onlyFindMin();
    this->onlyDeleteBlock(-1, -1);
  }

  auto ret = std::pair<int, int>(-1, -1);

  if (k != INT_MAX) {
    ret = this->onlyInsertBlock(k, v);
  } else {
    this->insertDummyBlock();
  }

  this->t++;
  return ret;
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x58, %rsp
movl %esi, %ebp
movq %rdi, %rbx
cmpb $0x1, 0x28(%rdi)
jne 0x423f
leaq 0x20(%rsp), %rdi
movq %rbx, %rsi
callq 0x3f68
leaq 0x20(%rsp), %rdi
movq %rbx, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq $-0x1, %rcx
callq 0x4056
cmpl $0x7fffffff, %ebp       # imm = 0x7FFFFFFF
jne 0x4258
movq %rbx, %rdi
callq 0x4472
movq $-0x1, %rax
jmp 0x4277
leaq 0x70(%rsp), %rax
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %rbx, %rdi
movl %ebp, %esi
callq 0x4282
incq 0x20(%rbx)
addq $0x58, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/obliviousram[P]PathOHeap/src/OHeapReadPathEviction.cpp
// Function: OHeapReadPathEviction::onlyInsertBlock(int, std::array<std::byte, 32ul>)
std::pair<int, int> OHeapReadPathEviction::onlyInsertBlock(int k, std::array<std::byte, Block::BLOCK_SIZE> v) {
  auto ret = std::pair<int, int>();

  int leaf = this->rand_gen->getRandomLeaf();
  stash.push_back(Block(leaf, this->t, k, v));
  
  ret.first = leaf;
  ret.second = this->t;

  this->evictAfterInsert();

  return ret;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x60, %rsp
movl %esi, %r14d
movq %rdi, %rbx
movq 0x38(%rdi), %rdi
movq (%rdi), %rax
callq *(%rax)
movl %eax, %ebp
movq 0x20(%rbx), %rdx
movaps 0x80(%rsp), %xmm0
movaps 0x90(%rsp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
leaq 0x28(%rsp), %rdi
movl %eax, %esi
movl %r14d, %ecx
callq 0x25cc
movq 0x48(%rbx), %rsi
cmpq 0x50(%rbx), %rsi
je 0x42fb
movq 0x58(%rsp), %rax
movq %rax, 0x30(%rsi)
movups 0x28(%rsp), %xmm0
movups 0x38(%rsp), %xmm1
movups 0x48(%rsp), %xmm2
movups %xmm2, 0x20(%rsi)
movups %xmm1, 0x10(%rsi)
movups %xmm0, (%rsi)
addq $0x38, 0x48(%rbx)
jmp 0x4309
leaq 0x40(%rbx), %rdi
leaq 0x28(%rsp), %rdx
callq 0x53cc
movq 0x20(%rbx), %r14
movq %rbx, %rdi
callq 0x4472
shlq $0x20, %r14
movl %ebp, %eax
orq %r14, %rax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop