LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpl $0x0, -0xc(%rbp)
jg 0x97dd
movl $0x10, %edi
callq 0x2090
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
leaq 0x5b89(%rip), %rsi      # 0xf331
callq 0x2240
jmp 0x97af
movq -0x30(%rbp), %rdi
movq 0xc826(%rip), %rsi      # 0x15fe0
movq 0xc7f7(%rip), %rdx      # 0x15fb8
callq 0x2210
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x20c0
jmp 0x983d
movq -0x28(%rbp), %rdi
movl 0x8(%rdi), %esi
addl -0xc(%rbp), %esi
callq 0x99d0
movq -0x28(%rbp), %rax
movl 0x8(%rax), %ecx
movl %ecx, -0x20(%rbp)
movl -0xc(%rbp), %ecx
addl 0x8(%rax), %ecx
movl %ecx, 0x8(%rax)
movl 0x8(%rax), %eax
cmpl -0x20(%rbp), %eax
jae 0x9834
movl $0x8, %edi
callq 0x2090
movq %rax, %rdi
movq %rdi, -0x38(%rbp)
callq 0x9710
movq -0x38(%rbp), %rdi
movq 0xc778(%rip), %rsi      # 0x15fa0
movq 0xc739(%rip), %rdx      # 0x15f68
callq 0x2210
movl -0x20(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x2230
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movb %cl, %al
movb %dl, %cl
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %cl
movb %cl, -0x11(%rbp)
andb $0x1, %al
movb %al, -0x12(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl (%rax), %ecx
andl $-0x4, %ecx
orl $0x0, %ecx
movl %ecx, (%rax)
movb -0x12(%rbp), %cl
andb $0x1, %cl
movzbl %cl, %edx
movl (%rax), %ecx
andl $0x1, %edx
shll $0x2, %edx
andl $-0x5, %ecx
orl %edx, %ecx
movl %ecx, (%rax)
movb -0x11(%rbp), %cl
andb $0x1, %cl
movzbl %cl, %edx
movl (%rax), %ecx
andl $0x1, %edx
shll $0x3, %edx
andl $-0x9, %ecx
orl %edx, %ecx
movl %ecx, (%rax)
movl (%rax), %ecx
andl $-0x11, %ecx
orl $0x0, %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rdi
callq 0x7720
movl %eax, %edx
movq -0x20(%rbp), %rax
movl (%rax), %ecx
andl $0x7ffffff, %edx        # imm = 0x7FFFFFF
shll $0x5, %edx
andl $0x1f, %ecx
orl %edx, %ecx
movl %ecx, (%rax)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rdi
callq 0x7720
movl %eax, %ecx
movl -0x24(%rbp), %eax
cmpl %ecx, %eax
jge 0x9983
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x9b50
movq %rax, %rdx
movq -0x20(%rbp), %rax
movslq -0x18(%rbp), %rcx
movl (%rdx), %edx
movl %edx, 0x4(%rax,%rcx,4)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x9943
movq -0x20(%rbp), %rax
movl (%rax), %eax
shrl $0x3, %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x99c6
movq -0x20(%rbp), %rax
movl (%rax), %eax
shrl $0x2, %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x99bb
movq -0x20(%rbp), %rax
movl (%rax), %ecx
shrl $0x5, %ecx
movl %ecx, %ecx
xorps %xmm0, %xmm0
movss %xmm0, 0x4(%rax,%rcx,4)
jmp 0x99c4
movq -0x20(%rbp), %rdi
callq 0x9b70
jmp 0x99c6
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl 0xc(%rax), %eax
cmpl -0xc(%rbp), %eax
jb 0x99f4
jmp 0x9ab6
movq -0x20(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x10(%rbp)
movq -0x20(%rbp), %rax
movl 0xc(%rax), %eax
cmpl -0xc(%rbp), %eax
jae 0x9a64
movq -0x20(%rbp), %rax
movl 0xc(%rax), %ecx
shrl %ecx
movl 0xc(%rax), %edx
shrl $0x3, %edx
addl %edx, %ecx
addl $0x2, %ecx
andl $-0x2, %ecx
movl %ecx, -0x14(%rbp)
movl -0x14(%rbp), %ecx
addl 0xc(%rax), %ecx
movl %ecx, 0xc(%rax)
movl 0xc(%rax), %eax
cmpl -0x10(%rbp), %eax
ja 0x9a62
movl $0x8, %edi
callq 0x2090
movq %rax, %rdi
movq %rdi, -0x28(%rbp)
callq 0x9710
movq -0x28(%rbp), %rdi
movq 0xc54a(%rip), %rsi      # 0x15fa0
movq 0xc50b(%rip), %rdx      # 0x15f68
callq 0x2210
jmp 0x99fe
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movl 0xc(%rax), %eax
movl %eax, %esi
shlq $0x2, %rsi
callq 0x2200
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
cmpq $0x0, (%rax)
jne 0x9ab6
movl $0x8, %edi
callq 0x2090
movq %rax, %rdi
movq %rdi, -0x30(%rbp)
callq 0x9710
movq -0x30(%rbp), %rdi
movq 0xc4f6(%rip), %rsi      # 0x15fa0
movq 0xc4b7(%rip), %rdx      # 0x15f68
callq 0x2210
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl (%rax), %eax
shrl $0x3, %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x9be1
movl $0x10, %edi
callq 0x2090
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
leaq 0x5806(%rip), %rsi      # 0xf3b2
callq 0x21a0
jmp 0x9bb3
movq -0x30(%rbp), %rdi
movq 0xc41a(%rip), %rsi      # 0x15fd8
movq 0xc3cb(%rip), %rdx      # 0x15f90
callq 0x2210
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x20c0
jmp 0x9c48
movl $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, -0x34(%rbp)
callq 0x8b00
movl %eax, %ecx
movl -0x34(%rbp), %eax
cmpl %ecx, %eax
jge 0x9c30
movq -0x28(%rbp), %rdi
addq $0x4, %rdi
movslq -0x1c(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rdi
callq 0x9c60
orl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x9bef
movq -0x28(%rbp), %rax
movl -0x18(%rbp), %edx
movl (%rax), %ecx
shrl $0x5, %ecx
movl %ecx, %ecx
movl %edx, 0x4(%rax,%rcx,4)
addq $0x40, %rsp
popq %rbp
retq
movq -0x10(%rbp), %rdi
callq 0x2230
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x9e50
movq -0x20(%rbp), %rcx
andb $0x1, %al
movzbl %al, %eax
movb 0x18(%rcx), %cl
andb $0x1, %cl
movzbl %cl, %ecx
orl %ecx, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8b00
movq -0x20(%rbp), %rdi
movl %eax, %esi
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %edx
callq 0x9850
movq -0x20(%rbp), %rdi
movl %eax, %esi
callq 0x9770
movq -0x20(%rbp), %rdi
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %esi
callq 0x9880
movq %rax, %rdi
movq -0x10(%rbp), %rsi
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %edx
callq 0x9e70
movl -0x18(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
subq $0x30, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, (%rax)
movb -0x11(%rbp), %cl
andb $0x1, %cl
movzbl %cl, %edx
movl (%rax), %ecx
andl $0x1, %edx
shll $0x3, %edx
andl $-0x9, %ecx
orl %edx, %ecx
movl %ecx, (%rax)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8b00
movl %eax, %ecx
movl -0x2c(%rbp), %eax
cmpl %ecx, %eax
jge 0x9ef9
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x89f0
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, -0x1c(%rbp)
movslq -0x18(%rbp), %rcx
movl -0x1c(%rbp), %edx
movl %edx, 0x4(%rax,%rcx,4)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x9eb6
movq -0x28(%rbp), %rax
movl (%rax), %eax
shrl $0x3, %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x9f5f
movq -0x28(%rbp), %rax
movl (%rax), %eax
shrl $0x2, %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x9f3f
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movl (%rax), %edx
shrl $0x5, %edx
movl %edx, %edx
movss 0x4(%rcx,%rdx,4), %xmm0
movl (%rax), %ecx
shrl $0x5, %ecx
movl %ecx, %ecx
movss %xmm0, 0x4(%rax,%rcx,4)
jmp 0x9f5d
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movl (%rax), %edx
shrl $0x5, %edx
movl %edx, %edx
movl 0x4(%rcx,%rdx,4), %edx
movl (%rax), %ecx
shrl $0x5, %ecx
movl %ecx, %ecx
movl %edx, 0x4(%rax,%rcx,4)
jmp 0x9f5f
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: Myyura[P]MyyuraSat/./source/../include/core/../type/../util/alloc.hpp
// Function: MyyuraSat::RegionAllocator<unsigned int>::move_to(MyyuraSat::RegionAllocator<unsigned int>&)
void move_to(RegionAllocator& to) {
        if (to._memory != NULL) { std::free(to._memory); }
        to._memory = _memory;
        to._size = _size;
        to._capacity = _capacity;
        to._wasted = _wasted;

        _memory = NULL;
        _size = _capacity = _wasted = 0;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0xa19e
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x2150
movq -0x18(%rbp), %rax
movq (%rax), %rdx
movq -0x10(%rbp), %rcx
movq %rdx, (%rcx)
movl 0x8(%rax), %edx
movq -0x10(%rbp), %rcx
movl %edx, 0x8(%rcx)
movl 0xc(%rax), %edx
movq -0x10(%rbp), %rcx
movl %edx, 0xc(%rcx)
movl 0x10(%rax), %edx
movq -0x10(%rbp), %rcx
movl %edx, 0x10(%rcx)
movq $0x0, (%rax)
movl $0x0, 0x10(%rax)
movl $0x0, 0xc(%rax)
movl $0x0, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: Myyura[P]MyyuraSat/./source/../include/core/../type/../util/vector.hpp
// Function: MyyuraSat::Vector<MyyuraSat::Literal, 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl 0x8(%rax), %eax
cmpl -0xc(%rbp), %eax
jl 0xa2d1
jmp 0xa31b
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x8920
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0xa311
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movslq -0x10(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rdi
callq 0x7710
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xa2e7
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x20(%rbp)
callq 0x8b00
movl %eax, %ecx
movl -0x20(%rbp), %eax
cmpl %ecx, %eax
jle 0xb3cb
movl $0x10, %edi
callq 0x2090
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
leaq 0x40f8(%rip), %rsi      # 0xf48e
callq 0x2040
jmp 0xb39d
movq -0x30(%rbp), %rdi
movq 0xac20(%rip), %rsi      # 0x15fc8
movq 0xac01(%rip), %rdx      # 0x15fb0
callq 0x2210
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x20c0
jmp 0xb422
movq -0x28(%rbp), %rax
movl (%rax), %eax
shrl $0x3, %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0xb3fc
movq -0x28(%rbp), %rax
movl (%rax), %ecx
shrl $0x5, %ecx
movl %ecx, %ecx
movl %ecx, %edx
movl (%rax), %ecx
shrl $0x5, %ecx
subl -0xc(%rbp), %ecx
movslq %ecx, %rcx
movl 0x4(%rax,%rdx,4), %edx
movl %edx, 0x4(%rax,%rcx,4)
movq -0x28(%rbp), %rax
movl -0xc(%rbp), %ecx
movl (%rax), %edx
shrl $0x5, %edx
subl %ecx, %edx
movl (%rax), %ecx
andl $0x7ffffff, %edx        # imm = 0x7FFFFFF
shll $0x5, %edx
andl $0x1f, %ecx
orl %edx, %ecx
movl %ecx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x2230
nopl (%rax,%rax)
// File: Myyura[P]MyyuraSat/./source/../include/core/../util/occurence_list.hpp
// Function: MyyuraSat::OccurenceList<MyyuraSat::Literal, MyyuraSat::Solver::_Watcher, MyyuraSat::Vector<MyyuraSat::Solver::_Watcher, 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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %esi
callq 0xc3f0
movq %rax, -0x18(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x18(%rbp), %rdi
callq 0x7bd0
movl %eax, %ecx
movl -0x34(%rbp), %eax
cmpl %ecx, %eax
jge 0xc306
movq -0x30(%rbp), %rax
addq $0x40, %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
movl -0x20(%rbp), %esi
callq 0x7c70
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0xc4a0
testb $0x1, %al
jne 0xc2f9
movq -0x18(%rbp), %rdi
movl -0x20(%rbp), %esi
callq 0x7c70
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
movl -0x24(%rbp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
callq 0x7c70
movq -0x48(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
jmp 0xc2fb
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xc28b
movq -0x18(%rbp), %rdi
movl -0x20(%rbp), %esi
subl -0x24(%rbp), %esi
callq 0x8f00
movq -0x30(%rbp), %rdi
addq $0x18, %rdi
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %esi
callq 0xc1a0
movb $0x0, (%rax)
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl 0x8(%rax), %eax
cmpl -0xc(%rbp), %eax
jl 0xced5
jmp 0xcf1f
movq -0x28(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0xcf30
movq -0x28(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0xcf15
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movb (%rcx), %dl
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
andb $0x1, %dl
movb %dl, (%rax,%rcx)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xceeb
movq -0x28(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, 0x8(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: willprice[P]parallel-cpp-workshop/mapreduce.cpp
// Function: main
int main(int argc, char **argv) {
  auto a = std::vector<int>({1, 2, 3, 4, 5});
  auto b = std::vector<int>({6, 7, 8, 9, 10});
  auto result = mapReduce(std::multiplies<int>(),
                          std::plus<int>(), a, b);
  std::cout << result << std::endl;
  return 0;
}

// Assembly:
subq $0xe8, %rsp
movl $0x0, 0xe4(%rsp)
movl %edi, 0xe0(%rsp)
movq %rsi, 0xd8(%rsp)
movups 0x3cf0(%rip), %xmm0     # 0x6018
movaps %xmm0, 0x90(%rsp)
movl $0x5, 0xa0(%rsp)
leaq 0x90(%rsp), %rax
movq %rax, 0xb0(%rsp)
movq $0x5, 0xb8(%rsp)
leaq 0x8f(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x2520
movq 0x18(%rsp), %rcx
movq 0xb0(%rsp), %rsi
movq 0xb8(%rsp), %rdx
leaq 0xc0(%rsp), %rdi
callq 0x2530
jmp 0x238d
leaq 0x8f(%rsp), %rdi
callq 0x25c0
movups 0x3c8b(%rip), %xmm0     # 0x602c
movaps %xmm0, 0x30(%rsp)
movl $0xa, 0x40(%rsp)
leaq 0x30(%rsp), %rax
movq %rax, 0x50(%rsp)
movq $0x5, 0x58(%rsp)
leaq 0x2f(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x2520
movq 0x10(%rsp), %rcx
movq 0x50(%rsp), %rsi
movq 0x58(%rsp), %rdx
leaq 0x60(%rsp), %rdi
callq 0x2530
jmp 0x23eb
leaq 0x2f(%rsp), %rdi
callq 0x25c0
leaq 0xc0(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x25d0
movl %eax, 0xc(%rsp)
jmp 0x240d
movl 0xc(%rsp), %eax
movl %eax, 0x28(%rsp)
movl 0x28(%rsp), %esi
movq 0x6bb8(%rip), %rdi      # 0x8fd8
callq 0x2170
movq %rax, (%rsp)
jmp 0x242b
movq (%rsp), %rdi
movq 0x6b92(%rip), %rsi      # 0x8fc8
callq 0x2100
jmp 0x243d
movl $0x0, 0xe4(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x2680
leaq 0xc0(%rsp), %rdi
callq 0x2680
movl 0xe4(%rsp), %eax
addq $0xe8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
leaq 0x8f(%rsp), %rdi
callq 0x25c0
jmp 0x24d3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
leaq 0x2f(%rsp), %rdi
callq 0x25c0
jmp 0x24c6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x2680
leaq 0xc0(%rsp), %rdi
callq 0x2680
movq 0x80(%rsp), %rdi
callq 0x2180
// File: willprice[P]parallel-cpp-workshop/mapreduce.cpp
// Function: auto mapReduce<std::multiplies<int>, std::plus<int>>(std::multiplies<int>, std::plus<int>, std::vector<int, std::allocator<int>> const&, std::vector<int, std::allocator<int>> const&)
auto mapReduce(MapFn map_fn, ReduceFn reduce_fn, 
               const std::vector<int> &arg1,
               const std::vector<int> &arg2) {
  int vals_count = std::min(arg1.size(), arg2.size());
  return tbb::parallel_reduce(
      tbb::blocked_range<int>(0, vals_count),
      0,
      [&](tbb::blocked_range<int> r, int running_total) {
        for (int i = r.begin(); i < r.end(); i++) {
          running_total = reduce_fn(running_total, map_fn(arg1[i], arg2[i]));
        }
        return running_total;
      }, reduce_fn);
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq 0x58(%rsp), %rdi
callq 0x2720
movq %rax, 0x40(%rsp)
movq 0x50(%rsp), %rdi
callq 0x2720
movq %rax, 0x38(%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x26e0
movq (%rax), %rax
movl %eax, 0x4c(%rsp)
movl 0x4c(%rsp), %edx
leaq 0x28(%rsp), %rdi
xorl %esi, %esi
movl $0x1, %ecx
callq 0x27b0
movl $0x0, 0x24(%rsp)
leaq 0x66(%rsp), %rax
movq %rax, (%rsp)
leaq 0x67(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x24(%rsp), %rsi
movq %rsp, %rdx
leaq 0x66(%rsp), %rcx
callq 0x2740
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: akw0088[P]openssl/adler32.c
// Function: adler32
unsigned int adler32(char *buf, unsigned int length)
{
	unsigned short a = 1;
	unsigned short b = 0;

	for(int i = 0; i < length; i++)
	{
	        a = (a + buf[i]) % MOD_ADLER;
	        b = (b + a) % MOD_ADLER;
	}

	return (b << 16) | a;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movw $0x1, -0xe(%rbp)
movw $0x0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
jae 0x121b
movzwl -0xe(%rbp), %eax
movq -0x8(%rbp), %rcx
movslq -0x14(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
addl %ecx, %eax
movl $0xfff1, %ecx           # imm = 0xFFF1
cltd
idivl %ecx
movw %dx, %ax
movw %ax, -0xe(%rbp)
movzwl -0x10(%rbp), %eax
movzwl -0xe(%rbp), %ecx
addl %ecx, %eax
movl $0xfff1, %ecx           # imm = 0xFFF1
cltd
idivl %ecx
movw %dx, %ax
movw %ax, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x11ce
movzwl -0x10(%rbp), %eax
shll $0x10, %eax
movzwl -0xe(%rbp), %ecx
orl %ecx, %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
movb %dl, %al
movb %sil, %dl
movl %edi, -0x4(%rbp)
movb %dl, -0x5(%rbp)
movb %al, -0x6(%rbp)
movl %ecx, -0xc(%rbp)
movl -0x4(%rbp), %eax
andl $0xffff, %eax           # imm = 0xFFFF
movw %ax, -0xe(%rbp)
movl -0x4(%rbp), %eax
shrl $0x10, %eax
movw %ax, -0x10(%rbp)
movzwl -0xe(%rbp), %eax
movzbl -0x5(%rbp), %ecx
addl %ecx, %eax
movzbl -0x6(%rbp), %ecx
subl %ecx, %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jge 0x1281
movl -0x14(%rbp), %eax
addl $0xfff1, %eax           # imm = 0xFFF1
movl %eax, -0x14(%rbp)
jmp 0x126e
movl -0x14(%rbp), %eax
movl $0xfff1, %ecx           # imm = 0xFFF1
cltd
idivl %ecx
movw %dx, %ax
movw %ax, -0xe(%rbp)
movzwl -0x10(%rbp), %eax
movzwl -0xe(%rbp), %ecx
addl %ecx, %eax
subl $0x1, %eax
movl -0xc(%rbp), %ecx
movzbl -0x6(%rbp), %edx
imull %edx, %ecx
subl %ecx, %eax
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jge 0x12c2
movl -0x18(%rbp), %eax
addl $0xfff1, %eax           # imm = 0xFFF1
movl %eax, -0x18(%rbp)
jmp 0x12af
movl -0x18(%rbp), %eax
movl $0xfff1, %ecx           # imm = 0xFFF1
cltd
idivl %ecx
movw %dx, %ax
movw %ax, -0x10(%rbp)
movzwl -0x10(%rbp), %eax
shll $0x10, %eax
movzwl -0xe(%rbp), %ecx
orl %ecx, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x2, -0x8(%rbp)
jge 0x1413
leaq 0xc04(%rip), %rdi       # 0x2007
movb $0x0, %al
callq 0x1060
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x147a
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq -0x14(%rbp), %rsi
callq 0x12f0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x144c
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0xbd8(%rip), %rdi       # 0x201d
movb $0x0, %al
callq 0x1060
movl $0x0, -0x24(%rbp)
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x11b0
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %esi
leaq 0xbc5(%rip), %rdi       # 0x2031
movb $0x0, %al
callq 0x1060
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: 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
subq $0x50, %rsp
movq %rsi, -0x30(%rbp)
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0xcaac0
movq -0x30(%rbp), %rsi
leaq 0x13e57d(%rip), %rdi    # 0x156960
callq 0xcd2e0
jmp 0x183ea
movq -0x40(%rbp), %rsi
leaq 0x13e68b(%rip), %rdi    # 0x156a80
callq 0xcd2f0
movq %rax, -0x48(%rbp)
jmp 0x18400
movq -0x48(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x9b210
movb %al, -0x49(%rbp)
jmp 0x18418
movb -0x49(%rbp), %al
testb $0x1, %al
jne 0x18421
jmp 0x18457
leaq 0x13e538(%rip), %rdi    # 0x156960
leaq 0xe4d71(%rip), %rsi     # 0xfd1a0
callq 0xba870
jmp 0x18436
movl $0x1, %edi
callq 0x15150
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0xcabd0
jmp 0x18474
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x1846a
movq -0x40(%rbp), %rdi
callq 0xcabd0
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0xfa2a0
nopl (%rax)
// File: TsukiGva2[P]Blade-lang/blade.cpp
// Function: max_element(std::vector<int, std::allocator<int>>)
int max_element(std::vector<int> arr){
	int grtr = 0;
	for (int i : arr) {
		grtr = std::max(i, grtr);
	}
	return grtr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1b360
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1b390
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x1b3c0
testb $0x1, %al
jne 0x184c4
jmp 0x184ef
leaq -0x20(%rbp), %rdi
callq 0x1b400
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
leaq -0x2c(%rbp), %rdi
leaq -0xc(%rbp), %rsi
callq 0x1b420
movl (%rax), %eax
movl %eax, -0xc(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x1b460
jmp 0x184b1
movl -0xc(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x90, %rsp
movq %r8, -0x68(%rbp)
movq %rsi, -0x80(%rbp)
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
movslq -0x14(%rbp), %rcx
xorl %eax, %eax
movl %eax, %edx
callq 0xcd280
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0xcc2f0
jmp 0x185c0
movq -0x80(%rbp), %rdi
callq 0xcadf0
movl %eax, -0x5c(%rbp)
leaq -0x5c(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x1b530
movq %rax, -0x88(%rbp)
jmp 0x185e2
movq -0x80(%rbp), %rsi
movq -0x88(%rbp), %rax
movslq (%rax), %rdx
leaq -0x58(%rbp), %rdi
movq $-0x1, %rcx
callq 0xcd280
jmp 0x18602
movq -0x70(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0xcc2f0
jmp 0x18611
leaq -0x58(%rbp), %rdi
callq 0xcabd0
movb $0x1, -0x21(%rbp)
testb $0x1, -0x21(%rbp)
jne 0x18654
jmp 0x1864b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x18661
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x58(%rbp), %rdi
callq 0xcabd0
jmp 0x18661
movq -0x70(%rbp), %rdi
callq 0xcabd0
movq -0x78(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0xcabd0
movq -0x30(%rbp), %rdi
callq 0xfa2a0
nopw %cs:(%rax,%rax)
// File: 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
subq $0x90, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1c290
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1c2c0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x1c2f0
testb $0x1, %al
jne 0x19319
jmp 0x193a8
leaq -0x28(%rbp), %rdi
callq 0x1c330
movq %rax, %rsi
leaq -0x50(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0xcd060
movq -0x80(%rbp), %rdi
leaq 0x13c65b(%rip), %rsi    # 0x155998
xorl %edx, %edx
callq 0x1c350
movb %al, -0x71(%rbp)
jmp 0x19349
movb -0x71(%rbp), %al
testb $0x1, %al
jne 0x19352
jmp 0x19391
xorl %eax, %eax
movl %eax, %esi
leaq -0x50(%rbp), %rdi
movl $0xa, %edx
callq 0x1c3a0
movl %eax, -0x84(%rbp)
jmp 0x1936c
movl -0x84(%rbp), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x19391
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0xcabd0
jmp 0x193c1
leaq -0x50(%rbp), %rdi
callq 0xcabd0
leaq -0x28(%rbp), %rdi
callq 0x1c3e0
jmp 0x19303
movq -0x70(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x1c400
movq -0x68(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0xfa2a0
nopw (%rax,%rax)
// File: TsukiGva2[P]Blade-lang/blade.cpp
// Function: sub(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 sub(std::vector<std::string> nums){
	int acc = 0;
	if (std::regex_match(nums[0], is_number)) {
		acc = std::stoi(nums[0]);
	}
	std::vector<std::string> numsbf(nums.begin()+1, nums.end());
	for (std::string i : numsbf) {
		if (std::regex_match(i, is_number)) {
			acc -= std::stoi(i);
		}
	}
	return std::to_string(acc);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rsi, -0xb0(%rbp)
movq %rdi, %rax
movq -0xb0(%rbp), %rdi
movq %rax, -0xa8(%rbp)
movq %rax, %rcx
movq %rcx, -0xa0(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0x1c520
movq %rax, %rdi
leaq 0x13c579(%rip), %rsi    # 0x155998
xorl %edx, %edx
callq 0x1c350
testb $0x1, %al
jne 0x1942c
jmp 0x19450
movq -0xb0(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1c520
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
callq 0x1c3a0
movl %eax, -0x14(%rbp)
movq -0xb0(%rbp), %rdi
callq 0x1c290
movq %rax, -0x40(%rbp)
leaq -0x40(%rbp), %rdi
movl $0x1, %esi
callq 0x1c540
movq -0xb0(%rbp), %rdi
movq %rax, -0x38(%rbp)
callq 0x1c2c0
movq %rax, -0x48(%rbp)
leaq -0x49(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x1c580
movq -0xb8(%rbp), %rcx
movq -0x38(%rbp), %rsi
movq -0x48(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0x1c5a0
jmp 0x194ac
leaq -0x49(%rbp), %rdi
callq 0x1c620
leaq -0x30(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rdi
callq 0x1c290
movq %rax, -0x70(%rbp)
movq -0x68(%rbp), %rdi
callq 0x1c2c0
movq %rax, -0x78(%rbp)
leaq -0x70(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x1c2f0
testb $0x1, %al
jne 0x194ed
jmp 0x195b6
leaq -0x70(%rbp), %rdi
callq 0x1c330
movq %rax, %rsi
leaq -0x98(%rbp), %rdi
callq 0xcd060
jmp 0x19507
leaq 0x13c48a(%rip), %rsi    # 0x155998
leaq -0x98(%rbp), %rdi
xorl %edx, %edx
callq 0x1c350
movb %al, -0xb9(%rbp)
jmp 0x19524
movb -0xb9(%rbp), %al
testb $0x1, %al
jne 0x19530
jmp 0x1959c
xorl %eax, %eax
movl %eax, %esi
leaq -0x98(%rbp), %rdi
movl $0xa, %edx
callq 0x1c3a0
movl %eax, -0xc0(%rbp)
jmp 0x1954d
movl -0xc0(%rbp), %ecx
movl -0x14(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x14(%rbp)
jmp 0x1959c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x49(%rbp), %rdi
callq 0x1c620
jmp 0x195e9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x195e0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x98(%rbp), %rdi
callq 0xcabd0
jmp 0x195e0
leaq -0x98(%rbp), %rdi
callq 0xcabd0
leaq -0x70(%rbp), %rdi
callq 0x1c3e0
jmp 0x194d7
movq -0xa8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x1c400
jmp 0x195c7
leaq -0x30(%rbp), %rdi
callq 0x1b610
movq -0xa0(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x1b610
movq -0x58(%rbp), %rdi
callq 0xfa2a0
nopw %cs:(%rax,%rax)
// File: 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
subq $0x90, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x1, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1c290
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1c2c0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x1c2f0
testb $0x1, %al
jne 0x1965a
jmp 0x196ee
leaq -0x28(%rbp), %rdi
callq 0x1c330
movq %rax, %rsi
leaq -0x50(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0xcd060
movq -0x80(%rbp), %rdi
leaq 0x13c31a(%rip), %rsi    # 0x155998
xorl %edx, %edx
callq 0x1c350
movb %al, -0x71(%rbp)
jmp 0x1968a
movb -0x71(%rbp), %al
testb $0x1, %al
jne 0x19693
jmp 0x196d7
xorl %eax, %eax
movl %eax, %esi
leaq -0x50(%rbp), %rdi
movl $0xa, %edx
callq 0x1c640
movq %rax, -0x88(%rbp)
jmp 0x196ae
movq -0x88(%rbp), %rax
imulq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x196d7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0xcabd0
jmp 0x19708
leaq -0x50(%rbp), %rdi
callq 0xcabd0
leaq -0x28(%rbp), %rdi
callq 0x1c3e0
jmp 0x19644
movq -0x70(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1c680
movq -0x68(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0xfa2a0
nopw %cs:(%rax,%rax)
// File: 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
subq $0xe0, %rsp
movq %rsi, -0xc8(%rbp)
movq %rdi, %rax
movq -0xc8(%rbp), %rdi
movq %rax, -0xc0(%rbp)
movq %rax, %rcx
movq %rcx, -0xb8(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
callq 0x1c290
movq %rax, -0x40(%rbp)
leaq -0x40(%rbp), %rdi
movl $0x1, %esi
callq 0x1c540
movq %rax, -0x38(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x1c330
movq %rax, %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0xcd060
movq -0xb0(%rbp), %rsi
leaq 0x13cae6(%rip), %rdi    # 0x156960
callq 0xcd2e0
movq %rax, -0xa8(%rbp)
jmp 0x19e88
movq -0xa8(%rbp), %rdi
leaq 0xa02ba(%rip), %rsi     # 0xba150
callq 0xb9360
jmp 0x19e9d
leaq 0xe33c7(%rip), %rsi     # 0xfd26b
leaq -0x90(%rbp), %rdi
leaq -0x30(%rbp), %rdx
callq 0x1cc10
jmp 0x19eb6
leaq 0xe33b7(%rip), %rdx     # 0xfd274
leaq -0x70(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x1cbc0
jmp 0x19ecf
movq -0xc8(%rbp), %rdi
callq 0x1c290
movq %rax, -0x98(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x1c330
movq %rax, %rsi
leaq 0x13ba28(%rip), %rdi    # 0x155920
callq 0x1be50
movq %rax, -0xd0(%rbp)
jmp 0x19f06
movq -0xd0(%rbp), %rdi
leaq -0x70(%rbp), %rsi
movq %rsi, -0xe0(%rbp)
callq 0xcac20
movq -0xe0(%rbp), %rdi
callq 0xcabd0
leaq -0x90(%rbp), %rdi
callq 0xcabd0
movq -0xc8(%rbp), %rdi
callq 0x1c290
movq %rax, -0xa0(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x1c330
movq %rax, %rsi
leaq 0x13b9c2(%rip), %rdi    # 0x155920
callq 0x1be50
movq %rax, -0xd8(%rbp)
jmp 0x19f6c
movq -0xd8(%rbp), %rsi
movq -0xc0(%rbp), %rdi
callq 0xcd060
jmp 0x19f81
leaq -0x30(%rbp), %rdi
callq 0xcabd0
movq -0xb8(%rbp), %rax
addq $0xe0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x19fd7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x19fcb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0xcabd0
leaq -0x90(%rbp), %rdi
callq 0xcabd0
leaq -0x30(%rbp), %rdi
callq 0xcabd0
movq -0x48(%rbp), %rdi
callq 0xfa2a0
nopl (%rax)
// File: 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
subq $0x60, %rsp
movq %rsi, -0x40(%rbp)
movq %rdi, %rax
movq -0x40(%rbp), %rdi
movq %rax, -0x38(%rbp)
movq %rax, %rcx
movq %rcx, -0x30(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
callq 0x1cd20
cmpq $0x2, %rax
jae 0x1a06c
leaq -0x11(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x505b0
movq -0x38(%rbp), %rdi
movq -0x48(%rbp), %rdx
leaq 0xe323a(%rip), %rsi     # 0xfd277
callq 0x1b480
jmp 0x1a044
leaq -0x11(%rbp), %rdi
callq 0x505d0
jmp 0x1a12f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x11(%rbp), %rdi
callq 0x505d0
jmp 0x1a139
movq -0x40(%rbp), %rdi
movl $0x1, %esi
callq 0x1c520
movq %rax, %rdi
callq 0xcadf0
cmpq $0x1, %rax
jbe 0x1a0cd
leaq -0x25(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x505b0
movq -0x38(%rbp), %rdi
movq -0x50(%rbp), %rdx
leaq 0xe31ee(%rip), %rsi     # 0xfd292
callq 0x1b480
jmp 0x1a0ab
leaq -0x25(%rbp), %rdi
callq 0x505d0
jmp 0x1a12f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x25(%rbp), %rdi
callq 0x505d0
jmp 0x1a139
movq -0x40(%rbp), %rdi
movl $0x1, %esi
callq 0x1c520
movq -0x40(%rbp), %rdi
movq %rax, -0x58(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0x1c520
movq %rax, %rsi
leaq 0x13b872(%rip), %rdi    # 0x155968
callq 0x1be50
movq -0x58(%rbp), %rsi
movq %rax, %rdi
callq 0xcac00
movq -0x40(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1c520
movq %rax, %rsi
leaq 0x13b84a(%rip), %rdi    # 0x155968
callq 0x1be50
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0xcd060
movq -0x30(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0xfa2a0
nopw %cs:(%rax,%rax)
// File: 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
subq $0x50, %rsp
movq %rsi, -0x40(%rbp)
movq %rdi, %rax
movq -0x40(%rbp), %rdi
movq %rax, -0x38(%rbp)
movq %rax, %rcx
movq %rcx, -0x30(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
callq 0x1cd20
cmpq $0x2, %rax
jae 0x1a1c6
leaq -0x11(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x505b0
movq -0x38(%rbp), %rdi
movq -0x48(%rbp), %rdx
leaq 0xe3127(%rip), %rsi     # 0xfd2c4
callq 0x1b480
jmp 0x1a1a4
leaq -0x11(%rbp), %rdi
callq 0x505d0
jmp 0x1a228
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x11(%rbp), %rdi
callq 0x505d0
jmp 0x1a232
movq -0x40(%rbp), %rdi
movl $0x1, %esi
callq 0x1c520
movq -0x40(%rbp), %rdi
movq %rax, -0x50(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0x1c520
movq %rax, %rsi
leaq 0x13b779(%rip), %rdi    # 0x155968
callq 0x1be50
movq -0x50(%rbp), %rsi
movq %rax, %rdi
callq 0xcac00
movq -0x40(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1c520
movq %rax, %rsi
leaq 0x13b751(%rip), %rdi    # 0x155968
callq 0x1be50
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0xcd060
movq -0x30(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0xfa2a0
nopl (%rax,%rax)
// File: TsukiGva2[P]Blade-lang/blade.cpp
// Function: if(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 _if(std::vector<std::string> args){
		if (args.size() < 3){
			return "too few arguments for if";
		}
        if (std::stoi(args[0])){
          return lc_eval("[_xfun \"" + args[1] + "\"]");
        } else {
          return lc_eval("[_xfun \"" + args[2] + "\"]");
        }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rsi, -0xc0(%rbp)
movq %rdi, %rax
movq -0xc0(%rbp), %rdi
movq %rax, -0xb8(%rbp)
movq %rax, %rcx
movq %rcx, -0xb0(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
callq 0x1cd20
cmpq $0x3, %rax
jae 0x1a454
leaq -0x11(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0x505b0
movq -0xb8(%rbp), %rdi
movq -0xc8(%rbp), %rdx
leaq 0xe2ed8(%rip), %rsi     # 0xfd2fd
callq 0x1b480
jmp 0x1a42c
leaq -0x11(%rbp), %rdi
callq 0x505d0
jmp 0x1a5c9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x11(%rbp), %rdi
callq 0x505d0
jmp 0x1a5d9
movq -0xc0(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1c520
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
callq 0x1c3a0
cmpl $0x0, %eax
je 0x1a51c
movq -0xc0(%rbp), %rdi
movl $0x1, %esi
callq 0x1c520
movq %rax, %rdx
leaq 0xe2dd2(%rip), %rsi     # 0xfd26b
leaq -0x68(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0x1cc10
movq -0xd0(%rbp), %rsi
leaq 0xe2dbd(%rip), %rdx     # 0xfd274
leaq -0x48(%rbp), %rdi
callq 0x1cbc0
jmp 0x1a4c2
movq -0xb8(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x18680
jmp 0x1a4d4
leaq -0x48(%rbp), %rdi
callq 0xcabd0
leaq -0x68(%rbp), %rdi
callq 0xcabd0
jmp 0x1a5c9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x1a50e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x48(%rbp), %rdi
callq 0xcabd0
leaq -0x68(%rbp), %rdi
callq 0xcabd0
jmp 0x1a5d9
movq -0xc0(%rbp), %rdi
movl $0x2, %esi
callq 0x1c520
movq %rax, %rdx
leaq 0xe2d34(%rip), %rsi     # 0xfd26b
leaq -0xa8(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
callq 0x1cc10
movq -0xd8(%rbp), %rsi
leaq 0xe2d1c(%rip), %rdx     # 0xfd274
leaq -0x88(%rbp), %rdi
callq 0x1cbc0
jmp 0x1a566
movq -0xb8(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x18680
jmp 0x1a57b
leaq -0x88(%rbp), %rdi
callq 0xcabd0
leaq -0xa8(%rbp), %rdi
callq 0xcabd0
jmp 0x1a5c9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x1a5bb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x88(%rbp), %rdi
callq 0xcabd0
leaq -0xa8(%rbp), %rdi
callq 0xcabd0
jmp 0x1a5d9
movq -0xb0(%rbp), %rax
addq $0xe0, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0xfa2a0
nopw %cs:(%rax,%rax)
// File: 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
subq $0xc0, %rsp
movq %rsi, -0xb0(%rbp)
movq %rdi, %rax
movq -0xb0(%rbp), %rdi
movq %rax, -0xa8(%rbp)
movq %rax, %rcx
movq %rcx, -0xa0(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
callq 0x1cd20
cmpq $0x2, %rax
jae 0x1a684
leaq -0x11(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x505b0
movq -0xa8(%rbp), %rdi
movq -0xb8(%rbp), %rdx
leaq 0xe2cc1(%rip), %rsi     # 0xfd316
callq 0x1b480
jmp 0x1a65c
leaq -0x11(%rbp), %rdi
callq 0x505d0
jmp 0x1a805
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x11(%rbp), %rdi
callq 0x505d0
jmp 0x1a815
movq -0xb0(%rbp), %rdi
movb $0x0, -0x25(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0x1c520
movq -0xa8(%rbp), %rdi
movq %rax, %rsi
callq 0xcd060
movq -0xb0(%rbp), %rdi
callq 0x1c290
movq %rax, -0x50(%rbp)
leaq -0x50(%rbp), %rdi
movl $0x1, %esi
callq 0x1c540
movq -0xb0(%rbp), %rdi
movq %rax, -0x48(%rbp)
callq 0x1c2c0
movq %rax, -0x58(%rbp)
leaq -0x59(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x1c580
movq -0xc0(%rbp), %rcx
movq -0x48(%rbp), %rsi
movq -0x58(%rbp), %rdx
leaq -0x40(%rbp), %rdi
callq 0x1c5a0
jmp 0x1a703
leaq -0x59(%rbp), %rdi
callq 0x1c620
leaq -0x40(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rdi
callq 0x1c290
movq %rax, -0x70(%rbp)
movq -0x68(%rbp), %rdi
callq 0x1c2c0
movq %rax, -0x78(%rbp)
leaq -0x70(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x1c2f0
testb $0x1, %al
jne 0x1a744
jmp 0x1a7c9
leaq -0x70(%rbp), %rdi
callq 0x1c330
movq %rax, %rsi
leaq -0x98(%rbp), %rdi
callq 0xcd060
jmp 0x1a75e
movq -0xa8(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0xcc2f0
jmp 0x1a773
leaq -0x98(%rbp), %rdi
callq 0xcabd0
leaq -0x70(%rbp), %rdi
callq 0x1c3e0
jmp 0x1a72e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x59(%rbp), %rdi
callq 0x1c620
jmp 0x1a7f7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x1a7de
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x98(%rbp), %rdi
callq 0xcabd0
jmp 0x1a7de
movb $0x1, -0x25(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x1b610
testb $0x1, -0x25(%rbp)
jne 0x1a7f5
jmp 0x1a7e9
leaq -0x40(%rbp), %rdi
callq 0x1b610
jmp 0x1a7f7
movq -0xa8(%rbp), %rdi
callq 0xcabd0
jmp 0x1a805
movq -0xa8(%rbp), %rdi
callq 0xcabd0
jmp 0x1a815
movq -0xa0(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0xfa2a0
nop