LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5818
movl %eax, %r12d
movq %r14, %rdi
movl %eax, %esi
callq 0x598a
movq %rax, %rdi
movq %rbx, %rsi
movl %r15d, %edx
callq 0x5b16
movl %r12d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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)
xorl %ecx, %ecx
movl (%rsi), %r8d
shrl $0x5, %r8d
cmpq %r8, %rcx
jae 0x5b43
movl 0x4(%rsi,%rcx,4), %r8d
movl %r8d, 0x4(%rdi,%rcx,4)
incq %rcx
jmp 0x5b28
testb %dl, %dl
je 0x5b69
movl %eax, %ecx
shrl $0x5, %ecx
shll $0x2, %ecx
testb $0x4, %al
jne 0x5b5d
movl 0x4(%rsi,%rcx), %eax
movl %eax, 0x4(%rdi,%rcx)
jmp 0x5b69
movss 0x4(%rsi,%rcx), %xmm0
movss %xmm0, 0x4(%rdi,%rcx)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rdi
callq 0x2160
movq (%r14), %rax
movq %rax, (%rbx)
movl 0x8(%r14), %eax
movl %eax, 0x8(%rbx)
movl 0xc(%r14), %eax
movl %eax, 0xc(%rbx)
movl 0x10(%r14), %eax
movl %eax, 0x10(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
andl $0x0, 0x10(%r14)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x6115
testb $0x8, %al
je 0x60ff
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
pushq $0x10
popq %rdi
callq 0x20a0
movq %rax, %rbx
leaq 0x22e2(%rip), %rsi      # 0x8409
movq %rax, %rdi
callq 0x2040
movq 0x6e92(%rip), %rsi      # 0xcfc8
movq 0x6e73(%rip), %rdx      # 0xcfb0
movq %rbx, %rdi
callq 0x2230
movq %rax, %r14
movq %rbx, %rdi
callq 0x20e0
movq %r14, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O2/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 %rdi, %rbx
movq %rsi, -0x30(%rbp)
movl (%rsi), %esi
callq 0x682a
movq %rax, %r15
movq %rbx, -0x38(%rbp)
leaq 0x40(%rbx), %r13
xorl %r14d, %r14d
xorl %r12d, %r12d
xorl %ebx, %ebx
movslq 0x8(%r15), %rax
cmpq %rax, %r12
jge 0x67f7
movq (%r15), %rsi
addq %r14, %rsi
movq %r13, %rdi
callq 0x6888
testb %al, %al
jne 0x67ee
movq (%r15), %rax
movl (%rax,%r12,4), %ecx
movslq %ebx, %rdx
incl %ebx
movl %ecx, (%rax,%rdx,4)
incq %r12
addq $0x4, %r14
jmp 0x67c4
subl %ebx, %r12d
movq %r15, %rdi
movl %r12d, %esi
callq 0x4df2
movq -0x38(%rbp), %rdi
addq $0x18, %rdi
movq -0x30(%rbp), %rax
movl (%rax), %esi
callq 0x662a
movb $0x0, (%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Myyura[P]MyyuraSat/./source/../include/core/../type/../util/vector.hpp
// Function: MyyuraSat::Vector<MyyuraSat::LiftedBoolean, 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 0x6d56
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
callq 0x6d58
movslq 0x8(%r14), %rax
movq (%r14), %rcx
movslq %ebx, %rdx
cmpq %rdx, %rax
jge 0x6d4e
movb $0x0, (%rcx,%rax)
incq %rax
jmp 0x6d40
movl %ebx, 0x8(%r14)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x6afb
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %ebx
movq %rdi, %r15
callq 0x6afc
movslq 0x8(%r15), %rax
movq (%r15), %rcx
movslq %ebx, %rdx
cmpq %rdx, %rax
jge 0x6aed
movb (%r14), %sil
movb %sil, (%rcx,%rax)
incq %rax
jmp 0x6adc
movl %ebx, 0x8(%r15)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r14
pushq %rbx
subq $0x58, %rsp
movups 0xd1a(%rip), %xmm0      # 0x3004
leaq 0x10(%rsp), %rsi
movaps %xmm0, (%rsi)
movl $0x5, 0x10(%rsi)
leaq 0x28(%rsp), %rdi
pushq $0x5
popq %rbx
leaq 0x40(%rsp), %r14
movq %rbx, %rdx
movq %r14, %rcx
callq 0x23a2
movups 0xd00(%rip), %xmm0      # 0x3018
movaps %xmm0, (%r14)
movl $0xa, 0x10(%r14)
leaq 0x10(%rsp), %rdi
leaq 0x40(%rsp), %rsi
leaq 0xf(%rsp), %rcx
movq %rbx, %rdx
callq 0x23a2
leaq 0x28(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x23d8
movq 0x2c87(%rip), %rdi      # 0x4fd8
movl %eax, %esi
callq 0x2160
movq %rax, %rdi
callq 0x2080
leaq 0x10(%rsp), %rdi
callq 0x2e76
leaq 0x28(%rsp), %rdi
callq 0x2e76
xorl %eax, %eax
addq $0x58, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
jmp 0x2390
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x2e76
leaq 0x28(%rsp), %rdi
callq 0x2e76
movq %rbx, %rdi
callq 0x2170
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x38, %rsp
movq 0x8(%rdi), %rax
subq (%rdi), %rax
sarq $0x2, %rax
movq 0x8(%rsi), %rcx
subq (%rsi), %rcx
sarq $0x2, %rcx
cmpq %rax, %rcx
cmovaeq %rax, %rcx
leaq 0x8(%rsp), %rax
movl %ecx, (%rax)
andl $0x0, 0x4(%rax)
leaq 0x4(%rsp), %r8
andl $0x0, (%r8)
movq $0x1, 0x8(%rax)
leaq 0x2(%rsp), %rcx
leaq 0x18(%rsp), %rdx
movq %rcx, (%rdx)
leaq 0x3(%rsp), %r9
movq %r9, 0x8(%rdx)
movq %rdi, 0x10(%rdx)
movq %rsi, 0x18(%rdx)
movq %rax, %rdi
movq %r8, %rsi
callq 0x2443
addq $0x38, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
movl %esi, %r8d
movw $0x1, %cx
xorl %r9d, %r9d
movl $0xfff1, %r10d          # imm = 0xFFF1
xorl %esi, %esi
movzwl %cx, %ecx
cmpq %r9, %r8
je 0x11fb
movsbl (%rdi,%r9), %eax
addl %ecx, %eax
cltd
idivl %r10d
movl %edx, %ecx
movzwl %si, %edx
movzwl %cx, %eax
addl %edx, %eax
xorl %edx, %edx
divl %r10d
incq %r9
movl %edx, %esi
jmp 0x11d2
shll $0x10, %esi
orl %ecx, %esi
movl %esi, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
movl %edx, %r8d
movzwl %di, %r11d
addl %esi, %r11d
movl %r11d, %eax
subl %edx, %eax
xorl %r10d, %r10d
testl %eax, %eax
cmovlel %r10d, %eax
addl %edx, %eax
xorl %esi, %esi
cmpl %r11d, %eax
setne %sil
subl %esi, %eax
subl %r11d, %eax
movl $0xfff1, %r9d           # imm = 0xFFF1
xorl %edx, %edx
divl %r9d
addl %esi, %eax
imull $0xfff1, %eax, %eax     # imm = 0xFFF1
addl %r11d, %eax
shrl $0x10, %edi
subl %r8d, %eax
movl %eax, %esi
subl %r9d, %esi
cmovbl %eax, %esi
imull %ecx, %r8d
movl %r8d, %ecx
notl %ecx
leal (%rdi,%rcx), %eax
addl %esi, %eax
testl %eax, %eax
cmovlel %r10d, %eax
leal (%rsi,%rdi), %r10d
addl %r8d, %eax
subl %esi, %eax
incl %eax
xorl %r8d, %r8d
cmpl %edi, %eax
setne %r8b
addl %r8d, %edi
subl %edi, %eax
xorl %edx, %edx
divl %r9d
addl %r8d, %eax
imull $0xfff1, %eax, %eax     # imm = 0xFFF1
addl %r10d, %ecx
addl %eax, %ecx
movl %ecx, %eax
xorl %edx, %edx
divl %r9d
shll $0x10, %edx
addl %edx, %esi
movl %esi, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x10, %rsp
cmpl $0x1, %edi
jg 0x1373
leaq 0xcb9(%rip), %rdi       # 0x2022
callq 0x1040
pushq $-0x1
popq %rbx
jmp 0x13bd
movq %rsi, %rbx
leaq -0x14(%rbp), %rsi
andl $0x0, (%rsi)
movq 0x8(%rbx), %rdi
callq 0x12a4
movq %rax, %r14
testq %rax, %rax
jne 0x13a0
movq 0x8(%rbx), %rsi
leaq 0xc6e(%rip), %rdi       # 0x2007
xorl %eax, %eax
callq 0x1070
movl -0x14(%rbp), %esi
movq %r14, %rdi
callq 0x11bc
leaq 0xc69(%rip), %rdi       # 0x201b
xorl %ebx, %ebx
movl %eax, %esi
xorl %eax, %eax
callq 0x1070
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq 0x109593(%rip), %rdi    # 0x120960
callq 0xa6ca0
leaq 0x1096a7(%rip), %rdi    # 0x120a80
movq %rbx, %rsi
callq 0xa6cb0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x173f7
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x109562(%rip), %rdi    # 0x120960
leaq 0xbfd03(%rip), %rsi     # 0xd7108
callq 0x94210
pushq $0x1
popq %rdi
callq 0x14150
movq %rax, %r14
movq %rbx, %rdi
callq 0xa4570
movq %r14, %rdi
callq 0xd3a40
// File: /workspace/github_cpp_makefile_star2_O2/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
movq (%rdi), %rcx
movq 0x8(%rdi), %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
je 0x17444
movl (%rcx), %esi
cmpl %eax, %esi
cmovgl %esi, %eax
addq $0x4, %rcx
jmp 0x17432
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0xa6c20
movq %rbx, %rdi
movq %r12, %rsi
callq 0xa5c80
movl 0x8(%r14), %eax
cmpl %r15d, %eax
cmovll %eax, %r15d
movslq %r15d, %rdx
leaq -0x40(%rbp), %rdi
pushq $-0x1
popq %rcx
movq %r14, %rsi
callq 0xa6c20
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0xa5c80
leaq -0x40(%rbp), %rdi
callq 0xa4570
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq -0x40(%rbp), %rdi
callq 0xa4570
jmp 0x174ee
jmp 0x174eb
movq %rax, %r14
movq %rbx, %rdi
callq 0xa4570
movq %r14, %rdi
callq 0xd3a40
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x28, %rsp
movq %rdi, -0x30(%rbp)
movq (%rsi), %r15
movq 0x8(%rsi), %rbx
xorl %r14d, %r14d
leaq -0x50(%rbp), %r12
leaq 0x107e1a(%rip), %r13    # 0x11f998
cmpq %rbx, %r15
je 0x17bbd
movq %r12, %rdi
movq %r15, %rsi
callq 0xa6a00
movq %r12, %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0x190d7
testb %al, %al
je 0x17baf
movq %r12, %rdi
xorl %esi, %esi
pushq $0xa
popq %rdx
callq 0x190f3
addl %eax, %r14d
movq %r12, %rdi
callq 0xa4570
addq $0x20, %r15
jmp 0x17b7e
movq -0x30(%rbp), %rbx
movq %rbx, %rdi
movl %r14d, %esi
callq 0x19114
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0xa4570
movq %rbx, %rdi
callq 0xd3a40
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, -0x30(%rbp)
movq (%rsi), %rdi
leaq 0x107d84(%rip), %rsi    # 0x11f998
xorl %r14d, %r14d
xorl %edx, %edx
callq 0x190d7
testb %al, %al
je 0x17c32
movq (%rbx), %rdi
pushq $0xa
popq %rdx
xorl %esi, %esi
callq 0x190f3
movl %eax, %r14d
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq $0x20, %rsi
leaq -0x48(%rbp), %rbx
leaq -0x68(%rbp), %r15
movq %rbx, %rdi
movq %r15, %rcx
callq 0x19174
movq (%rbx), %r12
movq 0x8(%rbx), %rbx
leaq 0x107d3a(%rip), %r13    # 0x11f998
cmpq %rbx, %r12
je 0x17c9d
movq %r15, %rdi
movq %r12, %rsi
callq 0xa6a00
movq %r15, %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0x190d7
testb %al, %al
je 0x17c8f
movq %r15, %rdi
xorl %esi, %esi
pushq $0xa
popq %rdx
callq 0x190f3
subl %eax, %r14d
movq %r15, %rdi
callq 0xa4570
addq $0x20, %r12
jmp 0x17c5e
movq -0x30(%rbp), %rbx
movq %rbx, %rdi
movl %r14d, %esi
callq 0x19114
leaq -0x48(%rbp), %rdi
callq 0x18cc4
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x17cc9
movq %rax, %rbx
jmp 0x17cda
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
callq 0xa4570
leaq -0x48(%rbp), %rdi
callq 0x18cc4
movq %rbx, %rdi
callq 0xd3a40
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x28, %rsp
movq %rdi, -0x30(%rbp)
movq (%rsi), %r15
movq 0x8(%rsi), %rbx
pushq $0x1
popq %r14
leaq -0x50(%rbp), %r12
leaq 0x107c82(%rip), %r13    # 0x11f998
cmpq %rbx, %r15
je 0x17d56
movq %r12, %rdi
movq %r15, %rsi
callq 0xa6a00
movq %r12, %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0x190d7
testb %al, %al
je 0x17d48
movq %r12, %rdi
xorl %esi, %esi
pushq $0xa
popq %rdx
callq 0x191a6
imulq %rax, %r14
movq %r12, %rdi
callq 0xa4570
addq $0x20, %r15
jmp 0x17d16
movq -0x30(%rbp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x191c7
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0xa4570
movq %rbx, %rdi
callq 0xd3a40
// File: /workspace/github_cpp_makefile_star2_O2/TsukiGva2[P]Blade-lang/blade.cpp
// Function: div(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 div(std::vector<std::string> nums){
	double acc = 1;
	if (std::regex_match(nums[0], is_number)) {
		acc = std::stof(nums[0]);
	}
	std::vector<std::string> numsbf(nums.begin()+1, nums.end());
	for (std::string i : numsbf) {
		if (std::regex_match(i, is_number)) {
			if (std::stof(i) != 0){
				acc /= std::stof(i);
			}
			else {
				return "can't divide by 0";
			}
		}
	}
	// solution
	// [/ 6 3 1]
	// (6 / 3) / 1
	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 %rsi, %r14
movq %rdi, -0x40(%rbp)
movq (%rsi), %rdi
leaq 0x107beb(%rip), %rsi    # 0x11f998
xorl %edx, %edx
callq 0x190d7
testb %al, %al
je 0x17dc8
movq (%r14), %rdi
xorl %esi, %esi
callq 0x19227
cvtss2sd %xmm0, %xmm0
jmp 0x17dd0
movsd 0xbf238(%rip), %xmm0    # 0xd7008
movsd %xmm0, -0x38(%rbp)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq $0x20, %rsi
leaq -0x58(%rbp), %r12
leaq -0x78(%rbp), %r14
movq %r12, %rdi
movq %r14, %rcx
callq 0x19174
movq (%r12), %r15
movq 0x8(%r12), %r13
leaq 0x107b95(%rip), %r12    # 0x11f998
cmpq %r13, %r15
je 0x17e81
movq %r14, %rdi
movq %r15, %rsi
callq 0xa6a00
movq %r14, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x190d7
movb $0x1, %bl
testb %al, %al
je 0x17e6f
movq %r14, %rdi
xorl %esi, %esi
callq 0x19227
ucomiss 0xbf1d9(%rip), %xmm0    # 0xd7010
jne 0x17e3b
jnp 0x17e59
movq %r14, %rdi
xorl %esi, %esi
callq 0x19227
cvtss2sd %xmm0, %xmm0
movsd -0x38(%rbp), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, -0x38(%rbp)
jmp 0x17e6f
movq -0x40(%rbp), %rdi
leaq 0xbf34e(%rip), %rsi     # 0xd71b2
leaq -0x29(%rbp), %rdx
callq 0x18c74
xorl %ebx, %ebx
movq %r14, %rdi
callq 0xa4570
addq $0x20, %r15
testb %bl, %bl
jne 0x17e03
jmp 0x17e8f
movq -0x40(%rbp), %rdi
movsd -0x38(%rbp), %xmm0
callq 0x19245
leaq -0x58(%rbp), %rdi
callq 0x18cc4
movq -0x40(%rbp), %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x17eaf
jmp 0x17eb4
movq %rax, %rbx
jmp 0x17ec0
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
callq 0xa4570
leaq -0x58(%rbp), %rdi
callq 0x18cc4
movq %rbx, %rdi
callq 0xd3a40
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rsi
addq $0x20, %rsi
leaq -0x58(%rbp), %r15
movq %r15, %rdi
callq 0xa6a00
leaq 0x10877a(%rip), %rdi    # 0x120960
movq %r15, %rsi
callq 0xa6ca0
movq %rax, %rdi
callq 0x93af0
leaq 0xbefd6(%rip), %rsi     # 0xd71d3
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rdx
callq 0x193ba
leaq 0xbefcb(%rip), %rdx     # 0xd71dc
leaq -0x78(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x19391
movq (%r14), %rsi
leaq 0x1076f8(%rip), %rdi    # 0x11f920
callq 0x18f46
leaq -0x78(%rbp), %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0xa45c0
movq %r15, %rdi
callq 0xa4570
leaq -0x38(%rbp), %rdi
callq 0xa4570
movq (%r14), %rsi
leaq 0x1076c9(%rip), %rdi    # 0x11f920
callq 0x18f46
movq %rbx, %rdi
movq %rax, %rsi
callq 0xa6a00
leaq -0x58(%rbp), %rdi
callq 0xa4570
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
callq 0xa4570
jmp 0x1828f
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0xa4570
jmp 0x182a1
jmp 0x1829e
jmp 0x1829e
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0xa4570
movq %rbx, %rdi
callq 0xd3a40
// File: /workspace/github_cpp_makefile_star2_O2/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
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rsi
movq 0x8(%r14), %rax
subq %rsi, %rax
cmpq $0x20, %rax
ja 0x182e4
leaq 0xbef01(%rip), %rsi     # 0xd71df
leaq -0x22(%rbp), %rdx
jmp 0x182f6
cmpq $0x2, 0x28(%rsi)
jb 0x18300
leaq 0xbef08(%rip), %rsi     # 0xd71fa
leaq -0x21(%rbp), %rdx
movq %rbx, %rdi
callq 0x18c74
jmp 0x18334
leaq 0x20(%rsi), %r15
leaq 0x10765d(%rip), %r12    # 0x11f968
movq %r12, %rdi
callq 0x18f46
movq %rax, %rdi
movq %r15, %rsi
callq 0xa41a0
movq (%r14), %rsi
movq %r12, %rdi
callq 0x18f46
movq %rbx, %rdi
movq %rax, %rsi
callq 0xa6a00
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rsi
movq 0x8(%r14), %rax
subq %rsi, %rax
cmpq $0x20, %rax
ja 0x1837e
leaq 0xbeebc(%rip), %rsi     # 0xd722c
leaq -0x21(%rbp), %rdx
movq %rbx, %rdi
callq 0x18c74
jmp 0x183b2
leaq 0x20(%rsi), %r15
leaq 0x1075df(%rip), %r12    # 0x11f968
movq %r12, %rdi
callq 0x18f46
movq %rax, %rdi
movq %r15, %rsi
callq 0xa41a0
movq (%r14), %rsi
movq %r12, %rdi
callq 0x18f46
movq %rbx, %rdi
movq %rax, %rsi
callq 0xa6a00
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
movq (%rsi), %rdi
movq 0x8(%rsi), %rax
subq %rdi, %rax
cmpq $0x40, %rax
ja 0x1847e
leaq 0xbedf8(%rip), %rsi     # 0xd7265
leaq -0x30(%rbp), %rdx
movq %rbx, %rdi
callq 0x18c74
jmp 0x18519
movq %rsi, %r14
pushq $0xa
popq %rdx
xorl %esi, %esi
callq 0x190f3
testl %eax, %eax
je 0x184ce
movq (%r14), %rdx
addq $0x20, %rdx
leaq 0xbed36(%rip), %rsi     # 0xd71d3
leaq -0x30(%rbp), %r14
movq %r14, %rdi
callq 0x193ba
leaq 0xbed2c(%rip), %rdx     # 0xd71dc
leaq -0x70(%rbp), %rdi
movq %r14, %rsi
callq 0x19391
leaq -0x70(%rbp), %rsi
movq %rbx, %rdi
callq 0x174fe
leaq -0x70(%rbp), %rdi
jmp 0x1850b
movq (%r14), %rdx
addq $0x40, %rdx
leaq 0xbecf7(%rip), %rsi     # 0xd71d3
leaq -0x30(%rbp), %r14
movq %r14, %rdi
callq 0x193ba
leaq 0xbeced(%rip), %rdx     # 0xd71dc
leaq -0x50(%rbp), %rdi
movq %r14, %rsi
callq 0x19391
leaq -0x50(%rbp), %rsi
movq %rbx, %rdi
callq 0x174fe
leaq -0x50(%rbp), %rdi
callq 0xa4570
leaq -0x30(%rbp), %rdi
callq 0xa4570
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
jmp 0x18537
jmp 0x1853e
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
callq 0xa4570
jmp 0x18541
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0xa4570
movq %rbx, %rdi
callq 0xd3a40
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rsi
movq 0x8(%r14), %rax
subq %rsi, %rax
cmpq $0x20, %rax
ja 0x1858c
leaq 0xbed00(%rip), %rsi     # 0xd727e
leaq -0x58(%rbp), %rdx
movq %rbx, %rdi
callq 0x18c74
jmp 0x185ea
movq %rbx, %rdi
callq 0xa6a00
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq $0x20, %rsi
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rcx
callq 0x19174
movq -0x38(%rbp), %r14
movq -0x30(%rbp), %r12
leaq -0x58(%rbp), %r15
cmpq %r12, %r14
je 0x185e1
movq %r15, %rdi
movq %r14, %rsi
callq 0xa6a00
movq %rbx, %rdi
movq %r15, %rsi
callq 0xa5c80
movq %r15, %rdi
callq 0xa4570
addq $0x20, %r14
jmp 0x185b8
leaq -0x38(%rbp), %rdi
callq 0x18cc4
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x18619
movq %rax, %r14
jmp 0x18610
movq %rax, %r14
leaq -0x58(%rbp), %rdi
callq 0xa4570
leaq -0x38(%rbp), %rdi
callq 0x18cc4
movq %rbx, %rdi
callq 0xa4570
movq %r14, %rdi
callq 0xd3a40
// File: /workspace/github_cpp_makefile_star2_O2/TsukiGva2[P]Blade-lang/blade.cpp
// Function: split_(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 split_(std::vector<std::string> args){
	std::string txt = args[0];
	std::vector<std::string> strs;
	std::remove(args[1].begin(), args[1].end(), ' ');
	char ch = args[1][0];
    size_t pos = txt.find( ch );
    size_t initialPos = 0;
    while( pos != std::string::npos ) {
        strs.push_back( txt.substr( initialPos, pos - initialPos ) );
        initialPos = pos + 1;

        pos = txt.find( ch, initialPos );
    }

    strs.push_back( txt.substr( initialPos, std::min( pos, txt.size() ) - initialPos + 1 ) );

	std::string res = "";

	for (std::string b : strs) {
		res += b + " ";
	}

    return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %rbx
movq %rdi, -0x30(%rbp)
movq (%rsi), %rsi
leaq -0x90(%rbp), %rdi
callq 0xa6a00
andq $0x0, -0x40(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x50(%rbp)
movq (%rbx), %rax
movq 0x20(%rax), %rdi
movq 0x28(%rax), %rsi
addq %rdi, %rsi
leaq -0x70(%rbp), %rdx
movb $0x20, (%rdx)
callq 0x23fef
movq (%rbx), %rax
movq 0x20(%rax), %rax
xorl %r13d, %r13d
movsbl (%rax), %r14d
leaq -0x90(%rbp), %r15
leaq -0x70(%rbp), %r12
movq %r15, %rdi
movl %r14d, %esi
movq %r13, %rdx
callq 0xa6100
cmpq $-0x1, %rax
je 0x186d9
movq %rax, %rbx
movq %rax, %rcx
subq %r13, %rcx
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0xa6c20
leaq -0x50(%rbp), %rdi
movq %r12, %rsi
callq 0x27dd8
movq %r12, %rdi
callq 0xa4570
incq %rbx
movq %rbx, %r13
jmp 0x18692
leaq -0x90(%rbp), %rsi
movq 0x8(%rsi), %rcx
subq %r13, %rcx
incq %rcx
leaq -0x70(%rbp), %rdi
movq %r13, %rdx
callq 0xa6c20
leaq -0x50(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x27dd8
leaq -0x70(%rbp), %rdi
callq 0xa4570
leaq 0xbec59(%rip), %rsi     # 0xd736c
leaq -0x70(%rbp), %rdx
movq -0x30(%rbp), %rdi
callq 0x18c74
movq -0x50(%rbp), %r14
movq -0x48(%rbp), %rbx
leaq -0x70(%rbp), %r15
leaq 0xbfded(%rip), %r12     # 0xd8520
leaq -0xb0(%rbp), %r13
cmpq %rbx, %r14
je 0x1877a
movq %r15, %rdi
movq %r14, %rsi
callq 0xa6a00
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x1945c
movq -0x30(%rbp), %rdi
movq %r13, %rsi
callq 0xa5c80
movq %r13, %rdi
callq 0xa4570
movq %r15, %rdi
callq 0xa4570
addq $0x20, %r14
jmp 0x1873a
leaq -0x50(%rbp), %rdi
callq 0x18cc4
leaq -0x90(%rbp), %rdi
callq 0xa4570
movq -0x30(%rbp), %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x187d5
jmp 0x187da
jmp 0x187d5
jmp 0x187d5
movq %rax, %r14
jmp 0x187cf
movq %rax, %r14
jmp 0x187c6
movq %rax, %r14
leaq -0xb0(%rbp), %rdi
callq 0xa4570
leaq -0x70(%rbp), %rdi
callq 0xa4570
movq -0x30(%rbp), %rdi
jmp 0x187e1
movq %rax, %r14
jmp 0x187e6
movq %rax, %r14
leaq -0x70(%rbp), %rdi
callq 0xa4570
leaq -0x50(%rbp), %rdi
callq 0x18cc4
leaq -0x90(%rbp), %rdi
callq 0xa4570
movq %r14, %rdi
callq 0xd3a40
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
cmpl $-0x1, (%rsi)
je 0x2606
movq %rsi, %r14
leaq 0x4a83(%rip), %rsi      # 0x7004
movq %rbx, %rdi
callq 0x2140
movl (%r14), %esi
movq %rax, %rdi
callq 0x2230
leaq 0x4cf2(%rip), %r15      # 0x728d
movq %rax, %rdi
movq %r15, %rsi
callq 0x2140
movq 0x8(%r14), %rsi
movq %rax, %rdi
callq 0x2130
movq %rax, %rdi
movq %r15, %rsi
callq 0x2140
movl 0x10(%r14), %esi
movq %rax, %rdi
callq 0x2230
leaq 0x4a4d(%rip), %rsi      # 0x701d
movq %rax, %rdi
callq 0x2140
xorl %r13d, %r13d
leaq 0x4a3f(%rip), %r12      # 0x7021
cmpq $0x20, %r13
je 0x260d
movzbl 0x14(%r14,%r13), %esi
movq %rbx, %rdi
callq 0x2230
movq %rax, %rdi
movq %r15, %rsi
callq 0x2140
incq %r13
jmp 0x25e2
leaq 0x4a16(%rip), %r12      # 0x7023
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2140
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x38(%rsi), %r14
xorl %r13d, %r13d
pushq $0x38
popq %rbp
movq 0x40(%r12), %rax
subq 0x38(%r12), %rax
cqto
idivq %rbp
cmpq %r13, %rax
jbe 0x2736
movq %r14, %rdi
movq %r13, %rsi
callq 0x2836
cmpq %r15, 0x8(%rax)
je 0x273a
incq %r13
jmp 0x270c
xorl %eax, %eax
jmp 0x2777
movl %r13d, %r15d
movq %r14, %rdi
movq %r15, %rsi
callq 0x2836
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups 0x20(%rax), %xmm2
movups %xmm0, (%rbx)
movups %xmm1, 0x10(%rbx)
movups %xmm2, 0x20(%rbx)
movq 0x30(%rax), %rax
movq %rax, 0x30(%rbx)
imulq $0x38, %r15, %rsi
addq (%r14), %rsi
movq %r14, %rdi
callq 0x2854
movb $0x1, %al
movb %al, 0x38(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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, 0x89c6(%rip)      # 0xb163
je 0x27b4
movl %edi, 0x89ab(%rip)      # 0xb150
movb $0x1, 0x89b7(%rip)      # 0xb163
addq $0x8, %rsp
popq %rbx
popq %r14
retq
pushq $0x10
popq %rdi
callq 0x20c0
movq %rax, %rbx
leaq 0x4899(%rip), %rsi      # 0x705f
movq %rax, %rdi
callq 0x2080
movq 0x881b(%rip), %rsi      # 0xaff0
movq 0x87ec(%rip), %rdx      # 0xafc8
movq %rbx, %rdi
callq 0x2220
movq %rax, %r14
movq %rbx, %rdi
callq 0x2100
movq %r14, %rdi
callq 0x2240
nop
// File: /workspace/github_cpp_makefile_star2_O2/obliviousram[P]PathOHeap/src/Job.cpp
// Function: Job::sampleData(int)
std::array<std::byte, Block::BLOCK_SIZE> Job::sampleData(int i) {
  std::array<std::byte, Block::BLOCK_SIZE> ret;
  ret.fill(std::byte{0});
  ret.at(0) = static_cast<std::byte>((i >> 24) & 0xFF);
  ret.at(1) = static_cast<std::byte>((i >> 16) & 0xFF);
  ret.at(2) = static_cast<std::byte>((i >> 8) & 0xFF);
  ret.at(3) = static_cast<std::byte>(i & 0xFF);
  return ret;
}

// Assembly:
movq %rdi, %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, 0x4(%rdi)
bswapl %esi
movl %esi, (%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/obliviousram[P]PathOHeap/src/Job.cpp
// Function: Job::run()
void Job::run() {
  int bucket_size = 4;
  int num_blocks = pow(2, 5);
  UntrustedStorageInterface* storage = new ServerStorage();
  RandForOHeapInterface* random = new RandomForOHeap();
  OHeapInterface* oheap = new OHeapReadPathEviction(storage, random, bucket_size, num_blocks, false);

  // Sample computation: fill the heap with some numbers, then read it back.
  for (int i = 0; i < num_blocks; i++) {
    oheap->insertBlock(i, Job::sampleData(i));
    std::cout << "Inserting Block " << i << " to OHeap. The stash size is: " <<
        oheap->getStashSize() << std::endl;
  }

  for (int i = 0; i < num_blocks; i++) {
    std::cout << "Extracting Block " << i << " from OHeap. " << oheap->extractMin() << std::endl;
  }

  delete oheap;
  delete random;
  delete storage;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
pushq $0x28
popq %rdi
callq 0x2150
movq %rax, %r14
movq %rax, %rdi
callq 0x5990
pushq $0x20
popq %rdi
callq 0x2150
movq %rax, %r12
movq %rax, %rdi
callq 0x583c
pushq $0x58
popq %rdi
callq 0x2150
movq %rax, %r15
pushq $0x4
popq %rcx
pushq $0x20
popq %r8
xorl %ebp, %ebp
movq %rax, %rdi
movq %r14, 0x28(%rsp)
movq %r14, %rsi
movq %r12, 0x20(%rsp)
movq %r12, %rdx
xorl %r9d, %r9d
callq 0x396c
leaq 0x34(%rsp), %r12
leaq 0x45b9(%rip), %r13      # 0x70e3
leaq 0x45c3(%rip), %rbx      # 0x70f4
cmpl $0x20, %ebp
je 0x2bbf
xorps %xmm0, %xmm0
movups %xmm0, 0xc(%r12)
movups %xmm0, (%r12)
andw $0x0, 0x30(%rsp)
movb $0x0, 0x32(%rsp)
movb %bpl, 0x33(%rsp)
movq (%r15), %rax
movups 0x30(%rsp), %xmm0
movups 0x40(%rsp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %r15, %rdi
movl %ebp, %esi
callq *0x8(%rax)
movq 0x8453(%rip), %rdi      # 0xafd0
movq %r13, %rsi
callq 0x2140
movq %rax, %rdi
movl %ebp, %esi
callq 0x2230
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2140
movq %rax, %r14
movq (%r15), %rax
movq %r15, %rdi
callq *0x40(%rax)
movq %r14, %rdi
movl %eax, %esi
callq 0x2230
movq %rax, %rdi
callq 0x20b0
incl %ebp
jmp 0x2b31
xorl %ebx, %ebx
leaq 0x454b(%rip), %r13      # 0x7113
leaq 0x4556(%rip), %rbp      # 0x7125
leaq 0x50(%rsp), %r14
cmpl $0x20, %ebx
je 0x2c23
movq 0x83f0(%rip), %rdi      # 0xafd0
movq %r13, %rsi
callq 0x2140
movq %rax, %rdi
movl %ebx, %esi
callq 0x2230
movq %rax, %rdi
movq %rbp, %rsi
callq 0x2140
movq %rax, %r12
movq (%r15), %rax
movq %r14, %rdi
movq %r15, %rsi
callq *0x18(%rax)
movq %r12, %rdi
movq %r14, %rsi
callq 0x2562
movq %rax, %rdi
callq 0x20b0
incl %ebx
jmp 0x2bd4
pushq $0x8
popq %rbx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2160
movq 0x20(%rsp), %rdi
movq %rbx, %rsi
callq 0x2160
movq 0x28(%rsp), %rdi
movq %rbx, %rsi
callq 0x2160
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
pushq $0x58
popq %rsi
movq %r15, %rdi
jmp 0x2c7c
movq %rax, %rbx
pushq $0x20
popq %rsi
movq %r12, %rdi
jmp 0x2c7c
movq %rax, %rbx
pushq $0x28
popq %rsi
movq %r14, %rdi
callq 0x2160
movq %rbx, %rdi
callq 0x2240
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3c22
cmpb $0x1, 0x28(%r14)
jne 0x3c16
movq %rsp, %rdi
pushq $-0x1
popq %rdx
pushq $-0x1
popq %rcx
movq %r14, %rsi
callq 0x3cda
movq %r14, %rdi
callq 0x407c
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x58, %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
leaq 0x8(%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)
leaq 0x40(%rsp), %rdi
callq 0x2898
movq 0x40(%r14), %rdi
movq 0x48(%r14), %rsi
cmpq %rdi, %rsi
je 0x3cca
callq 0x4c27
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2513
testb %al, %al
je 0x3cca
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 $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x88, %rsp
movq %rcx, %r15
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, 0x8(%rsp)
leaq 0x40(%rsi), %r12
xorl %r13d, %r13d
pushq $0x38
popq %rbx
movq 0x48(%r14), %rax
subq 0x40(%r14), %rax
cqto
idivq %rbx
cmpq %r13, %rax
jbe 0x3d34
movq %r12, %rdi
movq %r13, %rsi
callq 0x2836
incq %r13
cmpl %ebp, (%rax)
jne 0x3d02
cmpq %r15, 0x8(%rax)
jne 0x3d02
decl %r13d
movl %r13d, %ebx
jmp 0x3d37
pushq $-0x1
popq %rbx
leaq 0x10(%rsp), %r13
movq %r13, %rdi
callq 0x24f8
cmpl $-0x1, %ebx
je 0x3d88
movslq %ebx, %rbx
movq %r12, %rdi
movq %rbx, %rsi
callq 0x2836
movl 0x30(%rax), %ecx
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups 0x20(%rax), %xmm2
movaps %xmm0, 0x10(%rsp)
movl %ecx, 0x40(%rsp)
movaps %xmm2, 0x30(%rsp)
movaps %xmm1, 0x20(%rsp)
imulq $0x38, %rbx, %rsi
addq (%r12), %rsi
movq %r12, %rdi
callq 0x2854
leaq 0x50(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
movq %r15, %rcx
callq 0x442a
movq %r14, %rdi
movl %ebp, %esi
callq 0x40d2
cmpq $-0x1, 0x18(%rsp)
cmoveq %rbx, %r13
movq 0x30(%r13), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x30(%rax)
movups (%r13), %xmm0
movups 0x10(%r13), %xmm1
movups 0x20(%r13), %xmm2
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3e16
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x3c22
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
movq %r15, %rcx
callq 0x3cda
cmpb $0x1, 0x28(%rbx)
jne 0x3e34
movq %rbx, %rdi
callq 0x407c
incq 0x20(%rbx)
movq %r14, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3e77
leaq 0x20(%rsp), %rdi
movq %rbx, %rsi
callq 0x3c22
leaq 0x20(%rsp), %rdi
pushq $-0x1
popq %rdx
pushq $-0x1
popq %rcx
movq %rbx, %rsi
callq 0x3cda
cmpl $0x7fffffff, %ebp       # imm = 0x7FFFFFFF
jne 0x3e8c
movq %rbx, %rdi
callq 0x407c
pushq $-0x1
popq %rax
jmp 0x3eab
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 0x3eb6
incq 0x20(%rbx)
addq $0x58, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movl %esi, %ebx
movq %rdi, %r14
movq 0x38(%rdi), %rdi
movq (%rdi), %rax
callq *(%rax)
movl %eax, %ebp
leaq 0x40(%r14), %r15
movq 0x20(%r14), %rdx
movaps 0x90(%rsp), %xmm0
movaps 0xa0(%rsp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
leaq 0x28(%rsp), %r12
movq %r12, %rdi
movl %eax, %esi
movl %ebx, %ecx
callq 0x24dc
movq %r15, %rdi
movq %r12, %rsi
callq 0x4d24
movq 0x20(%r14), %rbx
movq %r14, %rdi
callq 0x407c
shlq $0x20, %rbx
movl %ebp, %eax
orq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop